teptris 0.3.4.1-s390x-linux → 0.3.6.2-s390x-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03cd9e7bdb695508f312e4edd6397190a401b2f8ab9c7c05b3c411c34b893e28
-  data.tar.gz: 49885bbb6bf6309d6179d28f793a3ca9ce1c7514b9811d65053cd9d306ec7c9d
+  metadata.gz: a7714ffb960a86733d898e932b30917af0e2e0e51c0c9d58cf0652fc083848a7
+  data.tar.gz: 32c660f483f7378dfce7f4d65ba3736bb648e1daca90b7639bf33a8da6d117ac
 SHA512:
-  metadata.gz: 3ee103b168cf78fa154e59a50af08f968ee889aa8b7a5689a1d6449aaa00e383d04d26ac405ec286b7d27cde2c50520711ad9cc4582bd37ccd6aaab337194580
-  data.tar.gz: 8609e01790929da7ddba33d1980af442bceaa247d22072c82eaf59d1935f301320444b36de1011acff6486935da673036a8220acbb9746ff859982a6db8d3b69
+  metadata.gz: 134ec3a18604e62ce34458ccd14c697088b9d40705a75bc7ca7db65c84592f65b89c6b3de2653465352afeb84e608f40bc661a02acd9fdd1939ac6f42df25c43
+  data.tar.gz: 78d689a0a221722ebd9142a3eda1ba7d86fb8294eacd723ce6984f0eff6a18e1182275fe973e6cb3f79fc162687279c28f2f501319c434951d195cf2c36f81c4

data/ext/teptris_ext/engine/README.md

@@ -1,4 +1,4 @@
-# libteptris 0.3.4 — vendored source
+# libteptris 0.3.6 — vendored source
 
 This directory carries the COMPLETE C source of the engine this
 gem's extension was built from (the packaging doctrine: compiled

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

@@ -187,6 +187,23 @@ TEPTRIS_API const char * teptris_version_string(void);
  * kept alive). Duplicate keys are TEPTRIS_ERR_ARG.
  * Memory: the builder owns its document until teptris_builder_finish
  * transfers it; otherwise teptris_builder_free destroys it. */
+/* Streaming TOML writer: op-stream in (grammar in
+ * src/teptris/emit/writer.c), TOML text out - the fused dumps path
+ * for bindings that walk host objects. Caller contract: within each
+ * table, scalar values must be fed before nested tables/AOTs;
+ * violations are ERR_STATE (invalid TOML is never emitted).
+ * Memory: *buf from teptris_writer_finish is malloc'd; free it with
+ * free(). */
+typedef struct teptris_writer teptris_writer;
+
+TEPTRIS_API teptris_writer *teptris_writer_new(void);
+TEPTRIS_API void teptris_writer_free(teptris_writer *w);
+TEPTRIS_API teptris_status teptris_writer_feed(teptris_writer *w,
+                                               const uint8_t *ops,
+                                               size_t len);
+TEPTRIS_API teptris_status teptris_writer_finish(teptris_writer *w,
+                                                 char **buf, size_t *len);
+
 typedef struct teptris_builder teptris_builder;
 
 TEPTRIS_API teptris_builder *teptris_builder_new(void);

data/ext/teptris_ext/engine/src/include/teptris/version.h

@@ -4,6 +4,6 @@
 #define TEPTRIS_VERSION_MAJOR 0
 #define TEPTRIS_VERSION_MINOR 3
 #define TEPTRIS_VERSION_PATCH 0
-#define TEPTRIS_VERSION_STRING "0.3.4"
+#define TEPTRIS_VERSION_STRING "0.3.6"
 
 #endif /* TEPTRIS_VERSION_H */

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

@@ -0,0 +1,419 @@
+/* Shared emit layer: buffer + scalar/escape/key writers used by both
+ * the DOM emitters (emitter.c) and the streaming writer (writer.c).
+ * Static-in-header: each TU gets its own copy; these are small and
+ * monomorphic. */
+#ifndef TEPTRIS_EMIT_SHARED_H
+#define TEPTRIS_EMIT_SHARED_H
+
+#include <math.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "teptris/common/chartype.h"
+#include "teptris/common/ryu/ryu_d2s.h"
+#include "teptris/dom/dom.h"
+
+typedef struct {
+    char *p;
+    size_t len, cap;
+    teptris_status st;
+} ebuf;
+
+static inline void eb_reserve(ebuf *b, size_t extra)
+{
+    if (b->st != TEPTRIS_OK) {
+        return;
+    }
+    if (b->len + extra + 1 <= b->cap) {
+        return;
+    }
+    size_t ncap = b->cap ? b->cap : 256;
+    while (b->len + extra + 1 > ncap) {
+        ncap *= 2;
+    }
+    char *np = realloc(b->p, ncap);
+    if (np == NULL) {
+        free(b->p);
+        b->p = NULL;
+        b->st = TEPTRIS_ERR_ALLOC;
+        return;
+    }
+    b->p = np;
+    b->cap = ncap;
+}
+
+static inline void eb_put(ebuf *b, const char *s, size_t n)
+{
+    if (b->st != TEPTRIS_OK) {
+        return;
+    }
+    if (b->len + n + 1 <= b->cap) {
+        memcpy(b->p + b->len, s, n);
+        b->len += n;
+        return;
+    }
+    eb_reserve(b, n);
+    if (b->st != TEPTRIS_OK) {
+        return;
+    }
+    memcpy(b->p + b->len, s, n);
+    b->len += n;
+}
+
+static inline void eb_c(ebuf *b, char c)
+{
+    if (b->st == TEPTRIS_OK && b->len + 2 <= b->cap) {
+        b->p[b->len++] = c;
+        return;
+    }
+    eb_put(b, &c, 1);
+}
+
+/* ", " — the element/entry separator — as one direct 2-byte write;
+ * the densest loops pay it per element */
+static inline void eb_sep2(ebuf *b)
+{
+    if (b->st == TEPTRIS_OK && b->len + 3 <= b->cap) {
+        b->p[b->len] = ',';
+        b->p[b->len + 1] = ' ';
+        b->len += 2;
+        return;
+    }
+    eb_put(b, ", ", 2);
+}
+
+static inline void eb_str(ebuf *b, const char *s)
+{
+    eb_put(b, s, strlen(s));
+}
+
+/* ------------------------------------------------------------- scalars -- */
+
+/* direct writer, shared by both emit views: snprintf costs a
+ * format-parse + locale check per number */
+static inline void emit_i64(ebuf *b, int64_t v)
+{
+    uint64_t mag;
+    bool neg = v < 0;
+    if (neg) {
+        mag = (uint64_t)(-(v + 1)) + 1; /* INT64_MIN safe */
+    } else {
+        mag = (uint64_t)v;
+    }
+    char tmp[32];
+    char *q = tmp + sizeof(tmp);
+    *--q = '\0';
+    do {
+        *--q = (char)('0' + (mag % 10));
+        mag /= 10;
+    } while (mag != 0);
+    if (neg) {
+        *--q = '-';
+    }
+    eb_put(b, q, (size_t)(tmp + sizeof(tmp) - 1 - q));
+}
+
+static inline void emit_float(ebuf *b, double f)
+{
+    if (isnan(f)) {
+        eb_str(b, "nan");
+        return;
+    }
+    if (isinf(f)) {
+        eb_str(b, f < 0 ? "-inf" : "inf");
+        return;
+    }
+    /* ryu shortest round-trip digits ("D[.DD]E[X]"), re-rendered in TOML
+     * notation: fixed-point when compact, scientific otherwise. */
+    char tmp[32];
+    int n = teptris_ryu_d2s_buffered_n(f, tmp);
+    /* the _n ryu variant does NOT terminate: bound every later read */
+    tmp[n] = '\0';
+
+    size_t i = 0;
+    bool neg = false;
+    if (tmp[0] == '-') {
+        neg = true;
+        i = 1;
+    }
+    char digits[24];
+    size_t nd = 0;
+    for (; i < (size_t)n && tmp[i] != 'E'; i++) {
+        if (tmp[i] != '.') {
+            digits[nd++] = tmp[i];
+        }
+    }
+    long sci_exp = (i < (size_t)n) ? strtol(tmp + i + 1, NULL, 10) : 0;
+    long e10 = sci_exp - (long)nd + 1; /* value = digits * 10^e10 */
+
+    char out[44];
+    size_t o = 0;
+    if (neg) {
+        out[o++] = '-';
+    }
+    if (e10 >= 0 && e10 + (long)nd <= 16) {
+        memcpy(out + o, digits, nd);
+        o += nd;
+        for (long k = 0; k < e10; k++) {
+            out[o++] = '0';
+        }
+        out[o++] = '.';
+        out[o++] = '0';
+    } else if (e10 < 0 && -e10 <= (long)nd) {
+        long ip = (long)nd + e10;
+        if (ip > 0) {
+            memcpy(out + o, digits, (size_t)ip);
+            o += (size_t)ip;
+            out[o++] = '.';
+            memcpy(out + o, digits + ip, nd - (size_t)ip);
+            o += nd - (size_t)ip;
+        } else {
+            out[o++] = '0';
+            out[o++] = '.';
+            memcpy(out + o, digits, nd);
+            o += nd;
+        }
+    } else if (e10 < 0 && -e10 - (long)nd <= 6) {
+        out[o++] = '0';
+        out[o++] = '.';
+        for (long k = 0; k < -e10 - (long)nd; k++) {
+            out[o++] = '0';
+        }
+        memcpy(out + o, digits, nd);
+        o += nd;
+    } else {
+        out[o++] = digits[0];
+        if (nd > 1) {
+            out[o++] = '.';
+            memcpy(out + o, digits + 1, nd - 1);
+            o += nd - 1;
+        }
+        o += (size_t)snprintf(out + o, sizeof(out) - o, "e%ld", sci_exp);
+    }
+    eb_put(b, out, o);
+}
+
+static inline size_t put_digits2(char *p, unsigned v)
+{
+    p[0] = (char)('0' + (v / 10));
+    p[1] = (char)('0' + (v % 10));
+    return 2;
+}
+
+static inline size_t put_digits4(char *p, unsigned v)
+{
+    put_digits2(p, v / 100);
+    put_digits2(p + 2, v % 100);
+    return 4;
+}
+
+static inline void emit_dt(ebuf *b, const teptris_datetime *dt, teptris_kind k)
+{
+    char tmp[64];
+    size_t n = 0;
+    if (k != TEPTRIS_TIME_LOCAL) {
+        n += put_digits4(tmp + n, (unsigned)dt->year);
+        tmp[n++] = '-';
+        n += put_digits2(tmp + n, dt->month);
+        tmp[n++] = '-';
+        n += put_digits2(tmp + n, dt->day);
+        if (k != TEPTRIS_DATE_LOCAL) {
+            tmp[n++] = 'T';
+        }
+    }
+    if (k != TEPTRIS_DATE_LOCAL) {
+        n += put_digits2(tmp + n, dt->hour);
+        tmp[n++] = ':';
+        n += put_digits2(tmp + n, dt->minute);
+        tmp[n++] = ':';
+        n += put_digits2(tmp + n, dt->second);
+    }
+    if (dt->nanosecond != 0 && k != TEPTRIS_DATE_LOCAL) {
+        tmp[n++] = '.';
+        unsigned v = dt->nanosecond;
+        for (int i = 8; i >= 0; i--) {
+            tmp[n + (size_t)i] = (char)('0' + v % 10);
+            v /= 10;
+        }
+        n += 9;
+        while (n > 0 && tmp[n - 1] == '0') {
+            n--; /* trim trailing fraction zeros, keep at least one digit */
+        }
+    }
+    if (k == TEPTRIS_DATETIME_OFFSET) {
+        int32_t off = dt->offset_seconds;
+        if (off == 0) {
+            tmp[n++] = 'Z';
+        } else {
+            int32_t a = (off < 0) ? -off : off;
+            tmp[n++] = (off < 0) ? '-' : '+';
+            n += put_digits2(tmp + n, (unsigned)(a / 3600));
+            tmp[n++] = ':';
+            n += put_digits2(tmp + n, (unsigned)((a % 3600) / 60));
+        }
+    }
+    eb_put(b, tmp, n);
+}
+
+static inline void emit_basic_bytes(ebuf *b, const char *s, size_t n)
+{
+    eb_c(b, '"');
+    size_t i = 0;
+    while (i < n) {
+        /* span-scan to the next byte needing escape; the clean run
+         * goes out as one eb_put instead of per-byte eb_c */
+        size_t start = i;
+        while (i < n) {
+            unsigned char c = (unsigned char)s[i];
+            if (c == '"' || c == '\\' || c < 0x20 || c == 0x7F) {
+                break;
+            }
+            i++;
+        }
+        eb_put(b, s + start, i - start);
+        if (i == n) {
+            break;
+        }
+        unsigned char c = (unsigned char)s[i++];
+        switch (c) {
+        case '"':
+            eb_str(b, "\\\"");
+            break;
+        case '\\':
+            eb_str(b, "\\\\");
+            break;
+        case '\b':
+            eb_str(b, "\\b");
+            break;
+        case '\t':
+            eb_str(b, "\\t");
+            break;
+        case '\n':
+            eb_str(b, "\\n");
+            break;
+        case '\f':
+            eb_str(b, "\\f");
+            break;
+        case '\r':
+            eb_str(b, "\\r");
+            break;
+        default:
+            if (c < 0x20 || c == 0x7F) {
+                char esc[8];
+                snprintf(esc, sizeof(esc), "\\u%04X", c);
+                eb_str(b, esc);
+            }
+        }
+    }
+    eb_c(b, '"');
+}
+
+static inline void emit_string_value(ebuf *b, teptris_view s)
+{
+    bool literal = true;
+    for (size_t i = 0; i < s.len; i++) {
+        unsigned char c = (unsigned char)s.ptr[i];
+        if (c == '\'' || (c < 0x20 && c != '\t') || c == 0x7F) {
+            literal = false;
+            break;
+        }
+    }
+    if (literal) {
+        eb_c(b, '\'');
+        eb_put(b, s.ptr, s.len);
+        eb_c(b, '\'');
+        return;
+    }
+    emit_basic_bytes(b, s.ptr, s.len);
+}
+
+/* Worst-case quoted-key length: 6 bytes per input byte (\u00XX) + 2 quotes. */
+static inline size_t key_buf_cap(teptris_view key)
+{
+    return key.len * 6 + 4;
+}
+
+static inline size_t key_to_buf(char *dst, teptris_view key)
+{
+    bool bare = key.len > 0;
+    for (size_t i = 0; i < key.len; i++) {
+        if (!tep_is_barekey((unsigned char)key.ptr[i])) {
+            bare = false;
+            break;
+        }
+    }
+    if (bare) {
+        memcpy(dst, key.ptr, key.len);
+        return key.len;
+    }
+    bool literal = true;
+    for (size_t i = 0; i < key.len; i++) {
+        unsigned char c = (unsigned char)key.ptr[i];
+        if (c == '\'' || (c < 0x20 && c != '\t') || c == 0x7F) {
+            literal = false;
+            break;
+        }
+    }
+    size_t n = 0;
+    if (literal) {
+        dst[n++] = '\'';
+        memcpy(dst + n, key.ptr, key.len);
+        n += key.len;
+        dst[n++] = '\'';
+        return n;
+    }
+    dst[n++] = '"';
+    for (size_t i = 0; i < key.len; i++) {
+        unsigned char c = (unsigned char)key.ptr[i];
+        switch (c) {
+        case '"':
+            dst[n++] = '\\';
+            dst[n++] = '"';
+            break;
+        case '\\':
+            dst[n++] = '\\';
+            dst[n++] = '\\';
+            break;
+        default:
+            if (c < 0x20) {
+                static const char hex[] = "0123456789ABCDEF";
+                dst[n++] = '\\';
+                dst[n++] = 'u';
+                dst[n++] = '0';
+                dst[n++] = '0';
+                dst[n++] = hex[c >> 4];
+                dst[n++] = hex[c & 0xF];
+            } else {
+                dst[n++] = (char)c;
+            }
+        }
+    }
+    dst[n++] = '"';
+    return n;
+}
+
+static inline void emit_key(ebuf *b, teptris_view key)
+{
+    /* keys <= ~42 bytes (every bare key, nearly all quoted) never
+     * touch the allocator */
+    char stack[256];
+    if (key_buf_cap(key) <= sizeof(stack)) {
+        size_t n = key_to_buf(stack, key);
+        eb_put(b, stack, n);
+        return;
+    }
+    char *ks = malloc(key_buf_cap(key));
+    if (ks == NULL) {
+        b->st = TEPTRIS_ERR_ALLOC;
+        return;
+    }
+    size_t n = key_to_buf(ks, key);
+    eb_put(b, ks, n);
+    free(ks);
+}
+
+/* --------------------------------------------------------------- values -- */
+#endif /* TEPTRIS_EMIT_SHARED_H */