makiri 0.2.0 → 0.4.0

data/ext/makiri/xpath/mkr_xpath_number.c

@@ -0,0 +1,109 @@
+/* mkr_xpath_number.c - XPath 1.0 Number parsing, grammar-exact and
+ * locale-independent.
+ *
+ * The Number production is `Digits ('.' Digits?)? | '.' Digits` - no sign, no
+ * exponent, no hex, decimal point only. C strtod accepts a superset of that
+ * (hex floats, exponents, INF/NAN words) and honours LC_NUMERIC, so the engine
+ * never hands strtod an unscanned buffer: the extent scanner below bounds the
+ * exact grammar bytes first, and the converter parses only those.
+ *
+ * This file is the ONE home of strtod in the engine (the lexer and the
+ * string->number coercion both come through here). It is compiled once and is
+ * representation-independent: it never touches a DOM node, only bytes.
+ */
+#include "mkr_xpath_internal.h"
+#include "../core/mkr_core.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+static inline int
+mkr_is_ascii_digit(int c)
+{
+  return c >= '0' && c <= '9';
+}
+
+size_t
+mkr_xpath_number_extent(const char *p, size_t len)
+{
+  /* All reads through the bounded span: mkr_span_peek is -1 past the end, so
+   * mkr_is_ascii_digit fails closed there and no scan can leave [p, p+len). */
+  mkr_span_t s = mkr_span(p, len);
+  const char *start = mkr_span_mark(&s);
+
+  if (mkr_is_ascii_digit(mkr_span_peek(&s))) {
+    /* Digits ('.' Digits?)?  -> "5", "5.", "5.5" */
+    while (mkr_is_ascii_digit(mkr_span_peek(&s))) mkr_span_skip(&s, 1);
+    if (mkr_span_peek(&s) == '.') {
+      mkr_span_skip(&s, 1);
+      while (mkr_is_ascii_digit(mkr_span_peek(&s))) mkr_span_skip(&s, 1);
+    }
+    return mkr_span_since(&s, start);
+  }
+  if (mkr_span_peek(&s) == '.') {
+    /* '.' Digits  -> ".5"  (a bare "." is NOT a Number) */
+    mkr_span_skip(&s, 1);
+    if (!mkr_is_ascii_digit(mkr_span_peek(&s))) return 0;
+    while (mkr_is_ascii_digit(mkr_span_peek(&s))) mkr_span_skip(&s, 1);
+    return mkr_span_since(&s, start);
+  }
+  return 0;
+}
+
+/* Allocation-free, locale-independent assembly of the (already grammar-checked)
+ * extent. Reached only when LC_NUMERIC != C makes the libc '.' parse fail, or
+ * when the isolating reparse copy can't be allocated (OOM). This corner trades
+ * correctly-rounded parsing for locale independence and never-failing: it builds
+ * the value digit-by-digit (libxml2-precision-class), so it can never raise and
+ * never mis-classifies the grammar. */
+static double
+mkr_xpath_number_manual(const char *p, size_t extent)
+{
+  double v = 0.0;
+  size_t i = 0;
+  for (; i < extent && p[i] >= '0' && p[i] <= '9'; i++) {
+    v = v * 10.0 + (double)(p[i] - '0');
+  }
+  if (i < extent && p[i] == '.') {
+    i++;
+    double scale = 1.0;
+    for (; i < extent && p[i] >= '0' && p[i] <= '9'; i++) {
+      scale /= 10.0;
+      v += (double)(p[i] - '0') * scale;
+    }
+  }
+  return v;
+}
+
+double
+mkr_xpath_number_from_extent(const char *p, size_t extent)
+{
+  if (p == NULL || extent == 0) return (double)NAN;
+
+  /* Fast path (the hot, common case): the engine text contract NUL-terminates
+   * the buffer at/after p+extent, so this strtod is bounded and cannot leave the
+   * buffer; in the C locale it parses exactly the grammar bytes - the extent
+   * holds no sign/exponent/hex/INF/NAN for strtod to over-consume. When it
+   * consumed precisely `extent` bytes we are done, with no allocation. */
+  char *end = NULL;
+  double v = strtod(p, &end);
+  if (end != NULL && (size_t)(end - p) == extent) return v;
+
+  /* Disagreement. Either strtod consumed MORE (a number-like continuation abuts
+   * the extent in the surrounding buffer, e.g. "1e3" / "0x10" where only "1" /
+   * "0" is the Number) - excluded by the grammar - or LESS (a comma-decimal
+   * LC_NUMERIC stopped at '.'). Reparse exactly the extent in isolation. The
+   * copy is made ONLY here, off the hot path. */
+  char *copy = mkr_strndup(p, extent);
+  if (copy != NULL) {
+    char *cend = NULL;
+    double cv = strtod(copy, &cend);
+    int full = (cend != NULL && (size_t)(cend - copy) == extent);
+    free(copy);
+    if (full) return cv;
+    /* parsed but stopped short -> LC_NUMERIC '.' failure: fall through. */
+  }
+  /* OOM on the copy, or the locale '.' failure: assemble by hand (no alloc), so
+   * we fail closed rather than turning an OOM into a NaN or a raise. */
+  return mkr_xpath_number_manual(p, extent);
+}

data/ext/makiri/xpath/mkr_xpath_parse.c

@@ -35,7 +35,7 @@ P_strndup(mkr_parser_t *P, const char *s, size_t n)
 
 /* strndup into an owned-text AST slot (node-test name, literal, varref/fncall
  * name). Returns 0 on success, -1 on OOM (P->err set, slot left {NULL,0}).
- * Callers MUST propagate the failure — a {NULL,0} slot left in the AST would
+ * Callers MUST propagate the failure - a {NULL,0} slot left in the AST would
  * silently mis-compare at evaluation, so the parse fails closed instead. The
  * stored length lets the evaluator compare names without a per-node strlen.
  * `text` is a slice of the already-validated expr buffer, so the copy is valid. */
@@ -64,19 +64,12 @@ P_eat(mkr_parser_t *P, mkr_tok_kind_t k, const char *what)
   return P_advance(P);
 }
 
-/* AST node allocator. Counts against max_ast_nodes and reports both
- * OOM and LIMIT distinctly. */
+/* AST node allocator - the shared mkr_node_alloc with this parser's limits/err
+ * (counts against max_ast_nodes, reports OOM and LIMIT distinctly). */
 static mkr_node_t *
 new_node(mkr_parser_t *P, mkr_nk_t kind)
 {
-  if (mkr_limit_ast_node(P->limits, P->err) != 0) return NULL;
-  mkr_node_t *n = mkr_callocarray(1, sizeof(*n));
-  if (n == NULL) {
-    mkr_err_set(P->err, MKR_XPATH_ERR_OOM, "out of memory allocating AST node");
-    return NULL;
-  }
-  n->kind = kind;
-  return n;
+  return mkr_node_alloc(P->limits, P->err, kind);
 }
 
 /* ---------- axis lookup ---------- */
@@ -84,7 +77,7 @@ new_node(mkr_parser_t *P, mkr_nk_t kind)
 static int
 axis_by_name(const char *s, size_t n, mkr_axis_t *out)
 {
-#define A(name, val) do { if (n == sizeof(name)-1 && memcmp(s, name, n) == 0) { *out = val; return 1; } } while (0)
+#define A(name, val) do { if (mkr_bytes_eq(s, n, name, sizeof(name)-1)) { *out = val; return 1; } } while (0)
   A("child",                MKR_AXIS_CHILD);
   A("descendant",           MKR_AXIS_DESCENDANT);
   A("parent",               MKR_AXIS_PARENT);
@@ -105,10 +98,10 @@ axis_by_name(const char *s, size_t n, mkr_axis_t *out)
 static int
 is_nodetype_name(const char *s, size_t n)
 {
-  return (n == 4 && memcmp(s, "node", 4) == 0)
-      || (n == 4 && memcmp(s, "text", 4) == 0)
-      || (n == 7 && memcmp(s, "comment", 7) == 0)
-      || (n == 22 && memcmp(s, "processing-instruction", 22) == 0);
+  return mkr_bytes_eq(s, n, "node", 4)
+      || mkr_bytes_eq(s, n, "text", 4)
+      || mkr_bytes_eq(s, n, "comment", 7)
+      || mkr_bytes_eq(s, n, "processing-instruction", 22);
 }
 
 /* ---------- forward decls ---------- */
@@ -146,6 +139,31 @@ make_implicit_step(mkr_step_t *out, mkr_axis_t axis, mkr_nt_kind_t nt_kind)
   return 0;
 }
 
+/* Parse a run of `('/' | '//') Step` continuations onto the step array,
+ * expanding each `//` to an implicit descendant-or-self::node() step. TOK(P)
+ * must be positioned at the (possible) leading separator; a non-separator token
+ * makes this a no-op (zero iterations). On failure the steps pushed so far stay
+ * in the array - the caller's owning node frees them (the path/filter node, via
+ * mkr_node_free). This is the single home for the slash-step loop that the
+ * relative-path, absolute `//`, and filter-expr trailing-path forms all share. */
+static int
+parse_step_tail(mkr_parser_t *P, mkr_step_t **steps, size_t *nsteps, size_t *cap)
+{
+  while (TOK(P).kind == MKR_TK_SLASH || TOK(P).kind == MKR_TK_DSLASH) {
+    int dslash = (TOK(P).kind == MKR_TK_DSLASH);
+    if (P_advance(P) != 0) return -1;
+    if (dslash) {
+      mkr_step_t implicit;
+      make_implicit_step(&implicit, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
+      if (push_step(P, steps, nsteps, cap, implicit) != 0) return -1;
+    }
+    mkr_step_t next = {0};
+    if (parse_step(P, &next) != 0) return -1;
+    if (push_step(P, steps, nsteps, cap, next) != 0) { mkr_step_clear(&next); return -1; }
+  }
+  return 0;
+}
+
 /* ---------- node-test parsing ---------- */
 
 /*
@@ -173,9 +191,9 @@ parse_node_test(mkr_parser_t *P, mkr_axis_t axis, mkr_nodetest_t *out)
       if (P_advance(P) != 0) return -1;
       if (TOK(P).kind == MKR_TK_LPAREN) {
         if (P_advance(P) != 0) return -1;
-        if      (saved.text.len == 4 && memcmp(saved.text.ptr, "node", 4)    == 0) out->kind = MKR_NT_NODE;
-        else if (saved.text.len == 4 && memcmp(saved.text.ptr, "text", 4)    == 0) out->kind = MKR_NT_TEXT;
-        else if (saved.text.len == 7 && memcmp(saved.text.ptr, "comment", 7) == 0) out->kind = MKR_NT_COMMENT;
+        if      (mkr_bytes_eq(saved.text.ptr, saved.text.len, "node", 4))    out->kind = MKR_NT_NODE;
+        else if (mkr_bytes_eq(saved.text.ptr, saved.text.len, "text", 4))    out->kind = MKR_NT_TEXT;
+        else if (mkr_bytes_eq(saved.text.ptr, saved.text.len, "comment", 7)) out->kind = MKR_NT_COMMENT;
         else /* processing-instruction */ {
           out->kind = MKR_NT_PI;
           if (TOK(P).kind == MKR_TK_LITERAL) {
@@ -198,14 +216,15 @@ parse_node_test(mkr_parser_t *P, mkr_axis_t axis, mkr_nodetest_t *out)
   }
 
   if (TOK(P).kind == MKR_TK_QNAME) {
-    /* QName name test: `prefix:local` or `prefix:*` — split at the colon. */
+    /* QName name test: `prefix:local` or `prefix:*` - split at the colon. */
     const char *s = TOK(P).text.ptr;
     size_t      n = TOK(P).text.len;
-    size_t      colon = 0;
-    while (colon < n && s[colon] != ':') colon++;
+    mkr_span_t  sp = mkr_span(s, n);
+    size_t      colon;
+    if (!mkr_span_find(&sp, ':', &colon)) colon = n;
     if (P_fill_owned_text(P, mkr_borrowed_text(s, colon), &out->prefix) != 0) return -1;
     if (n - colon - 1 == 1 && s[colon + 1] == '*') {
-      /* prefix:* — any element in the prefix's namespace. */
+      /* prefix:* - any element in the prefix's namespace. */
       out->kind = MKR_NT_WILDCARD;
     } else {
       out->kind  = MKR_NT_NAME;
@@ -249,8 +268,25 @@ parse_predicates(mkr_parser_t *P, mkr_node_t ***preds, size_t *npreds)
 
 /* ---------- step ---------- */
 
+static int parse_step_inner(mkr_parser_t *P, mkr_step_t *out);
+
+/* Parse one Step into *out. On failure *out is CLEARED here - a failing
+ * parse_step_inner can leave a partially-built step behind (an owned name-test
+ * text already strndup'd, predicates already pushed) and the callers all just
+ * bail, so freeing the partial step in one place keeps every error path
+ * leak-free without per-call-site cleanup. */
 static int
 parse_step(mkr_parser_t *P, mkr_step_t *out)
+{
+  if (parse_step_inner(P, out) == 0) {
+    return 0;
+  }
+  mkr_step_clear(out);
+  return -1;
+}
+
+static int
+parse_step_inner(mkr_parser_t *P, mkr_step_t *out)
 {
   memset(out, 0, sizeof(*out));
 
@@ -292,9 +328,9 @@ parse_step(mkr_parser_t *P, mkr_step_t *out)
        * but without re-consuming (we already advanced). */
       if (is_nodetype_name(saved.text.ptr, saved.text.len) && TOK(P).kind == MKR_TK_LPAREN) {
         if (P_advance(P) != 0) return -1;
-        if      (saved.text.len == 4 && memcmp(saved.text.ptr, "node", 4)    == 0) out->test.kind = MKR_NT_NODE;
-        else if (saved.text.len == 4 && memcmp(saved.text.ptr, "text", 4)    == 0) out->test.kind = MKR_NT_TEXT;
-        else if (saved.text.len == 7 && memcmp(saved.text.ptr, "comment", 7) == 0) out->test.kind = MKR_NT_COMMENT;
+        if      (mkr_bytes_eq(saved.text.ptr, saved.text.len, "node", 4))    out->test.kind = MKR_NT_NODE;
+        else if (mkr_bytes_eq(saved.text.ptr, saved.text.len, "text", 4))    out->test.kind = MKR_NT_TEXT;
+        else if (mkr_bytes_eq(saved.text.ptr, saved.text.len, "comment", 7)) out->test.kind = MKR_NT_COMMENT;
         else {
           out->test.kind = MKR_NT_PI;
           if (TOK(P).kind == MKR_TK_LITERAL) {
@@ -330,19 +366,7 @@ parse_relative_path(mkr_parser_t *P, mkr_step_t **steps, size_t *nsteps)
   if (parse_step(P, &s) != 0) return -1;
   if (push_step(P, steps, nsteps, &cap, s) != 0) { mkr_step_clear(&s); return -1; }
 
-  while (TOK(P).kind == MKR_TK_SLASH || TOK(P).kind == MKR_TK_DSLASH) {
-    int dslash = (TOK(P).kind == MKR_TK_DSLASH);
-    if (P_advance(P) != 0) return -1;
-    if (dslash) {
-      mkr_step_t implicit;
-      make_implicit_step(&implicit, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
-      if (push_step(P, steps, nsteps, &cap, implicit) != 0) return -1;
-    }
-    mkr_step_t next = {0};
-    if (parse_step(P, &next) != 0) return -1;
-    if (push_step(P, steps, nsteps, &cap, next) != 0) { mkr_step_clear(&next); return -1; }
-  }
-  return 0;
+  return parse_step_tail(P, steps, nsteps, &cap);
 }
 
 /* Returns 1 if the current token can begin a Step. */
@@ -373,28 +397,11 @@ parse_location_path(mkr_parser_t *P)
     return n;
   }
   if (TOK(P).kind == MKR_TK_DSLASH) {
+    /* '//' = '/descendant-or-self::node()/'. Leave TOK at the DSLASH so the
+     * shared loop expands it (implicit step + the following step) itself. */
     n->u.path.absolute = 1;
-    if (P_advance(P) != 0) goto fail;
-    /* '//' = '/descendant-or-self::node()/' */
     size_t cap = 0;
-    mkr_step_t implicit;
-    make_implicit_step(&implicit, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
-    if (push_step(P, &n->u.path.steps, &n->u.path.nsteps, &cap, implicit) != 0) goto fail;
-    mkr_step_t s = {0};
-    if (parse_step(P, &s) != 0) goto fail;
-    if (push_step(P, &n->u.path.steps, &n->u.path.nsteps, &cap, s) != 0) { mkr_step_clear(&s); goto fail; }
-    while (TOK(P).kind == MKR_TK_SLASH || TOK(P).kind == MKR_TK_DSLASH) {
-      int dslash = (TOK(P).kind == MKR_TK_DSLASH);
-      if (P_advance(P) != 0) goto fail;
-      if (dslash) {
-        mkr_step_t imp2;
-        make_implicit_step(&imp2, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
-        if (push_step(P, &n->u.path.steps, &n->u.path.nsteps, &cap, imp2) != 0) goto fail;
-      }
-      mkr_step_t s2 = {0};
-      if (parse_step(P, &s2) != 0) goto fail;
-      if (push_step(P, &n->u.path.steps, &n->u.path.nsteps, &cap, s2) != 0) { mkr_step_clear(&s2); goto fail; }
-    }
+    if (parse_step_tail(P, &n->u.path.steps, &n->u.path.nsteps, &cap) != 0) goto fail;
     return n;
   }
   /* Relative location path. */
@@ -423,8 +430,9 @@ parse_function_call(mkr_parser_t *P, mkr_token_t name_tok)
   if (n == NULL) return NULL;
 
   if (name_tok.kind == MKR_TK_QNAME) {
-    size_t colon = 0;
-    while (colon < name_tok.text.len && name_tok.text.ptr[colon] != ':') colon++;
+    mkr_span_t sp = mkr_span(name_tok.text.ptr, name_tok.text.len);
+    size_t colon;
+    if (!mkr_span_find(&sp, ':', &colon)) colon = name_tok.text.len;
     if (P_fill_owned_text(P, mkr_borrowed_text(name_tok.text.ptr, colon), &n->u.fncall.prefix) != 0) goto fail;
     if (P_fill_owned_text(P, mkr_borrowed_text(name_tok.text.ptr + colon + 1, name_tok.text.len - colon - 1), &n->u.fncall.name) != 0) goto fail;
   } else {
@@ -469,8 +477,9 @@ parse_primary(mkr_parser_t *P)
     n = new_node(P, MKR_NK_VARREF);
     if (n == NULL) return NULL;
     if (TOK(P).kind == MKR_TK_QNAME) {
-      size_t colon = 0;
-      while (colon < TOK(P).text.len && TOK(P).text.ptr[colon] != ':') colon++;
+      mkr_span_t sp = mkr_span(TOK(P).text.ptr, TOK(P).text.len);
+      size_t colon;
+      if (!mkr_span_find(&sp, ':', &colon)) colon = TOK(P).text.len;
       if (P_fill_owned_text(P, mkr_borrowed_text(TOK(P).text.ptr, colon), &n->u.varref.prefix) != 0) { mkr_node_free(n); return NULL; }
       if (P_fill_owned_text(P, mkr_borrowed_text(TOK(P).text.ptr + colon + 1, TOK(P).text.len - colon - 1), &n->u.varref.name) != 0) { mkr_node_free(n); return NULL; }
     } else {
@@ -533,30 +542,12 @@ parse_filter_expr(mkr_parser_t *P)
     mkr_node_free(f);
     return NULL;
   }
-  if (TOK(P).kind == MKR_TK_SLASH || TOK(P).kind == MKR_TK_DSLASH) {
-    int dslash = (TOK(P).kind == MKR_TK_DSLASH);
-    if (P_advance(P) != 0) { mkr_node_free(f); return NULL; }
-    size_t cap = 0;
-    if (dslash) {
-      mkr_step_t implicit;
-      make_implicit_step(&implicit, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
-      if (push_step(P, &f->u.filter.path_steps, &f->u.filter.npath, &cap, implicit) != 0) { mkr_node_free(f); return NULL; }
-    }
-    mkr_step_t s = {0};
-    if (parse_step(P, &s) != 0) { mkr_node_free(f); return NULL; }
-    if (push_step(P, &f->u.filter.path_steps, &f->u.filter.npath, &cap, s) != 0) { mkr_step_clear(&s); mkr_node_free(f); return NULL; }
-    while (TOK(P).kind == MKR_TK_SLASH || TOK(P).kind == MKR_TK_DSLASH) {
-      int dd = (TOK(P).kind == MKR_TK_DSLASH);
-      if (P_advance(P) != 0) { mkr_node_free(f); return NULL; }
-      if (dd) {
-        mkr_step_t imp2;
-        make_implicit_step(&imp2, MKR_AXIS_DESCENDANT_OR_SELF, MKR_NT_NODE);
-        if (push_step(P, &f->u.filter.path_steps, &f->u.filter.npath, &cap, imp2) != 0) { mkr_node_free(f); return NULL; }
-      }
-      mkr_step_t s2 = {0};
-      if (parse_step(P, &s2) != 0) { mkr_node_free(f); return NULL; }
-      if (push_step(P, &f->u.filter.path_steps, &f->u.filter.npath, &cap, s2) != 0) { mkr_step_clear(&s2); mkr_node_free(f); return NULL; }
-    }
+  /* Optional trailing location path (e.g. `$x/foo`, `(expr)//bar`). The shared
+   * loop is a no-op when no separator follows, so call it unconditionally. */
+  size_t cap = 0;
+  if (parse_step_tail(P, &f->u.filter.path_steps, &f->u.filter.npath, &cap) != 0) {
+    mkr_node_free(f);
+    return NULL;
   }
   return f;
 }
@@ -581,10 +572,8 @@ looks_like_filter_expr(mkr_parser_t *P)
     if (TOK(P).kind == MKR_TK_NAME && is_nodetype_name(s, n)) {
       return 0;
     }
-    /* peek next char (skipping ws) for '(' — cheaper than running the lexer. */
-    const char *p = P->L.cur;
-    while (*p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++;
-    return (*p == '(');
+    /* peek next byte (skipping ws) for '(' - cheaper than running the lexer. */
+    return (mkr_lexer_peek_nonws(&P->L) == '(');
   }
   default:
     return 0;
@@ -787,8 +776,8 @@ mkr_parse(mkr_verified_text_t expr, mkr_xpath_limits_t *limits, mkr_xpath_error_
   mkr_parser_t P;
   P.err    = err;
   P.limits = limits;
-  /* expr.ptr is a validated, NUL-terminated C string (mkr_verified_text_t). */
-  mkr_lexer_init(&P.L, expr.ptr, err);
+  /* expr is a validated, NUL-terminated text of known length (mkr_verified_text_t). */
+  mkr_lexer_init(&P.L, expr.ptr, expr.len, err);
   if (!P.L.good) return NULL;
 
   mkr_node_t *root = parse_expr(&P);
@@ -804,7 +793,7 @@ mkr_parse(mkr_verified_text_t expr, mkr_xpath_limits_t *limits, mkr_xpath_error_
    * pass so the latter sees the rewritten step structure. */
   mkr_apply_peephole(root);
   /* Static hoisting pass: marks subtrees that can be memoized during
-   * eval. Cheap (single AST walk) and runs once per parse — cached by
+   * eval. Cheap (single AST walk) and runs once per parse - cached by
    * the wrapper-level AST cache. */
   mkr_mark_context_independent(root);
   return root;

data/ext/makiri/xpath/mkr_xpath_prelude_html.h

@@ -0,0 +1,30 @@
+/* mkr_xpath_prelude_html.h - HTML engine-instance prelude.
+ *
+ * Included at the top of mkr_xpath_engine_html.c BEFORE the engine bodies,
+ * symmetric with mkr_xpath_prelude_xml.h. It binds the DOM types + the
+ * MKR_NODE_* node-access contract to Lexbor's lxb_dom, so the bodies compile
+ * against lxb_dom.
+ *
+ * The engine's internals are file-static (one merged TU per instance), so they
+ * never collide with the XML instance and need no renaming. Only the two
+ * node-dereferencing ENTRY points the driver dispatches on are external; the
+ * prelude suffixes them _html so they coexist with the XML instance's _xml
+ * pair. (mkr_xpath.c declares both and selects by engine_kind.) */
+#ifndef MKR_XPATH_PRELUDE_HTML_H
+#define MKR_XPATH_PRELUDE_HTML_H
+
+#include <lexbor/dom/dom.h>
+
+/* DOM types -> Lexbor (the type counterpart of MKR_NODE_*). */
+#define MKR_DOM_NODE     lxb_dom_node_t
+#define MKR_DOM_ELEMENT  lxb_dom_element_t
+#define MKR_DOM_ATTR     lxb_dom_attr_t
+#define MKR_DOM_DOCUMENT lxb_dom_document_t
+
+/* The two external entry points (the only symbols not file-static). */
+#define mkr_eval_ast        mkr_eval_ast_html
+#define mkr_try_first_match mkr_try_first_match_html
+
+#include "mkr_xpath_node_access_html.h"   /* MKR_NODE_* for lxb_dom */
+
+#endif /* MKR_XPATH_PRELUDE_HTML_H */

data/ext/makiri/xpath/mkr_xpath_prelude_xml.h

@@ -0,0 +1,28 @@
+/* mkr_xpath_prelude_xml.h - XML engine-instance prelude.
+ *
+ * Included at the top of mkr_xpath_engine_xml.c BEFORE the engine bodies. It
+ * binds the DOM types + MKR_NODE_* node-access contract to the custom
+ * mkr_xml_node_t (and selects the engine's XML host-policy via MKR_HOST_XML in
+ * the node-access header), so the same bodies compile for XML.
+ *
+ * The engine's internals are file-static (one merged TU per instance), so they
+ * coexist with the HTML instance without renaming. Only the two
+ * node-dereferencing ENTRY points the driver dispatches on are external; the
+ * prelude suffixes them _xml (the HTML prelude suffixes the same pair _html).
+ */
+#ifndef MKR_XPATH_PRELUDE_XML_H
+#define MKR_XPATH_PRELUDE_XML_H
+
+/* DOM types -> the custom node (the type counterpart of MKR_NODE_*). */
+#define MKR_DOM_NODE     mkr_xml_node_t
+#define MKR_DOM_ELEMENT  mkr_xml_node_t
+#define MKR_DOM_ATTR     mkr_xml_node_t
+#define MKR_DOM_DOCUMENT mkr_xml_doc_t
+
+/* The two external entry points (the only symbols not file-static). */
+#define mkr_eval_ast        mkr_eval_ast_xml
+#define mkr_try_first_match mkr_try_first_match_xml
+
+#include "mkr_xpath_node_access_xml.h"   /* MKR_NODE_* + MKR_HOST_XML for the custom node */
+
+#endif /* MKR_XPATH_PRELUDE_XML_H */