leptris 1.9.197.0 → 1.9.197.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe0d9ad19af1ea0312a5a04daf2f3fededf7c630490ebcf337bd231c5e86f76
-  data.tar.gz: 69ba7d9ba6b929220068d310d98e06e42480764828f023ed981b4f6625adb193
+  metadata.gz: 8de0724486489f72c2c7e2443165f3800ecf9d6c2982eb3a246dd3cd6ab6e70f
+  data.tar.gz: cfad76439cb742b582a4afa79e1ab029db61073843e5443a5c1d8250ee43c65e
 SHA512:
-  metadata.gz: 4eb77398a80e630172e14fe9d4ae3cbed2dc0416d3b6f6ed5d2343b394eb24477e9b824d8cfa5d18cdcc61cc2788d812de9b9ea533bf15a34f7478c51882aee7
-  data.tar.gz: 2a10f88e73dceb1ae6b48bb3aeacd8f5f696d54cbb5906acece5d2dac19c81925742b575f42a51a5a5eab750981fa4e9691570359cfa7dafd97c617b5adefff8
+  metadata.gz: c545ac6185a58d3628c4abbf9312a1fa54cf58878b357f6cabc64e1d84bb2624e15711872dea4d939b822a040fcbf3f753fc5c30186a393a3ecabe44d0043194
+  data.tar.gz: cf7246e381117269bad72dbb6213533d849f05b2573e5c611535a2826251c4d8f1f25e1c72a9381b179b7a4bd7656a0e41ca7caee5467ed2fc14563ec97636b6

data/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.199.0] - 2026-09-19
+
+### Changed — libleptris 1.9.197 → 1.9.199 (lockstep; 1.9.198/199
+released before this gem, entries folded)
+
+- **The 32-bit port shipped (upstream #1174 closed)** — per-wordsize
+  layout pins replace the 64-bit-only ABI asserts, xsl:number values
+  are 64-bit end to end (ILP32 truncation fixed), and SSE2 paths
+  gate on `__SSE2__` rather than x86-ness. **The `arm-linux` and
+  `arm-linux-musl` platform gems compile for the first time** —
+  their release legs (experimental, with in-container install +
+  round-trip smoke) validate the port directly.
+- **The root_doc_map TLS memo no longer resolves
+  namebp-carrying elements** (1.9.198, leptris/leptris#1189,
+  closed) — upstream adopted exactly the one-line guard filed from
+  our ubuntu-3.4 CI investigation: a recycled root address no
+  longer makes `set_root` mis-reject a same-document attach as
+  "cross-document". The seam_and_reads spec that exposed it runs
+  green across the full grid, deterministically.
+- HTML: memchr prefilter in the raw-text close-tag scan; 256-entry
+  LUT for the attribute-name scan (#1177).
+- `leptris validate --dtd` + DTD content-model fixes (cli; the
+  binding's DTD surface unchanged).
+- Still experimental pending upstream: ppc64le (LTO export
+  internalization, #1196 — the no-LTO release build ships working
+  gems) and s390x big-endian parser (#1197/#1194, engine work
+  in progress upstream).
+- No public-symbol changes: audit 323/323. 727/0 both modes.
+
 ## [1.9.197.0] - 2026-09-18
 
 ### Changed — libleptris 1.9.194 → 1.9.197 (lockstep)

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.197"
+LIBLEPTRIS_VERSION = "1.9.199"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the
@@ -128,6 +128,12 @@ task :compile do
   # LEPTRIS_PGO=0 escapes to the single-stage build.
   pgo = ENV["LEPTRIS_PGO"] != "0" && !Gem.win_platform?
   if pgo
+    # The trainer is disposable infrastructure — an engine-side
+    # trainer break (e.g. leptris/leptris#1204: GCC LTO internalizes
+    # CLI-only API symbols and the CLI link dies) must degrade the
+    # gem to the plain build (loudly, with the issue pointer), not
+    # block every platform's release.
+    begin
     # _GNU_SOURCE for the TRAIN build only: the CLI (the trainer, not
     # built in normal gems) uses fileno, which musl hides without a
     # POSIX feature macro (glibc is lenient). Upstream fix pending in
@@ -168,6 +174,15 @@ task :compile do
     sh "cmake -B #{build}/build -S #{build} #{cmake_base} " \
        "-DLEPTRIS_BUILD_CLI=OFF -DLEPTRIS_ENABLE_PGO=USE"
     sh "cmake --build #{build}/build --config Release -j 4"
+    rescue => e
+      warn "leptris: PGO trainer failed (#{e.message.to_s[0, 160]}); " \
+           "shipping the single-stage build — the parse path loses the " \
+           "~20% PGO gain this release (leptris/leptris#1204 tracks the " \
+           "engine-side trainer break)"
+      rm_rf(File.join(build, "build"))
+      sh "cmake -B #{build}/build -S #{build} #{cmake_base}"
+      sh "cmake --build #{build}/build --config Release -j 4"
+    end
   else
     sh "cmake -B #{build}/build -S #{build} #{cmake_base}"
     sh "cmake --build #{build}/build --config Release -j 4"

data/ext/leptris/native/native.c

@@ -1941,6 +1941,122 @@ static VALUE nf_snapshot_rows(VALUE self, VALUE document, VALUE addr)
     return out;
 }
 
+/* ---- Struct plan executor (moxml "miles faster" round) ------------
+ * The consumer's shape compiles to spec: name (interned String) ->
+ * [Struct class, attrs Hash (name -> slot Symbol), text slot Symbol
+ * or nil, children slot Symbol or nil]. C walks the subtree
+ * pre-order, mints typed structs directly (rb_struct_new +
+ * rb_struct_aset), and attaches each to the nearest OPEN frame —
+ * exactly Moxml::Plan's semantics: an unmatched element is a
+ * barrier (its matched descendants surface at top level). Zero
+ * Ruby frames and zero intermediate rows per element. */
+static void plan_walk(void *node, int depth, VALUE spec, VALUE stack,
+                      VALUE roots)
+{
+    if (f_node_type(node) == WS_NODE_ELEMENT) {
+        const char *name_c = f_elem_name(node);
+        VALUE entry = name_c ? rb_hash_aref(spec,
+                            rb_enc_interned_str(name_c, strlen(name_c),
+                                                rb_utf8_encoding()))
+                             : Qnil;
+
+        /* Complete deeper frames: pre-order means any open frame at
+         * depth >= this element's depth belongs to an earlier
+         * subtree that ended before this row. */
+        while (RARRAY_LEN(stack) >= 2 &&
+               NUM2INT(rb_ary_entry(stack, RARRAY_LEN(stack) - 2)) >=
+                 depth) {
+            rb_ary_pop(stack);
+            rb_ary_pop(stack);
+        }
+
+        if (!NIL_P(entry)) {
+            /* volatile: keep live VALUEs on the C stack so the
+             * conservative scanner sees them on every ABI (windows
+             * x64 keeps some only in callee-saved registers). */
+            volatile VALUE klass = rb_ary_entry(entry, 0);
+            volatile VALUE attrs_spec = rb_ary_entry(entry, 1);
+            volatile VALUE text_slot = rb_ary_entry(entry, 2);
+            volatile VALUE children_slot = rb_ary_entry(entry, 3);
+            VALUE value = rb_struct_new(klass);
+
+            for (void *a = f_attr_first(node); a; a = f_attr_next(a)) {
+                const char *an = f_attr_name(a);
+                VALUE slot = an ? rb_hash_aref(attrs_spec,
+                                      rb_enc_interned_str(an, strlen(an),
+                                                          rb_utf8_encoding()))
+                                : Qnil;
+                if (!NIL_P(slot)) {
+                    const char *av = f_attr_value(node, a);
+                    rb_struct_aset(value, slot,
+                                   av ? rb_utf8_str_new_cstr(av) : Qnil);
+                }
+            }
+            if (!NIL_P(text_slot)) {
+                void *c;
+                for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+                    if (f_node_type(c) == WS_NODE_TEXT) {
+                        const char *t = f_text_content(c);
+                        rb_struct_aset(value, text_slot,
+                                       t ? rb_utf8_str_new_cstr(t) : Qnil);
+                        break;
+                    }
+                }
+            }
+
+            /* attach: nearest open frame carrying a children array;
+             * barriers (unmatched ancestors) and the root surface
+             * the value at top level — Moxml::Plan's contract. */
+            if (RARRAY_LEN(stack) >= 2 &&
+                rb_ary_entry(stack, RARRAY_LEN(stack) - 1) != Qnil) {
+                rb_ary_push(rb_ary_entry(stack, RARRAY_LEN(stack) - 1),
+                            value);
+            } else {
+                rb_ary_push(roots, value);
+            }
+            RB_GC_GUARD(value);
+            RB_GC_GUARD(entry);
+
+            if (!NIL_P(children_slot)) {
+                VALUE children = rb_ary_new();
+                rb_struct_aset(value, children_slot, children);
+                rb_ary_push(stack, INT2NUM(depth));
+                rb_ary_push(stack, children);
+            }
+        } else {
+            /* unmatched: barrier frame — descendants must not
+             * attach through it (Moxml::Plan parity). */
+            rb_ary_push(stack, INT2NUM(depth));
+            rb_ary_push(stack, Qnil);
+        }
+
+        void *c;
+        for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+            plan_walk(c, depth + 1, spec, stack, roots);
+        }
+    } else if (f_node_type(node) == WS_NODE_DOCTYPE ||
+               f_node_type(node) == 9) {
+        void *dc = f_first_child(node);
+        while (dc) {
+            plan_walk(dc, depth, spec, stack, roots);
+            dc = f_next_sibling(dc);
+        }
+    }
+}
+
+static VALUE nf_plan_structs(VALUE self, VALUE document, VALUE addr,
+                             VALUE spec)
+{
+    (void)self;
+    (void)document;
+    VALUE roots = rb_ary_new();
+    VALUE stack = rb_ary_new();
+    plan_walk((void *)(uintptr_t)NUM2ULL(addr), 0, spec, stack, roots);
+    RB_GC_GUARD(spec);
+    RB_GC_GUARD(stack);
+    return roots;
+}
+
 /* ---- inner_html in one C pass (TODO.perf/18) --------------------
  * Serializes the receiver's children into one growable buffer:
  * elements via leptris_element_serialize_into (the same opts the
@@ -2490,6 +2606,8 @@ void Init_native(void)
                               nf_snapshot_subtree, 2);
     rb_define_module_function(m_native, "snapshot_rows",
                               nf_snapshot_rows, 2);
+    rb_define_module_function(m_native, "plan_structs",
+                              nf_plan_structs, 3);
     rb_define_module_function(m_native, "doc_handle_attach",
                               nf_doc_handle_attach, 1);
     rb_define_module_function(m_native, "doc_handle_release",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.197.0"
+  VERSION = "1.9.197.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.197.0
+  version: 1.9.197.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -144,6 +144,10 @@ files:
 - lib/leptris/vendor/aarch64-linux-musl/libutf8proc.so.3
 - lib/leptris/vendor/aarch64-linux/libleptris.so
 - lib/leptris/vendor/aarch64-linux/libutf8proc.so.3
+- lib/leptris/vendor/arm-linux-musl/libleptris.so
+- lib/leptris/vendor/arm-linux-musl/libutf8proc.so.3
+- lib/leptris/vendor/arm-linux/libleptris.so
+- lib/leptris/vendor/arm-linux/libutf8proc.so.3
 - lib/leptris/vendor/arm64-darwin/libleptris.dylib
 - lib/leptris/vendor/arm64-darwin/libutf8proc.3.dylib
 - lib/leptris/vendor/ppc64le-linux/libleptris.so