kstring.h

   1 #ifndef KSTRING_H
   2 #define KSTRING_H
   3
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <stdint.h>
   7
   8 #ifndef kroundup32
   9 #define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
  10 #endif
  11
  12 #ifndef KSTRING_T
  13 #define KSTRING_T kstring_t
  14 typedef struct __kstring_t {
  15         size_t l, m;
  16         char *s;
  17 } kstring_t;
  18 #endif
  19
  20 typedef struct {
  21         uint64_t tab[4];
  22         int sep, finished;
  23         const char *p; // end of the current token
  24 } ks_tokaux_t;
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30         int ksprintf(kstring_t *s, const char *fmt, ...);
  31         int ksplit_core(char *s, int delimiter, int *_max, int **_offsets);
  32         char *kstrstr(const char *str, const char *pat, int **_prep);
  33         char *kstrnstr(const char *str, const char *pat, int n, int **_prep);
  34         void *kmemmem(const void *_str, int n, const void *_pat, int m, int **_prep);
  35
  36         /* kstrtok() is similar to strtok_r() except that str is not
  37          * modified and both str and sep can be NULL. For efficiency, it is
  38          * actually recommended to set both to NULL in the subsequent calls
  39          * if sep is not changed. */
  40         char *kstrtok(const char *str, const char *sep, ks_tokaux_t *aux);
  41
  42 #ifdef __cplusplus
  43 }
  44 #endif
  45
  46 static inline int kputsn(const char *p, int l, kstring_t *s)
  47 {
  48         if (s->l + l + 1 >= s->m) {
  49                 s->m = s->l + l + 2;
  50                 kroundup32(s->m);
  51                 s->s = (char*)realloc(s->s, s->m);
  52         }
  53         memcpy(s->s + s->l, p, l);
  54         s->l += l;
  55         s->s[s->l] = 0;
  56         return l;
  57 }
  58
  59 static inline int kputs(const char *p, kstring_t *s)
  60 {
  61         return kputsn(p, strlen(p), s);
  62 }
  63
  64 static inline int kputc(int c, kstring_t *s)
  65 {
  66         if (s->l + 1 >= s->m) {
  67                 s->m = s->l + 2;
  68                 kroundup32(s->m);
  69                 s->s = (char*)realloc(s->s, s->m);
  70         }
  71         s->s[s->l++] = c;
  72         s->s[s->l] = 0;
  73         return c;
  74 }
  75
  76 static inline int kputw(int c, kstring_t *s)
  77 {
  78         char buf[16];
  79         int l, x;
  80         if (c == 0) return kputc('0', s);
  81         for (l = 0, x = c < 0? -c : c; x > 0; x /= 10) buf[l++] = x%10 + '0';
  82         if (c < 0) buf[l++] = '-';
  83         if (s->l + l + 1 >= s->m) {
  84                 s->m = s->l + l + 2;
  85                 kroundup32(s->m);
  86                 s->s = (char*)realloc(s->s, s->m);
  87         }
  88         for (x = l - 1; x >= 0; --x) s->s[s->l++] = buf[x];
  89         s->s[s->l] = 0;
  90         return 0;
  91 }
  92
  93 static inline int kputuw(unsigned c, kstring_t *s)
  94 {
  95         char buf[16];
  96         int l, i;
  97         unsigned x;
  98         if (c == 0) return kputc('0', s);
  99         for (l = 0, x = c; x > 0; x /= 10) buf[l++] = x%10 + '0';
 100         if (s->l + l + 1 >= s->m) {
 101                 s->m = s->l + l + 2;
 102                 kroundup32(s->m);
 103                 s->s = (char*)realloc(s->s, s->m);
 104         }
 105         for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
 106         s->s[s->l] = 0;
 107         return 0;
 108 }
 109
 110 static inline int *ksplit(kstring_t *s, int delimiter, int *n)
 111 {
 112         int max = 0, *offsets = 0;
 113         *n = ksplit_core(s->s, delimiter, &max, &offsets);
 114         return offsets;
 115 }
 116
 117 #endif