include/atalk/bstrlib.h

   1 /*\r
   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
   6  */\r
   7 \r
   8 /*!\r
   9  * @file\r
  10  * This file is the core module for implementing the bstring functions.\r
  11  */\r
  12 \r
  13 #ifndef BSTRLIB_INCLUDE\r
  14 #define BSTRLIB_INCLUDE\r
  15 \r
  16 #ifdef __cplusplus\r
  17 extern "C" {\r
  18 #endif\r
  19 \r
  20 #include <stdarg.h>\r
  21 #include <string.h>\r
  22 #include <limits.h>\r
  23 #include <ctype.h>\r
  24 \r
  25 #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)\r
  26 # if defined (__TURBOC__) && !defined (__BORLANDC__)\r
  27 #  define BSTRLIB_NOVSNP\r
  28 # endif\r
  29 #endif\r
  30 \r
  31 #define BSTR_ERR (-1)\r
  32 #define BSTR_OK (0)\r
  33 #define BSTR_BS_BUFF_LENGTH_GET (0)\r
  34 \r
  35 typedef struct tagbstring * bstring;\r
  36 typedef const struct tagbstring * const_bstring;\r
  37 \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
  50 \r
  51 /* Destroy function */\r
  52 extern int bdestroy (bstring b);\r
  53 \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
  57 \r
  58 /* Substring extraction */\r
  59 extern bstring bmidstr (const_bstring b, int left, int len);\r
  60 \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
  72 \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
  98 \r
  99 /* List of string container functions */\r
 100 struct bstrList {\r
 101     int qty, mlen;\r
 102     bstring * entry;\r
 103 };\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
 108 \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
 120 \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
 128 \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
 134 \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
 139         for (;;) { \\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
 146                         break; \\r
 147                 } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \\r
 148                         bstrtmp_r = BSTR_ERR; \\r
 149                         break; \\r
 150                 } \\r
 151                 bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \\r
 152         } \\r
 153         ret = bstrtmp_r; \\r
 154 }\r
 155 \r
 156 #endif\r
 157 \r
 158 typedef int (*bNgetc) (void *parm);\r
 159 typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);\r
 160 \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
 167 \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
 185 \r
 186 struct tagbstring {\r
 187         int mlen;\r
 188         int slen;\r
 189         unsigned char * data;\r
 190 };\r
 191 \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
 201 \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
 206 #endif\r
 207 #ifndef bsStatic\r
 208 # define bsStatic(q)        bsStaticMlen(q,-__LINE__)\r
 209 #endif\r
 210 \r
 211 /* Static constant block parameter pair */\r
 212 #define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)\r
 213 \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
 219     (t).mlen = -1;                                                   \\r
 220 }\r
 221 #define blk2tbstr(t,s,l) {            \\r
 222     (t).data = (unsigned char *) (s); \\r
 223     (t).slen = l;                     \\r
 224     (t).mlen = -1;                    \\r
 225 }\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
 235         }                                                                    \\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
 240             (t).slen = 0;                                                    \\r
 241         } else {                                                             \\r
 242             (t).data = bstrtmp_s->data + bstrtmp_left;                       \\r
 243             (t).slen = bstrtmp_len;                                          \\r
 244         }                                                                    \\r
 245     } else {                                                                 \\r
 246         (t).data = (unsigned char *)"";                                      \\r
 247         (t).slen = 0;                                                        \\r
 248     }                                                                        \\r
 249     (t).mlen = -__LINE__;                                                    \\r
 250 }\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
 257         }                                                                    \\r
 258     }                                                                        \\r
 259     (t).data = bstrtmp_s + bstrtmp_idx;                                      \\r
 260     (t).slen = bstrtmp_len - bstrtmp_idx;                                    \\r
 261     (t).mlen = -__LINE__;                                                    \\r
 262 }\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
 269         }                                                                    \\r
 270     }                                                                        \\r
 271     (t).data = bstrtmp_s;                                                    \\r
 272     (t).slen = bstrtmp_len + 1;                                              \\r
 273     (t).mlen = -__LINE__;                                                    \\r
 274 }\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
 281         }                                                                    \\r
 282         for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \\r
 283             if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \\r
 284         }                                                                    \\r
 285     }                                                                        \\r
 286     (t).data = bstrtmp_s + bstrtmp_idx;                                      \\r
 287     (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \\r
 288     (t).mlen = -__LINE__;                                                    \\r
 289 }\r
 290 \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
 295 \r
 296 #ifdef __cplusplus\r
 297 }\r
 298 #endif\r
 299 \r
 300 #endif\r