teptris 0.2.37-aarch64-linux → 0.2.39-aarch64-linux

data/ext/teptris_ext/engine/src/teptris/common/ryu/s2d.c

@@ -0,0 +1,259 @@
+// Copyright 2019 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+#include "ryu_parse.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef RYU_DEBUG
+#include <inttypes.h>
+#include <stdio.h>
+#endif
+
+#include "common.h"
+#include "d2s_intrinsics.h"
+
+#if defined(RYU_OPTIMIZE_SIZE)
+#include "d2s_small_table.h"
+#else
+#include "d2s_full_table.h"
+#endif
+
+#define DOUBLE_MANTISSA_BITS 52
+#define DOUBLE_EXPONENT_BITS 11
+#define DOUBLE_EXPONENT_BIAS 1023
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+
+static inline uint32_t floor_log2(const uint64_t value) {
+  long index;
+  return _BitScanReverse64(&index, value) ? index : 64;
+}
+
+#else
+
+static inline uint32_t floor_log2(const uint64_t value) {
+  return 63 - __builtin_clzll(value);
+}
+
+#endif
+
+// The max function is already defined on Windows.
+static inline int32_t max32(int32_t a, int32_t b) {
+  return a < b ? b : a;
+}
+
+static inline double int64Bits2Double(uint64_t bits) {
+  double f;
+  memcpy(&f, &bits, sizeof(double));
+  return f;
+}
+
+enum teptris_ryu_status teptris_ryu_s2d_n(const char * buffer, const int len, double * result) {
+  if (len == 0) {
+    return TEPTRIS_RYU_INPUT_TOO_SHORT;
+  }
+  int m10digits = 0;
+  int e10digits = 0;
+  int dotIndex = len;
+  int eIndex = len;
+  uint64_t m10 = 0;
+  int32_t e10 = 0;
+  bool signedM = false;
+  bool signedE = false;
+  int i = 0;
+  if (buffer[i] == '-') {
+    signedM = true;
+    i++;
+  }
+  for (; i < len; i++) {
+    char c = buffer[i];
+    if (c == '.') {
+      if (dotIndex != len) {
+        return TEPTRIS_RYU_MALFORMED_INPUT;
+      }
+      dotIndex = i;
+      continue;
+    }
+    if ((c < '0') || (c > '9')) {
+      break;
+    }
+    if (m10digits >= 17) {
+      return TEPTRIS_RYU_INPUT_TOO_LONG;
+    }
+    m10 = 10 * m10 + (c - '0');
+    if (m10 != 0) {
+      m10digits++;
+    }
+  }
+  if (i < len && ((buffer[i] == 'e') || (buffer[i] == 'E'))) {
+    eIndex = i;
+    i++;
+    if (i < len && ((buffer[i] == '-') || (buffer[i] == '+'))) {
+      signedE = buffer[i] == '-';
+      i++;
+    }
+    for (; i < len; i++) {
+      char c = buffer[i];
+      if ((c < '0') || (c > '9')) {
+        return TEPTRIS_RYU_MALFORMED_INPUT;
+      }
+      if (e10digits > 3) {
+        // TODO: Be more lenient. Return +/-Infinity or +/-0 instead.
+        return TEPTRIS_RYU_INPUT_TOO_LONG;
+      }
+      e10 = 10 * e10 + (c - '0');
+      if (e10 != 0) {
+        e10digits++;
+      }
+    }
+  }
+  if (i < len) {
+    return TEPTRIS_RYU_MALFORMED_INPUT;
+  }
+  if (signedE) {
+    e10 = -e10;
+  }
+  e10 -= dotIndex < eIndex ? eIndex - dotIndex - 1 : 0;
+  if (m10 == 0) {
+    *result = signedM ? -0.0 : 0.0;
+    return TEPTRIS_RYU_SUCCESS;
+  }
+
+#ifdef RYU_DEBUG
+  printf("Input=%s\n", buffer);
+  printf("m10digits = %d\n", m10digits);
+  printf("e10digits = %d\n", e10digits);
+  printf("m10 * 10^e10 = %" PRIu64 " * 10^%d\n", m10, e10);
+#endif
+
+  if ((m10digits + e10 <= -324) || (m10 == 0)) {
+    // Number is less than 1e-324, which should be rounded down to 0; return +/-0.0.
+    uint64_t ieee = ((uint64_t) signedM) << (DOUBLE_EXPONENT_BITS + DOUBLE_MANTISSA_BITS);
+    *result = int64Bits2Double(ieee);
+    return TEPTRIS_RYU_SUCCESS;
+  }
+  if (m10digits + e10 >= 310) {
+    // Number is larger than 1e+309, which should be rounded to +/-Infinity.
+    uint64_t ieee = (((uint64_t) signedM) << (DOUBLE_EXPONENT_BITS + DOUBLE_MANTISSA_BITS)) | (0x7ffull << DOUBLE_MANTISSA_BITS);
+    *result = int64Bits2Double(ieee);
+    return TEPTRIS_RYU_SUCCESS;
+  }
+
+  // Convert to binary float m2 * 2^e2, while retaining information about whether the conversion
+  // was exact (trailingZeros).
+  int32_t e2;
+  uint64_t m2;
+  bool trailingZeros;
+  if (e10 >= 0) {
+    // The length of m * 10^e in bits is:
+    //   log2(m10 * 10^e10) = log2(m10) + e10 log2(10) = log2(m10) + e10 + e10 * log2(5)
+    //
+    // We want to compute the DOUBLE_MANTISSA_BITS + 1 top-most bits (+1 for the implicit leading
+    // one in IEEE format). We therefore choose a binary output exponent of
+    //   log2(m10 * 10^e10) - (DOUBLE_MANTISSA_BITS + 1).
+    //
+    // We use floor(log2(5^e10)) so that we get at least this many bits; better to
+    // have an additional bit than to not have enough bits.
+    e2 = floor_log2(m10) + e10 + log2pow5(e10) - (DOUBLE_MANTISSA_BITS + 1);
+
+    // We now compute [m10 * 10^e10 / 2^e2] = [m10 * 5^e10 / 2^(e2-e10)].
+    // To that end, we use the DOUBLE_POW5_SPLIT table.
+    int j = e2 - e10 - ceil_log2pow5(e10) + DOUBLE_POW5_BITCOUNT;
+    assert(j >= 0);
+#if defined(RYU_OPTIMIZE_SIZE)
+    uint64_t pow5[2];
+    double_computePow5(e10, pow5);
+    m2 = mulShift64(m10, pow5, j);
+#else
+    assert(e10 < DOUBLE_POW5_TABLE_SIZE);
+    m2 = mulShift64(m10, DOUBLE_POW5_SPLIT[e10], j);
+#endif
+    // We also compute if the result is exact, i.e.,
+    //   [m10 * 10^e10 / 2^e2] == m10 * 10^e10 / 2^e2.
+    // This can only be the case if 2^e2 divides m10 * 10^e10, which in turn requires that the
+    // largest power of 2 that divides m10 + e10 is greater than e2. If e2 is less than e10, then
+    // the result must be exact. Otherwise we use the existing multipleOfPowerOf2 function.
+    trailingZeros = e2 < e10 || (e2 - e10 < 64 && multipleOfPowerOf2(m10, e2 - e10));
+  } else {
+    e2 = floor_log2(m10) + e10 - ceil_log2pow5(-e10) - (DOUBLE_MANTISSA_BITS + 1);
+    int j = e2 - e10 + ceil_log2pow5(-e10) - 1 + DOUBLE_POW5_INV_BITCOUNT;
+#if defined(RYU_OPTIMIZE_SIZE)
+    uint64_t pow5[2];
+    double_computeInvPow5(-e10, pow5);
+    m2 = mulShift64(m10, pow5, j);
+#else
+    assert(-e10 < DOUBLE_POW5_INV_TABLE_SIZE);
+    m2 = mulShift64(m10, DOUBLE_POW5_INV_SPLIT[-e10], j);
+#endif
+    trailingZeros = multipleOfPowerOf5(m10, -e10);
+  }
+
+#ifdef RYU_DEBUG
+  printf("m2 * 2^e2 = %" PRIu64 " * 2^%d\n", m2, e2);
+#endif
+
+  // Compute the final IEEE exponent.
+  uint32_t ieee_e2 = (uint32_t) max32(0, e2 + DOUBLE_EXPONENT_BIAS + floor_log2(m2));
+
+  if (ieee_e2 > 0x7fe) {
+    // Final IEEE exponent is larger than the maximum representable; return +/-Infinity.
+    uint64_t ieee = (((uint64_t) signedM) << (DOUBLE_EXPONENT_BITS + DOUBLE_MANTISSA_BITS)) | (0x7ffull << DOUBLE_MANTISSA_BITS);
+    *result = int64Bits2Double(ieee);
+    return TEPTRIS_RYU_SUCCESS;
+  }
+
+  // We need to figure out how much we need to shift m2. The tricky part is that we need to take
+  // the final IEEE exponent into account, so we need to reverse the bias and also special-case
+  // the value 0.
+  int32_t shift = (ieee_e2 == 0 ? 1 : ieee_e2) - e2 - DOUBLE_EXPONENT_BIAS - DOUBLE_MANTISSA_BITS;
+  assert(shift >= 0);
+#ifdef RYU_DEBUG
+  printf("ieee_e2 = %d\n", ieee_e2);
+  printf("shift = %d\n", shift);
+#endif
+  
+  // We need to round up if the exact value is more than 0.5 above the value we computed. That's
+  // equivalent to checking if the last removed bit was 1 and either the value was not just
+  // trailing zeros or the result would otherwise be odd.
+  //
+  // We need to update trailingZeros given that we have the exact output exponent ieee_e2 now.
+  trailingZeros &= (m2 & ((1ull << (shift - 1)) - 1)) == 0;
+  uint64_t lastRemovedBit = (m2 >> (shift - 1)) & 1;
+  bool roundUp = (lastRemovedBit != 0) && (!trailingZeros || (((m2 >> shift) & 1) != 0));
+
+#ifdef RYU_DEBUG
+  printf("roundUp = %d\n", roundUp);
+  printf("ieee_m2 = %" PRIu64 "\n", (m2 >> shift) + roundUp);
+#endif
+  uint64_t ieee_m2 = (m2 >> shift) + roundUp;
+  assert(ieee_m2 <= (1ull << (DOUBLE_MANTISSA_BITS + 1)));
+  ieee_m2 &= (1ull << DOUBLE_MANTISSA_BITS) - 1;
+  if (ieee_m2 == 0 && roundUp) {
+    // Due to how the IEEE represents +/-Infinity, we don't need to check for overflow here.
+    ieee_e2++;
+  }
+  
+  uint64_t ieee = (((((uint64_t) signedM) << DOUBLE_EXPONENT_BITS) | (uint64_t)ieee_e2) << DOUBLE_MANTISSA_BITS) | ieee_m2;
+  *result = int64Bits2Double(ieee);
+  return TEPTRIS_RYU_SUCCESS;
+}

data/ext/teptris_ext/engine/src/teptris/common/simd.h

@@ -0,0 +1,119 @@
+/* common/simd.h — length-guarded SIMD scan kernels (leptris lineage).
+ *
+ * Techniques ported from libleptris's simd_text framework:
+ * - vceqq/_mm_cmpeq + horizontal-nonzero early exit (find)
+ * - widen-then-add population counts (vpaddlq_u16/vaddvq_u16; the raw
+ *   byte add would truncate mod 256 at density >= 2)
+ * - NEON movemask emulation: narrow mask >> 7, widen, shift each lane
+ *   by its own index (vector shift), horizontal add — weights sum to
+ *   the exact bitmask because every bit appears exactly once
+ * - chunk only while a full vector remains; scalar tail; never read
+ *   past len
+ *
+ * ISA selection is baseline-only (NEON is architectural on aarch64,
+ * SSE2 on x86-64), so no runtime dispatch and no extra compile flags.
+ * Kernels return the first matching OFFSET, or len when nothing
+ * matched — callers test against len, never -1. */
+#ifndef TEPTRIS_COMMON_SIMD_H
+#define TEPTRIS_COMMON_SIMD_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+static inline unsigned tep_ctz32(unsigned x)
+{
+    unsigned long i;
+    _BitScanForward(&i, x);
+    return (unsigned)i;
+}
+#else
+static inline unsigned tep_ctz32(unsigned x) { return (unsigned)__builtin_ctz(x); }
+#endif
+
+#if defined(__aarch64__)
+#define TEPTRIS_SIMD_NEON 1
+#include <arm_neon.h>
+#elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64)
+#define TEPTRIS_SIMD_SSE2 1
+#include <emmintrin.h>
+#endif
+
+/* NEON: 16-bit mask from a byte-compare vector (leptris trick). */
+
+
+/* String-content stop scan: first offset where p[i] is q or e (either
+ * may be 0 to disable) or a control byte (c < 0x20, tab allowed) or
+ * 0x7F. len when absent. This is the combined terminator/validation
+ * scan for basic and literal strings and for comment bodies — one
+ * vector pass replaces per-byte quote/backslash/control checks. */
+static inline size_t tep_simd_str_stop(const char *p, size_t len, char q,
+                                       char e)
+{
+    size_t i = 0;
+#if defined(TEPTRIS_SIMD_NEON)
+    const uint8x16_t kq = vdupq_n_u8((uint8_t)q);
+    const uint8x16_t ke = vdupq_n_u8((uint8_t)e);
+    const uint8x16_t tab = vdupq_n_u8('\t');
+    const uint8x16_t lo = vdupq_n_u8(0x20);
+    const uint8x16_t del = vdupq_n_u8(0x7F);
+    for (; len - i >= 16; i += 16) {
+        uint8x16_t v = vld1q_u8((const uint8_t *)(p + i));
+        uint8x16_t ctrl = vandq_u8(vcltq_u8(v, lo), vmvnq_u8(vceqq_u8(v, tab)));
+        uint8x16_t m = vorrq_u8(ctrl, vceqq_u8(v, del));
+        if (q != 0) {
+            m = vorrq_u8(m, vceqq_u8(v, kq));
+        }
+        if (e != 0) {
+            m = vorrq_u8(m, vceqq_u8(v, ke));
+        }
+        if (vmaxvq_u8(m) != 0) {
+            uint8_t bytes[16];
+            vst1q_u8(bytes, m);
+            for (int k = 0; k < 16; k++) {
+                if (bytes[k]) {
+                    return i + (size_t)k;
+                }
+            }
+        }
+    }
+#elif defined(TEPTRIS_SIMD_SSE2)
+    const __m128i zero = _mm_setzero_si128();
+    const __m128i kq = _mm_set1_epi8(q);
+    const __m128i ke = _mm_set1_epi8(e);
+    const __m128i sp = _mm_set1_epi8(' ');
+    const __m128i tab = _mm_set1_epi8('\t');
+    const __m128i k20 = _mm_set1_epi8(0x20);
+    const __m128i del = _mm_set1_epi8((char)0x7F);
+    for (; len - i >= 16; i += 16) {
+        __m128i v = _mm_loadu_si128((const __m128i *)(p + i));
+        __m128i below = _mm_cmpeq_epi8(_mm_subs_epu8(v, k20), zero); /* c<=0x20 */
+        __m128i ctrl = _mm_andnot_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(v, sp), _mm_cmpeq_epi8(v, tab)), below);
+        __m128i m = _mm_or_si128(ctrl, _mm_cmpeq_epi8(v, del));
+        if (q != 0) {
+            m = _mm_or_si128(m, _mm_cmpeq_epi8(v, kq));
+        }
+        if (e != 0) {
+            m = _mm_or_si128(m, _mm_cmpeq_epi8(v, ke));
+        }
+        unsigned mask = (unsigned)_mm_movemask_epi8(m);
+        if (mask != 0) {
+            return i + tep_ctz32(mask);
+        }
+    }
+#endif
+    for (; i < len; i++) {
+        unsigned char c = (unsigned char)p[i];
+        if (c == q || c == e || (c < 0x20 && c != '\t') || c == 0x7F) {
+            return i;
+        }
+    }
+    return len;
+}
+
+#endif /* TEPTRIS_COMMON_SIMD_H */

data/ext/teptris_ext/engine/src/teptris/dom/dom.c

@@ -0,0 +1,192 @@
+#include "teptris/dom/dom.h"
+
+#include <string.h>
+
+#include "teptris/memory/arena.h"
+
+uint64_t teptris_dom_key_hash(const char *key, size_t key_len)
+{
+    uint64_t h = 1469598103934665603ULL;
+    for (size_t i = 0; i < key_len; i++) {
+        h ^= (unsigned char)key[i];
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+teptris_node *teptris_dom_new_node(teptris_document *doc, teptris_kind kind)
+{
+    teptris_node *n = teptris_arena_fast_alloc(&doc->arena,
+                                               sizeof(teptris_node));
+    if (n == NULL) {
+        return NULL;
+    }
+    memset(n, 0, sizeof(*n));
+    n->kind = (uint8_t)kind;
+    return n;
+}
+
+teptris_node *teptris_dom_new_table(teptris_document *doc, uint8_t flags)
+{
+    teptris_node *n = teptris_dom_new_node(doc, TEPTRIS_TABLE);
+    if (n != NULL) {
+        n->flags = flags;
+    }
+    return n;
+}
+
+teptris_node *teptris_dom_new_array(teptris_document *doc, uint8_t flags)
+{
+    teptris_node *n = teptris_dom_new_node(doc, TEPTRIS_ARRAY);
+    if (n != NULL) {
+        n->flags = flags;
+    }
+    return n;
+}
+
+static void index_insert(teptris_node *t, uint32_t entry_idx, uint64_t h)
+{
+    size_t mask = t->as.table.idx_cap - 1;
+    size_t slot = (size_t)h & mask;
+    while (t->as.table.index[slot] != 0) {
+        slot = (slot + 1) & mask;
+    }
+    t->as.table.index[slot] = entry_idx + 1;
+}
+
+static teptris_status index_rebuild(teptris_document *doc, teptris_node *t,
+                                    size_t new_cap)
+{
+    uint32_t *idx = teptris_arena_alloc(&doc->arena, new_cap * sizeof(uint32_t));
+    if (idx == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    memset(idx, 0, new_cap * sizeof(uint32_t));
+    t->as.table.index = idx;
+    t->as.table.idx_cap = new_cap;
+    for (size_t i = 0; i < t->as.table.len; i++) {
+        index_insert(t, (uint32_t)i, t->as.table.entries[i].hash);
+    }
+    return TEPTRIS_OK;
+}
+
+teptris_entry *teptris_dom_table_find_h(const teptris_node *t, const char *key,
+                                        size_t key_len, uint64_t *hash_out)
+{
+    if (t == NULL || t->kind != TEPTRIS_TABLE || t->as.table.idx_cap == 0) {
+        *hash_out = teptris_dom_key_hash(key, key_len);
+        return NULL;
+    }
+    uint64_t h = teptris_dom_key_hash(key, key_len);
+    *hash_out = h;
+    size_t mask = t->as.table.idx_cap - 1;
+    size_t slot = (size_t)h & mask;
+    for (;;) {
+        uint32_t e = t->as.table.index[slot];
+        if (e == 0) {
+            return NULL;
+        }
+        teptris_entry *entry = &t->as.table.entries[e - 1];
+        if (entry->key.len == key_len &&
+            memcmp(entry->key.ptr, key, key_len) == 0) {
+            return entry;
+        }
+        slot = (slot + 1) & mask;
+    }
+}
+
+teptris_entry *teptris_dom_table_find(const teptris_node *t, const char *key,
+                                      size_t key_len)
+{
+    uint64_t h;
+    return teptris_dom_table_find_h(t, key, key_len, &h);
+}
+
+teptris_status teptris_dom_table_insert(teptris_document *doc, teptris_node *t,
+                                        teptris_view key, teptris_node *value)
+{
+    return teptris_dom_table_insert_h(doc, t, key,
+                                      teptris_dom_key_hash(key.ptr, key.len),
+                                      value);
+}
+
+teptris_status teptris_dom_table_insert_h(teptris_document *doc, teptris_node *t,
+                                         teptris_view key, uint64_t hash,
+                                         teptris_node *value)
+{
+    return teptris_dom_table_insert_slot(doc, t, key, hash, value, SIZE_MAX);
+}
+
+teptris_status teptris_dom_table_insert_slot(teptris_document *doc,
+                                             teptris_node *t,
+                                             teptris_view key, uint64_t hash,
+                                             teptris_node *value, size_t slot)
+{
+    teptris_arena *a = &doc->arena;
+
+    /* load factor FIRST: a rebuild re-probes every entry and any
+     * pre-resolved slot becomes stale */
+    if ((t->as.table.len + 1) * 10 >= t->as.table.idx_cap * 7) {
+        size_t ncap = t->as.table.idx_cap ? t->as.table.idx_cap * 2 : 16;
+        teptris_status st = index_rebuild(doc, t, ncap);
+        if (st != TEPTRIS_OK) {
+            return st;
+        }
+        slot = SIZE_MAX;
+    }
+
+    if (t->as.table.len == t->as.table.cap) {
+        size_t ncap = t->as.table.cap ? t->as.table.cap * 2 : 8;
+        teptris_entry *ne =
+            teptris_arena_try_grow(a, t->as.table.entries,
+                                   t->as.table.cap * sizeof(teptris_entry),
+                                   ncap * sizeof(teptris_entry));
+        if (ne == NULL) {
+            ne = teptris_arena_alloc(a, ncap * sizeof(teptris_entry));
+            if (ne == NULL) {
+                return TEPTRIS_ERR_ALLOC;
+            }
+            memcpy(ne, t->as.table.entries,
+                   t->as.table.len * sizeof(teptris_entry));
+            t->as.table.entries = ne;
+        }
+        t->as.table.cap = ncap;
+    }
+
+    t->as.table.entries[t->as.table.len].key = key;
+    t->as.table.entries[t->as.table.len].value = value;
+    t->as.table.entries[t->as.table.len].hash = hash;
+    if (slot != SIZE_MAX) {
+        t->as.table.index[slot] = (uint32_t)t->as.table.len + 1;
+    } else {
+        index_insert(t, (uint32_t)t->as.table.len, hash);
+    }
+    t->as.table.len++;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_dom_array_push(teptris_document *doc, teptris_node *a,
+                                      teptris_node *value)
+{
+    teptris_arena *ar = &doc->arena;
+
+    if (a->as.array.len == a->as.array.cap) {
+        size_t ncap = a->as.array.cap ? a->as.array.cap * 2 : 8;
+        teptris_node **ni =
+            teptris_arena_try_grow(ar, a->as.array.items,
+                                   a->as.array.cap * sizeof(teptris_node *),
+                                   ncap * sizeof(teptris_node *));
+        if (ni == NULL) {
+            ni = teptris_arena_alloc(ar, ncap * sizeof(teptris_node *));
+            if (ni == NULL) {
+                return TEPTRIS_ERR_ALLOC;
+            }
+            memcpy(ni, a->as.array.items,
+                   a->as.array.len * sizeof(teptris_node *));
+            a->as.array.items = ni;
+        }
+        a->as.array.cap = ncap;
+    }
+    a->as.array.items[a->as.array.len++] = value;
+    return TEPTRIS_OK;
+}

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

@@ -0,0 +1,124 @@
+#ifndef TEPTRIS_DOM_H
+#define TEPTRIS_DOM_H
+
+#include <stdint.h>
+#include <string.h>
+
+#include "teptris/memory/arena.h"
+#include "teptris/teptris.h"
+
+/* Table define-semantics flags (parser-only state, invisible to readers). */
+#define TBL_EXPLICIT 0x01u /* named by a [table] header (or root) */
+#define TBL_IMPLICIT 0x02u /* intermediate of a header path */
+#define TBL_DOTTED 0x04u   /* intermediate of a dotted key */
+#define TBL_INLINE 0x08u   /* inline table value: immutable */
+#define ARR_AOT 0x10u      /* array created by [[...]] headers */
+
+typedef struct teptris_entry {
+    teptris_view key;    /* view into the parse input */
+    teptris_node *value;
+    uint64_t hash;       /* cached: index rebuilds never re-hash keys */
+} teptris_entry;
+
+struct teptris_node {
+    uint8_t kind;
+    uint8_t flags;
+    union {
+        teptris_view str; /* NUL-terminated arena copy */
+        int64_t i;
+        double f;
+        bool b;
+        teptris_datetime dt;
+        struct {
+            teptris_entry *entries; /* insertion order */
+            size_t len, cap;
+            uint32_t *index; /* entry_idx+1; 0 = empty; linear probe */
+            size_t idx_cap;
+        } table;
+        struct {
+            struct teptris_node **items;
+            size_t len, cap;
+        } array;
+    } as;
+};
+
+/* C99/MSVC-C-mode/nd C++ portable static assert (negative array
+ * size on violation); _Static_assert would pin us to C11+ */
+#if defined(__cplusplus)
+#define TEP_SA(cond, name) static_assert(cond, #name)
+#else
+#define TEP_SA(cond, name) typedef char tep_sa_##name[(cond) ? 1 : -1]
+#endif
+TEP_SA(sizeof(teptris_node) <= 64, node_fits_64);
+
+struct teptris_document {
+    teptris_arena arena;
+    teptris_node *root;
+    teptris_error err;
+    char err_msg[192];
+    uint32_t max_depth;
+};
+
+/* Constructors (arena-owned, zeroed). Return NULL on allocation failure. */
+teptris_node *teptris_dom_new_node(teptris_document *doc, teptris_kind kind);
+teptris_node *teptris_dom_new_table(teptris_document *doc, uint8_t flags);
+teptris_node *teptris_dom_new_array(teptris_document *doc, uint8_t flags);
+
+/* Find by key (hash index); NULL when absent. */
+teptris_entry *teptris_dom_table_find(const teptris_node *table, const char *key,
+                                      size_t key_len);
+
+/* Single-hash variants: find also reports the key hash so a following
+ * insert does not rehash (the common insert-dotted/resolve flow). */
+uint64_t teptris_dom_key_hash(const char *key, size_t key_len);
+teptris_entry *teptris_dom_table_find_h(const teptris_node *table,
+                                        const char *key, size_t key_len,
+                                        uint64_t *hash_out);
+
+/* Probe with a PRECOMPUTED hash that also reports the empty index
+ * slot the walk stopped at, for reuse by insert_slot — one walk for
+ * the whole miss->insert sequence (header and keyval paths).
+ * *slot_out is SIZE_MAX when the slot cannot be reused (empty table,
+ * non-table). Must be header-inline: cross-TU, the call cost ate the
+ * measured gain last time. */
+static inline teptris_entry *
+teptris_dom_table_probe_slot(const teptris_node *t, uint64_t hash,
+                             const char *key, size_t key_len, size_t *slot_out)
+{
+    *slot_out = SIZE_MAX;
+    if (t == NULL || t->kind != TEPTRIS_TABLE || t->as.table.idx_cap == 0) {
+        return NULL;
+    }
+    size_t mask = t->as.table.idx_cap - 1;
+    size_t slot = (size_t)hash & mask;
+    while (t->as.table.index[slot] != 0) {
+        uint32_t ei = t->as.table.index[slot] - 1;
+        const teptris_entry *e = &t->as.table.entries[ei];
+        if (e->hash == hash && e->key.len == key_len &&
+            memcmp(e->key.ptr, key, key_len) == 0) {
+            return (teptris_entry *)e;
+        }
+        slot = (slot + 1) & mask;
+    }
+    *slot_out = slot;
+    return NULL;
+}
+
+/* Insert; the key must not already exist (caller checks). */
+teptris_status teptris_dom_table_insert(teptris_document *doc, teptris_node *table,
+                                        teptris_view key, teptris_node *value);
+teptris_status teptris_dom_table_insert_h(teptris_document *doc,
+                                          teptris_node *table, teptris_view key,
+                                          uint64_t hash, teptris_node *value);
+/* insert_h with the empty index slot pre-resolved by probe_slot
+ * (SIZE_MAX = unresolved). A load-factor rebuild invalidates the
+ * slot internally and falls back to a fresh probe. */
+teptris_status teptris_dom_table_insert_slot(teptris_document *doc,
+                                             teptris_node *table,
+                                             teptris_view key, uint64_t hash,
+                                             teptris_node *value, size_t slot);
+
+teptris_status teptris_dom_array_push(teptris_document *doc, teptris_node *array,
+                                      teptris_node *value);
+
+#endif /* TEPTRIS_DOM_H */