leptris 1.9.201.4-arm-linux → 1.9.207.0-arm-linux

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -437,7 +437,47 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
      * Careful: first_attribute_off == 0 means empty list. We can't decode
      * the pointer and check for NULL — at offset 0 the decoded pointer
      * is `elem` itself, which is non-NULL. Check the offset field. */
+    /* #1200: duplicate-attribute detection. Prefilter on (len,
+     * first byte) — a mismatching pair costs two loads; the memcmp
+     * only runs on genuine candidates. First definition wins
+     * (libxml2 recover semantics, and the digest's first-wins
+     * becomes official); the duplicate never enters the chain, it
+     * costs its already-carved slot. */
     if (elem->first_attribute_off != 0) {
+        int dup = 0;
+        for (struct leptris_attribute* a =
+                 (struct leptris_attribute*)((char*)elem +
+                                             elem->first_attribute_off);
+             a; a = leptris_attr_next(a)) {
+            if (a->name_view.length == attr->name_view.length &&
+                a->name_view.data[0] == attr->name_view.data[0] &&
+                memcmp(a->name_view.data, attr->name_view.data,
+                       attr->name_view.length) == 0) {
+                dup = 1;
+                break;
+            }
+        }
+        if (dup) {
+            if (p->doc) {
+                extern struct LeptrisDiag* leptris_diag_emit(
+                    struct LeptrisDiag**, int*, int*,
+                    LeptrisDiagKind, LeptrisNodeRef,
+                    const char*, ...);
+                char qname[130];
+                size_t ql = attr->name_view.length < 129
+                                ? attr->name_view.length : 129;
+                memcpy(qname, attr->name_view.data, ql);
+                qname[ql] = '\0';
+                leptris_diag_emit(&p->doc->parse_diags,
+                                  &p->doc->parse_diag_count,
+                                  &p->doc->parse_diag_cap,
+                                  LEPTRIS_DIAG_RECOVER, NULL,
+                                  "Attribute %s redefined", qname);
+            }
+            /* 1 = duplicate skipped (keep first): the caller skips
+             * the raw-attr registration so BOTH surfaces agree. */
+            return 1;
+        }
         /* Cache should always be valid mid-parse. Fall back to walk
          * only if cache is NULL (defensive — shouldn't happen). */
         struct leptris_attribute* tail = p->current_elem_last_attr;
@@ -845,13 +885,16 @@ static int dp_parse_attrs(DParser* p, LeptrisElement elem) {
             continue;
         }
 
-        /* Regular attribute — zero-copy name/value, bulk-allocated struct. */
-        if (dp_add_attr_inline(p, elem, name_start, name_len,
-                                val_start, val_len, has_amp, has_ws,
-                                attr_colon) != 0)
+        /* Regular attribute — zero-copy name/value, bulk-allocated
+         * struct. 1 = duplicate skipped: neither surface sees it. */
+        int arc = dp_add_attr_inline(p, elem, name_start, name_len,
+                                     val_start, val_len, has_amp,
+                                     has_ws, attr_colon);
+        if (arc < 0) return -1;
+        if (arc == 0 &&
+            dp_raw_attr(p, elem, name_start, name_len,
+                        val_start, val_len) != 0)
             return -1;
-        if (dp_raw_attr(p, elem, name_start, name_len,
-                        val_start, val_len) != 0) return -1;
     }
     /* for (;;): every exit is a return inside the loop (0 = tag
      * closed, 1 = self-closing, -1 = error) — there is no
@@ -1571,9 +1614,21 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
             if (close_local_len <= 8 &&
                 (p.probe_slack ||
                  close_local + 8 <= p.end + 1)) {
+                /* The mask follows MEMORY order: memcpy fills the low
+                 * bytes on little-endian and the high bytes on
+                 * big-endian, so each dialect must mask the end its
+                 * load populated. The unconditional low-bytes mask
+                 * compared bytes past the name on big-endian and
+                 * failed every close tag (#1197). */
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+                uint64_t mask = (close_local_len == 8)
+                    ? ~(uint64_t)0
+                    : (~(uint64_t)0 << (64 - close_local_len * 8));
+#else
                 uint64_t mask = (close_local_len == 8)
                     ? ~(uint64_t)0
                     : ((1ull << (close_local_len * 8)) - 1);
+#endif
                 uint64_t a, b;
                 memcpy(&a, open_name, 8);
                 memcpy(&b, close_local, 8);

data/vendor-src/libleptris/src/leptris/html/html_parse.c

@@ -2722,6 +2722,13 @@ typedef struct {
     /* #659 foreign content: per-slot namespace of the open stack
      * (0 HTML, 1 SVG, 2 MathML) — parallel to open[]. */
     uint8_t open_ns[256];
+    /* #1225: last child of each open element — the builder's own
+     * O(1) append tail. The doc-level direct-mapped tail cache
+     * loses a persistent parent to an address collision roughly
+     * every 1KB of fresh pool allocations; each miss walks the
+     * whole child chain, which is quadratic on table/text-heavy
+     * pages. Slots are refreshed on push (NULL) and by hb_put. */
+    LeptrisNodeRef open_tail[256];
     size_t depth;
     LeptrisElement root;        /* first top-level element */
     LeptrisNodeRef top_head;    /* top-level chain: text, comments, root */
@@ -3054,30 +3061,130 @@ static int h_is_formatting(const char* n) {
 
 /* WHATWG "special" category (13.2.4.2) — the adoption agency's
  * furthest-block candidates. */
+/* Generated tag classifier (#1218 hot path): one first-char
+ * bucket walk replaces the ~78-entry strcmp scans that the
+ * sampler pinned at ~21% of WHATWG parse (h_is_special_ww +
+ * h_reconstructs). Keep in sync with the WHATWG special and
+ * no-formatting sets. */
+typedef struct {
+    char name[12];
+    uint8_t len;
+    uint8_t special;   /* WHATWG 13.2.4 special set */
+    uint8_t no_fmt;    /* never reconstructed (formatting) */
+} HTagInfo;
+
+static const HTagInfo h_tag_infos[] = {
+    {"address", 7, 1, 1},
+    {"applet", 6, 1, 0},
+    {"area", 4, 1, 0},
+    {"article", 7, 1, 1},
+    {"aside", 5, 1, 1},
+    {"base", 4, 1, 1},
+    {"basefont", 8, 1, 1},
+    {"bgsound", 7, 1, 1},
+    {"blockquote", 10, 1, 1},
+    {"body", 4, 1, 1},
+    {"br", 2, 1, 0},
+    {"button", 6, 1, 0},
+    {"caption", 7, 1, 1},
+    {"center", 6, 1, 1},
+    {"col", 3, 1, 1},
+    {"colgroup", 8, 1, 1},
+    {"dd", 2, 1, 1},
+    {"details", 7, 1, 1},
+    {"dialog", 6, 1, 1},
+    {"dir", 3, 1, 1},
+    {"div", 3, 1, 1},
+    {"dl", 2, 1, 1},
+    {"dt", 2, 1, 1},
+    {"embed", 5, 1, 0},
+    {"fieldset", 8, 1, 1},
+    {"figcaption", 10, 1, 1},
+    {"figure", 6, 1, 1},
+    {"footer", 6, 1, 1},
+    {"form", 4, 1, 1},
+    {"frame", 5, 1, 1},
+    {"frameset", 8, 1, 1},
+    {"h1", 2, 1, 1},
+    {"h2", 2, 1, 1},
+    {"h3", 2, 1, 1},
+    {"h4", 2, 1, 1},
+    {"h5", 2, 1, 1},
+    {"h6", 2, 1, 1},
+    {"head", 4, 1, 1},
+    {"header", 6, 1, 1},
+    {"hgroup", 6, 1, 1},
+    {"hr", 2, 1, 1},
+    {"html", 4, 1, 1},
+    {"iframe", 6, 1, 0},
+    {"img", 3, 1, 0},
+    {"input", 5, 1, 0},
+    {"keygen", 6, 1, 0},
+    {"li", 2, 1, 1},
+    {"link", 4, 1, 1},
+    {"listing", 7, 1, 1},
+    {"main", 4, 1, 1},
+    {"marquee", 7, 1, 0},
+    {"menu", 4, 1, 1},
+    {"meta", 4, 1, 1},
+    {"nav", 3, 1, 1},
+    {"noembed", 7, 1, 0},
+    {"noframes", 8, 1, 1},
+    {"noscript", 8, 1, 0},
+    {"object", 6, 1, 0},
+    {"ol", 2, 1, 1},
+    {"p", 1, 1, 1},
+    {"param", 5, 1, 0},
+    {"plaintext", 9, 1, 1},
+    {"pre", 3, 1, 1},
+    {"script", 6, 1, 1},
+    {"search", 6, 1, 1},
+    {"section", 7, 1, 1},
+    {"select", 6, 1, 0},
+    {"source", 6, 1, 0},
+    {"style", 5, 1, 1},
+    {"summary", 7, 1, 1},
+    {"table", 5, 1, 1},
+    {"tbody", 5, 1, 1},
+    {"td", 2, 1, 1},
+    {"template", 8, 1, 1},
+    {"textarea", 8, 1, 1},
+    {"tfoot", 5, 1, 1},
+    {"th", 2, 1, 1},
+    {"thead", 5, 1, 1},
+    {"title", 5, 1, 1},
+    {"tr", 2, 1, 1},
+    {"track", 5, 1, 0},
+    {"ul", 2, 1, 1},
+    {"wbr", 3, 1, 0},
+    {"xmp", 3, 1, 0},
+};
+
+/* bucket[first_char] = start index; bucket[first_char+1] = end */
+static const uint8_t h_tag_bucket[27] = {
+    0, 5, 12, 16, 23, 24, 31, 31, 42,
+    45, 45, 46, 49, 53, 57, 59, 63, 63,
+    63, 70, 81, 82, 82, 83, 84, 84, 84,
+};
+
+/* Resolve a (lowercased) tag name's flags; NULL when unknown. */
+static const HTagInfo* h_tag_lookup(const char* n) {
+    if (!n) return NULL;
+    unsigned char c = (unsigned char)n[0];
+    if (c < 'a' || c > 'z') return NULL;
+    for (int i = h_tag_bucket[c - 'a'];
+         i < h_tag_bucket[c - 'a' + 1]; i++) {
+        const HTagInfo* t = &h_tag_infos[i];
+        if ((uint8_t)n[t->len] == 0 && t->name[t->len - 1] == n[t->len - 1] &&
+            memcmp(n, t->name, t->len) == 0)
+            return t;
+    }
+    return NULL;
+}
+
 static int h_is_special_ww(const char* n) {
-    static const char* const k[] = {
-        "address",  "applet",  "area",   "article",  "aside",
-        "base",     "basefont", "bgsound", "blockquote", "body",
-        "br",       "button",  "caption", "center",  "col",
-        "colgroup", "dd",      "details", "dialog",  "dir",
-        "div",
-        "dl",       "dt",      "embed",  "fieldset", "figcaption",
-        "figure",   "footer",  "form",   "frame",    "frameset",
-        "h1",       "h2",      "h3",     "h4",       "h5",
-        "h6",       "head",    "header", "hgroup",   "hr",
-        "html",     "iframe",  "img",    "input",    "keygen",
-        "li",       "link",    "listing", "main",    "marquee",
-        "menu",     "meta",    "nav",    "noembed",  "noframes",
-        "noscript", "object",  "ol",     "p",        "param",
-        "plaintext", "pre",    "script", "search",   "section",
-        "select",   "source",  "style",  "summary",  "table",
-        "tbody",    "td",      "template", "textarea", "tfoot",
-        "th",       "thead",   "title",  "tr",       "track",
-        "ul",       "wbr",     "xmp",    NULL};
-    if (!n) return 0;
-    for (int i = 0; k[i]; i++)
-        if (strcmp(n, k[i]) == 0) return 1;
-    return 0;
+    const HTagInfo* t = h_tag_lookup(n);
+    return t && t->special;
 }
 
 #define H_NS_HTML 0
@@ -3249,22 +3356,8 @@ static int h_input_type_hidden(const char* q, const char* end) {
  * head set, the block-level set (they close p instead), the table
  * family, and raw-text elements. */
 static int h_reconstructs(const char* n) {
-    static const char* const no[] = {
-        "html",  "head",   "body",   "frameset", "base",  "basefont",
-        "bgsound", "link", "meta",   "script",   "style", "template",
-        "title", "noframes", "address", "article", "aside",
-        "blockquote", "center", "details", "dialog", "dir",
-        "div",   "dl",     "fieldset", "figcaption", "figure",
-        "footer", "header", "hgroup", "main",    "menu",  "nav",
-        "ol",    "p",      "search", "section",  "summary", "ul",
-        "h1",    "h2",     "h3",     "h4",       "h5",    "h6",
-        "pre",   "listing", "form",  "li",       "dd",    "dt",
-        "plaintext", "textarea", "table", "hr",  "caption", "col",
-        "colgroup", "frame", "tbody", "tfoot",   "thead", "td",
-        "th",    "tr",     NULL};
-    for (int i = 0; no[i]; i++)
-        if (strcmp(n, no[i]) == 0) return 0;
-    return 1;
+    const HTagInfo* t = h_tag_lookup(n);
+    return !(t && t->no_fmt);
 }
 
 /* ---- #659 foreign content (WHATWG 12.2.6.5) ---- */
@@ -3658,6 +3751,24 @@ static void h_insert_before(HBuilder* b, LeptrisElement parent,
         parent->child_count++;
 }
 
+/* O(1) append for open-stack parents (#1225): route through the
+ * builder's per-slot tail. Non-open parents fall back to the
+ * shared internal (whose tail cache + walk still apply). The hint
+ * is validated inside leptris_element_append_child_tail, so any
+ * stale slot is silently ignored — correctness never depends on
+ * the bookkeeping. */
+static void hb_put(HBuilder* b, LeptrisElement parent, LeptrisNodeRef n) {
+    for (size_t i = b->depth; i-- > 0;) {
+        if (b->open[i] == parent) {
+            leptris_element_append_child_tail(parent, n, b->doc,
+                                              b->open_tail[i]);
+            b->open_tail[i] = n;
+            return;
+        }
+    }
+    leptris_element_append_child_internal_doc(parent, n, b->doc);
+}
+
 static void h_append(HBuilder* b, LeptrisNodeRef n) {
     /* "in frameset" (13.2.6.4.18): non-whitespace text is IGNORED
      * with a frameset open ANYWHERE on top; whitespace inserts
@@ -3932,7 +4043,7 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
                 return;
             }
         }
-        leptris_element_append_child_internal_doc(top, n, b->doc);
+        hb_put(b, top, n);
     } else {
         h_top_append(b, n);
     }
@@ -3999,6 +4110,7 @@ static LeptrisElement h_open_foreign(HBuilder* b, const char* name,
     if (b->depth == 0 && !b->root) b->root = e;
     if (b->depth < 256) {
         b->open[b->depth] = e;
+        b->open_tail[b->depth] = NULL;
         b->open_ns[b->depth] = (uint8_t)ns;
         b->depth++;
     }
@@ -4036,6 +4148,7 @@ static LeptrisElement h_open_element(HBuilder* b, const char* name) {
     if (b->depth == 0 && !b->root) b->root = e;
     if (b->depth < 256) {
         b->open[b->depth] = e;
+        b->open_tail[b->depth] = NULL;
         b->open_ns[b->depth] = H_NS_HTML;
         b->depth++;
     }
@@ -4236,6 +4349,7 @@ static LeptrisElement h_afe_open_clone(HBuilder* b, LeptrisElement src) {
     if (b->depth == 0 && !b->root) b->root = c;
     if (b->depth < 256) {
         b->open[b->depth] = c;
+        b->open_tail[b->depth] = NULL;
         b->open_ns[b->depth] = H_NS_HTML;
         b->depth++;
     }
@@ -4518,6 +4632,7 @@ static LeptrisElement h_open_named(HBuilder* b, const char* name,
     if (b->depth == 0 && !b->root) b->root = e;
     if (push && b->depth < 256) {
         b->open[b->depth] = e;
+        b->open_tail[b->depth] = NULL;
         b->open_ns[b->depth] = H_NS_HTML;
         b->depth++;
     }
@@ -4532,8 +4647,7 @@ static LeptrisElement h_new_child(HBuilder* b, LeptrisElement parent,
     LeptrisElement e = leptris_element_create_with_view(nv, b->pool);
     if (!e) return NULL;
     leptris_root_doc_register(e, b->doc);
-    leptris_element_append_child_internal_doc(parent, (LeptrisNodeRef)e,
-                                              b->doc);
+    hb_put(b, parent, (LeptrisNodeRef)e);
     return e;
 }
 

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

@@ -836,6 +836,13 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
         /* The pool will be destroyed below, freeing all elements */
     }
 
+    /* Parse diagnostics (#1200): the recover-channel list. */
+    {
+        extern void leptris_diag_free(struct LeptrisDiag**, int*, int*);
+        leptris_diag_free(&doc->parse_diags, &doc->parse_diag_count,
+                          &doc->parse_diag_cap);
+    }
+
     /* Free document fields */
     if (doc->encoding) {
         LEPTRIS_FREE(doc->encoding);
@@ -921,9 +928,11 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
         leptris_root_doc_unregister((LeptrisElement)doc->new_dom_root);
     }
     /* #1038: fallback-path registrations (detached elements) die
-     * with the doc too — see leptris_root_doc_unregister_doc. */
+     * with the doc too — see leptris_root_doc_unregister_doc. The
+     * declaration must match root_doc_map.c's size_t return or the
+     * amalgamated single-TU build fails (#1217). */
     {
-        extern void leptris_root_doc_unregister_doc(
+        extern size_t leptris_root_doc_unregister_doc(
             struct leptris_document*);
         leptris_root_doc_unregister_doc(doc);
     }

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

@@ -9,6 +9,19 @@
 #ifndef LEPTRIS_INTERNAL_H
 #define LEPTRIS_INTERNAL_H
 
+/* Internal entry points must not leak into the shared-library ABI.
+ * Windows already hides them (no __declspec(dllexport)) and macOS
+ * build flags hide non-exported globals, but plain ELF keeps
+ * default visibility — leptris_set_error escaped into the Linux
+ * dynamic table while being absent from the PE exports, which no
+ * cross-platform FFI mirror can attach against (#1197 release
+ * cascade). */
+#if defined(_WIN32) || !(defined(__GNUC__) || defined(__clang__))
+#define LEPTRIS_LOCAL
+#else
+#define LEPTRIS_LOCAL __attribute__((visibility("hidden")))
+#endif
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -104,6 +117,8 @@ struct leptris_mut_attr_block {
     char bytes[];
 };
 
+struct LeptrisDiag;
+
 struct leptris_document {
     struct leptris_element* root;             /* Root element (legacy API) */
     /* Snapshot of this document's last failing parse message
@@ -111,6 +126,13 @@ struct leptris_document {
      * thread-local channel). */
     char last_error_message[256];
 
+    /* Recover-class parse diagnostics (#1200): the DOM parse's
+     * parity surface with the SAX lane's recover errors. Pool-free
+     * list (leptris_diag_* owns it); released in document_free. */
+    struct LeptrisDiag* parse_diags;
+    int parse_diag_count;
+    int parse_diag_cap;
+
     /* EXSLT-style extension pack enabled via leptris_exslt_enable
      * (TODO.concurrency/06). */
     int exslt_enabled;
@@ -883,7 +905,7 @@ static inline int leptris_strcmp(const char* s1, const char* s2) {
  * ============================================================================ */
 
 /* Set error with basic message */
-void leptris_set_error(leptris_error_code code, const char* message);
+LEPTRIS_LOCAL void leptris_set_error(leptris_error_code code, const char* message);
 
 /* Set error with line/column position */
 void leptris_set_parse_error_position(int line, int column);

data/vendor-src/libleptris/src/leptris/sax/pull.c

@@ -8,6 +8,7 @@
  * by the slice, not the document. All event strings are owned by the
  * puller and remain valid until the NEXT leptris_pull_next call. */
 #include "../../include/leptris/sax/sax.h"
+#include "sax_internal.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,6 +23,11 @@ typedef struct pull_event {
     /* START_ELEMENT attributes: owned flat copies [n1,v1,n2,v2...] */
     char** attrs;
     size_t attr_count;
+    /* One-shot buffer pulls (TODO.max-perf/2-3 slice 1): strings
+     * borrow the sax parser's stable storage (input buffer + scratch,
+     * alive until parser free) — queue_reset_event frees only the
+     * attrs array itself. */
+    int borrowed;
 } pull_event;
 
 struct leptris_pull_parser {
@@ -57,9 +63,14 @@ struct leptris_pull_parser {
 };
 
 static void queue_reset_event(pull_event* e) {
-    free(e->name); free(e->text);
+    if (!e->borrowed) {
+        free(e->name);
+        free(e->text);
+    }
     if (e->attrs) {
-        for (size_t i = 0; i < e->attr_count * 2; i++) free(e->attrs[i]);
+        if (!e->borrowed)
+            for (size_t i = 0; i < e->attr_count * 2; i++)
+                free(e->attrs[i]);
         free(e->attrs);
     }
     memset(e, 0, sizeof(*e));
@@ -73,6 +84,18 @@ static char* pull_strdup_n(const char* s, size_t n) {
     return c;
 }
 
+/* Event strings: borrow in one-shot mode (stable until parser free),
+ * strdup otherwise (streaming file mode — the source chunk dies at
+ * the next feed). */
+static char* ev_string(pull_event* e, const struct leptris_pull_parser* p,
+                       const char* s, size_t n) {
+    if (p->sax->one_shot) {
+        e->borrowed = 1;
+        return (char*)(s ? s : "");
+    }
+    return pull_strdup_n(s ? s : "", n);
+}
+
 static pull_event* queue_push(struct leptris_pull_parser* p) {
     size_t used = (p->tail + p->cap - p->head) % p->cap;
     if (used + 1 == p->cap) {   /* full: grow */
@@ -104,16 +127,25 @@ static void cb_start_element(void* ud, const char* name, const char** attrs) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_START_ELEMENT;
-    e->name = pull_strdup_n(name, strlen(name));
+    e->name = ev_string(e, p, name, strlen(name));
     if (attrs) {
         size_t n = 0;
         while (attrs[n]) n += 2;   /* flat [name, value, ..., NULL] */
         e->attr_count = n / 2;
         e->attrs = (char**)calloc(n + 1, sizeof(char*));
         if (e->attrs) {
-            for (size_t i = 0; i < n; i++)
-                e->attrs[i] = pull_strdup_n(attrs[i] ? attrs[i] : "",
-                                            attrs[i] ? strlen(attrs[i]) : 0);
+            if (p->sax->one_shot) {
+                /* Names/values are frame/scratch-owned (parser
+                 * lifetime); the array itself stays queue-owned. */
+                e->borrowed = 1;
+                for (size_t i = 0; i < n; i++)
+                    e->attrs[i] = (char*)(attrs[i] ? attrs[i] : "");
+            } else {
+                for (size_t i = 0; i < n; i++)
+                    e->attrs[i] = pull_strdup_n(
+                        attrs[i] ? attrs[i] : "",
+                        attrs[i] ? strlen(attrs[i]) : 0);
+            }
         }
     }
 }
@@ -123,7 +155,7 @@ static void cb_end_element(void* ud, const char* name) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_END_ELEMENT;
-    e->name = pull_strdup_n(name, strlen(name));
+    e->name = ev_string(e, p, name, strlen(name));
 }
 
 static void cb_characters(void* ud, const char* text, size_t len) {
@@ -131,7 +163,10 @@ static void cb_characters(void* ud, const char* text, size_t len) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_TEXT;
-    e->text = pull_strdup_n(text, len);
+    /* Text spans are raw input-buffer slices — no NUL terminator in
+     * stable storage, so they always copy even in one-shot mode
+     * (the public event contract is NUL-terminated strings). */
+    e->text = pull_strdup_n(text ? text : "", len);
     e->text_len = len;
 }
 
@@ -140,7 +175,7 @@ static void cb_comment(void* ud, const char* comment) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_COMMENT;
-    e->text = pull_strdup_n(comment, strlen(comment));
+    e->text = ev_string(e, p, comment, strlen(comment));
     e->text_len = strlen(comment);
 }
 
@@ -149,7 +184,7 @@ static void cb_cdata(void* ud, const char* cdata) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_CDATA;
-    e->text = pull_strdup_n(cdata, strlen(cdata));
+    e->text = ev_string(e, p, cdata, strlen(cdata));
     e->text_len = strlen(cdata);
 }
 
@@ -158,9 +193,9 @@ static void cb_pi(void* ud, const char* target, const char* data) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_PI;
-    e->name = pull_strdup_n(target, strlen(target));
+    e->name = ev_string(e, p, target, strlen(target));
     if (data) {
-        e->text = pull_strdup_n(data, strlen(data));
+        e->text = ev_string(e, p, data, strlen(data));
         e->text_len = strlen(data);
     }
 }
@@ -177,9 +212,9 @@ static void cb_start_prefix(void* ud, const char* prefix, const char* uri) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_START_PREFIX;
-    e->name = pull_strdup_n(prefix ? prefix : "",
-                            prefix ? strlen(prefix) : 0);
-    e->text = pull_strdup_n(uri ? uri : "", uri ? strlen(uri) : 0);
+    e->name = ev_string(e, p, prefix ? prefix : "",
+                        prefix ? strlen(prefix) : 0);
+    e->text = ev_string(e, p, uri ? uri : "", uri ? strlen(uri) : 0);
     e->text_len = uri ? strlen(uri) : 0;
 }
 
@@ -188,8 +223,8 @@ static void cb_end_prefix(void* ud, const char* prefix) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_END_PREFIX;
-    e->name = pull_strdup_n(prefix ? prefix : "",
-                            prefix ? strlen(prefix) : 0);
+    e->name = ev_string(e, p, prefix ? prefix : "",
+                        prefix ? strlen(prefix) : 0);
 }
 
 static void cb_error(void* ud, const char* message, int line, int column) {
@@ -240,6 +275,10 @@ LEPTRIS_API LeptrisPullParser leptris_pull_new(const char* xml, size_t len) {
     if (!p) return NULL;
     p->input = xml;
     p->len = len;
+    /* Memory source: single-feed parse — enable the one-shot fast
+     * paths (TODO.max-perf/2-3 slice 1). File mode keeps the
+     * chunked-streaming paths. */
+    leptris_sax_parser_set_one_shot(p->sax, 1);
     return p;
 }
 
@@ -279,8 +318,13 @@ LEPTRIS_API const LeptrisPullEvent* leptris_pull_next(LeptrisPullParser pull) {
             chunk_ptr = pull->file_buf;
             is_final = (chunk < PULL_SLICE);
         } else {
+            /* In-memory source: the whole buffer is caller-owned and
+             * resident, so slicing buys nothing — ONE feed makes the
+             * parse one-shot (no token ever straddles a chunk
+             * boundary), the precondition for zero-copy slice
+             * emission (TODO.max-perf/2-3, slice 1). File mode keeps
+             * the bounded-memory slicing. */
             chunk = pull->len - pull->pos;
-            if (chunk > PULL_SLICE) chunk = PULL_SLICE;
             chunk_ptr = pull->input + pull->pos;
             pull->pos += chunk;
             is_final = pull->pos == pull->len;

data/vendor-src/libleptris/src/leptris/sax/sax_internal.h

@@ -154,6 +154,13 @@ struct LeptrisSAXParser {
      * state machine. */
     int    streaming;
 
+    /* One-shot parse (TODO.max-perf/2-3 slice 1): the whole input
+     * arrives in a single feed and stays alive for the parser's
+     * lifetime (pull buffer mode). Tokens can never straddle a
+     * chunk boundary, so name scans run in place with one direct
+     * copy into the frame instead of carry+scratch+frame. */
+    int    one_shot;
+
     /* Emitted start_document once we've committed to parsing --
      * used to avoid emitting twice across feed() calls. */
     int    start_emitted;