neuron-technologies/el
2
0
Fork 0
Code Issues 1 Pull Requests 6 Actions Packages Projects Releases 5 Wiki Activity
Files
hotfix/runtime-engram-get-node-by-label
el/lang/el-compiler/runtime/el_runtime_win32.c
T

1147 lines
42 KiB
C
Raw Permalink Blame History

/*
* el_runtime_win32.c — Minimal Win32-compatible el runtime stub.
*
* Provides only the symbols that native-hello (and the el-native vessel) call
* from el_runtime.h. Replaces the full el_runtime.c + el_seed.c for
* cross-compiled Win32 targets where POSIX headers (pthread, curl, dlfcn,
* sys/socket, etc.) are unavailable.
*
* Symbols provided:
* Allocators: el_strdup, el_strbuf, el_wrap_str (static helpers)
* I/O: println, print
* String: el_str_concat, str_eq, str_starts_with, str_len, str_concat,
* int_to_str, str_to_int, native_str_to_int, str_slice, str_trim,
* str_contains, str_ends_with, str_to_upper, str_to_lower,
* str_index_of, str_char_at, str_char_code, str_replace,
* str_pad_left, str_pad_right, str_upper, str_lower
* Math: el_abs, el_max, el_min, int_to_float, float_to_int
* List: el_list_empty, el_list_new, el_list_len, el_list_get,
* el_list_append, el_list_clone
* Map: el_map_new, el_map_get, el_get_field, el_map_set
* Retain/RC: el_retain, el_release
* Arena: el_arena_push, el_arena_pop
* JSON: json_get_string, json_get_int, json_get_float, json_get_bool,
* json_get_raw, json_find_key (static), json_skip_value (static)
* Process: exit_program, env, el_runtime_init_args
* Stubs: All remaining el_runtime.h symbols as no-op / return-0 stubs
* so the linker is satisfied even if the app doesn't call them.
*
* el_request_start / el_request_end are provided as empty no-ops (no HTTP
* server, no per-request arena needed for a native GUI app).
*
* Compile:
* x86_64-w64-mingw32-gcc -std=c11 -DEL_TARGET_WIN32 -I<runtime> \
* -c el_runtime_win32.c -o el_runtime_win32.o
*/
#include "el_runtime.h"
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
/* ── Arena (single-threaded; no pthread needed) ─────────────────────────── */
#define EL_ARENA_INITIAL 512
typedef struct {
char** ptrs;
size_t count;
size_t cap;
} ElArena;
static ElArena _arena = {NULL, 0, 0};
static int _arena_active = 0;
static void el_arena_track(char* p) {
if (!_arena_active || !p) return;
if (_arena.count >= _arena.cap) {
size_t nc = _arena.cap == 0 ? EL_ARENA_INITIAL : _arena.cap * 2;
char** g = realloc(_arena.ptrs, nc * sizeof(char*));
if (!g) return;
_arena.ptrs = g;
_arena.cap = nc;
}
_arena.ptrs[_arena.count++] = p;
}
void el_request_start(void) { _arena.count = 0; _arena_active = 1; }
void el_request_end(void) {
_arena_active = 0;
for (size_t i = 0; i < _arena.count; i++) free(_arena.ptrs[i]);
_arena.count = 0;
}
#define EL_ARENA_SCOPE_DEPTH 32
static size_t _arena_scope[EL_ARENA_SCOPE_DEPTH];
static int _arena_scope_depth = 0;
el_val_t el_arena_push(void) {
if (!_arena_active) _arena_active = 1;
if (_arena_scope_depth < EL_ARENA_SCOPE_DEPTH)
_arena_scope[_arena_scope_depth++] = _arena.count;
return (el_val_t)(int64_t)_arena.count;
}
el_val_t el_arena_pop(el_val_t mark) {
size_t save = (size_t)(int64_t)mark;
if (save > _arena.count) save = 0;
for (size_t i = save; i < _arena.count; i++) {
if (_arena.ptrs[i]) { free(_arena.ptrs[i]); _arena.ptrs[i] = NULL; }
}
_arena.count = save;
if (_arena_scope_depth > 0) _arena_scope_depth--;
if (save == 0) _arena_active = 0;
return 0;
}
/* ── Allocator helpers ───────────────────────────────────────────────────── */
static char* el_strdup(const char* s) {
if (!s) { char* p = strdup(""); el_arena_track(p); return p; }
char* p = strdup(s);
el_arena_track(p);
return p;
}
static char* el_strbuf(size_t n) {
char* p = malloc(n + 1);
if (!p) { fputs("el_runtime_win32: out of memory\n", stderr); exit(1); }
p[0] = '\0';
el_arena_track(p);
return p;
}
static el_val_t el_wrap_str(char* s) {
return EL_STR(s);
}
/* ── I/O ─────────────────────────────────────────────────────────────────── */
el_val_t println(el_val_t s) {
const char* str = EL_CSTR(s);
puts(str ? str : "");
return 0;
}
el_val_t print(el_val_t s) {
const char* str = EL_CSTR(s);
if (str) fputs(str, stdout);
return 0;
}
el_val_t readline(void) {
char buf[4096];
if (!fgets(buf, sizeof(buf), stdin)) return el_wrap_str(el_strdup(""));
size_t len = strlen(buf);
if (len > 0 && buf[len - 1] == '\n') buf[len - 1] = '\0';
return el_wrap_str(el_strdup(buf));
}
/* ── String builtins ─────────────────────────────────────────────────────── */
el_val_t el_str_concat(el_val_t av, el_val_t bv) {
const char* a = EL_CSTR(av);
const char* b = EL_CSTR(bv);
if (!a) a = "";
if (!b) b = "";
size_t la = strlen(a), lb = strlen(b);
char* out = el_strbuf(la + lb);
memcpy(out, a, la);
memcpy(out + la, b, lb);
out[la + lb] = '\0';
return el_wrap_str(out);
}
el_val_t str_eq(el_val_t av, el_val_t bv) {
const char* a = EL_CSTR(av);
const char* b = EL_CSTR(bv);
if (!a || !b) return (el_val_t)(a == b);
return (el_val_t)(strcmp(a, b) == 0);
}
el_val_t str_starts_with(el_val_t sv, el_val_t prefv) {
const char* s = EL_CSTR(sv);
const char* p = EL_CSTR(prefv);
if (!s || !p) return 0;
return (el_val_t)(strncmp(s, p, strlen(p)) == 0);
}
el_val_t str_ends_with(el_val_t sv, el_val_t sufv) {
const char* s = EL_CSTR(sv);
const char* suf = EL_CSTR(sufv);
if (!s || !suf) return 0;
size_t ls = strlen(s), lsuf = strlen(suf);
if (lsuf > ls) return 0;
return (el_val_t)(strcmp(s + ls - lsuf, suf) == 0);
}
el_val_t str_len(el_val_t sv) {
const char* s = EL_CSTR(sv);
return s ? (el_val_t)strlen(s) : 0;
}
el_val_t str_concat(el_val_t a, el_val_t b) {
return el_str_concat(a, b);
}
el_val_t int_to_str(el_val_t n) {
char buf[32];
snprintf(buf, sizeof(buf), "%lld", (long long)n);
return el_wrap_str(el_strdup(buf));
}
el_val_t str_to_int(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return 0;
return (el_val_t)atoll(s);
}
el_val_t native_str_to_int(el_val_t sv) { return str_to_int(sv); }
el_val_t str_slice(el_val_t sv, el_val_t start, el_val_t end) {
const char* s = EL_CSTR(sv);
if (!s) return el_wrap_str(el_strdup(""));
int64_t len = (int64_t)strlen(s);
if (start < 0) start = 0;
if (end > len) end = len;
if (start >= end) return el_wrap_str(el_strdup(""));
int64_t sz = end - start;
char* out = el_strbuf((size_t)sz);
memcpy(out, s + start, (size_t)sz);
out[sz] = '\0';
return el_wrap_str(out);
}
el_val_t str_contains(el_val_t sv, el_val_t subv) {
const char* s = EL_CSTR(sv);
const char* sub = EL_CSTR(subv);
if (!s || !sub) return 0;
return (el_val_t)(strstr(s, sub) != NULL);
}
el_val_t str_replace(el_val_t sv, el_val_t fromv, el_val_t tov) {
const char* s = EL_CSTR(sv);
const char* from = EL_CSTR(fromv);
const char* to = EL_CSTR(tov);
if (!s || !from || !to) return el_wrap_str(el_strdup(s ? s : ""));
size_t ls = strlen(s), lf = strlen(from), lt = strlen(to);
if (lf == 0) return el_wrap_str(el_strdup(s));
/* Count occurrences */
size_t count = 0;
const char* p = s;
while ((p = strstr(p, from)) != NULL) { count++; p += lf; }
size_t new_len = ls + count * (lt > lf ? lt - lf : 0) - count * (lf > lt ? lf - lt : 0);
char* out = el_strbuf(new_len);
const char* src = s;
char* dst = out;
while ((p = strstr(src, from)) != NULL) {
size_t pre = (size_t)(p - src);
memcpy(dst, src, pre); dst += pre;
memcpy(dst, to, lt); dst += lt;
src = p + lf;
}
strcpy(dst, src);
return el_wrap_str(out);
}
el_val_t str_to_upper(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return el_wrap_str(el_strdup(""));
size_t n = strlen(s);
char* out = el_strbuf(n);
for (size_t i = 0; i < n; i++) out[i] = (char)toupper((unsigned char)s[i]);
out[n] = '\0';
return el_wrap_str(out);
}
el_val_t str_to_lower(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return el_wrap_str(el_strdup(""));
size_t n = strlen(s);
char* out = el_strbuf(n);
for (size_t i = 0; i < n; i++) out[i] = (char)tolower((unsigned char)s[i]);
out[n] = '\0';
return el_wrap_str(out);
}
el_val_t str_upper(el_val_t sv) { return str_to_upper(sv); }
el_val_t str_lower(el_val_t sv) { return str_to_lower(sv); }
el_val_t str_trim(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return el_wrap_str(el_strdup(""));
while (*s && isspace((unsigned char)*s)) s++;
size_t n = strlen(s);
while (n > 0 && isspace((unsigned char)s[n - 1])) n--;
char* out = el_strbuf(n);
memcpy(out, s, n);
out[n] = '\0';
return el_wrap_str(out);
}
el_val_t str_index_of(el_val_t sv, el_val_t subv) {
const char* s = EL_CSTR(sv);
const char* sub = EL_CSTR(subv);
if (!s || !sub) return -1;
const char* p = strstr(s, sub);
return p ? (el_val_t)(p - s) : -1;
}
el_val_t str_char_at(el_val_t sv, el_val_t i) {
const char* s = EL_CSTR(sv);
if (!s) return 0;
int64_t idx = (int64_t)i;
int64_t len = (int64_t)strlen(s);
if (idx < 0 || idx >= len) return 0;
char buf[2] = { s[idx], '\0' };
return el_wrap_str(el_strdup(buf));
}
el_val_t str_char_code(el_val_t sv, el_val_t i) {
const char* s = EL_CSTR(sv);
if (!s) return 0;
int64_t idx = (int64_t)i;
int64_t len = (int64_t)strlen(s);
if (idx < 0 || idx >= len) return 0;
return (el_val_t)(unsigned char)s[idx];
}
el_val_t str_pad_left(el_val_t sv, el_val_t widthv, el_val_t padv) {
const char* s = EL_CSTR(sv);
const char* pad = EL_CSTR(padv);
if (!s) s = "";
if (!pad || !*pad) pad = " ";
int64_t width = (int64_t)widthv;
int64_t slen = (int64_t)strlen(s);
if (slen >= width) return el_wrap_str(el_strdup(s));
int64_t need = width - slen;
char* out = el_strbuf((size_t)width);
size_t plen = strlen(pad);
for (int64_t i = 0; i < need; i++) out[i] = pad[i % plen];
memcpy(out + need, s, (size_t)slen);
out[width] = '\0';
return el_wrap_str(out);
}
el_val_t str_pad_right(el_val_t sv, el_val_t widthv, el_val_t padv) {
const char* s = EL_CSTR(sv);
const char* pad = EL_CSTR(padv);
if (!s) s = "";
if (!pad || !*pad) pad = " ";
int64_t width = (int64_t)widthv;
int64_t slen = (int64_t)strlen(s);
if (slen >= width) return el_wrap_str(el_strdup(s));
int64_t need = width - slen;
char* out = el_strbuf((size_t)width);
memcpy(out, s, (size_t)slen);
size_t plen = strlen(pad);
for (int64_t i = 0; i < need; i++) out[slen + i] = pad[i % plen];
out[width] = '\0';
return el_wrap_str(out);
}
el_val_t str_format(el_val_t fmtv, el_val_t datav) {
/* Minimal stub — just return the format string unchanged. */
return fmtv;
}
el_val_t str_split(el_val_t sv, el_val_t sepv) {
/* Return empty list stub. */
return el_list_empty();
}
el_val_t str_count(el_val_t sv, el_val_t subv) {
const char* s = EL_CSTR(sv);
const char* sub = EL_CSTR(subv);
if (!s || !sub || !*sub) return 0;
size_t lsub = strlen(sub);
int64_t cnt = 0;
const char* p = s;
while ((p = strstr(p, sub)) != NULL) { cnt++; p += lsub; }
return (el_val_t)cnt;
}
/* ── Math ────────────────────────────────────────────────────────────────── */
el_val_t el_abs(el_val_t n) { return n < 0 ? -n : n; }
el_val_t el_max(el_val_t a, el_val_t b) { return a > b ? a : b; }
el_val_t el_min(el_val_t a, el_val_t b) { return a < b ? a : b; }
el_val_t int_to_float(el_val_t n) { return el_from_float((double)(int64_t)n); }
el_val_t float_to_int(el_val_t f) { return (el_val_t)(int64_t)el_to_float(f); }
el_val_t float_to_str(el_val_t f) {
char buf[64];
snprintf(buf, sizeof(buf), "%g", el_to_float(f));
return el_wrap_str(el_strdup(buf));
}
el_val_t str_to_float(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return 0;
return el_from_float(strtod(s, NULL));
}
el_val_t format_float(el_val_t f, el_val_t decimals) {
char buf[128];
int d = (int)(int64_t)decimals;
if (d < 0) d = 0; if (d > 30) d = 30;
snprintf(buf, sizeof(buf), "%.*f", d, el_to_float(f));
return el_wrap_str(el_strdup(buf));
}
el_val_t decimal_round(el_val_t f, el_val_t decimals) { return format_float(f, decimals); }
el_val_t math_sqrt(el_val_t f) { return el_from_float(sqrt(el_to_float(f))); }
el_val_t math_log(el_val_t f) { return el_from_float(log10(el_to_float(f))); }
el_val_t math_ln(el_val_t f) { return el_from_float(log(el_to_float(f))); }
el_val_t math_sin(el_val_t f) { return el_from_float(sin(el_to_float(f))); }
el_val_t math_cos(el_val_t f) { return el_from_float(cos(el_to_float(f))); }
el_val_t math_pi(void) { return el_from_float(3.14159265358979323846); }
/* ── Refcounted heap objects ─────────────────────────────────────────────── */
#define EL_MAGIC_LIST 0xE15710A1u
#define EL_MAGIC_MAP 0xE19A704Bu
typedef struct { uint32_t magic; uint32_t refcount; } ElHeader;
typedef struct {
ElHeader hdr;
int64_t length;
int64_t capacity;
el_val_t* elems;
} ElList;
typedef struct {
ElHeader hdr;
int64_t count;
int64_t capacity;
el_val_t* keys;
el_val_t* values;
} ElMap;
static int looks_like_heap_obj(el_val_t v) {
if (v == 0) return 0;
int64_t s = (int64_t)v;
if (s > -0x10000 && s < 0x10000) return 0;
uintptr_t p = (uintptr_t)v;
if (p < 0x10000) return 0;
if (p & 0x7) return 0;
return 1;
}
void el_retain(el_val_t v) {
if (!looks_like_heap_obj(v)) return;
ElHeader* h = (ElHeader*)(uintptr_t)v;
if (h->magic == EL_MAGIC_LIST || h->magic == EL_MAGIC_MAP) h->refcount++;
}
void el_release(el_val_t v) {
if (!looks_like_heap_obj(v)) return;
ElHeader* h = (ElHeader*)(uintptr_t)v;
if (h->magic == EL_MAGIC_LIST) {
if (h->refcount > 0 && --h->refcount == 0) {
ElList* l = (ElList*)h;
free(l->elems); h->magic = 0; free(l);
}
} else if (h->magic == EL_MAGIC_MAP) {
if (h->refcount > 0 && --h->refcount == 0) {
ElMap* m = (ElMap*)h;
free(m->keys); free(m->values); h->magic = 0; free(m);
}
}
}
/* ── List ────────────────────────────────────────────────────────────────── */
static ElList* list_alloc(int64_t cap) {
if (cap < 4) cap = 4;
ElList* lst = malloc(sizeof(ElList));
if (!lst) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
lst->hdr.magic = EL_MAGIC_LIST;
lst->hdr.refcount = 1;
lst->length = 0;
lst->capacity = cap;
lst->elems = malloc((size_t)cap * sizeof(el_val_t));
if (!lst->elems) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
return lst;
}
el_val_t el_list_empty(void) { return EL_STR(list_alloc(4)); }
el_val_t el_list_new(el_val_t count, ...) {
ElList* lst = list_alloc(count > 0 ? count : 4);
va_list ap; va_start(ap, count);
for (int64_t i = 0; i < count; i++) lst->elems[i] = va_arg(ap, el_val_t);
va_end(ap);
lst->length = count;
return EL_STR(lst);
}
el_val_t el_list_len(el_val_t lv) {
ElList* l = (ElList*)(uintptr_t)lv;
return l ? l->length : 0;
}
el_val_t el_list_get(el_val_t lv, el_val_t idx) {
ElList* l = (ElList*)(uintptr_t)lv;
if (!l || idx < 0 || idx >= l->length) return 0;
return l->elems[idx];
}
el_val_t el_list_append(el_val_t lv, el_val_t elem) {
ElList* old = (ElList*)(uintptr_t)lv;
if (!old) {
ElList* fresh = list_alloc(4);
fresh->elems[0] = elem;
fresh->length = 1;
return EL_STR(fresh);
}
if (old->hdr.refcount <= 1) {
if (old->length >= old->capacity) {
int64_t nc = old->capacity > 0 ? old->capacity * 2 : 4;
el_val_t* g = realloc(old->elems, (size_t)nc * sizeof(el_val_t));
if (!g) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
old->elems = g;
old->capacity = nc;
}
old->elems[old->length++] = elem;
return lv;
}
int64_t nc = old->length + 1;
if (nc < 4) nc = 4;
ElList* fresh = malloc(sizeof(ElList));
if (!fresh) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
fresh->hdr.magic = EL_MAGIC_LIST;
fresh->hdr.refcount = 1;
fresh->length = old->length + 1;
fresh->capacity = nc;
fresh->elems = malloc((size_t)nc * sizeof(el_val_t));
if (!fresh->elems) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
if (old->length > 0)
memcpy(fresh->elems, old->elems, (size_t)old->length * sizeof(el_val_t));
fresh->elems[old->length] = elem;
return EL_STR(fresh);
}
el_val_t el_list_clone(el_val_t lv) {
ElList* old = (ElList*)(uintptr_t)lv;
if (!old) return el_list_empty();
ElList* fresh = list_alloc(old->capacity > 0 ? old->capacity : 4);
if (old->length > 0)
memcpy(fresh->elems, old->elems, (size_t)old->length * sizeof(el_val_t));
fresh->length = old->length;
return EL_STR(fresh);
}
/* ── Map ─────────────────────────────────────────────────────────────────── */
static ElMap* map_alloc(int64_t cap) {
if (cap < 4) cap = 4;
ElMap* m = malloc(sizeof(ElMap));
if (!m) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
m->hdr.magic = EL_MAGIC_MAP;
m->hdr.refcount = 1;
m->count = 0;
m->capacity = cap;
m->keys = malloc((size_t)cap * sizeof(el_val_t));
m->values = malloc((size_t)cap * sizeof(el_val_t));
if (!m->keys || !m->values) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
return m;
}
el_val_t el_map_new(el_val_t pair_count, ...) {
ElMap* m = map_alloc(pair_count > 0 ? pair_count : 4);
va_list ap; va_start(ap, pair_count);
for (int64_t i = 0; i < pair_count; i++) {
m->keys[i] = va_arg(ap, el_val_t);
m->values[i] = va_arg(ap, el_val_t);
}
va_end(ap);
m->count = pair_count;
return EL_STR(m);
}
el_val_t el_map_get(el_val_t mv, el_val_t kv) {
ElMap* m = (ElMap*)(uintptr_t)mv;
const char* key = EL_CSTR(kv);
if (!m || !key) return 0;
for (int64_t i = 0; i < m->count; i++) {
const char* k = EL_CSTR(m->keys[i]);
if (k && strcmp(k, key) == 0) return m->values[i];
}
return 0;
}
el_val_t el_get_field(el_val_t mv, el_val_t kv) { return el_map_get(mv, kv); }
el_val_t el_map_set(el_val_t mv, el_val_t kv, el_val_t value) {
ElMap* m = (ElMap*)(uintptr_t)mv;
if (!m) {
ElMap* fresh = map_alloc(4);
fresh->keys[0] = kv; fresh->values[0] = value; fresh->count = 1;
return EL_STR(fresh);
}
const char* key = EL_CSTR(kv);
if (key) {
for (int64_t i = 0; i < m->count; i++) {
const char* k = EL_CSTR(m->keys[i]);
if (k && strcmp(k, key) == 0) { m->values[i] = value; return mv; }
}
}
if (m->count >= m->capacity) {
int64_t nc = m->capacity > 0 ? m->capacity * 2 : 4;
el_val_t* gk = realloc(m->keys, (size_t)nc * sizeof(el_val_t));
el_val_t* gv = realloc(m->values, (size_t)nc * sizeof(el_val_t));
if (!gk || !gv) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
m->keys = gk; m->values = gv; m->capacity = nc;
}
m->keys[m->count] = kv; m->values[m->count] = value; m->count++;
return mv;
}
/* ── JSON helpers ────────────────────────────────────────────────────────── */
typedef struct {
const char* p;
const char* end;
int err;
} JsonParser;
static void jp_skip_ws(JsonParser* jp) {
while (jp->p < jp->end) {
char c = *jp->p;
if (c == ' ' || c == '\t' || c == '\n' || c == '\r') jp->p++;
else break;
}
}
static char* jp_parse_string_raw(JsonParser* jp) {
if (jp->p >= jp->end || *jp->p != '"') { jp->err = 1; return el_strdup(""); }
jp->p++;
size_t cap = 32, len = 0;
char* out = malloc(cap);
if (!out) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
while (jp->p < jp->end && *jp->p != '"') {
char c = *jp->p++;
if (c == '\\' && jp->p < jp->end) {
char esc = *jp->p++;
switch (esc) {
case '"': c = '"'; break;
case '\\': c = '\\'; break;
case '/': c = '/'; break;
case 'b': c = '\b'; break;
case 'f': c = '\f'; break;
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 't': c = '\t'; break;
case 'u':
for (int i = 0; i < 4 && jp->p < jp->end; i++) jp->p++;
c = '?';
break;
default: c = esc; break;
}
}
if (len + 1 >= cap) {
cap *= 2;
out = realloc(out, cap);
if (!out) { fputs("el_runtime_win32: OOM\n", stderr); exit(1); }
}
out[len++] = c;
}
if (jp->p < jp->end && *jp->p == '"') jp->p++;
else jp->err = 1;
out[len] = '\0';
return out;
}
static const char* json_skip_value(const char* p) {
if (!p || !*p) return p;
while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++;
if (*p == '"') {
p++;
int e = 0;
while (*p) {
if (e) { e = 0; p++; continue; }
if (*p == '\\') { e = 1; p++; continue; }
if (*p == '"') { p++; break; }
p++;
}
return p;
}
if (*p == '{' || *p == '[') {
char open = *p, close = (open == '{') ? '}' : ']';
int depth = 0, in_str = 0, e = 0;
while (*p) {
char c = *p;
if (in_str) {
if (e) e = 0;
else if (c == '\\') e = 1;
else if (c == '"') in_str = 0;
p++; continue;
}
if (c == '"') { in_str = 1; p++; continue; }
if (c == open) depth++;
else if (c == close) { depth--; p++; if (!depth) return p; continue; }
p++;
}
return p;
}
while (*p && *p != ',' && *p != '}' && *p != ']' &&
*p != ' ' && *p != '\t' && *p != '\n' && *p != '\r') p++;
return p;
}
static const char* json_find_key(const char* s, const char* key) {
if (!s || !key) return NULL;
size_t klen = strlen(key);
int depth = 0, in_str = 0, escape = 0;
const char* p = s;
while (*p) {
char c = *p;
if (in_str) {
if (escape) escape = 0;
else if (c == '\\') escape = 1;
else if (c == '"') {
p++; in_str = 0; continue;
}
p++; continue;
}
if (c == '"') {
const char* str_start = p + 1;
const char* q = str_start;
int e = 0;
while (*q) {
if (e) { e = 0; q++; continue; }
if (*q == '\\') { e = 1; q++; continue; }
if (*q == '"') break;
q++;
}
size_t slen = (size_t)(q - str_start);
const char* after = (*q == '"') ? q + 1 : q;
if (depth == 1 && slen == klen && strncmp(str_start, key, klen) == 0) {
const char* r = after;
while (*r == ' ' || *r == '\t' || *r == '\n' || *r == '\r') r++;
if (*r == ':') {
r++;
while (*r == ' ' || *r == '\t' || *r == '\n' || *r == '\r') r++;
return r;
}
}
p = after; continue;
}
if (c == '{' || c == '[') depth++;
else if (c == '}' || c == ']') depth--;
p++;
}
return NULL;
}
el_val_t json_get_string(el_val_t json_str, el_val_t key) {
const char* json = EL_CSTR(json_str);
const char* k = EL_CSTR(key);
const char* p = json_find_key(json, k);
if (!p || *p != '"') return el_wrap_str(el_strdup(""));
JsonParser jp = { p, json + (json ? strlen(json) : 0), 0 };
char* parsed = jp_parse_string_raw(&jp);
if (jp.err) { free(parsed); return el_wrap_str(el_strdup("")); }
return el_wrap_str(parsed);
}
el_val_t json_get_int(el_val_t json_str, el_val_t key) {
const char* json = EL_CSTR(json_str);
const char* k = EL_CSTR(key);
const char* p = json_find_key(json, k);
if (!p || *p == '"' || *p == '{' || *p == '[') return 0;
return (el_val_t)strtoll(p, NULL, 10);
}
el_val_t json_get_float(el_val_t json_str, el_val_t key) {
const char* json = EL_CSTR(json_str);
const char* k = EL_CSTR(key);
const char* p = json_find_key(json, k);
if (!p || *p == '"' || *p == '{' || *p == '[') return 0;
return el_from_float(strtod(p, NULL));
}
el_val_t json_get_bool(el_val_t json_str, el_val_t key) {
const char* json = EL_CSTR(json_str);
const char* k = EL_CSTR(key);
const char* p = json_find_key(json, k);
if (!p) return 0;
return (el_val_t)(strncmp(p, "true", 4) == 0);
}
el_val_t json_get_raw(el_val_t json_str, el_val_t key) {
const char* json = EL_CSTR(json_str);
const char* k = EL_CSTR(key);
const char* p = json_find_key(json, k);
if (!p) return el_wrap_str(el_strdup(""));
const char* end = json_skip_value(p);
size_t n = (size_t)(end - p);
char* out = el_strbuf(n);
memcpy(out, p, n);
out[n] = '\0';
return el_wrap_str(out);
}
el_val_t json_get(el_val_t json, el_val_t key) {
return json_get_raw(json, key);
}
/* Simple JSON number / scalar parser helpers for json_parse / json_stringify */
el_val_t json_parse(el_val_t s) {
/* Minimal: return the string verbatim (caller accesses via json_get_*). */
return s;
}
el_val_t json_stringify(el_val_t v) {
/* Basic: if it already looks like a string, return it. */
const char* s = EL_CSTR(v);
return s ? v : EL_STR("{}");
}
el_val_t json_set(el_val_t json_str, el_val_t key, el_val_t value) {
/* Stub: returns the original JSON unchanged. */
return json_str;
}
el_val_t json_array_len(el_val_t json_str) {
const char* s = EL_CSTR(json_str);
if (!s || *s != '[') return 0;
int64_t cnt = 0;
int depth = 0, in_str = 0, e = 0;
const char* p = s;
while (*p) {
char c = *p;
if (in_str) {
if (e) e = 0; else if (c == '\\') e = 1; else if (c == '"') in_str = 0;
p++; continue;
}
if (c == '"') { in_str = 1; p++; continue; }
if (c == '[' || c == '{') { if (depth++ == 0 && c == '[') { p++; continue; } }
else if (c == ']' || c == '}') { if (--depth == 0) break; }
else if (c == ',' && depth == 1) cnt++;
p++;
}
/* If we saw any content, count = separators + 1 */
if (depth == 0) { /* empty or done */ }
/* Simpler: count commas at depth 1 + 1 if non-empty */
/* Re-scan for simplicity */
cnt = 0;
depth = 0; in_str = 0; e = 0;
p = s;
int has_content = 0;
while (*p) {
char c = *p;
if (in_str) {
if (e) e = 0; else if (c == '\\') e = 1; else if (c == '"') in_str = 0;
p++; continue;
}
if (c == '"') { in_str = 1; p++; continue; }
if (c == '[' || c == '{') depth++;
else if (c == ']' || c == '}') {
depth--;
if (depth == 0) break;
}
if (depth == 1) {
if (c != '[' && c != ' ' && c != '\t' && c != '\n' && c != '\r') has_content = 1;
if (c == ',') cnt++;
}
p++;
}
return has_content ? cnt + 1 : 0;
}
el_val_t json_array_get(el_val_t json_str, el_val_t index) {
const char* s = EL_CSTR(json_str);
if (!s || *s != '[') return 0;
int64_t target = (int64_t)index;
int64_t cur = 0;
int depth = 0, in_str = 0, e = 0;
const char* p = s;
while (*p) {
char c = *p;
if (in_str) {
if (e) e = 0; else if (c == '\\') e = 1; else if (c == '"') in_str = 0;
p++; continue;
}
if (c == '"') { in_str = 1; }
if (c == '[' || c == '{') depth++;
else if (c == ']' || c == '}') { if (--depth == 0) break; }
if (depth == 1 && (p == s + 1 || c == ',')) {
if (c == ',') { cur++; p++; while (*p == ' ' || *p == '\t' || *p == '\n') p++; }
else { p++; while (*p == ' ' || *p == '\t' || *p == '\n') p++; }
if (cur == target) {
const char* end = json_skip_value(p);
size_t n = (size_t)(end - p);
char* out = el_strbuf(n);
memcpy(out, p, n); out[n] = '\0';
return el_wrap_str(out);
}
continue;
}
p++;
}
return 0;
}
el_val_t json_array_get_string(el_val_t json_str, el_val_t index) {
el_val_t raw = json_array_get(json_str, index);
if (!raw) return el_wrap_str(el_strdup(""));
const char* s = EL_CSTR(raw);
if (!s || *s != '"') return raw;
JsonParser jp = { s, s + strlen(s), 0 };
char* parsed = jp_parse_string_raw(&jp);
return el_wrap_str(parsed);
}
el_val_t json_escape_string(el_val_t sv) {
const char* s = EL_CSTR(sv);
if (!s) return el_wrap_str(el_strdup("\"\""));
size_t n = strlen(s);
char* out = el_strbuf(n * 6 + 4);
char* p = out;
*p++ = '"';
for (size_t i = 0; i < n; i++) {
unsigned char c = (unsigned char)s[i];
switch (c) {
case '"': *p++ = '\\'; *p++ = '"'; break;
case '\\': *p++ = '\\'; *p++ = '\\'; break;
case '\n': *p++ = '\\'; *p++ = 'n'; break;
case '\r': *p++ = '\\'; *p++ = 'r'; break;
case '\t': *p++ = '\\'; *p++ = 't'; break;
default:
if (c < 0x20) {
p += sprintf(p, "\\u%04x", c);
} else {
*p++ = (char)c;
}
}
}
*p++ = '"'; *p = '\0';
return el_wrap_str(out);
}
el_val_t json_build_object(el_val_t kvs) { return kvs; }
el_val_t json_build_array(el_val_t items) { return items; }
/* ── Environment / process ───────────────────────────────────────────────── */
el_val_t env(el_val_t key) {
const char* k = EL_CSTR(key);
if (!k) return el_wrap_str(el_strdup(""));
const char* v = getenv(k);
return el_wrap_str(el_strdup(v ? v : ""));
}
el_val_t exit_program(el_val_t code) {
exit((int)(int64_t)code);
return 0;
}
/* Args store — populated by el_runtime_init_args */
static el_val_t _el_args_list = 0;
void el_runtime_init_args(int argc, char** argv) {
_el_args_list = el_list_empty();
for (int i = 1; i < argc; i++) {
_el_args_list = el_list_append(_el_args_list, EL_STR(argv[i]));
}
}
el_val_t args(void) {
if (!_el_args_list) _el_args_list = el_list_empty();
return _el_args_list;
}
/* ── HTML helpers (stubs) ────────────────────────────────────────────────── */
el_val_t el_html_sanitize(el_val_t input_html, el_val_t allowlist_json) { return input_html; }
el_val_t html_raw(el_val_t s) { return s; }
el_val_t html_escape(el_val_t s) { return s; }
el_val_t url_encode(el_val_t s) { return s; }
el_val_t url_decode(el_val_t s) { return s; }
/* ── Filesystem stubs ────────────────────────────────────────────────────── */
el_val_t fs_read(el_val_t path) {
const char* p = EL_CSTR(path);
if (!p) return el_wrap_str(el_strdup(""));
FILE* f = fopen(p, "rb");
if (!f) return el_wrap_str(el_strdup(""));
fseek(f, 0, SEEK_END);
long sz = ftell(f);
rewind(f);
if (sz <= 0) { fclose(f); return el_wrap_str(el_strdup("")); }
char* buf = malloc((size_t)sz + 1);
if (!buf) { fclose(f); return el_wrap_str(el_strdup("")); }
size_t got = fread(buf, 1, (size_t)sz, f);
buf[got] = '\0';
fclose(f);
el_arena_track(buf);
return EL_STR(buf);
}
el_val_t fs_write(el_val_t path, el_val_t content) {
const char* p = EL_CSTR(path);
const char* c = EL_CSTR(content);
if (!p || !c) return 0;
FILE* f = fopen(p, "wb");
if (!f) return 0;
fputs(c, f);
fclose(f);
return 1;
}
el_val_t fs_exists(el_val_t path) {
const char* p = EL_CSTR(path);
if (!p) return 0;
FILE* f = fopen(p, "rb");
if (!f) return 0;
fclose(f);
return 1;
}
el_val_t fs_list(el_val_t path) { return el_wrap_str(el_strdup("")); }
el_val_t fs_list_json(el_val_t path) { return el_wrap_str(el_strdup("[]")); }
el_val_t fs_mkdir(el_val_t path) { return 0; }
el_val_t fs_write_bytes(el_val_t path, el_val_t bytes, el_val_t n) { return 0; }
/* ── HTTP stubs (no network in Win32 GUI app) ────────────────────────────── */
el_val_t http_get(el_val_t url) { return el_wrap_str(el_strdup("{\"error\":\"no http\"}")); }
el_val_t http_post(el_val_t url, el_val_t body) { return http_get(url); }
el_val_t http_post_json(el_val_t url, el_val_t body) { return http_get(url); }
el_val_t http_get_with_headers(el_val_t url, el_val_t h) { return http_get(url); }
el_val_t http_post_with_headers(el_val_t url, el_val_t b, el_val_t h) { return http_get(url); }
el_val_t http_post_json_with_headers(el_val_t url, el_val_t h, el_val_t b) { return http_get(url); }
el_val_t http_post_form_auth(el_val_t url, el_val_t b, el_val_t a) { return http_get(url); }
el_val_t http_delete(el_val_t url) { return http_get(url); }
el_val_t http_serve(el_val_t port, el_val_t handler) { return 0; }
el_val_t http_set_handler(el_val_t name) { return 0; }
el_val_t http_serve_v2(el_val_t port, el_val_t handler) { return 0; }
el_val_t http_set_handler_v2(el_val_t name) { return 0; }
el_val_t http_response(el_val_t status, el_val_t headers_json, el_val_t body) { return body; }
void el_seed_set_http_conn_fd(int fd) { (void)fd; }
el_val_t http_post_to_file(el_val_t url, el_val_t b, el_val_t h, el_val_t out) { return 0; }
el_val_t http_get_to_file(el_val_t url, el_val_t h, el_val_t out) { return 0; }
/* ── Time stubs ──────────────────────────────────────────────────────────── */
#include <time.h>
el_val_t time_now(void) { return (el_val_t)time(NULL); }
el_val_t time_now_utc(void) { return time_now(); }
el_val_t now_ns(void) { return (el_val_t)(time(NULL) * (int64_t)1000000000LL); }
el_val_t el_now_instant(void) { return now_ns(); }
el_val_t now(void) { return el_now_instant(); }
el_val_t unix_seconds(el_val_t n) { return n * 1000000000LL; }
el_val_t unix_millis(el_val_t n) { return n * 1000000LL; }
el_val_t unix_timestamp(void) { return (el_val_t)time(NULL); }
el_val_t sleep_secs(el_val_t secs) { return 0; }
el_val_t sleep_ms(el_val_t ms) { return 0; }
el_val_t el_sleep_duration(el_val_t dur) { return 0; }
el_val_t time_format(el_val_t ts, el_val_t fmt) { return el_wrap_str(el_strdup("")); }
el_val_t time_to_parts(el_val_t ts) { return el_wrap_str(el_strdup("{}")); }
el_val_t time_from_parts(el_val_t s, el_val_t ns, el_val_t tz) { return s; }
el_val_t time_add(el_val_t ts, el_val_t n, el_val_t unit) { return ts; }
el_val_t time_diff(el_val_t a, el_val_t b, el_val_t unit) { return a - b; }
el_val_t instant_from_iso8601(el_val_t s) { return 0; }
el_val_t el_duration_from_nanos(el_val_t ns) { return ns; }
el_val_t duration_seconds(el_val_t n) { return n * 1000000000LL; }
el_val_t duration_millis(el_val_t n) { return n * 1000000LL; }
el_val_t duration_nanos(el_val_t n) { return n; }
el_val_t el_instant_add_dur(el_val_t i, el_val_t d) { return i + d; }
el_val_t el_instant_sub_dur(el_val_t i, el_val_t d) { return i - d; }
el_val_t el_instant_diff(el_val_t a, el_val_t b) { return a - b; }
el_val_t el_duration_add(el_val_t a, el_val_t b) { return a + b; }
el_val_t el_duration_sub(el_val_t a, el_val_t b) { return a - b; }
el_val_t el_duration_scale(el_val_t d, el_val_t s) { return d * s; }
el_val_t el_duration_div(el_val_t d, el_val_t s) { return s ? d / s : 0; }
el_val_t el_instant_lt(el_val_t a, el_val_t b) { return a < b; }
el_val_t el_instant_le(el_val_t a, el_val_t b) { return a <= b; }
el_val_t el_instant_gt(el_val_t a, el_val_t b) { return a > b; }
el_val_t el_instant_ge(el_val_t a, el_val_t b) { return a >= b; }
el_val_t el_instant_eq(el_val_t a, el_val_t b) { return a == b; }
el_val_t el_instant_ne(el_val_t a, el_val_t b) { return a != b; }
el_val_t el_duration_lt(el_val_t a, el_val_t b) { return a < b; }
el_val_t el_duration_le(el_val_t a, el_val_t b) { return a <= b; }
el_val_t el_duration_gt(el_val_t a, el_val_t b) { return a > b; }
el_val_t el_duration_ge(el_val_t a, el_val_t b) { return a >= b; }
el_val_t el_duration_eq(el_val_t a, el_val_t b) { return a == b; }
el_val_t el_duration_ne(el_val_t a, el_val_t b) { return a != b; }
el_val_t instant_to_unix_seconds(el_val_t i) { return i / 1000000000LL; }
el_val_t instant_to_unix_millis(el_val_t i) { return i / 1000000LL; }
el_val_t instant_to_iso8601(el_val_t i) { return el_wrap_str(el_strdup("")); }
el_val_t duration_to_seconds(el_val_t d) { return d / 1000000000LL; }
el_val_t duration_to_millis(el_val_t d) { return d / 1000000LL; }
el_val_t duration_to_nanos(el_val_t d) { return d; }
/* ── Calendar stubs ──────────────────────────────────────────────────────── */
el_val_t zone(el_val_t id) { return id; }
el_val_t zone_utc(void) { return EL_STR("UTC"); }
el_val_t zone_local(void) { return EL_STR("local"); }
el_val_t zone_offset(el_val_t h, el_val_t m) { return 0; }
el_val_t earth_calendar(el_val_t z) { return 0; }
el_val_t earth_calendar_default(void) { return 0; }
el_val_t mars_calendar(void) { return 0; }
el_val_t cycle_calendar(el_val_t p) { return 0; }
el_val_t no_cycle_calendar(void) { return 0; }
el_val_t relative_calendar(el_val_t e) { return 0; }
el_val_t now_in(el_val_t cal) { return 0; }
el_val_t in_calendar(el_val_t inst, el_val_t cal) { return 0; }
el_val_t cal_format(el_val_t ct, el_val_t pattern) { return el_wrap_str(el_strdup("")); }
el_val_t cal_to_instant(el_val_t ct) { return 0; }
el_val_t cal_cycle_phase(el_val_t ct) { return 0; }
el_val_t cal_in(el_val_t ct, el_val_t cal) { return 0; }
el_val_t local_date(el_val_t y, el_val_t m, el_val_t d) { return 0; }
el_val_t local_time(el_val_t h, el_val_t m, el_val_t s, el_val_t ns) { return 0; }
el_val_t local_datetime(el_val_t date, el_val_t time) { return 0; }
el_val_t zoned(el_val_t date, el_val_t time, el_val_t cal) { return 0; }
el_val_t local_date_year(el_val_t ld) { return 0; }
el_val_t local_date_month(el_val_t ld) { return 0; }
el_val_t local_date_day(el_val_t ld) { return 0; }
el_val_t local_time_hour(el_val_t lt) { return 0; }
el_val_t local_time_minute(el_val_t lt) { return 0; }
el_val_t local_time_second(el_val_t lt) { return 0; }
el_val_t local_time_nanos(el_val_t lt) { return 0; }
el_val_t el_local_date_add_dur(el_val_t ld, el_val_t dur) { return ld; }
el_val_t el_local_time_add_dur(el_val_t lt, el_val_t dur) { return lt; }
el_val_t el_local_date_lt(el_val_t a, el_val_t b) { return a < b; }
el_val_t el_local_date_eq(el_val_t a, el_val_t b) { return a == b; }
el_val_t rhythm_cycle_start(void) { return 0; }
el_val_t rhythm_cycle_phase(el_val_t p) { return 0; }
el_val_t rhythm_duration(el_val_t d) { return 0; }
el_val_t rhythm_session_start(void) { return 0; }
el_val_t rhythm_event(el_val_t name) { return 0; }
el_val_t rhythm_and(el_val_t a, el_val_t b) { return 0; }
el_val_t rhythm_or(el_val_t a, el_val_t b) { return 0; }
el_val_t rhythm_weekday(el_val_t day) { return 0; }
el_val_t rhythm_weekly_at(el_val_t day, el_val_t h, el_val_t m) { return 0; }
el_val_t rhythm_next_after(el_val_t r, el_val_t after, el_val_t cal) { return 0; }
el_val_t rhythm_matches(el_val_t r, el_val_t ct) { return 0; }
/* ── UUID stubs ──────────────────────────────────────────────────────────── */
el_val_t uuid_new(void) { return el_wrap_str(el_strdup("00000000-0000-0000-0000-000000000000")); }
el_val_t uuid_v4(void) { return uuid_new(); }
/* ── State K/V stubs ─────────────────────────────────────────────────────── */
el_val_t state_set(el_val_t key, el_val_t value) { return value; }
el_val_t state_get(el_val_t key) { return 0; }
el_val_t state_del(el_val_t key) { return 0; }
el_val_t state_keys(void) { return el_wrap_str(el_strdup("[]")); }
el_val_t state_has(el_val_t key) { return 0; }
el_val_t state_get_or(el_val_t key, el_val_t def) { return def; }
/* ── TTL cache stubs ─────────────────────────────────────────────────────── */
el_val_t ttl_cache_set(el_val_t key, el_val_t value) { return value; }
el_val_t ttl_cache_get(el_val_t key, el_val_t max_age) { return 0; }
el_val_t ttl_cache_age(el_val_t key) { return -1; }
Reference in New Issue View Git Blame Copy Permalink