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         if(c < 0) for (l = 0, x = c; x < 0; x /= 10) buf[l++] = '0' - (x%10);
 116         else for (l = 0, x = c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 117         if (c < 0) buf[l++] = '-';
 118         if (s->l + l + 1 >= s->m) {
 119                 s->m = s->l + l + 2;
 120                 kroundup32(s->m);
 121                 s->s = (char*)realloc(s->s, s->m);
 122         }
 123         for (x = l - 1; x >= 0; --x) s->s[s->l++] = buf[x];
 124         s->s[s->l] = 0;
 125         return 0;
 126 }
 127
 128 static inline int kputuw(unsigned c, kstring_t *s)
 129 {
 130         char buf[16];
 131         int l, i;
 132         unsigned x;
 133         if (c == 0) return kputc('0', s);
 134         for (l = 0, x = c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 135         if (s->l + l + 1 >= s->m) {
 136                 s->m = s->l + l + 2;
 137                 kroundup32(s->m);
 138                 s->s = (char*)realloc(s->s, s->m);
 139         }
 140         for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
 141         s->s[s->l] = 0;
 142         return 0;
 143 }
 144
 145 static inline int kputl(long c, kstring_t *s)
 146 {
 147         char buf[32];
 148         long l, x;
 149         if (c == 0) return kputc('0', s);
 150         for (l = 0, x = c < 0? -c : c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 151         if (c < 0) buf[l++] = '-';
 152         if (s->l + l + 1 >= s->m) {
 153                 s->m = s->l + l + 2;
 154                 kroundup32(s->m);
 155                 s->s = (char*)realloc(s->s, s->m);
 156         }
 157         for (x = l - 1; x >= 0; --x) s->s[s->l++] = buf[x];
 158         s->s[s->l] = 0;
 159         return 0;
 160 }
 161
 162 static inline int *ksplit(kstring_t *s, int delimiter, int *n)
 163 {
 164         int max = 0, *offsets = 0;
 165         *n = ksplit_core(s->s, delimiter, &max, &offsets);
 166         return offsets;
 167 }
 168
 169 #endif