leptris 1.9.231.0 → 1.9.232.0

data/vendor-src/libleptris/src/leptris/xpath/parser.c

@@ -2382,6 +2382,98 @@ static XPathASTNode* parse_switch_expr(XPathParser* parser) {
         }
     }
 }
+
+/* String literal body -> decoded value (malloc'd). XQuery 3.1
+ * 3.1.1: character references (
, A, 😀) expand to
+ * the referenced codepoint -- EXEMPT from line-end normalization
+ * (QT3 K-CodepointToStringFunc-13) -- and the five predefined
+ * entity refs expand likewise. A '&' that is not a well-formed
+ * reference stays literal (the text-path leniency). Codepoints are
+ * UTF-8 encoded, so astral refs work. */
+static char* decode_string_literal(const char* p, size_t n) {
+    char* out = (char*)malloc(n + 1);
+    if (!out) return NULL;
+    size_t o = 0;
+    const char* pe = p + n;
+    while (p < pe) {
+        if (*p != '&') {
+            out[o++] = *p++;
+            continue;
+        }
+        const char* semi = memchr(p, ';', (size_t)(pe - p));
+        static const char* const k_predef[] = { "amp", "lt", "gt",
+                                                "quot", "apos" };
+        static const char k_predef_ch[] = { '&', '<', '>', '"', '\'' };
+        int handled = 0;
+        if (semi && (size_t)(semi - p) <= 12) {
+            size_t rl = (size_t)(semi - p - 1);
+            const char* r = p + 1;
+            if (*r == '#') {
+                r++;
+                int hex = 0;
+                if (r < semi && (*r == 'x' || *r == 'X')) {
+                    hex = 1;
+                    r++;
+                }
+                unsigned long cp = 0;
+                const char* ds = r;
+                while (r < semi) {
+                    char c = *r;
+                    int dv = hex ? (c >= '0' && c <= '9')
+                                       ? c - '0'
+                                       : (c >= 'a' && c <= 'f')
+                                             ? c - 'a' + 10
+                                             : (c >= 'A' && c <= 'F')
+                                                   ? c - 'A' + 10
+                                                   : -1
+                                : (c >= '0' && c <= '9') ? c - '0' : -1;
+                    if (dv < 0) break;
+                    cp = cp * (hex ? 16ul : 10ul) + (unsigned long)dv;
+                    if (cp > 0x110000ul) cp = 0x110001ul;
+                    r++;
+                }
+                if (r == semi && r > ds &&
+                    (cp == 0x9ul || cp == 0xAul || cp == 0xDul ||
+                     (cp >= 0x20ul && cp <= 0x10FFFFul)) &&
+                    (cp < 0xD800ul || cp > 0xDFFFul)) {
+                    if (cp < 0x80ul) {
+                        out[o++] = (char)cp;
+                    } else if (cp < 0x800ul) {
+                        out[o++] = (char)(0xC0 | (cp >> 6));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    } else if (cp < 0x10000ul) {
+                        out[o++] = (char)(0xE0 | (cp >> 12));
+                        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    } else {
+                        out[o++] = (char)(0xF0 | (cp >> 18));
+                        out[o++] = (char)(0x80 | ((cp >> 12) & 0x3F));
+                        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    }
+                    handled = 1;
+                }
+            } else {
+                for (int i = 0; i < 5; i++) {
+                    if (rl == strlen(k_predef[i]) &&
+                        memcmp(r, k_predef[i], rl) == 0) {
+                        out[o++] = k_predef_ch[i];
+                        handled = 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (handled) {
+            p = semi + 1;
+        } else {
+            out[o++] = *p++;
+        }
+    }
+    out[o] = '\0';
+    return out;
+}
+
 static XPathASTNode* parse_primary_expr(XPathParser* parser) {
     XPathToken* tok = current_token(parser);
     if (!tok) {
@@ -2423,13 +2515,21 @@ static XPathASTNode* parse_primary_expr(XPathParser* parser) {
         XPathASTNode* node = ast_node_new(XPATH_AST_STRING);
         if (!node) return NULL;
 
-        /* Remove quotes */
+        /* Remove quotes; expand references when present. The scan
+         * for '&' keeps the plain-literal path a memcpy (the common
+         * case pays nothing). */
         if (tok->value_len >= 2) {
-            size_t len = tok->value_len - 2;
-            node->value = LEPTRIS_ALLOC_N(char, len + 1);
-            if (node->value) {
-                memcpy(node->value, tok->value + 1, len);
-                node->value[len] = '\0';
+            const char* bp = tok->value + 1;
+            size_t blen = tok->value_len - 2;
+            if (blen && memchr(bp, '&', blen)) {
+                node->value = decode_string_literal(bp, blen);
+            }
+            if (!node->value) {
+                node->value = LEPTRIS_ALLOC_N(char, blen + 1);
+                if (node->value) {
+                    memcpy(node->value, bp, blen);
+                    node->value[blen] = '\0';
+                }
             }
         }
         advance_token(parser);

data/vendor-src/libleptris/test/abi/test_descriptor.cpp

@@ -386,6 +386,74 @@ TEST(PlanWalk, NamespaceFormsAndLeniency) {
     leptris_document_free(doc);
 }
 
+/* XSD-002 fallout class: child rows whose wire_name is the PREFIXED
+ * form ("w:b") — exactly what the ABI doc promises ("XML element
+ * name as it appears on the wire") — must bind namespaced elements.
+ * The matcher historically compared the LOCAL name only, so every
+ * prefixed row silently matched nothing: hosts hydrated empty
+ * subtrees (attributes read NULL, elements fell back to defaults)
+ * and re-serialized without them. Local-name rows keep binding. */
+TEST(PlanWalk, PrefixedWireNamesBindNamespacedElements) {
+    LeptrisDocument doc = parse(
+        "<w:document xmlns:w=\"urn:w\">"
+        "<w:r><w:b w:val=\"false\"/></w:r>"
+        "</w:document>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+
+    leptris_attr_plan b_attrs[] = {
+        {"w:val", LEPTRIS_PLAN_KIND_SCALAR, 7, 0, 0, nullptr},
+    };
+    leptris_child_plan b_row = {};
+    b_row.wire_name = "w:b";
+    b_row.kind = LEPTRIS_PLAN_KIND_NESTED;
+    b_row.child_plan_index = 2;
+    b_row.ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_child_plan r_row = {};
+    r_row.wire_name = "w:r";
+    r_row.kind = LEPTRIS_PLAN_KIND_NESTED;
+    r_row.child_plan_index = 1;
+    r_row.ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_element_plan plans[3] = {};
+    plans[0].element_name = "document";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[0].child_count = 1;
+    plans[0].child_plans = &r_row;
+    plans[1].element_name = "r";
+    plans[1].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[1].child_count = 1;
+    plans[1].child_plans = &b_row;
+    plans[2].element_name = "b";
+    plans[2].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[2].attribute_count = 1;
+    plans[2].attribute_plans = b_attrs;
+
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 3;
+    spec.plans = plans;
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+    LeptrisPlanResult r = leptris_plan_walk(doc, root, plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 1u);
+    LeptrisPlanResult rcoll = leptris_plan_value_at(r, 0);
+    ASSERT_NE(rcoll, nullptr);
+    /* the nested w:r row binds its element value */
+    ASSERT_EQ(leptris_plan_value_kind(rcoll), LEPTRIS_PLAN_VALUE_ELEMENT);
+    ASSERT_EQ(leptris_plan_value_count(rcoll), 1u);
+    LeptrisPlanResult bval = leptris_plan_value_at(rcoll, 0);
+    ASSERT_NE(bval, nullptr);
+    ASSERT_EQ(leptris_plan_value_kind(bval), LEPTRIS_PLAN_VALUE_ELEMENT);
+    const char* val = leptris_plan_value_attribute(bval, "w:val");
+    ASSERT_NE(val, nullptr);
+    EXPECT_STREQ(val, "false");
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+    leptris_document_free(doc);
+}
+
 TEST(PlanBuild, CopiesTheSpecStrings) {
     LeptrisDocument doc = parse("<doc><t>v</t></doc>");
     ASSERT_NE(doc, nullptr);

data/vendor-src/libleptris/test/dom/test_dom.cpp

@@ -2234,6 +2234,62 @@ TEST(DomBasics, NodeVisitWalksSubtreeEnterLeave) {
     leptris_document_free(doc);
 }
 
+/* Issue #1332: entering-only visit mode — one callback per node, on
+ * entering. Halves the C-callback invocations for consumers that
+ * discard the leaving half (family walks bind lazily on enter).
+ * Same walk order and depths as leptris_node_visit. */
+TEST(DomBasics, NodeVisitEnteringFiresOncePerNode) {
+    const char xml[] = "<r><a>t1</a><b><!--c--></b></r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+
+    VisitLog log;
+    leptris_node_visit_entering((LeptrisNodeRef)root, &VisitLog::visit,
+                                &log);
+    /* 5 nodes (r, a, text, b, comment) — the 3 leaving events of
+     * the full mode are gone. The event list has no L* entries. */
+    ASSERT_EQ(log.events.size(), 5u);
+    EXPECT_EQ(log.events[0], "Er:0");
+    EXPECT_EQ(log.events[1], "Ea:1");
+    EXPECT_EQ(log.events[2], "T:2");
+    EXPECT_EQ(log.events[3], "Eb:1");
+    EXPECT_EQ(log.events[4], "O:2");
+
+    /* Document-node walk behaves identically to the full mode. */
+    VisitLog dlog;
+    leptris_node_visit_entering(leptris_document_node(doc),
+                                &VisitLog::visit, &dlog);
+    ASSERT_EQ(dlog.events.size(), 5u);
+    EXPECT_EQ(dlog.events[0], "Er:0");
+    leptris_document_free(doc);
+}
+
+TEST(DomBasics, NodeVisitEnteringHalvesTheCallbackCount) {
+    /* The moxml-walk contract (#1332): elements visit TWICE in the
+     * full mode, ONCE here. */
+    const char xml[] =
+        "<r><a><b/><c><d/></c></a><e/><f><g><h/></g></f></r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+
+    int full_calls = 0, entering_calls = 0;
+    auto counter = +[](void* ud, LeptrisNodeRef, int, int) {
+        ++*static_cast<int*>(ud);
+    };
+    leptris_node_visit((LeptrisNodeRef)leptris_document_root(doc),
+                       counter, &full_calls);
+    leptris_node_visit_entering(
+        (LeptrisNodeRef)leptris_document_root(doc), counter,
+        &entering_calls);
+    EXPECT_EQ(full_calls, 18);        /* 9 elements * 2 */
+    EXPECT_EQ(entering_calls, 9);     /* 9 elements, once */
+    leptris_document_free(doc);
+}
+
 TEST(DomBasics, NodeChildrenExCarriesKinds) {
     const char xml[] =
         "<r>text<!--c--><a/><?pi x?></r>";