2 * This source file is part of the bstring string library. This code was
\r
3 * written by Paul Hsieh in 2002-2008, and is covered by the BSD open source
\r
4 * license and the GPL. Refer to the accompanying documentation for details
\r
5 * on usage and license.
\r
10 * This file is the core module for implementing the bstring functions.
\r
13 #ifndef BSTRLIB_INCLUDE
\r
14 #define BSTRLIB_INCLUDE
\r
25 #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
\r
26 # if defined (__TURBOC__) && !defined (__BORLANDC__)
\r
27 # define BSTRLIB_NOVSNP
\r
31 #define BSTR_ERR (-1)
\r
33 #define BSTR_BS_BUFF_LENGTH_GET (0)
\r
35 typedef struct tagbstring * bstring;
\r
36 typedef const struct tagbstring * const_bstring;
\r
38 /* Copy functions */
\r
39 #define cstr2bstr bfromcstr
\r
40 extern bstring bfromcstr (const char * str);
\r
41 extern bstring bfromcstralloc (int mlen, const char * str);
\r
42 extern bstring blk2bstr (const void * blk, int len);
\r
43 extern char * bstr2cstr (const_bstring s, char z);
\r
44 extern int bcstrfree (char * s);
\r
45 extern bstring bstrcpy (const_bstring b1);
\r
46 extern int bassign (bstring a, const_bstring b);
\r
47 extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
\r
48 extern int bassigncstr (bstring a, const char * str);
\r
49 extern int bassignblk (bstring a, const void * s, int len);
\r
51 /* Destroy function */
\r
52 extern int bdestroy (bstring b);
\r
54 /* Space allocation hinting functions */
\r
55 extern int balloc (bstring s, int len);
\r
56 extern int ballocmin (bstring b, int len);
\r
58 /* Substring extraction */
\r
59 extern bstring bmidstr (const_bstring b, int left, int len);
\r
61 /* Various standard manipulations */
\r
62 extern int bconcat (bstring b0, const_bstring b1);
\r
63 extern int bconchar (bstring b0, char c);
\r
64 extern int bcatcstr (bstring b, const char * s);
\r
65 extern int bcatblk (bstring b, const void * s, int len);
\r
66 extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
\r
67 extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
\r
68 extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
\r
69 extern int bdelete (bstring s1, int pos, int len);
\r
70 extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
\r
71 extern int btrunc (bstring b, int n);
\r
73 /* Scan/search functions */
\r
74 extern int bstricmp (const_bstring b0, const_bstring b1);
\r
75 extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
\r
76 extern int biseqcaseless (const_bstring b0, const_bstring b1);
\r
77 extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
\r
78 extern int biseq (const_bstring b0, const_bstring b1);
\r
79 extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
\r
80 extern int biseqcstr (const_bstring b, const char * s);
\r
81 extern int biseqcstrcaseless (const_bstring b, const char * s);
\r
82 extern int bstrcmp (const_bstring b0, const_bstring b1);
\r
83 extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
\r
84 extern int binstr (const_bstring s1, int pos, const_bstring s2);
\r
85 extern int binstrr (const_bstring s1, int pos, const_bstring s2);
\r
86 extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
\r
87 extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
\r
88 extern int bstrchrp (const_bstring b, int c, int pos);
\r
89 extern int bstrrchrp (const_bstring b, int c, int pos);
\r
90 #define bstrchr(b,c) bstrchrp ((b), (c), 0)
\r
91 #define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
\r
92 extern int binchr (const_bstring b0, int pos, const_bstring b1);
\r
93 extern int binchrr (const_bstring b0, int pos, const_bstring b1);
\r
94 extern int bninchr (const_bstring b0, int pos, const_bstring b1);
\r
95 extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
\r
96 extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
\r
97 extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
\r
99 /* List of string container functions */
\r
104 extern struct bstrList * bstrListCreate (void);
\r
105 extern int bstrListDestroy (struct bstrList * sl);
\r
106 extern int bstrListAlloc (struct bstrList * sl, int msz);
\r
107 extern int bstrListAllocMin (struct bstrList * sl, int msz);
\r
109 /* String split and join functions */
\r
110 extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
\r
111 extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
\r
112 extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
\r
113 extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
\r
114 extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
\r
115 int (* cb) (void * parm, int ofs, int len), void * parm);
\r
116 extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
\r
117 int (* cb) (void * parm, int ofs, int len), void * parm);
\r
118 extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
\r
119 int (* cb) (void * parm, int ofs, int len), void * parm);
\r
121 /* Miscellaneous functions */
\r
122 extern int bpattern (bstring b, int len);
\r
123 extern int btoupper (bstring b);
\r
124 extern int btolower (bstring b);
\r
125 extern int bltrimws (bstring b);
\r
126 extern int brtrimws (bstring b);
\r
127 extern int btrimws (bstring b);
\r
129 #if !defined (BSTRLIB_NOVSNP)
\r
130 extern bstring bformat (const char * fmt, ...);
\r
131 extern int bformata (bstring b, const char * fmt, ...);
\r
132 extern int bassignformat (bstring b, const char * fmt, ...);
\r
133 extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
\r
135 #define bvformata(ret, b, fmt, lastarg) { \
\r
136 bstring bstrtmp_b = (b); \
\r
137 const char * bstrtmp_fmt = (fmt); \
\r
138 int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
\r
140 va_list bstrtmp_arglist; \
\r
141 va_start (bstrtmp_arglist, lastarg); \
\r
142 bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
\r
143 va_end (bstrtmp_arglist); \
\r
144 if (bstrtmp_r >= 0) { /* Everything went ok */ \
\r
145 bstrtmp_r = BSTR_OK; \
\r
147 } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
\r
148 bstrtmp_r = BSTR_ERR; \
\r
151 bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
\r
158 typedef int (*bNgetc) (void *parm);
\r
159 typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
\r
161 /* Input functions */
\r
162 extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
\r
163 extern bstring bread (bNread readPtr, void * parm);
\r
164 extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
\r
165 extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
\r
166 extern int breada (bstring b, bNread readPtr, void * parm);
\r
168 /* Stream functions */
\r
169 extern struct bStream * bsopen (bNread readPtr, void * parm);
\r
170 extern void * bsclose (struct bStream * s);
\r
171 extern int bsbufflength (struct bStream * s, int sz);
\r
172 extern int bsreadln (bstring b, struct bStream * s, char terminator);
\r
173 extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
\r
174 extern int bsread (bstring b, struct bStream * s, int n);
\r
175 extern int bsreadlna (bstring b, struct bStream * s, char terminator);
\r
176 extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
\r
177 extern int bsreada (bstring b, struct bStream * s, int n);
\r
178 extern int bsunread (struct bStream * s, const_bstring b);
\r
179 extern int bspeek (bstring r, const struct bStream * s);
\r
180 extern int bssplitscb (struct bStream * s, const_bstring splitStr,
\r
181 int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
\r
182 extern int bssplitstrcb (struct bStream * s, const_bstring splitStr,
\r
183 int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
\r
184 extern int bseof (const struct bStream * s);
\r
186 struct tagbstring {
\r
189 unsigned char * data;
\r
192 /* Accessor macros */
\r
193 #define blengthe(b, e) (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
\r
194 #define blength(b) (blengthe ((b), 0))
\r
195 #define bdataofse(b, o, e) (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
\r
196 #define bdataofs(b, o) (bdataofse ((b), (o), (void *)0))
\r
197 #define bdatae(b, e) (bdataofse (b, 0, e))
\r
198 #define bdata(b) (bdataofs (b, 0))
\r
199 #define bchare(b, p, e) ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
\r
200 #define bchar(b, p) bchare ((b), (p), '\0')
\r
202 /* Static constant string initialization macro */
\r
203 #define bsStaticMlen(q,m) {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
\r
204 #if defined(_MSC_VER)
\r
205 # define bsStatic(q) bsStaticMlen(q,-32)
\r
208 # define bsStatic(q) bsStaticMlen(q,-__LINE__)
\r
211 /* Static constant block parameter pair */
\r
212 #define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
\r
214 /* Reference building macros */
\r
215 #define cstr2tbstr btfromcstr
\r
216 #define btfromcstr(t,s) { \
\r
217 (t).data = (unsigned char *) (s); \
\r
218 (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
\r
221 #define blk2tbstr(t,s,l) { \
\r
222 (t).data = (unsigned char *) (s); \
\r
226 #define btfromblk(t,s,l) blk2tbstr(t,s,l)
\r
227 #define bmid2tbstr(t,b,p,l) { \
\r
228 const_bstring bstrtmp_s = (b); \
\r
229 if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) { \
\r
230 int bstrtmp_left = (p); \
\r
231 int bstrtmp_len = (l); \
\r
232 if (bstrtmp_left < 0) { \
\r
233 bstrtmp_len += bstrtmp_left; \
\r
234 bstrtmp_left = 0; \
\r
236 if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left) \
\r
237 bstrtmp_len = bstrtmp_s->slen - bstrtmp_left; \
\r
238 if (bstrtmp_len <= 0) { \
\r
239 (t).data = (unsigned char *)""; \
\r
242 (t).data = bstrtmp_s->data + bstrtmp_left; \
\r
243 (t).slen = bstrtmp_len; \
\r
246 (t).data = (unsigned char *)""; \
\r
249 (t).mlen = -__LINE__; \
\r
251 #define btfromblkltrimws(t,s,l) { \
\r
252 int bstrtmp_idx = 0, bstrtmp_len = (l); \
\r
253 unsigned char * bstrtmp_s = (s); \
\r
254 if (bstrtmp_s && bstrtmp_len >= 0) { \
\r
255 for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) { \
\r
256 if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \
\r
259 (t).data = bstrtmp_s + bstrtmp_idx; \
\r
260 (t).slen = bstrtmp_len - bstrtmp_idx; \
\r
261 (t).mlen = -__LINE__; \
\r
263 #define btfromblkrtrimws(t,s,l) { \
\r
264 int bstrtmp_len = (l) - 1; \
\r
265 unsigned char * bstrtmp_s = (s); \
\r
266 if (bstrtmp_s && bstrtmp_len >= 0) { \
\r
267 for (; bstrtmp_len >= 0; bstrtmp_len--) { \
\r
268 if (!isspace (bstrtmp_s[bstrtmp_len])) break; \
\r
271 (t).data = bstrtmp_s; \
\r
272 (t).slen = bstrtmp_len + 1; \
\r
273 (t).mlen = -__LINE__; \
\r
275 #define btfromblktrimws(t,s,l) { \
\r
276 int bstrtmp_idx = 0, bstrtmp_len = (l) - 1; \
\r
277 unsigned char * bstrtmp_s = (s); \
\r
278 if (bstrtmp_s && bstrtmp_len >= 0) { \
\r
279 for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) { \
\r
280 if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \
\r
282 for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) { \
\r
283 if (!isspace (bstrtmp_s[bstrtmp_len])) break; \
\r
286 (t).data = bstrtmp_s + bstrtmp_idx; \
\r
287 (t).slen = bstrtmp_len + 1 - bstrtmp_idx; \
\r
288 (t).mlen = -__LINE__; \
\r
291 /* Write protection macros */
\r
292 #define bwriteprotect(t) { if ((t).mlen >= 0) (t).mlen = -1; }
\r
293 #define bwriteallow(t) { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
\r
294 #define biswriteprotected(t) ((t).mlen <= 0)
\r