8b969289b02bc7fa90d9c6d81c3c4e4eba32b6e2
[jra/samba/.git] / source4 / lib / ejs / miniMpr.c
1 /*
2  *      @file   miniMpr.cpp
3  *      @brief  Mini Mbedthis Portable Runtime (MPR)
4  *      @copy   default
5  *      
6  *      Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
7  *      
8  *      This software is distributed under commercial and open source licenses.
9  *      You may use the GPL open source license described below or you may acquire 
10  *      a commercial license from Mbedthis Software. You agree to be fully bound 
11  *      by the terms of either license. Consult the LICENSE.TXT distributed with 
12  *      this software for full details.
13  *      
14  *      This software is open source; you can redistribute it and/or modify it 
15  *      under the terms of the GNU General Public License as published by the 
16  *      Free Software Foundation; either version 2 of the License, or (at your 
17  *      option) any later version. See the GNU General Public License for more 
18  *      details at: http://www.mbedthis.com/downloads/gplLicense.html
19  *      
20  *      This program is distributed WITHOUT ANY WARRANTY; without even the 
21  *      implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
22  *      
23  *      This GPL license does NOT permit incorporating this software into 
24  *      proprietary programs. If you are unable to comply with the GPL, you must
25  *      acquire a commercial license to use this software. Commercial licenses 
26  *      for this software and support services are available from Mbedthis 
27  *      Software at http://www.mbedthis.com 
28  *      
29  *      @end
30  */
31
32 #include        "lib/ejs/miniMpr.h"
33
34 /************************************ Code ************************************/
35 #if !BLD_APPWEB
36 #if !BLD_GOAHEAD_WEBSERVER
37
38 static void *mpr_ctx;
39
40 /* set the memory context to be used for all ejs variables */
41 void mprSetCtx(TALLOC_CTX *ctx)
42 {
43         mpr_ctx = ctx;
44 }
45
46 /* return the memory context being used for all ejs variables */
47 void *mprMemCtx(void)
48 {
49         return mpr_ctx;
50 }
51
52 void mprFree(void *ptr)
53 {
54         talloc_free(ptr);
55 }
56
57 void *mprMalloc(uint size)
58 {
59         return talloc_size(mpr_ctx, size);
60 }
61
62 /******************************************************************************/
63
64 void *mprRealloc(void *ptr, uint size)
65 {
66         return talloc_realloc_size(mpr_ctx, ptr, size);
67 }
68
69 /******************************************************************************/
70
71 char *mprStrdup(const char *str)
72 {
73         if (str == 0) {
74                 str = "";
75         }
76         return talloc_strdup(mpr_ctx, str);
77 }
78
79 /*****************************************************************************/
80
81 int mprAllocSprintf(char **msgbuf, int maxSize, const char *fmt, ...)
82 {
83         va_list args;
84         char    *buf;
85         int             count;
86
87         va_start(args, fmt);
88         buf = mprMalloc(maxSize + 1);
89         count = mtVsprintf(buf, maxSize, fmt, args);
90         *msgbuf = buf;
91         va_end(args);
92         return count;
93 }
94
95 /*****************************************************************************/
96
97 int mprAllocVsprintf(char **msgbuf, int maxSize, const char *fmt, va_list args)
98 {
99         char    *buf;
100         int             count;
101
102         buf = mprMalloc(maxSize + 1);
103         count = mtVsprintf(buf, maxSize, fmt, args);
104         *msgbuf = buf;
105         return count;
106 }
107
108
109 /*****************************************************************************/
110 /*
111  *      Format a number as a string. FUTURE -- reverse args to be standard.
112  *              ie. mprItoa(char *userBuf, int bufsize, int value);
113  */
114
115 char *mprItoa(int value, char *buf, int width)
116 {
117         char    numBuf[16];
118         char    *cp, *dp, *endp;
119         int             negative;
120
121         cp = &numBuf[sizeof(numBuf)];
122         *--cp = '\0';
123
124         if (value < 0) {
125                 negative = 1;
126                 value = -value;
127                 width--;
128         } else {
129                 negative = 0;
130         }
131
132         do {
133                 *--cp = '0' + (value % 10);
134                 value /= 10;
135         } while (value > 0);
136
137         if (negative) {
138                 *--cp = '-';
139         }
140
141         dp = buf;
142         endp = &buf[width];
143         while (dp < endp && *cp) {
144                 *dp++ = *cp++;
145         }
146         *dp++ = '\0';
147         return buf;
148 }
149
150 /*****************************************************************************/
151
152 void mprLog(int level, const char *fmt, ...)
153 {
154         va_list args;
155         char    *buf;
156
157         if (DEBUGLVL(level)) {
158                 va_start(args, fmt);
159                 mprAllocVsprintf(&buf, MPR_MAX_STRING, fmt, args);
160                 va_end(args);
161                 DEBUG(level, ("mprLog: %s", buf));
162                 mprFree(buf);
163         }
164 }
165
166 /*****************************************************************************/
167
168 void mprBreakpoint(const char *file, int line, const char *cond)
169 {
170         char *buf;
171         mprAllocSprintf(&buf, MPR_MAX_STRING, "esp exception - ASSERT at %s:%d, %s\n", 
172                                         file, line, cond);
173         ejs_exception(buf);
174 }
175
176 #endif /* !BLD_GOAHEAD_WEBSERVER */
177 /*****************************************************************************/
178 /*
179  *      Create a general growable array structure
180  */
181
182 MprArray *mprCreateArray()
183 {
184         MprArray        *array;
185         int                     size;
186
187         array = (MprArray*) mprMalloc(sizeof(MprArray));
188         if (array == 0) {
189                 return 0;
190         }
191         memset(array, 0, sizeof(MprArray));
192
193         size = MPR_ARRAY_INCR * sizeof(void*);
194         array->handles = (void**) mprMalloc(size);
195         if (array->handles == 0) {
196                 mprFree(array);
197                 return 0;
198         }
199         memset(array->handles, 0, size);
200         array->max = MPR_ARRAY_INCR;
201         array->used = 0;
202         return array;
203 }
204
205 /*****************************************************************************/
206 /*
207  *      Dispose of the array. Callers responsibility to dispose of handle entries.
208  */
209
210 void mprDestroyArray(MprArray *array)
211 {
212         mprAssert(array);
213         mprAssert(array->max >= 0);
214         mprAssert(array->used >= 0);
215
216         mprFree(array->handles);
217         mprFree(array);
218 }
219
220 /*****************************************************************************/
221 /*
222  *      Add an item to the array
223  */
224
225 int mprAddToArray(MprArray *array, void *item)
226 {
227         int             memsize, idx, len;
228
229         mprAssert(array);
230         mprAssert(array->max >= 0);
231         mprAssert(array->used >= 0);
232
233         if (array->used < array->max) {
234                 idx = array->used++;
235                 mprAssert(idx >= 0 && idx < array->max);
236                 mprAssert(array->handles[idx] == 0);
237                 array->handles[idx] = item;
238                 return idx;
239         }
240
241         for (idx = array->used; idx < array->max; idx++) {
242                 if (array->handles[idx] == 0) {
243                         array->used++;
244                         mprAssert(array->handles[idx] == 0);
245                         array->handles[idx] = item;
246                         return idx;
247                 }
248         }
249
250         len = array->max + MPR_ARRAY_INCR;
251         memsize = len * sizeof(void*);
252         array->handles = (void**) mprRealloc((void*) array->handles, memsize);
253         if (array->handles == NULL) {
254                 return -1;
255         }
256         memset(&array->handles[array->max], 0, sizeof(void*) * MPR_ARRAY_INCR);
257         array->max = len;
258         array->used++;
259
260         mprAssert(idx >= 0 && idx < array->max);
261         mprAssert(array->handles[idx] == 0);
262
263         array->handles[idx] = item;
264         return idx;
265 }
266
267 /*****************************************************************************/
268 /*
269  *      Remove from the array
270  */
271
272 int mprRemoveFromArray(MprArray *array, int idx)
273 {
274         mprAssert(array);
275         mprAssert(array->max > 0);
276         mprAssert(idx >= 0 && idx < array->max);
277         mprAssert(array->handles[idx] != 0);
278         mprAssert(array->used > 0);
279
280         array->handles[idx] = 0;
281         return --array->used;
282 }
283
284 /*****************************************************************************/
285 /*
286  *      Thread-safe wrapping of strtok. Note "str" is modifed as per strtok()
287  */
288
289 char *mprStrTok(char *str, const char *delim, char **tok)
290 {
291         char    *start, *end;
292         int             i;
293
294         start = str ? str : *tok;
295
296         if (start == 0) {
297                 return 0;
298         }
299         
300         i = strspn(start, delim);
301         start += i;
302         if (*start == '\0') {
303                 *tok = 0;
304                 return 0;
305         }
306         end = strpbrk(start, delim);
307         if (end) {
308                 *end++ = '\0';
309                 i = strspn(end, delim);
310                 end += i;
311         }
312         *tok = end;
313         return start;
314 }
315
316 /*****************************************************************************/
317
318 static int mprCoreStrcat(int alloc, char **destp, int destMax, int existingLen, 
319         const char *delim, const char *src, va_list args)
320 {
321         va_list         ap;
322         char            *dest, *dp;
323         const char *str;
324         int                     sepLen, addBytes, required;
325
326         mprAssert(destp);
327         mprAssert(destMax > 0);
328         mprAssert(src);
329
330         dest = *destp;
331         sepLen = (delim) ? strlen(delim) : 0;
332
333 #ifdef __va_copy
334         __va_copy(ap, args);
335 #else
336         ap = args;
337 #endif
338         addBytes = 0;
339         str = src;
340         while (str) {
341                 addBytes += strlen(str) + sepLen;
342                 str = va_arg(ap, const char*);
343         }
344
345         if (existingLen > 0) {
346                 addBytes += sepLen;
347         }
348         required = existingLen + addBytes + 1;
349         if (required >= destMax) {
350                 mprAssert(0);
351                 return MPR_ERR_WONT_FIT;
352         }
353
354         if (alloc) {
355                 if (dest == 0) {
356                         dest = (char*) mprMalloc(required);
357                 } else {
358                         dest = (char*) mprRealloc(dest, required);
359                 }
360         } else {
361                 dest = (char*) *destp;
362         }
363
364         dp = &dest[existingLen];
365         if (delim) {
366                 strcpy(dp, delim);
367                 dp += sepLen;
368         }
369
370         if (addBytes > 0) {
371 #ifdef __va_copy
372                 __va_copy(ap, args);
373 #else
374                 ap = args;
375 #endif
376                 str = src;
377                 while (str) {
378                         strcpy(dp, str);
379                         dp += strlen(str);
380                         str = va_arg(ap, char*);
381                         if (delim && str) {
382                                 strcpy(dp, delim);
383                                 dp += sepLen;
384                         }
385                 }
386         } else if (dest == 0) {
387                 dest = (char*) mprMalloc(1);
388         } 
389         *dp = '\0';
390
391         *destp = dest;
392         mprAssert(dp < &dest[required]);
393         return required - 1;
394 }
395
396 /*****************************************************************************/
397
398 int mprReallocStrcat(char **destp, int destMax, int existingLen, 
399         const char *delim, const char *src,...)
400 {
401         va_list         ap;
402         int                     rc;
403
404         va_start(ap, src);
405         rc = mprCoreStrcat(1, destp, destMax, existingLen, delim, src, ap);
406         va_end(ap);
407         return rc;
408 }
409
410 /*****************************************************************************/
411 /*
412  *      Return the directory portion of a pathname into the users buffer.
413  */
414
415 int mprGetDirName(char *buf, int bufsize, char *path)
416 {
417         char    *cp;
418         int             dlen;
419
420         mprAssert(path);
421         mprAssert(buf);
422         mprAssert(bufsize > 0);
423
424         cp = strrchr(path, '/');
425         if (cp == 0) {
426 #if WIN
427                 cp = strrchr(path, '\\');
428                 if (cp == 0)
429 #endif
430                 {
431                         buf[0] = '\0';
432                         return 0;
433                 }
434         }
435
436         if (cp == path && cp[1] == '\0') {
437                 strcpy(buf, ".");
438                 return 0;
439         }
440
441         dlen = cp - path;
442         if (dlen < bufsize) {
443                 if (dlen == 0) {
444                         dlen++;
445                 }
446                 mprMemcpy(buf, bufsize, path, dlen);
447                 buf[dlen] = '\0';
448                 return 0;
449         }
450         return MPR_ERR_WONT_FIT;
451 }
452
453 /*****************************************************************************/
454
455 int mprStrcpy(char *dest, int destMax, const char *src)
456 {
457         int             len;
458
459         mprAssert(dest);
460         mprAssert(destMax > 0);
461         mprAssert(src);
462
463         len = strlen(src);
464         if (len >= destMax && len > 0) {
465                 mprAssert(0);
466                 return MPR_ERR_WONT_FIT;
467         }
468         if (len > 0) {
469                 memcpy(dest, src, len);
470                 dest[len] = '\0';
471         } else {
472                 *dest = '\0';
473                 len = 0;
474         } 
475         return len;
476 }
477
478 /*****************************************************************************/
479
480 int mprMemcpy(char *dest, int destMax, const char *src, int nbytes)
481 {
482         mprAssert(dest);
483         mprAssert(destMax > nbytes);
484         mprAssert(src);
485         mprAssert(nbytes > 0);
486
487         if (nbytes > destMax) {
488                 mprAssert(0);
489                 return MPR_ERR_WONT_FIT;
490         }
491         if (nbytes > 0) {
492                 memcpy(dest, src, nbytes);
493                 return nbytes;
494         } else {
495                 return 0;
496         }
497 }
498
499 /*****************************************************************************/
500 #else
501 void miniMprDummy() {}
502 #endif // !BLD_APPWEB && !BLD_GOAHEAD_WEBSERVER
503
504 /*
505  * Local variables:
506  * tab-width: 4
507  * c-basic-offset: 4
508  * End:
509  * vim:tw=78
510  * vim600: sw=4 ts=4 fdm=marker
511  * vim<600: sw=4 ts=4
512  */