makiri 0.2.0 → 0.4.0

data/ext/makiri/xpath/mkr_xpath_lex.c

@@ -2,46 +2,20 @@
 
 #include <ctype.h>
 #include <stdint.h>
-#include <stdlib.h>
 #include <string.h>
 
 /*
  * XPath 1.0 lexer. The parser drives token consumption and handles
  * context-sensitive keywords (and, or, div, mod, *, node()...) via
- * lookahead — the lexer is intentionally context-free.
+ * lookahead - the lexer is intentionally context-free.
+ *
+ * All input reads go through the bounded reader (core mkr_span_t): the input
+ * is a verified text (NUL-free, NUL-terminated, valid UTF-8) of known length,
+ * and the span makes an out-of-bounds read structurally impossible rather
+ * than a per-site convention. One-codepoint decoding is the strict core
+ * mkr_utf8_decode1 (the lexer formerly carried its own equivalent copy).
  */
 
-/* Decode one UTF-8 code point at NUL-terminated +p+. Returns its byte length
- * (1-4) and writes the code point to *cp; returns 0 at the terminator or on a
- * malformed/truncated/overlong/surrogate/out-of-range sequence (fail closed).
- * Never reads past the NUL: a NUL where a continuation byte is expected fails
- * the (b & 0xC0) == 0x80 check. */
-static int
-utf8_decode(const char *p, uint32_t *cp)
-{
-  const unsigned char *u = (const unsigned char *)p;
-  unsigned char b0 = u[0];
-  if (b0 < 0x80) { *cp = b0; return b0 == 0 ? 0 : 1; }
-
-  int n;
-  uint32_t c, min;
-  if      ((b0 & 0xE0) == 0xC0) { n = 1; c = b0 & 0x1Fu; min = 0x80; }
-  else if ((b0 & 0xF0) == 0xE0) { n = 2; c = b0 & 0x0Fu; min = 0x800; }
-  else if ((b0 & 0xF8) == 0xF0) { n = 3; c = b0 & 0x07u; min = 0x10000; }
-  else return 0; /* continuation byte or 0xF8+ as a lead: invalid */
-
-  for (int i = 1; i <= n; i++) {
-    unsigned char b = u[i];
-    if ((b & 0xC0) != 0x80) return 0; /* truncated (incl. NUL) or bad continuation */
-    c = (c << 6) | (b & 0x3Fu);
-  }
-  if (c < min) return 0;                      /* overlong */
-  if (c >= 0xD800 && c <= 0xDFFF) return 0;   /* surrogate */
-  if (c > 0x10FFFF) return 0;                 /* out of Unicode range */
-  *cp = c;
-  return n + 1;
-}
-
 /* NCName code-point classes per XPath 1.0 §3.7 -> Namespaces in XML -> the
  * XML 1.0 (5th ed.) Name production, minus ':' (NCName). NameStartChar and
  * the extra NameChar ranges; this is the definition browsers / libxml2 track. */
@@ -67,109 +41,92 @@ is_ncname_cont_cp(uint32_t c)
       || (c >= 0x0300 && c <= 0x036F) || (c >= 0x203F && c <= 0x2040);
 }
 
-/* If +p+ begins an NCName character, return its byte length (1-4); else 0.
- * +start+ selects the NameStartChar (1) vs NameChar (0) class. */
+/* If the span's cursor (+off bytes) begins an NCName character, return its
+ * byte length (1-4); else 0 (including at end-of-input - the strict decode
+ * fails closed there). +start+ selects NameStartChar (1) vs NameChar (0). */
 static int
-ncname_char(const char *p, int start)
+ncname_char(const mkr_span_t *in, size_t off, int start)
 {
+  mkr_span_t s = mkr_span_tail(in, off);
   uint32_t cp;
-  int len = utf8_decode(p, &cp);
+  int len = mkr_utf8_decode1_span(&s, &cp);
   if (len == 0) return 0;
   return (start ? is_ncname_start_cp(cp) : is_ncname_cont_cp(cp)) ? len : 0;
 }
 
-static void
-skip_ws(mkr_lexer_t *L)
-{
-  /* XPath 1.0 §3.7 ExprWhitespace = XML S = (#x20 | #x9 | #xD | #xA)+ only.
-   * Not C isspace(), which would also skip #xB (\v) and #xC (\f) — those are
-   * not XPath whitespace and must surface as a syntax error. */
-  char c;
-  while ((c = *L->cur) == ' ' || c == '\t' || c == '\r' || c == '\n') L->cur++;
-}
-
 static int
 lex_number(mkr_lexer_t *L, mkr_token_t *t, mkr_xpath_error_t *err)
 {
-  const char *s = L->cur;
-  char *end = NULL;
-  double v = strtod(s, &end);
-  if (end == s) {
-    mkr_err_setf(err, MKR_XPATH_ERR_SYNTAX, "expected number at '%.10s'", s);
+  /* Grammar-exact Number lex: the audited shared helpers scan and convert ONLY
+   * the bytes matching XPath 1.0 `Digits ('.' Digits?)? | '.' Digits`. We hand
+   * the helper a mark+length slice of the bounded reader (the sanctioned
+   * parser-TU pattern); it stays C-locale, so "0x1A" lexes as NUMBER 0 then NAME
+   * "x1A" and "1e3" as NUMBER 1 then NAME "e3", matching libxml2 / browsers. No
+   * raw scan (no strtod) remains in this TU. */
+  const char *mark = mkr_span_mark(&L->in);
+  size_t extent = mkr_xpath_number_extent(mark, mkr_span_left(&L->in));
+  if (extent == 0) {
+    mkr_err_setf(err, MKR_XPATH_ERR_SYNTAX, "expected number at '%.10s'", mark);
     return -1;
   }
-  t->kind  = MKR_TK_NUMBER;
-  t->text.ptr = s;
-  t->text.len   = (size_t)(end - s);
-  t->num   = v;
-  L->cur   = end;
+  t->kind     = MKR_TK_NUMBER;
+  t->text.ptr = mark;
+  t->text.len = extent;
+  t->num      = mkr_xpath_number_from_extent(mark, extent);
+  mkr_span_skip(&L->in, extent);
   return 0;
 }
 
-/* Is [s, s+len) well-formed UTF-8? Strict (same rules as utf8_decode: rejects
- * malformed/overlong/surrogate/out-of-range). */
-static int
-utf8_valid_range(const char *s, size_t len)
-{
-  const char *p = s, *e = s + len;
-  while (p < e) {
-    uint32_t cp;
-    int n = utf8_decode(p, &cp);
-    if (n <= 0 || (size_t)n > (size_t)(e - p)) return 0;
-    p += n;
-  }
-  return 1;
-}
-
 static int
 lex_string(mkr_lexer_t *L, mkr_token_t *t, mkr_xpath_error_t *err)
 {
-  char quote = *L->cur;
-  const char *start = L->cur + 1;
-  const char *p = start;
-  while (*p && *p != quote) p++;
-  if (*p != quote) {
+  int quote = mkr_span_peek(&L->in);
+  mkr_span_skip(&L->in, 1);
+  const char *start = mkr_span_mark(&L->in);
+  size_t len;
+  if (!mkr_span_find(&L->in, (char)quote, &len)) {
     mkr_err_set(err, MKR_XPATH_ERR_SYNTAX, "unterminated string literal");
     return -1;
   }
   /* Validate UTF-8 here, once, so every character-wise string function
    * (translate, substring, string-length, ...) can assume well-formed input
    * and so an invalid literal fails closed (SyntaxError) rather than producing
-   * a silently wrong/truncated result. */
-  size_t len = (size_t)(p - start);
-  if (!utf8_valid_range(start, len)) {
+   * a silently wrong/truncated result. The strict core validator applies the
+   * same rules (overlong/surrogate/out-of-range rejected) as the strict
+   * decoder the rest of the lexer uses. */
+  if (!mkr_utf8_valid((const unsigned char *)start, len)) {
     mkr_err_set(err, MKR_XPATH_ERR_SYNTAX, "invalid UTF-8 in string literal");
     return -1;
   }
   t->kind  = MKR_TK_LITERAL;
   t->text.ptr = start;
   t->text.len   = len;
-  L->cur   = p + 1;
+  mkr_span_skip(&L->in, len + 1);   /* content + closing quote */
   return 0;
 }
 
 static int
 lex_name(mkr_lexer_t *L, mkr_token_t *t)
 {
-  const char *s = L->cur;
+  const char *s = mkr_span_mark(&L->in);
   int n;
-  while ((n = ncname_char(L->cur, 0)) > 0) L->cur += n;
+  while ((n = ncname_char(&L->in, 0, 0)) > 0) mkr_span_skip(&L->in, (size_t)n);
   /* QName NameTest is `prefix:local` OR `prefix:*` (XPath 1.0 §2.3); the ':'
    * must not be the '::' axis separator. */
-  if (*L->cur == ':' && L->cur[1] != ':'
-      && (L->cur[1] == '*' || ncname_char(L->cur + 1, 1) > 0)) {
-    L->cur++; /* eat ':' */
-    if (*L->cur == '*') {
-      L->cur++; /* prefix:* */
+  if (mkr_span_peek(&L->in) == ':' && mkr_span_at(&L->in, 1) != ':'
+      && (mkr_span_at(&L->in, 1) == '*' || ncname_char(&L->in, 1, 1) > 0)) {
+    mkr_span_skip(&L->in, 1); /* eat ':' */
+    if (mkr_span_peek(&L->in) == '*') {
+      mkr_span_skip(&L->in, 1); /* prefix:* */
     } else {
-      while ((n = ncname_char(L->cur, 0)) > 0) L->cur += n;
+      while ((n = ncname_char(&L->in, 0, 0)) > 0) mkr_span_skip(&L->in, (size_t)n);
     }
     t->kind = MKR_TK_QNAME;
   } else {
     t->kind = MKR_TK_NAME;
   }
   t->text.ptr = s;
-  t->text.len   = (size_t)(L->cur - s);
+  t->text.len   = mkr_span_since(&L->in, s);
   return 0;
 }
 
@@ -177,45 +134,46 @@ static int
 next_token(mkr_lexer_t *L, mkr_token_t *t, mkr_xpath_error_t *err)
 {
   memset(t, 0, sizeof(*t));
-  skip_ws(L);
-  const char *s = L->cur;
-  char c = *s;
+  mkr_span_skip_xpath_ws(&L->in);  /* XPath S only - see mkr_xpath_is_ws */
+  const char *s = mkr_span_mark(&L->in);
+  int c = mkr_span_peek(&L->in);
 
-  if (c == '\0') {
+  if (c < 0) {
     t->kind = MKR_TK_EOF;
     t->text.ptr = s;
     t->text.len = 0;
     return 0;
   }
 
-  if (c == '/' && s[1] == '/') { t->kind = MKR_TK_DSLASH;     t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
-  if (c == '.' && s[1] == '.') { t->kind = MKR_TK_DOTDOT;     t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
-  if (c == ':' && s[1] == ':') { t->kind = MKR_TK_COLONCOLON; t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
-  if (c == '!' && s[1] == '=') { t->kind = MKR_TK_NE;         t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
-  if (c == '<' && s[1] == '=') { t->kind = MKR_TK_LE;         t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
-  if (c == '>' && s[1] == '=') { t->kind = MKR_TK_GE;         t->text.ptr = s; t->text.len = 2; L->cur += 2; return 0; }
+  int c1 = mkr_span_at(&L->in, 1);
+  if (c == '/' && c1 == '/') { t->kind = MKR_TK_DSLASH;     t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
+  if (c == '.' && c1 == '.') { t->kind = MKR_TK_DOTDOT;     t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
+  if (c == ':' && c1 == ':') { t->kind = MKR_TK_COLONCOLON; t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
+  if (c == '!' && c1 == '=') { t->kind = MKR_TK_NE;         t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
+  if (c == '<' && c1 == '=') { t->kind = MKR_TK_LE;         t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
+  if (c == '>' && c1 == '=') { t->kind = MKR_TK_GE;         t->text.ptr = s; t->text.len = 2; mkr_span_skip(&L->in, 2); return 0; }
 
   switch (c) {
-  case '(': t->kind = MKR_TK_LPAREN;   t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case ')': t->kind = MKR_TK_RPAREN;   t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '[': t->kind = MKR_TK_LBRACKET; t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case ']': t->kind = MKR_TK_RBRACKET; t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
+  case '(': t->kind = MKR_TK_LPAREN;   t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case ')': t->kind = MKR_TK_RPAREN;   t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '[': t->kind = MKR_TK_LBRACKET; t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case ']': t->kind = MKR_TK_RBRACKET; t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
   case '.':
-    if (isdigit((unsigned char)s[1])) {
+    if (c1 >= 0 && isdigit(c1)) {
       return lex_number(L, t, err);
     }
-    t->kind = MKR_TK_DOT; t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '@': t->kind = MKR_TK_AT;       t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case ',': t->kind = MKR_TK_COMMA;    t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '|': t->kind = MKR_TK_PIPE;     t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '/': t->kind = MKR_TK_SLASH;    t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '+': t->kind = MKR_TK_PLUS;     t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '-': t->kind = MKR_TK_MINUS;    t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '*': t->kind = MKR_TK_STAR;     t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '=': t->kind = MKR_TK_EQ;       t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '<': t->kind = MKR_TK_LT;       t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '>': t->kind = MKR_TK_GT;       t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
-  case '$': t->kind = MKR_TK_DOLLAR;   t->text.ptr = s; t->text.len = 1; L->cur++; return 0;
+    t->kind = MKR_TK_DOT; t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '@': t->kind = MKR_TK_AT;       t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case ',': t->kind = MKR_TK_COMMA;    t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '|': t->kind = MKR_TK_PIPE;     t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '/': t->kind = MKR_TK_SLASH;    t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '+': t->kind = MKR_TK_PLUS;     t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '-': t->kind = MKR_TK_MINUS;    t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '*': t->kind = MKR_TK_STAR;     t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '=': t->kind = MKR_TK_EQ;       t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '<': t->kind = MKR_TK_LT;       t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '>': t->kind = MKR_TK_GT;       t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
+  case '$': t->kind = MKR_TK_DOLLAR;   t->text.ptr = s; t->text.len = 1; mkr_span_skip(&L->in, 1); return 0;
   case '\'':
   case '"':
     return lex_string(L, t, err);
@@ -223,27 +181,25 @@ next_token(mkr_lexer_t *L, mkr_token_t *t, mkr_xpath_error_t *err)
     break;
   }
 
-  if (isdigit((unsigned char)c)) {
+  if (isdigit(c)) {
     return lex_number(L, t, err);
   }
-  if (ncname_char(s, 1) > 0) {
+  if (ncname_char(&L->in, 0, 1) > 0) {
     return lex_name(L, t);
   }
 
-  unsigned char uc = (unsigned char)c;
-  if (uc >= 0x20 && uc < 0x7F) {
+  if (c >= 0x20 && c < 0x7F) {
     mkr_err_setf(err, MKR_XPATH_ERR_SYNTAX, "unexpected character '%c'", c);
   } else {
-    mkr_err_setf(err, MKR_XPATH_ERR_SYNTAX, "unexpected byte 0x%02x", uc);
+    mkr_err_setf(err, MKR_XPATH_ERR_SYNTAX, "unexpected byte 0x%02x", (unsigned)c);
   }
   return -1;
 }
 
 void
-mkr_lexer_init(mkr_lexer_t *L, const char *src, mkr_xpath_error_t *err)
+mkr_lexer_init(mkr_lexer_t *L, const char *src, size_t len, mkr_xpath_error_t *err)
 {
-  L->src = src;
-  L->cur = src;
+  L->in  = mkr_span(src, len);
   memset(&L->tok, 0, sizeof(L->tok));
   L->good = (next_token(L, &L->tok, err) == 0);
 }
@@ -255,6 +211,20 @@ mkr_lexer_advance(mkr_lexer_t *L, mkr_xpath_error_t *err)
   return L->good ? 0 : -1;
 }
 
+/* The next non-whitespace byte after the current token (or -1 at the end),
+ * without consuming anything - the parser's function-call lookahead ("is this
+ * NAME followed by '('?"), kept here so the raw cursor never leaves the lexer. */
+int
+mkr_lexer_peek_nonws(const mkr_lexer_t *L)
+{
+  mkr_span_t s = L->in;
+  for (;;) {
+    int c = mkr_span_peek(&s);
+    if (mkr_xpath_is_ws(c)) { mkr_span_skip(&s, 1); continue; }
+    return c;
+  }
+}
+
 int
 mkr_tok_is_word_len(const mkr_token_t *t, const char *word, size_t word_len)
 {

data/ext/makiri/xpath/mkr_xpath_node_access_html.h

@@ -0,0 +1,138 @@
+/* mkr_xpath_node_access_html.h - node-access contract for the XPath engine.
+ *
+ * The engine's per-node work (navigation, name tests, namespace tests) is
+ * expressed through these MKR_NODE_* / MKR_ELEM_* macros instead of touching a
+ * concrete node struct directly. This lets the same engine logic be compiled
+ * for two node representations with ZERO runtime dispatch (compile-time
+ * monomorphization - measured ~0% vs direct field reads, whereas a runtime
+ * kind-branch costs ~+150%; see tmp/xml_spike/accessor_perf.c and
+ * docs/xml_parser_plan.ja.md §2.5):
+ *
+ *   - HTML: this header, accessors → lxb_dom_node_t fields / Lexbor lookups.
+ *   - XML (planned, §8.5): a sibling header binding the same macros to the
+ *     custom mkr_xml_node_t, then `#include`-ing the shared engine body.
+ *
+ * For the HTML instance every macro expands to exactly the field read / call
+ * the engine used before, so the compiled object code (and `rake bench`) is
+ * unchanged by construction. Node-type numeric values are shared between the
+ * representations (the custom XML node reuses LXB_DOM_NODE_TYPE_* values), so
+ * the type switches in the engine stay representation-neutral.
+ */
+#ifndef MKR_XPATH_NODE_ACCESS_HTML_H
+#define MKR_XPATH_NODE_ACCESS_HTML_H
+
+#include <lexbor/dom/dom.h>
+#include <lexbor/ns/ns.h>
+
+/* (The DOM node handle for this instance is lxb_dom_node_t; the XML instance
+ * will bind these macros to mkr_xml_node_t. No engine-wide typedef here - the
+ * engine already uses mkr_node_t for its XPath AST node.) */
+
+/* --- neutral node-type constants ---
+ * The shared engine body compares MKR_NODE_TYPE(n) against these instead of a
+ * representation-specific name, so the body is representation-neutral. This is
+ * the per-instance binding: the HTML instance maps the neutral names to Lexbor's
+ * LXB_DOM_NODE_TYPE_*; the XML instance (mkr_xpath_node_access_xml.h) maps the
+ * same names to MKR_XML_NODE_TYPE_*. The two encodings are asserted equal there,
+ * so the integer in a node's `type` field means the same thing to either
+ * instance (byte-identical codegen for HTML).
+ *
+ * NB: named MKR_NTYPE_* (node *type*), distinct from the engine's existing
+ * mkr_nt_kind_t enum MKR_NT_* (node *test* kinds: text()/comment()/pi()/...).
+ * An earlier MKR_NT_* name collided with that enum and broke //comment() etc. */
+#define MKR_NTYPE_ELEMENT            LXB_DOM_NODE_TYPE_ELEMENT
+#define MKR_NTYPE_ATTRIBUTE          LXB_DOM_NODE_TYPE_ATTRIBUTE
+#define MKR_NTYPE_TEXT               LXB_DOM_NODE_TYPE_TEXT
+#define MKR_NTYPE_CDATA_SECTION      LXB_DOM_NODE_TYPE_CDATA_SECTION
+#define MKR_NTYPE_COMMENT            LXB_DOM_NODE_TYPE_COMMENT
+#define MKR_NTYPE_PI                 LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION
+#define MKR_NTYPE_DOCUMENT_TYPE      LXB_DOM_NODE_TYPE_DOCUMENT_TYPE
+#define MKR_NTYPE_ENTITY             LXB_DOM_NODE_TYPE_ENTITY
+#define MKR_NTYPE_ENTITY_REFERENCE   LXB_DOM_NODE_TYPE_ENTITY_REFERENCE
+#define MKR_NTYPE_NOTATION           LXB_DOM_NODE_TYPE_NOTATION
+
+/* --- type / namespace-id (numeric, shared values) --- */
+#define MKR_NODE_TYPE(n)          ((n)->type)
+#define MKR_NODE_NS_ID(n)         ((n)->ns)
+
+/* --- navigation (return the node handle for this instance) --- */
+#define MKR_NODE_FIRST_CHILD(n)   ((n)->first_child)
+#define MKR_NODE_LAST_CHILD(n)    ((n)->last_child)
+#define MKR_NODE_NEXT(n)          ((n)->next)
+#define MKR_NODE_PREV(n)          ((n)->prev)
+#define MKR_NODE_PARENT(n)        ((n)->parent)
+
+/* --- element / attribute handles & iteration --- */
+#define MKR_NODE_AS_ELEMENT(n)    lxb_dom_interface_element(n)   /* node -> element handle */
+#define MKR_ELEM_FIRST_ATTR(el)   ((el)->first_attr)
+#define MKR_ATTR_NEXT(a)          ((a)->next)
+#define MKR_ATTR_VALUE(a, lenp)   lxb_dom_attr_value((a), (lenp)) /* borrowed value bytes */
+
+/* Strict element name tests resolve in the HTML namespace, so a foreign
+ * (non-HTML, non-null) element namespace is a non-match. The XML instance will
+ * redefine this against its own namespace representation. */
+#define MKR_NODE_IS_FOREIGN_NS(n) \
+    ((n)->ns != LXB_NS_HTML && (n)->ns != LXB_NS__UNDEF)
+
+/* --- name lookups (return borrowed lxb_char_t* bytes, set *(lenp)) --- */
+#define MKR_ELEM_LOCAL_NAME(n, lenp) \
+    lxb_dom_element_local_name((lxb_dom_element_t *)(n), (lenp))
+#define MKR_ATTR_LOCAL_NAME(n, lenp) \
+    lxb_dom_attr_local_name((lxb_dom_attr_t *)(n), (lenp))
+/* Borrowed qualified name of any node: HTML elements report their lowercase
+ * local name (the lowercase-tag HTML data model the engine assumes, matching
+ * Makiri::Node#name); every other kind defers to lxb_dom_node_name. The XML
+ * binding returns the node's contiguous qname instead. */
+static inline const lxb_char_t *
+mkr_html_node_name_qualified(lxb_dom_node_t *node, size_t *len)
+{
+    if (node == NULL) { if (len) *len = 0; return NULL; }
+    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+        return lxb_dom_element_qualified_name(lxb_dom_interface_element(node), len);
+    }
+    return lxb_dom_node_name(node, len);
+}
+#define MKR_ELEM_QUALIFIED_NAME(n, lenp) \
+    mkr_html_node_name_qualified((n), (lenp))
+#define MKR_ATTR_QUALIFIED_NAME(n, lenp) \
+    lxb_dom_attr_qualified_name((lxb_dom_attr_t *)(n), (lenp))
+#define MKR_NODE_PI_NAME(n, lenp) \
+    lxb_dom_node_name((n), (lenp))
+
+/* element attribute value by (raw) name; returns borrowed bytes or NULL. */
+#define MKR_ELEM_GET_ATTRIBUTE(el, name, nlen, vlenp) \
+    lxb_dom_element_get_attribute((el), (const lxb_char_t *)(name), (nlen), (vlenp))
+
+/* --- per-instance services (resolved against the concrete representation) ---
+ * The engine body uses these instead of calling Lexbor directly, so the XML
+ * instance can bind them to the custom node (which carries ns_uri / value
+ * directly and has no Lexbor ns hash / tag table). */
+
+/* Borrowed namespace-URI bytes for a node (or NULL, *lenp=0, if it has none).
+ * HTML resolves the node's ns-id against the document's ns hash. */
+static inline const char *
+mkr_html_node_ns_uri(lxb_dom_node_t *node, lxb_dom_document_t *doc, size_t *lenp)
+{
+    *lenp = 0;
+    if (node->ns == LXB_NS__UNDEF || doc == NULL || doc->ns == NULL) return NULL;
+    return (const char *)lxb_ns_by_id(doc->ns, node->ns, lenp);
+}
+#define MKR_NODE_NS_URI(node, doc, lenp) mkr_html_node_ns_uri((node), (doc), (lenp))
+
+/* Append a node's own text content to a mkr_buf_t, setting `st` (mkr_status_t).
+ * HTML uses lxb_dom_node_text_content (allocates; freed after the append). */
+#define MKR_NODE_APPEND_OWN_TEXT(node, buf, st)                              \
+    do {                                                                     \
+        size_t mkr__tlen = 0;                                                \
+        lxb_char_t *mkr__t = lxb_dom_node_text_content((node), &mkr__tlen);  \
+        (st) = (mkr__t == NULL) ? MKR_OK : mkr_buf_append((buf), mkr__t, mkr__tlen); \
+        if (mkr__t) lxb_dom_document_destroy_text((node)->owner_document, mkr__t); \
+    } while (0)
+
+/* Resolve a tag-name to a Lexbor tag id for the //tag element-index fast path.
+ * Only ever reached when the element index is present (HTML); for XML the index
+ * is NULL so the fast path bails before this, but it must still compile. */
+#define MKR_DOC_TAG_ID_BY_NAME(doc, ptr, len) \
+    lxb_tag_id_by_name((doc)->tags, (const lxb_char_t *)(ptr), (len))
+
+#endif /* MKR_XPATH_NODE_ACCESS_HTML_H */

data/ext/makiri/xpath/mkr_xpath_node_access_xml.h

@@ -0,0 +1,145 @@
+/* mkr_xpath_node_access_xml.h - node-access contract bound to the custom XML node.
+ *
+ * The XML counterpart of mkr_xpath_node_access_html.h: it binds the MKR_NODE_* / MKR_ELEM_*
+ * field-access macros + per-instance services to mkr_xml_node_t, so the shared
+ * XPath engine body (mkr_xpath_*_body.h) compiles for XML with zero runtime
+ * dispatch (§2.5). MKR_HOST_XML selects the engine's XML host-policy branches
+ * (name-test matching, §8.6). The custom node carries its namespace URI and a
+ * contiguous "prefix:local" qname directly, so there is no ns hash / tag table.
+ */
+#ifndef MKR_XPATH_NODE_ACCESS_XML_H
+#define MKR_XPATH_NODE_ACCESS_XML_H
+
+#include <lexbor/dom/dom.h>          /* for the MKR_XML_NODE_TYPE_* == LXB asserts + lxb_char_t */
+#include "../xml/mkr_xml_node.h"
+#include "../core/mkr_span.h"        /* mkr_bytes_eq / mkr_span_starts (this header is
+                                      * included before mkr_core.h in the XML engine TU) */
+#include <string.h>
+
+#define MKR_HOST_XML 1
+
+/* Bind the engine's neutral node-type names to the XML representation's own
+ * constants (the html binding maps the same names to LXB_DOM_NODE_TYPE_*). */
+#define MKR_NTYPE_ELEMENT            MKR_XML_NODE_TYPE_ELEMENT
+#define MKR_NTYPE_ATTRIBUTE          MKR_XML_NODE_TYPE_ATTRIBUTE
+#define MKR_NTYPE_TEXT               MKR_XML_NODE_TYPE_TEXT
+#define MKR_NTYPE_CDATA_SECTION      MKR_XML_NODE_TYPE_CDATA_SECTION
+#define MKR_NTYPE_COMMENT            MKR_XML_NODE_TYPE_COMMENT
+#define MKR_NTYPE_PI                 MKR_XML_NODE_TYPE_PI
+#define MKR_NTYPE_DOCUMENT_TYPE      MKR_XML_NODE_TYPE_DOCUMENT_TYPE
+#define MKR_NTYPE_ENTITY             MKR_XML_NODE_TYPE_ENTITY
+#define MKR_NTYPE_ENTITY_REFERENCE   MKR_XML_NODE_TYPE_ENTITY_REFERENCE
+#define MKR_NTYPE_NOTATION           MKR_XML_NODE_TYPE_NOTATION
+
+/* The whole monomorphization rests on the two representations agreeing on the
+ * node-type encoding (so a node's `type` integer means the same thing whichever
+ * instance walks it). Enforce that agreement at compile time rather than by
+ * comment - the XML constants must equal the Lexbor ones. */
+_Static_assert((int)MKR_XML_NODE_TYPE_ELEMENT == (int)LXB_DOM_NODE_TYPE_ELEMENT,                "node-type encoding drift: ELEMENT");
+_Static_assert((int)MKR_XML_NODE_TYPE_ATTRIBUTE == (int)LXB_DOM_NODE_TYPE_ATTRIBUTE,              "node-type encoding drift: ATTRIBUTE");
+_Static_assert((int)MKR_XML_NODE_TYPE_TEXT == (int)LXB_DOM_NODE_TYPE_TEXT,                   "node-type encoding drift: TEXT");
+_Static_assert((int)MKR_XML_NODE_TYPE_CDATA_SECTION == (int)LXB_DOM_NODE_TYPE_CDATA_SECTION,          "node-type encoding drift: CDATA_SECTION");
+_Static_assert((int)MKR_XML_NODE_TYPE_ENTITY_REFERENCE == (int)LXB_DOM_NODE_TYPE_ENTITY_REFERENCE,       "node-type encoding drift: ENTITY_REFERENCE");
+_Static_assert((int)MKR_XML_NODE_TYPE_ENTITY == (int)LXB_DOM_NODE_TYPE_ENTITY,                 "node-type encoding drift: ENTITY");
+_Static_assert((int)MKR_XML_NODE_TYPE_PI == (int)LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION, "node-type encoding drift: PI");
+_Static_assert((int)MKR_XML_NODE_TYPE_COMMENT == (int)LXB_DOM_NODE_TYPE_COMMENT,                "node-type encoding drift: COMMENT");
+_Static_assert((int)MKR_XML_NODE_TYPE_DOCUMENT == (int)LXB_DOM_NODE_TYPE_DOCUMENT,               "node-type encoding drift: DOCUMENT");
+_Static_assert((int)MKR_XML_NODE_TYPE_DOCUMENT_TYPE == (int)LXB_DOM_NODE_TYPE_DOCUMENT_TYPE,          "node-type encoding drift: DOCUMENT_TYPE");
+_Static_assert((int)MKR_XML_NODE_TYPE_NOTATION == (int)LXB_DOM_NODE_TYPE_NOTATION,               "node-type encoding drift: NOTATION");
+
+/* type / synthetic namespace-id (1 = has a namespace, 0 = none). */
+#define MKR_NODE_TYPE(n)          ((n)->type)
+#define MKR_NODE_NS_ID(n)         ((n)->ns_uri_len ? 1u : 0u)
+
+/* navigation */
+#define MKR_NODE_FIRST_CHILD(n)   ((n)->first_child)
+#define MKR_NODE_LAST_CHILD(n)    ((n)->last_child)
+#define MKR_NODE_NEXT(n)          ((n)->next)
+#define MKR_NODE_PREV(n)          ((n)->prev)
+#define MKR_NODE_PARENT(n)        ((n)->parent)
+
+/* element / attribute handles & iteration - the node IS its own element handle;
+ * attributes are a sibling-linked list off the element's `attrs`.
+ *
+ * Host policy (§8.6): a namespace declaration (xmlns / xmlns:*) is a NAMESPACE
+ * node in XPath 1.0, NOT an attribute, so it must not appear on the attribute
+ * axis (an unprefixed-wildcard attribute test, count of attributes, etc. ignore
+ * it). The reader still keeps it as a DOM attribute node (Node#attribute_nodes /
+ * Node#[] read el->attrs directly, in glue), matching DOM Level 2; only the
+ * XPath attribute iteration skips it. So the engine's MKR_ELEM_FIRST_ATTR /
+ * MKR_ATTR_NEXT advance past ns declarations, and every attribute-axis consumer
+ * (walk, predicates, doc-order) inherits that. The iterators take const and
+ * yield mutable (like strchr), so const callers (the doc-order comparator) and
+ * mutable ones share one implementation. */
+#define MKR_NODE_AS_ELEMENT(n)    (n)
+
+static inline int
+mkr_xml_attr_is_ns_decl(const mkr_xml_node_t *a)
+{
+    mkr_span_t q = mkr_span(a->qname, a->qname_len);
+    return mkr_bytes_eq(a->qname, a->qname_len, "xmlns", 5)   /* exact "xmlns" */
+        || mkr_span_starts(&q, "xmlns:", 6);                  /* "xmlns:*" prefix */
+}
+static inline mkr_xml_node_t *
+mkr_xml_first_xpath_attr(const mkr_xml_node_t *el)
+{
+    const mkr_xml_node_t *a = el->attrs;
+    while (a != NULL && mkr_xml_attr_is_ns_decl(a)) a = a->next;
+    return (mkr_xml_node_t *)a;
+}
+static inline mkr_xml_node_t *
+mkr_xml_next_xpath_attr(const mkr_xml_node_t *a)
+{
+    for (a = a->next; a != NULL && mkr_xml_attr_is_ns_decl(a); a = a->next) { }
+    return (mkr_xml_node_t *)a;
+}
+#define MKR_ELEM_FIRST_ATTR(el)   mkr_xml_first_xpath_attr(el)
+#define MKR_ATTR_NEXT(a)          mkr_xml_next_xpath_attr(a)
+#define MKR_ATTR_VALUE(a, lenp)   (*(lenp) = (a)->value_len, (const lxb_char_t *)(a)->value)
+
+/* Strict unprefixed element name tests must match a no-namespace node only, so a
+ * node with any namespace URI is "foreign" to an unprefixed test (§8.6). */
+#define MKR_NODE_IS_FOREIGN_NS(n) ((n)->ns_uri_len != 0)
+
+/* name lookups (borrowed bytes; the qname is the contiguous "prefix:local"). */
+#define MKR_ELEM_LOCAL_NAME(n, lenp)     (*(lenp) = (n)->local_len, (const lxb_char_t *)(n)->local)
+#define MKR_ATTR_LOCAL_NAME(n, lenp)     (*(lenp) = (n)->local_len, (const lxb_char_t *)(n)->local)
+#define MKR_ELEM_QUALIFIED_NAME(n, lenp) (*(lenp) = (n)->qname_len, (const lxb_char_t *)(n)->qname)
+#define MKR_ATTR_QUALIFIED_NAME(n, lenp) (*(lenp) = (n)->qname_len, (const lxb_char_t *)(n)->qname)
+#define MKR_NODE_PI_NAME(n, lenp)        (*(lenp) = (n)->local_len, (const lxb_char_t *)(n)->local)
+
+/* element attribute value by (raw, qualified) name; borrowed bytes or NULL. */
+static inline const lxb_char_t *
+mkr_xml_node_get_attribute(mkr_xml_node_t *el, const char *name, size_t nlen, size_t *vlenp)
+{
+    for (mkr_xml_node_t *a = el->attrs; a != NULL; a = a->next) {
+        if (mkr_xml_attr_is_ns_decl(a)) continue;   /* xmlns is a namespace node, not @attr */
+        if (mkr_bytes_eq(a->qname, a->qname_len, name, nlen)) {
+            *vlenp = a->value_len;
+            return (const lxb_char_t *)a->value;
+        }
+    }
+    *vlenp = 0;
+    return NULL;
+}
+#define MKR_ELEM_GET_ATTRIBUTE(el, name, nlen, vlenp) \
+    mkr_xml_node_get_attribute((el), (const char *)(name), (nlen), (vlenp))
+
+/* --- per-instance services (the custom node carries these directly) --- */
+
+/* Namespace URI bytes (borrowed) or NULL (len 0) if the node is in no namespace.
+ * +doc+ is unused: the node holds the resolved URI. */
+#define MKR_NODE_NS_URI(node, doc, lenp) \
+    (*(lenp) = (node)->ns_uri_len, (node)->ns_uri_len ? (node)->ns_uri : NULL)
+
+/* Append a node's own text content (its value slice) to a mkr_buf_t. */
+#define MKR_NODE_APPEND_OWN_TEXT(node, buf, st)                                \
+    (st) = ((node)->value_len                                                  \
+              ? mkr_buf_append((buf), (const lxb_char_t *)(node)->value, (node)->value_len) \
+              : MKR_OK)
+
+/* No tag-id table on the XML document; the //tag element-index fast path is
+ * never enabled for XML (the element index is NULL), so this is unreachable. */
+#define MKR_DOC_TAG_ID_BY_NAME(doc, ptr, len) LXB_TAG__UNDEF
+
+#endif /* MKR_XPATH_NODE_ACCESS_XML_H */