dlib

Unnamed repository; edit this file 'description' to name the repository.
git clone https://git.deepztream.com/dlib
Log | Files | Refs

dlib.h (12269B)


      1 #ifndef DLIB_H
      2 #define DLIB_H 1
      3 
      4 #include <assert.h>
      5 #include <ctype.h>
      6 #include <fcntl.h>
      7 #include <limits.h>
      8 #include <stdarg.h>
      9 #include <stdio.h>
     10 #include <stdbool.h>
     11 #include <stdint.h>
     12 #include <stdlib.h>
     13 #include <errno.h>
     14 #include <string.h>
     15 #include <unistd.h>
     16 
     17 #define todo_p(msg) \
     18   do { \
     19     fprintf(stderr, "%s:%i:1: Error: TODO: %s\n", __FILE__, __LINE__, (msg)); \
     20     abort(); \
     21   } while (0)
     22 
     23 #define todo_r(msg, ret) \
     24   do { \
     25     fprintf(stderr, "%s:%i:1: Error: TODO: %s\n", __FILE__, __LINE__, (msg)); \
     26     return (ret); \
     27   } while (0)
     28 
     29 #define todo(msg) \
     30   do { \
     31     fprintf(stderr, "%s:%i:1: Error: TODO: %s\n", __FILE__, __LINE__, (msg)); \
     32     return false; \
     33   } while (0)
     34 
     35 #define unimplemented() \
     36   do { \
     37     fprintf(stderr, "%s:%i:1: Error: not implemented %s\n", __FILE__, __LINE__, __func__); \
     38     abort(); \
     39   } while (0)
     40 
     41 #define unreachable(msg) \
     42   do { \
     43     fprintf(stderr, "%s:%i:1: Error: Unreachable: %s\n", __FILE__, __LINE__, (msg)); \
     44     abort(); \
     45   } while (0)
     46 
     47 #define pop_arg(argc, argv) ((argc)--, *(argv)++)
     48 
     49 #define da_append(da, new)\
     50   do {\
     51     if ((da)->capacity <= (da)->count) {\
     52       (da)->capacity = (da)->capacity ? (da)->capacity * 2 : 16;\
     53       (da)->items = realloc((da)->items, sizeof(*(da)->items) * (da)->capacity);\
     54     }\
     55     (da)->items[(da)->count++] = (new);\
     56   } while(0)
     57 
     58 #define da_prepend(da, new)\
     59   do {\
     60     if ((da)->capacity <= (da)->count) {\
     61       (da)->capacity = (da)->capacity ? (da)->capacity * 2 : 16;\
     62       (da)->items = realloc((da)->items, sizeof(*(da)->items) * (da)->capacity);\
     63     }\
     64     memmove((da)->items + 1, (da)->items, sizeof(*(da)->items) * ((da)->count++));\
     65     (da)->items[0] = (new);\
     66   } while(0)
     67 
     68 #define da_reserve(da, len)\
     69   do {\
     70     if ((da)->capacity >= (len)) break;\
     71     (da)->capacity = (len);\
     72     (da)->items = realloc((da)->items, sizeof(*(da)->items) * (len));\
     73   } while(0)
     74 
     75 #define da_expand(da, size)\
     76   do {\
     77     if ((da)->count >= (size)) break;\
     78     da_reserve(da, size);\
     79     (da)->count = (size);\
     80   } while(0)
     81 
     82 #define da_delete(da, index)\
     83   do {\
     84     assert((size_t) index < (size_t) (da)->count);\
     85     (da)->items[index] = (da)->items[--(da)->count];\
     86   } while (0)
     87 
     88 #define da_delete_ordered(da, index)\
     89   do {\
     90     assert((size_t) index < (size_t) (da)->count);\
     91     memmove(&(da)->items[(index)], &(da)->items[(index) + 1], sizeof(*(da)->items) * ((da)->count-- - (index) - 1));\
     92   } while (0)
     93 
     94 typedef struct {
     95   union {
     96     char *items;
     97     const char *data;
     98   };
     99   union {
    100     ssize_t count;
    101     ssize_t length;
    102   };
    103   ssize_t capacity;
    104 } Sb;
    105 #define String_builder Sb
    106 
    107 typedef struct {
    108   union {
    109     const char *items;
    110     const char *data;
    111   };
    112   union {
    113     ssize_t count;
    114     ssize_t length;
    115   };
    116 } Sv;
    117 #define String_view Sv
    118 
    119 typedef struct {
    120   void *base;
    121   void *head;
    122   void *end;
    123 } Temp_allocator;
    124 
    125 #define TA_DEFAULT_SIZE (1024*1024)
    126 
    127 void ta_init(Temp_allocator *ta, size_t size);
    128 void *ta_alloc(Temp_allocator *ta, size_t size);
    129 
    130 #define sb_append_char da_append
    131 int sb_printf(Sb *sb, const char *fmt, ...);
    132 void sb_append_cstr(Sb *sb, const char *cstr);
    133 void sb_append_sv(Sb *sb, Sv sv);
    134 bool sb_append_and_unescape_sv(Sb *sb, Sv sv);
    135 
    136 bool sb_read(Sb *sb, int fd);
    137 bool sb_read_file(Sb *sb, const char *file_name);
    138 void sb_write(int fd, Sb sb);
    139 
    140 void sb_release(Sb *sb);
    141 
    142 #define sv_literal(str) ((Sv){.items = (str), .count = (sizeof (str) - 1)})
    143 
    144 Sv sv_from_sb(Sb sb);
    145 Sv sv_from_cstr(const char *cstr);
    146 const char *sv_to_cstr(Sv sv);
    147 long int sv_to_number(Sv sv, int base);
    148 ssize_t sv_find_char(Sv sv, char c);
    149 
    150 Sv sv_chop(Sv sv, ssize_t count, Sv *rest);
    151 Sv sv_chop_delim(Sv sv, char c, Sv *rest);
    152 
    153 Sv sv_getline(Sv *sv);
    154 
    155 Sv sv_trim_left(Sv sv);
    156 Sv sv_trim_right(Sv sv);
    157 Sv sv_trim(Sv sv);
    158 
    159 Sv sv_substring(Sv sv, ssize_t start, ssize_t req_count);
    160 
    161 int sv_compare(Sv sv1, Sv sv2);
    162 bool sv_equal(Sv sv1, Sv sv2);
    163 bool sv_starts_with_cstr(Sv sv, const char *cstr);
    164 bool sv_starts_with(Sv sv, Sv prefix);
    165 
    166 void sv_write(int fd, Sv sv);
    167 
    168 /* Adding missing libc functions */
    169 int ctoi(int c);
    170 #define isddigit isdigit
    171 int isbdigit(int c);
    172 int isodigit(int c);
    173 
    174 int is_digit_base(int c, int base);
    175 
    176 #ifdef DLIB_IMPLEMENTATION
    177 
    178 void
    179 ta_init(Temp_allocator *ta, size_t size)
    180 {
    181   ta->base = malloc(size);
    182   ta->head = ta->base;
    183   ta->end = ta->base + size;
    184 }
    185 
    186 void *
    187 ta_alloc(Temp_allocator *ta, size_t size)
    188 {
    189   if (!ta->base) {
    190     ta->base = malloc(TA_DEFAULT_SIZE);
    191     ta->head = ta->base;
    192     ta->end = ta->base + TA_DEFAULT_SIZE;
    193   }
    194   void *result = ta->head;
    195   ta->head += (size + 0xF) & ~0xFul;
    196   if (ta->head >= ta->end) {
    197     fprintf(stderr, "Error: Temp allocator out of memory\n");
    198     exit(1);
    199   }
    200   return result;
    201 }
    202 
    203 int
    204 sb_printf(Sb *sb, const char *fmt, ...) {
    205   va_list args, args_copy;
    206   va_start(args, fmt);
    207   va_copy(args_copy, args);
    208   int len = vsnprintf(NULL, 0, fmt, args_copy) + 1;
    209   ssize_t new_size = sb->count + len;
    210   da_reserve(sb, new_size);
    211   va_end(args_copy);
    212   vsnprintf(sb->items + sb->count, len, fmt, args);
    213   va_end(args);
    214   sb->count = new_size - 1;
    215   return len - 1;
    216 }
    217 
    218 void
    219 sb_append_cstr(Sb *sb, const char *cstr)
    220 {
    221   ssize_t len = strlen(cstr);
    222   da_reserve(sb, sb->count + len);
    223   memcpy(sb->items + sb->count, cstr, len);
    224   sb->count += len;
    225 }
    226 
    227 void
    228 sb_append_sv(Sb *sb, Sv sv)
    229 {
    230   da_reserve(sb, sb->count + sv.count);
    231   memcpy(sb->items + sb->count, sv.items, sv.count);
    232   sb->count += sv.count;
    233 }
    234 
    235 /* Returns `false` if it encounters an invalid escape character */
    236 
    237 bool
    238 sb_append_and_unescape_sv(Sb *sb, Sv sv)
    239 {
    240   bool success = true;
    241   ssize_t i;
    242   char c;
    243   for (i = 0; i < sv.count; i++) {
    244     c = sv.data[i];
    245     if (c == '\\') {
    246       if (++i >= sv.count) {
    247         success = false;
    248       } else {
    249         c = sv.data[i];
    250         if (c == 'n') {
    251           c = '\n';
    252         } else if (c == 't') {
    253           c = '\t';
    254         } else if (c == 'r') {
    255           c = '\r';
    256         } else if (c == '0') {
    257           c = '\0';
    258         } else {
    259           if (c >= 32 && c < 127) {
    260             fprintf(stderr, "Info: escape character '%c' unsupported\n", c);
    261           } else {
    262             fprintf(stderr, "Info: escape character 0x%x02 unsupported\n", c);
    263           }
    264           success = false;
    265         }
    266       }
    267     }
    268     sb_append_char(sb, c);
    269   }
    270   return success;
    271 }
    272 
    273 bool
    274 sb_read(Sb *sb, int fd)
    275 {
    276   ssize_t read_count;
    277   ssize_t buf_size = 4096;
    278   char *buf = malloc(buf_size);
    279   do {
    280     read_count = read(fd, buf, buf_size);
    281     if (read_count < 0) {
    282       if (errno == EINTR) {
    283         continue;
    284       }
    285       perror("sb_read()");
    286       return false;
    287     }
    288     if (read_count == 0) {
    289       break;
    290     }
    291     sb_append_sv(sb, ((Sv) {.items = buf, .length = read_count}));
    292     if (read_count < buf_size) {
    293       break;
    294     }
    295   } while (1);
    296   free(buf);
    297   return true;
    298 }
    299 
    300 bool
    301 sb_read_file(Sb *sb, const char *file_name)
    302 {
    303   int fd = open(file_name, O_RDONLY);
    304   if (fd < 0) {
    305     perror("sb_read()");
    306     return false;
    307   }
    308   ssize_t read_count;
    309   ssize_t buf_size = 4096;
    310   char *buf = malloc(buf_size);
    311   do {
    312     read_count = read(fd, buf, buf_size);
    313     if (read_count < 0) {
    314       if (errno == EINTR) {
    315         continue;
    316       }
    317       perror("sb_read_file()");
    318       return false;
    319     }
    320     if (read_count == 0) {
    321       break;
    322     }
    323     sb_append_sv(sb, ((Sv) {.items = buf, .length = read_count}));
    324   } while (1);
    325   free(buf);
    326   return true;
    327 }
    328 
    329 void
    330 sb_write(int fd, Sb sb)
    331 {
    332   write(fd, sb.items, sb.length);
    333 }
    334 
    335 void
    336 sb_release(Sb *sb)
    337 {
    338   if (sb->capacity) {
    339     free(sb->items);
    340     sb->items = NULL;
    341     sb->count = 0;
    342     sb->capacity = 0;
    343   }
    344 }
    345 
    346 /* String view functions */
    347 
    348 void
    349 sv_write(int fd, Sv sv)
    350 {
    351   write(fd, sv.items, sv.count);
    352 }
    353 
    354 Sv
    355 sv_from_sb(Sb sb)
    356 {
    357   return (Sv) {.items = sb.items, .count = sb.count};
    358 }
    359 
    360 Sv
    361 sv_from_cstr(const char *cstr)
    362 {
    363   return (Sv) {.items = cstr, .count = strlen(cstr)};
    364 }
    365 
    366 const char *
    367 sv_to_cstr(Sv sv)
    368 {
    369   char *cstr = malloc(sv.count + 1);
    370   memcpy(cstr, sv.data, sv.count);
    371   cstr[sv.count] = '\0';
    372   return cstr;
    373 }
    374 
    375 long int
    376 sv_to_number(Sv sv, int base)
    377 {
    378   assert(sv.count > 0 && sv.items);
    379   long int result = 0;
    380   bool negative = false;
    381   if (*sv.items == '-') {
    382     negative = true;
    383     sv.items++;
    384     sv.count--;
    385   }
    386   if (sv_starts_with_cstr(sv, "0b") ||
    387       sv_starts_with_cstr(sv, "0o") ||
    388       sv_starts_with_cstr(sv, "0d") ||
    389       sv_starts_with_cstr(sv, "0x")) {
    390     sv.items += 2;
    391     sv.count -= 2;
    392   }
    393   do {
    394     if (!is_digit_base(*sv.items, base)) {
    395       fprintf(stderr, "Error: sv_to_number: Not a valid base%i digit '%c'\n", base, *sv.items);
    396     }
    397     result *= base;
    398     result += ctoi(*sv.items);
    399     sv.items++;
    400     sv.count--;
    401   } while (sv.count);
    402   return negative ? -result : result;
    403 }
    404 
    405 ssize_t
    406 sv_find_char(Sv sv, char c)
    407 {
    408   ssize_t pos = 0;
    409   while (sv.count > pos && sv.items[pos] != c)
    410     pos++;
    411   for (pos = 0; pos < sv.count && sv.items[pos] != c; pos++);
    412   return pos < sv.count ? pos : -1;
    413 }
    414 
    415 Sv
    416 sv_chop_delim(Sv sv, char c, Sv *rest)
    417 {
    418   ssize_t pos = sv_find_char(sv, c);
    419   Sv res = sv;
    420   if (pos > 0) {
    421     res.count = pos;
    422 
    423     rest->count -= pos + 1;
    424     rest->items += pos + 1;
    425   }
    426   return res;
    427 }
    428 
    429 Sv
    430 sv_chop(Sv sv, ssize_t count, Sv *rest)
    431 {
    432   Sv left = {0};
    433   ssize_t lcount, rcount;
    434   if (count > sv.count) {
    435     lcount = sv.count;
    436     rcount = 0;
    437   } else if (-count > sv.count) {
    438     lcount = 0;
    439     rcount = sv.count;
    440   } else if (count < 0) {
    441     lcount = sv.count + count;
    442     rcount = -count;
    443   } else {
    444     lcount = count;
    445     rcount = sv.count - count;
    446   }
    447   left.items = sv.items;
    448   left.count = lcount;
    449   if (rest) {
    450     rest->items = sv.items + lcount;
    451     rest->count = rcount;
    452   }
    453   return left;
    454 }
    455 
    456 Sv
    457 sv_trim_left(Sv sv)
    458 {
    459   while (sv.count && isspace(sv.items[0])) {
    460     sv.count--;
    461     sv.items++;
    462   }
    463   return sv;
    464 }
    465 
    466 Sv
    467 sv_trim_right(Sv sv)
    468 {
    469   while (sv.count && isspace(sv.items[sv.count - 1])) {
    470     sv.count--;
    471   }
    472   return sv;
    473 }
    474 
    475 Sv
    476 sv_trim(Sv sv)
    477 {
    478   return sv_trim_right(sv_trim_left(sv));
    479 }
    480 
    481 Sv
    482 sv_substring(Sv sv, ssize_t start, ssize_t req_count)
    483 {
    484   Sv ss = {0};
    485   if (start >= sv.count) return ss;
    486   ss.count = (req_count < sv.count - start) ? req_count : sv.count - start;
    487   ss.items = sv.items + start;
    488   return ss;
    489 }
    490 
    491 int
    492 sv_compare(Sv sv1, Sv sv2)
    493 {
    494   if (sv1.items == sv2.items && sv1.count == sv2.count) return 0;
    495   signed char diff;
    496   ssize_t pos;
    497   for (pos = 0; pos < sv1.count; pos++) {
    498     if (pos == sv2.count) return 1;
    499     if ((diff = sv1.items[pos] - sv2.items[pos])) return diff;
    500   }
    501   return pos < sv2.count ? -1 : 0;
    502 }
    503 
    504 bool
    505 sv_equal(Sv sv1, Sv sv2)
    506 {
    507   if (sv1.count != sv2.count) return false;
    508   if (sv1.items == sv2.items) return true;
    509   ssize_t pos;
    510   for (pos = 0; pos < sv1.count && sv1.items[pos] == sv2.items[pos]; pos++);
    511   return pos == sv1.count;
    512 }
    513 
    514 bool
    515 sv_starts_with_cstr(Sv sv, const char *cstr)
    516 {
    517   size_t cstr_len = strlen(cstr);
    518   assert(cstr_len <= SSIZE_MAX);
    519   if (sv.count < (ssize_t) cstr_len) return false;
    520   ssize_t pos;
    521   for (pos = 0; pos < (ssize_t) cstr_len && sv.items[pos] == cstr[pos]; pos++);
    522   return pos == (ssize_t) cstr_len;
    523 }
    524 
    525 bool
    526 sv_starts_with(Sv sv, Sv prefix)
    527 {
    528   if (sv.count < prefix.count) return false;
    529   ssize_t pos;
    530   for (pos = 0; pos < prefix.count && sv.items[pos] == prefix.items[pos]; pos++);
    531   return pos == prefix.count;
    532 }
    533 
    534 Sv
    535 sv_getline(Sv *sv)
    536 {
    537   Sv line = sv_chop_delim(*sv, '\n', sv);
    538   if (line.count && line.items[line.count - 1] == '\r') {
    539     line.count--;
    540   }
    541   return line;
    542 }
    543 
    544 int
    545 isbdigit(int c)
    546 {
    547   if (c > 127) {
    548     todo_p("unicode support");
    549   }
    550   return c == '0' || c == '1';
    551 }
    552 
    553 int
    554 isodigit(int c)
    555 {
    556   if (c > 127) {
    557     todo_p("unicode support");
    558   }
    559   return c == '0' || c == '1' || c == '2' || c == '3' ||
    560          c == '4' || c == '5' || c == '6' || c == '7';
    561 }
    562 
    563 int
    564 is_digit_base(int c, int base)
    565 {
    566   if (base == 2)  return isbdigit(c);
    567   if (base == 8)  return isodigit(c);
    568   if (base == 10) return isddigit(c);
    569   if (base == 16) return isxdigit(c);
    570   fprintf(stderr, "Error: is_digit_base: invalid base %i\n", base);
    571   return 0;
    572 }
    573 
    574 int
    575 ctoi(int c)
    576 {
    577   if (c >= '0' && c <= '9') return c - '0';
    578   if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
    579   if (c >= 'a' && c <= 'z') return c - 'a' + 10;
    580   fprintf(stderr, "Error: ctoi: invalid digit '%c'\n", c);
    581   return 0;
    582 }
    583 
    584 #endif // DLIB_IMPLEMENTATION
    585 
    586 #endif // DLIB_H