From a9e0bd32552c0ae8a6f1f1525fd05ad221d7393a Mon Sep 17 00:00:00 2001 From: Anas Elgarhy Date: Sun, 15 Mar 2026 08:31:12 +0200 Subject: [PATCH] clean: remove the compiler outputs --- tests/lib/std/test_http.exe | Bin 125640 -> 0 bytes tests/lib/std/test_http.exe.c | 8334 --------------------------------- 2 files changed, 8334 deletions(-) delete mode 100755 tests/lib/std/test_http.exe delete mode 100644 tests/lib/std/test_http.exe.c diff --git a/tests/lib/std/test_http.exe b/tests/lib/std/test_http.exe deleted file mode 100755 index cb7e50865ab645461523b703a73b32d1dd01efbb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 125640 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 diff --git a/tests/lib/std/test_http.exe.c b/tests/lib/std/test_http.exe.c deleted file mode 100644 index 317c3000..00000000 --- a/tests/lib/std/test_http.exe.c +++ /dev/null @@ -1,8334 +0,0 @@ -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif -#include -#include -#include -#include -#include -#include -#include -double _zc_pow(double, double) __asm__("pow"); -#include -#include -#define ZC_SIMD(T, N) T __attribute__((vector_size(N * sizeof(T)))) -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202300L -#define ZC_AUTO auto -#define ZC_AUTO_INIT(var, init) auto var = (init) -#else -#define ZC_AUTO __auto_type -#define ZC_AUTO_INIT(var, init) __auto_type var = (init) -#endif -#define ZC_CAST(T, x) ((T)(x)) -#ifdef __TINYC__ -#undef ZC_AUTO -#define ZC_AUTO __auto_type -#undef ZC_AUTO_INIT -#define ZC_AUTO_INIT(var, init) __typeof__((init)) var = (init) - -#ifndef __builtin_expect -#define __builtin_expect(x, v) (x) -#endif - -#ifndef __builtin_unreachable -#define __builtin_unreachable() -#endif -#else -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202300L -#define ZC_AUTO_INIT(var, init) auto var = (init) -#else -#define ZC_AUTO_INIT(var, init) __auto_type var = (init) -#endif -#endif -static inline const char *_z_bool_str(_Bool b) -{ - return b ? "true" : "false"; -} -#ifdef __SIZEOF_INT128__ -static inline const char *_z_u128_str(unsigned __int128 val) -{ - static _Thread_local char buf[40]; - if (val == 0) - { - return "0"; - } - int i = 38; - buf[39] = 0; - while (val > 0) - { - buf[i--] = (char)((val % 10) + '0'); - val /= 10; - } - return &buf[i + 1]; -} -static inline const char *_z_i128_str(__int128 val) -{ - static _Thread_local char buf[41]; - if (val == 0) - { - return "0"; - } - int neg = val < 0; - unsigned __int128 uval = neg ? -val : val; - int i = 39; - buf[40] = 0; - while (uval > 0) - { - buf[i--] = (char)((uval % 10) + '0'); - uval /= 10; - } - if (neg) - { - buf[i--] = '-'; - } - return &buf[i + 1]; -} -#define _z_128_map , __int128 : "%s", unsigned __int128 : "%s" -#else -#define _z_128_map -#endif -#ifdef __OBJC__ -#define _z_objc_map , id : "%s", Class : "%s", SEL : "%s" -#define _z_objc_arg_map(x) \ - , id : [(id)(x) description].UTF8String, Class : class_getName((Class)(x)), \ - SEL : sel_getName((SEL)(x)) -#else -#define _z_objc_map -#define _z_objc_arg_map(x) -#endif - -#define _z_str(x) \ - _Generic((x), \ - _Bool: "%s", \ - char: "%c", \ - signed char: "%c", \ - unsigned char: "%u", \ - short: "%d", \ - unsigned short: "%u", \ - int: "%d", \ - unsigned int: "%u", \ - long: "%ld", \ - unsigned long: "%lu", \ - long long: "%lld", \ - unsigned long long: "%llu", \ - float: "%f", \ - double: "%f", \ - char *: "%s", \ - const char *: "%s", \ - void *: "%p" _z_128_map _z_objc_map) -#ifdef __SIZEOF_INT128__ -#define _z_safe_i128(x) _Generic((x), __int128: (x), default: (__int128)0) -#define _z_safe_u128(x) _Generic((x), unsigned __int128: (x), default: (unsigned __int128)0) -#define _z_128_arg_map(x) \ - , __int128 : _z_i128_str(_z_safe_i128(x)), unsigned __int128 : _z_u128_str(_z_safe_u128(x)) -#else -#define _z_128_arg_map(x) -#endif -#define _z_safe_bool(x) _Generic((x), _Bool: (x), default: (_Bool)0) -#define _z_arg(x) \ - _Generic((x), \ - _Bool: _z_bool_str(_z_safe_bool(x)) _z_128_arg_map(x) _z_objc_arg_map(x), \ - default: (x)) -typedef size_t usize; -typedef char *string; -typedef struct -{ - void *func; - void *ctx; - void (*drop)(void *); -} z_closure_T; -static void *_z_closure_ctx_stash[256]; -typedef void U0; -typedef int8_t I8; -typedef uint8_t U8; -typedef int16_t I16; -typedef uint16_t U16; -typedef int32_t I32; -typedef uint32_t U32; -typedef int64_t I64; -typedef uint64_t U64; -#define F32 float -#define F64 double -#define z_malloc malloc -#define z_realloc realloc -#define z_free free -#define z_print printf -void z_panic(const char *msg) -{ - fprintf(stderr, "Panic: %s\n", msg); - exit(1); -} -#if defined(__APPLE__) -#define _ZC_SEC __attribute__((used, section("__DATA,__zarch"))) -#elif defined(_WIN32) -#define _ZC_SEC __attribute__((used)) -#else -#define _ZC_SEC __attribute__((used, section(".note.zarch"))) -#endif -static const unsigned char _zc_abi_v1[] _ZC_SEC = {0x07, 0xd5, 0x59, 0x30, 0x7c, 0x7f, 0x66, - 0x75, 0x30, 0x69, 0x7f, 0x65, 0x3c, 0x30, - 0x59, 0x7c, 0x79, 0x7e, 0x73, 0x71}; -void _z_autofree_impl(void *p) -{ - void **pp = (void **)p; - if (*pp) - { - z_free(*pp); - *pp = NULL; - } -} -#define assert(cond, ...) \ - if (!(cond)) \ - { \ - fprintf(stderr, "Assertion failed: " __VA_ARGS__); \ - exit(1); \ - } -string _z_readln_raw() -{ - size_t cap = 64; - size_t len = 0; - char *line = z_malloc(cap); - if (!line) - { - return NULL; - } - int c; - while ((c = fgetc(stdin)) != EOF) - { - if (c == '\n') - { - break; - } - if (len + 1 >= cap) - { - cap *= 2; - char *n = z_realloc(line, cap); - if (!n) - { - z_free(line); - return NULL; - } - line = n; - } - line[len++] = c; - } - if (len == 0 && c == EOF) - { - z_free(line); - return NULL; - } - line[len] = 0; - return line; -} -int _z_scan_helper(const char *fmt, ...) -{ - char *l = _z_readln_raw(); - if (!l) - { - return 0; - } - va_list ap; - va_start(ap, fmt); - int r = vsscanf(l, fmt, ap); - va_end(ap); - z_free(l); - return r; -} -int _z_orig_stdout = -1; -void _z_suppress_stdout() -{ - fflush(stdout); - if (_z_orig_stdout == -1) - { - _z_orig_stdout = dup(STDOUT_FILENO); - } - int nullfd = open("/dev/null", O_WRONLY); - dup2(nullfd, STDOUT_FILENO); - close(nullfd); -} -void _z_restore_stdout() -{ - fflush(stdout); - if (_z_orig_stdout != -1) - { - dup2(_z_orig_stdout, STDOUT_FILENO); - close(_z_orig_stdout); - _z_orig_stdout = -1; - } -} -#include -#include -#include -#include -#include -#include -#include -#include -typedef char *string; -typedef struct -{ - void **data; - int len; - int cap; -} Vec; -#define Vec_new() (Vec){.data = 0, .len = 0, .cap = 0} -void _z_vec_push(Vec *v, void *item) -{ - if (v->len >= v->cap) - { - v->cap = v->cap ? v->cap * 2 : 8; - v->data = z_realloc(v->data, v->cap * sizeof(void *)); - } - v->data[v->len++] = item; -} -static inline Vec _z_make_vec(int count, ...) -{ - Vec v = {0}; - v.cap = count > 8 ? count : 8; - v.data = z_malloc(v.cap * sizeof(void *)); - v.len = 0; - va_list args; - va_start(args, count); - for (int i = 0; i < count; i++) - { - v.data[v.len++] = va_arg(args, void *); - } - va_end(args); - return v; -} -#define Vec_push(v, i) _z_vec_push(&(v), (void *)(uintptr_t)(i)) -static inline long _z_check_bounds(long index, long limit) -{ - if (index < 0 || index >= limit) - { - fprintf(stderr, "Index out of bounds: %ld (limit %ld)\n", index, limit); - exit(1); - } - return index; -} - -typedef struct Result_bool Result_bool; -typedef struct VecIterResult_Header VecIterResult_Header; -typedef struct VecIterRef_Header VecIterRef_Header; -typedef struct VecIter_Header VecIter_Header; -typedef struct Vec_Header Vec_Header; -typedef struct Result_size_t Result_size_t; -typedef struct VecIterResult_String VecIterResult_String; -typedef struct VecIterRef_String VecIterRef_String; -typedef struct VecIter_String VecIter_String; -typedef struct Vec_String Vec_String; -typedef struct VecIterResult_int32_t VecIterResult_int32_t; -typedef struct VecIterRef_int32_t VecIterRef_int32_t; -typedef struct VecIter_int32_t VecIter_int32_t; -typedef struct Vec_int32_t Vec_int32_t; -typedef struct VecIterResult_size_t VecIterResult_size_t; -typedef struct VecIterRef_size_t VecIterRef_size_t; -typedef struct VecIter_size_t VecIter_size_t; -typedef struct Vec_size_t Vec_size_t; -typedef struct Option_size_t Option_size_t; -typedef struct Option_int32_t Option_int32_t; -typedef struct VecIterResult_char VecIterResult_char; -typedef struct VecIterRef_char VecIterRef_char; -typedef struct Option_char Option_char; -typedef struct VecIter_char VecIter_char; -typedef struct Vec_char Vec_char; -typedef struct Mutex Mutex; -typedef struct Thread Thread; -typedef struct Dns Dns; -typedef struct Server Server; -typedef struct TcpListener TcpListener; -typedef struct TcpStream TcpStream; -typedef struct StringCharsIter StringCharsIter; -typedef struct String String; -typedef struct Sort Sort; -typedef struct Result_Thread Result_Thread; -typedef struct Result_String Result_String; -typedef struct Result_TcpListener Result_TcpListener; -typedef struct Result_TcpStream Result_TcpStream; -typedef struct Option_String Option_String; -typedef struct Url Url; -typedef struct Response Response; -typedef struct Request Request; -typedef struct Header Header; -typedef struct Result_Url Result_Url; -typedef struct Option_Header Option_Header; -typedef struct Clone_VTable -{ - void *(*clone)(void *self); -} Clone_VTable; -typedef struct Clone -{ - void *self; - Clone_VTable *vtable; -} Clone; -Clone Clone__clone(Clone *self) -{ - void *ret = self->vtable->clone(self->self); - return (Clone){.self = ret, .vtable = self->vtable}; -} - -typedef struct Copy_VTable -{ -} Copy_VTable; -typedef struct Copy -{ - void *self; - Copy_VTable *vtable; -} Copy; - -typedef struct Drop_VTable -{ - void (*drop)(void *self); -} Drop_VTable; -typedef struct Drop -{ - void *self; - Drop_VTable *vtable; -} Drop; -void Drop__drop(Drop *self) -{ - return self->vtable->drop(self->self); -} - -#define panic(msg) _zen_panic(__FILE__, __LINE__, __func__, msg) - -#define ZC_IMPL_SORT(T) \ - static int _z_partition_##T(T *arr, int low, int high) \ - { \ - T pivot = arr[high]; \ - int i = low - 1; \ - for (int j = low; j < high; j++) \ - { \ - if (arr[j] < pivot) \ - { \ - i++; \ - T temp = arr[i]; \ - arr[i] = arr[j]; \ - arr[j] = temp; \ - } \ - } \ - T temp2 = arr[i + 1]; \ - arr[i + 1] = arr[high]; \ - arr[high] = temp2; \ - return i + 1; \ - } \ - static void _z_quick_sort_##T(T *arr, int low, int high) \ - { \ - if (low < high) \ - { \ - int pivot_idx = _z_partition_##T(arr, low, high); \ - _z_quick_sort_##T(arr, low, pivot_idx - 1); \ - _z_quick_sort_##T(arr, pivot_idx + 1, high); \ - } \ - } \ - void sort_##T(T *arr, size_t len) \ - { \ - if (len > 1) \ - { \ - _z_quick_sort_##T(arr, 0, (int)len - 1); \ - } \ - } - -// Pre-declare standard library types -ZC_IMPL_SORT(int) -ZC_IMPL_SORT(long) -ZC_IMPL_SORT(float) -ZC_IMPL_SORT(double) - -#ifdef _WIN32 -#include -#include -#pragma comment(lib, "ws2_32.lib") -typedef int socklen_t; -#include -typedef intptr_t ssize_t; -#else -#include -#include -#include -#include -#include -#include -#endif - -#ifdef _WIN32 -int _z_net_initialized = 0; -void _z_net_ensure_init(void) -{ - if (!_z_net_initialized) - { - WSADATA wsaData; - WSAStartup(MAKEWORD(2, 2), &wsaData); - _z_net_initialized = 1; - } -} -#else -void _z_net_ensure_init(void) -{ -} -#endif - -static ssize_t _z_socket(int domain, int type, int proto) -{ -#ifdef _WIN32 - _z_net_ensure_init(); - return (ssize_t)socket(domain, type, proto); -#else - return socket(domain, type, proto); -#endif -} - -static int _z_close(ssize_t fd) -{ -#ifdef _WIN32 - return closesocket((SOCKET)fd); -#else - return close((int)fd); -#endif -} - -static ssize_t _z_read(ssize_t fd, void *buf, size_t count) -{ -#ifdef _WIN32 - return recv((SOCKET)fd, (char *)buf, (int)count, 0); -#else - return read((int)fd, buf, count); -#endif -} - -static int _z_net_bind(ssize_t fd, const char *host, int port) -{ - struct sockaddr_in addr; - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) - { - return -1; - } - - int opt = 1; -#ifdef _WIN32 - setsockopt((SOCKET)fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)); - if (bind((SOCKET)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } - if (listen((SOCKET)fd, 10) < 0) - { - return -3; - } -#else - setsockopt((int)fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); - if (bind((int)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } - if (listen((int)fd, 10) < 0) - { - return -3; - } -#endif - return 0; -} - -static int _z_net_bind_udp(ssize_t fd, const char *host, int port) -{ - struct sockaddr_in addr; - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) - { - return -1; - } - - int opt = 1; -#ifdef _WIN32 - setsockopt((SOCKET)fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)); - if (bind((SOCKET)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } -#else - setsockopt((int)fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); - if (bind((int)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } -#endif - return 0; -} - -static int _z_net_connect(ssize_t fd, const char *host, int port) -{ - struct sockaddr_in addr; - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) - { - return -1; - } - -#ifdef _WIN32 - if (connect((SOCKET)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } -#else - if (connect((int)fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) - { - return -2; - } -#endif - return 0; -} - -static ssize_t _z_net_accept(ssize_t fd) -{ -#ifdef _WIN32 - return (ssize_t)accept((SOCKET)fd, NULL, NULL); -#else - return accept((int)fd, NULL, NULL); -#endif -} - -static ssize_t _z_net_write(ssize_t fd, const char *buf, size_t n) -{ -#ifdef _WIN32 - return send((SOCKET)fd, buf, (int)n, 0); -#else - return write((int)fd, (const void *)buf, n); -#endif -} - -static ssize_t _z_net_recvfrom(ssize_t fd, char *buf, size_t len, char *host_out, int *port_out) -{ - struct sockaddr_in addr; - socklen_t addr_len = sizeof(addr); -#ifdef _WIN32 - ssize_t n = recvfrom((SOCKET)fd, buf, (int)len, 0, (struct sockaddr *)&addr, &addr_len); -#else - ssize_t n = recvfrom((int)fd, buf, len, 0, (struct sockaddr *)&addr, &addr_len); -#endif - if (n >= 0 && host_out != NULL && port_out != NULL) - { - inet_ntop(AF_INET, &addr.sin_addr, host_out, INET_ADDRSTRLEN); - *port_out = ntohs(addr.sin_port); - } - return n; -} - -static ssize_t _z_net_sendto(ssize_t fd, const char *buf, size_t len, const char *host, int port) -{ - struct sockaddr_in addr; - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) - { - return -1; - } - -#ifdef _WIN32 - return sendto((SOCKET)fd, buf, (int)len, 0, (struct sockaddr *)&addr, sizeof(addr)); -#else - return sendto((int)fd, buf, len, 0, (struct sockaddr *)&addr, sizeof(addr)); -#endif -} - -static int _z_dns_resolve(const char *host, char *out_buf, size_t out_len) -{ - _z_net_ensure_init(); - struct addrinfo hints; - struct addrinfo *result, *rp; - - memset(&hints, 0, sizeof(struct addrinfo)); - hints.ai_family = AF_INET; // Allow IPv4 - hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = 0; - hints.ai_protocol = 0; /* Any protocol */ - - int s = getaddrinfo(host, NULL, &hints, &result); - if (s != 0) - { - return s; - } - - // Just pick the first one for now - int found = 0; - for (rp = result; rp != NULL; rp = rp->ai_next) - { - struct sockaddr_in *ipv4 = (struct sockaddr_in *)rp->ai_addr; - void *addr = &(ipv4->sin_addr); - - if (inet_ntop(rp->ai_family, addr, out_buf, out_len) != NULL) - { - found = 1; - break; - } - } - - freeaddrinfo(result); - return found ? 0 : -1; -} - -struct Result_bool -{ - bool is_ok; - bool val; - char *err; -}; - -struct VecIterResult_Header -{ - Header *ptr; -}; - -struct VecIterRef_Header -{ - Header *data; - size_t count; - size_t idx; -}; - -struct VecIter_Header -{ - Header *data; - size_t count; - size_t idx; -}; - -struct Vec_Header -{ - Header *data; - size_t len; - size_t cap; -}; - -struct Result_size_t -{ - bool is_ok; - size_t val; - char *err; -}; - -struct VecIterResult_String -{ - String *ptr; -}; - -struct VecIterRef_String -{ - String *data; - size_t count; - size_t idx; -}; - -struct VecIter_String -{ - String *data; - size_t count; - size_t idx; -}; - -struct Vec_String -{ - String *data; - size_t len; - size_t cap; -}; - -struct VecIterResult_int32_t -{ - int32_t *ptr; -}; - -struct VecIterRef_int32_t -{ - int32_t *data; - size_t count; - size_t idx; -}; - -struct VecIter_int32_t -{ - int32_t *data; - size_t count; - size_t idx; -}; - -struct Vec_int32_t -{ - int32_t *data; - size_t len; - size_t cap; -}; - -struct VecIterResult_size_t -{ - size_t *ptr; -}; - -struct VecIterRef_size_t -{ - size_t *data; - size_t count; - size_t idx; -}; - -struct VecIter_size_t -{ - size_t *data; - size_t count; - size_t idx; -}; - -struct Vec_size_t -{ - size_t *data; - size_t len; - size_t cap; -}; - -struct Option_size_t -{ - bool is_some; - size_t val; -}; - -struct Option_int32_t -{ - bool is_some; - int32_t val; -}; - -struct VecIterResult_char -{ - char *ptr; -}; - -struct VecIterRef_char -{ - char *data; - size_t count; - size_t idx; -}; - -struct Option_char -{ - bool is_some; - char val; -}; - -struct VecIter_char -{ - char *data; - size_t count; - size_t idx; -}; - -struct Vec_char -{ - char *data; - size_t len; - size_t cap; -}; - -struct Mutex -{ - void *handle; -}; - -struct Thread -{ - void *handle; -}; - -struct Dns -{ - char _placeholder; -}; - -struct Server -{ - int32_t port; - void (*handler)(Request *, Response *); -}; - -struct TcpListener -{ - ptrdiff_t handle; -}; - -struct TcpStream -{ - ptrdiff_t handle; -}; - -struct StringCharsIter -{ - char *data; - size_t len; - size_t pos; -}; - -struct String -{ - Vec_char vec; -}; - -struct Sort -{ - char _placeholder; -}; - -struct Result_Thread -{ - bool is_ok; - Thread val; - char *err; -}; - -struct Result_String -{ - bool is_ok; - String val; - char *err; -}; - -struct Result_TcpListener -{ - bool is_ok; - TcpListener val; - char *err; -}; - -struct Result_TcpStream -{ - bool is_ok; - TcpStream val; - char *err; -}; - -struct Option_String -{ - bool is_some; - String val; -}; - -struct Url -{ - String scheme; - String host; - int32_t port; - String path; - String query; -}; - -struct Response -{ - int32_t status; - Vec_Header headers; - String body; -}; - -struct Request -{ - String method; - String path; - Vec_Header headers; - String body; -}; - -struct Header -{ - String key; - String value; -}; - -struct Result_Url -{ - bool is_ok; - Url val; - char *err; -}; - -struct Option_Header -{ - bool is_some; - Header val; -}; - -typedef void (*ZenThreadFunc)(void *); - -struct ZenThreadCtx -{ - void *func_ptr; - void *ctx; -}; - -static void *_z_thread_trampoline(void *arg) -{ - z_closure_T *closure = (z_closure_T *)arg; - void (*f)(void *) = (void (*)(void *))closure->func; - f(closure->ctx); - if (closure->drop) - { - closure->drop(closure->ctx); - } - free(closure); - return NULL; -} - -static int _z_thread_equal(void *handle1, void *handle2) -{ - return pthread_equal((pthread_t)handle1, (pthread_t)handle2); -} - -static int _z_thread_spawn(void *ctx_copy, size_t *out_handle) -{ - pthread_t pt; - int ret = pthread_create(&pt, NULL, _z_thread_trampoline, ctx_copy); - if (ret == 0) - { - *out_handle = (size_t)pt; - } - return (int)ret; -} - -static int _z_thread_join(void *handle) -{ - return (int)pthread_join((pthread_t)handle, NULL); -} - -static int _z_thread_detach(void *handle) -{ - return pthread_detach((pthread_t)handle); -} - -static int _z_thread_cancel(void *handle) -{ - return pthread_cancel((pthread_t)handle); -} - -static void _z_mutex_init(void *ptr) -{ - pthread_mutex_init((pthread_mutex_t *)ptr, NULL); -} - -static void _z_mutex_lock(void *ptr) -{ - pthread_mutex_lock((pthread_mutex_t *)ptr); -} - -static void _z_mutex_unlock(void *ptr) -{ - pthread_mutex_unlock((pthread_mutex_t *)ptr); -} - -static void _z_mutex_destroy(void *ptr) -{ - pthread_mutex_destroy((pthread_mutex_t *)ptr); -} - -static void _z_usleep(int micros) -{ - usleep(micros); -} - -const int Z_AF_INET = 2; -const int Z_SOCK_STREAM = 1; -const int Z_SOCK_DGRAM = 2; -size_t __zen_hash_seed = 14695981039346656037ULL; -const size_t _HASH_MAGIC = 1099511628211; -Result_bool Result_bool__Ok(bool v); -Result_bool Result_bool__Err(char *e); -bool Result_bool__is_ok(Result_bool *self); -bool Result_bool__is_err(Result_bool *self); -void Result_bool__forget(Result_bool *self); -bool Result_bool__unwrap(Result_bool *self); -bool *Result_bool__unwrap_ref(Result_bool *self); -bool Result_bool__expect(Result_bool *self, char *msg); -Result_Thread Result_Thread__Ok(Thread v); -Result_Thread Result_Thread__Err(char *e); -bool Result_Thread__is_ok(Result_Thread *self); -bool Result_Thread__is_err(Result_Thread *self); -void Result_Thread__forget(Result_Thread *self); -Thread Result_Thread__unwrap(Result_Thread *self); -Thread *Result_Thread__unwrap_ref(Result_Thread *self); -Thread Result_Thread__expect(Result_Thread *self, char *msg); -Result_String Result_String__Ok(String v); -Result_String Result_String__Err(char *e); -bool Result_String__is_ok(Result_String *self); -bool Result_String__is_err(Result_String *self); -void Result_String__forget(Result_String *self); -String Result_String__unwrap(Result_String *self); -String *Result_String__unwrap_ref(Result_String *self); -String Result_String__expect(Result_String *self, char *msg); -Result_Url Result_Url__Ok(Url v); -Result_Url Result_Url__Err(char *e); -bool Result_Url__is_ok(Result_Url *self); -bool Result_Url__is_err(Result_Url *self); -void Result_Url__forget(Result_Url *self); -Url Result_Url__unwrap(Result_Url *self); -Url *Result_Url__unwrap_ref(Result_Url *self); -Url Result_Url__expect(Result_Url *self, char *msg); -Vec_Header Vec_Header__new(void); -Vec_Header Vec_Header__with_capacity(size_t cap); -void Vec_Header__grow(Vec_Header *self); -void Vec_Header__grow_to_fit(Vec_Header *self, size_t new_len); -VecIter_Header Vec_Header__iterator(Vec_Header *self); -VecIterRef_Header Vec_Header__iter_ref(Vec_Header *self); -void Vec_Header__push(Vec_Header *self, Header item); -void Vec_Header__insert(Vec_Header *self, size_t idx, Header item); -Header Vec_Header__pop(Vec_Header *self); -Option_Header Vec_Header__pop_opt(Vec_Header *self); -Header Vec_Header__remove(Vec_Header *self, size_t idx); -void Vec_Header__append(Vec_Header *self, Vec_Header other); -Header Vec_Header__get(Vec_Header *self, size_t idx); -Header Vec_Header__index(Vec_Header *self, size_t idx); -Header *Vec_Header__get_ref(Vec_Header *self, size_t idx); -Header Vec_Header__last(Vec_Header *self); -size_t Vec_Header__length(Vec_Header *self); -bool Vec_Header__contains(Vec_Header *self, Header item); -bool Vec_Header__is_empty(Vec_Header *self); -void Vec_Header__clear(Vec_Header *self); -void Vec_Header__free(Vec_Header *self); -Header Vec_Header__first(Vec_Header *self); -void Vec_Header__set(Vec_Header *self, size_t idx, Header item); -void Vec_Header__reverse(Vec_Header *self); -bool Vec_Header__eq(Vec_Header *self, Vec_Header *other); -void Vec_Header__forget(Vec_Header *self); -Vec_Header Vec_Header__add(Vec_Header *self, Vec_Header *other); -void Vec_Header__add_assign(Vec_Header *self, Vec_Header *other); -bool Vec_Header__neq(Vec_Header *self, Vec_Header *other); -void Vec_Header__shl(Vec_Header *self, Header item); -void Vec_Header__shr(Vec_Header *self, Header *out_item); -Vec_Header Vec_Header__mul(Vec_Header *self, size_t count); -void Vec_Header__mul_assign(Vec_Header *self, size_t count); -Vec_Header Vec_Header__clone(Vec_Header *self); -VecIterResult_Header VecIterRef_Header__next(VecIterRef_Header *self); -VecIterRef_Header VecIterRef_Header__iterator(VecIterRef_Header *self); -bool VecIterResult_Header__is_none(VecIterResult_Header *self); -Header *VecIterResult_Header__unwrap(VecIterResult_Header *self); -Option_Header VecIter_Header__next(VecIter_Header *self); -VecIter_Header VecIter_Header__iterator(VecIter_Header *self); -Option_Header Option_Header__Some(Header v); -Option_Header Option_Header__None(void); -bool Option_Header__is_some(Option_Header *self); -bool Option_Header__is_none(Option_Header *self); -void Option_Header__forget(Option_Header *self); -Header Option_Header__unwrap(Option_Header *self); -Header *Option_Header__unwrap_ref(Option_Header *self); -Header Option_Header__unwrap_or(Option_Header *self, Header def_val); -Header Option_Header__expect(Option_Header *self, char *msg); -Option_Header Option_Header__or_else(Option_Header *self, Option_Header other); -void Vec_Header__Drop_drop(Vec_Header *self); -Result_TcpListener Result_TcpListener__Ok(TcpListener v); -Result_TcpListener Result_TcpListener__Err(char *e); -bool Result_TcpListener__is_ok(Result_TcpListener *self); -bool Result_TcpListener__is_err(Result_TcpListener *self); -void Result_TcpListener__forget(Result_TcpListener *self); -TcpListener Result_TcpListener__unwrap(Result_TcpListener *self); -TcpListener *Result_TcpListener__unwrap_ref(Result_TcpListener *self); -TcpListener Result_TcpListener__expect(Result_TcpListener *self, char *msg); -Result_TcpStream Result_TcpStream__Ok(TcpStream v); -Result_TcpStream Result_TcpStream__Err(char *e); -bool Result_TcpStream__is_ok(Result_TcpStream *self); -bool Result_TcpStream__is_err(Result_TcpStream *self); -void Result_TcpStream__forget(Result_TcpStream *self); -TcpStream Result_TcpStream__unwrap(Result_TcpStream *self); -TcpStream *Result_TcpStream__unwrap_ref(Result_TcpStream *self); -TcpStream Result_TcpStream__expect(Result_TcpStream *self, char *msg); -Result_size_t Result_size_t__Ok(size_t v); -Result_size_t Result_size_t__Err(char *e); -bool Result_size_t__is_ok(Result_size_t *self); -bool Result_size_t__is_err(Result_size_t *self); -void Result_size_t__forget(Result_size_t *self); -size_t Result_size_t__unwrap(Result_size_t *self); -size_t *Result_size_t__unwrap_ref(Result_size_t *self); -size_t Result_size_t__expect(Result_size_t *self, char *msg); -Vec_String Vec_String__new(void); -Vec_String Vec_String__with_capacity(size_t cap); -void Vec_String__grow(Vec_String *self); -void Vec_String__grow_to_fit(Vec_String *self, size_t new_len); -VecIter_String Vec_String__iterator(Vec_String *self); -VecIterRef_String Vec_String__iter_ref(Vec_String *self); -void Vec_String__push(Vec_String *self, String item); -void Vec_String__insert(Vec_String *self, size_t idx, String item); -String Vec_String__pop(Vec_String *self); -Option_String Vec_String__pop_opt(Vec_String *self); -String Vec_String__remove(Vec_String *self, size_t idx); -void Vec_String__append(Vec_String *self, Vec_String other); -String Vec_String__get(Vec_String *self, size_t idx); -String Vec_String__index(Vec_String *self, size_t idx); -String *Vec_String__get_ref(Vec_String *self, size_t idx); -String Vec_String__last(Vec_String *self); -size_t Vec_String__length(Vec_String *self); -bool Vec_String__contains(Vec_String *self, String item); -bool Vec_String__is_empty(Vec_String *self); -void Vec_String__clear(Vec_String *self); -void Vec_String__free(Vec_String *self); -String Vec_String__first(Vec_String *self); -void Vec_String__set(Vec_String *self, size_t idx, String item); -void Vec_String__reverse(Vec_String *self); -bool Vec_String__eq(Vec_String *self, Vec_String *other); -void Vec_String__forget(Vec_String *self); -Vec_String Vec_String__add(Vec_String *self, Vec_String *other); -void Vec_String__add_assign(Vec_String *self, Vec_String *other); -bool Vec_String__neq(Vec_String *self, Vec_String *other); -void Vec_String__shl(Vec_String *self, String item); -void Vec_String__shr(Vec_String *self, String *out_item); -Vec_String Vec_String__mul(Vec_String *self, size_t count); -void Vec_String__mul_assign(Vec_String *self, size_t count); -Vec_String Vec_String__clone(Vec_String *self); -VecIterResult_String VecIterRef_String__next(VecIterRef_String *self); -VecIterRef_String VecIterRef_String__iterator(VecIterRef_String *self); -bool VecIterResult_String__is_none(VecIterResult_String *self); -String *VecIterResult_String__unwrap(VecIterResult_String *self); -Option_String VecIter_String__next(VecIter_String *self); -VecIter_String VecIter_String__iterator(VecIter_String *self); -Option_String Option_String__Some(String v); -Option_String Option_String__None(void); -bool Option_String__is_some(Option_String *self); -bool Option_String__is_none(Option_String *self); -void Option_String__forget(Option_String *self); -String Option_String__unwrap(Option_String *self); -String *Option_String__unwrap_ref(Option_String *self); -String Option_String__unwrap_or(Option_String *self, String def_val); -String Option_String__expect(Option_String *self, char *msg); -Option_String Option_String__or_else(Option_String *self, Option_String other); -void Vec_String__Drop_drop(Vec_String *self); -Vec_int32_t Vec_int32_t__new(void); -Vec_int32_t Vec_int32_t__with_capacity(size_t cap); -void Vec_int32_t__grow(Vec_int32_t *self); -void Vec_int32_t__grow_to_fit(Vec_int32_t *self, size_t new_len); -VecIter_int32_t Vec_int32_t__iterator(Vec_int32_t *self); -VecIterRef_int32_t Vec_int32_t__iter_ref(Vec_int32_t *self); -void Vec_int32_t__push(Vec_int32_t *self, int32_t item); -void Vec_int32_t__insert(Vec_int32_t *self, size_t idx, int32_t item); -int32_t Vec_int32_t__pop(Vec_int32_t *self); -Option_int32_t Vec_int32_t__pop_opt(Vec_int32_t *self); -int32_t Vec_int32_t__remove(Vec_int32_t *self, size_t idx); -void Vec_int32_t__append(Vec_int32_t *self, Vec_int32_t other); -int32_t Vec_int32_t__get(Vec_int32_t *self, size_t idx); -int32_t Vec_int32_t__index(Vec_int32_t *self, size_t idx); -int32_t *Vec_int32_t__get_ref(Vec_int32_t *self, size_t idx); -int32_t Vec_int32_t__last(Vec_int32_t *self); -size_t Vec_int32_t__length(Vec_int32_t *self); -bool Vec_int32_t__contains(Vec_int32_t *self, int32_t item); -bool Vec_int32_t__is_empty(Vec_int32_t *self); -void Vec_int32_t__clear(Vec_int32_t *self); -void Vec_int32_t__free(Vec_int32_t *self); -int32_t Vec_int32_t__first(Vec_int32_t *self); -void Vec_int32_t__set(Vec_int32_t *self, size_t idx, int32_t item); -void Vec_int32_t__reverse(Vec_int32_t *self); -bool Vec_int32_t__eq(Vec_int32_t *self, Vec_int32_t *other); -void Vec_int32_t__forget(Vec_int32_t *self); -Vec_int32_t Vec_int32_t__add(Vec_int32_t *self, Vec_int32_t *other); -void Vec_int32_t__add_assign(Vec_int32_t *self, Vec_int32_t *other); -bool Vec_int32_t__neq(Vec_int32_t *self, Vec_int32_t *other); -void Vec_int32_t__shl(Vec_int32_t *self, int32_t item); -void Vec_int32_t__shr(Vec_int32_t *self, int32_t *out_item); -Vec_int32_t Vec_int32_t__mul(Vec_int32_t *self, size_t count); -void Vec_int32_t__mul_assign(Vec_int32_t *self, size_t count); -Vec_int32_t Vec_int32_t__clone(Vec_int32_t *self); -VecIterResult_int32_t VecIterRef_int32_t__next(VecIterRef_int32_t *self); -VecIterRef_int32_t VecIterRef_int32_t__iterator(VecIterRef_int32_t *self); -bool VecIterResult_int32_t__is_none(VecIterResult_int32_t *self); -int32_t *VecIterResult_int32_t__unwrap(VecIterResult_int32_t *self); -Option_int32_t VecIter_int32_t__next(VecIter_int32_t *self); -VecIter_int32_t VecIter_int32_t__iterator(VecIter_int32_t *self); -void Vec_int32_t__Drop_drop(Vec_int32_t *self); -Vec_size_t Vec_size_t__new(void); -Vec_size_t Vec_size_t__with_capacity(size_t cap); -void Vec_size_t__grow(Vec_size_t *self); -void Vec_size_t__grow_to_fit(Vec_size_t *self, size_t new_len); -VecIter_size_t Vec_size_t__iterator(Vec_size_t *self); -VecIterRef_size_t Vec_size_t__iter_ref(Vec_size_t *self); -void Vec_size_t__push(Vec_size_t *self, size_t item); -void Vec_size_t__insert(Vec_size_t *self, size_t idx, size_t item); -size_t Vec_size_t__pop(Vec_size_t *self); -Option_size_t Vec_size_t__pop_opt(Vec_size_t *self); -size_t Vec_size_t__remove(Vec_size_t *self, size_t idx); -void Vec_size_t__append(Vec_size_t *self, Vec_size_t other); -size_t Vec_size_t__get(Vec_size_t *self, size_t idx); -size_t Vec_size_t__index(Vec_size_t *self, size_t idx); -size_t *Vec_size_t__get_ref(Vec_size_t *self, size_t idx); -size_t Vec_size_t__last(Vec_size_t *self); -size_t Vec_size_t__length(Vec_size_t *self); -bool Vec_size_t__contains(Vec_size_t *self, size_t item); -bool Vec_size_t__is_empty(Vec_size_t *self); -void Vec_size_t__clear(Vec_size_t *self); -void Vec_size_t__free(Vec_size_t *self); -size_t Vec_size_t__first(Vec_size_t *self); -void Vec_size_t__set(Vec_size_t *self, size_t idx, size_t item); -void Vec_size_t__reverse(Vec_size_t *self); -bool Vec_size_t__eq(Vec_size_t *self, Vec_size_t *other); -void Vec_size_t__forget(Vec_size_t *self); -Vec_size_t Vec_size_t__add(Vec_size_t *self, Vec_size_t *other); -void Vec_size_t__add_assign(Vec_size_t *self, Vec_size_t *other); -bool Vec_size_t__neq(Vec_size_t *self, Vec_size_t *other); -void Vec_size_t__shl(Vec_size_t *self, size_t item); -void Vec_size_t__shr(Vec_size_t *self, size_t *out_item); -Vec_size_t Vec_size_t__mul(Vec_size_t *self, size_t count); -void Vec_size_t__mul_assign(Vec_size_t *self, size_t count); -Vec_size_t Vec_size_t__clone(Vec_size_t *self); -VecIterResult_size_t VecIterRef_size_t__next(VecIterRef_size_t *self); -VecIterRef_size_t VecIterRef_size_t__iterator(VecIterRef_size_t *self); -bool VecIterResult_size_t__is_none(VecIterResult_size_t *self); -size_t *VecIterResult_size_t__unwrap(VecIterResult_size_t *self); -Option_size_t VecIter_size_t__next(VecIter_size_t *self); -VecIter_size_t VecIter_size_t__iterator(VecIter_size_t *self); -void Vec_size_t__Drop_drop(Vec_size_t *self); -Option_size_t Option_size_t__Some(size_t v); -Option_size_t Option_size_t__None(void); -bool Option_size_t__is_some(Option_size_t *self); -bool Option_size_t__is_none(Option_size_t *self); -void Option_size_t__forget(Option_size_t *self); -size_t Option_size_t__unwrap(Option_size_t *self); -size_t *Option_size_t__unwrap_ref(Option_size_t *self); -size_t Option_size_t__unwrap_or(Option_size_t *self, size_t def_val); -size_t Option_size_t__expect(Option_size_t *self, char *msg); -Option_size_t Option_size_t__or_else(Option_size_t *self, Option_size_t other); -Option_int32_t Option_int32_t__Some(int32_t v); -Option_int32_t Option_int32_t__None(void); -bool Option_int32_t__is_some(Option_int32_t *self); -bool Option_int32_t__is_none(Option_int32_t *self); -void Option_int32_t__forget(Option_int32_t *self); -int32_t Option_int32_t__unwrap(Option_int32_t *self); -int32_t *Option_int32_t__unwrap_ref(Option_int32_t *self); -int32_t Option_int32_t__unwrap_or(Option_int32_t *self, int32_t def_val); -int32_t Option_int32_t__expect(Option_int32_t *self, char *msg); -Option_int32_t Option_int32_t__or_else(Option_int32_t *self, Option_int32_t other); -Vec_char Vec_char__new(void); -Vec_char Vec_char__with_capacity(size_t cap); -void Vec_char__grow(Vec_char *self); -void Vec_char__grow_to_fit(Vec_char *self, size_t new_len); -VecIter_char Vec_char__iterator(Vec_char *self); -VecIterRef_char Vec_char__iter_ref(Vec_char *self); -void Vec_char__push(Vec_char *self, char item); -void Vec_char__insert(Vec_char *self, size_t idx, char item); -char Vec_char__pop(Vec_char *self); -Option_char Vec_char__pop_opt(Vec_char *self); -char Vec_char__remove(Vec_char *self, size_t idx); -void Vec_char__append(Vec_char *self, Vec_char other); -char Vec_char__get(Vec_char *self, size_t idx); -char Vec_char__index(Vec_char *self, size_t idx); -char *Vec_char__get_ref(Vec_char *self, size_t idx); -char Vec_char__last(Vec_char *self); -size_t Vec_char__length(Vec_char *self); -bool Vec_char__contains(Vec_char *self, char item); -bool Vec_char__is_empty(Vec_char *self); -void Vec_char__clear(Vec_char *self); -void Vec_char__free(Vec_char *self); -char Vec_char__first(Vec_char *self); -void Vec_char__set(Vec_char *self, size_t idx, char item); -void Vec_char__reverse(Vec_char *self); -bool Vec_char__eq(Vec_char *self, Vec_char *other); -void Vec_char__forget(Vec_char *self); -Vec_char Vec_char__add(Vec_char *self, Vec_char *other); -void Vec_char__add_assign(Vec_char *self, Vec_char *other); -bool Vec_char__neq(Vec_char *self, Vec_char *other); -void Vec_char__shl(Vec_char *self, char item); -void Vec_char__shr(Vec_char *self, char *out_item); -Vec_char Vec_char__mul(Vec_char *self, size_t count); -void Vec_char__mul_assign(Vec_char *self, size_t count); -Vec_char Vec_char__clone(Vec_char *self); -VecIterResult_char VecIterRef_char__next(VecIterRef_char *self); -VecIterRef_char VecIterRef_char__iterator(VecIterRef_char *self); -bool VecIterResult_char__is_none(VecIterResult_char *self); -char *VecIterResult_char__unwrap(VecIterResult_char *self); -Option_char VecIter_char__next(VecIter_char *self); -VecIter_char VecIter_char__iterator(VecIter_char *self); -Option_char Option_char__Some(char v); -Option_char Option_char__None(void); -bool Option_char__is_some(Option_char *self); -bool Option_char__is_none(Option_char *self); -void Option_char__forget(Option_char *self); -char Option_char__unwrap(Option_char *self); -char *Option_char__unwrap_ref(Option_char *self); -char Option_char__unwrap_or(Option_char *self, char def_val); -char Option_char__expect(Option_char *self, char *msg); -Option_char Option_char__or_else(Option_char *self, Option_char other); -void Vec_char__Drop_drop(Vec_char *self); -void handler(Request *_req, Response *res); -void assert_true(bool cond, char *msg); -void sleep_ms(int32_t ms); -void _z_usleep(int micros); -void _z_mutex_destroy(void *ptr); -void _z_mutex_unlock(void *ptr); -void _z_mutex_lock(void *ptr); -void _z_mutex_init(void *ptr); -int _z_thread_cancel(void *handle); -int _z_thread_detach(void *handle); -int _z_thread_join(void *handle); -int _z_thread_spawn(void *ctx, size_t *out); -int _z_thread_equal(void *handle1, void *handle2); -Response fetch(String url); -char *strstr(const char *haystack, const char *needle); -int32_t atoi(const char *s); -int32_t _z_dns_resolve(const char *host, char *out_buf, size_t out_len); -void _z_net_ensure_init(void); -int32_t atoi(const char *s); -Vec_Header _parse_headers(Vec_String lines, size_t start_idx); -size_t _map_hash_str(const char *str); -size_t hash_get_seed(void); -void hash_set_seed(size_t seed); -size_t hash_compute(const void *data, size_t len); -size_t hash_combine(size_t a, size_t b); -int _z_net_bind_udp(ptrdiff_t fd, const char *host, int port); -ptrdiff_t _z_net_sendto(ptrdiff_t fd, const char *buf, size_t len, const char *host, int port); -ptrdiff_t _z_net_recvfrom(ptrdiff_t fd, char *buf, size_t len, char *host_out, int *port_out); -ptrdiff_t _z_net_write(ptrdiff_t fd, const char *buf, size_t n); -ptrdiff_t _z_net_accept(ptrdiff_t fd); -int _z_net_connect(ptrdiff_t fd, const char *host, int port); -int _z_net_bind(ptrdiff_t fd, const char *host, int port); -void _z_net_ensure_init(void); -char *strerror(int errnum); -ptrdiff_t _z_read(ptrdiff_t fd, void *buf, size_t count); -int _z_close(ptrdiff_t fd); -ptrdiff_t _z_socket(int domain, int type, int proto); -int32_t strcasecmp(const char *s1, const char *s2); -void sort_double(double *arr, size_t len); -void sort_float(float *arr, size_t len); -void sort_long(long *arr, size_t len); -void sort_int(int32_t *arr, size_t len); -void _zen_panic(const char *file, int32_t line, const char *func, const char *msg); -void exit(int32_t code); -void Mutex__Drop_drop(Mutex *self); -Mutex Mutex__new(void); -void Mutex__lock(Mutex *self); -void Mutex__unlock(Mutex *self); -void Mutex__free(Mutex *self); -bool Thread__eq(Thread *self, const Thread other); -bool Thread__neq(Thread *self, const Thread other); -Result_Thread Thread__spawn(z_closure_T func); -Result_bool Thread__join(Thread *self); -Result_bool Thread__detach(Thread *self); -Result_bool Thread__cancel(Thread *self); -Result_String Dns__resolve(char *host); -Result_Url Url__parse(String raw); -void Url__destroy(Url *self); -Server Server__new(int32_t port, void (*handler)(Request *, Response *)); -void Server__start(Server *self); -Response Response__new(int32_t status); -void Response__set_header(Response *self, String key, String value); -void Response__set_header_str(Response *self, char *key, char *value); -void Response__set_body(Response *self, String body); -void Response__set_body_str(Response *self, char *body); -Request Request__new(String method, String path); -void TcpListener__Drop_drop(TcpListener *self); -Result_TcpListener TcpListener__bind(char *host, int port); -Result_TcpStream TcpListener__accept(TcpListener *self); -void TcpListener__close(TcpListener *self); -void TcpStream__Drop_drop(TcpStream *self); -Result_size_t TcpStream__read(TcpStream *self, char *buf, size_t len); -Result_size_t TcpStream__read_exact(TcpStream *self, char *buf, size_t len); -Result_size_t TcpStream__write(TcpStream *self, uint8_t *buf, size_t len); -void TcpStream__close(TcpStream *self); -Result_TcpStream TcpStream__connect(char *host, int port); -String String__new(char *s); -String String__from(char *s); -String String__from_rune(int32_t r); -String String__from_runes(int32_t *runes, size_t count); -char *String__c_str(String *self); -char *String__to_string(String *self); -void String__destroy(String *self); -void String__forget(String *self); -void String__append(String *self, String *other); -void String__append_c(String *self, char *s); -void String__push_rune(String *self, int32_t r); -void String__append_c_ptr(String *ptr, char *s); -String String__add(String *self, String *other); -void String__add_assign(String *self, String *other); -bool String__eq(String *self, String *other); -bool String__neq(String *self, String *other); -int32_t String__compare(String *self, String *other); -bool String__lt(String *self, String *other); -bool String__gt(String *self, String *other); -bool String__le(String *self, String *other); -bool String__ge(String *self, String *other); -int32_t String__compare_ignore_case(String *self, String *other); -bool String__eq_ignore_case(String *self, String *other); -bool String__eq_str(String *self, char *s); -size_t String__length(String *self); -String String__substring(String *self, size_t start, size_t len); -bool String__contains_str(String *self, char *target); -Option_size_t String__find_str(String *self, char *target); -Vec_size_t String__find_all_str(String *self, char *target); -String String__to_lowercase(String *self); -String String__pad_right(String *self, size_t target_len, char pad_char); -String String__pad_left(String *self, size_t target_len, char pad_char); -String String__to_uppercase(String *self); -Option_size_t String__find(String *self, char target); -void String__print(String *self); -void String__println(String *self); -bool String__is_empty(String *self); -bool String__contains(String *self, char target); -bool String__starts_with(String *self, char *prefix); -bool String__ends_with(String *self, char *suffix); -void String__reserve(String *self, size_t cap); -void String__free(String *self); -size_t String___utf8_seq_len(char first_byte); -size_t String__utf8_len(String *self); -String String__utf8_at(String *self, size_t idx); -int32_t String__utf8_get(String *self, size_t idx); -Vec_int32_t String__runes(String *self); -StringCharsIter String__chars(String *self); -String String__from_runes_vec(Vec_int32_t runes); -void String__insert_rune(String *self, size_t idx, int32_t r); -int32_t String__remove_rune_at(String *self, size_t idx); -String String__utf8_substr(String *self, size_t start_idx, size_t num_chars); -Vec_String String__split(String *self, char delim); -String String__trim(String *self); -String String__replace(String *self, char *target, char *replacement); -Option_int32_t StringCharsIter__next(StringCharsIter *self); -Drop_VTable Mutex_Drop_VTable = {.drop = (__typeof__(((Drop_VTable *)0)->drop))Mutex__Drop_drop}; -Drop_VTable TcpListener_Drop_VTable = { - .drop = (__typeof__(((Drop_VTable *)0)->drop))TcpListener__Drop_drop}; -Drop_VTable TcpStream_Drop_VTable = { - .drop = (__typeof__(((Drop_VTable *)0)->drop))TcpStream__Drop_drop}; -// Auto-Generated RAII Glue for Vec_Header -void Vec_Header__Drop_glue(Vec_Header *self) -{ - Vec_Header__Drop_drop(self); -} - -// Auto-Generated RAII Glue for Vec_String -void Vec_String__Drop_glue(Vec_String *self) -{ - Vec_String__Drop_drop(self); -} - -// Auto-Generated RAII Glue for Vec_int32_t -void Vec_int32_t__Drop_glue(Vec_int32_t *self) -{ - Vec_int32_t__Drop_drop(self); -} - -// Auto-Generated RAII Glue for Vec_size_t -void Vec_size_t__Drop_glue(Vec_size_t *self) -{ - Vec_size_t__Drop_drop(self); -} - -// Auto-Generated RAII Glue for Vec_char -void Vec_char__Drop_glue(Vec_char *self) -{ - Vec_char__Drop_drop(self); -} - -// Auto-Generated RAII Glue for Mutex -void Mutex__Drop_glue(Mutex *self) -{ - Mutex__Drop_drop(self); -} - -// Auto-Generated RAII Glue for TcpListener -void TcpListener__Drop_glue(TcpListener *self) -{ - TcpListener__Drop_drop(self); -} - -// Auto-Generated RAII Glue for TcpStream -void TcpStream__Drop_glue(TcpStream *self) -{ - TcpStream__Drop_drop(self); -} - -// Auto-Generated RAII Glue for String -void String__Drop_glue(String *self) -{ - Vec_char__Drop_glue(&self->vec); -} - -// Auto-Generated RAII Glue for Url -void Url__Drop_glue(Url *self) -{ - String__Drop_glue(&self->scheme); - String__Drop_glue(&self->host); - String__Drop_glue(&self->path); - String__Drop_glue(&self->query); -} - -// Auto-Generated RAII Glue for Response -void Response__Drop_glue(Response *self) -{ - Vec_Header__Drop_glue(&self->headers); - String__Drop_glue(&self->body); -} - -// Auto-Generated RAII Glue for Request -void Request__Drop_glue(Request *self) -{ - String__Drop_glue(&self->method); - String__Drop_glue(&self->path); - Vec_Header__Drop_glue(&self->headers); - String__Drop_glue(&self->body); -} - -// Auto-Generated RAII Glue for Header -void Header__Drop_glue(Header *self) -{ - String__Drop_glue(&self->key); - String__Drop_glue(&self->value); -} - -struct Lambda_0_Ctx -{ - Server server; -}; - -static void _lambda_0_drop(void *_ctx) -{ - struct Lambda_0_Ctx *ctx = (struct Lambda_0_Ctx *)_ctx; - free(_ctx); -} - -void _lambda_0(void *_ctx) -{ - struct Lambda_0_Ctx *ctx = (struct Lambda_0_Ctx *)_ctx; - Server__start((&ctx->server)); -} - -static void _z_test_0() -{ - { - Server server = Server__new(8081, handler); - Thread__spawn(({ - struct Lambda_0_Ctx *_z_ctx_0 = malloc(sizeof(struct Lambda_0_Ctx)); - _z_ctx_0->server = server; - (z_closure_T){.func = _lambda_0, .ctx = _z_ctx_0, .drop = _lambda_0_drop}; - })); - sleep_ms(100); - int __z_drop_flag_response = 1; - Response response = fetch(String__new("http://127.0.0.1:8081/hello")); - assert_true((response.status == 200), "Status 200"); - assert_true((!String__is_empty((&response.body))), "Body not empty"); - assert_true(String__eq_str((&response.body), "Hello World"), "Body content match"); - if (__z_drop_flag_response) - { - Response__Drop_glue(&response); - } - } -} - -void _z_run_tests() -{ - _z_test_0(); -} - -Result_bool Result_bool__Ok(bool v) -{ - { - return (Result_bool){.is_ok = true, .val = v}; - } -} - -Result_bool Result_bool__Err(char *e) -{ - { - return (Result_bool){.is_ok = false, .err = e}; - } -} - -bool Result_bool__is_ok(Result_bool *self) -{ - { - return self->is_ok; - } -} - -bool Result_bool__is_err(Result_bool *self) -{ - { - return (!self->is_ok); - } -} - -void Result_bool__forget(Result_bool *self) -{ - { - memset((&self->val), 0, sizeof(bool)); - } -} - -bool Result_bool__unwrap(Result_bool *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - bool v = self->val; - memset((&self->val), 0, sizeof(bool)); - return v; - } -} - -bool *Result_bool__unwrap_ref(Result_bool *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -bool Result_bool__expect(Result_bool *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Result_Thread Result_Thread__Ok(Thread v) -{ - { - return (Result_Thread){.is_ok = true, .val = v}; - } -} - -Result_Thread Result_Thread__Err(char *e) -{ - { - return (Result_Thread){.is_ok = false, .err = e}; - } -} - -bool Result_Thread__is_ok(Result_Thread *self) -{ - { - return self->is_ok; - } -} - -bool Result_Thread__is_err(Result_Thread *self) -{ - { - return (!self->is_ok); - } -} - -void Result_Thread__forget(Result_Thread *self) -{ - { - memset((&self->val), 0, sizeof(Thread)); - } -} - -Thread Result_Thread__unwrap(Result_Thread *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - Thread v = self->val; - memset((&self->val), 0, sizeof(Thread)); - return v; - } -} - -Thread *Result_Thread__unwrap_ref(Result_Thread *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -Thread Result_Thread__expect(Result_Thread *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Result_String Result_String__Ok(String v) -{ - int __z_drop_flag_v = 1; - { - { - Result_String _z_ret = (Result_String){.is_ok = true, .val = v}; - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } -} - -Result_String Result_String__Err(char *e) -{ - { - return (Result_String){.is_ok = false, .err = e}; - } -} - -bool Result_String__is_ok(Result_String *self) -{ - { - return self->is_ok; - } -} - -bool Result_String__is_err(Result_String *self) -{ - { - return (!self->is_ok); - } -} - -void Result_String__forget(Result_String *self) -{ - { - memset((&self->val), 0, sizeof(String)); - } -} - -String Result_String__unwrap(Result_String *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - String v = self->val; - memset((&self->val), 0, sizeof(String)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - } -} - -String *Result_String__unwrap_ref(Result_String *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -String Result_String__expect(Result_String *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Result_Url Result_Url__Ok(Url v) -{ - int __z_drop_flag_v = 1; - { - { - Result_Url _z_ret = (Result_Url){.is_ok = true, .val = v}; - if (__z_drop_flag_v) - { - Url__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - Url__Drop_glue(&v); - } -} - -Result_Url Result_Url__Err(char *e) -{ - { - return (Result_Url){.is_ok = false, .err = e}; - } -} - -bool Result_Url__is_ok(Result_Url *self) -{ - { - return self->is_ok; - } -} - -bool Result_Url__is_err(Result_Url *self) -{ - { - return (!self->is_ok); - } -} - -void Result_Url__forget(Result_Url *self) -{ - { - memset((&self->val), 0, sizeof(Url)); - } -} - -Url Result_Url__unwrap(Result_Url *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - Url v = self->val; - memset((&self->val), 0, sizeof(Url)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - Url__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - Url__Drop_glue(&v); - } - } -} - -Url *Result_Url__unwrap_ref(Result_Url *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -Url Result_Url__expect(Result_Url *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Vec_Header Vec_Header__new(void) -{ - { - return (Vec_Header){}; - } -} - -Vec_Header Vec_Header__with_capacity(size_t cap) -{ - { - if ((cap == 0)) - { - return (Vec_Header){}; - } - return (Vec_Header){.data = ((Header *)(malloc((cap * sizeof(Header))))), .cap = cap}; - } -} - -void Vec_Header__grow(Vec_Header *self) -{ - { - if ((self->cap == 0)) - { - (self->cap = 8); - } - else - { - (self->cap = (self->cap * 2)); - } - (self->data = ((Header *)(realloc(self->data, (self->cap * sizeof(Header)))))); - } -} - -void Vec_Header__grow_to_fit(Vec_Header *self, size_t new_len) -{ - { - if ((self->cap >= new_len)) - { - return; - } - if ((self->cap == 0)) - { - (self->cap = 8); - } - while ((self->cap < new_len)) - { - (self->cap = (self->cap * 2)); - } - (self->data = ((Header *)(realloc(self->data, (self->cap * sizeof(Header)))))); - } -} - -VecIter_Header Vec_Header__iterator(Vec_Header *self) -{ - { - return (VecIter_Header){.data = self->data, .count = self->len}; - } -} - -VecIterRef_Header Vec_Header__iter_ref(Vec_Header *self) -{ - { - return (VecIterRef_Header){.data = self->data, .count = self->len}; - } -} - -void Vec_Header__push(Vec_Header *self, Header item) -{ - int __z_drop_flag_item = 1; - { - if ((self->len >= self->cap)) - { - Vec_Header__grow(self); - } - (self->data[self->len] = item); - (self->len = (self->len + 1)); - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } -} - -void Vec_Header__insert(Vec_Header *self, size_t idx, Header item) -{ - int __z_drop_flag_item = 1; - { - if ((idx > self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Insert index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - if ((self->len >= self->cap)) - { - Vec_Header__grow(self); - } - if ((idx < self->len)) - { - memmove(((self->data + idx) + 1), (self->data + idx), - ((self->len - idx) * sizeof(Header))); - } - (self->data[idx] = item); - (self->len = (self->len + 1)); - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } -} - -Header Vec_Header__pop(Vec_Header *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: pop called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->len = (self->len - 1)); - return self->data[self->len]; - } -} - -Option_Header Vec_Header__pop_opt(Vec_Header *self) -{ - { - if ((self->len == 0)) - { - return Option_Header__None(); - } - (self->len = (self->len - 1)); - return Option_Header__Some(self->data[self->len]); - } -} - -Header Vec_Header__remove(Vec_Header *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Remove index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_item = 1; - Header item = self->data[idx]; - if ((idx < (self->len - 1))) - { - memmove((self->data + idx), ((self->data + idx) + 1), - (((self->len - idx) - 1) * sizeof(Header))); - } - (self->len = (self->len - 1)); - return ({ - ZC_AUTO _z_ret_mv = item; - memset(&item, 0, sizeof(_z_ret_mv)); - __z_drop_flag_item = 0; - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - _z_ret_mv; - }); - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - } -} - -void Vec_Header__append(Vec_Header *self, Vec_Header other) -{ - int __z_drop_flag_other = 1; - { - size_t new_len = (self->len + other.len); - Vec_Header__grow_to_fit(self, new_len); - memcpy((self->data + self->len), other.data, (other.len * sizeof(Header))); - (self->len = new_len); - Vec_Header__forget(&other); - } - if (__z_drop_flag_other) - { - Vec_Header__Drop_glue(&other); - } -} - -Header Vec_Header__get(Vec_Header *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[idx]; - } -} - -Header Vec_Header__index(Vec_Header *self, size_t idx) -{ - { - return Vec_Header__get(self, idx); - } -} - -Header *Vec_Header__get_ref(Vec_Header *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->data[idx]); - } -} - -Header Vec_Header__last(Vec_Header *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: last called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[(self->len - 1)]; - } -} - -size_t Vec_Header__length(Vec_Header *self) -{ - { - return self->len; - } -} - -bool Vec_Header__contains(Vec_Header *self, Header item) -{ - int __z_drop_flag_item = 1; - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&item), sizeof(Header)) == 0)) - { - { - bool _z_ret = true; - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - return _z_ret; - } - } - (i++); - } - { - bool _z_ret = false; - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - return _z_ret; - } - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } -} - -bool Vec_Header__is_empty(Vec_Header *self) -{ - { - return (self->len == 0); - } -} - -void Vec_Header__clear(Vec_Header *self) -{ - { - (self->len = 0); - } -} - -void Vec_Header__free(Vec_Header *self) -{ - { - if (self->data) - { - free(self->data); - } - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Header Vec_Header__first(Vec_Header *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: first called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[0]; - } -} - -void Vec_Header__set(Vec_Header *self, size_t idx, Header item) -{ - int __z_drop_flag_item = 1; - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: set index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->data[idx] = item); - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } -} - -void Vec_Header__reverse(Vec_Header *self) -{ - { - size_t i = 0; - size_t j = (self->len - 1); - while ((i < j)) - { - int __z_drop_flag_tmp = 1; - Header tmp = self->data[i]; - (self->data[i] = self->data[j]); - (self->data[j] = tmp); - (i++); - (j--); - if (__z_drop_flag_tmp) - { - Header__Drop_glue(&tmp); - } - } - } -} - -bool Vec_Header__eq(Vec_Header *self, Vec_Header *other) -{ - { - bool result = true; - if ((self->len != (*other).len)) - { - (result = false); - } - else - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&(*other).data[i]), sizeof(Header)) != 0)) - { - (result = false); - break; - } - (i = (i + 1)); - } - } - return result; - } -} - -void Vec_Header__forget(Vec_Header *self) -{ - { - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Vec_Header Vec_Header__add(Vec_Header *self, Vec_Header *other) -{ - { - int __z_drop_flag_result = 1; - Vec_Header result = Vec_Header__clone(self); - Vec_Header__append(&result, Vec_Header__clone(other)); - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_Header__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_Header__Drop_glue(&result); - } - } -} - -void Vec_Header__add_assign(Vec_Header *self, Vec_Header *other) -{ - { - Vec_Header__append(self, Vec_Header__clone(other)); - } -} - -bool Vec_Header__neq(Vec_Header *self, Vec_Header *other) -{ - { - bool result = (!Vec_Header__eq(self, other)); - return result; - } -} - -void Vec_Header__shl(Vec_Header *self, Header item) -{ - int __z_drop_flag_item = 1; - { - Vec_Header__push(self, item); - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } -} - -void Vec_Header__shr(Vec_Header *self, Header *out_item) -{ - { - if ((out_item != 0)) - { - ((*out_item) = Vec_Header__pop(self)); - } - else - { - Vec_Header__pop(self); - } - } -} - -Vec_Header Vec_Header__mul(Vec_Header *self, size_t count) -{ - { - int __z_drop_flag_result = 1; - Vec_Header result = Vec_Header__with_capacity((self->len * count)); - size_t c = 0; - while ((c < count)) - { - Vec_Header__append(&result, Vec_Header__clone(self)); - (c = (c + 1)); - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_Header__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_Header__Drop_glue(&result); - } - } -} - -void Vec_Header__mul_assign(Vec_Header *self, size_t count) -{ - { - if ((count == 0)) - { - Vec_Header__clear(self); - return; - } - if ((count == 1)) - { - return; - } - size_t original_len = self->len; - Vec_Header__grow_to_fit(self, (self->len * count)); - size_t c = 1; - while ((c < count)) - { - memcpy((self->data + (original_len * c)), self->data, (original_len * sizeof(Header))); - (self->len = (self->len + original_len)); - (c = (c + 1)); - } - } -} - -Vec_Header Vec_Header__clone(Vec_Header *self) -{ - { - if ((self->len == 0)) - { - return (Vec_Header){}; - } - Header *new_data = ((Header *)(malloc((self->len * sizeof(Header))))); - size_t i = 0; - while ((i < self->len)) - { - (new_data[i] = self->data[i]); - (i = (i + 1)); - } - return (Vec_Header){.data = new_data, .len = self->len, .cap = self->len}; - } -} - -VecIterResult_Header VecIterRef_Header__next(VecIterRef_Header *self) -{ - { - if ((self->idx < self->count)) - { - Header *item = (&self->data[self->idx]); - (self->idx = (self->idx + 1)); - return (VecIterResult_Header){.ptr = item}; - } - return (VecIterResult_Header){}; - } -} - -VecIterRef_Header VecIterRef_Header__iterator(VecIterRef_Header *self) -{ - { - return (*self); - } -} - -bool VecIterResult_Header__is_none(VecIterResult_Header *self) -{ - { - return (self->ptr == 0); - } -} - -Header *VecIterResult_Header__unwrap(VecIterResult_Header *self) -{ - { - if ((self->ptr == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on null VecIterResult"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->ptr; - } -} - -Option_Header VecIter_Header__next(VecIter_Header *self) -{ - { - if ((self->idx < self->count)) - { - int __z_drop_flag_item = 1; - Header item = self->data[self->idx]; - (self->idx = (self->idx + 1)); - { - Option_Header _z_ret = Option_Header__Some(item); - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - return _z_ret; - } - if (__z_drop_flag_item) - { - Header__Drop_glue(&item); - } - } - return Option_Header__None(); - } -} - -VecIter_Header VecIter_Header__iterator(VecIter_Header *self) -{ - { - return (*self); - } -} - -Option_Header Option_Header__Some(Header v) -{ - int __z_drop_flag_v = 1; - { - { - Option_Header _z_ret = (Option_Header){.is_some = true, .val = v}; - if (__z_drop_flag_v) - { - Header__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - Header__Drop_glue(&v); - } -} - -Option_Header Option_Header__None(void) -{ - { - return (Option_Header){.is_some = false}; - } -} - -bool Option_Header__is_some(Option_Header *self) -{ - { - return self->is_some; - } -} - -bool Option_Header__is_none(Option_Header *self) -{ - { - return (!self->is_some); - } -} - -void Option_Header__forget(Option_Header *self) -{ - { - memset((&self->val), 0, sizeof(Header)); - } -} - -Header Option_Header__unwrap(Option_Header *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - Header v = self->val; - memset((&self->val), 0, sizeof(Header)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - Header__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - Header__Drop_glue(&v); - } - } -} - -Header *Option_Header__unwrap_ref(Option_Header *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -Header Option_Header__unwrap_or(Option_Header *self, Header def_val) -{ - int __z_drop_flag_def_val = 1; - { - if (self->is_some) - { - { - Header _z_ret = self->val; - if (__z_drop_flag_def_val) - { - Header__Drop_glue(&def_val); - } - return _z_ret; - } - } - return ({ - ZC_AUTO _z_ret_mv = def_val; - memset(&def_val, 0, sizeof(_z_ret_mv)); - __z_drop_flag_def_val = 0; - if (__z_drop_flag_def_val) - { - Header__Drop_glue(&def_val); - } - _z_ret_mv; - }); - } - if (__z_drop_flag_def_val) - { - Header__Drop_glue(&def_val); - } -} - -Header Option_Header__expect(Option_Header *self, char *msg) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Option_Header Option_Header__or_else(Option_Header *self, Option_Header other) -{ - { - if (self->is_some) - { - return (*self); - } - return other; - } -} - -void Vec_Header__Drop_drop(Vec_Header *self) -{ - { - Vec_Header__free(self); - } -} - -Result_TcpListener Result_TcpListener__Ok(TcpListener v) -{ - int __z_drop_flag_v = 1; - { - { - Result_TcpListener _z_ret = (Result_TcpListener){.is_ok = true, .val = v}; - if (__z_drop_flag_v) - { - TcpListener__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - TcpListener__Drop_glue(&v); - } -} - -Result_TcpListener Result_TcpListener__Err(char *e) -{ - { - return (Result_TcpListener){.is_ok = false, .err = e}; - } -} - -bool Result_TcpListener__is_ok(Result_TcpListener *self) -{ - { - return self->is_ok; - } -} - -bool Result_TcpListener__is_err(Result_TcpListener *self) -{ - { - return (!self->is_ok); - } -} - -void Result_TcpListener__forget(Result_TcpListener *self) -{ - { - memset((&self->val), 0, sizeof(TcpListener)); - } -} - -TcpListener Result_TcpListener__unwrap(Result_TcpListener *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - TcpListener v = self->val; - memset((&self->val), 0, sizeof(TcpListener)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - TcpListener__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - TcpListener__Drop_glue(&v); - } - } -} - -TcpListener *Result_TcpListener__unwrap_ref(Result_TcpListener *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -TcpListener Result_TcpListener__expect(Result_TcpListener *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Result_TcpStream Result_TcpStream__Ok(TcpStream v) -{ - int __z_drop_flag_v = 1; - { - { - Result_TcpStream _z_ret = (Result_TcpStream){.is_ok = true, .val = v}; - if (__z_drop_flag_v) - { - TcpStream__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - TcpStream__Drop_glue(&v); - } -} - -Result_TcpStream Result_TcpStream__Err(char *e) -{ - { - return (Result_TcpStream){.is_ok = false, .err = e}; - } -} - -bool Result_TcpStream__is_ok(Result_TcpStream *self) -{ - { - return self->is_ok; - } -} - -bool Result_TcpStream__is_err(Result_TcpStream *self) -{ - { - return (!self->is_ok); - } -} - -void Result_TcpStream__forget(Result_TcpStream *self) -{ - { - memset((&self->val), 0, sizeof(TcpStream)); - } -} - -TcpStream Result_TcpStream__unwrap(Result_TcpStream *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - TcpStream v = self->val; - memset((&self->val), 0, sizeof(TcpStream)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - TcpStream__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - TcpStream__Drop_glue(&v); - } - } -} - -TcpStream *Result_TcpStream__unwrap_ref(Result_TcpStream *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -TcpStream Result_TcpStream__expect(Result_TcpStream *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Result_size_t Result_size_t__Ok(size_t v) -{ - { - return (Result_size_t){.is_ok = true, .val = v}; - } -} - -Result_size_t Result_size_t__Err(char *e) -{ - { - return (Result_size_t){.is_ok = false, .err = e}; - } -} - -bool Result_size_t__is_ok(Result_size_t *self) -{ - { - return self->is_ok; - } -} - -bool Result_size_t__is_err(Result_size_t *self) -{ - { - return (!self->is_ok); - } -} - -void Result_size_t__forget(Result_size_t *self) -{ - { - memset((&self->val), 0, sizeof(size_t)); - } -} - -size_t Result_size_t__unwrap(Result_size_t *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - size_t v = self->val; - memset((&self->val), 0, sizeof(size_t)); - return v; - } -} - -size_t *Result_size_t__unwrap_ref(Result_size_t *self) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on Err: "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -size_t Result_size_t__expect(Result_size_t *self, char *msg) -{ - { - if ((!self->is_ok)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "%s", ": "); - fprintf(stderr, "%s", self->err); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Vec_String Vec_String__new(void) -{ - { - return (Vec_String){}; - } -} - -Vec_String Vec_String__with_capacity(size_t cap) -{ - { - if ((cap == 0)) - { - return (Vec_String){}; - } - return (Vec_String){.data = ((String *)(malloc((cap * sizeof(String))))), .cap = cap}; - } -} - -void Vec_String__grow(Vec_String *self) -{ - { - if ((self->cap == 0)) - { - (self->cap = 8); - } - else - { - (self->cap = (self->cap * 2)); - } - (self->data = ((String *)(realloc(self->data, (self->cap * sizeof(String)))))); - } -} - -void Vec_String__grow_to_fit(Vec_String *self, size_t new_len) -{ - { - if ((self->cap >= new_len)) - { - return; - } - if ((self->cap == 0)) - { - (self->cap = 8); - } - while ((self->cap < new_len)) - { - (self->cap = (self->cap * 2)); - } - (self->data = ((String *)(realloc(self->data, (self->cap * sizeof(String)))))); - } -} - -VecIter_String Vec_String__iterator(Vec_String *self) -{ - { - return (VecIter_String){.data = self->data, .count = self->len}; - } -} - -VecIterRef_String Vec_String__iter_ref(Vec_String *self) -{ - { - return (VecIterRef_String){.data = self->data, .count = self->len}; - } -} - -void Vec_String__push(Vec_String *self, String item) -{ - int __z_drop_flag_item = 1; - { - if ((self->len >= self->cap)) - { - Vec_String__grow(self); - } - (self->data[self->len] = item); - (self->len = (self->len + 1)); - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } -} - -void Vec_String__insert(Vec_String *self, size_t idx, String item) -{ - int __z_drop_flag_item = 1; - { - if ((idx > self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Insert index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - if ((self->len >= self->cap)) - { - Vec_String__grow(self); - } - if ((idx < self->len)) - { - memmove(((self->data + idx) + 1), (self->data + idx), - ((self->len - idx) * sizeof(String))); - } - (self->data[idx] = item); - (self->len = (self->len + 1)); - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } -} - -String Vec_String__pop(Vec_String *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: pop called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->len = (self->len - 1)); - return self->data[self->len]; - } -} - -Option_String Vec_String__pop_opt(Vec_String *self) -{ - { - if ((self->len == 0)) - { - return Option_String__None(); - } - (self->len = (self->len - 1)); - return Option_String__Some(self->data[self->len]); - } -} - -String Vec_String__remove(Vec_String *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Remove index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_item = 1; - String item = self->data[idx]; - if ((idx < (self->len - 1))) - { - memmove((self->data + idx), ((self->data + idx) + 1), - (((self->len - idx) - 1) * sizeof(String))); - } - (self->len = (self->len - 1)); - return ({ - ZC_AUTO _z_ret_mv = item; - memset(&item, 0, sizeof(_z_ret_mv)); - __z_drop_flag_item = 0; - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - _z_ret_mv; - }); - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - } -} - -void Vec_String__append(Vec_String *self, Vec_String other) -{ - int __z_drop_flag_other = 1; - { - size_t new_len = (self->len + other.len); - Vec_String__grow_to_fit(self, new_len); - memcpy((self->data + self->len), other.data, (other.len * sizeof(String))); - (self->len = new_len); - Vec_String__forget(&other); - } - if (__z_drop_flag_other) - { - Vec_String__Drop_glue(&other); - } -} - -String Vec_String__get(Vec_String *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[idx]; - } -} - -String Vec_String__index(Vec_String *self, size_t idx) -{ - { - return Vec_String__get(self, idx); - } -} - -String *Vec_String__get_ref(Vec_String *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->data[idx]); - } -} - -String Vec_String__last(Vec_String *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: last called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[(self->len - 1)]; - } -} - -size_t Vec_String__length(Vec_String *self) -{ - { - return self->len; - } -} - -bool Vec_String__contains(Vec_String *self, String item) -{ - int __z_drop_flag_item = 1; - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&item), sizeof(String)) == 0)) - { - { - bool _z_ret = true; - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - return _z_ret; - } - } - (i++); - } - { - bool _z_ret = false; - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - return _z_ret; - } - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } -} - -bool Vec_String__is_empty(Vec_String *self) -{ - { - return (self->len == 0); - } -} - -void Vec_String__clear(Vec_String *self) -{ - { - (self->len = 0); - } -} - -void Vec_String__free(Vec_String *self) -{ - { - if (self->data) - { - free(self->data); - } - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -String Vec_String__first(Vec_String *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: first called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[0]; - } -} - -void Vec_String__set(Vec_String *self, size_t idx, String item) -{ - int __z_drop_flag_item = 1; - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: set index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->data[idx] = item); - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } -} - -void Vec_String__reverse(Vec_String *self) -{ - { - size_t i = 0; - size_t j = (self->len - 1); - while ((i < j)) - { - int __z_drop_flag_tmp = 1; - String tmp = self->data[i]; - (self->data[i] = self->data[j]); - (self->data[j] = tmp); - (i++); - (j--); - if (__z_drop_flag_tmp) - { - String__Drop_glue(&tmp); - } - } - } -} - -bool Vec_String__eq(Vec_String *self, Vec_String *other) -{ - { - bool result = true; - if ((self->len != (*other).len)) - { - (result = false); - } - else - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&(*other).data[i]), sizeof(String)) != 0)) - { - (result = false); - break; - } - (i = (i + 1)); - } - } - return result; - } -} - -void Vec_String__forget(Vec_String *self) -{ - { - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Vec_String Vec_String__add(Vec_String *self, Vec_String *other) -{ - { - int __z_drop_flag_result = 1; - Vec_String result = Vec_String__clone(self); - Vec_String__append(&result, Vec_String__clone(other)); - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_String__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_String__Drop_glue(&result); - } - } -} - -void Vec_String__add_assign(Vec_String *self, Vec_String *other) -{ - { - Vec_String__append(self, Vec_String__clone(other)); - } -} - -bool Vec_String__neq(Vec_String *self, Vec_String *other) -{ - { - bool result = (!Vec_String__eq(self, other)); - return result; - } -} - -void Vec_String__shl(Vec_String *self, String item) -{ - int __z_drop_flag_item = 1; - { - Vec_String__push(self, item); - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } -} - -void Vec_String__shr(Vec_String *self, String *out_item) -{ - { - if ((out_item != 0)) - { - ((*out_item) = Vec_String__pop(self)); - } - else - { - Vec_String__pop(self); - } - } -} - -Vec_String Vec_String__mul(Vec_String *self, size_t count) -{ - { - int __z_drop_flag_result = 1; - Vec_String result = Vec_String__with_capacity((self->len * count)); - size_t c = 0; - while ((c < count)) - { - Vec_String__append(&result, Vec_String__clone(self)); - (c = (c + 1)); - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_String__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_String__Drop_glue(&result); - } - } -} - -void Vec_String__mul_assign(Vec_String *self, size_t count) -{ - { - if ((count == 0)) - { - Vec_String__clear(self); - return; - } - if ((count == 1)) - { - return; - } - size_t original_len = self->len; - Vec_String__grow_to_fit(self, (self->len * count)); - size_t c = 1; - while ((c < count)) - { - memcpy((self->data + (original_len * c)), self->data, (original_len * sizeof(String))); - (self->len = (self->len + original_len)); - (c = (c + 1)); - } - } -} - -Vec_String Vec_String__clone(Vec_String *self) -{ - { - if ((self->len == 0)) - { - return (Vec_String){}; - } - String *new_data = ((String *)(malloc((self->len * sizeof(String))))); - size_t i = 0; - while ((i < self->len)) - { - (new_data[i] = self->data[i]); - (i = (i + 1)); - } - return (Vec_String){.data = new_data, .len = self->len, .cap = self->len}; - } -} - -VecIterResult_String VecIterRef_String__next(VecIterRef_String *self) -{ - { - if ((self->idx < self->count)) - { - String *item = (&self->data[self->idx]); - (self->idx = (self->idx + 1)); - return (VecIterResult_String){.ptr = item}; - } - return (VecIterResult_String){}; - } -} - -VecIterRef_String VecIterRef_String__iterator(VecIterRef_String *self) -{ - { - return (*self); - } -} - -bool VecIterResult_String__is_none(VecIterResult_String *self) -{ - { - return (self->ptr == 0); - } -} - -String *VecIterResult_String__unwrap(VecIterResult_String *self) -{ - { - if ((self->ptr == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on null VecIterResult"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->ptr; - } -} - -Option_String VecIter_String__next(VecIter_String *self) -{ - { - if ((self->idx < self->count)) - { - int __z_drop_flag_item = 1; - String item = self->data[self->idx]; - (self->idx = (self->idx + 1)); - { - Option_String _z_ret = Option_String__Some(item); - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - return _z_ret; - } - if (__z_drop_flag_item) - { - String__Drop_glue(&item); - } - } - return Option_String__None(); - } -} - -VecIter_String VecIter_String__iterator(VecIter_String *self) -{ - { - return (*self); - } -} - -Option_String Option_String__Some(String v) -{ - int __z_drop_flag_v = 1; - { - { - Option_String _z_ret = (Option_String){.is_some = true, .val = v}; - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - return _z_ret; - } - } - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } -} - -Option_String Option_String__None(void) -{ - { - return (Option_String){.is_some = false}; - } -} - -bool Option_String__is_some(Option_String *self) -{ - { - return self->is_some; - } -} - -bool Option_String__is_none(Option_String *self) -{ - { - return (!self->is_some); - } -} - -void Option_String__forget(Option_String *self) -{ - { - memset((&self->val), 0, sizeof(String)); - } -} - -String Option_String__unwrap(Option_String *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int __z_drop_flag_v = 1; - String v = self->val; - memset((&self->val), 0, sizeof(String)); - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - String__Drop_glue(&v); - } - } -} - -String *Option_String__unwrap_ref(Option_String *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -String Option_String__unwrap_or(Option_String *self, String def_val) -{ - int __z_drop_flag_def_val = 1; - { - if (self->is_some) - { - { - String _z_ret = self->val; - if (__z_drop_flag_def_val) - { - String__Drop_glue(&def_val); - } - return _z_ret; - } - } - return ({ - ZC_AUTO _z_ret_mv = def_val; - memset(&def_val, 0, sizeof(_z_ret_mv)); - __z_drop_flag_def_val = 0; - if (__z_drop_flag_def_val) - { - String__Drop_glue(&def_val); - } - _z_ret_mv; - }); - } - if (__z_drop_flag_def_val) - { - String__Drop_glue(&def_val); - } -} - -String Option_String__expect(Option_String *self, char *msg) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Option_String Option_String__or_else(Option_String *self, Option_String other) -{ - { - if (self->is_some) - { - return (*self); - } - return other; - } -} - -void Vec_String__Drop_drop(Vec_String *self) -{ - { - Vec_String__free(self); - } -} - -Vec_int32_t Vec_int32_t__new(void) -{ - { - return (Vec_int32_t){}; - } -} - -Vec_int32_t Vec_int32_t__with_capacity(size_t cap) -{ - { - if ((cap == 0)) - { - return (Vec_int32_t){}; - } - return (Vec_int32_t){.data = ((int32_t *)(malloc((cap * sizeof(int32_t))))), .cap = cap}; - } -} - -void Vec_int32_t__grow(Vec_int32_t *self) -{ - { - if ((self->cap == 0)) - { - (self->cap = 8); - } - else - { - (self->cap = (self->cap * 2)); - } - (self->data = ((int32_t *)(realloc(self->data, (self->cap * sizeof(int32_t)))))); - } -} - -void Vec_int32_t__grow_to_fit(Vec_int32_t *self, size_t new_len) -{ - { - if ((self->cap >= new_len)) - { - return; - } - if ((self->cap == 0)) - { - (self->cap = 8); - } - while ((self->cap < new_len)) - { - (self->cap = (self->cap * 2)); - } - (self->data = ((int32_t *)(realloc(self->data, (self->cap * sizeof(int32_t)))))); - } -} - -VecIter_int32_t Vec_int32_t__iterator(Vec_int32_t *self) -{ - { - return (VecIter_int32_t){.data = self->data, .count = self->len}; - } -} - -VecIterRef_int32_t Vec_int32_t__iter_ref(Vec_int32_t *self) -{ - { - return (VecIterRef_int32_t){.data = self->data, .count = self->len}; - } -} - -void Vec_int32_t__push(Vec_int32_t *self, int32_t item) -{ - { - if ((self->len >= self->cap)) - { - Vec_int32_t__grow(self); - } - (self->data[self->len] = item); - (self->len = (self->len + 1)); - } -} - -void Vec_int32_t__insert(Vec_int32_t *self, size_t idx, int32_t item) -{ - { - if ((idx > self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Insert index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - if ((self->len >= self->cap)) - { - Vec_int32_t__grow(self); - } - if ((idx < self->len)) - { - memmove(((self->data + idx) + 1), (self->data + idx), - ((self->len - idx) * sizeof(int32_t))); - } - (self->data[idx] = item); - (self->len = (self->len + 1)); - } -} - -int32_t Vec_int32_t__pop(Vec_int32_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: pop called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->len = (self->len - 1)); - return self->data[self->len]; - } -} - -Option_int32_t Vec_int32_t__pop_opt(Vec_int32_t *self) -{ - { - if ((self->len == 0)) - { - return Option_int32_t__None(); - } - (self->len = (self->len - 1)); - return Option_int32_t__Some(self->data[self->len]); - } -} - -int32_t Vec_int32_t__remove(Vec_int32_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Remove index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int32_t item = self->data[idx]; - if ((idx < (self->len - 1))) - { - memmove((self->data + idx), ((self->data + idx) + 1), - (((self->len - idx) - 1) * sizeof(int32_t))); - } - (self->len = (self->len - 1)); - return item; - } -} - -void Vec_int32_t__append(Vec_int32_t *self, Vec_int32_t other) -{ - int __z_drop_flag_other = 1; - { - size_t new_len = (self->len + other.len); - Vec_int32_t__grow_to_fit(self, new_len); - memcpy((self->data + self->len), other.data, (other.len * sizeof(int32_t))); - (self->len = new_len); - Vec_int32_t__forget(&other); - } - if (__z_drop_flag_other) - { - Vec_int32_t__Drop_glue(&other); - } -} - -int32_t Vec_int32_t__get(Vec_int32_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[idx]; - } -} - -int32_t Vec_int32_t__index(Vec_int32_t *self, size_t idx) -{ - { - return Vec_int32_t__get(self, idx); - } -} - -int32_t *Vec_int32_t__get_ref(Vec_int32_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->data[idx]); - } -} - -int32_t Vec_int32_t__last(Vec_int32_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: last called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[(self->len - 1)]; - } -} - -size_t Vec_int32_t__length(Vec_int32_t *self) -{ - { - return self->len; - } -} - -bool Vec_int32_t__contains(Vec_int32_t *self, int32_t item) -{ - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&item), sizeof(int32_t)) == 0)) - { - return true; - } - (i++); - } - return false; - } -} - -bool Vec_int32_t__is_empty(Vec_int32_t *self) -{ - { - return (self->len == 0); - } -} - -void Vec_int32_t__clear(Vec_int32_t *self) -{ - { - (self->len = 0); - } -} - -void Vec_int32_t__free(Vec_int32_t *self) -{ - { - if (self->data) - { - free(self->data); - } - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -int32_t Vec_int32_t__first(Vec_int32_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: first called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[0]; - } -} - -void Vec_int32_t__set(Vec_int32_t *self, size_t idx, int32_t item) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: set index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->data[idx] = item); - } -} - -void Vec_int32_t__reverse(Vec_int32_t *self) -{ - { - size_t i = 0; - size_t j = (self->len - 1); - while ((i < j)) - { - int32_t tmp = self->data[i]; - (self->data[i] = self->data[j]); - (self->data[j] = tmp); - (i++); - (j--); - } - } -} - -bool Vec_int32_t__eq(Vec_int32_t *self, Vec_int32_t *other) -{ - { - bool result = true; - if ((self->len != (*other).len)) - { - (result = false); - } - else - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&(*other).data[i]), sizeof(int32_t)) != 0)) - { - (result = false); - break; - } - (i = (i + 1)); - } - } - return result; - } -} - -void Vec_int32_t__forget(Vec_int32_t *self) -{ - { - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Vec_int32_t Vec_int32_t__add(Vec_int32_t *self, Vec_int32_t *other) -{ - { - int __z_drop_flag_result = 1; - Vec_int32_t result = Vec_int32_t__clone(self); - Vec_int32_t__append(&result, Vec_int32_t__clone(other)); - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_int32_t__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_int32_t__Drop_glue(&result); - } - } -} - -void Vec_int32_t__add_assign(Vec_int32_t *self, Vec_int32_t *other) -{ - { - Vec_int32_t__append(self, Vec_int32_t__clone(other)); - } -} - -bool Vec_int32_t__neq(Vec_int32_t *self, Vec_int32_t *other) -{ - { - bool result = (!Vec_int32_t__eq(self, other)); - return result; - } -} - -void Vec_int32_t__shl(Vec_int32_t *self, int32_t item) -{ - { - Vec_int32_t__push(self, item); - } -} - -void Vec_int32_t__shr(Vec_int32_t *self, int32_t *out_item) -{ - { - if ((out_item != 0)) - { - ((*out_item) = Vec_int32_t__pop(self)); - } - else - { - Vec_int32_t__pop(self); - } - } -} - -Vec_int32_t Vec_int32_t__mul(Vec_int32_t *self, size_t count) -{ - { - int __z_drop_flag_result = 1; - Vec_int32_t result = Vec_int32_t__with_capacity((self->len * count)); - size_t c = 0; - while ((c < count)) - { - Vec_int32_t__append(&result, Vec_int32_t__clone(self)); - (c = (c + 1)); - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_int32_t__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_int32_t__Drop_glue(&result); - } - } -} - -void Vec_int32_t__mul_assign(Vec_int32_t *self, size_t count) -{ - { - if ((count == 0)) - { - Vec_int32_t__clear(self); - return; - } - if ((count == 1)) - { - return; - } - size_t original_len = self->len; - Vec_int32_t__grow_to_fit(self, (self->len * count)); - size_t c = 1; - while ((c < count)) - { - memcpy((self->data + (original_len * c)), self->data, (original_len * sizeof(int32_t))); - (self->len = (self->len + original_len)); - (c = (c + 1)); - } - } -} - -Vec_int32_t Vec_int32_t__clone(Vec_int32_t *self) -{ - { - if ((self->len == 0)) - { - return (Vec_int32_t){}; - } - int32_t *new_data = ((int32_t *)(malloc((self->len * sizeof(int32_t))))); - size_t i = 0; - while ((i < self->len)) - { - (new_data[i] = self->data[i]); - (i = (i + 1)); - } - return (Vec_int32_t){.data = new_data, .len = self->len, .cap = self->len}; - } -} - -VecIterResult_int32_t VecIterRef_int32_t__next(VecIterRef_int32_t *self) -{ - { - if ((self->idx < self->count)) - { - int32_t *item = (&self->data[self->idx]); - (self->idx = (self->idx + 1)); - return (VecIterResult_int32_t){.ptr = item}; - } - return (VecIterResult_int32_t){}; - } -} - -VecIterRef_int32_t VecIterRef_int32_t__iterator(VecIterRef_int32_t *self) -{ - { - return (*self); - } -} - -bool VecIterResult_int32_t__is_none(VecIterResult_int32_t *self) -{ - { - return (self->ptr == 0); - } -} - -int32_t *VecIterResult_int32_t__unwrap(VecIterResult_int32_t *self) -{ - { - if ((self->ptr == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on null VecIterResult"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->ptr; - } -} - -Option_int32_t VecIter_int32_t__next(VecIter_int32_t *self) -{ - { - if ((self->idx < self->count)) - { - int32_t item = self->data[self->idx]; - (self->idx = (self->idx + 1)); - return Option_int32_t__Some(item); - } - return Option_int32_t__None(); - } -} - -VecIter_int32_t VecIter_int32_t__iterator(VecIter_int32_t *self) -{ - { - return (*self); - } -} - -void Vec_int32_t__Drop_drop(Vec_int32_t *self) -{ - { - Vec_int32_t__free(self); - } -} - -Vec_size_t Vec_size_t__new(void) -{ - { - return (Vec_size_t){}; - } -} - -Vec_size_t Vec_size_t__with_capacity(size_t cap) -{ - { - if ((cap == 0)) - { - return (Vec_size_t){}; - } - return (Vec_size_t){.data = ((size_t *)(malloc((cap * sizeof(size_t))))), .cap = cap}; - } -} - -void Vec_size_t__grow(Vec_size_t *self) -{ - { - if ((self->cap == 0)) - { - (self->cap = 8); - } - else - { - (self->cap = (self->cap * 2)); - } - (self->data = ((size_t *)(realloc(self->data, (self->cap * sizeof(size_t)))))); - } -} - -void Vec_size_t__grow_to_fit(Vec_size_t *self, size_t new_len) -{ - { - if ((self->cap >= new_len)) - { - return; - } - if ((self->cap == 0)) - { - (self->cap = 8); - } - while ((self->cap < new_len)) - { - (self->cap = (self->cap * 2)); - } - (self->data = ((size_t *)(realloc(self->data, (self->cap * sizeof(size_t)))))); - } -} - -VecIter_size_t Vec_size_t__iterator(Vec_size_t *self) -{ - { - return (VecIter_size_t){.data = self->data, .count = self->len}; - } -} - -VecIterRef_size_t Vec_size_t__iter_ref(Vec_size_t *self) -{ - { - return (VecIterRef_size_t){.data = self->data, .count = self->len}; - } -} - -void Vec_size_t__push(Vec_size_t *self, size_t item) -{ - { - if ((self->len >= self->cap)) - { - Vec_size_t__grow(self); - } - (self->data[self->len] = item); - (self->len = (self->len + 1)); - } -} - -void Vec_size_t__insert(Vec_size_t *self, size_t idx, size_t item) -{ - { - if ((idx > self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Insert index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - if ((self->len >= self->cap)) - { - Vec_size_t__grow(self); - } - if ((idx < self->len)) - { - memmove(((self->data + idx) + 1), (self->data + idx), - ((self->len - idx) * sizeof(size_t))); - } - (self->data[idx] = item); - (self->len = (self->len + 1)); - } -} - -size_t Vec_size_t__pop(Vec_size_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: pop called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->len = (self->len - 1)); - return self->data[self->len]; - } -} - -Option_size_t Vec_size_t__pop_opt(Vec_size_t *self) -{ - { - if ((self->len == 0)) - { - return Option_size_t__None(); - } - (self->len = (self->len - 1)); - return Option_size_t__Some(self->data[self->len]); - } -} - -size_t Vec_size_t__remove(Vec_size_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Remove index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - size_t item = self->data[idx]; - if ((idx < (self->len - 1))) - { - memmove((self->data + idx), ((self->data + idx) + 1), - (((self->len - idx) - 1) * sizeof(size_t))); - } - (self->len = (self->len - 1)); - return item; - } -} - -void Vec_size_t__append(Vec_size_t *self, Vec_size_t other) -{ - int __z_drop_flag_other = 1; - { - size_t new_len = (self->len + other.len); - Vec_size_t__grow_to_fit(self, new_len); - memcpy((self->data + self->len), other.data, (other.len * sizeof(size_t))); - (self->len = new_len); - Vec_size_t__forget(&other); - } - if (__z_drop_flag_other) - { - Vec_size_t__Drop_glue(&other); - } -} - -size_t Vec_size_t__get(Vec_size_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[idx]; - } -} - -size_t Vec_size_t__index(Vec_size_t *self, size_t idx) -{ - { - return Vec_size_t__get(self, idx); - } -} - -size_t *Vec_size_t__get_ref(Vec_size_t *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->data[idx]); - } -} - -size_t Vec_size_t__last(Vec_size_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: last called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[(self->len - 1)]; - } -} - -size_t Vec_size_t__length(Vec_size_t *self) -{ - { - return self->len; - } -} - -bool Vec_size_t__contains(Vec_size_t *self, size_t item) -{ - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&item), sizeof(size_t)) == 0)) - { - return true; - } - (i++); - } - return false; - } -} - -bool Vec_size_t__is_empty(Vec_size_t *self) -{ - { - return (self->len == 0); - } -} - -void Vec_size_t__clear(Vec_size_t *self) -{ - { - (self->len = 0); - } -} - -void Vec_size_t__free(Vec_size_t *self) -{ - { - if (self->data) - { - free(self->data); - } - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -size_t Vec_size_t__first(Vec_size_t *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: first called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[0]; - } -} - -void Vec_size_t__set(Vec_size_t *self, size_t idx, size_t item) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: set index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->data[idx] = item); - } -} - -void Vec_size_t__reverse(Vec_size_t *self) -{ - { - size_t i = 0; - size_t j = (self->len - 1); - while ((i < j)) - { - size_t tmp = self->data[i]; - (self->data[i] = self->data[j]); - (self->data[j] = tmp); - (i++); - (j--); - } - } -} - -bool Vec_size_t__eq(Vec_size_t *self, Vec_size_t *other) -{ - { - bool result = true; - if ((self->len != (*other).len)) - { - (result = false); - } - else - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&(*other).data[i]), sizeof(size_t)) != 0)) - { - (result = false); - break; - } - (i = (i + 1)); - } - } - return result; - } -} - -void Vec_size_t__forget(Vec_size_t *self) -{ - { - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Vec_size_t Vec_size_t__add(Vec_size_t *self, Vec_size_t *other) -{ - { - int __z_drop_flag_result = 1; - Vec_size_t result = Vec_size_t__clone(self); - Vec_size_t__append(&result, Vec_size_t__clone(other)); - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_size_t__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_size_t__Drop_glue(&result); - } - } -} - -void Vec_size_t__add_assign(Vec_size_t *self, Vec_size_t *other) -{ - { - Vec_size_t__append(self, Vec_size_t__clone(other)); - } -} - -bool Vec_size_t__neq(Vec_size_t *self, Vec_size_t *other) -{ - { - bool result = (!Vec_size_t__eq(self, other)); - return result; - } -} - -void Vec_size_t__shl(Vec_size_t *self, size_t item) -{ - { - Vec_size_t__push(self, item); - } -} - -void Vec_size_t__shr(Vec_size_t *self, size_t *out_item) -{ - { - if ((out_item != 0)) - { - ((*out_item) = Vec_size_t__pop(self)); - } - else - { - Vec_size_t__pop(self); - } - } -} - -Vec_size_t Vec_size_t__mul(Vec_size_t *self, size_t count) -{ - { - int __z_drop_flag_result = 1; - Vec_size_t result = Vec_size_t__with_capacity((self->len * count)); - size_t c = 0; - while ((c < count)) - { - Vec_size_t__append(&result, Vec_size_t__clone(self)); - (c = (c + 1)); - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_size_t__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_size_t__Drop_glue(&result); - } - } -} - -void Vec_size_t__mul_assign(Vec_size_t *self, size_t count) -{ - { - if ((count == 0)) - { - Vec_size_t__clear(self); - return; - } - if ((count == 1)) - { - return; - } - size_t original_len = self->len; - Vec_size_t__grow_to_fit(self, (self->len * count)); - size_t c = 1; - while ((c < count)) - { - memcpy((self->data + (original_len * c)), self->data, (original_len * sizeof(size_t))); - (self->len = (self->len + original_len)); - (c = (c + 1)); - } - } -} - -Vec_size_t Vec_size_t__clone(Vec_size_t *self) -{ - { - if ((self->len == 0)) - { - return (Vec_size_t){}; - } - size_t *new_data = ((size_t *)(malloc((self->len * sizeof(size_t))))); - size_t i = 0; - while ((i < self->len)) - { - (new_data[i] = self->data[i]); - (i = (i + 1)); - } - return (Vec_size_t){.data = new_data, .len = self->len, .cap = self->len}; - } -} - -VecIterResult_size_t VecIterRef_size_t__next(VecIterRef_size_t *self) -{ - { - if ((self->idx < self->count)) - { - size_t *item = (&self->data[self->idx]); - (self->idx = (self->idx + 1)); - return (VecIterResult_size_t){.ptr = item}; - } - return (VecIterResult_size_t){}; - } -} - -VecIterRef_size_t VecIterRef_size_t__iterator(VecIterRef_size_t *self) -{ - { - return (*self); - } -} - -bool VecIterResult_size_t__is_none(VecIterResult_size_t *self) -{ - { - return (self->ptr == 0); - } -} - -size_t *VecIterResult_size_t__unwrap(VecIterResult_size_t *self) -{ - { - if ((self->ptr == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on null VecIterResult"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->ptr; - } -} - -Option_size_t VecIter_size_t__next(VecIter_size_t *self) -{ - { - if ((self->idx < self->count)) - { - size_t item = self->data[self->idx]; - (self->idx = (self->idx + 1)); - return Option_size_t__Some(item); - } - return Option_size_t__None(); - } -} - -VecIter_size_t VecIter_size_t__iterator(VecIter_size_t *self) -{ - { - return (*self); - } -} - -void Vec_size_t__Drop_drop(Vec_size_t *self) -{ - { - Vec_size_t__free(self); - } -} - -Option_size_t Option_size_t__Some(size_t v) -{ - { - return (Option_size_t){.is_some = true, .val = v}; - } -} - -Option_size_t Option_size_t__None(void) -{ - { - return (Option_size_t){.is_some = false}; - } -} - -bool Option_size_t__is_some(Option_size_t *self) -{ - { - return self->is_some; - } -} - -bool Option_size_t__is_none(Option_size_t *self) -{ - { - return (!self->is_some); - } -} - -void Option_size_t__forget(Option_size_t *self) -{ - { - memset((&self->val), 0, sizeof(size_t)); - } -} - -size_t Option_size_t__unwrap(Option_size_t *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - size_t v = self->val; - memset((&self->val), 0, sizeof(size_t)); - return v; - } -} - -size_t *Option_size_t__unwrap_ref(Option_size_t *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -size_t Option_size_t__unwrap_or(Option_size_t *self, size_t def_val) -{ - { - if (self->is_some) - { - return self->val; - } - return def_val; - } -} - -size_t Option_size_t__expect(Option_size_t *self, char *msg) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Option_size_t Option_size_t__or_else(Option_size_t *self, Option_size_t other) -{ - { - if (self->is_some) - { - return (*self); - } - return other; - } -} - -Option_int32_t Option_int32_t__Some(int32_t v) -{ - { - return (Option_int32_t){.is_some = true, .val = v}; - } -} - -Option_int32_t Option_int32_t__None(void) -{ - { - return (Option_int32_t){.is_some = false}; - } -} - -bool Option_int32_t__is_some(Option_int32_t *self) -{ - { - return self->is_some; - } -} - -bool Option_int32_t__is_none(Option_int32_t *self) -{ - { - return (!self->is_some); - } -} - -void Option_int32_t__forget(Option_int32_t *self) -{ - { - memset((&self->val), 0, sizeof(int32_t)); - } -} - -int32_t Option_int32_t__unwrap(Option_int32_t *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - int32_t v = self->val; - memset((&self->val), 0, sizeof(int32_t)); - return v; - } -} - -int32_t *Option_int32_t__unwrap_ref(Option_int32_t *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -int32_t Option_int32_t__unwrap_or(Option_int32_t *self, int32_t def_val) -{ - { - if (self->is_some) - { - return self->val; - } - return def_val; - } -} - -int32_t Option_int32_t__expect(Option_int32_t *self, char *msg) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Option_int32_t Option_int32_t__or_else(Option_int32_t *self, Option_int32_t other) -{ - { - if (self->is_some) - { - return (*self); - } - return other; - } -} - -Vec_char Vec_char__new(void) -{ - { - return (Vec_char){}; - } -} - -Vec_char Vec_char__with_capacity(size_t cap) -{ - { - if ((cap == 0)) - { - return (Vec_char){}; - } - return (Vec_char){.data = ((char *)(malloc((cap * sizeof(char))))), .cap = cap}; - } -} - -void Vec_char__grow(Vec_char *self) -{ - { - if ((self->cap == 0)) - { - (self->cap = 8); - } - else - { - (self->cap = (self->cap * 2)); - } - (self->data = ((char *)(realloc(self->data, (self->cap * sizeof(char)))))); - } -} - -void Vec_char__grow_to_fit(Vec_char *self, size_t new_len) -{ - { - if ((self->cap >= new_len)) - { - return; - } - if ((self->cap == 0)) - { - (self->cap = 8); - } - while ((self->cap < new_len)) - { - (self->cap = (self->cap * 2)); - } - (self->data = ((char *)(realloc(self->data, (self->cap * sizeof(char)))))); - } -} - -VecIter_char Vec_char__iterator(Vec_char *self) -{ - { - return (VecIter_char){.data = self->data, .count = self->len}; - } -} - -VecIterRef_char Vec_char__iter_ref(Vec_char *self) -{ - { - return (VecIterRef_char){.data = self->data, .count = self->len}; - } -} - -void Vec_char__push(Vec_char *self, char item) -{ - { - if ((self->len >= self->cap)) - { - Vec_char__grow(self); - } - (self->data[self->len] = item); - (self->len = (self->len + 1)); - } -} - -void Vec_char__insert(Vec_char *self, size_t idx, char item) -{ - { - if ((idx > self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Insert index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - if ((self->len >= self->cap)) - { - Vec_char__grow(self); - } - if ((idx < self->len)) - { - memmove(((self->data + idx) + 1), (self->data + idx), - ((self->len - idx) * sizeof(char))); - } - (self->data[idx] = item); - (self->len = (self->len + 1)); - } -} - -char Vec_char__pop(Vec_char *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: pop called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->len = (self->len - 1)); - return self->data[self->len]; - } -} - -Option_char Vec_char__pop_opt(Vec_char *self) -{ - { - if ((self->len == 0)) - { - return Option_char__None(); - } - (self->len = (self->len - 1)); - return Option_char__Some(self->data[self->len]); - } -} - -char Vec_char__remove(Vec_char *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Remove index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - char item = self->data[idx]; - if ((idx < (self->len - 1))) - { - memmove((self->data + idx), ((self->data + idx) + 1), - (((self->len - idx) - 1) * sizeof(char))); - } - (self->len = (self->len - 1)); - return item; - } -} - -void Vec_char__append(Vec_char *self, Vec_char other) -{ - int __z_drop_flag_other = 1; - { - size_t new_len = (self->len + other.len); - Vec_char__grow_to_fit(self, new_len); - memcpy((self->data + self->len), other.data, (other.len * sizeof(char))); - (self->len = new_len); - Vec_char__forget(&other); - } - if (__z_drop_flag_other) - { - Vec_char__Drop_glue(&other); - } -} - -char Vec_char__get(Vec_char *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[idx]; - } -} - -char Vec_char__index(Vec_char *self, size_t idx) -{ - { - return Vec_char__get(self, idx); - } -} - -char *Vec_char__get_ref(Vec_char *self, size_t idx) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: Index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->data[idx]); - } -} - -char Vec_char__last(Vec_char *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: last called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[(self->len - 1)]; - } -} - -size_t Vec_char__length(Vec_char *self) -{ - { - return self->len; - } -} - -bool Vec_char__contains(Vec_char *self, char item) -{ - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&item), sizeof(char)) == 0)) - { - return true; - } - (i++); - } - return false; - } -} - -bool Vec_char__is_empty(Vec_char *self) -{ - { - return (self->len == 0); - } -} - -void Vec_char__clear(Vec_char *self) -{ - { - (self->len = 0); - } -} - -void Vec_char__free(Vec_char *self) -{ - { - if (self->data) - { - free(self->data); - } - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -char Vec_char__first(Vec_char *self) -{ - { - if ((self->len == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: first called on empty Vec"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->data[0]; - } -} - -void Vec_char__set(Vec_char *self, size_t idx, char item) -{ - { - if ((idx >= self->len)) - { - ({ - fprintf(stderr, "%s", "Panic: set index out of bounds"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - (self->data[idx] = item); - } -} - -void Vec_char__reverse(Vec_char *self) -{ - { - size_t i = 0; - size_t j = (self->len - 1); - while ((i < j)) - { - char tmp = self->data[i]; - (self->data[i] = self->data[j]); - (self->data[j] = tmp); - (i++); - (j--); - } - } -} - -bool Vec_char__eq(Vec_char *self, Vec_char *other) -{ - { - bool result = true; - if ((self->len != (*other).len)) - { - (result = false); - } - else - { - size_t i = 0; - while ((i < self->len)) - { - if ((memcmp((&self->data[i]), (&(*other).data[i]), sizeof(char)) != 0)) - { - (result = false); - break; - } - (i = (i + 1)); - } - } - return result; - } -} - -void Vec_char__forget(Vec_char *self) -{ - { - (self->data = 0); - (self->len = 0); - (self->cap = 0); - } -} - -Vec_char Vec_char__add(Vec_char *self, Vec_char *other) -{ - { - int __z_drop_flag_result = 1; - Vec_char result = Vec_char__clone(self); - Vec_char__append(&result, Vec_char__clone(other)); - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_char__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_char__Drop_glue(&result); - } - } -} - -void Vec_char__add_assign(Vec_char *self, Vec_char *other) -{ - { - Vec_char__append(self, Vec_char__clone(other)); - } -} - -bool Vec_char__neq(Vec_char *self, Vec_char *other) -{ - { - bool result = (!Vec_char__eq(self, other)); - return result; - } -} - -void Vec_char__shl(Vec_char *self, char item) -{ - { - Vec_char__push(self, item); - } -} - -void Vec_char__shr(Vec_char *self, char *out_item) -{ - { - if ((out_item != 0)) - { - ((*out_item) = Vec_char__pop(self)); - } - else - { - Vec_char__pop(self); - } - } -} - -Vec_char Vec_char__mul(Vec_char *self, size_t count) -{ - { - int __z_drop_flag_result = 1; - Vec_char result = Vec_char__with_capacity((self->len * count)); - size_t c = 0; - while ((c < count)) - { - Vec_char__append(&result, Vec_char__clone(self)); - (c = (c + 1)); - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - Vec_char__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - Vec_char__Drop_glue(&result); - } - } -} - -void Vec_char__mul_assign(Vec_char *self, size_t count) -{ - { - if ((count == 0)) - { - Vec_char__clear(self); - return; - } - if ((count == 1)) - { - return; - } - size_t original_len = self->len; - Vec_char__grow_to_fit(self, (self->len * count)); - size_t c = 1; - while ((c < count)) - { - memcpy((self->data + (original_len * c)), self->data, (original_len * sizeof(char))); - (self->len = (self->len + original_len)); - (c = (c + 1)); - } - } -} - -Vec_char Vec_char__clone(Vec_char *self) -{ - { - if ((self->len == 0)) - { - return (Vec_char){}; - } - char *new_data = ((char *)(malloc((self->len * sizeof(char))))); - size_t i = 0; - while ((i < self->len)) - { - (new_data[i] = self->data[i]); - (i = (i + 1)); - } - return (Vec_char){.data = new_data, .len = self->len, .cap = self->len}; - } -} - -VecIterResult_char VecIterRef_char__next(VecIterRef_char *self) -{ - { - if ((self->idx < self->count)) - { - char *item = (&self->data[self->idx]); - (self->idx = (self->idx + 1)); - return (VecIterResult_char){.ptr = item}; - } - return (VecIterResult_char){}; - } -} - -VecIterRef_char VecIterRef_char__iterator(VecIterRef_char *self) -{ - { - return (*self); - } -} - -bool VecIterResult_char__is_none(VecIterResult_char *self) -{ - { - return (self->ptr == 0); - } -} - -char *VecIterResult_char__unwrap(VecIterResult_char *self) -{ - { - if ((self->ptr == 0)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on null VecIterResult"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->ptr; - } -} - -Option_char VecIter_char__next(VecIter_char *self) -{ - { - if ((self->idx < self->count)) - { - char item = self->data[self->idx]; - (self->idx = (self->idx + 1)); - return Option_char__Some(item); - } - return Option_char__None(); - } -} - -VecIter_char VecIter_char__iterator(VecIter_char *self) -{ - { - return (*self); - } -} - -Option_char Option_char__Some(char v) -{ - { - return (Option_char){.is_some = true, .val = v}; - } -} - -Option_char Option_char__None(void) -{ - { - return (Option_char){.is_some = false}; - } -} - -bool Option_char__is_some(Option_char *self) -{ - { - return self->is_some; - } -} - -bool Option_char__is_none(Option_char *self) -{ - { - return (!self->is_some); - } -} - -void Option_char__forget(Option_char *self) -{ - { - memset((&self->val), 0, sizeof(char)); - } -} - -char Option_char__unwrap(Option_char *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - char v = self->val; - memset((&self->val), 0, sizeof(char)); - return v; - } -} - -char *Option_char__unwrap_ref(Option_char *self) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: unwrap_ref called on None"); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return (&self->val); - } -} - -char Option_char__unwrap_or(Option_char *self, char def_val) -{ - { - if (self->is_some) - { - return self->val; - } - return def_val; - } -} - -char Option_char__expect(Option_char *self, char *msg) -{ - { - if ((!self->is_some)) - { - ({ - fprintf(stderr, "%s", "Panic: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - return self->val; - } -} - -Option_char Option_char__or_else(Option_char *self, Option_char other) -{ - { - if (self->is_some) - { - return (*self); - } - return other; - } -} - -void Vec_char__Drop_drop(Vec_char *self) -{ - { - Vec_char__free(self); - } -} - -void handler(Request *_req, Response *res) -{ - { - Response__set_body(res, String__new("Hello World")); - } -} - -void assert_true(bool cond, char *msg) -{ - { - if ((!cond)) - { - ({ - fprintf(stderr, "%s", "Assertion failed: "); - fprintf(stderr, "%s", msg); - fprintf(stderr, "\n"); - 0; - }); - exit(1); - } - } -} - -void sleep_ms(int32_t ms) -{ - { - int micros = ((int)((ms * 1000))); - _z_usleep(micros); - } -} - -Response fetch(String url) -{ - int __z_drop_flag_url = 1; - { - Result_Url u_res = Url__parse(url); - if (Result_Url__is_err((&u_res))) - { - ({ - fprintf(stdout, "%s", "Invalid URL: "); - fprintf(stdout, "%s", u_res.err); - fprintf(stdout, "\n"); - 0; - }); - { - Response _z_ret = Response__new(0); - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - return _z_ret; - } - } - int __z_drop_flag_u = 1; - Url u = Result_Url__unwrap((&u_res)); - if ((!String__eq_str((&u.scheme), "http"))) - { - ({ - fprintf(stdout, "%s", "Only http:// supported"); - fprintf(stdout, "\n"); - 0; - }); - { - Response _z_ret = Response__new(0); - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - return _z_ret; - } - } - int __z_drop_flag_host_ip = 1; - String host_ip = String__new(String__c_str((&u.host))); - Result_String dns_res = Dns__resolve(String__c_str((&u.host))); - if (Result_String__is_ok((&dns_res))) - { - String__free((&host_ip)); - (host_ip = Result_String__unwrap((&dns_res))); - } - char *ip_str = String__c_str((&host_ip)); - Result_TcpStream stream_res = TcpStream__connect(ip_str, u.port); - if (Result_TcpStream__is_err((&stream_res))) - { - ({ - fprintf(stdout, "%s", "Failed to connect to "); - fprintf(stdout, "%s", String__c_str((&u.host))); - fprintf(stdout, "%s", ":"); - fprintf(stdout, "%d", u.port); - fprintf(stdout, "%s", " ("); - fprintf(stdout, "%s", ip_str); - fprintf(stdout, "%s", ")"); - fprintf(stdout, "\n"); - 0; - }); - { - Response _z_ret = Response__new(0); - if (__z_drop_flag_host_ip) - { - String__Drop_glue(&host_ip); - } - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - return _z_ret; - } - } - int __z_drop_flag_stream = 1; - TcpStream stream = Result_TcpStream__unwrap((&stream_res)); - int __z_drop_flag_req_line = 1; - String req_line = String__new("GET "); - String__append((&req_line), (&u.path)); - if ((!String__is_empty((&u.query)))) - { - String__append_c((&req_line), "?"); - String__append((&req_line), (&u.query)); - } - String__append_c((&req_line), " HTTP/1.1\r\nHost: "); - String__append((&req_line), (&u.host)); - String__append_c((&req_line), "\r\nConnection: close\r\n\r\n"); - TcpStream__write((&stream), ((uint8_t *)(String__c_str((&req_line)))), - String__length((&req_line))); - char buf[4096] = {0}; - Result_size_t n_res = TcpStream__read((&stream), (&buf[_z_check_bounds(0, 4096)]), 4096); - if (Result_size_t__is_err((&n_res))) - { - TcpStream__close((&stream)); - { - Response _z_ret = Response__new(0); - if (__z_drop_flag_req_line) - { - String__Drop_glue(&req_line); - } - if (__z_drop_flag_stream) - { - TcpStream__Drop_glue(&stream); - } - if (__z_drop_flag_host_ip) - { - String__Drop_glue(&host_ip); - } - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - return _z_ret; - } - } - size_t n = Result_size_t__unwrap((&n_res)); - if ((n == 0)) - { - TcpStream__close((&stream)); - { - Response _z_ret = Response__new(0); - if (__z_drop_flag_req_line) - { - String__Drop_glue(&req_line); - } - if (__z_drop_flag_stream) - { - TcpStream__Drop_glue(&stream); - } - if (__z_drop_flag_host_ip) - { - String__Drop_glue(&host_ip); - } - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - return _z_ret; - } - } - if ((n < 4096)) - { - (buf[_z_check_bounds(n, 4096)] = 0); - } - else - { - (buf[_z_check_bounds(4095, 4096)] = 0); - } - int __z_drop_flag_raw_res = 1; - String raw_res = String__new((&buf[_z_check_bounds(0, 4096)])); - Option_size_t first_space = String__find((&raw_res), ' '); - int32_t status = 0; - if (Option_size_t__is_some((&first_space))) - { - size_t fs = Option_size_t__unwrap((&first_space)); - int __z_drop_flag_rest_line = 1; - String rest_line = - String__substring((&raw_res), (fs + 1), ((String__length((&raw_res)) - fs) - 1)); - Option_size_t second_space = String__find((&rest_line), ' '); - if (Option_size_t__is_some((&second_space))) - { - size_t ss = Option_size_t__unwrap((&second_space)); - int __z_drop_flag_code_str = 1; - String code_str = String__substring((&rest_line), 0, ss); - (status = atoi(String__c_str((&code_str)))); - if (__z_drop_flag_code_str) - { - String__Drop_glue(&code_str); - } - } - else - { - (status = atoi(String__c_str((&rest_line)))); - } - if (__z_drop_flag_rest_line) - { - String__Drop_glue(&rest_line); - } - } - int __z_drop_flag_res = 1; - Response res = Response__new(status); - string body_sep = "\r\n\r\n"; - char *body_ptr = strstr(String__c_str((&raw_res)), body_sep); - if ((body_ptr != NULL)) - { - size_t body_offset = ((size_t)((body_ptr - String__c_str((&raw_res))))); - size_t body_start = (body_offset + 4); - int __z_drop_flag_body_content = 1; - String body_content = String__substring((&raw_res), body_start, - (String__length((&raw_res)) - body_start)); - Response__set_body((&res), body_content); - if (__z_drop_flag_body_content) - { - String__Drop_glue(&body_content); - } - } - TcpStream__close((&stream)); - return ({ - ZC_AUTO _z_ret_mv = res; - memset(&res, 0, sizeof(_z_ret_mv)); - __z_drop_flag_res = 0; - if (__z_drop_flag_res) - { - Response__Drop_glue(&res); - } - if (__z_drop_flag_raw_res) - { - String__Drop_glue(&raw_res); - } - if (__z_drop_flag_req_line) - { - String__Drop_glue(&req_line); - } - if (__z_drop_flag_stream) - { - TcpStream__Drop_glue(&stream); - } - if (__z_drop_flag_host_ip) - { - String__Drop_glue(&host_ip); - } - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } - _z_ret_mv; - }); - if (__z_drop_flag_res) - { - Response__Drop_glue(&res); - } - if (__z_drop_flag_raw_res) - { - String__Drop_glue(&raw_res); - } - if (__z_drop_flag_req_line) - { - String__Drop_glue(&req_line); - } - if (__z_drop_flag_stream) - { - TcpStream__Drop_glue(&stream); - } - if (__z_drop_flag_host_ip) - { - String__Drop_glue(&host_ip); - } - if (__z_drop_flag_u) - { - Url__Drop_glue(&u); - } - } - if (__z_drop_flag_url) - { - String__Drop_glue(&url); - } -} - -Vec_Header _parse_headers(Vec_String lines, size_t start_idx) -{ - int __z_drop_flag_lines = 1; - { - int __z_drop_flag_headers = 1; - Vec_Header headers = Vec_Header__new(); - size_t len = lines.len; - for (size_t i = (size_t)(start_idx); i < len; i = (i + 1)) - { - String *line = Vec_String__get_ref((&lines), i); - if (String__is_empty(line)) - { - break; - } - int __z_drop_flag_parts = 1; - Vec_String parts = String__split(line, ':'); - if ((parts.len >= 2)) - { - String *key = Vec_String__get_ref((&parts), 0); - String *val = Vec_String__get_ref((&parts), 1); - int __z_drop_flag_key_t = 1; - String key_t = String__trim(key); - int __z_drop_flag_val_t = 1; - String val_t = String__trim(val); - Vec_Header__push((&headers), (struct Header){.key = key_t, .value = val_t}); - if (__z_drop_flag_val_t) - { - String__Drop_glue(&val_t); - } - if (__z_drop_flag_key_t) - { - String__Drop_glue(&key_t); - } - } - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - } - return ({ - ZC_AUTO _z_ret_mv = headers; - memset(&headers, 0, sizeof(_z_ret_mv)); - __z_drop_flag_headers = 0; - if (__z_drop_flag_headers) - { - Vec_Header__Drop_glue(&headers); - } - if (__z_drop_flag_lines) - { - Vec_String__Drop_glue(&lines); - } - _z_ret_mv; - }); - if (__z_drop_flag_headers) - { - Vec_Header__Drop_glue(&headers); - } - } - if (__z_drop_flag_lines) - { - Vec_String__Drop_glue(&lines); - } -} - -size_t _map_hash_str(const char *str) -{ - { - size_t hash = hash_get_seed(); - size_t i = 0; - while ((str[i] != 0)) - { - uint8_t b = ((uint8_t)(str[i])); - (hash = hash_combine(hash, ((size_t)(b)))); - (i = (i + 1)); - } - return hash; - } -} - -inline size_t hash_get_seed(void) -{ - { - return __zen_hash_seed; - } -} - -void hash_set_seed(size_t seed) -{ - { - (__zen_hash_seed = seed); - } -} - -size_t hash_compute(const void *data, size_t len) -{ - { - size_t hash = __zen_hash_seed; - uint8_t *bytes = ((uint8_t *)(data)); - for (size_t i = (size_t)(0); i < len; i = (i + 1)) - { - (hash = hash_combine(hash, ((size_t)(bytes[i])))); - } - return hash; - } -} - -inline size_t hash_combine(size_t a, size_t b) -{ - { - (a = (a ^ b)); - (a = (a * 435)); - return a; - } -} - -void _zen_panic(const char *file, int32_t line, const char *func, const char *msg) -{ - { - fprintf(stderr, "%s:%d (%s): Panic: %s\n", file, line, func, msg); - exit(1); - } -} - -void Mutex__Drop_drop(Mutex *self) -{ - { - Mutex__free(self); - } -} - -Mutex Mutex__new(void) -{ - { - void *ptr = malloc(64); - _z_mutex_init(ptr); - return (struct Mutex){.handle = ptr}; - } -} - -void Mutex__lock(Mutex *self) -{ - { - _z_mutex_lock(self->handle); - } -} - -void Mutex__unlock(Mutex *self) -{ - { - _z_mutex_unlock(self->handle); - } -} - -void Mutex__free(Mutex *self) -{ - { - if (self->handle) - { - _z_mutex_destroy(self->handle); - free(self->handle); - (self->handle = NULL); - } - } -} - -bool Thread__eq(Thread *self, const Thread other) -{ - { - return _z_thread_equal(self->handle, other.handle); - } -} - -bool Thread__neq(Thread *self, const Thread other) -{ - { - return (!Thread__eq(self, other)); - } -} - -Result_Thread Thread__spawn(z_closure_T func) -{ - int __z_drop_flag_func = 1; - { - size_t out_handle = 0; - void *ctx = malloc(sizeof(z_closure_T)); - if ((ctx == NULL)) - { - { - Result_Thread _z_ret = Result_Thread__Err("OOM"); - if (__z_drop_flag_func && func.drop) - { - func.drop(func.ctx); - } - return _z_ret; - } - } - memcpy(ctx, (&func), sizeof(z_closure_T)); - - ((z_closure_T *)&func)->drop = NULL; - - int ret = _z_thread_spawn(ctx, (&out_handle)); - if ((ret != 0)) - { - free(ctx); - { - Result_Thread _z_ret = Result_Thread__Err("Failed to create thread"); - if (__z_drop_flag_func && func.drop) - { - func.drop(func.ctx); - } - return _z_ret; - } - } - { - Result_Thread _z_ret = - Result_Thread__Ok((struct Thread){.handle = ((void *)(out_handle))}); - if (__z_drop_flag_func && func.drop) - { - func.drop(func.ctx); - } - return _z_ret; - } - } - if (__z_drop_flag_func && func.drop) - { - func.drop(func.ctx); - } -} - -Result_bool Thread__join(Thread *self) -{ - { - int err = _z_thread_join(self->handle); - if (err) - { - return Result_bool__Err("Join failed"); - } - return Result_bool__Ok(true); - } -} - -Result_bool Thread__detach(Thread *self) -{ - { - int err = _z_thread_detach(self->handle); - if (err) - { - return Result_bool__Err("Detach failed"); - } - return Result_bool__Ok(true); - } -} - -Result_bool Thread__cancel(Thread *self) -{ - { - int err = _z_thread_cancel(self->handle); - if (err) - { - return Result_bool__Err("Cancel failed"); - } - return Result_bool__Ok(true); - } -} - -Result_String Dns__resolve(char *host) -{ - { - char buf[64] = {0}; - int32_t res = _z_dns_resolve(host, (&buf[_z_check_bounds(0, 64)]), 64); - if ((res != 0)) - { - return Result_String__Err("DNS resolution failed"); - } - return Result_String__Ok(String__new((&buf[_z_check_bounds(0, 64)]))); - } -} - -Result_Url Url__parse(String raw) -{ - int __z_drop_flag_raw = 1; - { - char *u_str = String__c_str((&raw)); - char *scheme_end = strstr(u_str, "://"); - if ((scheme_end == NULL)) - { - { - Result_Url _z_ret = Result_Url__Err("Missing scheme"); - if (__z_drop_flag_raw) - { - String__Drop_glue(&raw); - } - return _z_ret; - } - } - size_t scheme_len = ((size_t)((scheme_end - u_str))); - int __z_drop_flag_scheme = 1; - String scheme = String__substring((&raw), 0, scheme_len); - char *rest = (scheme_end + 3); - int32_t default_port = 80; - if (String__eq_str((&scheme), "https")) - { - (default_port = 443); - } - ZC_AUTO host_end_slash = strchr(rest, '/'); - ZC_AUTO host_end_q = strchr(rest, '?'); - ZC_AUTO host_end = host_end_slash; - if ((host_end == NULL)) - { - (host_end = host_end_q); - } - else if (((host_end_q != NULL) && (host_end_q < host_end))) - { - (host_end = host_end_q); - } - size_t host_len = 0; - if ((host_end == NULL)) - { - (host_len = strlen(rest)); - } - else - { - (host_len = ((size_t)((host_end - rest)))); - } - char *host_port_buf = ((char *)(malloc((host_len + 1)))); - strncpy(host_port_buf, rest, host_len); - (host_port_buf[host_len] = 0); - int __z_drop_flag_host_str = 1; - String host_str = String__new(host_port_buf); - free(host_port_buf); - int32_t port = default_port; - int __z_drop_flag_final_host = 1; - String final_host = String__new(""); - int __z_drop_flag_parts = 1; - Vec_String parts = String__split((&host_str), ':'); - if ((parts.len == 2)) - { - (final_host = String__trim( - (__typeof__((Vec_String__get((&parts), 0)))[]){Vec_String__get((&parts), 0)})); - int __z_drop_flag_p_str = 1; - String p_str = Vec_String__get((&parts), 1); - (port = atoi(String__c_str((&p_str)))); - if (__z_drop_flag_p_str) - { - String__Drop_glue(&p_str); - } - } - else - { - (final_host = String__new(String__c_str((&host_str)))); - } - String__free((&host_str)); - int __z_drop_flag_path = 1; - String path = String__new("/"); - int __z_drop_flag_query = 1; - String query = String__new(""); - if ((host_end != NULL)) - { - if (((*host_end) == '/')) - { - int __z_drop_flag_remaining = 1; - String remaining = String__new(host_end); - Option_size_t q_pos = String__find((&remaining), '?'); - if (Option_size_t__is_some((&q_pos))) - { - size_t q_idx = Option_size_t__unwrap((&q_pos)); - String__free((&path)); - (path = String__substring((&remaining), 0, q_idx)); - String__free((&query)); - (query = String__substring((&remaining), (q_idx + 1), - ((String__length((&remaining)) - q_idx) - 1))); - } - else - { - String__free((&path)); - (path = String__substring((&remaining), 0, String__length((&remaining)))); - } - String__free((&remaining)); - if (__z_drop_flag_remaining) - { - String__Drop_glue(&remaining); - } - } - else if (((*host_end) == '?')) - { - String__free((&query)); - (query = String__new((host_end + 1))); - } - } - { - Result_Url _z_ret = Result_Url__Ok((struct Url){ - .scheme = scheme, .host = final_host, .port = port, .path = path, .query = query}); - if (__z_drop_flag_query) - { - String__Drop_glue(&query); - } - if (__z_drop_flag_path) - { - String__Drop_glue(&path); - } - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - if (__z_drop_flag_final_host) - { - String__Drop_glue(&final_host); - } - if (__z_drop_flag_host_str) - { - String__Drop_glue(&host_str); - } - if (__z_drop_flag_scheme) - { - String__Drop_glue(&scheme); - } - if (__z_drop_flag_raw) - { - String__Drop_glue(&raw); - } - return _z_ret; - } - if (__z_drop_flag_query) - { - String__Drop_glue(&query); - } - if (__z_drop_flag_path) - { - String__Drop_glue(&path); - } - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - if (__z_drop_flag_final_host) - { - String__Drop_glue(&final_host); - } - if (__z_drop_flag_host_str) - { - String__Drop_glue(&host_str); - } - if (__z_drop_flag_scheme) - { - String__Drop_glue(&scheme); - } - } - if (__z_drop_flag_raw) - { - String__Drop_glue(&raw); - } -} - -void Url__destroy(Url *self) -{ - { - String__free((&self->scheme)); - String__free((&self->host)); - String__free((&self->path)); - String__free((&self->query)); - } -} - -Server Server__new(int32_t port, void (*handler)(Request *, Response *)) -{ - { - return (struct Server){.port = port, .handler = ((void *)(handler))}; - } -} - -void Server__start(Server *self) -{ - { - string host = "0.0.0.0"; - Result_TcpListener listener_res = TcpListener__bind(host, self->port); - if (Result_TcpListener__is_err((&listener_res))) - { - ({ - fprintf(stdout, "%s", "Failed to bind port "); - fprintf(stdout, "%d", self->port); - fprintf(stdout, "\n"); - 0; - }); - return; - } - int __z_drop_flag_listener = 1; - TcpListener listener = Result_TcpListener__unwrap((&listener_res)); - ({ - fprintf(stdout, "%s", "Server listening on port "); - fprintf(stdout, "%d", self->port); - fprintf(stdout, "\n"); - 0; - }); - while (true) - { - Result_TcpStream client_res = TcpListener__accept((&listener)); - if (Result_TcpStream__is_err((&client_res))) - { - continue; - } - int __z_drop_flag_client = 1; - TcpStream client = Result_TcpStream__unwrap((&client_res)); - char buf[4096] = {0}; - Result_size_t read_res = - TcpStream__read((&client), (&buf[_z_check_bounds(0, 4096)]), 4096); - if (Result_size_t__is_ok((&read_res))) - { - size_t bytes_read = Result_size_t__unwrap((&read_res)); - if ((bytes_read > 0)) - { - if ((bytes_read < 4096)) - { - (buf[_z_check_bounds(bytes_read, 4096)] = 0); - } - else - { - (buf[_z_check_bounds(4095, 4096)] = 0); - } - int __z_drop_flag_req_str = 1; - String req_str = String__new((&buf[_z_check_bounds(0, 4096)])); - int __z_drop_flag_lines = 1; - Vec_String lines = String__split((&req_str), '\n'); - if ((lines.len > 0)) - { - String *first_line = Vec_String__get_ref((&lines), 0); - int __z_drop_flag_fl_parts = 1; - Vec_String fl_parts = String__split(first_line, ' '); - if ((fl_parts.len >= 2)) - { - int __z_drop_flag_method = 1; - String method = String__trim(Vec_String__get_ref((&fl_parts), 0)); - int __z_drop_flag_path = 1; - String path = String__trim(Vec_String__get_ref((&fl_parts), 1)); - int __z_drop_flag_req = 1; - Request req = Request__new(method, path); - int __z_drop_flag_res = 1; - Response res = Response__new(200); - void (*h_func)(Request *, Response *) = self->handler; - h_func((&req), (&res)); - int __z_drop_flag_response_str = 1; - String response_str = String__new("HTTP/1.1 "); - if ((res.status == 200)) - { - String__append_c((&response_str), "200 OK\r\n"); - } - else if ((res.status == 404)) - { - String__append_c((&response_str), "404 Not Found\r\n"); - } - else - { - String__append_c((&response_str), "500 Internal Server Error\r\n"); - } - for (int i = (int)(0); i < res.headers.len; i = (i + 1)) - { - Header *header = Vec_Header__get_ref((&res.headers), i); - String__append((&response_str), (&header->key)); - String__append_c((&response_str), ": "); - String__append((&response_str), (&header->value)); - String__append_c((&response_str), "\r\n"); - } - String__append_c((&response_str), "Content-Length: "); - char len_buf[32] = {0}; - size_t _body_len = String__length((&res.body)); - - snprintf(len_buf, 32, "%zu", _body_len); - - String__append_c((&response_str), (&len_buf[_z_check_bounds(0, 32)])); - String__append_c((&response_str), "\r\n"); - String__append_c((&response_str), "\r\n"); - String__append((&response_str), (&res.body)); - TcpStream__write((&client), - ((uint8_t *)(String__c_str((&response_str)))), - String__length((&response_str))); - if (__z_drop_flag_response_str) - { - String__Drop_glue(&response_str); - } - if (__z_drop_flag_res) - { - Response__Drop_glue(&res); - } - if (__z_drop_flag_req) - { - Request__Drop_glue(&req); - } - if (__z_drop_flag_path) - { - String__Drop_glue(&path); - } - if (__z_drop_flag_method) - { - String__Drop_glue(&method); - } - } - if (__z_drop_flag_fl_parts) - { - Vec_String__Drop_glue(&fl_parts); - } - } - if (__z_drop_flag_lines) - { - Vec_String__Drop_glue(&lines); - } - if (__z_drop_flag_req_str) - { - String__Drop_glue(&req_str); - } - } - } - TcpStream__close((&client)); - if (__z_drop_flag_client) - { - TcpStream__Drop_glue(&client); - } - } - if (__z_drop_flag_listener) - { - TcpListener__Drop_glue(&listener); - } - } -} - -Response Response__new(int32_t status) -{ - { - return (struct Response){ - .status = status, .headers = Vec_Header__new(), .body = String__new("")}; - } -} - -void Response__set_header(Response *self, String key, String value) -{ - int __z_drop_flag_key = 1; - int __z_drop_flag_value = 1; - { - int __z_drop_flag_h = 1; - Header h = (struct Header){.key = key, .value = value}; - Vec_Header__push((&self->headers), h); - if (__z_drop_flag_h) - { - Header__Drop_glue(&h); - } - } - if (__z_drop_flag_value) - { - String__Drop_glue(&value); - } - if (__z_drop_flag_key) - { - String__Drop_glue(&key); - } -} - -void Response__set_header_str(Response *self, char *key, char *value) -{ - { - Vec_Header__push((&self->headers), - (struct Header){.key = String__new(key), .value = String__new(value)}); - } -} - -void Response__set_body(Response *self, String body) -{ - int __z_drop_flag_body = 1; - { - String__free((&self->body)); - (self->body = body); - } - if (__z_drop_flag_body) - { - String__Drop_glue(&body); - } -} - -void Response__set_body_str(Response *self, char *body) -{ - { - String__free((&self->body)); - (self->body = String__new(body)); - } -} - -Request Request__new(String method, String path) -{ - int __z_drop_flag_method = 1; - int __z_drop_flag_path = 1; - { - { - Request _z_ret = (struct Request){.method = method, - .path = path, - .headers = Vec_Header__new(), - .body = String__new("")}; - if (__z_drop_flag_path) - { - String__Drop_glue(&path); - } - if (__z_drop_flag_method) - { - String__Drop_glue(&method); - } - return _z_ret; - } - } - if (__z_drop_flag_path) - { - String__Drop_glue(&path); - } - if (__z_drop_flag_method) - { - String__Drop_glue(&method); - } -} - -void TcpListener__Drop_drop(TcpListener *self) -{ - { - TcpListener__close(self); - } -} - -Result_TcpListener TcpListener__bind(char *host, int port) -{ - { - ptrdiff_t fd = _z_socket(2, 1, 0); - if ((fd < 0)) - { - return Result_TcpListener__Err("Failed to create socket"); - } - int res = _z_net_bind(fd, host, port); - if ((res == (-1))) - { - _z_close(fd); - return Result_TcpListener__Err("Invalid address"); - } - if ((res == (-2))) - { - _z_close(fd); - return Result_TcpListener__Err("Bind failed"); - } - if ((res == (-3))) - { - _z_close(fd); - return Result_TcpListener__Err("Listen failed"); - } - return Result_TcpListener__Ok((struct TcpListener){.handle = (fd + 1)}); - } -} - -Result_TcpStream TcpListener__accept(TcpListener *self) -{ - { - ptrdiff_t client_fd = _z_net_accept((self->handle - 1)); - if ((client_fd < 0)) - { - return Result_TcpStream__Err("Accept failed"); - } - return Result_TcpStream__Ok((struct TcpStream){.handle = (client_fd + 1)}); - } -} - -void TcpListener__close(TcpListener *self) -{ - { - if ((self->handle > 0)) - { - _z_close((self->handle - 1)); - (self->handle = 0); - } - } -} - -void TcpStream__Drop_drop(TcpStream *self) -{ - { - TcpStream__close(self); - } -} - -Result_size_t TcpStream__read(TcpStream *self, char *buf, size_t len) -{ - { - ptrdiff_t n = _z_read((self->handle - 1), ((void *)(buf)), len); - if ((n < 0)) - { - return Result_size_t__Err(strerror(errno)); - } - return Result_size_t__Ok(((size_t)(n))); - } -} - -Result_size_t TcpStream__read_exact(TcpStream *self, char *buf, size_t len) -{ - { - size_t total_read = 0; - while ((total_read < len)) - { - Result_size_t res = TcpStream__read(self, (buf + total_read), (len - total_read)); - if (Result_size_t__is_err((&res))) - { - return res; - } - size_t n = Result_size_t__unwrap((&res)); - if ((n == 0)) - { - return Result_size_t__Err("Unexpected EOF"); - } - (total_read = (total_read + n)); - } - return Result_size_t__Ok(total_read); - } -} - -Result_size_t TcpStream__write(TcpStream *self, uint8_t *buf, size_t len) -{ - { - ptrdiff_t n = _z_net_write((self->handle - 1), ((char *)(buf)), len); - if ((n < 0)) - { - return Result_size_t__Err("Write failed"); - } - return Result_size_t__Ok(((size_t)(n))); - } -} - -void TcpStream__close(TcpStream *self) -{ - { - if ((self->handle > 0)) - { - _z_close((self->handle - 1)); - (self->handle = 0); - } - } -} - -Result_TcpStream TcpStream__connect(char *host, int port) -{ - { - ptrdiff_t fd = _z_socket(2, 1, 0); - if ((fd < 0)) - { - return Result_TcpStream__Err("Failed to create socket"); - } - int res = _z_net_connect(fd, host, port); - if ((res == (-1))) - { - _z_close(fd); - return Result_TcpStream__Err("Invalid address"); - } - if ((res == (-2))) - { - _z_close(fd); - return Result_TcpStream__Err("Connection failed"); - } - return Result_TcpStream__Ok((struct TcpStream){.handle = (fd + 1)}); - } -} - -String String__new(char *s) -{ - { - ZC_AUTO len = strlen(s); - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - for (int i = (int)(0); i < len; i = (i + 1)) - { - Vec_char__push((&v), s[i]); - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -String String__from(char *s) -{ - { - return String__new(s); - } -} - -String String__from_rune(int32_t r) -{ - { - int __z_drop_flag_s = 1; - String s = String__new(""); - String__push_rune(&s, r); - return ({ - ZC_AUTO _z_ret_mv = s; - memset(&s, 0, sizeof(_z_ret_mv)); - __z_drop_flag_s = 0; - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - _z_ret_mv; - }); - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - } -} - -String String__from_runes(int32_t *runes, size_t count) -{ - { - int __z_drop_flag_s = 1; - String s = String__new(""); - for (size_t i = (size_t)(0); i < count; i = (i + 1)) - { - String__push_rune(&s, runes[i]); - } - return ({ - ZC_AUTO _z_ret_mv = s; - memset(&s, 0, sizeof(_z_ret_mv)); - __z_drop_flag_s = 0; - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - _z_ret_mv; - }); - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - } -} - -char *String__c_str(String *self) -{ - { - return self->vec.data; - } -} - -char *String__to_string(String *self) -{ - { - return String__c_str(self); - } -} - -void String__destroy(String *self) -{ - { - Vec_char__free((&self->vec)); - } -} - -void String__forget(String *self) -{ - { - Vec_char__forget((&self->vec)); - } -} - -void String__append(String *self, String *other) -{ - { - if ((self->vec.len > 0)) - { - (self->vec.len = (self->vec.len - 1)); - } - size_t other_len = (*other).vec.len; - for (int i = (int)(0); i < other_len; i = (i + 1)) - { - Vec_char__push((&self->vec), Vec_char__get((&(*other).vec), i)); - } - } -} - -void String__append_c(String *self, char *s) -{ - { - if ((self->vec.len > 0)) - { - (self->vec.len = (self->vec.len - 1)); - } - ZC_AUTO len = strlen(s); - for (int i = (int)(0); i < len; i = (i + 1)) - { - Vec_char__push((&self->vec), s[i]); - } - Vec_char__push((&self->vec), 0); - } -} - -void String__push_rune(String *self, int32_t r) -{ - { - if ((self->vec.len > 0)) - { - (self->vec.len = (self->vec.len - 1)); - } - uint32_t val = ((uint32_t)(r)); - if ((val < 128)) - { - Vec_char__push((&self->vec), ((char)(val))); - } - else if ((val < 2048)) - { - Vec_char__push((&self->vec), ((char)((192 | (val >> 6))))); - Vec_char__push((&self->vec), ((char)((128 | (val & 63))))); - } - else if ((val < 65536)) - { - Vec_char__push((&self->vec), ((char)((224 | (val >> 12))))); - Vec_char__push((&self->vec), ((char)((128 | ((val >> 6) & 63))))); - Vec_char__push((&self->vec), ((char)((128 | (val & 63))))); - } - else - { - Vec_char__push((&self->vec), ((char)((240 | (val >> 18))))); - Vec_char__push((&self->vec), ((char)((128 | ((val >> 12) & 63))))); - Vec_char__push((&self->vec), ((char)((128 | ((val >> 6) & 63))))); - Vec_char__push((&self->vec), ((char)((128 | (val & 63))))); - } - Vec_char__push((&self->vec), 0); - } -} - -void String__append_c_ptr(String *ptr, char *s) -{ - { - if ((ptr->vec.len > 0)) - { - (ptr->vec.len = (ptr->vec.len - 1)); - } - ZC_AUTO len = strlen(s); - for (int i = (int)(0); i < len; i = (i + 1)) - { - Vec_char__push((&ptr->vec), s[i]); - } - Vec_char__push((&ptr->vec), 0); - } -} - -String String__add(String *self, String *other) -{ - { - int __z_drop_flag_new_s = 1; - String new_s = String__from(String__c_str(self)); - String__append((&new_s), other); - char *d = new_s.vec.data; - size_t l = new_s.vec.len; - size_t c = new_s.vec.cap; - String__forget((&new_s)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c}}; - if (__z_drop_flag_new_s) - { - String__Drop_glue(&new_s); - } - return _z_ret; - } - if (__z_drop_flag_new_s) - { - String__Drop_glue(&new_s); - } - } -} - -void String__add_assign(String *self, String *other) -{ - { - String__append(self, other); - } -} - -bool String__eq(String *self, String *other) -{ - { - int zero = 0; - return (strcmp(String__c_str(self), String__c_str((&(*other)))) == zero); - } -} - -bool String__neq(String *self, String *other) -{ - { - return (!String__eq(self, other)); - } -} - -int32_t String__compare(String *self, String *other) -{ - { - return strcmp(String__c_str(self), String__c_str((&(*other)))); - } -} - -bool String__lt(String *self, String *other) -{ - { - return (String__compare(self, other) < 0); - } -} - -bool String__gt(String *self, String *other) -{ - { - return (String__compare(self, other) > 0); - } -} - -bool String__le(String *self, String *other) -{ - { - return (String__compare(self, other) <= 0); - } -} - -bool String__ge(String *self, String *other) -{ - { - return (String__compare(self, other) >= 0); - } -} - -int32_t String__compare_ignore_case(String *self, String *other) -{ - { - return strcasecmp(String__c_str(self), String__c_str((&(*other)))); - } -} - -bool String__eq_ignore_case(String *self, String *other) -{ - { - int32_t zero = 0; - return (String__compare_ignore_case(self, other) == zero); - } -} - -bool String__eq_str(String *self, char *s) -{ - { - int zero = 0; - return (strcmp(String__c_str(self), s) == zero); - } -} - -size_t String__length(String *self) -{ - { - if ((self->vec.len == 0)) - { - return 0; - } - return (self->vec.len - 1); - } -} - -String String__substring(String *self, size_t start, size_t len) -{ - { - if (((start + len) > String__length(self))) - { - panic("substring out of bounds"); - } - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - for (size_t i = (size_t)(0); i < len; i = (i + 1)) - { - Vec_char__push((&v), Vec_char__get((&self->vec), (start + i))); - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -bool String__contains_str(String *self, char *target) -{ - { - return Option_size_t__is_some((Option_size_t[]){String__find_str(self, target)}); - } -} - -Option_size_t String__find_str(String *self, char *target) -{ - { - ZC_AUTO t_len = strlen(target); - if ((t_len == 0)) - { - return Option_size_t__Some(0); - } - size_t s_len = String__length(self); - if ((t_len > s_len)) - { - return Option_size_t__None(); - } - for (size_t i = (size_t)(0); i <= (s_len - t_len); i = (i + 1)) - { - bool is_match = true; - for (size_t k = (size_t)(0); k < t_len; k = (k + 1)) - { - if ((Vec_char__get((&self->vec), (i + k)) != target[k])) - { - (is_match = false); - break; - } - } - if (is_match) - { - return Option_size_t__Some(i); - } - } - return Option_size_t__None(); - } -} - -Vec_size_t String__find_all_str(String *self, char *target) -{ - { - int __z_drop_flag_indices = 1; - Vec_size_t indices = Vec_size_t__new(); - ZC_AUTO t_len = strlen(target); - if ((t_len == 0)) - { - return ({ - ZC_AUTO _z_ret_mv = indices; - memset(&indices, 0, sizeof(_z_ret_mv)); - __z_drop_flag_indices = 0; - if (__z_drop_flag_indices) - { - Vec_size_t__Drop_glue(&indices); - } - _z_ret_mv; - }); - } - size_t s_len = String__length(self); - if ((t_len > s_len)) - { - return ({ - ZC_AUTO _z_ret_mv = indices; - memset(&indices, 0, sizeof(_z_ret_mv)); - __z_drop_flag_indices = 0; - if (__z_drop_flag_indices) - { - Vec_size_t__Drop_glue(&indices); - } - _z_ret_mv; - }); - } - for (size_t i = (size_t)(0); i <= (s_len - t_len); i = (i + 1)) - { - bool is_match = true; - for (size_t k = (size_t)(0); k < t_len; k = (k + 1)) - { - if ((Vec_char__get((&self->vec), (i + k)) != target[k])) - { - (is_match = false); - break; - } - } - if (is_match) - { - Vec_size_t__push((&indices), i); - } - } - return ({ - ZC_AUTO _z_ret_mv = indices; - memset(&indices, 0, sizeof(_z_ret_mv)); - __z_drop_flag_indices = 0; - if (__z_drop_flag_indices) - { - Vec_size_t__Drop_glue(&indices); - } - _z_ret_mv; - }); - if (__z_drop_flag_indices) - { - Vec_size_t__Drop_glue(&indices); - } - } -} - -String String__to_lowercase(String *self) -{ - { - size_t len = String__length(self); - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - for (size_t i = (size_t)(0); i < len; i = (i + 1)) - { - char c = Vec_char__get((&self->vec), i); - if (((c >= 'A') && (c <= 'Z'))) - { - Vec_char__push((&v), ((char)((((int32_t)(c)) + 32)))); - } - else - { - Vec_char__push((&v), c); - } - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c_cap = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c_cap}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -String String__pad_right(String *self, size_t target_len, char pad_char) -{ - { - size_t current_len = String__length(self); - if ((current_len >= target_len)) - { - return String__from(String__c_str(self)); - } - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - for (size_t i = (size_t)(0); i < current_len; i = (i + 1)) - { - Vec_char__push((&v), Vec_char__get((&self->vec), i)); - } - for (size_t i = (size_t)(current_len); i < target_len; i = (i + 1)) - { - Vec_char__push((&v), pad_char); - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c_cap = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c_cap}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -String String__pad_left(String *self, size_t target_len, char pad_char) -{ - { - size_t current_len = String__length(self); - if ((current_len >= target_len)) - { - return String__from(String__c_str(self)); - } - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - size_t diff = (target_len - current_len); - for (size_t i = (size_t)(0); i < diff; i = (i + 1)) - { - Vec_char__push((&v), pad_char); - } - for (size_t i = (size_t)(0); i < current_len; i = (i + 1)) - { - Vec_char__push((&v), Vec_char__get((&self->vec), i)); - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c_cap = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c_cap}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -String String__to_uppercase(String *self) -{ - { - size_t len = String__length(self); - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - for (size_t i = (size_t)(0); i < len; i = (i + 1)) - { - char c = Vec_char__get((&self->vec), i); - if (((c >= 'a') && (c <= 'z'))) - { - Vec_char__push((&v), ((char)((((int32_t)(c)) - 32)))); - } - else - { - Vec_char__push((&v), c); - } - } - Vec_char__push((&v), 0); - char *d = v.data; - size_t l = v.len; - size_t c_cap = v.cap; - Vec_char__forget((&v)); - { - String _z_ret = (struct String){.vec = (Vec_char){.data = d, .len = l, .cap = c_cap}}; - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - return _z_ret; - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } -} - -Option_size_t String__find(String *self, char target) -{ - { - size_t len = String__length(self); - for (size_t i = (size_t)(0); i < len; i = (i + 1)) - { - if ((Vec_char__get((&self->vec), i) == target)) - { - return Option_size_t__Some(i); - } - } - return Option_size_t__None(); - } -} - -void String__print(String *self) -{ - { - printf("%s", String__c_str(self)); - fflush(stdout); - } -} - -void String__println(String *self) -{ - { - printf("%s\n", String__c_str(self)); - } -} - -bool String__is_empty(String *self) -{ - { - return (String__length(self) == 0); - } -} - -bool String__contains(String *self, char target) -{ - { - return Option_size_t__is_some( - (__typeof__((String__find(self, target)))[]){String__find(self, target)}); - } -} - -bool String__starts_with(String *self, char *prefix) -{ - { - ZC_AUTO plen = strlen(prefix); - if ((plen > String__length(self))) - { - return false; - } - int zero = 0; - return (strncmp(String__c_str(self), prefix, plen) == zero); - } -} - -bool String__ends_with(String *self, char *suffix) -{ - { - ZC_AUTO slen = strlen(suffix); - size_t len = String__length(self); - if ((slen > len)) - { - return false; - } - int32_t offset = ((int32_t)((len - slen))); - int zero = 0; - return (strcmp((String__c_str(self) + offset), suffix) == zero); - } -} - -void String__reserve(String *self, size_t cap) -{ - { - Vec_char__grow_to_fit((&self->vec), (cap + 1)); - } -} - -void String__free(String *self) -{ - { - Vec_char__free((&self->vec)); - } -} - -size_t String___utf8_seq_len(char first_byte) -{ - { - int32_t b = ((int32_t)(first_byte)); - if (((b & 128) == 0)) - { - return 1; - } - if (((b & 224) == 192)) - { - return 2; - } - if (((b & 240) == 224)) - { - return 3; - } - if (((b & 248) == 240)) - { - return 4; - } - return 1; - } -} - -size_t String__utf8_len(String *self) -{ - { - size_t count = 0; - size_t i = 0; - size_t len = String__length(self); - while ((i < len)) - { - char c = Vec_char__get((&self->vec), i); - (i = (i + String___utf8_seq_len(c))); - (count = (count + 1)); - } - return count; - } -} - -String String__utf8_at(String *self, size_t idx) -{ - { - size_t count = 0; - size_t i = 0; - size_t len = String__length(self); - while ((i < len)) - { - char c = Vec_char__get((&self->vec), i); - size_t seq = String___utf8_seq_len(c); - if ((count == idx)) - { - return String__substring(self, i, seq); - } - (i = (i + seq)); - (count = (count + 1)); - } - return String__new(""); - } -} - -int32_t String__utf8_get(String *self, size_t idx) -{ - { - size_t count = 0; - size_t i = 0; - size_t len = String__length(self); - while ((i < len)) - { - uint8_t c = ((uint8_t)(Vec_char__get((&self->vec), i))); - size_t seq = String___utf8_seq_len(((char)(c))); - if ((count == idx)) - { - if ((seq == 1)) - { - return ((int32_t)(c)); - } - if ((seq == 2)) - { - return ((int32_t)(( - (((int32_t)((c & 31))) << 6) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63)))); - } - if ((seq == 3)) - { - return ((int32_t)(( - ((((int32_t)((c & 15))) << 12) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) - << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63)))); - } - if ((seq == 4)) - { - return ((int32_t)(( - (((((int32_t)((c & 7))) << 18) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) - << 12)) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63) - << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 3)))))) & 63)))); - } - } - (i = (i + seq)); - (count = (count + 1)); - } - return ((int32_t)(0)); - } -} - -Vec_int32_t String__runes(String *self) -{ - { - int __z_drop_flag_v = 1; - Vec_int32_t v = Vec_int32_t__new(); - size_t i = 0; - size_t len = String__length(self); - while ((i < len)) - { - uint8_t c = ((uint8_t)(Vec_char__get((&self->vec), i))); - size_t seq = String___utf8_seq_len(((char)(c))); - int32_t val = 0; - if ((seq == 1)) - { - (val = ((int32_t)(c))); - } - else if ((seq == 2)) - { - (val = ((int32_t)(( - (((int32_t)((c & 31))) << 6) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63))))); - } - else if ((seq == 3)) - { - (val = ((int32_t)(( - ((((int32_t)((c & 15))) << 12) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) - << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63))))); - } - else if ((seq == 4)) - { - (val = ((int32_t)(( - (((((int32_t)((c & 7))) << 18) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) - << 12)) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63) - << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 3)))))) & 63))))); - } - Vec_int32_t__push((&v), val); - (i = (i + seq)); - } - return ({ - ZC_AUTO _z_ret_mv = v; - memset(&v, 0, sizeof(_z_ret_mv)); - __z_drop_flag_v = 0; - if (__z_drop_flag_v) - { - Vec_int32_t__Drop_glue(&v); - } - _z_ret_mv; - }); - if (__z_drop_flag_v) - { - Vec_int32_t__Drop_glue(&v); - } - } -} - -StringCharsIter String__chars(String *self) -{ - { - return (struct StringCharsIter){.data = String__c_str(self), .len = String__length(self)}; - } -} - -String String__from_runes_vec(Vec_int32_t runes) -{ - int __z_drop_flag_runes = 1; - { - int __z_drop_flag_s = 1; - String s = String__new(""); - for (size_t i = (size_t)(0); i < runes.len; i = (i + 1)) - { - String__push_rune((&s), Vec_int32_t__get((&runes), i)); - } - return ({ - ZC_AUTO _z_ret_mv = s; - memset(&s, 0, sizeof(_z_ret_mv)); - __z_drop_flag_s = 0; - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - if (__z_drop_flag_runes) - { - Vec_int32_t__Drop_glue(&runes); - } - _z_ret_mv; - }); - if (__z_drop_flag_s) - { - String__Drop_glue(&s); - } - } - if (__z_drop_flag_runes) - { - Vec_int32_t__Drop_glue(&runes); - } -} - -void String__insert_rune(String *self, size_t idx, int32_t r) -{ - { - size_t i = 0; - size_t count = 0; - size_t len = String__length(self); - while (((i < len) && (count < idx))) - { - (i = (i + String___utf8_seq_len(Vec_char__get((&self->vec), i)))); - (count = (count + 1)); - } - uint32_t val = ((uint32_t)(r)); - if ((val < 128)) - { - Vec_char__insert((&self->vec), i, ((char)(val))); - } - else if ((val < 2048)) - { - Vec_char__insert((&self->vec), i, ((char)((192 | (val >> 6))))); - Vec_char__insert((&self->vec), (i + 1), ((char)((128 | (val & 63))))); - } - else if ((val < 65536)) - { - Vec_char__insert((&self->vec), i, ((char)((224 | (val >> 12))))); - Vec_char__insert((&self->vec), (i + 1), ((char)((128 | ((val >> 6) & 63))))); - Vec_char__insert((&self->vec), (i + 2), ((char)((128 | (val & 63))))); - } - else - { - Vec_char__insert((&self->vec), i, ((char)((240 | (val >> 18))))); - Vec_char__insert((&self->vec), (i + 1), ((char)((128 | ((val >> 12) & 63))))); - Vec_char__insert((&self->vec), (i + 2), ((char)((128 | ((val >> 6) & 63))))); - Vec_char__insert((&self->vec), (i + 3), ((char)((128 | (val & 63))))); - } - } -} - -int32_t String__remove_rune_at(String *self, size_t idx) -{ - { - size_t i = 0; - size_t count = 0; - size_t len = String__length(self); - while (((i < len) && (count < idx))) - { - (i = (i + String___utf8_seq_len(Vec_char__get((&self->vec), i)))); - (count = (count + 1)); - } - if ((i >= len)) - { - return ((int32_t)(0)); - } - uint8_t c = ((uint8_t)(Vec_char__get((&self->vec), i))); - size_t seq = String___utf8_seq_len(((char)(c))); - int32_t val = 0; - if ((seq == 1)) - { - (val = ((int32_t)(c))); - } - else if ((seq == 2)) - { - (val = ((int32_t)(( - (((int32_t)((c & 31))) << 6) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63))))); - } - else if ((seq == 3)) - { - (val = ((int32_t)(( - ((((int32_t)((c & 15))) << 12) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63))))); - } - else if ((seq == 4)) - { - (val = ((int32_t)(( - (((((int32_t)((c & 7))) << 18) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 1)))))) & 63) << 12)) | - ((((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 2)))))) & 63) << 6)) | - (((int32_t)(((uint8_t)(Vec_char__get((&self->vec), (i + 3)))))) & 63))))); - } - for (size_t j = (size_t)(0); j < seq; j = (j + 1)) - { - Vec_char__remove((&self->vec), i); - } - return val; - } -} - -String String__utf8_substr(String *self, size_t start_idx, size_t num_chars) -{ - { - if ((num_chars == 0)) - { - return String__new(""); - } - size_t byte_start = 0; - size_t byte_len = 0; - size_t count = 0; - size_t i = 0; - size_t len = String__length(self); - bool found_start = false; - while ((i < len)) - { - if (((!found_start) && (count == start_idx))) - { - (byte_start = i); - (found_start = true); - (count = 0); - } - else if ((!found_start)) - { - char c = Vec_char__get((&self->vec), i); - (i = (i + String___utf8_seq_len(c))); - (count = (count + 1)); - continue; - } - if ((count < num_chars)) - { - char c = Vec_char__get((&self->vec), i); - size_t seq = String___utf8_seq_len(c); - (byte_len = (byte_len + seq)); - (i = (i + seq)); - (count = (count + 1)); - } - else - { - break; - } - } - if ((!found_start)) - { - return String__new(""); - } - return String__substring(self, byte_start, byte_len); - } -} - -Vec_String String__split(String *self, char delim) -{ - { - int __z_drop_flag_parts = 1; - Vec_String parts = Vec_String__new(); - size_t len = String__length(self); - if ((len == 0)) - { - return ({ - ZC_AUTO _z_ret_mv = parts; - memset(&parts, 0, sizeof(_z_ret_mv)); - __z_drop_flag_parts = 0; - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - _z_ret_mv; - }); - } - size_t start = 0; - size_t i = 0; - while ((i < len)) - { - if ((Vec_char__get((&self->vec), i) == delim)) - { - Vec_String__push((&parts), String__substring(self, start, (i - start))); - (start = (i + 1)); - } - (i = (i + 1)); - } - if ((start <= len)) - { - Vec_String__push((&parts), String__substring(self, start, (len - start))); - } - return ({ - ZC_AUTO _z_ret_mv = parts; - memset(&parts, 0, sizeof(_z_ret_mv)); - __z_drop_flag_parts = 0; - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - _z_ret_mv; - }); - if (__z_drop_flag_parts) - { - Vec_String__Drop_glue(&parts); - } - } -} - -String String__trim(String *self) -{ - { - size_t start = 0; - size_t len = String__length(self); - size_t end = len; - while ((start < len)) - { - char c = Vec_char__get((&self->vec), start); - if (((((c != ' ') && (c != '\t')) && (c != '\n')) && (c != '\r'))) - { - break; - } - (start = (start + 1)); - } - if ((start == len)) - { - return String__new(""); - } - while ((end > start)) - { - char c = Vec_char__get((&self->vec), (end - 1)); - if (((((c != ' ') && (c != '\t')) && (c != '\n')) && (c != '\r'))) - { - break; - } - (end = (end - 1)); - } - return String__substring(self, start, (end - start)); - } -} - -String String__replace(String *self, char *target, char *replacement) -{ - { - ZC_AUTO t_len = strlen(target); - if ((t_len == 0)) - { - return String__substring(self, 0, String__length(self)); - } - size_t s_len = String__length(self); - int __z_drop_flag_result = 1; - String result = String__new(""); - size_t i = 0; - while ((i < s_len)) - { - if (((i + t_len) <= s_len)) - { - bool is_match = true; - for (size_t k = (size_t)(0); k < t_len; k = (k + 1)) - { - if ((Vec_char__get((&self->vec), (i + k)) != target[k])) - { - (is_match = false); - break; - } - } - if (is_match) - { - int __z_drop_flag_r_str = 1; - String r_str = String__new(replacement); - String__append((&result), (&r_str)); - (i = (i + t_len)); - if (__z_drop_flag_r_str) - { - String__Drop_glue(&r_str); - } - continue; - if (__z_drop_flag_r_str) - { - String__Drop_glue(&r_str); - } - } - } - int __z_drop_flag_v = 1; - Vec_char v = Vec_char__new(); - Vec_char__push((&v), Vec_char__get((&self->vec), i)); - Vec_char__push((&v), 0); - int __z_drop_flag_ch_s = 1; - String ch_s = String__new(v.data); - String__append((&result), (&ch_s)); - String__destroy((&ch_s)); - (i = (i + 1)); - if (__z_drop_flag_ch_s) - { - String__Drop_glue(&ch_s); - } - if (__z_drop_flag_v) - { - Vec_char__Drop_glue(&v); - } - } - return ({ - ZC_AUTO _z_ret_mv = result; - memset(&result, 0, sizeof(_z_ret_mv)); - __z_drop_flag_result = 0; - if (__z_drop_flag_result) - { - String__Drop_glue(&result); - } - _z_ret_mv; - }); - if (__z_drop_flag_result) - { - String__Drop_glue(&result); - } - } -} - -Option_int32_t StringCharsIter__next(StringCharsIter *self) -{ - { - if ((self->pos >= self->len)) - { - return Option_int32_t__None(); - } - uint8_t c = ((uint8_t)(self->data[self->pos])); - size_t seq = String___utf8_seq_len(((char)(c))); - if (((self->pos + seq) > self->len)) - { - (self->pos = self->len); - return Option_int32_t__None(); - } - int32_t val = 0; - if ((seq == 1)) - { - (val = ((int32_t)(c))); - } - else if ((seq == 2)) - { - (val = ((int32_t)(((((int32_t)((c & 31))) << 6) | - (((int32_t)(((uint8_t)(self->data[(self->pos + 1)])))) & 63))))); - } - else if ((seq == 3)) - { - (val = - ((int32_t)((((((int32_t)((c & 15))) << 12) | - ((((int32_t)(((uint8_t)(self->data[(self->pos + 1)])))) & 63) << 6)) | - (((int32_t)(((uint8_t)(self->data[(self->pos + 2)])))) & 63))))); - } - else if ((seq == 4)) - { - (val = (( - int32_t)(((((((int32_t)((c & 7))) << 18) | - ((((int32_t)(((uint8_t)(self->data[(self->pos + 1)])))) & 63) << 12)) | - ((((int32_t)(((uint8_t)(self->data[(self->pos + 2)])))) & 63) << 6)) | - (((int32_t)(((uint8_t)(self->data[(self->pos + 3)])))) & 63))))); - } - (self->pos = (self->pos + seq)); - return Option_int32_t__Some(val); - } -} - -int main() -{ - _z_run_tests(); - return 0; -}