leptris 1.9.318.0-arm-linux → 1.9.319.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee7babaf2291f4504600ca04e9ae6bc2ec2ae180b6ab7ebaae467ad175ed240e
-  data.tar.gz: 1be2ebb114b6f49629edd3c7200ac9cc56f4afe8e346d13731d83fe8f6bb1681
+  metadata.gz: 2d73bfbca7f678b33985e74690f98802f0f020a438cb7f248df62b4531c3f33b
+  data.tar.gz: 81923f67f5adb8e770fa8d9228677b58f33990babc4261a38766c0186b00654e
 SHA512:
-  metadata.gz: a1fd9336ea9f80f28aa9768e387e8e7a1475de21a930ec4204047c9dc8d17f61812c97e74bf2c30b54f7c0b6fbfa7b49715b5e0a2c5be1c6ff860fe1cac6f175
-  data.tar.gz: baf8c3639dd59c27fa6a2a3bb5e1feb9449b6763a7fc221ca3cb00f5320a0ead3caf691f6c573fddaee99397d1b1679feb226bd28c97ba094a2a4627a93f8af6
+  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.318"
+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.318.0"
+  VERSION = "1.9.319.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -1295,6 +1295,15 @@ attach_function :leptris_parse_string,
         [: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

data/lib/leptris/xml/xsd.rb

@@ -9,6 +9,22 @@ module Leptris::XML::XSD
     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.
@@ -57,5 +73,21 @@ module Leptris::XML::XSD
       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/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.318
+- libleptris v1.9.319
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,39 @@
 ## [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

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -28,6 +28,7 @@ set(LEPTRIS_SOURCES
     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.h

@@ -909,6 +909,17 @@ 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/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/xsd/compile.c

@@ -8,14 +8,119 @@
 #include <string.h>
 
 #include "../../include/leptris.h"
+#include "xsd_internal.h"
 
 #define XSD_NS "http://www.w3.org/2001/XMLSchema"
 
+extern int xsd_simple_valid(const XsdSimple* simple, const char* v);
+
 struct leptris_xsd_schema {
     size_t declaration_count;
+    XsdSimple* simple_types;
     char* error;
 };
 
+static char* xsd_strdup(const char* s) {
+    if (!s) return NULL;
+    size_t n = strlen(s) + 1;
+    char* out = (char*)malloc(n);
+    if (out) memcpy(out, s, n);
+    return out;
+}
+
+/* Capture one xs:simpleType's restriction model (slice 2). */
+static XsdSimple* xsd_capture_simple(LeptrisElement st) {
+    const char* name = leptris_element_attribute(st, "name");
+    if (!name) return NULL; /* anonymous types ride their element */
+
+    XsdSimple* simple = (XsdSimple*)calloc(1, sizeof(*simple));
+    if (!simple) return NULL;
+    simple->name = xsd_strdup(name);
+    simple->length = simple->min_length = simple->max_length = -1;
+    simple->total_digits = simple->fraction_digits = -1;
+
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(st));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL, *prefix = NULL, *uri = NULL;
+        leptris_element_expanded_name(e, &local, &prefix, &uri);
+        if (uri && strcmp(uri, XSD_NS) != 0) continue;
+        if (!local) continue;
+        if (strcmp(local, "restriction") == 0) {
+            simple->base =
+                xsd_strdup(leptris_element_attribute(e, "base"));
+            for (LeptrisNodeRef f = leptris_node_first_child(
+                     leptris_element_as_node(e));
+                 f; f = leptris_node_next_sibling(f)) {
+                if (leptris_node_get_type(f) != LEPTRIS_NODE_TYPE_ELEMENT)
+                    continue;
+                LeptrisElement fe = (LeptrisElement)f;
+                const char* fl = NULL, *fp = NULL, *fu = NULL;
+                leptris_element_expanded_name(fe, &fl, &fp, &fu);
+                if (!fl || (fu && strcmp(fu, XSD_NS) != 0)) continue;
+                const char* val =
+                    leptris_element_attribute(fe, "value");
+                if (strcmp(fl, "pattern") == 0)
+                    simple->pattern = xsd_strdup(val);
+                else if (strcmp(fl, "enumeration") == 0) {
+                    XsdFacetValue* fv =
+                        (XsdFacetValue*)calloc(1, sizeof(*fv));
+                    if (fv) {
+                        fv->text = xsd_strdup(val);
+                        fv->next = simple->enum_values;
+                        simple->enum_values = fv;
+                        simple->enum_count++;
+                    }
+                } else if (strcmp(fl, "minInclusive") == 0)
+                    simple->min_inclusive = xsd_strdup(val);
+                else if (strcmp(fl, "minExclusive") == 0)
+                    simple->min_exclusive = xsd_strdup(val);
+                else if (strcmp(fl, "maxInclusive") == 0)
+                    simple->max_inclusive = xsd_strdup(val);
+                else if (strcmp(fl, "maxExclusive") == 0)
+                    simple->max_exclusive = xsd_strdup(val);
+                else if (strcmp(fl, "length") == 0)
+                    simple->length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "minLength") == 0)
+                    simple->min_length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "maxLength") == 0)
+                    simple->max_length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "totalDigits") == 0)
+                    simple->total_digits = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "fractionDigits") == 0)
+                    simple->fraction_digits = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "whiteSpace") == 0)
+                    simple->whitespace = xsd_strdup(val);
+            }
+        }
+    }
+
+    return simple;
+}
+
+/* Depth-capped local-base resolution with a cycle guard: the
+ * restriction chain walks to its built-in, facets of EVERY hop
+ * apply (XSD semantics). */
+static const XsdSimple* xsd_find_simple(struct leptris_xsd_schema* s,
+                                        const char* name) {
+    for (XsdSimple* t = s->simple_types; t; t = t->next)
+        if (strcmp(t->name, name) == 0) return t;
+    return NULL;
+}
+
+static int xsd_valid_chain(struct leptris_xsd_schema* s,
+                           const XsdSimple* t, const char* v, int depth) {
+    if (!t || depth > 32) return 0;
+    if (t->base && strncmp(t->base, "xs:", 3) != 0) {
+        const XsdSimple* next = xsd_find_simple(s, t->base);
+        if (next && !xsd_valid_chain(s, next, v, depth + 1)) return 0;
+    }
+    return xsd_simple_valid(t, v);
+}
+
 static void xsd_set_error(struct leptris_xsd_schema* s, const char* msg) {
     free(s->error);
     s->error = NULL;
@@ -88,8 +193,15 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
             continue;
         leptris_element_expanded_name((LeptrisElement)n, &local, &prefix,
                                       &uri);
-        if (xsd_is_declaration(local, uri))
-            s->declaration_count++;
+        if (!xsd_is_declaration(local, uri)) continue;
+        s->declaration_count++;
+        if (strcmp(local, "simpleType") == 0 && uri && !strcmp(uri, XSD_NS)) {
+            XsdSimple* captured = xsd_capture_simple((LeptrisElement)n);
+            if (captured) {
+                captured->next = s->simple_types;
+                s->simple_types = captured;
+            }
+        }
     }
 
     leptris_document_free(doc);
@@ -106,10 +218,49 @@ fail:
 LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
     struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
     if (!s) return;
+    XsdSimple* t = s->simple_types;
+    while (t) {
+        XsdSimple* next = t->next;
+        free(t->name);
+        free(t->base);
+        free(t->pattern);
+        XsdFacetValue* fv = t->enum_values;
+        while (fv) {
+            XsdFacetValue* fn = fv->next;
+            free(fv->text);
+            free(fv);
+            fv = fn;
+        }
+        free(t->min_inclusive);
+        free(t->min_exclusive);
+        free(t->max_inclusive);
+        free(t->max_exclusive);
+        free(t->whitespace);
+        free(t);
+        t = next;
+    }
     free(s->error);
     free(s);
 }
 
+/* ---- slice 2: lexical validation --------------------------------- */
+
+LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
+                                          const char* lexical) {
+    extern int xsd_builtin_valid(const char* type, const char* v);
+    return xsd_builtin_valid(builtin, lexical);
+}
+
+LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
+                                         const char* type_name,
+                                         const char* lexical) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s || !type_name || !lexical) return 0;
+    const XsdSimple* t = xsd_find_simple(s, type_name);
+    if (!t) return -1; /* unknown type */
+    return xsd_valid_chain(s, t, lexical, 0);
+}
+
 LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema) {
     if (!schema) return 0;
     return ((struct leptris_xsd_schema*)schema)->declaration_count;

data/vendor-src/libleptris/src/leptris/xsd/datatypes.c

@@ -0,0 +1,445 @@
+/* xsd/datatypes.c — #1075 slice 2: built-in datatype lexical
+ * validity and user simpleType restriction checking.
+ *
+ * Built-ins covered here are the tier-1 family: string/Name family,
+ * boolean, the numeric family (decimal, integer + its derivations,
+ * float, double), the date/time family, duration, hex/base64Binary,
+ * anyURI, QName. User simpleTypes validate their base first, then
+ * their facets: pattern (the rng_regex engine — the XSD pattern
+ * subset is exactly its dialect), enumeration, min/max inclusive/
+ * exclusive, the length family, total/fractionDigits. */
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "xsd_internal.h"
+
+/* rng_regex.c — the XSD pattern dialect (libxml2-compatible). */
+extern int rng_regex_matches(const char* pat, const char* text);
+
+/* ---- character-class helpers ------------------------------------- */
+
+static int xsd_ncname_start(char c) {
+    return isalpha((unsigned char)c) || c == '_' ||
+           (unsigned char)c >= 0x80;
+}
+static int xsd_ncname_char(char c) {
+    return xsd_ncname_start(c) || isdigit((unsigned char)c) ||
+           c == '-' || c == '.';
+}
+static int xsd_is_ncname(const char* s) {
+    if (!s || !*s || !xsd_ncname_start(*s)) return 0;
+    for (const char* p = s + 1; *p; p++)
+        if (!xsd_ncname_char(*p)) return 0;
+    return 1;
+}
+static int xsd_digits_only(const char* s) {
+    if (!s || !*s) return 0;
+    for (const char* p = s; *p; p++)
+        if (!isdigit((unsigned char)*p)) return 0;
+    return 1;
+}
+/* [-+]?digits — the shared integer lexical shape. */
+static int xsd_signed_integer(const char* s) {
+    if (!s || !*s) return 0;
+    if (*s == '+' || *s == '-') s++;
+    return xsd_digits_only(s);
+}
+
+/* ---- numeric range table (the integer derivations) --------------- */
+
+typedef struct {
+    const char* name;
+    long long lo, hi;
+    int integer; /* 1 = integer lexical; 0 = decimal lexical */
+} NumType;
+
+static const NumType k_numerics[] = {
+    {"xs:integer", -9223372036854775807LL - 1, 9223372036854775807LL, 1},
+    {"xs:nonNegativeInteger", 0, 9223372036854775807LL, 1},
+    {"xs:positiveInteger", 1, 9223372036854775807LL, 1},
+    {"xs:nonPositiveInteger", -9223372036854775807LL - 1, 0, 1},
+    {"xs:negativeInteger", -9223372036854775807LL - 1, -1, 1},
+    {"xs:long", -9223372036854775807LL - 1, 9223372036854775807LL, 1},
+    {"xs:int", -2147483648LL, 2147483647LL, 1},
+    {"xs:short", -32768, 32767, 1},
+    {"xs:byte", -128, 127, 1},
+    {"xs:unsignedLong", 0, 9223372036854775807LL, 1},
+    {"xs:unsignedInt", 0, 4294967295LL, 1},
+    {"xs:unsignedShort", 0, 65535, 1},
+    {"xs:unsignedByte", 0, 255, 1},
+    {NULL, 0, 0, 0},
+};
+
+/* XSD digits: no leading-zero rule beyond the sign for zero, but
+ * "007" is a valid integer lexical in XSD (unlike most languages). */
+static int value_in_range(const char* s, long long lo, long long hi) {
+    if (!xsd_signed_integer(s)) return 0;
+    /* Guard 64-bit overflow: XSD allows arbitrarily many digits —
+     * values beyond long long are still "in" xs:integer (arbitrary
+     * precision) but cannot sit in a bounded derivation's range.
+     * Digit-count prefilter keeps strtoll well-defined. */
+    const char* digits = (*s == '+' || *s == '-') ? s + 1 : s;
+    size_t nd = strlen(digits);
+    while (nd > 1 && digits[0] == '0') { digits++; nd--; }
+    if (nd > 19) return 0;
+    char* end = NULL;
+    long long v = strtoll(s, &end, 10);
+    if (end && *end) return 0;
+    return v >= lo && v <= hi;
+}
+
+/* ---- date/time lexical shapes ------------------------------------ */
+
+static int four_digits(const char** p) {
+    if (!isdigit((unsigned char)(*p)[0]) ||
+        !isdigit((unsigned char)(*p)[1]) ||
+        !isdigit((unsigned char)(*p)[2]) ||
+        !isdigit((unsigned char)(*p)[3]))
+        return 0;
+    *p += 4;
+    return 1;
+}
+static int two_digits(const char** p) {
+    if (!isdigit((unsigned char)(*p)[0]) ||
+        !isdigit((unsigned char)(*p)[1]))
+        return 0;
+    *p += 2;
+    return 1;
+}
+static int tz_optional(const char** p) {
+    if (**p != 'Z' && **p != '+' && **p != '-') return 1; /* absent */
+    if (**p == 'Z') { (*p)++; return **p == 0; }
+    (*p)++;
+    return two_digits(p) && *(*p) == ':' && (*p)++ && two_digits(p) &&
+           **p == 0;
+}
+static int two_digits_bounded(const char** p, int lo, int hi) {
+    if (!two_digits(p)) return 0;
+    int v = ((*p)[-2] - '0') * 10 + ((*p)[-1] - '0');
+    return v >= lo && v <= hi;
+}
+static int ymd(const char** p, int need_month, int need_day) {
+    if (!four_digits(p)) return 0;
+    if (need_month) {
+        if (*(*p)++ != '-') return 0;
+        if (!two_digits_bounded(p, 1, 12)) return 0;
+    }
+    if (need_day) {
+        if (*(*p)++ != '-') return 0;
+        if (!two_digits_bounded(p, 1, 31)) return 0;
+    }
+    return 1;
+}
+static int time_tail(const char** p) {
+    if (!two_digits(p)) return 0;
+    if (*(*p)++ != ':') return 0;
+    if (!two_digits(p)) return 0;
+    if (**p == ':') {
+        (*p)++;
+        if (!two_digits(p)) return 0;
+        if (**p == '.') {
+            (*p)++;
+            if (!xsd_digits_only(*p)) return 0;
+            while (isdigit((unsigned char)**p)) (*p)++;
+        }
+    }
+    return tz_optional(p);
+}
+
+/* ---- the built-in table ------------------------------------------ */
+
+int xsd_builtin_valid(const char* type, const char* v) {
+    if (!type || !v) return 0;
+    if (strcmp(type, "xs:string") == 0) return 1;
+    if (strcmp(type, "xs:normalizedString") == 0) return 1;
+    if (strcmp(type, "xs:token") == 0) {
+        if (*v == 0) return 1;
+        if (isspace((unsigned char)v[0]) ||
+            isspace((unsigned char)v[strlen(v) - 1]))
+            return 0;
+        for (const char* p = v; *p; p++) {
+            if (isspace((unsigned char)*p) &&
+                isspace((unsigned char)p[1]))
+                return 0;
+            if (*p == '\n' || *p == '\r' || *p == '\t') return 0;
+        }
+        return 1;
+    }
+    if (strcmp(type, "xs:Name") == 0) {
+        /* Name: NameStartChar (NameChar)* — NCName is the strict
+         * ASCII/80 subset; libxml2 accepts ':' in Names. */
+        if (!*v || !xsd_ncname_start(*v) && *v != ':') return 0;
+        for (const char* p = v + 1; *p; p++)
+            if (!xsd_ncname_char(*p) && *p != ':') return 0;
+        return 1;
+    }
+    if (strcmp(type, "xs:NMTOKEN") == 0) {
+        if (!*v) return 0;
+        for (const char* p = v; *p; p++)
+            if (!xsd_ncname_char(*p) && *p != ':') return 0;
+        return 1;
+    }
+    if (strcmp(type, "xs:NCName") == 0 || strcmp(type, "xs:ID") == 0 ||
+        strcmp(type, "xs:IDREF") == 0 || strcmp(type, "xs:ENTITY") == 0)
+        return xsd_is_ncname(v);
+    if (strcmp(type, "xs:language") == 0) {
+        /* [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})* */
+        const char* p = v;
+        int n = 0;
+        while (isalpha((unsigned char)*p) && n <= 8) { p++; n++; }
+        if (n < 1 || n > 8 || (*p && *p != '-')) return 0;
+        while (*p == '-') {
+            p++;
+            n = 0;
+            while ((isalnum((unsigned char)*p)) && n <= 8) { p++; n++; }
+            if (n < 1 || n > 8) return 0;
+        }
+        return *p == 0;
+    }
+    if (strcmp(type, "xs:anyURI") == 0) {
+        /* Permissive (libxml2-compatible): no ASCII control
+         * characters, no leading/trailing space. */
+        if (*v && (unsigned char)v[0] <= 0x20) return 0;
+        size_t n = strlen(v);
+        if (n && (unsigned char)v[n - 1] <= 0x20) return 0;
+        for (const char* p = v; *p; p++)
+            if ((unsigned char)*p < 0x20) return 0;
+        return 1;
+    }
+    if (strcmp(type, "xs:QName") == 0) {
+        const char* colon = strchr(v, ':');
+        if (!colon) return xsd_is_ncname(v);
+        size_t plen = (size_t)(colon - v);
+        char pfx[256];
+        if (plen >= sizeof(pfx)) return 0;
+        memcpy(pfx, v, plen);
+        pfx[plen] = 0;
+        return xsd_is_ncname(pfx) && xsd_is_ncname(colon + 1);
+    }
+    if (strcmp(type, "xs:boolean") == 0)
+        return strcmp(v, "true") == 0 || strcmp(v, "false") == 0 ||
+               strcmp(v, "0") == 0 || strcmp(v, "1") == 0;
+    if (strcmp(type, "xs:decimal") == 0) {
+        /* [-+]?((d+(.d*)?)|(.d+)) */
+        const char* p = v;
+        if (*p == '+' || *p == '-') p++;
+        int lead = 0;
+        while (isdigit((unsigned char)*p)) { p++; lead = 1; }
+        int frac = 0;
+        if (*p == '.') {
+            p++;
+            while (isdigit((unsigned char)*p)) { p++; frac = 1; }
+        }
+        if (*p) return 0;
+        return lead || frac;
+    }
+    for (const NumType* t = k_numerics; t->name; t++) {
+        if (strcmp(type, t->name) == 0) return value_in_range(v, t->lo, t->hi);
+    }
+    if (strcmp(type, "xs:float") == 0 || strcmp(type, "xs:double") == 0) {
+        if (strcmp(v, "INF") == 0 || strcmp(v, "-INF") == 0 ||
+            strcmp(v, "NaN") == 0)
+            return 1;
+        /* decimal or scientific */
+        const char* p = v;
+        if (*p == '+' || *p == '-') p++;
+        int mant = 0;
+        while (isdigit((unsigned char)*p)) { p++; mant = 1; }
+        if (*p == '.') {
+            p++;
+            while (isdigit((unsigned char)*p)) { p++; mant = 1; }
+        }
+        if (!mant) return 0;
+        if (*p == 'e' || *p == 'E') {
+            p++;
+            if (*p == '+' || *p == '-') p++;
+            if (!xsd_digits_only(p)) return 0;
+        } else if (*p) {
+            return 0;
+        }
+        return 1;
+    }
+    if (strcmp(type, "xs:date") == 0) {
+        const char* p = v;
+        if (*p == '-') p++; /* BC years */
+        if (!ymd(&p, 1, 1)) return 0;
+        return tz_optional(&p);
+    }
+    if (strcmp(type, "xs:gYearMonth") == 0) {
+        const char* p = v;
+        if (*p == '-') p++;
+        if (!ymd(&p, 1, 0)) return 0;
+        return tz_optional(&p);
+    }
+    if (strcmp(type, "xs:gYear") == 0) {
+        const char* p = v;
+        if (*p == '-') p++;
+        if (!four_digits(&p)) return 0;
+        return tz_optional(&p);
+    }
+    if (strcmp(type, "xs:gMonthDay") == 0) {
+        const char* p = v;
+        if (p[0] != '-' || p[1] != '-') return 0;
+        p += 2;
+        if (!two_digits(&p)) return 0;
+        if (*p == 0) return 1;
+        if (*p++ != '-') return 0;
+        return two_digits(&p) && *p == 0;
+    }
+    if (strcmp(type, "xs:gDay") == 0) {
+        const char* p = v;
+        if (*p++ != '-') return 0;
+        if (*p++ != '-') return 0;
+        return two_digits(&p) && *p == 0;
+    }
+    if (strcmp(type, "xs:gMonth") == 0) {
+        const char* p = v;
+        if (*p++ != '-') return 0;
+        if (*p++ != '-') return 0;
+        return two_digits(&p) && *p == 0;
+    }
+    if (strcmp(type, "xs:dateTime") == 0) {
+        const char* p = v;
+        if (*p == '-') p++;
+        if (!ymd(&p, 1, 1)) return 0;
+        if (*p != 'T' && *p != ' ') return 0;
+        p++;
+        return time_tail(&p);
+    }
+    if (strcmp(type, "xs:time") == 0) {
+        const char* p = v;
+        return time_tail(&p);
+    }
+    if (strcmp(type, "xs:duration") == 0 ||
+        strcmp(type, "xs:dayTimeDuration") == 0 ||
+        strcmp(type, "xs:yearMonthDuration") == 0) {
+        /* PnYnMnDTnHnMnS, at least one component; optional sign. */
+        const char* p = v;
+        if (*p == '-' || *p == '+') p++;
+        if (*p++ != 'P') return 0;
+        int any = 0;
+        int in_time = 0;
+        for (;;) {
+            if (*p == 'T') {
+                if (in_time) return 0;
+                in_time = 1;
+                p++;
+                continue;
+            }
+            if (!isdigit((unsigned char)*p)) break;
+            while (isdigit((unsigned char)*p)) p++;
+            if (*p == '.') { p++; while (isdigit((unsigned char)*p)) p++; }
+            char unit = *p;
+            if (!unit) return 0;
+            /* Months (date) and minutes (time) share 'M' — the
+             * in_time flag disambiguates, so only the unambiguous
+             * units are side-checked. */
+            if (in_time && unit == 'Y') return 0;
+            if (!in_time && (unit == 'H' || unit == 'S')) return 0;
+            p++;
+            any = 1;
+        }
+        return any && *p == 0;
+    }
+    if (strcmp(type, "xs:hexBinary") == 0) {
+        size_t n = strlen(v);
+        if (n % 2) return 0;
+        for (const char* p = v; *p; p++)
+            if (!isxdigit((unsigned char)*p)) return 0;
+        return 1;
+    }
+    if (strcmp(type, "xs:base64Binary") == 0) {
+        size_t n = strlen(v);
+        if (!n) return 1;
+        size_t i = 0;
+        while (i + 4 <= n) {
+            for (int k = 0; k < 4; k++) {
+                char c = v[i + k];
+                if (!isalnum((unsigned char)c) && c != '+' && c != '/' &&
+                    !(k == 3 && c == '='))
+                    return 0;
+            }
+            i += 4;
+        }
+        for (; i < n; i++) {
+            char c = v[i];
+            if (!isalnum((unsigned char)c) && c != '+' && c != '/' &&
+                c != '=')
+                return 0;
+        }
+        return 1;
+    }
+    return -1; /* not in the tier-1 table */
+}
+
+/* ---- facet checking on a captured simpleType --------------------- */
+
+int xsd_simple_valid(const XsdSimple* simple, const char* v);
+
+/* The base chain resolves to a built-in reference: validate the
+ * lexical against it first. */
+static int base_valid(const char* base, const char* v) {
+    if (!base) return xsd_builtin_valid("xs:string", v);
+    if (strncmp(base, "xs:", 3) == 0) return xsd_builtin_valid(base, v);
+    return -1; /* local base — the resolver walks the chain */
+}
+
+static int facet_check(const XsdSimple* s, const char* v) {
+    if (s->pattern && !rng_regex_matches(s->pattern, v)) return 0;
+    if (s->enum_values) {
+        int found = 0;
+        for (XsdFacetValue* e = s->enum_values; e; e = e->next)
+            if (strcmp(e->text, v) == 0) { found = 1; break; }
+        if (!found) return 0;
+    }
+    /* Length family: character count (string-family semantics). */
+    size_t n = strlen(v);
+    if (s->length >= 0 && (long)n != s->length) return 0;
+    if (s->min_length >= 0 && (long)n < s->min_length) return 0;
+    if (s->max_length >= 0 && (long)n > s->max_length) return 0;
+
+    /* Numeric min/max when the value parses as a double. */
+    char* end = NULL;
+    double d = strtod(v, &end);
+    if (end && *end == 0 && end != v) {
+        if (s->min_inclusive && !(d >= strtod(s->min_inclusive, NULL)))
+            return 0;
+        if (s->min_exclusive && !(d > strtod(s->min_exclusive, NULL)))
+            return 0;
+        if (s->max_inclusive && !(d <= strtod(s->max_inclusive, NULL)))
+            return 0;
+        if (s->max_exclusive && !(d < strtod(s->max_exclusive, NULL)))
+            return 0;
+    }
+    if (s->total_digits >= 0) {
+        long total = 0, frac = 0, seen_frac = 0;
+        for (const char* p = v; *p; p++) {
+            if (isdigit((unsigned char)*p)) {
+                total++;
+                if (seen_frac) frac++;
+            } else if (*p == '.') {
+                seen_frac = 1;
+            }
+        }
+        if (total > s->total_digits) return 0;
+        if (s->fraction_digits >= 0 && frac > s->fraction_digits)
+            return 0;
+    }
+    return 1;
+}
+
+int xsd_simple_valid(const XsdSimple* simple, const char* v) {
+    if (!simple || !v) return 0;
+    int base = base_valid(simple->base, v);
+    if (base == 0) return 0;
+    /* base == -1 (local base) delegates to the resolver's chain in
+     * the caller; facets still apply here. */
+    return facet_check(simple, v);
+}
+
+/* Pattern/enumeration defaults for whitespace — slice 3 grows the
+ * whitespace facet (collapse/replace) into the value pipeline. */
+const char* xsd_simple_whitespace(const XsdSimple* simple) {
+    return simple ? simple->whitespace : NULL;
+}

data/vendor-src/libleptris/src/leptris/xsd/xsd_internal.h

@@ -0,0 +1,43 @@
+/* xsd/xsd_internal.h — XSD subsystem internals (#1075 tier 1).
+ * Copyright (c) 2024, Ribose Inc. */
+#ifndef LEPTRIS_XSD_INTERNAL_H
+#define LEPTRIS_XSD_INTERNAL_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* One xs:enumeration / facet value, schema-owned. */
+typedef struct xsd_facet_value {
+    char* text;
+    struct xsd_facet_value* next;
+} XsdFacetValue;
+
+/* A user simpleType captured at compile time: name, restriction
+ * base (a built-in reference like "xs:integer" or another local
+ * simpleType name), and the facets the restriction carries. */
+typedef struct xsd_simple {
+    char* name;
+    char* base;
+    char* pattern;
+    XsdFacetValue* enum_values;
+    size_t enum_count;
+    char* min_inclusive;
+    char* min_exclusive;
+    char* max_inclusive;
+    char* max_exclusive;
+    long length;
+    long min_length;
+    long max_length; /* -1 = absent */
+    long total_digits;
+    long fraction_digits;
+    char* whitespace; /* "preserve" | "replace" | "collapse" */
+    struct xsd_simple* next;
+} XsdSimple;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* LEPTRIS_XSD_INTERNAL_H */

data/vendor-src/libleptris/test/rng/test_rng.cpp

@@ -1363,3 +1363,18 @@ TEST(RngParse, FileErrorsPublishToLastError) {
     ASSERT_NE(err, nullptr);
     EXPECT_NE(strstr(err, "open"), nullptr) << err;
 }
+
+// #1075 slice 2 found it: the {n} EXACT quantifier parsed as
+// open-ended {n,} (the no-comma branch never set the hi bound), so
+// [A-Z]{3} matched ABCD. Any RNG schema with exact bounds silently
+// accepted longer runs. Never-again spec on the direct engine call.
+TEST(RngRegex, ExactQuantifierIsClosed) {
+    EXPECT_EQ(rng_regex_matches("[A-Z]{3}", "ABC"), 1);
+    EXPECT_EQ(rng_regex_matches("[A-Z]{3}", "ABCD"), 0);
+    EXPECT_EQ(rng_regex_matches("[A-Z]{3}", "AB"), 0);
+    EXPECT_EQ(rng_regex_matches("a{2,3}", "aa"), 1);
+    EXPECT_EQ(rng_regex_matches("a{2,3}", "aaa"), 1);
+    EXPECT_EQ(rng_regex_matches("a{2,3}", "aaaa"), 0);
+    EXPECT_EQ(rng_regex_matches("a{2}", "aa"), 1);
+    EXPECT_EQ(rng_regex_matches("a{2}", "aaa"), 0);
+}

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -152,3 +152,115 @@ TEST(Libxml2Corpus, EveryFixtureCompilesOrFailsCleanly) {
 }
 
 }  // namespace
+
+// ---- slice 2: lexical validation ----------------------------------
+namespace {
+
+struct BuiltinCase {
+    const char* type;
+    const char* value;
+    int expect; /* 1 valid, 0 invalid, -1 not-in-table */
+};
+
+TEST(XsdDatatypes, BuiltinsLexicalMatrix) {
+    const BuiltinCase cases[] = {
+        {"xs:integer", "42", 1},        {"xs:integer", "-7", 1},
+        {"xs:integer", "+007", 1},       {"xs:integer", "3.5", 0},
+        {"xs:integer", "", 0},           {"xs:integer", "12a", 0},
+        {"xs:byte", "127", 1},           {"xs:byte", "128", 0},
+        {"xs:unsignedInt", "0", 1},      {"xs:unsignedInt", "-1", 0},
+        {"xs:positiveInteger", "1", 1},  {"xs:positiveInteger", "0", 0},
+        {"xs:decimal", "-0.5", 1},       {"xs:decimal", ".5", 1},
+        {"xs:decimal", "5.", 1},         {"xs:decimal", ".", 0},
+        {"xs:boolean", "true", 1},       {"xs:boolean", "2", 0},
+        {"xs:double", "1.5e10", 1},      {"xs:double", "INF", 1},
+        {"xs:date", "2026-10-08", 1},    {"xs:date", "2026-13-01", 0},
+        {"xs:dateTime", "2026-10-08T12:30:00", 1},
+        {"xs:time", "23:59:59.123", 1},  {"xs:time", "24:00:00", 1},
+        {"xs:duration", "P1Y2M3DT4H5M6S", 1},
+        {"xs:duration", "P", 0},
+        {"xs:hexBinary", "0A1F", 1},     {"xs:hexBinary", "0A1", 0},
+        {"xs:base64Binary", "QUJD", 1},  {"xs:base64Binary", "!", 0},
+        {"xs:NCName", "_a1", 1},         {"xs:NCName", "1a", 0},
+        {"xs:token", "a b", 1},          {"xs:token", "a  b", 0},
+        {"xs:language", "en", 1},        {"xs:language", "e!", 0},
+        {"xs:anyURI", "http://x/y", 1},
+        {"xs:notAThing", "x", -1},
+    };
+    for (const BuiltinCase& c : cases) {
+        SCOPED_TRACE(std::string(c.type) + " : " + c.value);
+        EXPECT_EQ(leptris_xsd_builtin_valid(c.type, c.value), c.expect)
+            << c.type << " : " << c.value;
+    }
+}
+
+TEST(XsdDatatypes, RestrictionFacetsApply) {
+    const char* xsd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"count\">"
+        "<xs:restriction base=\"xs:integer\">"
+        "<xs:minInclusive value=\"1\"/>"
+        "<xs:maxInclusive value=\"10\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "<xs:simpleType name=\"code\">"
+        "<xs:restriction base=\"xs:string\">"
+        "<xs:pattern value=\"[A-Z]{3}\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "<xs:simpleType name=\"color\">"
+        "<xs:restriction base=\"xs:string\">"
+        "<xs:enumeration value=\"red\"/>"
+        "<xs:enumeration value=\"green\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "<xs:simpleType name=\"label\">"
+        "<xs:restriction base=\"xs:string\">"
+        "<xs:minLength value=\"2\"/>"
+        "<xs:maxLength value=\"4\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "</xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    EXPECT_EQ(st, LEPTRIS_OK);
+
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "count", "5"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "count", "0"), 0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "count", "11"), 0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "count", "x"), 0);
+
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "code", "ABC"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "code", "ABCD"), 0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "code", "abc"), 0);
+
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "color", "red"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "color", "blue"), 0);
+
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "label", "ab"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "label", "abcde"), 0);
+
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "missing", "x"), -1);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdDatatypes, LocalBaseChainValidatesEveryHop) {
+    const char* xsd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"outer\">"
+        "<xs:restriction base=\"inner\">"
+        "<xs:maxInclusive value=\"100\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "<xs:simpleType name=\"inner\">"
+        "<xs:restriction base=\"xs:integer\">"
+        "<xs:minInclusive value=\"10\"/>"
+        "</xs:restriction></xs:simpleType>"
+        "</xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    /* Both hops' facets bind: 5 fails inner, 150 fails outer. */
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "outer", "50"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "outer", "5"), 0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "outer", "150"), 0);
+    leptris_xsd_free(s);
+}
+
+}  // namespace

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.318",
+  "version": "1.9.319",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.318.0
+  version: 1.9.319.0
 platform: arm-linux
 authors:
 - Ribose Inc.
@@ -697,6 +697,8 @@ files:
 - vendor-src/libleptris/src/leptris/xpath/xpath_variables.h
 - vendor-src/libleptris/src/leptris/xquery/xquery.c
 - vendor-src/libleptris/src/leptris/xsd/compile.c
+- vendor-src/libleptris/src/leptris/xsd/datatypes.c
+- vendor-src/libleptris/src/leptris/xsd/xsd_internal.h
 - vendor-src/libleptris/src/leptris/xslt/xslt_exec.c
 - vendor-src/libleptris/src/leptris/xslt/xslt_functions.c
 - vendor-src/libleptris/src/leptris/xslt/xslt_internal.h