libsheepy

libsheepyBt.c (29640B)

---

 #include "libsheepyBt.h"
 
 #ifndef LIBSHEEPY_VERSION
 #define libsheepyPrealloc (1024*1024)
 #define makeRoom(length, alloc, addlength) funcbegin\
     typeof(alloc) r;\
     typeof(alloc) newlen = (length) + (addlength);\
     if (newlen < (alloc)) {\
       r = alloc;\
     } \
     else {\
       if (newlen < libsheepyPrealloc) {\
         r = newlen * 2;\
       }\
       else {\
         r = newlen + libsheepyPrealloc;\
       }\
     }\
     r;\
   funcend
 #endif
 
 /**
  * return a btt object with s as buffer
  */
 btt initCharB(char *s) {
   ret charB(s);
 }
 
 /**
  * return a btt object with s as buffer
  * the buffer is not going to be reallocated
  */
 btt initCCharB(char *s) {
   ret ccharB(s);
 }
 
 /**
  * return a btt object with buf as buffer
  */
 btt initB(void *buf, u32 len, bool allocated) {
   ret voidB(buf, len, allocated);
 }
 
 /**
  * return a btt object with a heap allocated buffer of size allocateSize
  */
 btt newB(u32 allocateSize) {
   btt r    = {.len = 0};
   r.b     = malloc(allocateSize ? allocateSize : 4/*allocate 4 bytes when len is 0*/);
   if (!r.b) ret emptybt;
   r.alloc = allocateSize;
   ret r;
 }
 
 /**
  * return a heap allocated btt object with a heap allocated buffer of size allocateSize
  */
 btt *allocNewB(u32 allocateSize) {
   btt *r = malloc(sizeof(*r));
   *r    = newB(allocateSize ? allocateSize : 4/*allocate 4 bytes when len is 0*/);
   ret r;
 }
 
 bool reallocB(btt *b, size_t newSize) {
   if (!b or (/*read only*/b->alloc == 0 and b->len > 0) or newSize == 0/*==0 will free the b->b buffer*/) ret false;
   u8 *tmp = realloc(b->b, newSize);
   if (!tmp) ret false; /*realloc failed*/
   b->b     = tmp;
   b->alloc = newSize;
   // when newSize is shorter than the buffer length
   // truncate the buffer
   if (newSize < b->len) b->len = newSize;
   ret true;
 }
 
 // not needed, use charB or ccharB
 // /**
 //  * set buf in the b btt object
 //  */
 // btt *setB(btt *b, char *buf, bool allocated) {
 //   if (!b or !buf) ret null;
 //   b->b     = buf;
 //   b->len   = strlen(buf);
 //   b->alloc = (allocated) ? b->len : 0;
 //   ret b;
 // }
 
 /**
  * return a heap allocated btt object with buf assigned to it
  */
 btt *allocCharB(char *buf) {
   if (!buf) ret null;
   btt *r = malloc(sizeof(*r));
   if (!r) ret null;
   *r    = charB(buf);
   ret r;
 }
 
 /**
  * return a heap allocated btt object with buf assigned to it
  */
 btt *allocCCharB(char *buf) {
   if (!buf) ret null;
   btt *r = malloc(sizeof(*r));
   if (!r) ret null;
   *r    = ccharB(buf);
   ret r;
 }
 
 btt *allocBufB(void *buf, u32 len, bool allocated) {
   if (!buf) ret null;
   btt *r = malloc(sizeof(*r));
   if (!r) ret null;
   *r    = voidB(buf, len, allocated);
   ret r;
 }
 
 /**
  * return a heap allocated btt object with b assigned to it
  */
 btt *allocB(const btt b) {
   btt *r = malloc(sizeof(*r));
   if (!r) ret null;
   *r    = b;
   ret r;
 }
 
 /**
  * return a heap allocated btt object with *b assigned to it
  */
 btt *allocPB(const btt *b) {
   if (!b) ret null;
   ret allocB(*b);
 }
 
 /**
  * return a btt object with a heap allocated copy of b.b
  */
 btt copyB(const btt b) {
   btt r   = b;
   r.alloc = b.len ? b.len : 4 /*allocate 4 bytes when len is 0*/;
   r.b     = malloc(r.alloc);
   memcpy(r.b, b.b, b.len);
   ret r;
 }
 
 btt copyPB(btt *b) {
   if (!b) ret emptybt;
   ret copyB(*b);
 }
 
 /**
  * return a heap allocated btt object with a heap allocated copy of b.b
  */
 btt *dupB(const btt b) {
   btt *r = malloc(sizeof(*r));
   *r    = copyB(b);
   ret r;
 }
 
 btt *dupPB(btt *b) {
   if (!b) ret null;
   ret dupB(*b);
 }
 
 btt *setValB(btt *b, btt *a) {
   if (!a or !b) ret null;
   freenB(b);
   *b = *a;
   ret b;
 }
 
 /**
  * free heap allocated .b
  * nothing if not heap allocated
  */
 void freeB(btt b) {
   if (b.alloc) {
     free(b.b);
   }
 }
 
 /**
  * free heap allocated .b and assign null to .b
  * nothing if not heap allocated
  */
 void freenB(btt *b) {
   if (b and b->alloc) {
     freen(b->b);
     b->len = 0;
     b->alloc = 0;
   }
 }
 
 /**
  * free the heap allocated btt object (container only, not .b)
  */
 void finishB(btt **b) {
   if (b) {
     free(*b);
     *b = null;
   }
 }
 
 /**
  * free the heap allocated btt object and free .b
  */
 void terminateB(btt **b) {
   if (b) {
     if (*b and (*b)->alloc) {
       free((*b)->b);
     }
     free(*b);
     *b = null;
   }
 }
 
 // terminate val when it is out of scope
 void cleanUpTerminateB(btt **val) {
   terminateB(val);
 }
 
 // free local val when it is out of scope
 void cleanUpFreeLocalB(btt *val) {
   freeB(*val);
 }
 
 // free val when it is out of scope
 void cleanUpFreeB(btt **val) {
   freeB(**val);
 }
 
 // finish val when it is out of scope
 void cleanUpFinishB(btt **val) {
   finishB(val);
 }
 
 // convert btt to char* allocated on heap
 char *toCharB(btt *b) {
   if (not b or not b->b) ret null;
   char *r = malloc(b->len+1);
   if (not r) ret null;
   if (b->len) memcpy(r, b->b, b->len);
   r[b->len] = 0;
   ret r;
 }
 
 bool isEmptyB(const btt b) {
   if (not b.b or not b.len) ret yes;
   ret no;
 }
 
 bool isEmptyPB(btt *b) {
   if (not b) ret yes;
   ret isEmptyB(*b);
 }
 
 bool isValidB(const btt b) {
   if (not b.b or (b.alloc and b.len > b.alloc)) ret no;
   ret yes;
 }
 
 bool isValidPB(btt *b) {
   if (not b) ret no;
   ret isValidB(*b);
 }
 
 bool eqCharB(btt a, char *b) {
   if (not b or not a.b) ret no;
   if (a.len != strlen(b)) ret no;
   ret memcmp(a.b, b, a.len) == 0;
 }
 
 /**
  * return a btt object with s appended to b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushB(const btt b, const char *s) {
   // duplicate b.b
   // copy s to b end
   btt r  = copyB(b);
   btt *p = bPushB(&r, s);
   if (p) ret r;
   else {
     freeB(r);
     ret emptybt;
   }
 }
 
 // TODO pushManyB
 
 /**
  * update b and append s
  * b.b is reallocated
  */
 btt *bPushB(btt *b, const char *s) {
   if (!b or !b->b or !s) ret null;
 
   size_t len = strlen(s);
   u32 newsize = makeRoom(b->len, b->alloc, len);
   // check if there is enough space
   if (newsize > b->alloc) {
     u8 *tmp = realloc(b->b, newsize);
     if (!tmp) ret null;
     b->b = tmp;
     b->alloc = newsize;
   }
   // copy s to b end
   memcpy(b->b+b->len, s, len);
   b->len += len;
   ret b;
 }
 
 /**
  * update b and append '\0'
  * b.b is reallocated
  */
 btt *bPushNulB(btt *b) {
   if (!b or !b->b) ret null;
 
   u32 newsize = makeRoom(b->len, b->alloc, 1);
   // check if there is enough space
   if (newsize > b->alloc) {
     u8 *tmp = realloc(b->b, newsize);
     if (!tmp) ret null;
     b->b = tmp;
     b->alloc = newsize;
   }
   b->b[b->len] = 0;
   b->len++;
   ret b;
 }
 
 // TODO bPushManyB
 
 /**
  * return a btt object with s btt object appended to b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushBB(const btt b, const btt s) {
   // duplicate b.b
   // copy s to b end
   btt r  = copyB(b);
   btt *p = bPushBB(&r, s);
   if (p) ret r;
   else {
     freeB(r);
     ret emptybt;
   }
   ret r;
 }
 
 // TODO bPushManyBB
 
 /**
  * update b and append s btt object
  * b.b is reallocated
  */
 btt *bPushBB(btt *b, const btt s) {
 
   if (!b or !b->b or !s.b) ret null;
   if (!s.len) ret b;
 
   u32 newsize = makeRoom(b->len, b->alloc, s.len);
   // check if there is enough space
   if (newsize > b->alloc) {
     u8 *tmp = realloc(b->b, newsize);
     if (!tmp) ret null;
     b->b = tmp;
     b->alloc = newsize;
   }
   // copy s to b end
   memcpy(b->b+b->len, s.b, s.len);
   b->len += s.len;
   ret b;
 }
 
 // TODO bPushManyBB
 
 /**
  * return a btt object with *s btt object appended to b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushBPB(const btt b, const btt *s) {
   if (!s) ret emptybt;
   // duplicate b.b
   // copy s to b end
   ret pushBB(b, *s);
 }
 
 // TODO bPushManyBPB
 
 /**
  * update b and append *s btt object
  * b.b is reallocated
  */
 btt *bPushBPB(btt *b, const btt *s) {
   if (!s) ret null;
   // copy s to b end
   ret bPushBB(b, *s);
 }
 
 // TODO bPushManyBB
 
 /**
  * return a btt object with s appended to *b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushPB(const btt *b, const char *s) {
   if (!b) ret emptybt;
   ret pushB(*b, s);
 }
 // TODO pushManyPB...
 
 /**
  * return a btt object with s btt object appended to *b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushPBB(const btt *b, const btt s) {
   if (!b) ret emptybt;
   ret pushBB(*b, s);
 }
 // TODO pushManyPBB...
 
 /**
  * return a btt object with *s btt object appended to *b
  * b doesn't need to have a heap allocated buffer
  */
 btt pushPBPB(const btt *b, const btt *s) {
   if (!b) ret emptybt;
   ret pushBPB(*b, s);
 }
 // TODO pushManyPBPB...
 
 /**
  * buffer insert string in string at index
  *
  * return string with toInsert at index
  * negative indexes are allowed
  * index -1 is the end of the array and is equivalent to index len
  *
  * \param
  *   string
  * \param
  *   index in string
  * \param
  *   toInsert string
  * \return
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
 btt *bInsertB(btt *b, int64_t index, const char *toInsert) {
   if (!b or !b->b or !toInsert) return NULL;
   if (b->alloc == 0 and b->len > 0) {
     // string is not allocated so it is readonly
     return(NULL);
   }
   int64_t blen = (int64_t)b->len;
 
   if (!blen && index == -1) {
     // empty string, index -1 is equal to 0
     index = 0;
   }
   bool neg = false;
   if (index < 0) {
     neg = true;
   }
 
   if (index > blen) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
   if (index < -blen) {
     return(NULL);
   }
   if (neg) {
     index = blen + index;
   }
 
   size_t len = strlen(toInsert);
   u32 newsize = makeRoom(b->len, b->alloc, len);
   // check if there is enough space
   if (newsize > b->alloc) {
     u8 *tmp = realloc(b->b, newsize);
     if (!tmp) return NULL;
     b->b = tmp;
     b->alloc = newsize;
   }
   // when index == b->len, just add toInsert at the end
   if (index < b->len) {
     memmove(b->b+index+len, b->b+index, b->len - index);
   }
   // copy toInsert at index in b
   memcpy(b->b+index, toInsert, len);
   b->len += len;
   return b;
 }
 
 /**
  * buffer insert btt string in string at index
  *
  * return string with toInsert at index
  * negative indexes are allowed
  * index -1 is the end of the array and is equivalent to index len
  *
  * \param
  *   string
  * \param
  *   index in string
  * \param
  *   toInsert string
  * \return
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
 btt *bInsertBB(btt *b, int64_t index, const btt *toInsert) {
   if (!b or !b->b or !toInsert or !toInsert->b) return NULL;
   if (b->alloc == 0 and b->len > 0) {
     // string is not allocated so it is readonly
     return(NULL);
   }
   int64_t blen = (int64_t)b->len;
 
   if (!blen && index == -1) {
     // empty string, index -1 is equal to 0
     index = 0;
   }
   bool neg = false;
   if (index < 0) {
     neg = true;
   }
 
   if (index > blen) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
   if (index < -blen) {
     return(NULL);
   }
   if (neg) {
     index = blen + index;
   }
 
   size_t len = toInsert->len;
   u32 newsize = makeRoom(b->len, b->alloc, len);
   // check if there is enough space
   if (newsize > b->alloc) {
     u8 *tmp = realloc(b->b, newsize);
     if (!tmp) return NULL;
     b->b = tmp;
     b->alloc = newsize;
   }
   // when index == b->len, just add toInsert at the end
   if (index < b->len) {
     memmove(b->b+index+len, b->b+index, b->len - index);
   }
   // copy toInsert at index in b
   memcpy(b->b+index, toInsert->b, len);
   b->len += len;
   return b;
 }
 
 /**
  * buffer delete string
  *
  * return string without the string between start and end
  * negative indexes are allowed
  *
  * \param
  *   string to delete
  * \param
  *   start: start index, must be in the string
  * \param
  *   end: end index, must be in the string after start
  * \return
  *   sliced string
  *   unchanged string when start=end
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
 btt *bDelB(btt *string, int64_t start, int64_t end) {
   int64_t len;
 
   // sanity checks
   if (!string or !string->b) {
     return(NULL);
   }
   if (string->alloc == 0 and string->len > 0) {
     // string is not allocated so it is readonly
     return(NULL);
   }
 
   len = (int64_t)string->len;
 
   if (start >= len) {
     start = len;
   }
   if (end > len) {
     end = len;
   }
   if (start <= -len) {
     start = -len;
   }
   if (end <= -len) {
     end = -len;
   }
   if (start < 0) {
     start = len + start;
   }
   if (end <= 0) {
     end = len + end;
   }
   if (end < start) {
     return(NULL);
   }
 
   if (start == end) {
     return(string);
   }
 
   // start < end < len
   // copy range to a new string
   int64_t n;
   n = end - start;
   memmove(string->b+start, string->b+start+n, (size_t)(len-n-start));
   string->len -= n;
 
   return(string);
 }
 
 /**
  * buffer delete element/character string
  *
  * return string without the character at given index
  * negative indexes are allowed
  *
  * \param
  *   string to delete
  * \param
  *   index: must be in the string, -1 is the last character in the string
  * \return
  *   string with one less character
  *   NULL when input string is NULL or invalid index
  */
 btt *bDelElemB(btt *string, int64_t index) {
   int64_t len;
 
   // sanity checks
   if (!string or !string->b) {
     return(NULL);
   }
   if (string->alloc == 0 and string->len > 0) {
     // string is not allocated so it is readonly
     return(NULL);
   }
 
   len = (int64_t)string->len;
   if (index >= len) {
     return(NULL);
   }
   if (index < -len) {
     return(NULL);
   }
   if (index < 0) {
     index = len + index;
   }
 
   // when index == len-1 only decrement len, delete last char and there is nothing to move
   if (index < len-1) {
     memmove(string->b+index, string->b+index+1, string->len - index-1);
   }
   string->len--;
   return string;
 }
 
 /**
  * read file to new btt
  *
  * The function allocates the buffer
  *
  * \param
  *   filePath path to file
  * \return
  *   data from file in a btt (you must free the pointer)
  *   (btt).b==NULL error
  */
 btt readFileB(const char *filePath) {
   btt r       = init0Var;
   ssize_t len = readFile(filePath, (void**)&r.b);
   if (len == -1) {
     r.b = NULL;
     return r;
   }
   r.len = r.alloc = len;
   return r;
 }
 
 /**
  * write btt to file
  *
  * \param
  *   filePath path to file
  *   btt
  * \return
  *   1 success
  *   0 error
  */
 int writeFileB(const char *filePath, btt b) {
   // sanity checks
   if (!b.b) {
     return 0;
   }
   return writeFile(filePath, b.b, b.len);
 }
 
 int64_t findCharB(btt b, const char *needle) {
   if (!b.b or !needle ) ret -1;
   u8 *p = memmem(b.b, b.len, needle, strlen(needle));
   if (!p) ret -1;
   ret (int64_t)(p - b.b);
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitB(vbtt *vb, const btt b, const btt delim) {
   if (!vb or !b.b or !delim.b) ret null;
 
   vb->count = 0;
 
   if (!delim.len or !b.len) {
     // empty delimiter empty string, return string in a list
     if (vb->count >= vb->maxCount) ret null;
     vectorAppend(vb, b);
     ret vb;
   }
 
   u8 *working        = b.b;
   u8 *nextTokenStart = working;
   u32 i              = 0;
   if (delim.len == 1) {
     while (i < b.len) {
       u8 *ptr = memchr(working, delim.b[0], b.len-i);
       if (!ptr)
         break;
       if (vb->count >= vb->maxCount) ret null;
       nextTokenStart = ptr + 1;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       vectorAppend(vb, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   else {
     while (i < b.len) {
       u8 *ptr = memmem(working, b.len-i, delim.b, delim.len);
       if (!ptr)
         break;
       if (vb->count >= vb->maxCount) ret null;
       nextTokenStart = ptr + delim.len;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       vectorAppend(vb, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   if (vb->count >= vb->maxCount) ret null;
   btt tok = {.b = nextTokenStart, .len = (b.b+b.len)-nextTokenStart, .alloc = 0};
   vectorAppend(vb, tok);
 
   ret vb;
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitCharB(vbtt *vb, const btt b, char *delim) {
   btt d = ccharB(delim);
   ret sasplitB(vb, b, d);
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitDPB(vbtt *vb, const btt b, const btt *delim) {
   if (!delim) ret null;
   ret sasplitB(vb, b, *delim);
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitPB(vbtt *vb, const btt *b, const btt delim) {
   if (!b) ret null;
   ret sasplitB(vb, *b, delim);
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitPCharB(vbtt *vb, const btt *b, char *delim) {
   if (!b) ret null;
   ret sasplitCharB(vb, *b, delim);
 }
 
 /**
  * split b in vb static vector
  * the vector is not reallocated
  */
 vbtt *sasplitPDPB(vbtt *vb, const btt *b, const btt *delim) {
   if (!b or !delim) ret null;
   ret sasplitB(vb, *b, *delim);
 }
 
 /**
  * allocate elements
  * only when the vector is full
  */
 #undef vectorAlloc
 #define vectorAlloc(name) do{\
     if (!(name)->array) {\
       (name)->array    = malloc(vectorSz * sizeof (name)->array[0]);\
       (name)->maxCount = vectorSz;\
     }\
     else {\
       u32 length    = (name)->count * sizeof (name)->array[0];\
       u32 alloc     = (name)->maxCount * sizeof (name)->array[0];\
       u32 addlength = sizeof (name)->array[0];\
       u32 newsize = makeRoom(length,\
                              alloc,\
                              addlength\
                             );\
       (name)->maxCount = newsize / sizeof (name)->array[0];\
       (name)->array    = realloc((name)->array, newsize);\
     }\
   } while(0)
 
 /**
  * split b in vb vector
  */
 vbtt *asplitB(vbtt *vb, const btt b, const btt delim) {
   if (!vb or !b.b or !delim.b) ret null;
 
   vb->count = 0;
 
   if (!delim.len or !b.len) {
     // empty delimiter empty string, return string in a list
     vectorAppend(vb, b);
     ret vb;
   }
 
   u8 *working        = b.b;
   u8 *nextTokenStart = working;
   u32 i              = 0;
   if (delim.len == 1) {
     while (i < b.len) {
       u8 *ptr = memchr(working, delim.b[0], b.len-i);
       if (!ptr)
         break;
       nextTokenStart = ptr + 1;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       vectorAppend(vb, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   else {
     while (i < b.len) {
       u8 *ptr = memmem(working, b.len-i, delim.b, delim.len);
       if (!ptr)
         break;
       nextTokenStart = ptr + delim.len;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       vectorAppend(vb, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   btt tok = {.b = nextTokenStart, .len = (b.b+b.len)-nextTokenStart, .alloc = 0};
   vectorAppend(vb, tok);
 
   ret vb;
 }
 
 /**
  * split b in vb vector
  */
 vbtt *asplitCharB(vbtt *vb, const btt b, char *delim) {
   btt d = ccharB(delim);
   ret asplitB(vb, b, d);
 }
 
 /**
  * split b in vb vector
  */
 vbtt *asplitDPB(vbtt *vb, const btt b, const btt *delim) {
   if (!delim) ret null;
   ret asplitB(vb, b, *delim);
 }
 
 /**
  * split b in vb vector
  */
 vbtt *asplitPB(vbtt *vb, const btt *b, const btt delim) {
   if (!b) ret null;
   ret asplitB(vb, *b, delim);
 }
 
 /**
  * split b in vb vector
  */
 vbtt *asplitPCharB(vbtt *vb, const btt *b, char *delim) {
   if (!b) ret null;
   ret asplitCharB(vb, *b, delim);
 }
 
 /**
  * split b in vb vector
  */
 vbtt *asplitPDPB(vbtt *vb, const btt *b, const btt *delim) {
   if (!b or !delim) ret null;
   ret asplitB(vb, *b, *delim);
 }
 
 /**
  * return vbtt vector with tokens from b
  * this function has good performance for small element counts
  */
 vbtt splitB(const btt b, const btt delim) {
   vbtt r;
   if (!b.b or !delim.b) ret emptyvbt;
 
   vectorInitCount(&r, 5);
 
   asplitB(&r, b, delim);
 
   ret r;
 }
 
 /**
  * return vbtt vector with tokens from b
  * this function has good performance for small element counts
  */
 vbtt splitCharB(const btt b, char *delim) {
   vbtt r;
 
   if (!b.b or !delim) ret emptyvbt;
 
   vectorInitCount(&r, 5);
 
   btt d = ccharB(delim);
   asplitB(&r, b, d);
 
   ret r;
 }
 
 /**
  * split b in vb vector
  */
 vbtt splitDPB(const btt b, const btt *delim) {
   if (!delim) ret emptyvbt;
   ret splitB(b, *delim);
 }
 
 /**
  * split b in vb vector
  */
 vbtt splitPB(const btt *b, const btt delim) {
   if (!b) ret emptyvbt;
   ret splitB(*b, delim);
 }
 
 /**
  * return vbtt vector with tokens from b
  * this function has good performance for small element counts
  */
 vbtt splitPCharB(const btt *b, char *delim) {
   if (!b) ret emptyvbt;
   ret splitCharB(*b, delim);
 }
 
 /**
  * split b in vb vector
  */
 vbtt splitPDPB(const btt *b, const btt *delim) {
   if (!b or !delim) ret emptyvbt;
   ret splitB(*b, *delim);
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitB(const btt b, const btt delim) {
   dbtt r;
 
   if (!b.b or !delim.b) ret emptydbt;
 
   dVectorInit(&r);
 
   if (!delim.len or !b.len) {
     // empty delimiter empty string, return string in a list
     dVectorAppend(&r, b);
     ret r;
   }
 
   u8 *working        = b.b;
   u8 *nextTokenStart = working;
   u32 i              = 0;
   if (delim.len == 1) {
     while (i < b.len) {
       u8 *ptr = memchr(working, delim.b[0], b.len-i);
       if (!ptr)
         break;
       nextTokenStart = ptr + 1;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       dVectorAppend(&r, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   else {
     while (i < b.len) {
       u8 *ptr = memmem(working, b.len-i, delim.b, delim.len);
       if (!ptr)
         break;
       nextTokenStart = ptr + delim.len;
       btt tok = {.b = working, .len = ptr-working, .alloc = 0};
       dVectorAppend(&r, tok);
       i += tok.len + delim.len;
       working = b.b + i;
     }
   }
   btt tok = {.b = nextTokenStart, .len = (b.b+b.len)-nextTokenStart, .alloc = 0};
   dVectorAppend(&r, tok);
 
   ret r;
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitCharB(const btt b, char *delim) {
   btt d = ccharB(delim);
   ret dsplitB(b, d);
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitDPB(const btt b, const btt *delim) {
   if (!delim) ret emptydbt;
   ret dsplitB(b, *delim);
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitPB(const btt *b, const btt delim) {
   if (!b) ret emptydbt;
   ret dsplitB(*b, delim);
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitPCharB(const btt *b, char *delim) {
   if (!b) ret emptydbt;
   ret dsplitCharB(*b, delim);
 }
 
 /**
  * return dbtt vector with tokens from b
  * this function has good performance for large element counts
  */
 dbtt dsplitPDPB(const btt *b, const btt *delim) {
   if (!b or !delim) ret emptydbt;
   ret dsplitB(*b, *delim);
 }
 
 /**
  * slice String
  * return a btt object which is the string between start and end
  * negative indexes are allowed
  */
 btt sliceB(const btt b, int64_t start, int64_t end) {
   btt r = {0};
   if (!b.b) ret emptybt;
 
   #define checkRange(B, rval)\
   i64 len = (B).len;\
   if (start > len)\
     ret rval;\
   if (end > len)\
     end = len;\
   if (start <= -len)\
     start = -len;\
   if (end <= -len)\
     ret rval;\
   if (start < 0)\
     start = len + start;\
   if (end <= 0)\
     end = len + end;\
   if (end < start)\
     ret rval
   checkRange(b, emptybt);
 
   r.b   = b.b + start;
   if (start == end) {
     // empty string
     r.len = 0;
   }
   else {
     // start < end < len
     r.len = end - start;
   }
   ret r;
 }
 
 /**
  * slice String
  * update the b btt object and keep only the string between start and end
  * negative indexes are allowed
  */
 btt *bSliceB(btt *b, int64_t start, int64_t end) {
   if (!b) ret null;
 
   checkRange(*b, null);
 
   if (start == end) {
     // empty string
     b->len = 0;
   }
   else {
     // start < end < len
     b->len = end - start;
     if (start)
       memmove(b->b, b->b+start, b->len);
   }
   ret b;
 }
 
 /**
  * slice String
  * return a btt object which is the string between start and end
  * negative indexes are allowed
  */
 btt slicePB(const btt *b, int64_t start, int64_t end) {
   if (!b) ret emptybt;
   ret sliceB(*b, start, end);
 }
 
 /**
  * join list, the elements are seperated with delim in the resulting string
  *
  * \param
  *   list
  * \param
  *   delim: string seperator
  * \return
  *   joined string (you must free the btt)
  *   empty when list or delim are NULL
  */
 btt joinCharB(vbtt list, const char* delim) {
   btt r = {0};
 
   // sanity checks
   if (!delim) {
     return r;
   }
 
   vectorForEach(&list, e) {
     if (!r.b) {
       r = copyB(*e);
     }
     else {
       // TODO check return value
       bPushB(&r, delim);
       bPushBB(&r, *e);
     }
   }
   return(r);
 }
 
 
 btt copyRngB(const btt b, int64_t start, int64_t end) {
   btt s = sliceB(b, start, end);
   if (not s.b) ret s; // error return {0}
   else         ret copyB(s);
 }
 
 // cropB copy and remove
 btt bCropB(btt *b, int64_t start, int64_t end) {
 
   // sanity checks
   if (!b or !b->b) {
     ret emptybt;
   }
   if (b->alloc == 0 and b->len > 0) {
     // b is not allocated so it is readonly
     ret emptybt;
   }
 
   checkRange(*b, emptybt);
 
   // slice to s
   btt s = {0};
   s.b   = b->b + start;
   if (start == end) {
     // empty string
     s.len = 0;
     ret s; // nothing to delete in b
   }
   else {
     // start < end < len
     s.len = end - start;
   }
 
   // copy s to r and allocate on heap
   btt r;
   r.len = s.len;
   r.b     = malloc(r.len);
   r.alloc = r.len;
   memcpy(r.b, s.b, r.len);
 
   // delete string between start and end in b
   // copy range to a new string
   int64_t n;
   n = end - start;
   memmove(b->b+start, b->b+start+n, (size_t)(len-n-start));
   b->len -= n;
 
   ret r;
 }
 
 /**
  * return a btt object without the leading and trailing spaces
  */
 btt trimB(const btt b) {
   btt r = {0};
   if (!b.b) ret emptybt;
 
   r.b = b.b;
 
   u32 i = 0;
 
   // remove leading spaces
   while (i < b.len and isspace(*r.b)) {
     i++; r.b++;
   }
 
   if (i == b.len) {
     // all spaces
     r.b     = b.b;
     ret r;
   }
 
   // remove trailing spaces
   u8 *end = b.b + b.len - 1;
   while (isspace(*end))
     end--;
 
   r.len = end - r.b + 1;
 
   ret r;
 }
 
 /**
  * update b btt object and remove the leading and trailing spaces
  */
 // memmove data
 btt *bTrimB(btt *b) {
   if (!b or !b->b) ret null;
 
   btt t = trimB(*b);
 
   if (t.b != b->b)
     memmove(b->b, t.b, t.len);
   b->len = t.len;
 
   ret b;
 }
 
 /**
  * return a btt object without the leading and trailing spaces
  */
 btt trimPB(const btt *b) {
   if (!b) emptybt;
   ret trimB(*b);
 }
 
 /**
  * remove empty strings from list
  *
  * \param
  *   list
  * \return
  *   list without empty strings
  *   empty list when list is empty
  *   unchanged list when list is NULL
  *   NULL error
  */
 vbtt *bCompactB(vbtt *list) {
 
   // sanity checks
   if (!list) {
     return(NULL);
   }
 
   u16 rindex = 0;
   // keep non empty elements
   vectorForEach(list, e) {
     trimBG(e);
     if (not isEmptyPB(e)) {
       list->array[rindex++] = *e;
     }
     else {
       freenB(e);
     }
   }
   list->count = rindex;
   return(list);
 }
 
 /**
  * buffer size normalize path
  *
  * remove unecessary /, .. and .
  * leading / is kept
  * leading .. is kept
  * leading . is removed
  *
  * '/../' becomes '/'
  *
  * \param
  *   path
  * \return
  *   path modified path
  *   NULL when path is NULL
  */
 btt *bNormalizePathB(btt *path) {
 
   // sanity checks
   if (!path) {
     return(NULL);
   }
 
   if (!path->len) {
     return(path);
   }
 
   if (isEmptyPB(path)) {
     return(path);
   }
 
   // list path elements
   vbtt pathL = splitBG(path, "/");
 
   // remove empty elements
   bCompactB(&pathL);
 
   if (pathL.count == 0) {
     vectorFree(&pathL);
     // keep leading /
     path->b[0] = '/';
     path->len  = 1;
     return(path);
   }
 
   // new path elements
   vbtt list;
   vectorInitCount(&list, pathL.count);
 
   // detect leading double dots
   bool onlyLeadingDoubleDots = true;
 
   // add elements to list
   vectorForEach(&pathL, level) {
     if (eqCharB(*level, "..")) {
       if (onlyLeadingDoubleDots) {
         // keep leading ..
         vectorAppend(&list, charB(strdup("..")));
       }
       else {
         // remove .. in path
         if (list.count) {
           btt s = vectorPop(&list);
           freeB(s);
         }
       }
     }
     else if (!eqCharB(*level, ".")) {
       // remove . and add elements
       btt c = copyB(*level);
       vectorAppend(&list, c);
       // an element is pushed, so this is the end of leading double dots
       onlyLeadingDoubleDots = false;
     }
   }
 
   if (list.count == 1 && eqCharB(vectorAt(&list, 0), "..") && path->b[0] == '/') {
     // handle ../ .. /.. /../
     vectorAt(&list, 0).len = 0;
   }
 
   // handle /.: add empty string
   if (eqCharB(*path, "/.")) {
     btt c = newB(4);
     vectorAppend(&list, c);
   }
 
   // keep leading /
   if (path->b[0] == '/') {
     if (list.count == 0) {
       // .. cancelled path: /a/b/../..
       vectorFree(&pathL);
       vectorFree(&list);
       path->len = 1;
       return(path);
     }
     //why? pErrorNULL(listPrependS(&list, ""));
   }
 
   // create new path
   btt r = joinCharB(list, "/");
   vectorFree(&pathL);
   vectorFree(&list);
   if (!r.b) {
     path->len = 0;
     return(path);
   }
   // TODO check null
   setValB(path, &r);
   return(path);
 }
 
 void printB(const btt b) {
   write(STDOUT_FILENO, b.b, b.len);
 }
 
 void printDebugB(const btt b) {
   write(STDOUT_FILENO, "\"", 1);
   printB(b);
   write(STDOUT_FILENO, "\"", 1);
   put;
 }
 
 void printDebugInfoB(const btt b) {
   logD("b: %p, len: %"PRIu32", alloc: %"PRIu32, b.b, b.len, b.alloc);
   printDebugB(b);
 }
 // vim: set expandtab ts=2 sw=2: