kstring.h

   1 /* The MIT License
   2
   3    Copyright (c) by Attractive Chaos <attractor@live.co.uk>
   4
   5    Permission is hereby granted, free of charge, to any person obtaining
   6    a copy of this software and associated documentation files (the
   7    "Software"), to deal in the Software without restriction, including
   8    without limitation the rights to use, copy, modify, merge, publish,
   9    distribute, sublicense, and/or sell copies of the Software, and to
  10    permit persons to whom the Software is furnished to do so, subject to
  11    the following conditions:
  12
  13    The above copyright notice and this permission notice shall be
  14    included in all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  20    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  21    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23    SOFTWARE.
  24 */
  25
  26 #ifndef KSTRING_H
  27 #define KSTRING_H
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdint.h>
  32
  33 #ifndef kroundup32
  34 #define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
  35 #endif
  36
  37 #ifndef KSTRING_T
  38 #define KSTRING_T kstring_t
  39 typedef struct __kstring_t {
  40         size_t l, m;
  41         char *s;
  42 } kstring_t;
  43 #endif
  44
  45 typedef struct {
  46         uint64_t tab[4];
  47         int sep, finished;
  48         const char *p; // end of the current token
  49 } ks_tokaux_t;
  50
  51 #ifdef __cplusplus
  52 extern "C" {
  53 #endif
  54
  55         int ksprintf(kstring_t *s, const char *fmt, ...);
  56         int ksplit_core(char *s, int delimiter, int *_max, int **_offsets);
  57         char *kstrstr(const char *str, const char *pat, int **_prep);
  58         char *kstrnstr(const char *str, const char *pat, int n, int **_prep);
  59         void *kmemmem(const void *_str, int n, const void *_pat, int m, int **_prep);
  60
  61         /* kstrtok() is similar to strtok_r() except that str is not
  62          * modified and both str and sep can be NULL. For efficiency, it is
  63          * actually recommended to set both to NULL in the subsequent calls
  64          * if sep is not changed. */
  65         char *kstrtok(const char *str, const char *sep, ks_tokaux_t *aux);
  66
  67 #ifdef __cplusplus
  68 }
  69 #endif
  70
  71 static inline void ks_resize(kstring_t *s, size_t size)
  72 {
  73         if (s->m < size) {
  74                 s->m = size;
  75                 kroundup32(s->m);
  76                 s->s = (char*)realloc(s->s, s->m);
  77         }
  78 }
  79
  80 static inline int kputsn(const char *p, int l, kstring_t *s)
  81 {
  82         if (s->l + l + 1 >= s->m) {
  83                 s->m = s->l + l + 2;
  84                 kroundup32(s->m);
  85                 s->s = (char*)realloc(s->s, s->m);
  86         }
  87         memcpy(s->s + s->l, p, l);
  88         s->l += l;
  89         s->s[s->l] = 0;
  90         return l;
  91 }
  92
  93 static inline int kputs(const char *p, kstring_t *s)
  94 {
  95         return kputsn(p, strlen(p), s);
  96 }
  97
  98 static inline int kputc(int c, kstring_t *s)
  99 {
 100         if (s->l + 1 >= s->m) {
 101                 s->m = s->l + 2;
 102                 kroundup32(s->m);
 103                 s->s = (char*)realloc(s->s, s->m);
 104         }
 105         s->s[s->l++] = c;
 106         s->s[s->l] = 0;
 107         return c;
 108 }
 109
 110 static inline int kputw(int c, kstring_t *s)
 111 {
 112         char buf[16];
 113         int l, x;
 114         if (c == 0) return kputc('0', s);
 115         for (l = 0, x = c < 0? -c : c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 116         if (c < 0) buf[l++] = '-';
 117         if (s->l + l + 1 >= s->m) {
 118                 s->m = s->l + l + 2;
 119                 kroundup32(s->m);
 120                 s->s = (char*)realloc(s->s, s->m);
 121         }
 122         for (x = l - 1; x >= 0; --x) s->s[s->l++] = buf[x];
 123         s->s[s->l] = 0;
 124         return 0;
 125 }
 126
 127 static inline int kputuw(unsigned c, kstring_t *s)
 128 {
 129         char buf[16];
 130         int l, i;
 131         unsigned x;
 132         if (c == 0) return kputc('0', s);
 133         for (l = 0, x = c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 134         if (s->l + l + 1 >= s->m) {
 135                 s->m = s->l + l + 2;
 136                 kroundup32(s->m);
 137                 s->s = (char*)realloc(s->s, s->m);
 138         }
 139         for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
 140         s->s[s->l] = 0;
 141         return 0;
 142 }
 143
 144 static inline int *ksplit(kstring_t *s, int delimiter, int *n)
 145 {
 146         int max = 0, *offsets = 0;
 147         *n = ksplit_core(s->s, delimiter, &max, &offsets);
 148         return offsets;
 149 }
 150
 151 #endif