teptris 0.2.37-powerpc64le-linux → 0.2.39-powerpc64le-linux

data/ext/teptris_ext/engine/src/teptris/emit/emitter.h

@@ -0,0 +1,11 @@
+#ifndef TEPTRIS_EMITTER_H
+#define TEPTRIS_EMITTER_H
+
+#include "teptris/teptris.h"
+
+teptris_status teptris_emit_document(const teptris_document *doc, char **buf,
+                                     size_t *len);
+teptris_status teptris_emit_document_json(const teptris_document *doc,
+                                          char **buf, size_t *len);
+
+#endif /* TEPTRIS_EMITTER_H */

data/ext/teptris_ext/engine/src/teptris/memory/arena.c

@@ -0,0 +1,104 @@
+#include "teptris/memory/arena.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define TEPTRIS_ARENA_BLOCK_SIZE (64u * 1024u)
+#define TEPTRIS_ARENA_ALIGN 16u
+
+static size_t round_up(size_t n, size_t align)
+{
+    return (n + align - 1) & ~(align - 1);
+}
+
+/* Block header size rounded so the data area starts 16-byte aligned. */
+static size_t block_data_offset(void)
+{
+    return round_up(sizeof(teptris_arena_block), TEPTRIS_ARENA_ALIGN);
+}
+
+void teptris_arena_init(teptris_arena *arena)
+{
+    arena->head = NULL;
+}
+
+static teptris_arena_block *block_new(size_t cap)
+{
+    size_t data_off = block_data_offset();
+    teptris_arena_block *b = malloc(data_off + cap);
+    if (b == NULL) {
+        return NULL;
+    }
+    b->next = NULL;
+    b->used = 0;
+    b->cap = cap;
+    return b;
+}
+
+static char *block_data(teptris_arena_block *b)
+{
+    return (char *)b + block_data_offset();
+}
+
+void *teptris_arena_alloc(teptris_arena *arena, size_t size)
+{
+    size_t need = round_up(size, TEPTRIS_ARENA_ALIGN);
+    teptris_arena_block *b = arena->head;
+
+    if (b != NULL && b->used + need <= b->cap) {
+        void *p = block_data(b) + b->used;
+        b->used += need;
+        return p;
+    }
+
+    size_t cap = TEPTRIS_ARENA_BLOCK_SIZE;
+    if (need > cap) {
+        cap = need;
+    }
+    /* Geometric growth: fewer blocks means fewer malloc/free (and free's
+     * madvise) calls on large documents. */
+    if (arena->head != NULL && arena->head->cap * 2 > cap) {
+        cap = arena->head->cap * 2;
+    }
+    teptris_arena_block *nb = block_new(cap);
+    if (nb == NULL) {
+        return NULL;
+    }
+    nb->next = arena->head;
+    arena->head = nb;
+    void *p = block_data(nb) + nb->used;
+    nb->used += need;
+    return p;
+}
+
+void *teptris_arena_try_grow(teptris_arena *arena, void *last, size_t old_size,
+                             size_t new_size)
+{
+    teptris_arena_block *b = arena->head;
+    if (b == NULL || last == NULL) {
+        return NULL;
+    }
+    size_t old_rounded = round_up(old_size, TEPTRIS_ARENA_ALIGN);
+    size_t new_rounded = round_up(new_size, TEPTRIS_ARENA_ALIGN);
+    if (new_size < old_size) {
+        return NULL;
+    }
+    if ((char *)last + old_rounded == block_data(b) + b->used &&
+        b->used + (new_rounded - old_rounded) <= b->cap) {
+        b->used += new_rounded - old_rounded;
+        return last;
+    }
+    return NULL;
+}
+
+void teptris_arena_destroy(teptris_arena *arena)
+{
+    teptris_arena_block *b = arena->head;
+    while (b != NULL) {
+        teptris_arena_block *next = b->next;
+        free(b);
+        b = next;
+    }
+    arena->head = NULL;
+}

data/ext/teptris_ext/engine/src/teptris/memory/arena.h

@@ -0,0 +1,53 @@
+#ifndef TEPTRIS_ARENA_H
+#define TEPTRIS_ARENA_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Per-document bump arena: every allocation reachable from a document is
+ * carved from here and released in one pass at document free. */
+typedef struct teptris_arena_block {
+    struct teptris_arena_block *next;
+    size_t used;
+    size_t cap;
+    /* data follows, 16-byte aligned */
+} teptris_arena_block;
+
+typedef struct teptris_arena {
+    teptris_arena_block *head; /* most recently allocated block */
+} teptris_arena;
+
+void teptris_arena_init(teptris_arena *arena);
+void *teptris_arena_alloc(teptris_arena *arena, size_t size);
+
+/* Inline bump: the hot path (node/table-entry allocation) is three
+ * instructions when the head block has room; falls back to the
+ * out-of-line allocator for a new block. Must mirror arena.c's
+ * block_data offset exactly (header rounded to 16). */
+static inline void *teptris_arena_fast_alloc(teptris_arena *arena, size_t size)
+{
+    size_t need = (size + 15) & ~(size_t)15;
+    teptris_arena_block *b = arena->head;
+    if (b != NULL && b->used + need <= b->cap) {
+        char *base = (char *)b +
+                     ((sizeof(teptris_arena_block) + 15) & ~(size_t)15);
+        b->used += need;
+        return base + b->used - need;
+    }
+    return teptris_arena_alloc(arena, size);
+}
+/* Grow the most recent arena allocation in place when possible.
+ * Returns the (possibly moved) pointer, or NULL if `last` is not the
+ * tail — caller then allocates+copies itself. */
+void *teptris_arena_try_grow(teptris_arena *arena, void *last, size_t old_size,
+                             size_t new_size);
+void teptris_arena_destroy(teptris_arena *arena);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TEPTRIS_ARENA_H */

data/ext/teptris_ext/engine/src/teptris/parse/datetime.c

@@ -0,0 +1,218 @@
+#include <string.h>
+
+#include "teptris/common/chartype.h"
+#include "teptris/memory/arena.h"
+#include "teptris/parse/parse.h"
+
+static int d2(const char *p)
+{
+    return (p[0] - '0') * 10 + (p[1] - '0');
+}
+
+static int num4(const char *p)
+{
+    return d2(p) * 100 + d2(p + 2);
+}
+
+static bool is_dig(const char *p)
+{
+    return tep_is_dec((unsigned char)*p);
+}
+
+static int days_in_month(int y, int m)
+{
+    static const int d[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    if (m == 2) {
+        bool leap = (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
+        return leap ? 29 : 28;
+    }
+    return d[m - 1];
+}
+
+bool teptris_datetime_lookahead(const teptris_parser *ps)
+{
+    const char *p = ps->p;
+    size_t avail = (size_t)(ps->end - p);
+    /* Separator bytes first: every int/float value pays this check on
+     * its way to parse_number, and plain numbers fail both in two
+     * loads (p[4] is a digit or delimiter, never '-'; p[2] likewise
+     * never ':'). Digit verification only runs when a datetime shape
+     * is actually possible. */
+    if (avail >= 10 && p[4] == '-' && p[7] == '-' && is_dig(p) &&
+        is_dig(p + 1) && is_dig(p + 2) && is_dig(p + 3) && is_dig(p + 5) &&
+        is_dig(p + 6) && is_dig(p + 8) && is_dig(p + 9)) {
+        return true;
+    }
+    /* TOML 1.1: seconds are optional — HH:MM alone dispatches here
+     * (HH:MM:SS still matches: p[5] == ':'). */
+    if (avail >= 5 && p[2] == ':' && is_dig(p) && is_dig(p + 1) &&
+        is_dig(p + 3) && is_dig(p + 4)) {
+        return true;
+    }
+    return false;
+}
+
+static teptris_status finish_node(teptris_parser *ps, teptris_kind kind,
+                                  const teptris_datetime *dt, size_t total,
+                                  teptris_node **out)
+{
+    teptris_node *n = teptris_dom_new_node(ps->doc, kind);
+    if (n == NULL) {
+        return tep_fail_at(ps, NULL, TEPTRIS_ERR_ALLOC, "out of memory");
+    }
+    n->as.dt = *dt;
+    /* the consumed span is datetime grammar only — no newline can
+     * occur in it, so advance directly (skips tep_adv's memchr) */
+    ps->p += total;
+    *out = n;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_parse_datetime(teptris_parser *ps, teptris_node **out)
+{
+    const char *p = ps->p;
+    const char *end = ps->end;
+    const char *start = p;
+    teptris_datetime dt;
+    memset(&dt, 0, sizeof(dt));
+
+    if (p[4] == '-') {
+        int y = num4(p);
+        int mo = d2(p + 5);
+        int da = d2(p + 8);
+        if (mo < 1 || mo > 12) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid month");
+        }
+        if (da < 1 || da > days_in_month(y, mo)) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid day");
+        }
+        dt.year = (int32_t)y;
+        dt.month = (uint8_t)mo;
+        dt.day = (uint8_t)da;
+        p += 10;
+
+        bool has_time =
+            p < end && (*p == 'T' || *p == 't' || *p == ' ') &&
+            (size_t)(end - p) >= 6 && is_dig(p + 1) && is_dig(p + 2) &&
+            p[3] == ':' && is_dig(p + 4) && is_dig(p + 5);
+        if (!has_time) {
+            return finish_node(ps, TEPTRIS_DATE_LOCAL, &dt,
+                               (size_t)(p - start), out);
+        }
+        p++; /* separator */
+
+        int h = d2(p);
+        int mi = d2(p + 3);
+        int s = 0; /* TOML 1.1: seconds optional */
+        size_t consumed = 5;
+        if (p[5] == ':') {
+            if ((size_t)(end - p) < 8 || !is_dig(p + 6) || !is_dig(p + 7)) {
+                return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX,
+                                   "invalid second");
+            }
+            s = d2(p + 6);
+            consumed = 8;
+        }
+        if (h > 23) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid hour");
+        }
+        if (mi > 59) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid minute");
+        }
+        if (s > 60) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid second");
+        }
+        dt.hour = (uint8_t)h;
+        dt.minute = (uint8_t)mi;
+        dt.second = (uint8_t)s;
+        p += consumed;
+
+        if (p < end && *p == '.') {
+            p++;
+            if (p >= end || !is_dig(p)) {
+                return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX,
+                                   "expected fractional digits");
+            }
+            uint32_t scale = 100000000u; /* 9 digits */
+            uint32_t ns = 0;
+            while (p < end && is_dig(p)) {
+                if (scale > 0) {
+                    ns += (uint32_t)(*p - '0') * scale;
+                    scale /= 10;
+                }
+                p++; /* beyond 9 digits: validated, then truncated */
+            }
+            dt.nanosecond = ns;
+        }
+
+        if (p < end && (*p == 'Z' || *p == 'z')) {
+            dt.offset_seconds = 0;
+            p++;
+            return finish_node(ps, TEPTRIS_DATETIME_OFFSET, &dt,
+                               (size_t)(p - start), out);
+        }
+        if (p < end && (*p == '+' || *p == '-') &&
+            (size_t)(end - p) >= 6 && is_dig(p + 1) && is_dig(p + 2) &&
+            p[3] == ':' && is_dig(p + 4) && is_dig(p + 5)) {
+            int sign = (*p == '-') ? -1 : 1;
+            int oh = d2(p + 1);
+            int om = d2(p + 4);
+            if (oh > 23 || om > 59) {
+                return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX,
+                                   "invalid UTC offset");
+            }
+            dt.offset_seconds = sign * (oh * 3600 + om * 60);
+            p += 6;
+            return finish_node(ps, TEPTRIS_DATETIME_OFFSET, &dt,
+                               (size_t)(p - start), out);
+        }
+        return finish_node(ps, TEPTRIS_DATETIME_LOCAL, &dt,
+                           (size_t)(p - start), out);
+    }
+
+    /* time-only; TOML 1.1: seconds optional */
+    int h = d2(p);
+    int mi = d2(p + 3);
+    int s = 0;
+    size_t consumed = 5;
+    if ((size_t)(end - p) >= 8 && p[5] == ':') {
+        if (!is_dig(p + 6) || !is_dig(p + 7)) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid second");
+        }
+        s = d2(p + 6);
+        consumed = 8;
+    }
+    if (h > 23) {
+        return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid hour");
+    }
+    if (mi > 59) {
+        return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid minute");
+    }
+    if (s > 60) {
+        return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "invalid second");
+    }
+    dt.hour = (uint8_t)h;
+    dt.minute = (uint8_t)mi;
+    dt.second = (uint8_t)s;
+    p += consumed;
+
+    if (p < end && *p == '.') {
+        p++;
+        if (p >= end || !is_dig(p)) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX,
+                               "expected fractional digits");
+        }
+        uint32_t scale = 100000000u;
+        uint32_t ns = 0;
+        while (p < end && is_dig(p)) {
+            if (scale > 0) {
+                ns += (uint32_t)(*p - '0') * scale;
+                scale /= 10;
+            }
+            p++;
+        }
+        dt.nanosecond = ns;
+    }
+
+    return finish_node(ps, TEPTRIS_TIME_LOCAL, &dt, (size_t)(p - start), out);
+}

data/ext/teptris_ext/engine/src/teptris/parse/keys.c

@@ -0,0 +1,121 @@
+#include <string.h>
+
+#include "teptris/common/chartype.h"
+#include "teptris/memory/arena.h"
+#include "teptris/parse/parse.h"
+
+/* Quoted key: single-line basic or literal string, decoded to an
+ * arena-owned NUL-terminated view. Opening delimiter at the cursor. */
+static teptris_status quoted_key(teptris_parser *ps, teptris_view *out)
+{
+    bool basic = *ps->p == '"';
+    tep_adv(ps, 1);
+
+    const char *content;
+    size_t plen;
+    if (teptris_try_plain_body(ps, basic ? '"' : '\'', &content, &plen)) {
+        char *buf = teptris_arena_alloc(&ps->doc->arena, plen + 1);
+        if (buf == NULL) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_ALLOC, "out of memory");
+        }
+        memcpy(buf, content, plen);
+        buf[plen] = '\0';
+        tep_adv(ps, plen + 1);
+        out->ptr = buf;
+        out->len = plen;
+        return TEPTRIS_OK;
+    }
+
+    teptris_parser save = *ps;
+    size_t len = 0;
+    teptris_status st = basic ? tep_scan_basic(ps, false, NULL, &len)
+                              : tep_scan_literal(ps, false, NULL, &len);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    char *buf = teptris_arena_alloc(&ps->doc->arena, len + 1);
+    if (buf == NULL) {
+        return tep_fail_at(ps, NULL, TEPTRIS_ERR_ALLOC, "out of memory");
+    }
+    *ps = save;
+    st = basic ? tep_scan_basic(ps, false, buf, &len)
+               : tep_scan_literal(ps, false, buf, &len);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    buf[len] = '\0';
+    out->ptr = buf;
+    out->len = len;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_parse_key_path(teptris_parser *ps,
+                                      teptris_view *sbuf, size_t scap,
+                                      teptris_view **parts, size_t *count)
+{
+    teptris_arena *a = &ps->doc->arena;
+    teptris_view *v = sbuf;
+    size_t n = 0, cap = scap;
+
+    for (;;) {
+        teptris_status st = tep_skip_ws(ps);
+        if (st != TEPTRIS_OK) {
+            return st;
+        }
+        if (ps->p >= ps->end) {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX, "expected key");
+        }
+        unsigned char c = (unsigned char)*ps->p;
+
+        teptris_view key;
+        if (c == '"' || c == '\'') {
+            st = quoted_key(ps, &key);
+            if (st != TEPTRIS_OK) {
+                return st;
+            }
+        } else if (tep_is_barekey(c)) {
+            const char *start = ps->p;
+            while (ps->p < ps->end && tep_is_barekey((unsigned char)*ps->p)) {
+                ps->p++;
+            }
+            key.ptr = start;
+            key.len = (size_t)(ps->p - start);
+        } else {
+            return tep_fail_at(ps, NULL, TEPTRIS_ERR_SYNTAX,
+                               "expected key (bare or quoted)");
+        }
+
+        if (n == cap) {
+            size_t ncap = cap * 2;
+            teptris_view *nv = teptris_arena_try_grow(
+                a, v, cap * sizeof(teptris_view), ncap * sizeof(teptris_view));
+            if (nv == NULL) {
+                nv = teptris_arena_alloc(a, ncap * sizeof(teptris_view));
+                if (nv == NULL) {
+                    return tep_fail_at(ps, NULL, TEPTRIS_ERR_ALLOC,
+                                       "out of memory");
+                }
+                memcpy(nv, v, n * sizeof(teptris_view));
+                v = nv;
+            } else {
+                v = nv;
+            }
+            cap = ncap;
+        }
+        v[n++] = key;
+
+        st = tep_skip_ws(ps);
+        if (st != TEPTRIS_OK) {
+            return st;
+        }
+        if (ps->p < ps->end && *ps->p == '.') {
+            tep_adv(ps, 1);
+            continue;
+        }
+        break;
+    }
+
+    *parts = v;
+    *count = n;
+    return TEPTRIS_OK;
+}

data/ext/teptris_ext/engine/src/teptris/parse/parse.h

@@ -0,0 +1,76 @@
+#ifndef TEPTRIS_PARSE_H
+#define TEPTRIS_PARSE_H
+
+#include "teptris/dom/dom.h"
+#include "teptris/teptris.h"
+
+typedef struct teptris_parser {
+    teptris_document *doc;
+    const char *src;  /* input start (error position rescans) */
+    const char *p;    /* cursor */
+    const char *end;  /* one past last input byte */
+    uint32_t depth;
+    uint32_t max_depth;
+    teptris_node *cur; /* open table (root until the first header) */
+} teptris_parser;
+
+/* parser.c entry: validates UTF-8, skips BOM, runs the line loop. */
+teptris_status teptris_parser_run(teptris_document *doc, const char *data,
+                                  size_t len);
+
+/* Record a failure into doc->err at the current cursor (or `at` when
+ * non-NULL). Always returns `code` so callers `return tep_fail(...)`. */
+teptris_status tep_fail_at(teptris_parser *ps, const char *at, teptris_status code,
+                           const char *fmt, ...);
+
+/* Advance the cursor n bytes (clamped to the end). Position state
+ * (line/bol) is lazy: tep_fail_at computes it by rescan on error. */
+void tep_adv(teptris_parser *ps, size_t n);
+
+/* scalars.c: dispatch on the first byte; parses any value. */
+teptris_status teptris_parse_value(teptris_parser *ps, teptris_node **out);
+teptris_status teptris_parse_value_fast(teptris_parser *ps, teptris_node **out);
+/* Number (int/float/inf/nan); signed_input: cursor at '+'/'-'. */
+teptris_status teptris_parse_number(teptris_parser *ps, teptris_node **out,
+                                    bool signed_input);
+
+/* parser.c: composite values. */
+teptris_status teptris_parse_array(teptris_parser *ps, teptris_node **out);
+teptris_status teptris_parse_inline(teptris_parser *ps, teptris_node **out);
+
+/* Shared by keys.c for quoted keys. Decode a basic string body (opening
+ * quote(s) consumed by the caller) into `out` (NULL = count only). */
+teptris_status tep_scan_basic(teptris_parser *ps, bool multiline, char *out,
+                              size_t *out_len);
+teptris_status tep_scan_literal(teptris_parser *ps, bool multiline, char *out,
+                                size_t *out_len);
+
+/* scalars.c: fast path — lookahead for a single-line string body with no
+ * escapes and no control bytes (the common case). Does not move the
+ * cursor; on success the caller copies span→arena and advances len+1. */
+bool teptris_try_plain_body(teptris_parser *ps, char close, const char **content,
+                            size_t *len);
+
+/* keys.c: dotted key path. Parts are views (input or arena copies). */
+/* Parses a dotted key path. `sbuf`/`scap` is a CALLER-OWNED buffer
+ * (typically a stack array of 8): paths that fit never allocate, and
+ * *parts points into it or into the document arena — valid until the
+ * caller's frame ends or the document is freed. */
+teptris_status teptris_parse_key_path(teptris_parser *ps,
+                                      teptris_view *sbuf, size_t scap,
+                                      teptris_view **parts, size_t *count);
+
+/* datetime.c */
+bool teptris_datetime_lookahead(const teptris_parser *ps);
+teptris_status teptris_parse_datetime(teptris_parser *ps, teptris_node **out);
+
+/* parser.c: skip space/tab (parser loop) — arrays also allow newlines
+ * and comments. Both validate comment contents. */
+teptris_status tep_skip_ws(teptris_parser *ps);
+teptris_status tep_skip_ws_nl(teptris_parser *ps);
+/* True at cursor when at '\n', "\r\n" or EOF. */
+bool tep_at_eol(const teptris_parser *ps);
+/* Consume ws, optional comment, and the EOL; error when trailing bytes. */
+teptris_status tep_finish_line(teptris_parser *ps);
+
+#endif /* TEPTRIS_PARSE_H */