1 /*
2  * This source file has had its exported symbols prefixed with _al_ or _AL_
3  * for the Allegro project.
4  */
5 
6 /*
7  * This source file is part of the _al_bstring string library.  This code was
8  * written by Paul Hsieh in 2002-2008, and is covered by the BSD open source
9  * license and the GPL. Refer to the accompanying documentation for details
10  * on usage and license.
11  */
12 
13 /*
14  * bstrlib.c
15  *
16  * This file is the core module for implementing the _al_bstring functions.
17  */
18 
19 #ifndef _AL_BSTRLIB_INCLUDE
20 #define _AL_BSTRLIB_INCLUDE
21 
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25 
26 #include <stdarg.h>
27 #include <string.h>
28 #include <limits.h>
29 #include <ctype.h>
30 
31 #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
32 # if defined (__TURBOC__) && !defined (__BORLANDC__)
33 #  define BSTRLIB_NOVSNP
34 # endif
35 #endif
36 
37 #define _AL_BSTR_ERR (-1)
38 #define _AL_BSTR_OK (0)
39 #define _AL_BSTR_BS_BUFF_LENGTH_GET (0)
40 
41 typedef struct _al_tagbstring * _al_bstring;
42 typedef const struct _al_tagbstring * _al_const_bstring;
43 
44 /* Copy functions */
45 #define _al_cstr2bstr _al_bfromcstr
46 extern _al_bstring _al_bfromcstr (const char * str);
47 extern _al_bstring _al_bfromcstralloc (int mlen, const char * str);
48 extern _al_bstring _al_blk2bstr (const void * blk, int len);
49 extern char * _al_bstr2cstr (_al_const_bstring s, char z);
50 extern int _al_bcstrfree (char * s);
51 extern _al_bstring _al_bstrcpy (_al_const_bstring b1);
52 extern int _al_bassign (_al_bstring a, _al_const_bstring b);
53 extern int _al_bassignmidstr (_al_bstring a, _al_const_bstring b, int left, int len);
54 extern int _al_bassigncstr (_al_bstring a, const char * str);
55 extern int _al_bassignblk (_al_bstring a, const void * s, int len);
56 
57 /* Destroy function */
58 extern int _al_bdestroy (_al_bstring b);
59 
60 /* Space allocation hinting functions */
61 extern int _al_balloc (_al_bstring s, int len);
62 extern int _al_ballocmin (_al_bstring b, int len);
63 
64 /* Substring extraction */
65 extern _al_bstring _al_bmidstr (_al_const_bstring b, int left, int len);
66 
67 /* Various standard manipulations */
68 extern int _al_bconcat (_al_bstring b0, _al_const_bstring b1);
69 extern int _al_bconchar (_al_bstring b0, char c);
70 extern int _al_bcatcstr (_al_bstring b, const char * s);
71 extern int _al_bcatblk (_al_bstring b, const void * s, int len);
72 extern int _al_binsert (_al_bstring s1, int pos, _al_const_bstring s2, unsigned char fill);
73 extern int _al_binsertch (_al_bstring s1, int pos, int len, unsigned char fill);
74 extern int _al_breplace (_al_bstring b1, int pos, int len, _al_const_bstring b2, unsigned char fill);
75 extern int _al_bdelete (_al_bstring s1, int pos, int len);
76 extern int _al_bsetstr (_al_bstring b0, int pos, _al_const_bstring b1, unsigned char fill);
77 extern int _al_btrunc (_al_bstring b, int n);
78 
79 /* Scan/search functions */
80 extern int _al_bstricmp (_al_const_bstring b0, _al_const_bstring b1);
81 extern int _al_bstrnicmp (_al_const_bstring b0, _al_const_bstring b1, int n);
82 extern int _al_biseqcaseless (_al_const_bstring b0, _al_const_bstring b1);
83 extern int _al_bisstemeqcaselessblk (_al_const_bstring b0, const void * blk, int len);
84 extern int _al_biseq (_al_const_bstring b0, _al_const_bstring b1);
85 extern int _al_bisstemeqblk (_al_const_bstring b0, const void * blk, int len);
86 extern int _al_biseqcstr (_al_const_bstring b, const char * s);
87 extern int _al_biseqcstrcaseless (_al_const_bstring b, const char * s);
88 extern int _al_bstrcmp (_al_const_bstring b0, _al_const_bstring b1);
89 extern int _al_bstrncmp (_al_const_bstring b0, _al_const_bstring b1, int n);
90 extern int _al_binstr (_al_const_bstring s1, int pos, _al_const_bstring s2);
91 extern int _al_binstrr (_al_const_bstring s1, int pos, _al_const_bstring s2);
92 extern int _al_binstrcaseless (_al_const_bstring s1, int pos, _al_const_bstring s2);
93 extern int _al_binstrrcaseless (_al_const_bstring s1, int pos, _al_const_bstring s2);
94 extern int _al_bstrchrp (_al_const_bstring b, int c, int pos);
95 extern int _al_bstrrchrp (_al_const_bstring b, int c, int pos);
96 #define _al_bstrchr(b,c) _al_bstrchrp ((b), (c), 0)
97 #define _al_bstrrchr(b,c) _al_bstrrchrp ((b), (c), _al_blength(b)-1)
98 extern int _al_binchr (_al_const_bstring b0, int pos, _al_const_bstring b1);
99 extern int _al_binchrr (_al_const_bstring b0, int pos, _al_const_bstring b1);
100 extern int _al_bninchr (_al_const_bstring b0, int pos, _al_const_bstring b1);
101 extern int _al_bninchrr (_al_const_bstring b0, int pos, _al_const_bstring b1);
102 extern int _al_bfindreplace (_al_bstring b, _al_const_bstring find, _al_const_bstring repl, int pos);
103 extern int _al_bfindreplacecaseless (_al_bstring b, _al_const_bstring find, _al_const_bstring repl, int pos);
104 
105 /* List of string container functions */
106 struct _al_bstrList {
107     int qty, mlen;
108     _al_bstring * entry;
109 };
110 extern struct _al_bstrList * _al_bstrListCreate (void);
111 extern int _al_bstrListDestroy (struct _al_bstrList * sl);
112 extern int _al_bstrListAlloc (struct _al_bstrList * sl, int msz);
113 extern int _al_bstrListAllocMin (struct _al_bstrList * sl, int msz);
114 
115 /* String split and join functions */
116 extern struct _al_bstrList * _al_bsplit (_al_const_bstring str, unsigned char splitChar);
117 extern struct _al_bstrList * _al_bsplits (_al_const_bstring str, _al_const_bstring splitStr);
118 extern struct _al_bstrList * _al_bsplitstr (_al_const_bstring str, _al_const_bstring splitStr);
119 extern _al_bstring _al_bjoin (const struct _al_bstrList * bl, _al_const_bstring sep);
120 extern int _al_bsplitcb (_al_const_bstring str, unsigned char splitChar, int pos,
121 	int (* cb) (void * parm, int ofs, int len), void * parm);
122 extern int _al_bsplitscb (_al_const_bstring str, _al_const_bstring splitStr, int pos,
123 	int (* cb) (void * parm, int ofs, int len), void * parm);
124 extern int _al_bsplitstrcb (_al_const_bstring str, _al_const_bstring splitStr, int pos,
125 	int (* cb) (void * parm, int ofs, int len), void * parm);
126 
127 /* Miscellaneous functions */
128 extern int _al_bpattern (_al_bstring b, int len);
129 extern int _al_btoupper (_al_bstring b);
130 extern int _al_btolower (_al_bstring b);
131 extern int _al_bltrimws (_al_bstring b);
132 extern int _al_brtrimws (_al_bstring b);
133 extern int _al_btrimws (_al_bstring b);
134 
135 #if !defined (BSTRLIB_NOVSNP)
136 extern _al_bstring _al_bformat (const char * fmt, ...);
137 extern int _al_bformata (_al_bstring b, const char * fmt, ...);
138 extern int _al_bassignformat (_al_bstring b, const char * fmt, ...);
139 extern int _al_bvcformata (_al_bstring b, int count, const char * fmt, va_list arglist);
140 
141 #define _al_bvformata(ret, b, fmt, lastarg) { \
142 _al_bstring bstrtmp_b = (b); \
143 const char * bstrtmp_fmt = (fmt); \
144 int bstrtmp_r = _AL_BSTR_ERR, bstrtmp_sz = 16; \
145 	for (;;) { \
146 		va_list bstrtmp_arglist; \
147 		va_start (bstrtmp_arglist, lastarg); \
148 		bstrtmp_r = _al_bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
149 		va_end (bstrtmp_arglist); \
150 		if (bstrtmp_r >= 0) { /* Everything went ok */ \
151 			bstrtmp_r = _AL_BSTR_OK; \
152 			break; \
153 		} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
154 			bstrtmp_r = _AL_BSTR_ERR; \
155 			break; \
156 		} \
157 		bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
158 	} \
159 	ret = bstrtmp_r; \
160 }
161 
162 #endif
163 
164 typedef int (*_al_bNgetc) (void *parm);
165 typedef size_t (* _al_bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
166 
167 /* Input functions */
168 extern _al_bstring _al_bgets (_al_bNgetc getcPtr, void * parm, char terminator);
169 extern _al_bstring _al_bread (_al_bNread readPtr, void * parm);
170 extern int _al_bgetsa (_al_bstring b, _al_bNgetc getcPtr, void * parm, char terminator);
171 extern int _al_bassigngets (_al_bstring b, _al_bNgetc getcPtr, void * parm, char terminator);
172 extern int _al_breada (_al_bstring b, _al_bNread readPtr, void * parm);
173 
174 /* Stream functions */
175 extern struct _al_bStream * _al_bsopen (_al_bNread readPtr, void * parm);
176 extern void * _al_bsclose (struct _al_bStream * s);
177 extern int _al_bsbufflength (struct _al_bStream * s, int sz);
178 extern int _al_bsreadln (_al_bstring b, struct _al_bStream * s, char terminator);
179 extern int _al_bsreadlns (_al_bstring r, struct _al_bStream * s, _al_const_bstring term);
180 extern int _al_bsread (_al_bstring b, struct _al_bStream * s, int n);
181 extern int _al_bsreadlna (_al_bstring b, struct _al_bStream * s, char terminator);
182 extern int _al_bsreadlnsa (_al_bstring r, struct _al_bStream * s, _al_const_bstring term);
183 extern int _al_bsreada (_al_bstring b, struct _al_bStream * s, int n);
184 extern int _al_bsunread (struct _al_bStream * s, _al_const_bstring b);
185 extern int _al_bspeek (_al_bstring r, const struct _al_bStream * s);
186 extern int _al_bssplitscb (struct _al_bStream * s, _al_const_bstring splitStr,
187 	int (* cb) (void * parm, int ofs, _al_const_bstring entry), void * parm);
188 extern int _al_bssplitstrcb (struct _al_bStream * s, _al_const_bstring splitStr,
189 	int (* cb) (void * parm, int ofs, _al_const_bstring entry), void * parm);
190 extern int _al_bseof (const struct _al_bStream * s);
191 
192 #ifndef __al_tagbstring_defined
193 #define __al_tagbstring_defined
194 struct _al_tagbstring {
195 	int mlen;
196 	int slen;
197 	unsigned char * data;
198 };
199 #endif
200 
201 /* Accessor macros */
202 #define _al_blengthe(b, e)      (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
203 #define _al_blength(b)          (_al_blengthe ((b), 0))
204 #define _al_bdataofse(b, o, e)  (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
205 #define _al_bdataofs(b, o)      (_al_bdataofse ((b), (o), (void *)0))
206 #define _al_bdatae(b, e)        (_al_bdataofse (b, 0, e))
207 #define _al_bdata(b)            (_al_bdataofs (b, 0))
208 #define _al_bchare(b, p, e)     ((((unsigned)(p)) < (unsigned)_al_blength(b)) ? ((b)->data[(p)]) : (e))
209 #define _al_bchar(b, p)         _al_bchare ((b), (p), '\0')
210 
211 /* Static constant string initialization macro */
212 #define _al_bsStaticMlen(q,m)   {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
213 #if defined(_MSC_VER)
214 # define _al_bsStatic(q)        _al_bsStaticMlen(q,-32)
215 #endif
216 #ifndef _al_bsStatic
217 # define _al_bsStatic(q)        _al_bsStaticMlen(q,-__LINE__)
218 #endif
219 
220 /* Static constant block parameter pair */
221 #define _al_bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
222 
223 /* Reference building macros */
224 #define _al_cstr2tbstr _al_btfromcstr
225 #define _al_btfromcstr(t,s) {                                            \
226     (t).data = (unsigned char *) (s);                                \
227     (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
228     (t).mlen = -1;                                                   \
229 }
230 #define _al_blk2tbstr(t,s,l) {            \
231     (t).data = (unsigned char *) (s); \
232     (t).slen = l;                     \
233     (t).mlen = -1;                    \
234 }
235 #define _al_btfromblk(t,s,l) _al_blk2tbstr(t,s,l)
236 #define _al_bmid2tbstr(t,b,p,l) {                                                \
237     _al_const_bstring bstrtmp_s = (b);                                           \
238     if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {              \
239         int bstrtmp_left = (p);                                              \
240         int bstrtmp_len  = (l);                                              \
241         if (bstrtmp_left < 0) {                                              \
242             bstrtmp_len += bstrtmp_left;                                     \
243             bstrtmp_left = 0;                                                \
244         }                                                                    \
245         if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                    \
246             bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                    \
247         if (bstrtmp_len <= 0) {                                              \
248             (t).data = (unsigned char *)"";                                  \
249             (t).slen = 0;                                                    \
250         } else {                                                             \
251             (t).data = bstrtmp_s->data + bstrtmp_left;                       \
252             (t).slen = bstrtmp_len;                                          \
253         }                                                                    \
254     } else {                                                                 \
255         (t).data = (unsigned char *)"";                                      \
256         (t).slen = 0;                                                        \
257     }                                                                        \
258     (t).mlen = -__LINE__;                                                    \
259 }
260 #define _al_btfromblkltrimws(t,s,l) {                                            \
261     int bstrtmp_idx = 0, bstrtmp_len = (l);                                  \
262     unsigned char * bstrtmp_s = (s);                                         \
263     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
264         for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                   \
265             if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
266         }                                                                    \
267     }                                                                        \
268     (t).data = bstrtmp_s + bstrtmp_idx;                                      \
269     (t).slen = bstrtmp_len - bstrtmp_idx;                                    \
270     (t).mlen = -__LINE__;                                                    \
271 }
272 #define _al_btfromblkrtrimws(t,s,l) {                                            \
273     int bstrtmp_len = (l) - 1;                                               \
274     unsigned char * bstrtmp_s = (s);                                         \
275     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
276         for (; bstrtmp_len >= 0; bstrtmp_len--) {                            \
277             if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
278         }                                                                    \
279     }                                                                        \
280     (t).data = bstrtmp_s;                                                    \
281     (t).slen = bstrtmp_len + 1;                                              \
282     (t).mlen = -__LINE__;                                                    \
283 }
284 #define _al_btfromblktrimws(t,s,l) {                                             \
285     int bstrtmp_idx = 0, bstrtmp_len = (l) - 1;                              \
286     unsigned char * bstrtmp_s = (s);                                         \
287     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
288         for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                  \
289             if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
290         }                                                                    \
291         for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \
292             if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
293         }                                                                    \
294     }                                                                        \
295     (t).data = bstrtmp_s + bstrtmp_idx;                                      \
296     (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \
297     (t).mlen = -__LINE__;                                                    \
298 }
299 
300 /* Write protection macros */
301 #define _al_bwriteprotect(t)     { if ((t).mlen >=  0) (t).mlen = -1; }
302 #define _al_bwriteallow(t)       { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
303 #define _al_biswriteprotected(t) ((t).mlen <= 0)
304 
305 #ifdef __cplusplus
306 }
307 #endif
308 
309 #endif
310