teptris 0.3.4.1 → 0.3.6.2

data/ext/teptris_ext/materialize.c

@@ -9,7 +9,15 @@
 #define FMT_FORBID_TIME 2
 #define FMT_FORBID_DATE 4
 
-static VALUE eParseError, eError, cDate;
+static VALUE eParseError, eError, cDate, cDoc;
+/* rb_raise's varargs formatting segfaults in its format dispatch on
+ * windows x64-mingw-ucrt ruby 4.0 (diag #158/#160: the identical raise
+ * crashes across PGO on/off while direct exception construction runs
+ * clean, and every rb_exc_new site has always been fine) — build the
+ * message with snprintf and raise via rb_exc_new. */
+static void raise_teptris(const char *msg) {
+    rb_exc_raise(rb_exc_new(eError, msg, (long)strlen(msg)));
+}
 
 /* civil date -> days since epoch (Hinnant, inverse of the dump side) */
 static int64_t days_from_civil(int32_t y, uint8_t m, uint8_t d) {
@@ -223,14 +231,14 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags,
         if (flags & FMT_STRING_DATES) return dt_string(&d, kind);
         if (kind == TEPTRIS_DATETIME_OFFSET || kind == TEPTRIS_DATETIME_LOCAL) {
             if (flags & FMT_FORBID_TIME)
-                rb_raise(eError, "value materializes Time, which is not in "
-                                 "permitted_classes (use datetime_policy: :string)");
+                raise_teptris("value materializes Time, which is not in "
+                          "permitted_classes (use datetime_policy: :string)");
             return time_from_dt(&d, kind == TEPTRIS_DATETIME_OFFSET);
         }
         if (kind == TEPTRIS_DATE_LOCAL) {
             if (flags & FMT_FORBID_DATE)
-                rb_raise(eError, "value materializes Date, which is not in "
-                                 "permitted_classes (use datetime_policy: :string)");
+                raise_teptris("value materializes Date, which is not in "
+                          "permitted_classes (use datetime_policy: :string)");
             return rb_funcall(cDate, rb_intern("new"), 3,
                               INT2FIX(d.year), INT2FIX(d.month), INT2FIX(d.day));
         }
@@ -297,6 +305,66 @@ static VALUE ext_load(int argc, VALUE *argv, VALUE self) {
     return out;
 }
 
+/* ---------------- native-doc API: the retained DOM ----------------
+ * load_doc parses into an engine document the wrapper OWNS, together
+ * with a private copy of the input - the doc's keys/values are
+ * zero-copy views into that copy, so both live and die together.
+ * dump_doc serializes with the C emitter: the roundtrip
+ * dump_doc(load_doc(s)) never materializes Ruby objects. */
+
+static void dump_check(teptris_status st);
+
+typedef struct {
+    teptris_document *doc;
+    char *buf;
+} doc_owner;
+
+static void doc_owner_free(void *p) {
+    doc_owner *o = (doc_owner *)p;
+    if (o->doc != NULL) teptris_document_free(o->doc);
+    if (o->buf != NULL) xfree(o->buf);
+    xfree(o);
+}
+static size_t doc_owner_size(const void *p) { return sizeof(doc_owner); }
+static const rb_data_type_t doc_owner_type = {
+    "TeptrisExt/Doc",
+    {0, doc_owner_free, doc_owner_size, NULL, 0},
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE ext_load_doc(VALUE self, VALUE str) {
+    StringValue(str);
+    long len = RSTRING_LEN(str);
+    char *cbuf = ALLOC_N(char, (size_t)len + 1);
+    memcpy(cbuf, RSTRING_PTR(str), (size_t)len);
+    teptris_document *doc = NULL;
+    struct gvl_parse_arg arg = {cbuf, (size_t)len, &doc, TEPTRIS_OK};
+    rb_thread_call_without_gvl(parse_without_gvl, &arg, RUBY_UBF_IO, NULL);
+    if (arg.st != TEPTRIS_OK) {
+        const teptris_error *e = teptris_document_error(doc);
+        VALUE ex = rb_exc_new(eParseError, e->message, (long)strlen(e->message));
+        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+        xfree(cbuf);
+        teptris_document_free(doc);
+        rb_exc_raise(ex);
+    }
+    doc_owner *o = ALLOC(doc_owner);
+    o->doc = doc;
+    o->buf = cbuf;
+    return TypedData_Wrap_Struct(cDoc, &doc_owner_type, o);
+}
+
+static VALUE ext_dump_doc(VALUE self, VALUE rbdoc) {
+    doc_owner *o;
+    TypedData_Get_Struct(rbdoc, doc_owner, &doc_owner_type, o);
+    char *buf = NULL;
+    size_t len = 0;
+    dump_check(teptris_document_emit(o->doc, &buf, &len));
+    VALUE out = rb_utf8_str_new(buf, (long)len);
+    free(buf);
+    return out;
+}
+
 static VALUE ext_version(VALUE self) {
     return rb_str_new_cstr(teptris_version_string());
 }
@@ -305,11 +373,15 @@ static VALUE ext_version(VALUE self) {
 
 static ID id_utc_offset, id_to_s, id_to_i, id_nsec;
 
+
 static void dump_check(teptris_status st) {
     if (st == TEPTRIS_OK) return;
     if (st == TEPTRIS_ERR_ALLOC)
-        rb_raise(eError, "out of memory while dumping");
-    rb_raise(eError, "cannot dump value (%s)", teptris_status_string(st));
+        raise_teptris("out of memory while dumping");
+    char msg[128];
+    snprintf(msg, sizeof msg, "cannot dump value (%s)",
+             teptris_status_string(st));
+    raise_teptris(msg);
 }
 
 /* days since 1970-01-01 -> proleptic-Gregorian y/m/d (Hinnant) */
@@ -384,7 +456,9 @@ static void dump_scalar(teptris_builder *b, const char *key, size_t klen,
                                                     TEPTRIS_DATE_LOCAL, &dt));
             return;
         }
-        rb_raise(eError, "cannot dump %s", rb_obj_classname(v));
+        char msg[192];
+        snprintf(msg, sizeof msg, "cannot dump %s", rb_obj_classname(v));
+        raise_teptris(msg);
     }
 }
 
@@ -446,21 +520,28 @@ static VALUE dump_with(VALUE obj,
                  rb_obj_classname(obj));
     teptris_builder *b = teptris_builder_new();
     if (b == NULL)
-        rb_raise(eError, "out of memory while dumping");
+        raise_teptris("out of memory while dumping");
     rb_hash_foreach(obj, table_each, (VALUE)b);
     teptris_document *doc = NULL;
     teptris_status st = teptris_builder_finish(b, &doc);
     if (st != TEPTRIS_OK) {
         teptris_builder_free(b);
-        rb_raise(eError, "cannot dump (%s)", teptris_status_string(st));
+        char msg[128];
+        snprintf(msg, sizeof msg, "cannot dump (%s)",
+                 teptris_status_string(st));
+        raise_teptris(msg);
     }
     char *buf = NULL;
     size_t len = 0;
     st = emit(doc, &buf, &len);
     teptris_document_free(doc);
     teptris_builder_free(b); /* doc already transferred/freed */
-    if (st != TEPTRIS_OK)
-        rb_raise(eError, "dump failed (%s)", teptris_status_string(st));
+    if (st != TEPTRIS_OK) {
+        char msg[128];
+        snprintf(msg, sizeof msg, "dump failed (%s)",
+                 teptris_status_string(st));
+        raise_teptris(msg);
+    }
     VALUE out = rb_enc_str_new(buf, (long)len, rb_utf8_encoding());
     free(buf);
     return out;
@@ -674,7 +755,7 @@ static VALUE ext_plan_build(VALUE self, VALUE rows, VALUE first_row)
     long nrows = RARRAY_LEN(rows);
     long nplans = RARRAY_LEN(first_row) - 1;
     if (nplans < 1 || nrows < 1) {
-        rb_raise(eError, "plan needs >= 1 plan and >= 1 row");
+        raise_teptris("plan needs >= 1 plan and >= 1 row");
     }
     teptris_plan_row *crows = calloc((size_t)nrows, sizeof(*crows));
     /* bytes-vs-count: this must be (nplans+1) * sizeof(uint32_t) — the
@@ -684,7 +765,7 @@ static VALUE ext_plan_build(VALUE self, VALUE rows, VALUE first_row)
     if (crows == NULL || cfirst == NULL) {
         free(crows);
         free(cfirst);
-        rb_raise(eError, "out of memory building plan");
+        raise_teptris("out of memory building plan");
     }
     for (long i = 0; i < nrows; i++) {
         VALUE row = rb_ary_entry(rows, i);
@@ -705,7 +786,9 @@ static VALUE ext_plan_build(VALUE self, VALUE rows, VALUE first_row)
     free(crows);
     free(cfirst);
     if (plan == NULL) {
-        rb_raise(eError, "invalid plan spec (status %d)", (int)st);
+        char msg[96];
+        snprintf(msg, sizeof msg, "invalid plan spec (status %d)", (int)st);
+        raise_teptris(msg);
     }
     return TypedData_Wrap_Struct(rb_cObject, &plan_type, plan);
 }
@@ -730,7 +813,9 @@ static VALUE ext_plan_emit(VALUE self, VALUE rb_plan, VALUE toml)
         teptris_plan_walk(plan, teptris_document_root(doc), &st);
     if (res == NULL) {
         teptris_document_free(doc);
-        rb_raise(eError, "plan walk failed (status %d)", (int)st);
+        char msg[96];
+        snprintf(msg, sizeof msg, "plan walk failed (status %d)", (int)st);
+        raise_teptris(msg);
     }
     VALUE out = asm_rows(plan, res, 0);
     teptris_plan_result_free(res);
@@ -866,7 +951,7 @@ static VALUE lazy_each(VALUE self) {
         break;
     }
     default:
-        rb_raise(eError, "scalar node has nothing to iterate");
+        raise_teptris("scalar node has nothing to iterate");
     }
     return self;
 }
@@ -897,7 +982,7 @@ static VALUE lazy_get(VALUE self, VALUE key) {
         break;
     }
     default:
-        rb_raise(eError, "scalar node is not subscriptable");
+        raise_teptris("scalar node is not subscriptable");
     }
     if (child == NULL) return Qnil;
     return lazy_wrap(v->owner, child);
@@ -1011,7 +1096,12 @@ static VALUE ext_load_lazy_batch(VALUE self, VALUE strings) {
     long n = RARRAY_LEN(strings);
     if (n == 0) return rb_ary_new();
     batch_scratch *s = batch_scratch_alloc(n);
-    if (s == NULL) rb_raise(eError, "out of memory batching %ld documents", n);
+    if (s == NULL) {
+        char msg[96];
+        snprintf(msg, sizeof msg,
+                 "out of memory batching %ld documents", n);
+        raise_teptris(msg);
+    }
     /* the batch parse is pure C: pin every input (one tmp lock per
      * string - repeated objects dup; frozen strings cannot take the
      * lock, yet compaction can move them) and release the GVL for the
@@ -1163,7 +1253,12 @@ static VALUE ext_load_batch(int argc, VALUE *argv, VALUE self) {
     if (n == 0) return rb_ary_new();
     unsigned flags = flags_from_opts(opts);
     batch_scratch *s = batch_scratch_alloc(n);
-    if (s == NULL) rb_raise(eError, "out of memory batching %ld documents", n);
+    if (s == NULL) {
+        char msg[96];
+        snprintf(msg, sizeof msg,
+                 "out of memory batching %ld documents", n);
+        raise_teptris(msg);
+    }
     for (long i = 0; i < n; i++) {
         VALUE str = rb_ary_entry(strings, i);
         StringValue(str);
@@ -1175,7 +1270,10 @@ static VALUE ext_load_batch(int argc, VALUE *argv, VALUE self) {
                             s->docs, s->statuses);
     if (batch != TEPTRIS_OK) {
         batch_scratch_free(s);
-        rb_raise(eError, "batch parse failed (status %d)", (int)batch);
+        char msg[96];
+        snprintf(msg, sizeof msg, "batch parse failed (status %d)",
+                 (int)batch);
+        raise_teptris(msg);
     }
     long first_fail = -1;
     for (long i = 0; i < n; i++) {
@@ -1209,7 +1307,13 @@ void Init_teptris_ext(void) {
      * call state (key cache, arenas, types) is per-object or per-call */
     rb_ext_ractor_safe(true);
     VALUE m = rb_define_module("TeptrisExt");
+    cDoc = rb_define_class_under(m, "Doc", rb_cObject);
+    /* opaque handle: no Ruby-side allocation (silences the
+     * allocator-undefine warning on reload) */
+    rb_undef_alloc_func(cDoc);
     rb_define_module_function(m, "load", ext_load, -1);
+    rb_define_module_function(m, "load_doc", ext_load_doc, 1);
+    rb_define_module_function(m, "dump_doc", ext_dump_doc, 1);
     rb_define_module_function(m, "load_lazy", ext_load_lazy, 1);
     rb_define_module_function(m, "load_batch", ext_load_batch, -1);
     rb_define_module_function(m, "load_slice", ext_load_slice, -1);

data/lib/teptris/toml.rb

@@ -18,6 +18,24 @@ module Teptris::TOML
       TeptrisExt.load(toml)
     end
 
+    # Parse into a RETAINED engine document (an opaque TeptrisExt::Doc
+    # handle; no Ruby objects are materialized). Pair with dump_doc for
+    # a roundtrip that runs entirely at C speed - reserialization of
+    # an unchanged document skips both Ruby-object walks. The doc owns
+    # a private copy of the input: its values are views into it, so
+    # mutating the source string afterwards is invisible (and the doc
+    # keeps the copy alive).
+    def load_doc(toml)
+      raise ArgumentError, "input must be a String" unless toml.is_a?(String)
+
+      TeptrisExt.load_doc(toml)
+    end
+
+    # Emit a load_doc() document at C speed (canonical TOML).
+    def dump_doc(doc)
+      TeptrisExt.dump_doc(doc)
+    end
+
     # Safe-load shaped entry point for frameworks: permitted_classes
     # restricts datetime materialization (raise when a value would
     # materialize an unpermitted class); datetime_policy :string keeps

data/lib/teptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teptris
-  VERSION = "0.3.4.1"
+  VERSION = "0.3.6.2"
 end

data/sig/teptris.rbs

@@ -22,6 +22,8 @@ module Teptris
     # Time for local datetimes, Date for dates, "HH:MM:SS" String for
     # local times.
     def self.load: (String toml) -> Hash[String, untyped]
+    def self.load_doc: (String toml) -> untyped
+    def self.dump_doc: (untyped doc) -> String
 
     def self.load_file: (String path) -> Hash[String, untyped]
 
@@ -122,6 +124,10 @@ module TeptrisExt
 
   def self.load_lazy_batch: (Array[String] tomls) -> Array[LazyValue]
 
+  def self.load_doc: (String toml) -> untyped
+
+  def self.dump_doc: (untyped doc) -> String
+
   def self.dump: (untyped obj) -> String
 
   def self.dump_json_natural: (untyped obj) -> String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.3.4.1
+  version: 0.3.6.2
 platform: ruby
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies: []
 description: A native C extension over libteptris, a C99 TOML 1.1 parser/emitter.
   API shape mirrors the tomlib gem.
@@ -39,8 +39,10 @@ files:
 - ext/teptris_ext/engine/src/teptris/common/simd.h
 - ext/teptris_ext/engine/src/teptris/dom/dom.c
 - ext/teptris_ext/engine/src/teptris/dom/dom.h
+- ext/teptris_ext/engine/src/teptris/emit/emit_shared.h
 - ext/teptris_ext/engine/src/teptris/emit/emitter.c
 - ext/teptris_ext/engine/src/teptris/emit/emitter.h
+- ext/teptris_ext/engine/src/teptris/emit/writer.c
 - ext/teptris_ext/engine/src/teptris/memory/arena.c
 - ext/teptris_ext/engine/src/teptris/memory/arena.h
 - ext/teptris_ext/engine/src/teptris/parse/datetime.c