makiri 0.2.0 → 0.4.0

data/ext/makiri/xpath/mkr_css.h

@@ -0,0 +1,65 @@
+#ifndef MKR_CSS_H
+#define MKR_CSS_H
+
+#include "mkr_xpath.h"   /* mkr_node_t, mkr_xpath_limits_t, mkr_xpath_error_t, mkr_verified_text_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * CSS selector front-end for the native XPath engine.
+ *
+ * Rather than convert CSS to an XPath *string* and re-parse it, this lowers a
+ * CSS selector directly into the engine's compiled AST (the same mkr_node_t that
+ * mkr_parse produces), which is then run by mkr_xpath_eval_compiled[_first].
+ * The whole evaluation - per-evaluate budgets, document order, dedup, namespace
+ * resolution - is therefore shared with XPath, and CSS gains no new evaluator
+ * opcodes: every supported selector lowers to existing PATH/step/predicate nodes
+ * (name tests + contains/starts-with/substring/count/position/not + arithmetic).
+ *
+ * The CSS *parsing* reuses Lexbor's selector parser (which, unlike its matcher,
+ * preserves name case), so this layer only walks the parsed selector list and
+ * builds AST. The result AST is owned by the caller and freed with mkr_node_free,
+ * exactly like an mkr_parse result.
+ *
+ * Namespaces (Nokogiri-compatible): a bare type selector binds to the document's
+ * DEFAULT namespace when one is in scope. The glue collects the in-scope
+ * namespaces (Ruby side, mirroring Nokogiri's `document.namespaces`), registers
+ * them on the context so the engine resolves prefixes at eval, and registers the
+ * default namespace under the synthetic prefix "xmlns" (Nokogiri's convention).
+ * +default_prefix+ is that synthetic prefix ("xmlns") when a default namespace is
+ * in scope, or NULL otherwise; lowering uses it to emit name tests:
+ *   - bare `el`   -> prefix = default_prefix (when set), else no-namespace
+ *   - `p|el`      -> prefix = "p"  (resolved by the engine; unbound -> error)
+ *   - `*|el`      -> any namespace (nodetest wildcard + local-name() predicate)
+ *   - `|el`       -> no namespace
+ */
+/* The synthetic prefix bound to the document's default namespace (Nokogiri's
+ * convention). The glue registers this prefix -> default-ns URI on the context. */
+#define MKR_CSS_DEFAULT_NS_PREFIX "xmlns"
+
+typedef struct {
+  const char *default_prefix; /* MKR_CSS_DEFAULT_NS_PREFIX when a default ns is in scope, else NULL */
+} mkr_css_ns_t;
+
+/*
+ * Compile +selector+ into a freshly allocated AST (caller frees with
+ * mkr_node_free). Returns NULL on error with *err filled:
+ *   MKR_XPATH_ERR_SYNTAX        - malformed selector or an unsupported construct
+ *                                 (jQuery extensions, pseudo-elements, the case
+ *                                 modifier)
+ *   MKR_XPATH_ERR_OOM / _LIMIT  - allocation failure / selector-complexity cap
+ * +ns+ may be NULL (bare selectors then match no-namespace). +limits+ bounds the
+ * AST node count.
+ */
+mkr_node_t *mkr_css_compile(mkr_verified_text_t selector,
+                            const mkr_css_ns_t *ns,
+                            mkr_xpath_limits_t *limits,
+                            mkr_xpath_error_t  *err);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MKR_CSS_H */

data/ext/makiri/xpath/mkr_xpath.c

@@ -9,7 +9,7 @@
 #include <string.h>
 
 /*
- * Native XPath engine — top-level: context lifetime, namespace + variable
+ * Native XPath engine - top-level: context lifetime, namespace + variable
  * registries, the eval entry point that drives parser + evaluator.
  *
  * Phase 1 builds the engine up to a working subset (see plan file).
@@ -27,8 +27,8 @@ typedef struct {
 } mkr_var_entry_t;
 
 struct mkr_xpath_context_s {
-  lxb_dom_document_t *doc;
-  lxb_dom_node_t     *node;
+  MKR_DOM_DOCUMENT *doc;
+  MKR_DOM_NODE     *node;
 
   mkr_ns_entry_t *ns;
   size_t         ns_count;
@@ -60,6 +60,14 @@ struct mkr_xpath_context_s {
   mkr_tag_index_lookup_t   tag_lookup;
   mkr_tag_index_foreign_t  tag_has_foreign;
 
+  /* XML element-name index: the owning document plus a lazy getter and a
+   * string-keyed lookup, injected by the XML glue. NULL disables the
+   * descendant-name fast path (the engine then walks). HTML uses the tag-id
+   * index above instead. */
+  void                    *name_index_owner;
+  mkr_name_index_get_t     name_index_get;
+  mkr_name_index_lookup_t  name_index_lookup;
+
   /* Namespace-matching policy for UNPREFIXED name tests. 0 (default) =
    * strict/HTML5-faithful: an unprefixed name resolves in the HTML namespace
    * (matches HTML-namespace or no-namespace nodes only; foreign SVG/MathML
@@ -67,8 +75,36 @@ struct mkr_xpath_context_s {
    * tests and wildcards are unaffected. Set by the glue from the
    * namespace_matching: option. */
   int unprefixed_lax;
+
+  /* Which monomorphized engine instance walks this context's nodes: 0 = HTML
+   * (lxb_dom), 1 = XML (custom node). Set by the glue at context creation. Only
+   * the two node-dereferencing entries (eval, first-match) dispatch on it; all
+   * other per-evaluate machinery is representation-neutral (pointer/string only),
+   * so it runs the HTML copy for both. */
+  int engine_kind;
 };
 
+/* The two node-dereferencing engine ENTRY points, one pair per monomorphized
+ * instance (mkr_xpath_engine_{html,xml}.c - the bodies suffix them _html / _xml
+ * via the prelude). The driver holds them as void node pointers and dispatches
+ * on ctx->engine_kind; every other per-evaluate helper is representation-neutral
+ * and shared (mkr_xpath_shared.c), called by its bare name. The signatures are
+ * node-pointer-only, hence ABI-identical across the two instances. */
+int mkr_eval_ast_html(mkr_xpath_context_t *ctx, const mkr_node_t *ast,
+                      mkr_val_t *out, mkr_xpath_error_t *err);
+int mkr_eval_ast_xml (mkr_xpath_context_t *ctx, const mkr_node_t *ast,
+                      mkr_val_t *out, mkr_xpath_error_t *err);
+int mkr_try_first_match_html(mkr_xpath_context_t *ctx, const mkr_node_t *ast,
+                             MKR_DOM_NODE **out_node, mkr_xpath_error_t *err);
+int mkr_try_first_match_xml (mkr_xpath_context_t *ctx, const mkr_node_t *ast,
+                             MKR_DOM_NODE **out_node, mkr_xpath_error_t *err);
+
+void
+mkr_xpath_set_engine_kind(mkr_xpath_context_t *ctx, int kind)
+{
+  if (ctx) ctx->engine_kind = kind ? 1 : 0;
+}
+
 mkr_doc_order_index_t *
 mkr_ctx_order_index(mkr_xpath_context_t *ctx)
 {
@@ -104,6 +140,35 @@ mkr_ctx_tag_has_foreign(mkr_xpath_context_t *ctx)
   return ctx ? ctx->tag_has_foreign : NULL;
 }
 
+void
+mkr_xpath_context_set_name_index(mkr_xpath_context_t *ctx, void *owner,
+                                 mkr_name_index_get_t get,
+                                 mkr_name_index_lookup_t lookup)
+{
+  if (ctx == NULL) return;
+  ctx->name_index_owner  = owner;
+  ctx->name_index_get    = get;
+  ctx->name_index_lookup = lookup;
+}
+
+void *
+mkr_ctx_name_index_owner(mkr_xpath_context_t *ctx)
+{
+  return ctx ? ctx->name_index_owner : NULL;
+}
+
+mkr_name_index_get_t
+mkr_ctx_name_index_get(mkr_xpath_context_t *ctx)
+{
+  return ctx ? ctx->name_index_get : NULL;
+}
+
+mkr_name_index_lookup_t
+mkr_ctx_name_index_lookup(mkr_xpath_context_t *ctx)
+{
+  return ctx ? ctx->name_index_lookup : NULL;
+}
+
 mkr_str_cache_t *
 mkr_ctx_str_cache(mkr_xpath_context_t *ctx)
 {
@@ -163,7 +228,7 @@ mkr_xpath_limits_init_defaults(mkr_xpath_limits_t *L)
   L->max_steps           = 256;             /* path step count     */
   L->max_predicates      = 64;              /* per-step predicates */
   L->max_function_args   = 64;
-  L->max_nodeset_size    = 10 * 1000 * 1000; /* 10M nodes — large but bounded */
+  L->max_nodeset_size    = 10 * 1000 * 1000; /* 10M nodes - large but bounded */
   L->max_eval_ops        = 50 * 1000 * 1000; /* 50M evaluator steps */
   L->max_string_bytes    = 64 * 1024 * 1024; /* 64 MB string-value */
   L->max_recursion_depth = 256;
@@ -272,29 +337,10 @@ mkr_limit_check_expr_bytes(mkr_xpath_limits_t *L, size_t bytes, mkr_xpath_error_
 
 /* ---------- node qualified name ---------- */
 
-/*
- * Borrowed qualified name for any node. HTML elements report their
- * lowercase local name (lxb_dom_element_qualified_name), matching
- * Makiri::Node#name and the lowercase-tag HTML data model the engine
- * assumes; every other node kind defers to lxb_dom_node_name.
- */
-const lxb_char_t *
-mkr_dom_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);
-}
-
 /* ---------- context ---------- */
 
 mkr_xpath_context_t *
-mkr_xpath_context_new(lxb_dom_document_t *doc, lxb_dom_node_t *node)
+mkr_xpath_context_new(MKR_DOM_DOCUMENT *doc, MKR_DOM_NODE *node)
 {
   mkr_xpath_context_t *ctx = mkr_callocarray(1, sizeof(*ctx));
   if (ctx == NULL) {
@@ -447,19 +493,19 @@ mkr_ctx_lookup_variable_text(mkr_xpath_context_t *ctx, const char *prefix,
   return 0;
 }
 
-lxb_dom_node_t *
+MKR_DOM_NODE *
 mkr_ctx_node(mkr_xpath_context_t *ctx)
 {
   return ctx ? ctx->node : NULL;
 }
 
 void
-mkr_ctx_set_node(mkr_xpath_context_t *ctx, lxb_dom_node_t *node)
+mkr_ctx_set_node(mkr_xpath_context_t *ctx, MKR_DOM_NODE *node)
 {
   if (ctx) ctx->node = node;
 }
 
-lxb_dom_document_t *
+MKR_DOM_DOCUMENT *
 mkr_ctx_document(mkr_xpath_context_t *ctx)
 {
   return ctx ? ctx->doc : NULL;
@@ -563,7 +609,7 @@ mkr_xpath_eval_compiled(mkr_xpath_context_t *ctx, mkr_node_t *ast,
 
   /* String-value cache snapshot. Nested eval (handler that calls back
    * into XPath on the same context) sees outer entries but anything it
-   * adds is discarded on return — outer borrowed pointers stay valid. */
+   * adds is discarded on return - outer borrowed pointers stay valid. */
   size_t str_cache_snapshot = ctx->str_cache.count;
   /* Document-order index: outermost evaluate owns the lifecycle. If the
    * outer wasn't built, the inner's build (if any) gets cleared at this
@@ -572,13 +618,14 @@ mkr_xpath_eval_compiled(mkr_xpath_context_t *ctx, mkr_node_t *ast,
   int order_was_built = ctx->order_index.built;
 
   mkr_val_t v = {0};
-  int eval_rc = mkr_eval_ast(ctx, ast, &v, &err);
+  int eval_rc = ctx->engine_kind ? mkr_eval_ast_xml(ctx, ast, &v, &err)
+                                 : mkr_eval_ast_html(ctx, ast, &v, &err);
   mkr_str_cache_truncate(&ctx->str_cache, str_cache_snapshot);
   if (!order_was_built && ctx->order_index.built) {
     mkr_doc_order_index_clear(&ctx->order_index);
   }
   /* Clear memoized values regardless of success: they are valid only
-   * within a single evaluate scope. Defensive — also clears on error. */
+   * within a single evaluate scope. Defensive - also clears on error. */
   mkr_node_clear_memos(ast);
   if (eval_rc != 0) {
     if (out_error) *out_error = err; else mkr_xpath_error_clear(&err);
@@ -600,8 +647,25 @@ mkr_xpath_eval_compiled_first(mkr_xpath_context_t *ctx, mkr_node_t *ast,
     }
     return -1;
   }
-  lxb_dom_node_t *node = NULL;
-  if (mkr_try_first_match(ctx, ast, &node)) {
+  /* Reset the per-evaluate counters before the first-match fast path: its
+   * descendant walk charges every visited node to max_eval_ops, so it is
+   * bounded fail-closed exactly like the full evaluator (which resets these in
+   * mkr_xpath_eval_compiled). The not-recognised fallback below resets them
+   * again; the walk only runs for recognised shapes, so nothing double-counts. */
+  ctx->limits.eval_ops        = 0;
+  ctx->limits.recursion_depth = 0;
+
+  MKR_DOM_NODE *node = NULL;
+  mkr_xpath_error_t err = {0};
+  int matched = ctx->engine_kind ? mkr_try_first_match_xml(ctx, ast, &node, &err)
+                                 : mkr_try_first_match_html(ctx, ast, &node, &err);
+  if (matched < 0) {
+    /* Op budget exceeded while walking - fail closed (do NOT fall back to the
+     * full evaluator, which would hit the same wall). */
+    if (out_error) *out_error = err; else mkr_xpath_error_clear(&err);
+    return -1;
+  }
+  if (matched) {
     /* Recognised first-match shape: return a 0-or-1-node node-set without
      * building (or sorting) the full descendant set. */
     mkr_val_t v = {0};

data/ext/makiri/xpath/mkr_xpath.h

@@ -17,7 +17,7 @@ extern "C" {
  *
  * Security: every evaluate enforces per-call budgets (op count, recursion
  * depth, node-set / string caps); any overrun fails closed with
- * MKR_XPATH_ERR_LIMIT — never a truncated or wrong result.
+ * MKR_XPATH_ERR_LIMIT - never a truncated or wrong result.
  */
 
 typedef enum {
@@ -45,7 +45,10 @@ typedef struct {
   mkr_xpath_type_t type;
   union {
     struct {
-      lxb_dom_node_t **nodes;
+      /* Representation-agnostic node pointers: lxb_dom_node_t* for an HTML
+       * document, mkr_xml_node_t* for an XML one. The glue knows the kind and
+       * casts; the engine boundary stays neutral. */
+      void **nodes;
       size_t count;
     } nodeset;
     mkr_owned_text_t string; /* owned; valid when type == MKR_XPATH_TYPE_STRING */
@@ -59,7 +62,10 @@ typedef struct {
   char *message; /* heap-allocated, freed with mkr_xpath_error_free */
 } mkr_xpath_error_t;
 
-mkr_xpath_context_t *mkr_xpath_context_new(lxb_dom_document_t *doc, lxb_dom_node_t *node);
+/* Create a context for +node+ in +doc+ (representation-agnostic void* - the glue
+ * passes lxb_dom_* for HTML, mkr_xml_* for XML; the engine kind is selected via
+ * mkr_xpath_set_engine_kind). */
+mkr_xpath_context_t *mkr_xpath_context_new(void *doc, void *node);
 void                mkr_xpath_context_free(mkr_xpath_context_t *ctx);
 
 int  mkr_xpath_register_ns(mkr_xpath_context_t *ctx, mkr_verified_text_t prefix, mkr_verified_text_t uri);
@@ -108,7 +114,7 @@ void  mkr_xpath_set_func_resolver   (mkr_xpath_context_t *ctx, mkr_func_resolver
 
 /*
  * Element-index hooks, injected by the glue layer alongside an opaque index
- * pointer. The engine never sees the index's concrete type — it only calls
+ * pointer. The engine never sees the index's concrete type - it only calls
  * back through these, exactly as it calls Ruby only through the func resolver
  * above. This keeps the engine free of the lexbor_compat headers.
  *
@@ -129,10 +135,109 @@ void  mkr_xpath_context_set_element_index(mkr_xpath_context_t *ctx, void *index,
                                           mkr_tag_index_lookup_t lookup,
                                           mkr_tag_index_foreign_t has_foreign);
 
+/* XML element-name index hooks (string-keyed; the HTML tag-id index above is
+ * integer-keyed). get(owner) lazily builds + caches the index on the owning
+ * document and returns it (or NULL on OOM -> the engine walks); lookup returns
+ * the document-ordered bucket for (local, ns_uri). Node pointers are void*. */
+typedef void *(*mkr_name_index_get_t)(void *owner);
+typedef void *const *(*mkr_name_index_lookup_t)(const void *index,
+                                                const char *local, size_t local_len,
+                                                const char *ns_uri, size_t ns_uri_len,
+                                                size_t *count);
+void  mkr_xpath_context_set_name_index(mkr_xpath_context_t *ctx, void *owner,
+                                       mkr_name_index_get_t get,
+                                       mkr_name_index_lookup_t lookup);
+
 
 void mkr_xpath_value_clear(mkr_xpath_value_t *v);
 void mkr_xpath_error_clear(mkr_xpath_error_t *e);
 
+/* ------------------------------------------------------------------ *
+ * Engine-client API: parser, compiled-AST evaluator, context accessors
+ * and the internal value model. The Ruby glue (the engine's client) drives the
+ * engine through these and bridges custom-function handlers, so they live on
+ * this public boundary -- representation-neutral (node pointers are void*; the
+ * glue casts to the document's kind) and free of the MKR_DOM_* monomorphization
+ * machinery in mkr_xpath_internal.h, which the glue never includes. The engine
+ * itself reaches them through internal.h, which includes this header.
+ * ------------------------------------------------------------------ */
+
+/* Per-evaluate budgets + live counters. Filled by
+ * mkr_xpath_limits_init_defaults; every overrun fails closed with
+ * MKR_XPATH_ERR_LIMIT. */
+typedef struct {
+  /* Static budgets. */
+  size_t max_expr_bytes;
+  size_t max_ast_nodes;
+  size_t max_steps;
+  size_t max_predicates;
+  size_t max_function_args;
+  size_t max_nodeset_size;
+  size_t max_eval_ops;
+  size_t max_string_bytes;
+  size_t max_recursion_depth;
+  /* Live counters. */
+  size_t ast_nodes;
+  size_t eval_ops;
+  size_t recursion_depth;
+} mkr_xpath_limits_t;
+
+/* The compiled AST, opaque to clients (built by mkr_parse, freed by
+ * mkr_node_free, run by the evaluator). */
+typedef struct mkr_node_s mkr_node_t;
+
+/* The engine's internal value -- the type a custom-function resolver receives
+ * as its void* args / out (distinct from mkr_xpath_value_t, the result-boundary
+ * type, which names the node array `nodes`). Node pointers are void*; the glue
+ * handler bridge reads/writes them and casts to the document's representation. */
+typedef struct {
+  void  **items;
+  size_t  count;
+  size_t  capacity;
+} mkr_nodeset_t;
+
+typedef struct {
+  mkr_xpath_type_t type;
+  union {
+    mkr_nodeset_t    nodeset;
+    mkr_owned_text_t string;
+    double           number;
+    int              boolean;
+  } u;
+} mkr_val_t;
+
+/* Parse an expression into a compiled AST (caller frees with mkr_node_free);
+ * NULL on error (*err filled). 'limits' bounds the AST node count. */
+mkr_node_t *mkr_parse(mkr_verified_text_t expr, mkr_xpath_limits_t *limits, mkr_xpath_error_t *err);
+void        mkr_node_free(mkr_node_t *n);
+
+/* Evaluate a compiled AST; fills *out_value / *out_error. _first is the
+ * Node#at_xpath variant (a 0-or-1-node result without building the full set). */
+int mkr_xpath_eval_compiled      (mkr_xpath_context_t *ctx, mkr_node_t *ast,
+                                  mkr_xpath_value_t *out_value, mkr_xpath_error_t *out_error);
+int mkr_xpath_eval_compiled_first(mkr_xpath_context_t *ctx, mkr_node_t *ast,
+                                  mkr_xpath_value_t *out_value, mkr_xpath_error_t *out_error);
+
+/* Select the monomorphized engine instance: 0 = HTML (lxb_dom), 1 = XML. */
+void mkr_xpath_set_engine_kind(mkr_xpath_context_t *ctx, int kind);
+
+/* Context accessors used by the glue (node pointers are void*). */
+mkr_xpath_limits_t *mkr_ctx_limits           (mkr_xpath_context_t *ctx);
+void               *mkr_ctx_document         (mkr_xpath_context_t *ctx);
+void                mkr_ctx_set_node         (mkr_xpath_context_t *ctx, void *node);
+void                mkr_ctx_set_unprefixed_lax(mkr_xpath_context_t *ctx, int lax);
+
+/* Error helpers (fill *err; never raise). */
+void mkr_err_set (mkr_xpath_error_t *err, mkr_xpath_status_t status, const char *msg);
+void mkr_err_setf(mkr_xpath_error_t *err, mkr_xpath_status_t status, const char *fmt, ...);
+
+/* Node-set builder + value setter, for the custom-function handler bridge. */
+void mkr_nodeset_init (mkr_nodeset_t *ns);
+int  mkr_nodeset_push (mkr_nodeset_t *ns, void *node, mkr_xpath_limits_t *limits, mkr_xpath_error_t *err);
+void mkr_nodeset_clear(mkr_nodeset_t *ns);
+int  mkr_val_set_borrowed_text_copy(mkr_val_t *v, mkr_borrowed_text_t text,
+                                    mkr_xpath_error_t *err, const char *what);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/makiri/xpath/mkr_xpath_engine_html.c

@@ -0,0 +1,17 @@
+/* mkr_xpath_engine_html.c - the HTML monomorphization of the XPath engine.
+ *
+ * One translation unit holding the whole per-instance engine: the value model,
+ * the built-in function library, and the evaluator. The prelude binds the
+ * MKR_NODE_* / MKR_DOM_* contract to Lexbor's lxb_dom (mkr_xpath_engine_xml.c is
+ * the identical build for the custom XML node). Because all three bodies share
+ * this one TU, every helper they pass between each other is file-static - the
+ * engine internals never collide with the XML instance and need no per-symbol
+ * renaming. Only the two node-dereferencing ENTRY points the driver dispatches
+ * on (mkr_eval_ast, mkr_try_first_match) are external, suffixed _html by the
+ * prelude. The representation-independent primitives both instances call live
+ * once in mkr_xpath_shared.c. */
+#include "mkr_xpath_prelude_html.h"
+
+#include "mkr_xpath_value_body.h"
+#include "mkr_xpath_funcs_body.h"
+#include "mkr_xpath_eval_body.h"

data/ext/makiri/xpath/mkr_xpath_engine_xml.c

@@ -0,0 +1,12 @@
+/* mkr_xpath_engine_xml.c - the XML monomorphization of the XPath engine.
+ *
+ * Byte-for-byte the same bodies as mkr_xpath_engine_html.c, but the prelude
+ * binds the MKR_NODE_* / MKR_DOM_* contract to the custom mkr_xml_node_t and
+ * selects the engine's XML host-policy branches (MKR_HOST_XML). See
+ * mkr_xpath_engine_html.c for the one-TU / file-static rationale; here the two
+ * external entries are suffixed _xml. */
+#include "mkr_xpath_prelude_xml.h"
+
+#include "mkr_xpath_value_body.h"
+#include "mkr_xpath_funcs_body.h"
+#include "mkr_xpath_eval_body.h"