src/dstrings.c

   1 /* coded by Ketmar // Vampire Avalon (psyc://ketmar.no-ip.org/~Ketmar)
   2  * Understanding is not required. Only obedience.
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include "dstrings.h"
  22
  23
  24 static inline void dstr_zero (dstring_t *s) {
  25   if (s != NULL) {
  26     s->str = s->sbuf;
  27     s->len = 0;
  28     s->size = sizeof(s->sbuf);
  29     s->sbuf[0] = 0;
  30   }
  31 }
  32
  33
  34 void dstr_init (dstring_t *s) {
  35   dstr_zero(s);
  36 }
  37
  38
  39 void dstr_init_cstr (dstring_t *s, const void *str) {
  40   dstr_init(s);
  41   dstr_push_cstr(s, str);
  42 }
  43
  44
  45 void dstr_init_buf (dstring_t *s, const void *start, int len) {
  46   dstr_init(s);
  47   dstr_push_buf(s, start, len);
  48 }
  49
  50
  51 void dstr_init_memrange (dstring_t *s, const void *start, const void *finish) {
  52   dstr_init(s);
  53   dstr_push_memrange(s, start, finish);
  54 }
  55
  56
  57 void dstr_done (dstring_t *s) {
  58   if (s != NULL) {
  59     if (s->str != s->sbuf) free(s->str);
  60     dstr_zero(s);
  61   }
  62 }
  63
  64
  65 void dstr_clear (dstring_t *s) {
  66   if (s != NULL) {
  67     s->str[s->len=0] = 0;
  68   }
  69 }
  70
  71
  72 void dstr_empty (dstring_t *s) {
  73   if (s != NULL) {
  74     if (s->str != s->sbuf) free(s->str);
  75     dstr_zero(s);
  76   }
  77 }
  78
  79
  80 static void dstr_resv (dstring_t *s, int size) {
  81   if (s != NULL) {
  82     if (size < 0) size = 0;
  83     if (size > 0) {
  84       if (s->str == s->sbuf) {
  85         s->str = malloc(size);
  86         if (s->len > 0) memcpy(s->str, s->sbuf, s->len);
  87         s->str[s->len] = 0;
  88       } else {
  89         char *ns = realloc(s->str, size);
  90         if (ns == NULL) { fprintf(stderr, "FATAL: out of memory!\n"); abort(); }
  91         s->str = ns;
  92       }
  93     }
  94     s->size = size;
  95   }
  96 }
  97
  98
  99 void dstr_reserve (dstring_t *s, int size) {
 100   if (s != NULL && size > s->size) dstr_resv(s, size);
 101 }
 102
 103
 104 // make room for at least `spc` chars
 105 static inline void dstr_expand (dstring_t *s, int spc) {
 106   if (s != NULL && spc >= 0) dstr_reserve(s, ((s->len+spc+1)|0x3ff)+1);
 107 }
 108
 109
 110 void dstr_push_buf (dstring_t *s, const void *start, int len) {
 111   if (s != NULL) {
 112     if (len < 0) len = (start != NULL ? strlen((const char *)start) : 0);
 113     if (len > 0) {
 114       dstr_expand(s, len);
 115       if (start == NULL) memset(s->str+s->len, 32, len); else memmove(s->str+s->len, start, len);
 116       s->str[s->len+=len] = 0;
 117     }
 118   }
 119 }
 120
 121
 122 void dstr_push_cstr (dstring_t *s, const void *str) {
 123   dstr_push_buf(s, str, -1);
 124 }
 125
 126
 127 void dstr_push_memrange (dstring_t *s, const void *start, const void *finish) {
 128   if (s != NULL && finish > start) dstr_push_buf(s, start, ((const char *)finish)-((const char *)start));
 129 }
 130
 131
 132 void dstr_push_char (dstring_t *s, int x) {
 133   if (s != NULL) {
 134     dstr_expand(s, 1);
 135     s->str[s->len++] = x&0xff;
 136     s->str[s->len] = 0;
 137   }
 138 }
 139
 140
 141 void dstr_set_cstr (dstring_t *s, const void *cstr) {
 142   dstr_clear(s);
 143   dstr_push_cstr(s, cstr);
 144 }
 145
 146
 147 void dstr_set_buf (dstring_t *s, const void *start, int len) {
 148   dstr_clear(s);
 149   dstr_push_buf(s, start, len);
 150 }
 151
 152 void dstr_set_memrange (dstring_t *s, const void *start, const void *finish) {
 153   dstr_clear(s);
 154   dstr_push_memrange(s, start, finish);
 155 }
 156
 157
 158 void dstr_chop (dstring_t *s, int n) {
 159   if (s != NULL) {
 160     if (n < 0) n = 0; else if (n > s->len) n = s->len;
 161     s->str[s->len=n] = 0;
 162   }
 163 }
 164
 165
 166 int dstr_pop_char (dstring_t *s) {
 167   if (s != NULL) {
 168     int res = (s->len > 0 ? (unsigned char)(s->str[--s->len]) : 0);
 169     s->str[s->len] = 0;
 170     return res;
 171   }
 172   return 0;
 173 }
 174
 175
 176 char dstr_last_char (dstring_t *s) {
 177   return (s != NULL && s->len > 0 ? s->str[s->len-1] : 0);
 178 }
 179
 180
 181 char *dstr_cstr (dstring_t *s) {
 182   return (s != NULL ? s->str : NULL);
 183 }
 184
 185
 186 int dstr_len (dstring_t *s) {
 187   return (s != NULL ? s->len : 0);
 188 }