leptris 1.9.317.1-arm-linux → 1.9.319.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2824d22f679e46bb0bcb8d79a163886812769ba8c9fe668e1243e27723cd0d7d
-  data.tar.gz: ab423424bd971f3dd6088ecae5ef9b2e15ab25b6ee64bcda617ab0cd19b7098b
+  metadata.gz: 2d73bfbca7f678b33985e74690f98802f0f020a438cb7f248df62b4531c3f33b
+  data.tar.gz: 81923f67f5adb8e770fa8d9228677b58f33990babc4261a38766c0186b00654e
 SHA512:
-  metadata.gz: e355e20bc42352cf12697bcbb34b56b767fd6efa7ab82247bb57d89333d565d50fe1009a5c6b0dbd56aaf256f6c877970b95d6ea741c37d83140de432e9022ad
-  data.tar.gz: e04b01514ed223d2ef660c69cf9d2294f0903e3a12523e37c154bb61b18ba54458f8e6b5847c53077c0d4d94755ca767221b4f5997563240cbd6bf4c761feb5e
+  metadata.gz: 601ca1dfd786e2d15f76693fee886b49a25e336a6f2cbd43365bda6ca5de327239750abdf3114ff44178d276b8bb4f8bd13a2bc7884ddb8d0ed1c3a4858a6bbf
+  data.tar.gz: 3939d7264a015ef4ab66a32027896dec0adee34df022eda80afdf3f01f3c9a95a53c1f393bb634e3430f5797e99383055b765c1bf820ab2e3029cae05f87b9fc

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [1.9.319.0] - 2026-10-08
+
+### Added — engine sync (libleptris 1.9.319)
+
+- **XSD lexical validation, slice 2 (#1075)**:
+  `XSD.builtin_valid?` covers the tier-1 built-in table (string
+  family, token, boolean, decimal/integer ranges, float/double,
+  date/time with bounds, duration, hex/base64Binary) by the
+  "xs:NAME" reference spelling; `Schema#simple_valid?` resolves
+  user simpleTypes through cycle-guarded restriction chains
+  (pattern / enumeration / min-max / length / digits facets).
+  The C face's -1 (not-in-table / unknown type) raises — a silent
+  false would let misspelled types validate nothing forever.
+  (Slice 1's compile surface rode in the parallel 1.9.318.0.)
+
+### Fixed — engine sync (1.9.319)
+
+- **RELAX NG exact `{n}` quantifiers (PR #1583)**: the regex
+  engine's no-comma branch never set the hi bound — `[A-Z]{3}`
+  matched `ABCD`, so any schema using exact bounds silently
+  over-accepted. Pinned through the binding's datatype path
+  (accepts ABC, rejects ABCD).
+
+### Performance — engine sync (1.9.318)
+
+- Per-thread small-span arena recycle (#1436): the tiny-doc
+  create/destroy row drops ~15% (183→159 ns/doc quiet-hardware) —
+  engine-internal; the binding inherits it on every
+  Document.create cycle.
+
 ## [1.9.317.1] - 2026-10-08
 
 ### Fixed

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.317"
+LIBLEPTRIS_VERSION = "1.9.319"
 # 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

data/lib/leptris/version.rb

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

data/lib/leptris/xml/ffi.rb

@@ -157,6 +157,7 @@ module Leptris
       typedef :pointer, :leptris_xpath_ns_set
       typedef :pointer, :leptris_xpath_compiled
       typedef :pointer, :leptris_relaxng
+      typedef :pointer, :leptris_xsd_schema
       typedef :pointer, :leptris_xslt
       typedef :pointer, :leptris_xquery
       typedef :pointer, :leptris_schematron
@@ -1283,6 +1284,27 @@ attach_function :leptris_parse_string,
                :column, :int
       end
 
+      # XSD tier-1 (libleptris 1.9.318, #1075): compilation surface —
+      # compile a schema, count its top-level declarations, surface
+      # schema-level errors. Validation is a later tier.
+      attach_function :leptris_xsd_compile,
+        [:string, :size_t, :pointer], :leptris_xsd_schema
+      attach_function :leptris_xsd_free,
+        [:leptris_xsd_schema], :void
+      attach_function :leptris_xsd_declaration_count,
+        [:leptris_xsd_schema], :size_t
+      attach_function :leptris_xsd_error,
+        [:leptris_xsd_schema], UTF8_STRING
+      # Slice 2 (libleptris 1.9.319, #1075): lexical validation.
+      # Built-ins take the "xs:NAME" reference spelling; -1 = not
+      # in the tier-1 table. simple_valid resolves a user
+      # simpleType by local name through cycle-guarded restriction
+      # chains; -1 = unknown type.
+      attach_function :leptris_xsd_builtin_valid,
+        [:string, :string], :int
+      attach_function :leptris_xsd_simple_valid,
+        [:leptris_xsd_schema, :string, :string], :int
+
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng
       attach_function :leptris_rng_parse_file,

data/lib/leptris/xml/xsd.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Leptris::XML::XSD
+  module_function
+
+  def compile(schema_xml)
+    Schema.compile(schema_xml)
+  end
+
+  # Slice 2 (libleptris 1.9.319, #1075): built-in lexical table.
+  # +builtin+ takes the "xs:NAME" reference spelling. Returns
+  # true/false; an unknown table name raises — a silent false
+  # would let misspelled types validate nothing forever.
+  def builtin_valid?(builtin, lexical)
+    r = Leptris::XML::FFI.leptris_xsd_builtin_valid(
+      builtin.to_s, lexical.to_s)
+    case r
+    when 1 then true
+    when 0 then false
+    else
+      raise ArgumentError,
+        "#{builtin.inspect} is not in the tier-1 built-in table"
+    end
+  end
+
+  # A compiled XSD schema (libleptris >= 1.9.318, #1075 tier-1):
+  # the compilation surface — a declaration census and schema-level
+  # error reporting. Validation is a later tier and not exposed yet.
+  #
+  #     schema = Leptris::XML::XSD.compile(xsd_text)
+  #     schema.declaration_count  # => top-level schema declarations
+  #     schema.error              # => nil, or the engine's message
+  #
+  class Schema
+    # GC-managed compiled handle.
+    class Handle < ::FFI::AutoPointer
+      def self.release(ptr)
+        Leptris::XML::FFI.leptris_xsd_free(ptr)
+      end
+    end
+
+    # Compile a schema from XML text. Raises Error when the text is
+    # not usable at all (not well-formed, no root); schema-level
+    # problems compile to a handle whose #error carries the detail
+    # — the tier-1 contract.
+    def self.compile(schema_xml)
+      xml = schema_xml.to_s
+      status = ::FFI::MemoryPointer.new(:int)
+      raw = Leptris::XML::FFI.leptris_xsd_compile(xml, xml.bytesize, status)
+      if raw.null?
+        raise Leptris::XML::Error,
+          "schema compile failed (status #{status.read_int}): " \
+          "#{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    # Number of top-level schema declarations the compiler
+    # recognized (elements, types, groups, ...).
+    def declaration_count
+      Leptris::XML::FFI.leptris_xsd_declaration_count(@handle)
+    end
+
+    # The engine's schema-level error message, or nil when the
+    # schema compiled cleanly.
+    def error
+      msg = Leptris::XML::FFI.leptris_xsd_error(@handle)
+      msg.nil? || msg.empty? ? nil : msg
+    end
+
+    # Slice 2 (libleptris 1.9.319, #1075): lexical validation of
+    # +lexical+ against the user simpleType +type_name+ (local
+    # name) — restriction chains validate every hop's facets,
+    # cycle-guarded. Unknown type names raise (the -1 contract).
+    def simple_valid?(type_name, lexical)
+      r = Leptris::XML::FFI.leptris_xsd_simple_valid(
+        @handle, type_name.to_s, lexical.to_s)
+      case r
+      when 1 then true
+      when 0 then false
+      else
+        raise ArgumentError,
+          "#{type_name.inspect} is not a simpleType in this schema"
+      end
+    end
+  end
+end

data/lib/leptris/xml.rb

@@ -35,6 +35,7 @@ module Leptris
     autoload :XSLT, "leptris/xml/xslt"
     autoload :XQuery, "leptris/xml/xquery"
     autoload :RelaxNG, "leptris/xml/relaxng"
+    autoload :XSD, "leptris/xml/xsd"
     autoload :DTD, "leptris/xml/dtd"
     autoload :Pull, "leptris/xml/pull"
     autoload :Iterparse, "leptris/xml/iterparse"

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.317
+- libleptris v1.9.319
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,60 @@
 ## [Unreleased]
 
+## [1.9.319] - 2026-10-08
+
+### Added
+
+- **XSD validation, tier 1, slices 1–2 (#1075, PRs #1581/#1583).**
+  Slice 1: the `leptris_xsd_compile` surface (xs:schema identity
+  under any namespace spelling, top-level declaration enumeration,
+  error-carrying failure handles) plus the corpus gate — libxml2's
+  own `test/schemas` set (350 files, MIT) vendored at
+  `test/xsd/libxml2-cases`, **163/163 fixtures compiling** with a
+  pinned monotonic floor. Slice 2: `leptris_xsd_builtin_valid` —
+  the tier-1 built-in lexical table (string/Name family, token,
+  language, anyURI, QName, boolean, decimal, the integer-derivation
+  ranges, float/double, the date/time family with month/day bounds,
+  duration, hex/base64Binary) — and `leptris_xsd_simple_valid`:
+  named simpleTypes captured at compile (base + pattern /
+  enumeration / min-max inclusive-exclusive / length family /
+  total-fractionDigits facets), validated through cycle-guarded
+  restriction chains where every hop's facets bind.
+
+### Fixed
+
+- **Regex engine: `{n}` EXACT quantifiers parsed open-ended
+  (PR #1583).** The no-comma branch never set the hi bound, so
+  `[A-Z]{3}` matched `ABCD` — any RELAX NG schema using exact
+  quantifier bounds silently accepted longer runs. Root fix in the
+  quantifier parser plus a never-again spec on the direct engine
+  call; `rng_internal.h` gained C++ guards for test-side calls.
+- Amalgamated single-TU build: the XSD datatype statics now carry
+  the `xsd_` prefix (collision with the xpath lexer's same-named
+  statics — the #1217 class).
+
+
+
+## [1.9.318] - 2026-10-08
+
+### Performance
+
+- **Per-thread small-span arena recycle — the tiny-doc fixed row
+  (#1436, PR #1580).** The global retain tier deliberately skipped
+  spans below 256 KB, so every small document paid full malloc/free
+  bookkeeping per create/destroy cycle; the quiet-hardware profile
+  named that cycle as the heart of the ~185 ns/doc tiny-doc row. A
+  per-thread LIFO cache inside the arena's retain seam hands the
+  previous document's span back with no allocator, no spinlock, and
+  no cross-thread traffic. Three standing contracts preserved:
+  exact-size take (the fail-fast capacity never silently widens),
+  custom-allocator stand-down (hooked accounting sees every
+  malloc/free pair), and ASAN bypass with thread-cleanup drain.
+  Measured on bench_doc_lifecycle (interleaved A/B, Release):
+  tight cycle 183/203/183 → 166/159/159 ns/doc (~15% off the
+  fixed row).
+
+
+
 ## [1.9.317] - 2026-10-07
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.317
+    VERSION 1.9.319
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/CMakeLists.txt

@@ -27,6 +27,8 @@ set(LEPTRIS_SOURCES
     leptris/sch/schematron.c
     leptris/diff/diff.c
     leptris/rng/parse.c
+    leptris/xsd/compile.c
+    leptris/xsd/datatypes.c
     leptris/rng/rng_public.c
     leptris/rng/rng_regex.c
     leptris/rng/validate.c

data/vendor-src/libleptris/src/include/leptris/types.h

@@ -34,6 +34,8 @@ typedef struct leptris_doctype*      LeptrisDoctype;
 typedef const char*                 LeptrisNamespace;
 typedef struct leptris_xpath_result* LeptrisXPathResult;
 typedef struct leptris_relaxng*    LeptrisRelaxNG;
+/* #1075 XSD tier 1: opaque compiled W3C XML Schema handle. */
+typedef struct leptris_xsd_schema*  LeptrisXsdSchema;
 #endif
 
 /* ============================================================================

data/vendor-src/libleptris/src/include/leptris.h

@@ -882,6 +882,44 @@ LEPTRIS_API LeptrisRelaxNG leptris_rng_parse(const char* schema,
 LEPTRIS_API LeptrisRelaxNG leptris_rng_parse_file(const char* path,
                                                   LeptrisStatus* status);
 LEPTRIS_API void leptris_rng_free(LeptrisRelaxNG rng);
+
+/* ============================================================================
+ * XSD (W3C XML Schema) — #1075 tier 1, slice 1: compilation.
+ *
+ * leptris_xsd_compile parses schema text and builds the top-level
+ * declaration model (xs:element / xs:attribute / xs:simpleType /
+ * xs:complexType / xs:group / xs:attributeGroup / xs:notation).
+ * Slices that follow add the datatype/facet machinery, content
+ * models, identity constraints, and instance validation.
+ *
+ * @param xsd_text schema bytes (UTF-8)
+ * @param len      byte length
+ * @param status   LEPTRIS_OK, or LEPTRIS_ERROR_PARSE (not
+ *                 well-formed, not an xs:schema document, or no
+ *                 recognized XML Schema namespace spelling)
+ * @return compiled schema; on failure an error-carrying handle
+ *         (leptris_xsd_error says why — free it the same way)
+ */
+LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
+                                                 size_t len,
+                                                 LeptrisStatus* status);
+LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema);
+/* Number of top-level schema declarations compiled (0 is valid). */
+LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema);
+/* Last compile error detail (NULL when the handle is valid).
+ * Schema-owned; lives until leptris_xsd_free. */
+LEPTRIS_API const char* leptris_xsd_error(LeptrisXsdSchema schema);
+
+/* Slice 2 — lexical validation. Built-ins take the "xs:NAME"
+ * reference spelling; -1 = not in the tier-1 table. */
+LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
+                                          const char* lexical);
+/* A user simpleType compiled into the schema, by local name:
+ * 1 valid, 0 invalid, -1 unknown type. Restriction chains (local
+ * bases) validate every hop's facets, cycle-guarded. */
+LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
+                                         const char* type_name,
+                                         const char* lexical);
 /* Validate an instance document against the parsed schema
  * (phase-2 core subset: element/attribute/text/data/value/
  * choice/group/interleave/repeats/ref). Returns 1 valid; on 0,

data/vendor-src/libleptris/src/leptris/dom/element.h

@@ -29,6 +29,7 @@ typedef struct leptris_doctype*         LeptrisDoctype;
 typedef const char*                    LeptrisNamespace;
 typedef struct leptris_xpath_result*    LeptrisXPathResult;
 typedef struct leptris_relaxng* LeptrisRelaxNG;
+typedef struct leptris_xsd_schema* LeptrisXsdSchema;
 #endif
 
 #include "node.h"

data/vendor-src/libleptris/src/leptris/memory/arena.c

@@ -3,6 +3,7 @@
  */
 #include "arena.h"
 
+#include "../common/port.h" /* LEPTRIS_THREAD_LOCAL */
 #include <stdint.h> /* uintptr_t: was transitive via glibc's mman graph */
 #include <stdlib.h>
 #include <string.h>
@@ -16,6 +17,7 @@
  * every byte the library takes. */
 void* leptris_alloc_hook(size_t size);
 void leptris_free_hook(void* ptr);
+int leptris_custom_allocator_active(void);
 
 #define ARENA_ALIGNMENT 8u
 
@@ -92,11 +94,78 @@ static void retain_lock(void) {
 static void retain_unlock(void) { __sync_lock_release(&g_retain_lock); }
 #endif
 
+/* ---- Small-span TLS recycle (#1436 tiny-doc fixed row) ---------
+ * The global retain deliberately skips spans below ARENA_RETAIN_MIN
+ * ("libc zone-reuses them"), but the per-document fixed-cost profile
+ * names arena create+destroy as the heart of the ~185 ns/doc
+ * tiny-doc row: even zone-recycled, malloc/free pay bookkeeping per
+ * span, and the batched-GC shape pays first-touch faults when a
+ * batch's spans outrun the zone cache. A per-thread LIFO of small
+ * spans hands the previous document's span back with no allocator,
+ * no global spinlock, and no cross-thread traffic. Same contract as
+ * the global tier: NOT zeroed, callers memset what they need. */
+#define ARENA_TLS_SPANS 8u
+#define ARENA_TLS_MAX_BYTES (2u * 1024u * 1024u)
+
+typedef struct {
+    char* base[ARENA_TLS_SPANS];
+    size_t size[ARENA_TLS_SPANS];
+    size_t count;
+    size_t bytes;
+} ArenaSmallCache;
+
+static LEPTRIS_THREAD_LOCAL ArenaSmallCache g_small;
+
+/* LIFO take, EXACT size only: a reused span must report exactly the
+ * requested capacity (same as a fresh malloc), or the fail-fast
+ * bound silently widens for whoever sized a span to its budget —
+ * the exhaustion specs pin that. Small spans are near-homogeneous
+ * per workload (a 64 KB-doc stream recycles 64 KB spans), so
+ * exact-match still catches the hot case. */
+static char* small_take(size_t request, size_t* capacity) {
+    if (request >= ARENA_RETAIN_MIN) return NULL;
+    /* Stands down under custom allocators, same as the pool
+     * recycler: hooked accounting must see every malloc/free pair. */
+    if (leptris_custom_allocator_active()) return NULL;
+    for (size_t i = g_small.count; i > 0; i--) {
+        size_t idx = i - 1;
+        if (g_small.size[idx] == request) {
+            char* found = g_small.base[idx];
+            *capacity = g_small.size[idx];
+            g_small.bytes -= g_small.size[idx];
+            g_small.base[idx] = g_small.base[g_small.count - 1];
+            g_small.size[idx] = g_small.size[g_small.count - 1];
+            g_small.count--;
+            return found;
+        }
+    }
+    return NULL;
+}
+
+/* Returns 1 when the span was parked, 0 when the cache is full or
+ * the size belongs to the global tier — the caller frees then. */
+static int small_give(char* base, size_t size) {
+    if (size >= ARENA_RETAIN_MIN) return 0;
+    if (leptris_custom_allocator_active()) return 0;
+    if (g_small.count >= ARENA_TLS_SPANS ||
+        g_small.bytes + size > ARENA_TLS_MAX_BYTES)
+        return 0;
+    g_small.base[g_small.count] = base;
+    g_small.size[g_small.count] = size;
+    g_small.count++;
+    g_small.bytes += size;
+    return 1;
+}
+
 /* Best fit: the smallest retained block that covers the request, so
  * oversized blocks aren't burned on small documents. Returns the
- * block and reports its true capacity; NULL when nothing fits (or
- * the request is below the retain threshold — malloc territory). */
+ * block and reports its true capacity; NULL when nothing fits. */
 static char* retain_take(size_t request, size_t* capacity) {
+    /* 'parked', never 'small' — MSVC's headers #define small (the
+     * OLE `#define small char`) and turn the local into a type
+     * token (C2059). */
+    char* parked = small_take(request, capacity);
+    if (parked) return parked;
     if (request < ARENA_RETAIN_MIN) return NULL;
     char* found = NULL;
     size_t found_size = 0;
@@ -128,7 +197,8 @@ static void retain_give(char* base, size_t size) {
     return;
 #endif
     if (size < ARENA_RETAIN_MIN) {
-        leptris_free_hook(base);
+        if (!small_give(base, size))
+            leptris_free_hook(base);
         return;
     }
     retain_lock();
@@ -149,6 +219,16 @@ static void retain_give(char* base, size_t size) {
  * blocks are process-lifetime parking by design; release them so
  * embedded hosts and leak checkers see a clean exit. */
 void leptris_arena_retain_drain(void) {
+    /* The small tier drains the CALLING thread's cache — the shape
+     * leptris_thread_cleanup serves. Other threads' cached spans
+     * stay reachable through their TLS slots and die with the
+     * process (the same still-reachable parking as the global
+     * tier). */
+    for (size_t i = 0; i < g_small.count; i++)
+        leptris_free_hook(g_small.base[i]);
+    g_small.count = 0;
+    g_small.bytes = 0;
+
     retain_lock();
     for (size_t i = 0; i < g_retain.count; i++)
         leptris_free_hook(g_retain.base[i]);

data/vendor-src/libleptris/src/leptris/rng/rng_internal.h

@@ -8,6 +8,10 @@
 #ifndef LEPTRIS_RNG_INTERNAL_H
 #define LEPTRIS_RNG_INTERNAL_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "../include/leptris.h"
 #include "../dom/diag.h"
 #include <stddef.h>
@@ -109,4 +113,8 @@ int rng_regex_matches(const char* pat, const char* text);
 void rng_pattern_free(RngPattern* p);
 void rng_grammar_free(RngGrammar* g);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/vendor-src/libleptris/src/leptris/rng/rng_regex.c

@@ -289,6 +289,10 @@ static RreNode* parse_piece(RreParser* ps) {
                     }
                 }
             }
+            /* {n} with no comma is EXACT — h must be l, not the
+             * -1 "unbounded" sentinel. The old code left h = -1,
+             * so [A-Z]{3} matched ABCD (open-ended {3,}). */
+            if (*q != ',' && h == -1) h = l;
             if (*q == '}' && l >= 0 && (h == -1 || h >= l)) {
                 lo = l;
                 hi = h;

data/vendor-src/libleptris/src/leptris/xpath/evaluator.h

@@ -25,6 +25,7 @@ typedef struct leptris_doctype*         LeptrisDoctype;
 typedef const char*                    LeptrisNamespace;
 typedef struct leptris_xpath_result*    LeptrisXPathResult;
 typedef struct leptris_relaxng* LeptrisRelaxNG;
+typedef struct leptris_xsd_schema* LeptrisXsdSchema;
 #endif
 
 /* ============================================================================