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