1: /*
2: * This source file is part of the bstring string library. This code was
3: * written by Paul Hsieh in 2002-2007, and is covered by the BSD open source
4: * license. Refer to the accompanying documentation for details on usage and
5: * license.
6: */
7:
8: /*
9: * bstrlib.c
10: *
11: * This file is the core module for implementing the bstring functions.
12: */
13:
14: #include <stdio.h>
15: #include <stddef.h>
16: #include <stdarg.h>
17: #include <stdlib.h>
18: #include <string.h>
19: #include <ctype.h>
20: #include "bstrlib.h"
21:
22: /* Optionally include a mechanism for debugging memory */
23:
24: #if defined(MEMORY_DEBUG) || defined(BSTRLIB_MEMORY_DEBUG)
25: #include "memdbg.h"
26: #endif
27:
28: #ifndef bstr__alloc
29: #define bstr__alloc(x) malloc (x)
30: #endif
31:
32: #ifndef bstr__free
33: #define bstr__free(p) free (p)
34: #endif
35:
36: #ifndef bstr__realloc
37: #define bstr__realloc(p,x) realloc ((p), (x))
38: #endif
39:
40: #ifndef bstr__memcpy
41: #define bstr__memcpy(d,s,l) memcpy ((d), (s), (l))
42: #endif
43:
44: #ifndef bstr__memmove
45: #define bstr__memmove(d,s,l) memmove ((d), (s), (l))
46: #endif
47:
48: #ifndef bstr__memset
49: #define bstr__memset(d,c,l) memset ((d), (c), (l))
50: #endif
51:
52: #ifndef bstr__memcmp
53: #define bstr__memcmp(d,c,l) memcmp ((d), (c), (l))
54: #endif
55:
56: #ifndef bstr__memchr
57: #define bstr__memchr(s,c,l) memchr ((s), (c), (l))
58: #endif
59:
60: /* Just a length safe wrapper for memmove. */
61:
62: #define bBlockCopy(D,S,L) { if ((L) > 0) bstr__memmove ((D),(S),(L)); }
63:
64: /* Compute the snapped size for a given requested size. By snapping to powers
65: of 2 like this, repeated reallocations are avoided. */
66: static int snapUpSize (int i) {
67: if (i < 8) {
68: i = 8;
69: } else {
70: unsigned int j;
71: j = (unsigned int) i;
72:
73: j |= (j >> 1);
74: j |= (j >> 2);
75: j |= (j >> 4);
76: j |= (j >> 8); /* Ok, since int >= 16 bits */
77: #if (UINT_MAX != 0xffff)
78: j |= (j >> 16); /* For 32 bit int systems */
79: #if (UINT_MAX > 0xffffffffUL)
80: j |= (j >> 32); /* For 64 bit int systems */
81: #endif
82: #endif
83: /* Least power of two greater than i */
84: j++;
85: if ((int) j >= i) i = (int) j;
86: }
87: return i;
88: }
89:
90: /* int balloc (bstring b, int len)
91: *
92: * Increase the size of the memory backing the bstring b to at least len.
93: */
94: int balloc (bstring b, int olen) {
95: int len;
96: if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen <= 0 ||
97: b->mlen < b->slen || olen <= 0) {
98: return BSTR_ERR;
99: }
100:
101: if (olen >= b->mlen) {
102: unsigned char * x;
103:
104: if ((len = snapUpSize (olen)) <= b->mlen) return BSTR_OK;
105:
106: /* Assume probability of a non-moving realloc is 0.125 */
107: if (7 * b->mlen < 8 * b->slen) {
108:
109: /* If slen is close to mlen in size then use realloc to reduce
110: the memory defragmentation */
111:
112: reallocStrategy:;
113:
114: x = (unsigned char *) bstr__realloc (b->data, (size_t) len);
115: if (x == NULL) {
116:
117: /* Since we failed, try allocating the tighest possible
118: allocation */
119:
120: if (NULL == (x = (unsigned char *) bstr__realloc (b->data, (size_t) (len = olen)))) {
121: return BSTR_ERR;
122: }
123: }
124: } else {
125:
126: /* If slen is not close to mlen then avoid the penalty of copying
127: the extra bytes that are allocated, but not considered part of
128: the string */
129:
130: if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) {
131:
132: /* Perhaps there is no available memory for the two
133: allocations to be in memory at once */
134:
135: goto reallocStrategy;
136:
137: } else {
138: if (b->slen) bstr__memcpy ((char *) x, (char *) b->data, (size_t) b->slen);
139: bstr__free (b->data);
140: }
141: }
142: b->data = x;
143: b->mlen = len;
144: b->data[b->slen] = (unsigned char) '\0';
145: }
146:
147: return BSTR_OK;
148: }
149:
150: /* int ballocmin (bstring b, int len)
151: *
152: * Set the size of the memory backing the bstring b to len or b->slen+1,
153: * whichever is larger. Note that repeated use of this function can degrade
154: * performance.
155: */
156: int ballocmin (bstring b, int len) {
157: unsigned char * s;
158:
159: if (b == NULL || b->data == NULL || (b->slen+1) < 0 || b->mlen <= 0 ||
160: b->mlen < b->slen || len <= 0) {
161: return BSTR_ERR;
162: }
163:
164: if (len < b->slen + 1) len = b->slen + 1;
165:
166: if (len != b->mlen) {
167: s = (unsigned char *) bstr__realloc (b->data, (size_t) len);
168: if (NULL == s) return BSTR_ERR;
169: s[b->slen] = (unsigned char) '\0';
170: b->data = s;
171: b->mlen = len;
172: }
173:
174: return BSTR_OK;
175: }
176:
177: /* bstring bfromcstr (const char * str)
178: *
179: * Create a bstring which contains the contents of the '\0' terminated char *
180: * buffer str.
181: */
182: bstring bfromcstr (const char * str) {
183: bstring b;
184: int i;
185: size_t j;
186:
187: if (str == NULL) return NULL;
188: j = (strlen) (str);
189: i = snapUpSize ((int) (j + (2 - (j != 0))));
190: if (i <= (int) j) return NULL;
191:
192: b = (bstring) bstr__alloc (sizeof (struct tagbstring));
193: if (NULL == b) return NULL;
194: b->slen = (int) j;
195: if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
196: bstr__free (b);
197: return NULL;
198: }
199:
200: bstr__memcpy (b->data, str, j+1);
201: return b;
202: }
203:
204: /* bstring bfromcstralloc (int mlen, const char * str)
205: *
206: * Create a bstring which contains the contents of the '\0' terminated char *
207: * buffer str. The memory buffer backing the string is at least len
208: * characters in length.
209: */
210: bstring bfromcstralloc (int mlen, const char * str) {
211: bstring b;
212: int i;
213: size_t j;
214:
215: if (str == NULL) return NULL;
216: j = (strlen) (str);
217: i = snapUpSize ((int) (j + (2 - (j != 0))));
218: if (i <= (int) j) return NULL;
219:
220: b = (bstring) bstr__alloc (sizeof (struct tagbstring));
221: if (b == NULL) return NULL;
222: b->slen = (int) j;
223: if (i < mlen) i = mlen;
224:
225: if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
226: bstr__free (b);
227: return NULL;
228: }
229:
230: bstr__memcpy (b->data, str, j+1);
231: return b;
232: }
233:
234: /* bstring blk2bstr (const void * blk, int len)
235: *
236: * Create a bstring which contains the content of the block blk of length
237: * len.
238: */
239: bstring blk2bstr (const void * blk, int len) {
240: bstring b;
241: int i;
242:
243: if (blk == NULL || len < 0) return NULL;
244: b = (bstring) bstr__alloc (sizeof (struct tagbstring));
245: if (b == NULL) return NULL;
246: b->slen = len;
247:
248: i = len + (2 - (len != 0));
249: i = snapUpSize (i);
250:
251: b->mlen = i;
252:
253: b->data = (unsigned char *) bstr__alloc ((size_t) b->mlen);
254: if (b->data == NULL) {
255: bstr__free (b);
256: return NULL;
257: }
258:
259: if (len > 0) bstr__memcpy (b->data, blk, (size_t) len);
260: b->data[len] = (unsigned char) '\0';
261:
262: return b;
263: }
264:
265: /* char * bstr2cstr (const_bstring s, char z)
266: *
267: * Create a '\0' terminated char * buffer which is equal to the contents of
268: * the bstring s, except that any contained '\0' characters are converted
269: * to the character in z. This returned value should be freed with a
270: * bcstrfree () call, by the calling application.
271: */
272: char * bstr2cstr (const_bstring b, char z) {
273: int i, l;
274: char * r;
275:
276: if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
277: l = b->slen;
278: r = (char *) bstr__alloc ((size_t) (l + 1));
279: if (r == NULL) return r;
280:
281: for (i=0; i < l; i ++) {
282: r[i] = (char) ((b->data[i] == '\0') ? z : (char) (b->data[i]));
283: }
284:
285: r[l] = (unsigned char) '\0';
286:
287: return r;
288: }
289:
290: /* int bcstrfree (char * s)
291: *
292: * Frees a C-string generated by bstr2cstr (). This is normally unnecessary
293: * since it just wraps a call to bstr__free (), however, if bstr__alloc ()
294: * and bstr__free () have been redefined as a macros within the bstrlib
295: * module (via defining them in memdbg.h after defining
296: * BSTRLIB_MEMORY_DEBUG) with some difference in behaviour from the std
297: * library functions, then this allows a correct way of freeing the memory
298: * that allows higher level code to be independent from these macro
299: * redefinitions.
300: */
301: int bcstrfree (char * s) {
302: if (s) {
303: bstr__free (s);
304: return BSTR_OK;
305: }
306: return BSTR_ERR;
307: }
308:
309: /* int bconcat (bstring b0, const_bstring b1)
310: *
311: * Concatenate the bstring b1 to the bstring b0.
312: */
313: int bconcat (bstring b0, const_bstring b1) {
314: int len, d;
315: bstring aux = (bstring) b1;
316:
317: if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL) return BSTR_ERR;
318:
319: d = b0->slen;
320: len = b1->slen;
321: if ((d | (b0->mlen - d) | len) < 0) return BSTR_ERR;
322:
323: if (b0->mlen <= d + len + 1) {
324: ptrdiff_t pd;
325: if (0 <= (pd = b1->data - b0->data) && pd < b0->mlen) {
326: if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
327: }
328: if (balloc (b0, d + len + 1) != BSTR_OK) {
329: if (aux != b1) bdestroy (aux);
330: return BSTR_ERR;
331: }
332: }
333:
334: bBlockCopy (&b0->data[d], &aux->data[0], (size_t) len);
335: b0->data[d + len] = (unsigned char) '\0';
336: b0->slen += len;
337: if (aux != b1) bdestroy (aux);
338: return BSTR_OK;
339: }
340:
341: /* int bconchar (bstring b, char c)
342: *
343: * Concatenate the single character c to the bstring b.
344: */
345: int bconchar (bstring b, char c) {
346: int d;
347:
348: if (b == NULL) return BSTR_ERR;
349: d = b->slen;
350: if ((d | (b->mlen - d)) < 0 || balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
351: b->data[d] = (unsigned char) c;
352: b->data[d + 1] = (unsigned char) '\0';
353: b->slen++;
354: return BSTR_OK;
355: }
356:
357: /* int bcatcstr (bstring b, const char * s)
358: *
359: * Concatenate a char * string to a bstring.
360: */
361: int bcatcstr (bstring b, const char * s) {
362: char * d;
363: int i, l;
364:
365: if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
366: || b->mlen <= 0 || s == NULL) return BSTR_ERR;
367:
368: /* Optimistically concatenate directly */
369: l = b->mlen - b->slen;
370: d = (char *) &b->data[b->slen];
371: for (i=0; i < l; i++) {
372: if ((*d++ = *s++) == '\0') {
373: b->slen += i;
374: return BSTR_OK;
375: }
376: }
377: b->slen += i;
378:
379: /* Need to explicitely resize and concatenate tail */
380: return bcatblk (b, (const void *) s, (int) strlen (s));
381: }
382:
383: /* int bcatblk (bstring b, const void * s, int len)
384: *
385: * Concatenate a fixed length buffer to a bstring.
386: */
387: int bcatblk (bstring b, const void * s, int len) {
388: int nl;
389:
390: if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
391: || b->mlen <= 0 || s == NULL || len < 0) return BSTR_ERR;
392:
393: if (0 > (nl = b->slen + len)) return BSTR_ERR; /* Overflow? */
394: if (b->mlen <= nl && 0 > balloc (b, nl + 1)) return BSTR_ERR;
395:
396: bBlockCopy (&b->data[b->slen], s, (size_t) len);
397: b->slen = nl;
398: b->data[nl] = (unsigned char) '\0';
399: return BSTR_OK;
400: }
401:
402: /* bstring bstrcpy (const_bstring b)
403: *
404: * Create a copy of the bstring b.
405: */
406: bstring bstrcpy (const_bstring b) {
407: bstring b0;
408: int i,j;
409:
410: /* Attempted to copy an invalid string? */
411: if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
412:
413: b0 = (bstring) bstr__alloc (sizeof (struct tagbstring));
414: if (b0 == NULL) {
415: /* Unable to allocate memory for string header */
416: return NULL;
417: }
418:
419: i = b->slen;
420: j = snapUpSize (i + 1);
421:
422: b0->data = (unsigned char *) bstr__alloc (j);
423: if (b0->data == NULL) {
424: j = i + 1;
425: b0->data = (unsigned char *) bstr__alloc (j);
426: if (b0->data == NULL) {
427: /* Unable to allocate memory for string data */
428: bstr__free (b0);
429: return NULL;
430: }
431: }
432:
433: b0->mlen = j;
434: b0->slen = i;
435:
436: if (i) bstr__memcpy ((char *) b0->data, (char *) b->data, i);
437: b0->data[b0->slen] = (unsigned char) '\0';
438:
439: return b0;
440: }
441:
442: /* int bassign (bstring a, const_bstring b)
443: *
444: * Overwrite the string a with the contents of string b.
445: */
446: int bassign (bstring a, const_bstring b) {
447: if (b == NULL || b->data == NULL || b->slen < 0)
448: return BSTR_ERR;
449: if (b->slen != 0) {
450: if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR;
451: bstr__memmove (a->data, b->data, b->slen);
452: } else {
453: if (a == NULL || a->data == NULL || a->mlen < a->slen ||
454: a->slen < 0 || a->mlen == 0)
455: return BSTR_ERR;
456: }
457: a->data[b->slen] = (unsigned char) '\0';
458: a->slen = b->slen;
459: return BSTR_OK;
460: }
461:
462: /* int bassignmidstr (bstring a, const_bstring b, int left, int len)
463: *
464: * Overwrite the string a with the middle of contents of string b
465: * starting from position left and running for a length len. left and
466: * len are clamped to the ends of b as with the function bmidstr.
467: */
468: int bassignmidstr (bstring a, const_bstring b, int left, int len) {
469: if (b == NULL || b->data == NULL || b->slen < 0)
470: return BSTR_ERR;
471:
472: if (left < 0) {
473: len += left;
474: left = 0;
475: }
476:
477: if (len > b->slen - left) len = b->slen - left;
478:
479: if (a == NULL || a->data == NULL || a->mlen < a->slen ||
480: a->slen < 0 || a->mlen == 0)
481: return BSTR_ERR;
482:
483: if (len > 0) {
484: if (balloc (a, len) != BSTR_OK) return BSTR_ERR;
485: bstr__memmove (a->data, b->data + left, len);
486: a->slen = len;
487: } else {
488: a->slen = 0;
489: }
490: a->data[a->slen] = (unsigned char) '\0';
491: return BSTR_OK;
492: }
493:
494: /* int bassigncstr (bstring a, const char * str)
495: *
496: * Overwrite the string a with the contents of char * string str. Note that
497: * the bstring a must be a well defined and writable bstring. If an error
498: * occurs BSTR_ERR is returned however a may be partially overwritten.
499: */
500: int bassigncstr (bstring a, const char * str) {
501: int i;
502: size_t len;
503: if (a == NULL || a->data == NULL || a->mlen < a->slen ||
504: a->slen < 0 || a->mlen == 0 || NULL == str)
505: return BSTR_ERR;
506:
507: for (i=0; i < a->mlen; i++) {
508: if ('\0' == (a->data[i] = str[i])) {
509: a->slen = i;
510: return BSTR_OK;
511: }
512: }
513:
514: a->slen = i;
515: len = strlen (str + i);
516: if (len > INT_MAX || i + len + 1 > INT_MAX ||
517: 0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR;
518: bBlockCopy (a->data + i, str + i, (size_t) len + 1);
519: a->slen += (int) len;
520: return BSTR_OK;
521: }
522:
523: /* int bassignblk (bstring a, const void * s, int len)
524: *
525: * Overwrite the string a with the contents of the block (s, len). Note that
526: * the bstring a must be a well defined and writable bstring. If an error
527: * occurs BSTR_ERR is returned and a is not overwritten.
528: */
529: int bassignblk (bstring a, const void * s, int len) {
530: if (a == NULL || a->data == NULL || a->mlen < a->slen ||
531: a->slen < 0 || a->mlen == 0 || NULL == s || len + 1 < 1)
532: return BSTR_ERR;
533: if (len + 1 > a->mlen && 0 > balloc (a, len + 1)) return BSTR_ERR;
534: bBlockCopy (a->data, s, (size_t) len);
535: a->data[len] = (unsigned char) '\0';
536: a->slen = len;
537: return BSTR_OK;
538: }
539:
540: /* int btrunc (bstring b, int n)
541: *
542: * Truncate the bstring to at most n characters.
543: */
544: int btrunc (bstring b, int n) {
545: if (n < 0 || b == NULL || b->data == NULL || b->mlen < b->slen ||
546: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
547: if (b->slen > n) {
548: b->slen = n;
549: b->data[n] = (unsigned char) '\0';
550: }
551: return BSTR_OK;
552: }
553:
554: #define upcase(c) (toupper ((unsigned char) c))
555: #define downcase(c) (tolower ((unsigned char) c))
556: #define wspace(c) (isspace ((unsigned char) c))
557:
558: /* int btoupper (bstring b)
559: *
560: * Convert contents of bstring to upper case.
561: */
562: int btoupper (bstring b) {
563: int i, len;
564: if (b == NULL || b->data == NULL || b->mlen < b->slen ||
565: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
566: for (i=0, len = b->slen; i < len; i++) {
567: b->data[i] = (unsigned char) upcase (b->data[i]);
568: }
569: return BSTR_OK;
570: }
571:
572: /* int btolower (bstring b)
573: *
574: * Convert contents of bstring to lower case.
575: */
576: int btolower (bstring b) {
577: int i, len;
578: if (b == NULL || b->data == NULL || b->mlen < b->slen ||
579: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
580: for (i=0, len = b->slen; i < len; i++) {
581: b->data[i] = (unsigned char) downcase (b->data[i]);
582: }
583: return BSTR_OK;
584: }
585:
586: /* int bstricmp (const_bstring b0, const_bstring b1)
587: *
588: * Compare two strings without differentiating between case. The return
589: * value is the difference of the values of the characters where the two
590: * strings first differ after lower case transformation, otherwise 0 is
591: * returned indicating that the strings are equal. If the lengths are
592: * different, then a difference from 0 is given, but if the first extra
593: * character is '\0', then it is taken to be the value UCHAR_MAX+1.
594: */
595: int bstricmp (const_bstring b0, const_bstring b1) {
596: int i, v, n;
597:
598: if (bdata (b0) == NULL || b0->slen < 0 ||
599: bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN;
600: if ((n = b0->slen) > b1->slen) n = b1->slen;
601: else if (b0->slen == b1->slen && b0->data == b1->data) return BSTR_OK;
602:
603: for (i = 0; i < n; i ++) {
604: v = (char) downcase (b0->data[i])
605: - (char) downcase (b1->data[i]);
606: if (0 != v) return v;
607: }
608:
609: if (b0->slen > n) {
610: v = (char) downcase (b0->data[n]);
611: if (v) return v;
612: return UCHAR_MAX + 1;
613: }
614: if (b1->slen > n) {
615: v = - (char) downcase (b1->data[n]);
616: if (v) return v;
617: return - (int) (UCHAR_MAX + 1);
618: }
619: return BSTR_OK;
620: }
621:
622: /* int bstrnicmp (const_bstring b0, const_bstring b1, int n)
623: *
624: * Compare two strings without differentiating between case for at most n
625: * characters. If the position where the two strings first differ is
626: * before the nth position, the return value is the difference of the values
627: * of the characters, otherwise 0 is returned. If the lengths are different
628: * and less than n characters, then a difference from 0 is given, but if the
629: * first extra character is '\0', then it is taken to be the value
630: * UCHAR_MAX+1.
631: */
632: int bstrnicmp (const_bstring b0, const_bstring b1, int n) {
633: int i, v, m;
634:
635: if (bdata (b0) == NULL || b0->slen < 0 ||
636: bdata (b1) == NULL || b1->slen < 0 || n < 0) return SHRT_MIN;
637: m = n;
638: if (m > b0->slen) m = b0->slen;
639: if (m > b1->slen) m = b1->slen;
640:
641: if (b0->data != b1->data) {
642: for (i = 0; i < m; i ++) {
643: v = (char) downcase (b0->data[i]);
644: v -= (char) downcase (b1->data[i]);
645: if (v != 0) return b0->data[i] - b1->data[i];
646: }
647: }
648:
649: if (n == m || b0->slen == b1->slen) return BSTR_OK;
650:
651: if (b0->slen > m) {
652: v = (char) downcase (b0->data[m]);
653: if (v) return v;
654: return UCHAR_MAX + 1;
655: }
656:
657: v = - (char) downcase (b1->data[m]);
658: if (v) return v;
659: return - (int) (UCHAR_MAX + 1);
660: }
661:
662: /* int biseqcaseless (const_bstring b0, const_bstring b1)
663: *
664: * Compare two strings for equality without differentiating between case.
665: * If the strings differ other than in case, 0 is returned, if the strings
666: * are the same, 1 is returned, if there is an error, -1 is returned. If
667: * the length of the strings are different, this function is O(1). '\0'
668: * termination characters are not treated in any special way.
669: */
670: int biseqcaseless (const_bstring b0, const_bstring b1) {
671: int i, n;
672:
673: if (bdata (b0) == NULL || b0->slen < 0 ||
674: bdata (b1) == NULL || b1->slen < 0) return BSTR_ERR;
675: if (b0->slen != b1->slen) return BSTR_OK;
676: if (b0->data == b1->data || b0->slen == 0) return 1;
677: for (i=0, n=b0->slen; i < n; i++) {
678: if (b0->data[i] != b1->data[i]) {
679: unsigned char c = (unsigned char) downcase (b0->data[i]);
680: if (c != (unsigned char) downcase (b1->data[i])) return 0;
681: }
682: }
683: return 1;
684: }
685:
686: /* int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len)
687: *
688: * Compare beginning of string b0 with a block of memory of length len
689: * without differentiating between case for equality. If the beginning of b0
690: * differs from the memory block other than in case (or if b0 is too short),
691: * 0 is returned, if the strings are the same, 1 is returned, if there is an
692: * error, -1 is returned. '\0' characters are not treated in any special
693: * way.
694: */
695: int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) {
696: int i;
697:
698: if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
699: return BSTR_ERR;
700: if (b0->slen < len) return BSTR_OK;
701: if (b0->data == (const unsigned char *) blk || len == 0) return 1;
702:
703: for (i = 0; i < len; i ++) {
704: if (b0->data[i] != ((const unsigned char *) blk)[i]) {
705: if (downcase (b0->data[i]) !=
706: downcase (((const unsigned char *) blk)[i])) return 0;
707: }
708: }
709: return 1;
710: }
711:
712: /*
713: * int bltrimws (bstring b)
714: *
715: * Delete whitespace contiguous from the left end of the string.
716: */
717: int bltrimws (bstring b) {
718: int i, len;
719:
720: if (b == NULL || b->data == NULL || b->mlen < b->slen ||
721: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
722:
723: for (len = b->slen, i = 0; i < len; i++) {
724: if (!wspace (b->data[i])) {
725: return bdelete (b, 0, i);
726: }
727: }
728:
729: b->data[0] = (unsigned char) '\0';
730: b->slen = 0;
731: return BSTR_OK;
732: }
733:
734: /*
735: * int brtrimws (bstring b)
736: *
737: * Delete whitespace contiguous from the right end of the string.
738: */
739: int brtrimws (bstring b) {
740: int i;
741:
742: if (b == NULL || b->data == NULL || b->mlen < b->slen ||
743: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
744:
745: for (i = b->slen - 1; i >= 0; i--) {
746: if (!wspace (b->data[i])) {
747: if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
748: b->slen = i + 1;
749: return BSTR_OK;
750: }
751: }
752:
753: b->data[0] = (unsigned char) '\0';
754: b->slen = 0;
755: return BSTR_OK;
756: }
757:
758: /*
759: * int btrimws (bstring b)
760: *
761: * Delete whitespace contiguous from both ends of the string.
762: */
763: int btrimws (bstring b) {
764: int i, j;
765:
766: if (b == NULL || b->data == NULL || b->mlen < b->slen ||
767: b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
768:
769: for (i = b->slen - 1; i >= 0; i--) {
770: if (!wspace (b->data[i])) {
771: if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
772: b->slen = i + 1;
773: for (j = 0; wspace (b->data[j]); j++) {}
774: return bdelete (b, 0, j);
775: }
776: }
777:
778: b->data[0] = (unsigned char) '\0';
779: b->slen = 0;
780: return BSTR_OK;
781: }
782:
783: /* int biseq (const_bstring b0, const_bstring b1)
784: *
785: * Compare the string b0 and b1. If the strings differ, 0 is returned, if
786: * the strings are the same, 1 is returned, if there is an error, -1 is
787: * returned. If the length of the strings are different, this function is
788: * O(1). '\0' termination characters are not treated in any special way.
789: */
790: int biseq (const_bstring b0, const_bstring b1) {
791: if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
792: b0->slen < 0 || b1->slen < 0) return BSTR_ERR;
793: if (b0->slen != b1->slen) return BSTR_OK;
794: if (b0->data == b1->data || b0->slen == 0) return 1;
795: return !bstr__memcmp (b0->data, b1->data, b0->slen);
796: }
797:
798: /* int bisstemeqblk (const_bstring b0, const void * blk, int len)
799: *
800: * Compare beginning of string b0 with a block of memory of length len for
801: * equality. If the beginning of b0 differs from the memory block (or if b0
802: * is too short), 0 is returned, if the strings are the same, 1 is returned,
803: * if there is an error, -1 is returned. '\0' characters are not treated in
804: * any special way.
805: */
806: int bisstemeqblk (const_bstring b0, const void * blk, int len) {
807: int i;
808:
809: if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
810: return BSTR_ERR;
811: if (b0->slen < len) return BSTR_OK;
812: if (b0->data == (const unsigned char *) blk || len == 0) return 1;
813:
814: for (i = 0; i < len; i ++) {
815: if (b0->data[i] != ((const unsigned char *) blk)[i]) return BSTR_OK;
816: }
817: return 1;
818: }
819:
820: /* int biseqcstr (const_bstring b, const char *s)
821: *
822: * Compare the bstring b and char * string s. The C string s must be '\0'
823: * terminated at exactly the length of the bstring b, and the contents
824: * between the two must be identical with the bstring b with no '\0'
825: * characters for the two contents to be considered equal. This is
826: * equivalent to the condition that their current contents will be always be
827: * equal when comparing them in the same format after converting one or the
828: * other. If the strings are equal 1 is returned, if they are unequal 0 is
829: * returned and if there is a detectable error BSTR_ERR is returned.
830: */
831: int biseqcstr (const_bstring b, const char * s) {
832: int i;
833: if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) return BSTR_ERR;
834: for (i=0; i < b->slen; i++) {
835: if (s[i] == '\0' || b->data[i] != (unsigned char) s[i]) return BSTR_OK;
836: }
837: return s[i] == '\0';
838: }
839:
840: /* int biseqcstrcaseless (const_bstring b, const char *s)
841: *
842: * Compare the bstring b and char * string s. The C string s must be '\0'
843: * terminated at exactly the length of the bstring b, and the contents
844: * between the two must be identical except for case with the bstring b with
845: * no '\0' characters for the two contents to be considered equal. This is
846: * equivalent to the condition that their current contents will be always be
847: * equal ignoring case when comparing them in the same format after
848: * converting one or the other. If the strings are equal, except for case,
849: * 1 is returned, if they are unequal regardless of case 0 is returned and
850: * if there is a detectable error BSTR_ERR is returned.
851: */
852: int biseqcstrcaseless (const_bstring b, const char * s) {
853: int i;
854: if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) return BSTR_ERR;
855: for (i=0; i < b->slen; i++) {
856: if (s[i] == '\0' ||
857: (b->data[i] != (unsigned char) s[i] &&
858: downcase (b->data[i]) != (unsigned char) downcase (s[i])))
859: return BSTR_OK;
860: }
861: return s[i] == '\0';
862: }
863:
864: /* int bstrcmp (const_bstring b0, const_bstring b1)
865: *
866: * Compare the string b0 and b1. If there is an error, SHRT_MIN is returned,
867: * otherwise a value less than or greater than zero, indicating that the
868: * string pointed to by b0 is lexicographically less than or greater than
869: * the string pointed to by b1 is returned. If the the string lengths are
870: * unequal but the characters up until the length of the shorter are equal
871: * then a value less than, or greater than zero, indicating that the string
872: * pointed to by b0 is shorter or longer than the string pointed to by b1 is
873: * returned. 0 is returned if and only if the two strings are the same. If
874: * the length of the strings are different, this function is O(n). Like its
875: * standard C library counter part strcmp, the comparison does not proceed
876: * past any '\0' termination characters encountered.
877: */
878: int bstrcmp (const_bstring b0, const_bstring b1) {
879: int i, v, n;
880:
881: if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
882: b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
883: n = b0->slen; if (n > b1->slen) n = b1->slen;
884: if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0))
885: return BSTR_OK;
886:
887: for (i = 0; i < n; i ++) {
888: v = ((char) b0->data[i]) - ((char) b1->data[i]);
889: if (v != 0) return v;
890: if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
891: }
892:
893: if (b0->slen > n) return 1;
894: if (b1->slen > n) return -1;
895: return BSTR_OK;
896: }
897:
898: /* int bstrncmp (const_bstring b0, const_bstring b1, int n)
899: *
900: * Compare the string b0 and b1 for at most n characters. If there is an
901: * error, SHRT_MIN is returned, otherwise a value is returned as if b0 and
902: * b1 were first truncated to at most n characters then bstrcmp was called
903: * with these new strings are paremeters. If the length of the strings are
904: * different, this function is O(n). Like its standard C library counter
905: * part strcmp, the comparison does not proceed past any '\0' termination
906: * characters encountered.
907: */
908: int bstrncmp (const_bstring b0, const_bstring b1, int n) {
909: int i, v, m;
910:
911: if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
912: b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
913: m = n;
914: if (m > b0->slen) m = b0->slen;
915: if (m > b1->slen) m = b1->slen;
916:
917: if (b0->data != b1->data) {
918: for (i = 0; i < m; i ++) {
919: v = ((char) b0->data[i]) - ((char) b1->data[i]);
920: if (v != 0) return v;
921: if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
922: }
923: }
924:
925: if (n == m || b0->slen == b1->slen) return BSTR_OK;
926:
927: if (b0->slen > m) return 1;
928: return -1;
929: }
930:
931: /* bstring bmidstr (const_bstring b, int left, int len)
932: *
933: * Create a bstring which is the substring of b starting from position left
934: * and running for a length len (clamped by the end of the bstring b.) If
935: * b is detectably invalid, then NULL is returned. The section described
936: * by (left, len) is clamped to the boundaries of b.
937: */
938: bstring bmidstr (const_bstring b, int left, int len) {
939:
940: if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
941:
942: if (left < 0) {
943: len += left;
944: left = 0;
945: }
946:
947: if (len > b->slen - left) len = b->slen - left;
948:
949: if (len <= 0) return bfromcstr ("");
950: return blk2bstr (b->data + left, len);
951: }
952:
953: /* int bdelete (bstring b, int pos, int len)
954: *
955: * Removes characters from pos to pos+len-1 inclusive and shifts the tail of
956: * the bstring starting from pos+len to pos. len must be positive for this
957: * call to have any effect. The section of the string described by (pos,
958: * len) is clamped to boundaries of the bstring b.
959: */
960: int bdelete (bstring b, int pos, int len) {
961: /* Clamp to left side of bstring */
962: if (pos < 0) {
963: len += pos;
964: pos = 0;
965: }
966:
967: if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 ||
968: b->mlen < b->slen || b->mlen <= 0)
969: return BSTR_ERR;
970: if (len > 0 && pos < b->slen) {
971: if (pos + len >= b->slen) {
972: b->slen = pos;
973: } else {
974: bBlockCopy ((char *) (b->data + pos),
975: (char *) (b->data + pos + len),
976: b->slen - (pos+len));
977: b->slen -= len;
978: }
979: b->data[b->slen] = (unsigned char) '\0';
980: }
981: return BSTR_OK;
982: }
983:
984: /* int bdestroy (bstring b)
985: *
986: * Free up the bstring. Note that if b is detectably invalid or not writable
987: * then no action is performed and BSTR_ERR is returned. Like a freed memory
988: * allocation, dereferences, writes or any other action on b after it has
989: * been bdestroyed is undefined.
990: */
991: int bdestroy (bstring b) {
992: if (b == NULL || b->slen < 0 || b->mlen <= 0 || b->mlen < b->slen ||
993: b->data == NULL)
994: return BSTR_ERR;
995:
996: bstr__free (b->data);
997:
998: /* In case there is any stale usage, there is one more chance to
999: notice this error. */
1000:
1001: b->slen = -1;
1002: b->mlen = -__LINE__;
1003: b->data = NULL;
1004:
1005: bstr__free (b);
1006: return BSTR_OK;
1007: }
1008:
1009: /* int binstr (const_bstring b1, int pos, const_bstring b2)
1010: *
1011: * Search for the bstring b2 in b1 starting from position pos, and searching
1012: * forward. If it is found then return with the first position where it is
1013: * found, otherwise return BSTR_ERR. Note that this is just a brute force
1014: * string searcher that does not attempt clever things like the Boyer-Moore
1015: * search algorithm. Because of this there are many degenerate cases where
1016: * this can take much longer than it needs to.
1017: */
1018: int binstr (const_bstring b1, int pos, const_bstring b2) {
1019: int j, ii, ll, lf;
1020: unsigned char * d0;
1021: unsigned char c0;
1022: register unsigned char * d1;
1023: register unsigned char c1;
1024: register int i;
1025:
1026: if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
1027: b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
1028: if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
1029: if (b1->slen < pos || pos < 0) return BSTR_ERR;
1030: if (b2->slen == 0) return pos;
1031:
1032: /* No space to find such a string? */
1033: if ((lf = b1->slen - b2->slen + 1) <= pos) return BSTR_ERR;
1034:
1035: /* An obvious alias case */
1036: if (b1->data == b2->data && pos == 0) return 0;
1037:
1038: i = pos;
1039:
1040: d0 = b2->data;
1041: d1 = b1->data;
1042: ll = b2->slen;
1043:
1044: /* Peel off the b2->slen == 1 case */
1045: c0 = d0[0];
1046: if (1 == ll) {
1047: for (;i < lf; i++) if (c0 == d1[i]) return i;
1048: return BSTR_ERR;
1049: }
1050:
1051: c1 = c0;
1052: j = 0;
1053: lf = b1->slen - 1;
1054:
1055: ii = -1;
1056: if (i < lf) do {
1057: /* Unrolled current character test */
1058: if (c1 != d1[i]) {
1059: if (c1 != d1[1+i]) {
1060: i += 2;
1061: continue;
1062: }
1063: i++;
1064: }
1065:
1066: /* Take note if this is the start of a potential match */
1067: if (0 == j) ii = i;
1068:
1069: /* Shift the test character down by one */
1070: j++;
1071: i++;
1072:
1073: /* If this isn't past the last character continue */
1074: if (j < ll) {
1075: c1 = d0[j];
1076: continue;
1077: }
1078:
1079: N0:;
1080:
1081: /* If no characters mismatched, then we matched */
1082: if (i == ii+j) return ii;
1083:
1084: /* Shift back to the beginning */
1085: i -= j;
1086: j = 0;
1087: c1 = c0;
1088: } while (i < lf);
1089:
1090: /* Deal with last case if unrolling caused a misalignment */
1091: if (i == lf && ll == j+1 && c1 == d1[i]) goto N0;
1092:
1093: return BSTR_ERR;
1094: }
1095:
1096: /* int binstrr (const_bstring b1, int pos, const_bstring b2)
1097: *
1098: * Search for the bstring b2 in b1 starting from position pos, and searching
1099: * backward. If it is found then return with the first position where it is
1100: * found, otherwise return BSTR_ERR. Note that this is just a brute force
1101: * string searcher that does not attempt clever things like the Boyer-Moore
1102: * search algorithm. Because of this there are many degenerate cases where
1103: * this can take much longer than it needs to.
1104: */
1105: int binstrr (const_bstring b1, int pos, const_bstring b2) {
1106: int j, i, l;
1107: unsigned char * d0, * d1;
1108:
1109: if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
1110: b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
1111: if (b1->slen == pos && b2->slen == 0) return pos;
1112: if (b1->slen < pos || pos < 0) return BSTR_ERR;
1113: if (b2->slen == 0) return pos;
1114:
1115: /* Obvious alias case */
1116: if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return 0;
1117:
1118: i = pos;
1119: if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
1120:
1121: /* If no space to find such a string then snap back */
1122: if (l + 1 <= i) i = l;
1123: j = 0;
1124:
1125: d0 = b2->data;
1126: d1 = b1->data;
1127: l = b2->slen;
1128:
1129: for (;;) {
1130: if (d0[j] == d1[i + j]) {
1131: j ++;
1132: if (j >= l) return i;
1133: } else {
1134: i --;
1135: if (i < 0) break;
1136: j=0;
1137: }
1138: }
1139:
1140: return BSTR_ERR;
1141: }
1142:
1143: /* int binstrcaseless (const_bstring b1, int pos, const_bstring b2)
1144: *
1145: * Search for the bstring b2 in b1 starting from position pos, and searching
1146: * forward but without regard to case. If it is found then return with the
1147: * first position where it is found, otherwise return BSTR_ERR. Note that
1148: * this is just a brute force string searcher that does not attempt clever
1149: * things like the Boyer-Moore search algorithm. Because of this there are
1150: * many degenerate cases where this can take much longer than it needs to.
1151: */
1152: int binstrcaseless (const_bstring b1, int pos, const_bstring b2) {
1153: int j, i, l, ll;
1154: unsigned char * d0, * d1;
1155:
1156: if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
1157: b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
1158: if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
1159: if (b1->slen < pos || pos < 0) return BSTR_ERR;
1160: if (b2->slen == 0) return pos;
1161:
1162: l = b1->slen - b2->slen + 1;
1163:
1164: /* No space to find such a string? */
1165: if (l <= pos) return BSTR_ERR;
1166:
1167: /* An obvious alias case */
1168: if (b1->data == b2->data && pos == 0) return BSTR_OK;
1169:
1170: i = pos;
1171: j = 0;
1172:
1173: d0 = b2->data;
1174: d1 = b1->data;
1175: ll = b2->slen;
1176:
1177: for (;;) {
1178: if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
1179: j ++;
1180: if (j >= ll) return i;
1181: } else {
1182: i ++;
1183: if (i >= l) break;
1184: j=0;
1185: }
1186: }
1187:
1188: return BSTR_ERR;
1189: }
1190:
1191: /* int binstrrcaseless (const_bstring b1, int pos, const_bstring b2)
1192: *
1193: * Search for the bstring b2 in b1 starting from position pos, and searching
1194: * backward but without regard to case. If it is found then return with the
1195: * first position where it is found, otherwise return BSTR_ERR. Note that
1196: * this is just a brute force string searcher that does not attempt clever
1197: * things like the Boyer-Moore search algorithm. Because of this there are
1198: * many degenerate cases where this can take much longer than it needs to.
1199: */
1200: int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) {
1201: int j, i, l;
1202: unsigned char * d0, * d1;
1203:
1204: if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
1205: b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
1206: if (b1->slen == pos && b2->slen == 0) return pos;
1207: if (b1->slen < pos || pos < 0) return BSTR_ERR;
1208: if (b2->slen == 0) return pos;
1209:
1210: /* Obvious alias case */
1211: if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return BSTR_OK;
1212:
1213: i = pos;
1214: if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
1215:
1216: /* If no space to find such a string then snap back */
1217: if (l + 1 <= i) i = l;
1218: j = 0;
1219:
1220: d0 = b2->data;
1221: d1 = b1->data;
1222: l = b2->slen;
1223:
1224: for (;;) {
1225: if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
1226: j ++;
1227: if (j >= l) return i;
1228: } else {
1229: i --;
1230: if (i < 0) break;
1231: j=0;
1232: }
1233: }
1234:
1235: return BSTR_ERR;
1236: }
1237:
1238:
1239: /* int bstrchrp (const_bstring b, int c, int pos)
1240: *
1241: * Search for the character c in b forwards from the position pos
1242: * (inclusive).
1243: */
1244: int bstrchrp (const_bstring b, int c, int pos) {
1245: unsigned char * p;
1246:
1247: if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) return BSTR_ERR;
1248: p = (unsigned char *) bstr__memchr ((b->data + pos), (unsigned char) c, (b->slen - pos));
1249: if (p) return (int) (p - b->data);
1250: return BSTR_ERR;
1251: }
1252:
1253: /* int bstrrchrp (const_bstring b, int c, int pos)
1254: *
1255: * Search for the character c in b backwards from the position pos in string
1256: * (inclusive).
1257: */
1258: int bstrrchrp (const_bstring b, int c, int pos) {
1259: int i;
1260:
1261: if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) return BSTR_ERR;
1262: for (i=pos; i >= 0; i--) {
1263: if (b->data[i] == (unsigned char) c) return i;
1264: }
1265: return BSTR_ERR;
1266: }
1267:
1268: #if !defined (BSTRLIB_AGGRESSIVE_MEMORY_FOR_SPEED_TRADEOFF)
1269: #define LONG_LOG_BITS_QTY (3)
1270: #define LONG_BITS_QTY (1 << LONG_LOG_BITS_QTY)
1271: #define LONG_TYPE unsigned char
1272:
1273: #define CFCLEN ((1 << CHAR_BIT) / LONG_BITS_QTY)
1274: struct charField { LONG_TYPE content[CFCLEN]; };
1275: #define testInCharField(cf,c) ((cf)->content[(c) >> LONG_LOG_BITS_QTY] & (((long)1) << ((c) & (LONG_BITS_QTY-1))))
1276: #define setInCharField(cf,idx) { \
1277: unsigned int c = (unsigned int) (idx); \
1278: (cf)->content[c >> LONG_LOG_BITS_QTY] |= (LONG_TYPE) (1ul << (c & (LONG_BITS_QTY-1))); \
1279: }
1280:
1281: #else
1282:
1283: #define CFCLEN (1 << CHAR_BIT)
1284: struct charField { unsigned char content[CFCLEN]; };
1285: #define testInCharField(cf,c) ((cf)->content[(unsigned char) (c)])
1286: #define setInCharField(cf,idx) (cf)->content[(unsigned int) (idx)] = ~0
1287:
1288: #endif
1289:
1290: /* Convert a bstring to charField */
1291: static int buildCharField (struct charField * cf, const_bstring b) {
1292: int i;
1293: if (b == NULL || b->data == NULL || b->slen <= 0) return BSTR_ERR;
1294: memset ((void *) cf->content, 0, sizeof (struct charField));
1295: for (i=0; i < b->slen; i++) {
1296: setInCharField (cf, b->data[i]);
1297: }
1298: return BSTR_OK;
1299: }
1300:
1301: static void invertCharField (struct charField * cf) {
1302: int i;
1303: for (i=0; i < CFCLEN; i++) cf->content[i] = ~cf->content[i];
1304: }
1305:
1306: /* Inner engine for binchr */
1307: static int binchrCF (const unsigned char * data, int len, int pos, const struct charField * cf) {
1308: int i;
1309: for (i=pos; i < len; i++) {
1310: unsigned char c = (unsigned char) data[i];
1311: if (testInCharField (cf, c)) return i;
1312: }
1313: return BSTR_ERR;
1314: }
1315:
1316: /* int binchr (const_bstring b0, int pos, const_bstring b1);
1317: *
1318: * Search for the first position in b0 starting from pos or after, in which
1319: * one of the characters in b1 is found and return it. If such a position
1320: * does not exist in b0, then BSTR_ERR is returned.
1321: */
1322: int binchr (const_bstring b0, int pos, const_bstring b1) {
1323: struct charField chrs;
1324: if (pos < 0 || b0 == NULL || b0->data == NULL ||
1325: b0->slen <= pos) return BSTR_ERR;
1326: if (1 == b1->slen) return bstrchrp (b0, b1->data[0], pos);
1327: if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
1328: return binchrCF (b0->data, b0->slen, pos, &chrs);
1329: }
1330:
1331: /* Inner engine for binchrr */
1332: static int binchrrCF (const unsigned char * data, int pos, const struct charField * cf) {
1333: int i;
1334: for (i=pos; i >= 0; i--) {
1335: unsigned int c = (unsigned int) data[i];
1336: if (testInCharField (cf, c)) return i;
1337: }
1338: return BSTR_ERR;
1339: }
1340:
1341: /* int binchrr (const_bstring b0, int pos, const_bstring b1);
1342: *
1343: * Search for the last position in b0 no greater than pos, in which one of
1344: * the characters in b1 is found and return it. If such a position does not
1345: * exist in b0, then BSTR_ERR is returned.
1346: */
1347: int binchrr (const_bstring b0, int pos, const_bstring b1) {
1348: struct charField chrs;
1349: if (pos < 0 || b0 == NULL || b0->data == NULL || b1 == NULL ||
1350: b0->slen < pos) return BSTR_ERR;
1351: if (pos == b0->slen) pos--;
1352: if (1 == b1->slen) return bstrrchrp (b0, b1->data[0], pos);
1353: if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
1354: return binchrrCF (b0->data, pos, &chrs);
1355: }
1356:
1357: /* int bninchr (const_bstring b0, int pos, const_bstring b1);
1358: *
1359: * Search for the first position in b0 starting from pos or after, in which
1360: * none of the characters in b1 is found and return it. If such a position
1361: * does not exist in b0, then BSTR_ERR is returned.
1362: */
1363: int bninchr (const_bstring b0, int pos, const_bstring b1) {
1364: struct charField chrs;
1365: if (pos < 0 || b0 == NULL || b0->data == NULL ||
1366: b0->slen <= pos) return BSTR_ERR;
1367: if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
1368: invertCharField (&chrs);
1369: return binchrCF (b0->data, b0->slen, pos, &chrs);
1370: }
1371:
1372: /* int bninchrr (const_bstring b0, int pos, const_bstring b1);
1373: *
1374: * Search for the last position in b0 no greater than pos, in which none of
1375: * the characters in b1 is found and return it. If such a position does not
1376: * exist in b0, then BSTR_ERR is returned.
1377: */
1378: int bninchrr (const_bstring b0, int pos, const_bstring b1) {
1379: struct charField chrs;
1380: if (pos < 0 || b0 == NULL || b0->data == NULL ||
1381: b0->slen < pos) return BSTR_ERR;
1382: if (pos == b0->slen) pos--;
1383: if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
1384: invertCharField (&chrs);
1385: return binchrrCF (b0->data, pos, &chrs);
1386: }
1387:
1388: /* int bsetstr (bstring b0, int pos, bstring b1, unsigned char fill)
1389: *
1390: * Overwrite the string b0 starting at position pos with the string b1. If
1391: * the position pos is past the end of b0, then the character "fill" is
1392: * appended as necessary to make up the gap between the end of b0 and pos.
1393: * If b1 is NULL, it behaves as if it were a 0-length string.
1394: */
1395: int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill) {
1396: int d, newlen;
1397: ptrdiff_t pd;
1398: bstring aux = (bstring) b1;
1399:
1400: if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data ||
1401: b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR;
1402: if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return BSTR_ERR;
1403:
1404: d = pos;
1405:
1406: /* Aliasing case */
1407: if (NULL != aux) {
1408: if ((pd = (ptrdiff_t) (b1->data - b0->data)) >= 0 && pd < (ptrdiff_t) b0->mlen) {
1409: if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
1410: }
1411: d += aux->slen;
1412: }
1413:
1414: /* Increase memory size if necessary */
1415: if (balloc (b0, d + 1) != BSTR_OK) {
1416: if (aux != b1) bdestroy (aux);
1417: return BSTR_ERR;
1418: }
1419:
1420: newlen = b0->slen;
1421:
1422: /* Fill in "fill" character as necessary */
1423: if (pos > newlen) {
1424: bstr__memset (b0->data + b0->slen, (int) fill, (size_t) (pos - b0->slen));
1425: newlen = pos;
1426: }
1427:
1428: /* Copy b1 to position pos in b0. */
1429: if (aux != NULL) {
1430: bBlockCopy ((char *) (b0->data + pos), (char *) aux->data, aux->slen);
1431: if (aux != b1) bdestroy (aux);
1432: }
1433:
1434: /* Indicate the potentially increased size of b0 */
1435: if (d > newlen) newlen = d;
1436:
1437: b0->slen = newlen;
1438: b0->data[newlen] = (unsigned char) '\0';
1439:
1440: return BSTR_OK;
1441: }
1442:
1443: /* int binsert (bstring b1, int pos, bstring b2, unsigned char fill)
1444: *
1445: * Inserts the string b2 into b1 at position pos. If the position pos is
1446: * past the end of b1, then the character "fill" is appended as necessary to
1447: * make up the gap between the end of b1 and pos. Unlike bsetstr, binsert
1448: * does not allow b2 to be NULL.
1449: */
1450: int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) {
1451: int d, l;
1452: ptrdiff_t pd;
1453: bstring aux = (bstring) b2;
1454:
1455: if (pos < 0 || b1 == NULL || b2 == NULL || b1->slen < 0 ||
1456: b2->slen < 0 || b1->mlen < b1->slen || b1->mlen <= 0) return BSTR_ERR;
1457:
1458: /* Aliasing case */
1459: if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && pd < (ptrdiff_t) b1->mlen) {
1460: if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR;
1461: }
1462:
1463: /* Compute the two possible end pointers */
1464: d = b1->slen + aux->slen;
1465: l = pos + aux->slen;
1466: if ((d|l) < 0) return BSTR_ERR;
1467:
1468: if (l > d) {
1469: /* Inserting past the end of the string */
1470: if (balloc (b1, l + 1) != BSTR_OK) {
1471: if (aux != b2) bdestroy (aux);
1472: return BSTR_ERR;
1473: }
1474: bstr__memset (b1->data + b1->slen, (int) fill, (size_t) (pos - b1->slen));
1475: b1->slen = l;
1476: } else {
1477: /* Inserting in the middle of the string */
1478: if (balloc (b1, d + 1) != BSTR_OK) {
1479: if (aux != b2) bdestroy (aux);
1480: return BSTR_ERR;
1481: }
1482: bBlockCopy (b1->data + l, b1->data + pos, d - l);
1483: b1->slen = d;
1484: }
1485: bBlockCopy (b1->data + pos, aux->data, aux->slen);
1486: b1->data[b1->slen] = (unsigned char) '\0';
1487: if (aux != b2) bdestroy (aux);
1488: return BSTR_OK;
1489: }
1490:
1491: /* int breplace (bstring b1, int pos, int len, bstring b2,
1492: * unsigned char fill)
1493: *
1494: * Replace a section of a string from pos for a length len with the string b2.
1495: * fill is used is pos > b1->slen.
1496: */
1497: int breplace (bstring b1, int pos, int len, const_bstring b2,
1498: unsigned char fill) {
1499: int pl, ret;
1500: ptrdiff_t pd;
1501: bstring aux = (bstring) b2;
1502:
1503: if (pos < 0 || len < 0 || (pl = pos + len) < 0 || b1 == NULL ||
1504: b2 == NULL || b1->data == NULL || b2->data == NULL ||
1505: b1->slen < 0 || b2->slen < 0 || b1->mlen < b1->slen ||
1506: b1->mlen <= 0) return BSTR_ERR;
1507:
1508: /* Straddles the end? */
1509: if (pl >= b1->slen) {
1510: if ((ret = bsetstr (b1, pos, b2, fill)) < 0) return ret;
1511: if (pos + b2->slen < b1->slen) {
1512: b1->slen = pos + b2->slen;
1513: b1->data[b1->slen] = (unsigned char) '\0';
1514: }
1515: return ret;
1516: }
1517:
1518: /* Aliasing case */
1519: if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && pd < (ptrdiff_t) b1->slen) {
1520: if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR;
1521: }
1522:
1523: if (aux->slen > len) {
1524: if (balloc (b1, b1->slen + aux->slen - len) != BSTR_OK) {
1525: if (aux != b2) bdestroy (aux);
1526: return BSTR_ERR;
1527: }
1528: }
1529:
1530: if (aux->slen != len) bstr__memmove (b1->data + pos + aux->slen, b1->data + pos + len, b1->slen - (pos + len));
1531: bstr__memcpy (b1->data + pos, aux->data, aux->slen);
1532: b1->slen += aux->slen - len;
1533: b1->data[b1->slen] = (unsigned char) '\0';
1534: if (aux != b2) bdestroy (aux);
1535: return BSTR_OK;
1536: }
1537:
1538: /* int bfindreplace (bstring b, const_bstring find, const_bstring repl,
1539: * int pos)
1540: *
1541: * Replace all occurrences of a find string with a replace string after a
1542: * given point in a bstring.
1543: */
1544:
1545: typedef int (*instr_fnptr) (const_bstring s1, int pos, const_bstring s2);
1546:
1547: static int findreplaceengine (bstring b, const_bstring find, const_bstring repl, int pos, instr_fnptr instr) {
1548: int i, ret, slen, mlen, delta, acc;
1549: int * d;
1550: int static_d[32];
1551: ptrdiff_t pd;
1552: bstring auxf = (bstring) find;
1553: bstring auxr = (bstring) repl;
1554:
1555: if (b == NULL || b->data == NULL || find == NULL ||
1556: find->data == NULL || repl == NULL || repl->data == NULL ||
1557: pos < 0 || find->slen <= 0 || b->mlen < 0 || b->slen > b->mlen ||
1558: b->mlen <= 0 || b->slen < 0 || repl->slen < 0) return BSTR_ERR;
1559: if (pos > b->slen - find->slen) return BSTR_OK;
1560:
1561: /* Alias with find string */
1562: pd = (ptrdiff_t) (find->data - b->data);
1563: if ((ptrdiff_t) (pos - find->slen) < pd && pd < (ptrdiff_t) b->slen) {
1564: if (NULL == (auxf = bstrcpy (find))) return BSTR_ERR;
1565: }
1566:
1567: /* Alias with repl string */
1568: pd = (ptrdiff_t) (repl->data - b->data);
1569: if ((ptrdiff_t) (pos - repl->slen) < pd && pd < (ptrdiff_t) b->slen) {
1570: if (NULL == (auxr = bstrcpy (repl))) {
1571: if (auxf != find) bdestroy (auxf);
1572: return BSTR_ERR;
1573: }
1574: }
1575:
1576: delta = auxf->slen - auxr->slen;
1577:
1578: /* in-place replacement since find and replace strings are of equal
1579: length */
1580: if (delta == 0) {
1581: while ((pos = instr (b, pos, auxf)) >= 0) {
1582: bstr__memcpy (b->data + pos, auxr->data, auxr->slen);
1583: pos += auxf->slen;
1584: }
1585: if (auxf != find) bdestroy (auxf);
1586: if (auxr != repl) bdestroy (auxr);
1587: return BSTR_OK;
1588: }
1589:
1590: /* shrinking replacement since auxf->slen > auxr->slen */
1591: if (delta > 0) {
1592: acc = 0;
1593:
1594: while ((i = instr (b, pos, auxf)) >= 0) {
1595: if (acc && i > pos)
1596: bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
1597: if (auxr->slen)
1598: bstr__memcpy (b->data + i - acc, auxr->data, auxr->slen);
1599: acc += delta;
1600: pos = i + auxf->slen;
1601: }
1602:
1603: if (acc) {
1604: i = b->slen;
1605: if (i > pos)
1606: bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
1607: b->slen -= acc;
1608: b->data[b->slen] = (unsigned char) '\0';
1609: }
1610:
1611: if (auxf != find) bdestroy (auxf);
1612: if (auxr != repl) bdestroy (auxr);
1613: return BSTR_OK;
1614: }
1615:
1616: /* expanding replacement since find->slen < repl->slen. Its a lot
1617: more complicated. */
1618:
1619: mlen = 32;
1620: d = (int *) static_d; /* Avoid malloc for trivial cases */
1621: acc = slen = 0;
1622:
1623: while ((pos = instr (b, pos, auxf)) >= 0) {
1624: if (slen + 1 >= mlen) {
1625: int sl;
1626: int * t;
1627: mlen += mlen;
1628: sl = sizeof (int *) * mlen;
1629: if (static_d == d) d = NULL;
1630: if (sl < mlen || NULL == (t = (int *) bstr__realloc (d, sl))) {
1631: ret = BSTR_ERR;
1632: goto done;
1633: }
1634: if (NULL == d) bstr__memcpy (t, static_d, sizeof (static_d));
1635: d = t;
1636: }
1637: d[slen] = pos;
1638: slen++;
1639: acc -= delta;
1640: pos += auxf->slen;
1641: if (pos < 0 || acc < 0) {
1642: ret = BSTR_ERR;
1643: goto done;
1644: }
1645: }
1646: d[slen] = b->slen;
1647:
1648: if (BSTR_OK == (ret = balloc (b, b->slen + acc + 1))) {
1649: b->slen += acc;
1650: for (i = slen-1; i >= 0; i--) {
1651: int s, l;
1652: s = d[i] + auxf->slen;
1653: l = d[i+1] - s;
1654: if (l) {
1655: bstr__memmove (b->data + s + acc, b->data + s, l);
1656: }
1657: if (auxr->slen) {
1658: bstr__memmove (b->data + s + acc - auxr->slen,
1659: auxr->data, auxr->slen);
1660: }
1661: acc += delta;
1662: }
1663: b->data[b->slen] = (unsigned char) '\0';
1664: }
1665:
1666: done:;
1667: if (static_d == d) d = NULL;
1668: bstr__free (d);
1669: if (auxf != find) bdestroy (auxf);
1670: if (auxr != repl) bdestroy (auxr);
1671: return ret;
1672: }
1673:
1674: /* int bfindreplace (bstring b, const_bstring find, const_bstring repl,
1675: * int pos)
1676: *
1677: * Replace all occurrences of a find string with a replace string after a
1678: * given point in a bstring.
1679: */
1680: int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos) {
1681: return findreplaceengine (b, find, repl, pos, binstr);
1682: }
1683:
1684: /* int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl,
1685: * int pos)
1686: *
1687: * Replace all occurrences of a find string, ignoring case, with a replace
1688: * string after a given point in a bstring.
1689: */
1690: int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos) {
1691: return findreplaceengine (b, find, repl, pos, binstrcaseless);
1692: }
1693:
1694: /* int binsertch (bstring b, int pos, int len, unsigned char fill)
1695: *
1696: * Inserts the character fill repeatedly into b at position pos for a
1697: * length len. If the position pos is past the end of b, then the
1698: * character "fill" is appended as necessary to make up the gap between the
1699: * end of b and the position pos + len.
1700: */
1701: int binsertch (bstring b, int pos, int len, unsigned char fill) {
1702: int d, l, i;
1703:
1704: if (pos < 0 || b == NULL || b->slen < 0 || b->mlen < b->slen ||
1705: b->mlen <= 0 || len < 0) return BSTR_ERR;
1706:
1707: /* Compute the two possible end pointers */
1708: d = b->slen + len;
1709: l = pos + len;
1710: if ((d|l) < 0) return BSTR_ERR;
1711:
1712: if (l > d) {
1713: /* Inserting past the end of the string */
1714: if (balloc (b, l + 1) != BSTR_OK) return BSTR_ERR;
1715: pos = b->slen;
1716: b->slen = l;
1717: } else {
1718: /* Inserting in the middle of the string */
1719: if (balloc (b, d + 1) != BSTR_OK) return BSTR_ERR;
1720: for (i = d - 1; i >= l; i--) {
1721: b->data[i] = b->data[i - len];
1722: }
1723: b->slen = d;
1724: }
1725:
1726: for (i=pos; i < l; i++) b->data[i] = fill;
1727: b->data[b->slen] = (unsigned char) '\0';
1728: return BSTR_OK;
1729: }
1730:
1731: /* int bpattern (bstring b, int len)
1732: *
1733: * Replicate the bstring, b in place, end to end repeatedly until it
1734: * surpasses len characters, then chop the result to exactly len characters.
1735: * This function operates in-place. The function will return with BSTR_ERR
1736: * if b is NULL or of length 0, otherwise BSTR_OK is returned.
1737: */
1738: int bpattern (bstring b, int len) {
1739: int i, d;
1740:
1741: d = blength (b);
1742: if (d <= 0 || len < 0 || balloc (b, len + 1) != BSTR_OK) return BSTR_ERR;
1743: if (len > 0) {
1744: if (d == 1) return bsetstr (b, len, NULL, b->data[0]);
1745: for (i = d; i < len; i++) b->data[i] = b->data[i - d];
1746: }
1747: b->data[len] = (unsigned char) '\0';
1748: b->slen = len;
1749: return BSTR_OK;
1750: }
1751:
1752: #define BS_BUFF_SZ (1024)
1753:
1754: /* int breada (bstring b, bNread readPtr, void * parm)
1755: *
1756: * Use a finite buffer fread-like function readPtr to concatenate to the
1757: * bstring b the entire contents of file-like source data in a roughly
1758: * efficient way.
1759: */
1760: int breada (bstring b, bNread readPtr, void * parm) {
1761: int i, l, n;
1762:
1763: if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
1764: b->mlen <= 0 || readPtr == NULL) return BSTR_ERR;
1765:
1766: i = b->slen;
1767: for (n=i+16; ; n += ((n < BS_BUFF_SZ) ? n : BS_BUFF_SZ)) {
1768: if (BSTR_OK != balloc (b, n + 1)) return BSTR_ERR;
1769: l = (int) readPtr ((void *) (b->data + i), 1, n - i, parm);
1770: i += l;
1771: b->slen = i;
1772: if (i < n) break;
1773: }
1774:
1775: b->data[i] = (unsigned char) '\0';
1776: return BSTR_OK;
1777: }
1778:
1779: /* bstring bread (bNread readPtr, void * parm)
1780: *
1781: * Use a finite buffer fread-like function readPtr to create a bstring
1782: * filled with the entire contents of file-like source data in a roughly
1783: * efficient way.
1784: */
1785: bstring bread (bNread readPtr, void * parm) {
1786: int ret;
1787: bstring buff;
1788:
1789: if (readPtr == NULL) return NULL;
1790: buff = bfromcstr ("");
1791: if (buff == NULL) return NULL;
1792: ret = breada (buff, readPtr, parm);
1793: if (ret < 0) {
1794: bdestroy (buff);
1795: return NULL;
1796: }
1797: return buff;
1798: }
1799:
1800: /* int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator)
1801: *
1802: * Use an fgetc-like single character stream reading function (getcPtr) to
1803: * obtain a sequence of characters which are concatenated to the end of the
1804: * bstring b. The stream read is terminated by the passed in terminator
1805: * parameter.
1806: *
1807: * If getcPtr returns with a negative number, or the terminator character
1808: * (which is appended) is read, then the stream reading is halted and the
1809: * function returns with a partial result in b. If there is an empty partial
1810: * result, 1 is returned. If no characters are read, or there is some other
1811: * detectable error, BSTR_ERR is returned.
1812: */
1813: int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) {
1814: int c, d, e;
1815:
1816: if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
1817: b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
1818: d = 0;
1819: e = b->mlen - 2;
1820:
1821: while ((c = getcPtr (parm)) >= 0) {
1822: if (d > e) {
1823: b->slen = d;
1824: if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
1825: e = b->mlen - 2;
1826: }
1827: b->data[d] = (unsigned char) c;
1828: d++;
1829: if (c == terminator) break;
1830: }
1831:
1832: b->data[d] = (unsigned char) '\0';
1833: b->slen = d;
1834:
1835: return d == 0 && c < 0;
1836: }
1837:
1838: /* int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator)
1839: *
1840: * Use an fgetc-like single character stream reading function (getcPtr) to
1841: * obtain a sequence of characters which are concatenated to the end of the
1842: * bstring b. The stream read is terminated by the passed in terminator
1843: * parameter.
1844: *
1845: * If getcPtr returns with a negative number, or the terminator character
1846: * (which is appended) is read, then the stream reading is halted and the
1847: * function returns with a partial result concatentated to b. If there is
1848: * an empty partial result, 1 is returned. If no characters are read, or
1849: * there is some other detectable error, BSTR_ERR is returned.
1850: */
1851: int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) {
1852: int c, d, e;
1853:
1854: if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
1855: b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
1856: d = b->slen;
1857: e = b->mlen - 2;
1858:
1859: while ((c = getcPtr (parm)) >= 0) {
1860: if (d > e) {
1861: b->slen = d;
1862: if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
1863: e = b->mlen - 2;
1864: }
1865: b->data[d] = (unsigned char) c;
1866: d++;
1867: if (c == terminator) break;
1868: }
1869:
1870: b->data[d] = (unsigned char) '\0';
1871: b->slen = d;
1872:
1873: return d == 0 && c < 0;
1874: }
1875:
1876: /* bstring bgets (bNgetc getcPtr, void * parm, char terminator)
1877: *
1878: * Use an fgetc-like single character stream reading function (getcPtr) to
1879: * obtain a sequence of characters which are concatenated into a bstring.
1880: * The stream read is terminated by the passed in terminator function.
1881: *
1882: * If getcPtr returns with a negative number, or the terminator character
1883: * (which is appended) is read, then the stream reading is halted and the
1884: * result obtained thus far is returned. If no characters are read, or
1885: * there is some other detectable error, NULL is returned.
1886: */
1887: bstring bgets (bNgetc getcPtr, void * parm, char terminator) {
1888: int ret;
1889: bstring buff;
1890:
1891: if (NULL == getcPtr || NULL == (buff = bfromcstr (""))) return NULL;
1892:
1893: ret = bgetsa (buff, getcPtr, parm, terminator);
1894: if (ret < 0 || buff->slen <= 0) {
1895: bdestroy (buff);
1896: buff = NULL;
1897: }
1898: return buff;
1899: }
1900:
1901: struct bStream {
1902: bstring buff; /* Buffer for over-reads */
1903: void * parm; /* The stream handle for core stream */
1904: bNread readFnPtr; /* fread compatible fnptr for core stream */
1905: int isEOF; /* track file's EOF state */
1906: int maxBuffSz;
1907: };
1908:
1909: /* struct bStream * bsopen (bNread readPtr, void * parm)
1910: *
1911: * Wrap a given open stream (described by a fread compatible function
1912: * pointer and stream handle) into an open bStream suitable for the bstring
1913: * library streaming functions.
1914: */
1915: struct bStream * bsopen (bNread readPtr, void * parm) {
1916: struct bStream * s;
1917:
1918: if (readPtr == NULL) return NULL;
1919: s = (struct bStream *) bstr__alloc (sizeof (struct bStream));
1920: if (s == NULL) return NULL;
1921: s->parm = parm;
1922: s->buff = bfromcstr ("");
1923: s->readFnPtr = readPtr;
1924: s->maxBuffSz = BS_BUFF_SZ;
1925: s->isEOF = 0;
1926: return s;
1927: }
1928:
1929: /* int bsbufflength (struct bStream * s, int sz)
1930: *
1931: * Set the length of the buffer used by the bStream. If sz is zero, the
1932: * length is not set. This function returns with the previous length.
1933: */
1934: int bsbufflength (struct bStream * s, int sz) {
1935: int oldSz;
1936: if (s == NULL || sz < 0) return BSTR_ERR;
1937: oldSz = s->maxBuffSz;
1938: if (sz > 0) s->maxBuffSz = sz;
1939: return oldSz;
1940: }
1941:
1942: int bseof (const struct bStream * s) {
1943: if (s == NULL || s->readFnPtr == NULL) return BSTR_ERR;
1944: return s->isEOF && (s->buff->slen == 0);
1945: }
1946:
1947: /* void * bsclose (struct bStream * s)
1948: *
1949: * Close the bStream, and return the handle to the stream that was originally
1950: * used to open the given stream.
1951: */
1952: void * bsclose (struct bStream * s) {
1953: void * parm;
1954: if (s == NULL) return NULL;
1955: s->readFnPtr = NULL;
1956: if (s->buff) bdestroy (s->buff);
1957: s->buff = NULL;
1958: parm = s->parm;
1959: s->parm = NULL;
1960: s->isEOF = 1;
1961: bstr__free (s);
1962: return parm;
1963: }
1964:
1965: /* int bsreadlna (bstring r, struct bStream * s, char terminator)
1966: *
1967: * Read a bstring terminated by the terminator character or the end of the
1968: * stream from the bStream (s) and return it into the parameter r. This
1969: * function may read additional characters from the core stream that are not
1970: * returned, but will be retained for subsequent read operations.
1971: */
1972: int bsreadlna (bstring r, struct bStream * s, char terminator) {
1973: int i, l, ret, rlo;
1974: char * b;
1975: struct tagbstring x;
1976:
1977: if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 ||
1978: r->slen < 0 || r->mlen < r->slen) return BSTR_ERR;
1979: l = s->buff->slen;
1980: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
1981: b = (char *) s->buff->data;
1982: x.data = (unsigned char *) b;
1983:
1984: /* First check if the current buffer holds the terminator */
1985: b[l] = terminator; /* Set sentinel */
1986: for (i=0; b[i] != terminator; i++) ;
1987: if (i < l) {
1988: x.slen = i + 1;
1989: ret = bconcat (r, &x);
1990: s->buff->slen = l;
1991: if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
1992: return BSTR_OK;
1993: }
1994:
1995: rlo = r->slen;
1996:
1997: /* If not then just concatenate the entire buffer to the output */
1998: x.slen = l;
1999: if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
2000:
2001: /* Perform direct in-place reads into the destination to allow for
2002: the minimum of data-copies */
2003: for (;;) {
2004: if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) return BSTR_ERR;
2005: b = (char *) (r->data + r->slen);
2006: l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
2007: if (l <= 0) {
2008: r->data[r->slen] = (unsigned char) '\0';
2009: s->buff->slen = 0;
2010: s->isEOF = 1;
2011: /* If nothing was read return with an error message */
2012: return BSTR_ERR & -(r->slen == rlo);
2013: }
2014: b[l] = terminator; /* Set sentinel */
2015: for (i=0; b[i] != terminator; i++) ;
2016: if (i < l) break;
2017: r->slen += l;
2018: }
2019:
2020: /* Terminator found, push over-read back to buffer */
2021: i++;
2022: r->slen += i;
2023: s->buff->slen = l - i;
2024: bstr__memcpy (s->buff->data, b + i, l - i);
2025: r->data[r->slen] = (unsigned char) '\0';
2026: return BSTR_OK;
2027: }
2028:
2029: /* int bsreadlnsa (bstring r, struct bStream * s, bstring term)
2030: *
2031: * Read a bstring terminated by any character in the term string or the end
2032: * of the stream from the bStream (s) and return it into the parameter r.
2033: * This function may read additional characters from the core stream that
2034: * are not returned, but will be retained for subsequent read operations.
2035: */
2036: int bsreadlnsa (bstring r, struct bStream * s, const_bstring term) {
2037: int i, l, ret, rlo;
2038: unsigned char * b;
2039: struct tagbstring x;
2040: struct charField cf;
2041:
2042: if (s == NULL || s->buff == NULL || r == NULL || term == NULL ||
2043: term->data == NULL || r->mlen <= 0 || r->slen < 0 ||
2044: r->mlen < r->slen) return BSTR_ERR;
2045: if (term->slen == 1) return bsreadlna (r, s, term->data[0]);
2046: if (term->slen < 1 || buildCharField (&cf, term)) return BSTR_ERR;
2047:
2048: l = s->buff->slen;
2049: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
2050: b = (unsigned char *) s->buff->data;
2051: x.data = b;
2052:
2053: /* First check if the current buffer holds the terminator */
2054: b[l] = term->data[0]; /* Set sentinel */
2055: for (i=0; !testInCharField (&cf, b[i]); i++) ;
2056: if (i < l) {
2057: x.slen = i + 1;
2058: ret = bconcat (r, &x);
2059: s->buff->slen = l;
2060: if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
2061: return BSTR_OK;
2062: }
2063:
2064: rlo = r->slen;
2065:
2066: /* If not then just concatenate the entire buffer to the output */
2067: x.slen = l;
2068: if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
2069:
2070: /* Perform direct in-place reads into the destination to allow for
2071: the minimum of data-copies */
2072: for (;;) {
2073: if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) return BSTR_ERR;
2074: b = (unsigned char *) (r->data + r->slen);
2075: l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
2076: if (l <= 0) {
2077: r->data[r->slen] = (unsigned char) '\0';
2078: s->buff->slen = 0;
2079: s->isEOF = 1;
2080: /* If nothing was read return with an error message */
2081: return BSTR_ERR & -(r->slen == rlo);
2082: }
2083:
2084: b[l] = term->data[0]; /* Set sentinel */
2085: for (i=0; !testInCharField (&cf, b[i]); i++) ;
2086: if (i < l) break;
2087: r->slen += l;
2088: }
2089:
2090: /* Terminator found, push over-read back to buffer */
2091: i++;
2092: r->slen += i;
2093: s->buff->slen = l - i;
2094: bstr__memcpy (s->buff->data, b + i, l - i);
2095: r->data[r->slen] = (unsigned char) '\0';
2096: return BSTR_OK;
2097: }
2098:
2099: /* int bsreada (bstring r, struct bStream * s, int n)
2100: *
2101: * Read a bstring of length n (or, if it is fewer, as many bytes as is
2102: * remaining) from the bStream. This function may read additional
2103: * characters from the core stream that are not returned, but will be
2104: * retained for subsequent read operations. This function will not read
2105: * additional characters from the core stream beyond virtual stream pointer.
2106: */
2107: int bsreada (bstring r, struct bStream * s, int n) {
2108: int l, ret, orslen;
2109: char * b;
2110: struct tagbstring x;
2111:
2112: if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
2113: || r->slen < 0 || r->mlen < r->slen || n <= 0) return BSTR_ERR;
2114:
2115: n += r->slen;
2116: if (n <= 0) return BSTR_ERR;
2117:
2118: l = s->buff->slen;
2119:
2120: orslen = r->slen;
2121:
2122: if (0 == l) {
2123: if (s->isEOF) return BSTR_ERR;
2124: if (r->mlen > n) {
2125: l = (int) s->readFnPtr (r->data + r->slen, 1, n - r->slen, s->parm);
2126: if (0 >= l || l > n - r->slen) {
2127: s->isEOF = 1;
2128: return BSTR_ERR;
2129: }
2130: r->slen += l;
2131: r->data[r->slen] = (unsigned char) '\0';
2132: return 0;
2133: }
2134: }
2135:
2136: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
2137: b = (char *) s->buff->data;
2138: x.data = (unsigned char *) b;
2139:
2140: do {
2141: if (l + r->slen >= n) {
2142: x.slen = n - r->slen;
2143: ret = bconcat (r, &x);
2144: s->buff->slen = l;
2145: if (BSTR_OK == ret) bdelete (s->buff, 0, x.slen);
2146: return BSTR_ERR & -(r->slen == orslen);
2147: }
2148:
2149: x.slen = l;
2150: if (BSTR_OK != bconcat (r, &x)) break;
2151:
2152: l = n - r->slen;
2153: if (l > s->maxBuffSz) l = s->maxBuffSz;
2154:
2155: l = (int) s->readFnPtr (b, 1, l, s->parm);
2156:
2157: } while (l > 0);
2158: if (l < 0) l = 0;
2159: if (l == 0) s->isEOF = 1;
2160: s->buff->slen = l;
2161: return BSTR_ERR & -(r->slen == orslen);
2162: }
2163:
2164: /* int bsreadln (bstring r, struct bStream * s, char terminator)
2165: *
2166: * Read a bstring terminated by the terminator character or the end of the
2167: * stream from the bStream (s) and return it into the parameter r. This
2168: * function may read additional characters from the core stream that are not
2169: * returned, but will be retained for subsequent read operations.
2170: */
2171: int bsreadln (bstring r, struct bStream * s, char terminator) {
2172: if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0)
2173: return BSTR_ERR;
2174: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
2175: r->slen = 0;
2176: return bsreadlna (r, s, terminator);
2177: }
2178:
2179: /* int bsreadlns (bstring r, struct bStream * s, bstring term)
2180: *
2181: * Read a bstring terminated by any character in the term string or the end
2182: * of the stream from the bStream (s) and return it into the parameter r.
2183: * This function may read additional characters from the core stream that
2184: * are not returned, but will be retained for subsequent read operations.
2185: */
2186: int bsreadlns (bstring r, struct bStream * s, const_bstring term) {
2187: if (s == NULL || s->buff == NULL || r == NULL || term == NULL
2188: || term->data == NULL || r->mlen <= 0) return BSTR_ERR;
2189: if (term->slen == 1) return bsreadln (r, s, term->data[0]);
2190: if (term->slen < 1) return BSTR_ERR;
2191: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
2192: r->slen = 0;
2193: return bsreadlnsa (r, s, term);
2194: }
2195:
2196: /* int bsread (bstring r, struct bStream * s, int n)
2197: *
2198: * Read a bstring of length n (or, if it is fewer, as many bytes as is
2199: * remaining) from the bStream. This function may read additional
2200: * characters from the core stream that are not returned, but will be
2201: * retained for subsequent read operations. This function will not read
2202: * additional characters from the core stream beyond virtual stream pointer.
2203: */
2204: int bsread (bstring r, struct bStream * s, int n) {
2205: if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
2206: || n <= 0) return BSTR_ERR;
2207: if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
2208: r->slen = 0;
2209: return bsreada (r, s, n);
2210: }
2211:
2212: /* int bsunread (struct bStream * s, const_bstring b)
2213: *
2214: * Insert a bstring into the bStream at the current position. These
2215: * characters will be read prior to those that actually come from the core
2216: * stream.
2217: */
2218: int bsunread (struct bStream * s, const_bstring b) {
2219: if (s == NULL || s->buff == NULL) return BSTR_ERR;
2220: return binsert (s->buff, 0, b, (unsigned char) '?');
2221: }
2222:
2223: /* int bspeek (bstring r, const struct bStream * s)
2224: *
2225: * Return the currently buffered characters from the bStream that will be
2226: * read prior to reads from the core stream.
2227: */
2228: int bspeek (bstring r, const struct bStream * s) {
2229: if (s == NULL || s->buff == NULL) return BSTR_ERR;
2230: return bassign (r, s->buff);
2231: }
2232:
2233: /* bstring bjoin (const struct bstrList * bl, const_bstring sep);
2234: *
2235: * Join the entries of a bstrList into one bstring by sequentially
2236: * concatenating them with the sep string in between. If there is an error
2237: * NULL is returned, otherwise a bstring with the correct result is returned.
2238: */
2239: bstring bjoin (const struct bstrList * bl, const_bstring sep) {
2240: bstring b;
2241: int i, c, v;
2242:
2243: if (bl == NULL || bl->qty < 0) return NULL;
2244: if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL;
2245:
2246: for (i = 0, c = 1; i < bl->qty; i++) {
2247: v = bl->entry[i]->slen;
2248: if (v < 0) return NULL; /* Invalid input */
2249: c += v;
2250: if (c < 0) return NULL; /* Wrap around ?? */
2251: }
2252:
2253: if (sep != NULL) c += (bl->qty - 1) * sep->slen;
2254:
2255: b = (bstring) bstr__alloc (sizeof (struct tagbstring));
2256: if (NULL == b) return NULL; /* Out of memory */
2257: b->data = (unsigned char *) bstr__alloc (c);
2258: if (b->data == NULL) {
2259: bstr__free (b);
2260: return NULL;
2261: }
2262:
2263: b->mlen = c;
2264: b->slen = c-1;
2265:
2266: for (i = 0, c = 0; i < bl->qty; i++) {
2267: if (i > 0 && sep != NULL) {
2268: bstr__memcpy (b->data + c, sep->data, sep->slen);
2269: c += sep->slen;
2270: }
2271: v = bl->entry[i]->slen;
2272: bstr__memcpy (b->data + c, bl->entry[i]->data, v);
2273: c += v;
2274: }
2275: b->data[c] = (unsigned char) '\0';
2276: return b;
2277: }
2278:
2279: #define BSSSC_BUFF_LEN (256)
2280:
2281: /* int bssplitscb (struct bStream * s, const_bstring splitStr,
2282: * int (* cb) (void * parm, int ofs, const_bstring entry), void * parm)
2283: *
2284: * Iterate the set of disjoint sequential substrings read from a stream
2285: * divided by any of the characters in splitStr. An empty splitStr causes
2286: * the whole stream to be iterated once.
2287: *
2288: * Note: At the point of calling the cb function, the bStream pointer is
2289: * pointed exactly at the position right after having read the split
2290: * character. The cb function can act on the stream by causing the bStream
2291: * pointer to move, and bssplitscb will continue by starting the next split
2292: * at the position of the pointer after the return from cb.
2293: *
2294: * However, if the cb causes the bStream s to be destroyed then the cb must
2295: * return with a negative value, otherwise bssplitscb will continue in an
2296: * undefined manner.
2297: */
2298: int bssplitscb (struct bStream * s, const_bstring splitStr,
2299: int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
2300: struct charField chrs;
2301: bstring buff;
2302: int i, p, ret;
2303:
2304: if (cb == NULL || s == NULL || s->readFnPtr == NULL
2305: || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
2306:
2307: if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
2308:
2309: if (splitStr->slen == 0) {
2310: while (bsreada (buff, s, BSSSC_BUFF_LEN) >= 0) ;
2311: if ((ret = cb (parm, 0, buff)) > 0)
2312: ret = 0;
2313: } else {
2314: buildCharField (&chrs, splitStr);
2315: ret = p = i = 0;
2316: for (;;) {
2317: if (i >= buff->slen) {
2318: bsreada (buff, s, BSSSC_BUFF_LEN);
2319: if (i >= buff->slen) {
2320: if (0 < (ret = cb (parm, p, buff))) ret = 0;
2321: break;
2322: }
2323: }
2324: if (testInCharField (&chrs, buff->data[i])) {
2325: struct tagbstring t;
2326: unsigned char c;
2327:
2328: blk2tbstr (t, buff->data + i + 1, buff->slen - (i + 1));
2329: if ((ret = bsunread (s, &t)) < 0) break;
2330: buff->slen = i;
2331: c = buff->data[i];
2332: buff->data[i] = (unsigned char) '\0';
2333: if ((ret = cb (parm, p, buff)) < 0) break;
2334: buff->data[i] = c;
2335: buff->slen = 0;
2336: p += i + 1;
2337: i = -1;
2338: }
2339: i++;
2340: }
2341: }
2342:
2343: bdestroy (buff);
2344: return ret;
2345: }
2346:
2347: /* int bssplitstrcb (struct bStream * s, const_bstring splitStr,
2348: * int (* cb) (void * parm, int ofs, const_bstring entry), void * parm)
2349: *
2350: * Iterate the set of disjoint sequential substrings read from a stream
2351: * divided by the entire substring splitStr. An empty splitStr causes
2352: * each character of the stream to be iterated.
2353: *
2354: * Note: At the point of calling the cb function, the bStream pointer is
2355: * pointed exactly at the position right after having read the split
2356: * character. The cb function can act on the stream by causing the bStream
2357: * pointer to move, and bssplitscb will continue by starting the next split
2358: * at the position of the pointer after the return from cb.
2359: *
2360: * However, if the cb causes the bStream s to be destroyed then the cb must
2361: * return with a negative value, otherwise bssplitscb will continue in an
2362: * undefined manner.
2363: */
2364: int bssplitstrcb (struct bStream * s, const_bstring splitStr,
2365: int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
2366: bstring buff;
2367: int i, p, ret;
2368:
2369: if (cb == NULL || s == NULL || s->readFnPtr == NULL
2370: || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
2371:
2372: if (splitStr->slen == 1) return bssplitscb (s, splitStr, cb, parm);
2373:
2374: if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
2375:
2376: if (splitStr->slen == 0) {
2377: for (i=0; bsreada (buff, s, BSSSC_BUFF_LEN) >= 0; i++) {
2378: if ((ret = cb (parm, 0, buff)) < 0) {
2379: bdestroy (buff);
2380: return ret;
2381: }
2382: buff->slen = 0;
2383: }
2384: return BSTR_OK;
2385: } else {
2386: ret = p = i = 0;
2387: for (i=p=0;;) {
2388: if ((ret = binstr (buff, 0, splitStr)) >= 0) {
2389: struct tagbstring t;
2390: blk2tbstr (t, buff->data, ret);
2391: i = ret + splitStr->slen;
2392: if ((ret = cb (parm, p, &t)) < 0) break;
2393: p += i;
2394: bdelete (buff, 0, i);
2395: } else {
2396: bsreada (buff, s, BSSSC_BUFF_LEN);
2397: if (bseof (s)) {
2398: if ((ret = cb (parm, p, buff)) > 0) ret = 0;
2399: break;
2400: }
2401: }
2402: }
2403: }
2404:
2405: bdestroy (buff);
2406: return ret;
2407: }
2408:
2409: /* int bstrListCreate (void)
2410: *
2411: * Create a bstrList.
2412: */
2413: struct bstrList * bstrListCreate (void) {
2414: struct bstrList * sl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
2415: if (sl) {
2416: sl->entry = (bstring *) bstr__alloc (1*sizeof (bstring));
2417: if (!sl->entry) {
2418: bstr__free (sl);
2419: sl = NULL;
2420: } else {
2421: sl->qty = 0;
2422: sl->mlen = 1;
2423: }
2424: }
2425: return sl;
2426: }
2427:
2428: /* int bstrListDestroy (struct bstrList * sl)
2429: *
2430: * Destroy a bstrList that has been created by bsplit, bsplits or bstrListCreate.
2431: */
2432: int bstrListDestroy (struct bstrList * sl) {
2433: int i;
2434: if (sl == NULL || sl->qty < 0) return BSTR_ERR;
2435: for (i=0; i < sl->qty; i++) {
2436: if (sl->entry[i]) {
2437: bdestroy (sl->entry[i]);
2438: sl->entry[i] = NULL;
2439: }
2440: }
2441: sl->qty = -1;
2442: sl->mlen = -1;
2443: bstr__free (sl->entry);
2444: sl->entry = NULL;
2445: bstr__free (sl);
2446: return BSTR_OK;
2447: }
2448:
2449: /* int bstrListAlloc (struct bstrList * sl, int msz)
2450: *
2451: * Ensure that there is memory for at least msz number of entries for the
2452: * list.
2453: */
2454: int bstrListAlloc (struct bstrList * sl, int msz) {
2455: bstring * l;
2456: int smsz;
2457: size_t nsz;
2458: if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || sl->qty > sl->mlen) return BSTR_ERR;
2459: if (sl->mlen >= msz) return BSTR_OK;
2460: smsz = snapUpSize (msz);
2461: nsz = ((size_t) smsz) * sizeof (bstring);
2462: if (nsz < (size_t) smsz) return BSTR_ERR;
2463: l = bstr__realloc (sl->entry, nsz);
2464: if (!l) {
2465: smsz = msz;
2466: nsz = ((size_t) smsz) * sizeof (bstring);
2467: l = bstr__realloc (sl->entry, nsz);
2468: if (!l) return BSTR_ERR;
2469: }
2470: sl->mlen = smsz;
2471: sl->entry = l;
2472: return BSTR_OK;
2473: }
2474:
2475: /* int bstrListAllocMin (struct bstrList * sl, int msz)
2476: *
2477: * Try to allocate the minimum amount of memory for the list to include at
2478: * least msz entries or sl->qty whichever is greater.
2479: */
2480: int bstrListAllocMin (struct bstrList * sl, int msz) {
2481: bstring * l;
2482: size_t nsz;
2483: if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || sl->qty > sl->mlen) return BSTR_ERR;
2484: if (msz < sl->qty) msz = sl->qty;
2485: if (sl->mlen == msz) return BSTR_OK;
2486: nsz = ((size_t) msz) * sizeof (bstring);
2487: if (nsz < (size_t) msz) return BSTR_ERR;
2488: l = bstr__realloc (sl->entry, nsz);
2489: if (!l) return BSTR_ERR;
2490: sl->mlen = msz;
2491: sl->entry = l;
2492: return BSTR_OK;
2493: }
2494:
2495: /* int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
2496: * int (* cb) (void * parm, int ofs, int len), void * parm)
2497: *
2498: * Iterate the set of disjoint sequential substrings over str divided by the
2499: * character in splitChar.
2500: *
2501: * Note: Non-destructive modification of str from within the cb function
2502: * while performing this split is not undefined. bsplitcb behaves in
2503: * sequential lock step with calls to cb. I.e., after returning from a cb
2504: * that return a non-negative integer, bsplitcb continues from the position
2505: * 1 character after the last detected split character and it will halt
2506: * immediately if the length of str falls below this point. However, if the
2507: * cb function destroys str, then it *must* return with a negative value,
2508: * otherwise bsplitcb will continue in an undefined manner.
2509: */
2510: int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
2511: int (* cb) (void * parm, int ofs, int len), void * parm) {
2512: int i, p, ret;
2513:
2514: if (cb == NULL || str == NULL || pos < 0 || pos > str->slen)
2515: return BSTR_ERR;
2516:
2517: p = pos;
2518: do {
2519: for (i=p; i < str->slen; i++) {
2520: if (str->data[i] == splitChar) break;
2521: }
2522: if ((ret = cb (parm, p, i - p)) < 0) return ret;
2523: p = i + 1;
2524: } while (p <= str->slen);
2525: return BSTR_OK;
2526: }
2527:
2528: /* int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
2529: * int (* cb) (void * parm, int ofs, int len), void * parm)
2530: *
2531: * Iterate the set of disjoint sequential substrings over str divided by any
2532: * of the characters in splitStr. An empty splitStr causes the whole str to
2533: * be iterated once.
2534: *
2535: * Note: Non-destructive modification of str from within the cb function
2536: * while performing this split is not undefined. bsplitscb behaves in
2537: * sequential lock step with calls to cb. I.e., after returning from a cb
2538: * that return a non-negative integer, bsplitscb continues from the position
2539: * 1 character after the last detected split character and it will halt
2540: * immediately if the length of str falls below this point. However, if the
2541: * cb function destroys str, then it *must* return with a negative value,
2542: * otherwise bsplitscb will continue in an undefined manner.
2543: */
2544: int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
2545: int (* cb) (void * parm, int ofs, int len), void * parm) {
2546: struct charField chrs;
2547: int i, p, ret;
2548:
2549: if (cb == NULL || str == NULL || pos < 0 || pos > str->slen
2550: || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
2551: if (splitStr->slen == 0) {
2552: if ((ret = cb (parm, 0, str->slen)) > 0) ret = 0;
2553: return ret;
2554: }
2555:
2556: if (splitStr->slen == 1)
2557: return bsplitcb (str, splitStr->data[0], pos, cb, parm);
2558:
2559: buildCharField (&chrs, splitStr);
2560:
2561: p = pos;
2562: do {
2563: for (i=p; i < str->slen; i++) {
2564: if (testInCharField (&chrs, str->data[i])) break;
2565: }
2566: if ((ret = cb (parm, p, i - p)) < 0) return ret;
2567: p = i + 1;
2568: } while (p <= str->slen);
2569: return BSTR_OK;
2570: }
2571:
2572: /* int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
2573: * int (* cb) (void * parm, int ofs, int len), void * parm)
2574: *
2575: * Iterate the set of disjoint sequential substrings over str divided by the
2576: * substring splitStr. An empty splitStr causes the whole str to be
2577: * iterated once.
2578: *
2579: * Note: Non-destructive modification of str from within the cb function
2580: * while performing this split is not undefined. bsplitstrcb behaves in
2581: * sequential lock step with calls to cb. I.e., after returning from a cb
2582: * that return a non-negative integer, bsplitscb continues from the position
2583: * 1 character after the last detected split character and it will halt
2584: * immediately if the length of str falls below this point. However, if the
2585: * cb function destroys str, then it *must* return with a negative value,
2586: * otherwise bsplitscb will continue in an undefined manner.
2587: */
2588: int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
2589: int (* cb) (void * parm, int ofs, int len), void * parm) {
2590: int i, p, ret;
2591:
2592: if (cb == NULL || str == NULL || pos < 0 || pos > str->slen
2593: || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
2594:
2595: if (0 == splitStr->slen) {
2596: for (i=pos; i < str->slen; i++) {
2597: if ((ret = cb (parm, i, 1)) < 0) return ret;
2598: }
2599: return BSTR_OK;
2600: }
2601:
2602: if (splitStr->slen == 1)
2603: return bsplitcb (str, splitStr->data[0], pos, cb, parm);
2604:
2605: for (i=p=pos; i <= str->slen - splitStr->slen; i++) {
2606: if (0 == bstr__memcmp (splitStr->data, str->data + i, splitStr->slen)) {
2607: if ((ret = cb (parm, p, i - p)) < 0) return ret;
2608: i += splitStr->slen;
2609: p = i;
2610: }
2611: }
2612: if ((ret = cb (parm, p, str->slen - p)) < 0) return ret;
2613: return BSTR_OK;
2614: }
2615:
2616: struct genBstrList {
2617: bstring b;
2618: struct bstrList * bl;
2619: };
2620:
2621: static int bscb (void * parm, int ofs, int len) {
2622: struct genBstrList * g = (struct genBstrList *) parm;
2623: if (g->bl->qty >= g->bl->mlen) {
2624: int mlen = g->bl->mlen * 2;
2625: bstring * tbl;
2626:
2627: while (g->bl->qty >= mlen) {
2628: if (mlen < g->bl->mlen) return BSTR_ERR;
2629: mlen += mlen;
2630: }
2631:
2632: tbl = (bstring *) bstr__realloc (g->bl->entry, sizeof (bstring) * mlen);
2633: if (tbl == NULL) return BSTR_ERR;
2634:
2635: g->bl->entry = tbl;
2636: g->bl->mlen = mlen;
2637: }
2638:
2639: g->bl->entry[g->bl->qty] = bmidstr (g->b, ofs, len);
2640: g->bl->qty++;
2641: return BSTR_OK;
2642: }
2643:
2644: /* struct bstrList * bsplit (const_bstring str, unsigned char splitChar)
2645: *
2646: * Create an array of sequential substrings from str divided by the character
2647: * splitChar.
2648: */
2649: struct bstrList * bsplit (const_bstring str, unsigned char splitChar) {
2650: struct genBstrList g;
2651:
2652: if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
2653:
2654: g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
2655: if (g.bl == NULL) return NULL;
2656: g.bl->mlen = 4;
2657: g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
2658: if (NULL == g.bl->entry) {
2659: bstr__free (g.bl);
2660: return NULL;
2661: }
2662:
2663: g.b = (bstring) str;
2664: g.bl->qty = 0;
2665: if (bsplitcb (str, splitChar, 0, bscb, &g) < 0) {
2666: bstrListDestroy (g.bl);
2667: return NULL;
2668: }
2669: return g.bl;
2670: }
2671:
2672: /* struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr)
2673: *
2674: * Create an array of sequential substrings from str divided by the entire
2675: * substring splitStr.
2676: */
2677: struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) {
2678: struct genBstrList g;
2679:
2680: if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
2681:
2682: g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
2683: if (g.bl == NULL) return NULL;
2684: g.bl->mlen = 4;
2685: g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
2686: if (NULL == g.bl->entry) {
2687: bstr__free (g.bl);
2688: return NULL;
2689: }
2690:
2691: g.b = (bstring) str;
2692: g.bl->qty = 0;
2693: if (bsplitstrcb (str, splitStr, 0, bscb, &g) < 0) {
2694: bstrListDestroy (g.bl);
2695: return NULL;
2696: }
2697: return g.bl;
2698: }
2699:
2700: /* struct bstrList * bsplits (const_bstring str, bstring splitStr)
2701: *
2702: * Create an array of sequential substrings from str divided by any of the
2703: * characters in splitStr. An empty splitStr causes a single entry bstrList
2704: * containing a copy of str to be returned.
2705: */
2706: struct bstrList * bsplits (const_bstring str, const_bstring splitStr) {
2707: struct genBstrList g;
2708:
2709: if ( str == NULL || str->slen < 0 || str->data == NULL ||
2710: splitStr == NULL || splitStr->slen < 0 || splitStr->data == NULL)
2711: return NULL;
2712:
2713: g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
2714: if (g.bl == NULL) return NULL;
2715: g.bl->mlen = 4;
2716: g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
2717: if (NULL == g.bl->entry) {
2718: bstr__free (g.bl);
2719: return NULL;
2720: }
2721: g.b = (bstring) str;
2722: g.bl->qty = 0;
2723:
2724: if (bsplitscb (str, splitStr, 0, bscb, &g) < 0) {
2725: bstrListDestroy (g.bl);
2726: return NULL;
2727: }
2728: return g.bl;
2729: }
2730:
2731: #if defined (__TURBOC__) && !defined (__BORLANDC__)
2732: # ifndef BSTRLIB_NOVSNP
2733: # define BSTRLIB_NOVSNP
2734: # endif
2735: #endif
2736:
2737: /* Give WATCOM C/C++, MSVC some latitude for their non-support of vsnprintf */
2738: #if defined(__WATCOMC__) || defined(_MSC_VER)
2739: #define exvsnprintf(r,b,n,f,a) {r = _vsnprintf (b,n,f,a);}
2740: #else
2741: #ifdef BSTRLIB_NOVSNP
2742: /* This is just a hack. If you are using a system without a vsnprintf, it is
2743: not recommended that bformat be used at all. */
2744: #define exvsnprintf(r,b,n,f,a) {vsprintf (b,f,a); r = -1;}
2745: #define START_VSNBUFF (256)
2746: #else
2747:
2748: #ifdef __GNUC__
2749: /* Something is making gcc complain about this prototype not being here, so
2750: I've just gone ahead and put it in.
2751: extern int vsnprintf (char *buf, size_t count, const char *format, va_list arg);
2752: */
2753: #endif
2754:
2755: #define exvsnprintf(r,b,n,f,a) {r = vsnprintf (b,n,f,a);}
2756: #endif
2757: #endif
2758:
2759: #if !defined (BSTRLIB_NOVSNP)
2760:
2761: #ifndef START_VSNBUFF
2762: #define START_VSNBUFF (16)
2763: #endif
2764:
2765: /* On IRIX vsnprintf returns n-1 when the operation would overflow the target
2766: buffer, WATCOM and MSVC both return -1, while C99 requires that the
2767: returned value be exactly what the length would be if the buffer would be
2768: large enough. This leads to the idea that if the return value is larger
2769: than n, then changing n to the return value will reduce the number of
2770: iterations required. */
2771:
2772: /* int bformata (bstring b, const char * fmt, ...)
2773: *
2774: * After the first parameter, it takes the same parameters as printf (), but
2775: * rather than outputting results to stdio, it appends the results to
2776: * a bstring which contains what would have been output. Note that if there
2777: * is an early generation of a '\0' character, the bstring will be truncated
2778: * to this end point.
2779: */
2780: int bformata (bstring b, const char * fmt, ...) {
2781: va_list arglist;
2782: bstring buff;
2783: int n, r;
2784:
2785: if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0
2786: || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
2787:
2788: /* Since the length is not determinable beforehand, a search is
2789: performed using the truncating "vsnprintf" call (to avoid buffer
2790: overflows) on increasing potential sizes for the output result. */
2791:
2792: if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
2793: if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
2794: n = 1;
2795: if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
2796: }
2797:
2798: for (;;) {
2799: va_start (arglist, fmt);
2800: exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
2801: va_end (arglist);
2802:
2803: buff->data[n] = (unsigned char) '\0';
2804: buff->slen = (int) (strlen) ((char *) buff->data);
2805:
2806: if (buff->slen < n) break;
2807:
2808: if (r > n) n = r; else n += n;
2809:
2810: if (BSTR_OK != balloc (buff, n + 2)) {
2811: bdestroy (buff);
2812: return BSTR_ERR;
2813: }
2814: }
2815:
2816: r = bconcat (b, buff);
2817: bdestroy (buff);
2818: return r;
2819: }
2820:
2821: /* int bassignformat (bstring b, const char * fmt, ...)
2822: *
2823: * After the first parameter, it takes the same parameters as printf (), but
2824: * rather than outputting results to stdio, it outputs the results to
2825: * the bstring parameter b. Note that if there is an early generation of a
2826: * '\0' character, the bstring will be truncated to this end point.
2827: */
2828: int bassignformat (bstring b, const char * fmt, ...) {
2829: va_list arglist;
2830: bstring buff;
2831: int n, r;
2832:
2833: if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0
2834: || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
2835:
2836: /* Since the length is not determinable beforehand, a search is
2837: performed using the truncating "vsnprintf" call (to avoid buffer
2838: overflows) on increasing potential sizes for the output result. */
2839:
2840: if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
2841: if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
2842: n = 1;
2843: if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
2844: }
2845:
2846: for (;;) {
2847: va_start (arglist, fmt);
2848: exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
2849: va_end (arglist);
2850:
2851: buff->data[n] = (unsigned char) '\0';
2852: buff->slen = (int) (strlen) ((char *) buff->data);
2853:
2854: if (buff->slen < n) break;
2855:
2856: if (r > n) n = r; else n += n;
2857:
2858: if (BSTR_OK != balloc (buff, n + 2)) {
2859: bdestroy (buff);
2860: return BSTR_ERR;
2861: }
2862: }
2863:
2864: r = bassign (b, buff);
2865: bdestroy (buff);
2866: return r;
2867: }
2868:
2869: /* bstring bformat (const char * fmt, ...)
2870: *
2871: * Takes the same parameters as printf (), but rather than outputting results
2872: * to stdio, it forms a bstring which contains what would have been output.
2873: * Note that if there is an early generation of a '\0' character, the
2874: * bstring will be truncated to this end point.
2875: */
2876: bstring bformat (const char * fmt, ...) {
2877: va_list arglist;
2878: bstring buff;
2879: int n, r;
2880:
2881: if (fmt == NULL) return NULL;
2882:
2883: /* Since the length is not determinable beforehand, a search is
2884: performed using the truncating "vsnprintf" call (to avoid buffer
2885: overflows) on increasing potential sizes for the output result. */
2886:
2887: if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
2888: if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
2889: n = 1;
2890: if (NULL == (buff = bfromcstralloc (n + 2, ""))) return NULL;
2891: }
2892:
2893: for (;;) {
2894: va_start (arglist, fmt);
2895: exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
2896: va_end (arglist);
2897:
2898: buff->data[n] = (unsigned char) '\0';
2899: buff->slen = (int) (strlen) ((char *) buff->data);
2900:
2901: if (buff->slen < n) break;
2902:
2903: if (r > n) n = r; else n += n;
2904:
2905: if (BSTR_OK != balloc (buff, n + 2)) {
2906: bdestroy (buff);
2907: return NULL;
2908: }
2909: }
2910:
2911: return buff;
2912: }
2913:
2914: /* int bvcformata (bstring b, int count, const char * fmt, va_list arglist)
2915: *
2916: * The bvcformata function formats data under control of the format control
2917: * string fmt and attempts to append the result to b. The fmt parameter is
2918: * the same as that of the printf function. The variable argument list is
2919: * replaced with arglist, which has been initialized by the va_start macro.
2920: * The size of the output is upper bounded by count. If the required output
2921: * exceeds count, the string b is not augmented with any contents and a value
2922: * below BSTR_ERR is returned. If a value below -count is returned then it
2923: * is recommended that the negative of this value be used as an update to the
2924: * count in a subsequent pass. On other errors, such as running out of
2925: * memory, parameter errors or numeric wrap around BSTR_ERR is returned.
2926: * BSTR_OK is returned when the output is successfully generated and
2927: * appended to b.
2928: *
2929: * Note: There is no sanity checking of arglist, and this function is
2930: * destructive of the contents of b from the b->slen point onward. If there
2931: * is an early generation of a '\0' character, the bstring will be truncated
2932: * to this end point.
2933: */
2934: int bvcformata (bstring b, int count, const char * fmt, va_list arg) {
2935: int n, r, l;
2936:
2937: if (b == NULL || fmt == NULL || count <= 0 || b->data == NULL
2938: || b->mlen <= 0 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
2939:
2940: if (count > (n = b->slen + count) + 2) return BSTR_ERR;
2941: if (BSTR_OK != balloc (b, n + 2)) return BSTR_ERR;
2942:
2943: exvsnprintf (r, (char *) b->data + b->slen, count + 2, fmt, arg);
2944:
2945: /* Did the operation complete successfully within bounds? */
2946:
2947: if (n >= (l = b->slen + (int) (strlen) ((const char *) b->data + b->slen))) {
2948: b->slen = l;
2949: return BSTR_OK;
2950: }
2951:
2952: /* Abort, since the buffer was not large enough. The return value
2953: tries to help set what the retry length should be. */
2954:
2955: b->data[b->slen] = '\0';
2956: if (r > count+1) l = r; else {
2957: l = count+count;
2958: if (count > l) l = INT_MAX;
2959: }
2960: n = -l;
2961: if (n > BSTR_ERR-1) n = BSTR_ERR-1;
2962: return n;
2963: }
2964:
2965: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bstrlib.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / coova-chilli / bstring