src/str.c

   1 #if defined(_MSC_VER)
   2 #if !defined _CRT_SECURE_NO_WARNINGS
   3 #define _CRT_SECURE_NO_WARNINGS /* NOLINT */
   4 #endif /* _CRT_SECURE_NO_WARNINGS */
   5 #endif /* _MSC_VER */
   6 #include "a/str.h"
   7
   8 a_str *a_str_new(void)
   9 {
  10     a_str *const ctx = (a_str *)a_alloc(A_NULL, sizeof(a_str));
  11     if (ctx) { a_str_ctor(ctx); }
  12     return ctx;
  13 }
  14
  15 void a_str_die(a_str *ctx)
  16 {
  17     if (ctx)
  18     {
  19         a_str_dtor(ctx);
  20         a_alloc(ctx, 0);
  21     }
  22 }
  23
  24 void a_str_ctor(a_str *ctx)
  25 {
  26     ctx->ptr_ = A_NULL;
  27     ctx->num_ = 0;
  28     ctx->mem_ = 0;
  29 }
  30
  31 void a_str_dtor(a_str *ctx)
  32 {
  33     if (ctx->ptr_)
  34     {
  35         a_alloc(ctx->ptr_, 0);
  36         ctx->ptr_ = A_NULL;
  37     }
  38     ctx->num_ = 0;
  39     ctx->mem_ = 0;
  40 }
  41
  42 int a_str_copy(a_str *ctx, a_str const *obj)
  43 {
  44     int ok;
  45     a_str_ctor(ctx);
  46     ok = a_str_alloc_(ctx, obj->num_ + 1);
  47     if (ok == A_SUCCESS)
  48     {
  49         if (obj->num_) { a_copy(ctx->ptr_, obj->ptr_, obj->num_); }
  50         ctx->ptr_[obj->num_] = 0;
  51         ctx->num_ = obj->num_;
  52     }
  53     return ok;
  54 }
  55
  56 void a_str_move(a_str *ctx, a_str *obj)
  57 {
  58     a_copy(ctx, obj, sizeof(*obj));
  59     a_zero(obj, sizeof(*obj));
  60 }
  61
  62 char *a_str_exit(a_str *ctx)
  63 {
  64     char *const str = ctx->ptr_;
  65     if (ctx->ptr_)
  66     {
  67         ctx->ptr_[ctx->num_] = 0;
  68         ctx->ptr_ = A_NULL;
  69     }
  70     ctx->num_ = 0;
  71     ctx->mem_ = 0;
  72     return str;
  73 }
  74
  75 int a_str_alloc_(a_str *ctx, a_size mem)
  76 {
  77     char *ptr;
  78     mem = a_size_up(sizeof(void *), mem);
  79     ptr = (char *)a_alloc(ctx->ptr_, mem);
  80     if (ptr || mem == 0)
  81     {
  82         ctx->ptr_ = ptr;
  83         ctx->mem_ = mem;
  84         return A_SUCCESS;
  85     }
  86     return A_FAILURE;
  87 }
  88
  89 int a_str_alloc(a_str *ctx, a_size mem)
  90 {
  91     if (mem > ctx->mem_)
  92     {
  93         return a_str_alloc_(ctx, mem);
  94     }
  95     return A_SUCCESS;
  96 }
  97
  98 int a_str_cmp_(void const *p0, a_size n0, void const *p1, a_size n1)
  99 {
 100     int ok;
 101     if (p0 && p1)
 102     {
 103         ok = memcmp(p0, p1, A_MIN(n0, n1));
 104         if (ok) { return ok; }
 105     }
 106     return (n0 > n1) - (n0 < n1);
 107 }
 108
 109 int a_str_cmp(a_str const *ctx, a_str const *str)
 110 {
 111     return a_str_cmp_(ctx->ptr_, ctx->num_, str->ptr_, str->num_);
 112 }
 113
 114 int a_str_cmpn(a_str const *ctx, void const *pdata, a_size nbyte)
 115 {
 116     return a_str_cmp_(ctx->ptr_, ctx->num_, pdata, nbyte);
 117 }
 118
 119 int a_str_cmps(a_str const *ctx, void const *str)
 120 {
 121     return a_str_cmp_(ctx->ptr_, ctx->num_, str, strlen((char const *)str));
 122 }
 123
 124 int a_str_getc_(a_str *ctx)
 125 {
 126     int c = ~0;
 127     if (ctx->num_)
 128     {
 129         c = (int)ctx->ptr_[--ctx->num_];
 130     }
 131     return c;
 132 }
 133
 134 int a_str_getc(a_str *ctx)
 135 {
 136     int c = ~0;
 137     if (ctx->num_)
 138     {
 139         c = (int)ctx->ptr_[--ctx->num_];
 140         ctx->ptr_[ctx->num_] = 0;
 141     }
 142     return c;
 143 }
 144
 145 int a_str_putc_(a_str *ctx, int c)
 146 {
 147     if (a_str_alloc(ctx, ctx->num_ + 1) == A_SUCCESS)
 148     {
 149         ctx->ptr_[ctx->num_++] = (char)c;
 150         return c;
 151     }
 152     return ~0;
 153 }
 154
 155 int a_str_putc(a_str *ctx, int c)
 156 {
 157     if (a_str_alloc(ctx, ctx->num_ + 2) == A_SUCCESS)
 158     {
 159         ctx->ptr_[ctx->num_++] = (char)c;
 160         ctx->ptr_[ctx->num_] = 0;
 161         return c;
 162     }
 163     return ~0;
 164 }
 165
 166 a_size a_str_getn_(a_str *ctx, void *pdata, a_size nbyte)
 167 {
 168     if (nbyte > ctx->num_) { nbyte = ctx->num_; }
 169     if (nbyte)
 170     {
 171         ctx->num_ -= nbyte;
 172         if (pdata) { a_copy(pdata, ctx->ptr_ + ctx->num_, nbyte); }
 173     }
 174     return nbyte;
 175 }
 176
 177 a_size a_str_getn(a_str *ctx, void *pdata, a_size nbyte)
 178 {
 179     if (nbyte > ctx->num_) { nbyte = ctx->num_; }
 180     if (nbyte)
 181     {
 182         ctx->num_ -= nbyte;
 183         if (pdata) { a_copy(pdata, ctx->ptr_ + ctx->num_, nbyte); }
 184         ctx->ptr_[ctx->num_] = 0;
 185     }
 186     return nbyte;
 187 }
 188
 189 int a_str_setn_(a_str *ctx, void const *pdata, a_size nbyte)
 190 {
 191     int ok = a_str_alloc(ctx, nbyte);
 192     if (ok == A_SUCCESS && nbyte)
 193     {
 194         a_copy(ctx->ptr_, pdata, nbyte);
 195         ctx->num_ = nbyte;
 196     }
 197     return ok;
 198 }
 199
 200 int a_str_putn_(a_str *ctx, void const *pdata, a_size nbyte)
 201 {
 202     int ok = a_str_alloc(ctx, ctx->num_ + nbyte);
 203     if (ok == A_SUCCESS && nbyte)
 204     {
 205         a_copy(ctx->ptr_ + ctx->num_, pdata, nbyte);
 206         ctx->num_ += nbyte;
 207     }
 208     return ok;
 209 }
 210
 211 int a_str_setn(a_str *ctx, void const *pdata, a_size nbyte)
 212 {
 213     int ok = a_str_alloc(ctx, nbyte + 1);
 214     if (ok == A_SUCCESS)
 215     {
 216         if (nbyte) { a_copy(ctx->ptr_, pdata, nbyte); }
 217         ctx->ptr_[nbyte] = 0;
 218         ctx->num_ = nbyte;
 219     }
 220     return ok;
 221 }
 222
 223 int a_str_putn(a_str *ctx, void const *pdata, a_size nbyte)
 224 {
 225     int ok = a_str_alloc(ctx, ctx->num_ + nbyte + 1);
 226     if (ok == A_SUCCESS)
 227     {
 228         if (nbyte)
 229         {
 230             a_copy(ctx->ptr_ + ctx->num_, pdata, nbyte);
 231             ctx->num_ += nbyte;
 232         }
 233         ctx->ptr_[ctx->num_] = 0;
 234     }
 235     return ok;
 236 }
 237
 238 int a_str_sets_(a_str *ctx, void const *str)
 239 {
 240     return a_str_setn_(ctx, str, strlen((char const *)str));
 241 }
 242 int a_str_sets(a_str *ctx, void const *str)
 243 {
 244     return a_str_setn(ctx, str, strlen((char const *)str));
 245 }
 246
 247 int a_str_puts_(a_str *ctx, void const *str)
 248 {
 249     return a_str_putn_(ctx, str, strlen((char const *)str));
 250 }
 251 int a_str_puts(a_str *ctx, void const *str)
 252 {
 253     return a_str_putn(ctx, str, strlen((char const *)str));
 254 }
 255
 256 int a_str_set_(a_str *ctx, a_str const *obj)
 257 {
 258     return a_str_setn_(ctx, obj->ptr_, obj->num_);
 259 }
 260 int a_str_set(a_str *ctx, a_str const *obj)
 261 {
 262     return a_str_setn(ctx, obj->ptr_, obj->num_);
 263 }
 264
 265 int a_str_put_(a_str *ctx, a_str const *obj)
 266 {
 267     return a_str_putn_(ctx, obj->ptr_, obj->num_);
 268 }
 269 int a_str_put(a_str *ctx, a_str const *obj)
 270 {
 271     return a_str_putn(ctx, obj->ptr_, obj->num_);
 272 }
 273
 274 #include <stdio.h>
 275
 276 int a_str_setv(a_str *ctx, char const *fmt, va_list va)
 277 {
 278     int res;
 279     va_list ap;
 280     va_copy(ap, va);
 281     res = vsnprintf(ctx->ptr_, ctx->mem_, fmt, ap);
 282     va_end(ap);
 283     if ((a_size)res + 1 > ctx->mem_)
 284     {
 285         if (A_UNLIKELY(a_str_alloc_(ctx, (a_size)res + 1))) { return 0; }
 286         va_copy(ap, va);
 287         res = vsnprintf(ctx->ptr_, ctx->mem_, fmt, ap);
 288         va_end(ap);
 289     }
 290     if (res >= 0) { ctx->num_ = (a_size)res; }
 291     return res;
 292 }
 293
 294 int a_str_putv(a_str *ctx, char const *fmt, va_list va)
 295 {
 296     int res;
 297     va_list ap;
 298     a_size mem;
 299     char *ptr = ctx->ptr_ ? ctx->ptr_ + ctx->num_ : ctx->ptr_;
 300     va_copy(ap, va);
 301     mem = ctx->mem_ - ctx->num_;
 302     res = vsnprintf(ptr, mem, fmt, ap);
 303     mem = ctx->num_ + (a_size)(res + 1);
 304     va_end(ap);
 305     if (mem > ctx->mem_)
 306     {
 307         if (A_UNLIKELY(a_str_alloc_(ctx, mem))) { return 0; }
 308         va_copy(ap, va);
 309         ptr = ctx->ptr_ + ctx->num_;
 310         mem = ctx->mem_ - ctx->num_;
 311         res = vsnprintf(ptr, mem, fmt, ap);
 312         va_end(ap);
 313     }
 314     if (res > 0) { ctx->num_ += (a_size)res; }
 315     return res;
 316 }
 317
 318 int a_str_setf(a_str *ctx, char const *fmt, ...)
 319 {
 320     int res;
 321     va_list va;
 322     va_start(va, fmt);
 323     res = a_str_setv(ctx, fmt, va);
 324     va_end(va);
 325     return res;
 326 }
 327
 328 int a_str_putf(a_str *ctx, char const *fmt, ...)
 329 {
 330     int res;
 331     va_list va;
 332     va_start(va, fmt);
 333     res = a_str_putv(ctx, fmt, va);
 334     va_end(va);
 335     return res;
 336 }
 337
 338 #include "a/utf.h"
 339
 340 a_size a_str_utflen(a_str const *ctx)
 341 {
 342     a_size length = 0;
 343     if (ctx->num_)
 344     {
 345         char const *head = ctx->ptr_;
 346         char const *const tail = head + ctx->num_;
 347         unsigned int offset = a_utf_decode(head, A_NULL);
 348         for (; offset; offset = a_utf_decode(head, A_NULL))
 349         {
 350             ++length;
 351             head += offset;
 352             if (head >= tail) { break; }
 353         }
 354     }
 355     return length;
 356 }