aboutsummaryrefslogtreecommitdiff
path: root/src/bstrlib.h
blob: c8fa6944958b5d2a82f2e2d3e0c31307b091f04c (plain) 
    

  1. /*
    2. 

  2.  * This source file is part of the bstring string library.  This code was
    3. 

  3.  * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
    4. 

  4.  * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
    5. 

  5.  * for details on usage and license.
    6. 

  6.  */
    7. 

  7. 

  8. /*
    9. 

  9.  * bstrlib.h
    10. 

  10.  *
    11. 

  11.  * This file is the header file for the core module for implementing the 
    12. 

  12.  * bstring functions.
    13. 

  13.  */
    14. 

  14. 

  15. #ifndef BSTRLIB_INCLUDE
    16. 

  16. #define BSTRLIB_INCLUDE
    17. 

  17. 

  18. #ifdef __cplusplus
    19. 

  19. extern "C" {
    20. 

  20. #endif
    21. 

  21. 

  22. #include <stdarg.h>
    23. 

  23. #include <string.h>
    24. 

  24. #include <limits.h>
    25. 

  25. #include <ctype.h>
    26. 

  26. 

  27. #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
    28. 

  28. # if defined (__TURBOC__) && !defined (__BORLANDC__)
    29. 

  29. #  define BSTRLIB_NOVSNP
    30. 

  30. # endif
    31. 

  31. #endif
    32. 

  32. 

  33. #define BSTR_ERR (-1)
    34. 

  34. #define BSTR_OK (0)
    35. 

  35. #define BSTR_BS_BUFF_LENGTH_GET (0)
    36. 

  36. 

  37. typedef struct tagbstring * bstring;
    38. 

  38. typedef const struct tagbstring * const_bstring;
    39. 

  39. 

  40. /* Copy functions */
    41. 

  41. #define cstr2bstr bfromcstr
    42. 

  42. extern bstring bfromcstr (const char * str);
    43. 

  43. extern bstring bfromcstralloc (int mlen, const char * str);
    44. 

  44. extern bstring blk2bstr (const void * blk, int len);
    45. 

  45. extern char * bstr2cstr (const_bstring s, char z);
    46. 

  46. extern int bcstrfree (char * s);
    47. 

  47. extern bstring bstrcpy (const_bstring b1);
    48. 

  48. extern int bassign (bstring a, const_bstring b);
    49. 

  49. extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
    50. 

  50. extern int bassigncstr (bstring a, const char * str);
    51. 

  51. extern int bassignblk (bstring a, const void * s, int len);
    52. 

  52. 

  53. /* Destroy function */
    54. 

  54. extern int bdestroy (bstring b);
    55. 

  55. 

  56. /* Space allocation hinting functions */
    57. 

  57. extern int balloc (bstring s, int len);
    58. 

  58. extern int ballocmin (bstring b, int len);
    59. 

  59. 

  60. /* Substring extraction */
    61. 

  61. extern bstring bmidstr (const_bstring b, int left, int len);
    62. 

  62. 

  63. /* Various standard manipulations */
    64. 

  64. extern int bconcat (bstring b0, const_bstring b1);
    65. 

  65. extern int bconchar (bstring b0, char c);
    66. 

  66. extern int bcatcstr (bstring b, const char * s);
    67. 

  67. extern int bcatblk (bstring b, const void * s, int len);
    68. 

  68. extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
    69. 

  69. extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
    70. 

  70. extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
    71. 

  71. extern int bdelete (bstring s1, int pos, int len);
    72. 

  72. extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
    73. 

  73. extern int btrunc (bstring b, int n);
    74. 

  74. 

  75. /* Scan/search functions */
    76. 

  76. extern int bstricmp (const_bstring b0, const_bstring b1);
    77. 

  77. extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
    78. 

  78. extern int biseqcaseless (const_bstring b0, const_bstring b1);
    79. 

  79. extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
    80. 

  80. extern int biseq (const_bstring b0, const_bstring b1);
    81. 

  81. extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
    82. 

  82. extern int biseqcstr (const_bstring b, const char * s);
    83. 

  83. extern int biseqcstrcaseless (const_bstring b, const char * s);
    84. 

  84. extern int bstrcmp (const_bstring b0, const_bstring b1);
    85. 

  85. extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
    86. 

  86. extern int binstr (const_bstring s1, int pos, const_bstring s2);
    87. 

  87. extern int binstrr (const_bstring s1, int pos, const_bstring s2);
    88. 

  88. extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
    89. 

  89. extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
    90. 

  90. extern int bstrchrp (const_bstring b, int c, int pos);
    91. 

  91. extern int bstrrchrp (const_bstring b, int c, int pos);
    92. 

  92. #define bstrchr(b,c) bstrchrp ((b), (c), 0)
    93. 

  93. #define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
    94. 

  94. extern int binchr (const_bstring b0, int pos, const_bstring b1);
    95. 

  95. extern int binchrr (const_bstring b0, int pos, const_bstring b1);
    96. 

  96. extern int bninchr (const_bstring b0, int pos, const_bstring b1);
    97. 

  97. extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
    98. 

  98. extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
    99. 

  99. extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
    100. 

  100. 

  101. /* List of string container functions */
    102. 

  102. struct bstrList {
    103. 

  103.     int qty, mlen;
    104. 

  104.     bstring * entry;
    105. 

  105. };
    106. 

  106. extern struct bstrList * bstrListCreate (void);
    107. 

  107. extern int bstrListDestroy (struct bstrList * sl);
    108. 

  108. extern int bstrListAlloc (struct bstrList * sl, int msz);
    109. 

  109. extern int bstrListAllocMin (struct bstrList * sl, int msz);
    110. 

  110. 

  111. /* String split and join functions */
    112. 

  112. extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
    113. 

  113. extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
    114. 

  114. extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
    115. 

  115. extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
    116. 

  116. extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
    117. 

  117.     int (* cb) (void * parm, int ofs, int len), void * parm);
    118. 

  118. extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
    119. 

  119.     int (* cb) (void * parm, int ofs, int len), void * parm);
    120. 

  120. extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
    121. 

  121.     int (* cb) (void * parm, int ofs, int len), void * parm);
    122. 

  122. 

  123. /* Miscellaneous functions */
    124. 

  124. extern int bpattern (bstring b, int len);
    125. 

  125. extern int btoupper (bstring b);
    126. 

  126. extern int btolower (bstring b);
    127. 

  127. extern int bltrimws (bstring b);
    128. 

  128. extern int brtrimws (bstring b);
    129. 

  129. extern int btrimws (bstring b);
    130. 

  130. 

  131. /* <*>printf format functions */
    132. 

  132. #if !defined (BSTRLIB_NOVSNP)
    133. 

  133. extern bstring bformat (const char * fmt, ...);
    134. 

  134. extern int bformata (bstring b, const char * fmt, ...);
    135. 

  135. extern int bassignformat (bstring b, const char * fmt, ...);
    136. 

  136. extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
    137. 

  137. 

  138. #define bvformata(ret, b, fmt, lastarg) { \
    139. 

  139. bstring bstrtmp_b = (b); \
    140. 

  140. const char * bstrtmp_fmt = (fmt); \
    141. 

  141. int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
    142. 

  142.     for (;;) { \
    143. 

  143.         va_list bstrtmp_arglist; \
    144. 

  144.         va_start (bstrtmp_arglist, lastarg); \
    145. 

  145.         bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
    146. 

  146.         va_end (bstrtmp_arglist); \
    147. 

  147.         if (bstrtmp_r >= 0) { /* Everything went ok */ \
    148. 

  148.             bstrtmp_r = BSTR_OK; \
    149. 

  149.             break; \
    150. 

  150.         } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
    151. 

  151.             bstrtmp_r = BSTR_ERR; \
    152. 

  152.             break; \
    153. 

  153.         } \
    154. 

  154.         bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
    155. 

  155.     } \
    156. 

  156.     ret = bstrtmp_r; \
    157. 

  157. }
    158. 

  158. 

  159. #endif
    160. 

  160. 

  161. typedef int (*bNgetc) (void *parm);
    162. 

  162. typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
    163. 

  163. 

  164. /* Input functions */
    165. 

  165. extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
    166. 

  166. extern bstring bread (bNread readPtr, void * parm);
    167. 

  167. extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
    168. 

  168. extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
    169. 

  169. extern int breada (bstring b, bNread readPtr, void * parm);
    170. 

  170. 

  171. /* Stream functions */
    172. 

  172. extern struct bStream * bsopen (bNread readPtr, void * parm);
    173. 

  173. extern void * bsclose (struct bStream * s);
    174. 

  174. extern int bsbufflength (struct bStream * s, int sz);
    175. 

  175. extern int bsreadln (bstring b, struct bStream * s, char terminator);
    176. 

  176. extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
    177. 

  177. extern int bsread (bstring b, struct bStream * s, int n);
    178. 

  178. extern int bsreadlna (bstring b, struct bStream * s, char terminator);
    179. 

  179. extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
    180. 

  180. extern int bsreada (bstring b, struct bStream * s, int n);
    181. 

  181. extern int bsunread (struct bStream * s, const_bstring b);
    182. 

  182. extern int bspeek (bstring r, const struct bStream * s);
    183. 

  183. extern int bssplitscb (struct bStream * s, const_bstring splitStr, 
    184. 

  184.     int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
    185. 

  185. extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
    186. 

  186.     int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
    187. 

  187. extern int bseof (const struct bStream * s);
    188. 

  188. 

  189. struct tagbstring {
    190. 

  190.     int mlen;
    191. 

  191.     int slen;
    192. 

  192.     unsigned char * data;
    193. 

  193. };
    194. 

  194. 

  195. /* Accessor macros */
    196. 

  196. #define blengthe(b, e)      (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
    197. 

  197. #define blength(b)          (blengthe ((b), 0))
    198. 

  198. #define bdataofse(b, o, e)  (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
    199. 

  199. #define bdataofs(b, o)      (bdataofse ((b), (o), (void *)0))
    200. 

  200. #define bdatae(b, e)        (bdataofse (b, 0, e))
    201. 

  201. #define bdata(b)            (bdataofs (b, 0))
    202. 

  202. #define bchare(b, p, e)     ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
    203. 

  203. #define bchar(b, p)         bchare ((b), (p), '\0')
    204. 

  204. 

  205. /* Static constant string initialization macro */
    206. 

  206. #define bsStaticMlen(q,m)   {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
    207. 

  207. #if defined(_MSC_VER)
    208. 

  208. /* There are many versions of MSVC which emit __LINE__ as a non-constant. */
    209. 

  209. # define bsStatic(q)        bsStaticMlen(q,-32)
    210. 

  210. #endif
    211. 

  211. #ifndef bsStatic
    212. 

  212. # define bsStatic(q)        bsStaticMlen(q,-__LINE__)
    213. 

  213. #endif
    214. 

  214. 

  215. /* Static constant block parameter pair */
    216. 

  216. #define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
    217. 

  217. 

  218. /* Reference building macros */
    219. 

  219. #define cstr2tbstr btfromcstr
    220. 

  220. #define btfromcstr(t,s) {                                            \
    221. 

  221.     (t).data = (unsigned char *) (s);                                \
    222. 

  222.     (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
    223. 

  223.     (t).mlen = -1;                                                   \
    224. 

  224. }
    225. 

  225. #define blk2tbstr(t,s,l) {            \
    226. 

  226.     (t).data = (unsigned char *) (s); \
    227. 

  227.     (t).slen = l;                     \
    228. 

  228.     (t).mlen = -1;                    \
    229. 

  229. }
    230. 

  230. #define btfromblk(t,s,l) blk2tbstr(t,s,l)
    231. 

  231. #define bmid2tbstr(t,b,p,l) {                                                \
    232. 

  232.     const_bstring bstrtmp_s = (b);                                           \
    233. 

  233.     if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {              \
    234. 

  234.         int bstrtmp_left = (p);                                              \
    235. 

  235.         int bstrtmp_len  = (l);                                              \
    236. 

  236.         if (bstrtmp_left < 0) {                                              \
    237. 

  237.             bstrtmp_len += bstrtmp_left;                                     \
    238. 

  238.             bstrtmp_left = 0;                                                \
    239. 

  239.         }                                                                    \
    240. 

  240.         if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                    \
    241. 

  241.             bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                    \
    242. 

  242.         if (bstrtmp_len <= 0) {                                              \
    243. 

  243.             (t).data = (unsigned char *)"";                                  \
    244. 

  244.             (t).slen = 0;                                                    \
    245. 

  245.         } else {                                                             \
    246. 

  246.             (t).data = bstrtmp_s->data + bstrtmp_left;                       \
    247. 

  247.             (t).slen = bstrtmp_len;                                          \
    248. 

  248.         }                                                                    \
    249. 

  249.     } else {                                                                 \
    250. 

  250.         (t).data = (unsigned char *)"";                                      \
    251. 

  251.         (t).slen = 0;                                                        \
    252. 

  252.     }                                                                        \
    253. 

  253.     (t).mlen = -__LINE__;                                                    \
    254. 

  254. }
    255. 

  255. #define btfromblkltrimws(t,s,l) {                                            \
    256. 

  256.     int bstrtmp_idx = 0, bstrtmp_len = (l);                                  \
    257. 

  257.     unsigned char * bstrtmp_s = (s);                                         \
    258. 

  258.     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
    259. 

  259.         for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                   \
    260. 

  260.             if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
    261. 

  261.         }                                                                    \
    262. 

  262.     }                                                                        \
    263. 

  263.     (t).data = bstrtmp_s + bstrtmp_idx;                                      \
    264. 

  264.     (t).slen = bstrtmp_len - bstrtmp_idx;                                    \
    265. 

  265.     (t).mlen = -__LINE__;                                                    \
    266. 

  266. }
    267. 

  267. #define btfromblkrtrimws(t,s,l) {                                            \
    268. 

  268.     int bstrtmp_len = (l) - 1;                                               \
    269. 

  269.     unsigned char * bstrtmp_s = (s);                                         \
    270. 

  270.     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
    271. 

  271.         for (; bstrtmp_len >= 0; bstrtmp_len--) {                            \
    272. 

  272.             if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
    273. 

  273.         }                                                                    \
    274. 

  274.     }                                                                        \
    275. 

  275.     (t).data = bstrtmp_s;                                                    \
    276. 

  276.     (t).slen = bstrtmp_len + 1;                                              \
    277. 

  277.     (t).mlen = -__LINE__;                                                    \
    278. 

  278. }
    279. 

  279. #define btfromblktrimws(t,s,l) {                                             \
    280. 

  280.     int bstrtmp_idx = 0, bstrtmp_len = (l) - 1;                              \
    281. 

  281.     unsigned char * bstrtmp_s = (s);                                         \
    282. 

  282.     if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
    283. 

  283.         for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                  \
    284. 

  284.             if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
    285. 

  285.         }                                                                    \
    286. 

  286.         for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \
    287. 

  287.             if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
    288. 

  288.         }                                                                    \
    289. 

  289.     }                                                                        \
    290. 

  290.     (t).data = bstrtmp_s + bstrtmp_idx;                                      \
    291. 

  291.     (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \
    292. 

  292.     (t).mlen = -__LINE__;                                                    \
    293. 

  293. }
    294. 

  294. 

  295. /* Write protection macros */
    296. 

  296. #define bwriteprotect(t)     { if ((t).mlen >=  0) (t).mlen = -1; }
    297. 

  297. #define bwriteallow(t)       { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
    298. 

  298. #define biswriteprotected(t) ((t).mlen <= 0)
    299. 

  299. 

  300. #ifdef __cplusplus
    301. 

  301. }
    302. 

  302. #endif
    303. 

  303. 

  304. #endif
    305.
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-02 17:30:38 +0000