leptris 1.9.201.1-arm-linux → 1.9.201.2-arm-linux

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

@@ -0,0 +1,319 @@
+/* xpath_ast_cache.c — LRU cache of parsed XPath expression ASTs.
+ *
+ * Per TODO 113 perf audit: parsing the expression accounts for a
+ * large fraction of leptris_xpath_eval time. For workloads that
+ * evaluate the same expression repeatedly (very common), caching
+ * the parsed AST eliminates the parse cost on every call after
+ * the first.
+ *
+ * TODO 120 Phase F: the cache now also holds the compiled bytecode
+ * alongside the AST. The bytecode is compiled lazily on first VM
+ * eval and reused thereafter, so repeated evals skip both the
+ * parse and the compile phase.
+ *
+ * Implementation: fixed 16-slot open-addressed hash by expression
+ * string hash, guarded by a process-global mutex
+ * (TODO.concurrency/08).
+ *
+ * Tradeoff: this leaks ASTs and bytecodes at process exit.
+ * Acceptable for a process-global cache of small (~100 byte) ASTs
+ * and ~1 KB bytecodes. */
+
+#include "xpath_internal.h"
+#include "../common/port.h"  /* LEPTRIS_MUTEX */
+#include "parser.h"  /* ast_node_free */
+#include "bytecode.h"  /* leptris_xpath_bytecode_free */
+#include "../leptris_internal.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define XPATH_AST_CACHE_SLOTS 16
+
+typedef struct {
+    unsigned hash;        /* FNV-1a hash; 0 = empty slot */
+    char* expr_copy;      /* Owned string copy (for re-lookup verification) */
+    size_t expr_len;
+    XPathASTNode* ast;    /* Owned AST */
+    LeptrisXPathBytecode* bc;  /* Owned bytecode (lazy; NULL until first VM eval) */
+    int pins;             /* In-flight borrows (TODO.concurrency/08) */
+} xpath_ast_cache_slot;
+
+static xpath_ast_cache_slot g_cache[XPATH_AST_CACHE_SLOTS];
+
+/* TODO.concurrency/08: an evicted entry with pins > 0 moves here
+ * until its last borrower releases. AST/bytecode pointers escape
+ * the mutex for the duration of one evaluate — eviction may not
+ * free them underneath a running thread. */
+typedef struct cache_graveyard {
+    char* expr_copy;
+    XPathASTNode* ast;
+    LeptrisXPathBytecode* bc;
+    int pins;
+    struct cache_graveyard* next;
+} cache_graveyard;
+
+static cache_graveyard* g_graveyard;  /* guarded by g_cache_mutex */
+
+/* TODO.concurrency/08: the process-wide cache is mutex-guarded, not
+ * thread-local — a per-thread cache would leak its ASTs on thread
+ * exit (no portable TLS destructors in C99), and bindings evaluate
+ * from pooled threads. Uncontended lock/unlock is ~20 ns; the
+ * parse-once reuse win is preserved across threads. */
+static leptris_mutex_t g_cache_mutex = LEPTRIS_MUTEX_INIT;
+/* #682 Phase 2: xslt_exec is single-threaded within a transform;
+ * when the calling thread claims ownership of the cache the mutex
+ * is skipped entirely (hot path: every xpath_eval does get+release). */
+static LEPTRIS_THREAD_LOCAL int g_cache_owner_active;
+int xpath_ast_cache_owner_begin(void) {
+    int prev = g_cache_owner_active;
+    g_cache_owner_active = 1;
+    return prev;
+}
+void xpath_ast_cache_owner_end(int prev) {
+    g_cache_owner_active = prev;
+}
+#define XPATH_CACHE_OWNED (g_cache_owner_active)
+
+/* FNV-1a 32-bit hash. */
+static unsigned xpath_hash(const char* s, size_t len) {
+    unsigned h = 2166136261u;
+    for (size_t i = 0; i < len; i++) {
+        h ^= (unsigned char)s[i];
+        h *= 16777619u;
+    }
+    /* Avoid the sentinel value of 0 (= empty slot). */
+    return h == 0 ? 1 : h;
+}
+
+static XPathASTNode* cache_lookup_locked(const char* expr, size_t expr_len) {
+    if (!expr || expr_len == 0) return NULL;
+    unsigned h = xpath_hash(expr, expr_len);
+    /* Open-addressed probe: linear scan starting at h % SLOTS. */
+    for (size_t probe = 0; probe < XPATH_AST_CACHE_SLOTS; probe++) {
+        size_t i = (h + probe) % XPATH_AST_CACHE_SLOTS;
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->hash == 0) return NULL;  /* empty */
+        if (slot->hash == h &&
+            slot->expr_len == expr_len &&
+            memcmp(slot->expr_copy, expr, expr_len) == 0) {
+            return slot->ast;
+        }
+    }
+    return NULL;
+}
+
+/* Combined lookup (TODO 159 Phase E drive-by): single hash + scan
+ * that returns both AST and bytecode. Replaces the previous pattern
+ * of calling xpath_ast_cache_lookup + xpath_ast_cache_get_bc which
+ * hashed the expression twice per leptris_xpath_eval call. */
+static int cache_get_locked(const char* expr, size_t expr_len,
+                             XPathCacheEntry* out) {
+    if (!expr || expr_len == 0 || !out) return 0;
+    out->ast = NULL;
+    out->bc = NULL;
+    unsigned h = xpath_hash(expr, expr_len);
+    for (size_t probe = 0; probe < XPATH_AST_CACHE_SLOTS; probe++) {
+        size_t i = (h + probe) % XPATH_AST_CACHE_SLOTS;
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->hash == 0) return 0;  /* empty */
+        if (slot->hash == h &&
+            slot->expr_len == expr_len &&
+            memcmp(slot->expr_copy, expr, expr_len) == 0) {
+            out->ast = slot->ast;
+            out->bc = slot->bc;
+            slot->pins++;  /* borrow pinned for one evaluate */
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* Returns the canonical AST for `expr` after insert. The caller
+ * MUST use the returned pointer (a racing twin insert may have won
+ * the slot; the passed AST is then freed and using it would be a
+ * use-after-free). The returned entry comes back pinned for the
+ * caller — pair with xpath_ast_cache_release. */
+static XPathASTNode* cache_insert_locked(const char* expr, size_t expr_len, XPathASTNode* ast) {
+    if (!expr || expr_len == 0 || !ast) return ast;
+    unsigned h = xpath_hash(expr, expr_len);
+
+    /* Find target slot: prefer the hash slot itself if empty or
+     * already holds this expression; otherwise probe for empty or
+     * overwrite the entry furthest from the hash slot (LRU-ish). */
+    size_t target = h % XPATH_AST_CACHE_SLOTS;
+    for (size_t probe = 0; probe < XPATH_AST_CACHE_SLOTS; probe++) {
+        size_t i = (h + probe) % XPATH_AST_CACHE_SLOTS;
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->hash == 0) {
+            target = i;
+            break;
+        }
+        if (slot->hash == h &&
+            slot->expr_len == expr_len &&
+            memcmp(slot->expr_copy, expr, expr_len) == 0) {
+            /* Already cached (racing twin won). The cached one is
+             * canonical; free the caller's private twin. */
+            ast_node_free(ast);
+            slot->pins++;
+            return slot->ast;
+        }
+    }
+
+    /* Overwrite target slot. A pinned entry moves to the graveyard
+     * instead of being freed underneath its borrowers. */
+    xpath_ast_cache_slot* slot = &g_cache[target];
+    if (slot->expr_copy) {
+        if (slot->pins > 0) {
+            cache_graveyard* g =
+                (cache_graveyard*)malloc(sizeof(*g));
+            if (g) {
+                g->expr_copy = slot->expr_copy;
+                g->ast = slot->ast;
+                g->bc = slot->bc;
+                g->pins = slot->pins;
+                g->next = g_graveyard;
+                g_graveyard = g;
+            }
+        } else {
+            LEPTRIS_FREE(slot->expr_copy);
+            ast_node_free(slot->ast);
+            if (slot->bc) leptris_xpath_bytecode_free(slot->bc);
+        }
+    }
+    /* Copy the expression string so future lookups can verify. */
+    char* copy = LEPTRIS_ALLOC_N(char, expr_len + 1);
+    if (!copy) return NULL;
+    memcpy(copy, expr, expr_len);
+    copy[expr_len] = '\0';
+
+    slot->hash = h;
+    slot->expr_copy = copy;
+    slot->expr_len = expr_len;
+    slot->ast = ast;
+    slot->bc = NULL;  /* lazy; compiled on first VM eval */
+    slot->pins = 1;   /* pinned for the inserting caller */
+    return ast;
+}
+
+static void cache_release_locked(XPathASTNode* ast) {
+    if (!ast) return;
+    for (size_t i = 0; i < XPATH_AST_CACHE_SLOTS; i++) {
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->ast == ast) {
+            if (slot->pins > 0) slot->pins--;
+            return;
+        }
+    }
+    for (cache_graveyard** pp = &g_graveyard; *pp; pp = &(*pp)->next) {
+        cache_graveyard* g = *pp;
+        if (g->ast == ast) {
+            if (--g->pins <= 0) {
+                *pp = g->next;
+                LEPTRIS_FREE(g->expr_copy);
+                ast_node_free(g->ast);
+                if (g->bc) leptris_xpath_bytecode_free(g->bc);
+                free(g);
+            }
+            return;
+        }
+    }
+}
+
+static LeptrisXPathBytecode* cache_get_bc_locked(const char* expr, size_t expr_len) {
+    if (!expr || expr_len == 0) return NULL;
+    unsigned h = xpath_hash(expr, expr_len);
+    for (size_t probe = 0; probe < XPATH_AST_CACHE_SLOTS; probe++) {
+        size_t i = (h + probe) % XPATH_AST_CACHE_SLOTS;
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->hash == 0) return NULL;  /* empty */
+        if (slot->hash == h &&
+            slot->expr_len == expr_len &&
+            memcmp(slot->expr_copy, expr, expr_len) == 0) {
+            return slot->bc;
+        }
+    }
+    return NULL;
+}
+
+static void cache_store_bc_locked(const char* expr, size_t expr_len,
+                                   LeptrisXPathBytecode* bc) {
+    if (!expr || expr_len == 0 || !bc) {
+        if (bc) leptris_xpath_bytecode_free(bc);
+        return;
+    }
+    unsigned h = xpath_hash(expr, expr_len);
+    for (size_t probe = 0; probe < XPATH_AST_CACHE_SLOTS; probe++) {
+        size_t i = (h + probe) % XPATH_AST_CACHE_SLOTS;
+        xpath_ast_cache_slot* slot = &g_cache[i];
+        if (slot->hash == 0) {
+            /* Expression not in the cache. Free the orphan bytecode;
+             * the caller's path (leptris_xpath_eval) should always
+             * insert the AST before storing the bc, so this branch
+             * is defensive. */
+            leptris_xpath_bytecode_free(bc);
+            return;
+        }
+        if (slot->hash == h &&
+            slot->expr_len == expr_len &&
+            memcmp(slot->expr_copy, expr, expr_len) == 0) {
+            /* Race-safe last-writer-wins. If two threads compile
+             * concurrently, the loser frees its bytecode to avoid
+             * a leak. The winner's bytecode stays referenced until
+             * the slot is overwritten. */
+            if (slot->bc) leptris_xpath_bytecode_free(bc);
+            else slot->bc = bc;
+            return;
+        }
+    }
+    /* Not found — defensive free. */
+    leptris_xpath_bytecode_free(bc);
+}
+
+/* ---- Public entry points: mutex-guarded (TODO.concurrency/08) ---- */
+
+XPathASTNode* xpath_ast_cache_lookup(const char* expr, size_t expr_len) {
+    if (XPATH_CACHE_OWNED) return cache_lookup_locked(expr, expr_len);
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    XPathASTNode* r = cache_lookup_locked(expr, expr_len);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+    return r;
+}
+
+int xpath_ast_cache_get(const char* expr, size_t expr_len,
+                         XPathCacheEntry* out) {
+    if (XPATH_CACHE_OWNED) return cache_get_locked(expr, expr_len, out);
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    int r = cache_get_locked(expr, expr_len, out);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+    return r;
+}
+
+XPathASTNode* xpath_ast_cache_insert(const char* expr, size_t expr_len, XPathASTNode* ast) {
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    XPathASTNode* r = cache_insert_locked(expr, expr_len, ast);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+    return r;
+}
+
+void xpath_ast_cache_release(XPathASTNode* ast) {
+    if (XPATH_CACHE_OWNED) { cache_release_locked(ast); return; }
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    cache_release_locked(ast);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+}
+
+LeptrisXPathBytecode* xpath_ast_cache_get_bc(const char* expr, size_t expr_len) {
+    if (XPATH_CACHE_OWNED) return cache_get_bc_locked(expr, expr_len);
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    LeptrisXPathBytecode* r = cache_get_bc_locked(expr, expr_len);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+    return r;
+}
+
+void xpath_ast_cache_store_bc(const char* expr, size_t expr_len,
+                               LeptrisXPathBytecode* bc) {
+    LEPTRIS_MUTEX_LOCK(&g_cache_mutex);
+    cache_store_bc_locked(expr, expr_len, bc);
+    LEPTRIS_MUTEX_UNLOCK(&g_cache_mutex);
+}

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

@@ -0,0 +1,263 @@
+/* xpath/xpath_compiled.c — compiled XPath expressions
+ * (TODO.bindings/03, issue #510 Tier 2).
+ *
+ * leptris_xpath_eval re-hashes the expression and re-checks the
+ * process-wide AST/bytecode cache on every call. A compiled handle
+ * pins its cache entry once and skips both steps — the hot-loop win
+ * for bindings (issue #509's follow-up).
+ *
+ * Thread contract (mirrors the README Threading model): the pinned
+ * entry is immutable; any number of threads may evaluate the same
+ * handle concurrently against different documents. Free the handle
+ * only after the last evaluation returns. */
+#include "xpath_internal.h"
+#include "parser.h"
+#include "bytecode.h"
+#include "evaluator_internal.h"
+#include "xpath_variables.h"
+#include "../leptris_internal.h"
+#include "../../include/leptris.h"
+#include <stdlib.h>
+#include <string.h>
+
+struct leptris_xpath_compiled {
+    char* expr;
+    size_t expr_len;
+    XPathASTNode* ast;   /* canonical, pinned in the cache */
+};
+
+LEPTRIS_API LeptrisXPathCompiled leptris_xpath_compile(const char* expression) {
+    if (!expression || !*expression) return NULL;
+    size_t len = strlen(expression);
+
+    struct leptris_xpath_compiled* c =
+        (struct leptris_xpath_compiled*)calloc(1, sizeof(*c));
+    if (!c) return NULL;
+    c->expr_len = len;
+    c->expr = (char*)malloc(len + 1);
+    if (!c->expr) { free(c); return NULL; }
+    memcpy(c->expr, expression, len);
+    c->expr[len] = '\0';
+
+    XPathParser* parser = xpath_parser_new(expression, len);
+    if (!parser) { free(c->expr); free(c); return NULL; }
+    XPathASTNode* ast = xpath_parse(parser);
+    const char* parse_error = xpath_parser_error(parser);
+    if (!ast || parse_error) {
+        leptris_set_error(LEPTRIS_ERROR_XPATH_SYNTAX,
+                          parse_error && parse_error[0]
+                              ? parse_error : "XPath syntax error");
+        xpath_parser_free(parser);
+        free(c->expr); free(c);
+        return NULL;
+    }
+    xpath_parser_free(parser);
+
+    /* Insert returns the canonical (pinned) AST — a racing twin may
+     * have won the slot; never keep using the private parse. */
+    c->ast = xpath_ast_cache_insert(c->expr, len, ast);
+    if (!c->ast) { free(c->expr); free(c); return NULL; }
+    return c;
+}
+
+/* Run a compiled expression against a PREPARED context (the XSLT
+ * bridge installs its own function registry + variable set before
+ * calling this). VM fast path first; AST interpreter fallback. The
+ * caller owns the context storage and is responsible for cleanup. */
+struct leptris_xpath_result* leptris_xpath_compiled_eval_in(
+        LeptrisXPathCompiled compiled, XPathContext* xpath_ctx) {
+    if (!compiled || !xpath_ctx || !xpath_ctx->document) return NULL;
+    LeptrisXPathBytecode* bc = xpath_ast_cache_get_bc(compiled->expr,
+                                                      compiled->expr_len);
+    struct leptris_xpath_result* result = NULL;
+    if (bc) {
+        result = leptris_xpath_vm_run_bc(bc, xpath_ctx);
+    } else {
+        bc = leptris_xpath_compile_ast(compiled->ast);
+        if (bc) {
+            result = leptris_xpath_vm_run_bc(bc, xpath_ctx);
+            xpath_ast_cache_store_bc(compiled->expr, compiled->expr_len, bc);
+        }
+    }
+    if (!result) result = xpath_evaluate(xpath_ctx, compiled->ast);
+
+    if (!result && xpath_ctx->error_msg[0]) {
+        struct leptris_document* d = xpath_ctx->document;
+        strncpy(d->last_error_message, xpath_ctx->error_msg,
+                sizeof(d->last_error_message) - 1);
+        d->last_error_message[sizeof(d->last_error_message) - 1] = '\0';
+    }
+    return result;
+}
+
+LEPTRIS_API LeptrisXPathResult leptris_xpath_compiled_eval(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context) {
+    if (!compiled || !doc) return NULL;
+
+    LeptrisElement context_elem =
+        context ? context : leptris_document_root(doc);
+    if (!context_elem) return NULL;
+
+    XPathContext ctx_storage;
+    XPathContext* xpath_ctx = &ctx_storage;
+    xpath_context_init(xpath_ctx, doc, context_elem);
+    if (!xpath_ctx->document) return NULL;
+
+    struct leptris_xpath_result* result =
+        leptris_xpath_compiled_eval_in(compiled, xpath_ctx);
+
+    xpath_context_cleanup(xpath_ctx);
+    return result;
+}
+
+/* TODO.engine/02: the context-carrying variants. The ns/vars routes
+ * run the direct evaluator (VM fast paths skip prefixed name tests),
+ * so these evaluate the pinned AST with ns_set / variable_set
+ * installed — the same semantics as leptris_xpath_eval_ns /
+ * leptris_xpath_eval_with_vars_context, minus the re-parse. pos is
+ * the caller's in-flight node-list position (§12.4 position()); the
+ * wrappers pass 1 (the XPath default context position). */
+static struct leptris_xpath_result* compiled_eval_context(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context, struct leptris_xpath_ns_map* ns,
+        XPathVariableSet* vars, size_t pos, size_t size) {
+    if (!compiled || !doc) return NULL;
+
+    LeptrisElement context_elem =
+        context ? context : leptris_document_root(doc);
+    if (!context_elem) return NULL;
+
+    XPathContext ctx_storage;
+    XPathContext* xpath_ctx = &ctx_storage;
+    xpath_context_init(xpath_ctx, doc, context_elem);
+    if (!xpath_ctx->document) return NULL;
+
+    xpath_ctx->ns_set = ns;
+    xpath_ctx->variable_set = vars;
+    xpath_ctx->context_position = pos;
+    xpath_ctx->context_size = size ? size : 1;
+
+    /* VM fast path first (issue #564): the VM's name matcher is
+     * namespace-aware and the absolute folds lower prefixed tests
+     * through the local-name bucket + URI verification, so ns-bound
+     * expressions ride the same index-backed paths as plain ones.
+     * The bytecode comes from the shared per-expression cache.
+     *
+     * Variable-bound expressions ride it too (#565): $var
+     * references compile to BC_FALLBACK_EVAL subtrees that evaluate
+     * with THIS context, so bindings resolve, and a fused
+     * name[attr=$var] predicate runs on the index-backed opcode.
+     * The earlier bug-76 divergence was the position-predicate
+     * absolute tail — which never merged; position predicates on
+     * absolute paths stay on the interpreter path. */
+    struct leptris_xpath_result* result = NULL;
+    {
+        /* Pinned borrow (the raw get_bc returns an unpinned pointer —
+         * a re-entrant store during the run can evict and free it;
+         * ASAN caught exactly that in libxslt bug-147, PR #600). */
+        XPathCacheEntry ce;
+        int hit = xpath_ast_cache_get(compiled->expr, compiled->expr_len,
+                                      &ce);
+        LeptrisXPathBytecode* bc = hit ? ce.bc : NULL;
+        if (hit && !bc) {
+            bc = leptris_xpath_compile_ast(compiled->ast);
+            if (bc) {
+                xpath_ast_cache_store_bc(compiled->expr,
+                                         compiled->expr_len, bc);
+                /* #1079: a twin compile may have won the slot and
+                 * store freed OUR bytecode as the loser — re-read
+                 * the canonical cached bytecode for the run (the
+                 * entry is pinned, so it cannot be evicted here). */
+                LeptrisXPathBytecode* canonical = xpath_ast_cache_get_bc(
+                    compiled->expr, compiled->expr_len);
+                if (canonical) bc = canonical;
+            }
+        }
+        if (bc) {
+            result = leptris_xpath_vm_run_bc(bc, xpath_ctx);
+            if (!result) xpath_ctx->error_msg[0] = '\0';
+        }
+        if (hit) xpath_ast_cache_release(ce.ast);
+    }
+    if (!result)
+        result = xpath_evaluate(xpath_ctx, compiled->ast);
+
+    if (!result && xpath_ctx->error_msg[0]) {
+        strncpy(doc->last_error_message, xpath_ctx->error_msg,
+                sizeof(doc->last_error_message) - 1);
+        doc->last_error_message[sizeof(doc->last_error_message) - 1] = '\0';
+    }
+
+    xpath_context_cleanup(xpath_ctx);
+    return result;
+}
+
+LEPTRIS_API LeptrisXPathResult leptris_xpath_compiled_eval_ns(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context, LeptrisXPathNsSet ns) {
+    return compiled_eval_context(compiled, doc, context,
+                                 (struct leptris_xpath_ns_map*)ns, NULL, 1, 1);
+}
+
+/* Combined ns + vars entry (public, issue 608): prefixed tests plus
+ * $var references in one compiled call. */
+LEPTRIS_API LeptrisXPathResult leptris_xpath_compiled_eval_ns_vars(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context, LeptrisXPathNsSet ns,
+        LeptrisXPathVariableSet variables) {
+    return compiled_eval_context(
+        compiled, doc, context, (struct leptris_xpath_ns_map*)ns,
+        (XPathVariableSet*)variables, 1, 1);
+}
+
+/* Full-context eval for the XSLT engine: the VM fast path when
+ * neither ns nor vars are bound (identical semantics to
+ * leptris_xpath_compiled_eval), the AST interpreter otherwise, and
+ * the context position carries the in-flight node-list position so
+ * position() (§12.4) reflects the for-each / apply-templates
+ * iteration instead of the XPath default 1. */
+struct leptris_xpath_result* leptris_xpath_compiled_eval_ctx(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context, struct leptris_xpath_ns_map* ns,
+        XPathVariableSet* vars, size_t pos, size_t size) {
+    if (!compiled || !doc) return NULL;
+    if (ns || vars)
+        return compiled_eval_context(compiled, doc, context, ns, vars,
+                                     pos, size);
+
+    LeptrisElement context_elem =
+        context ? context : leptris_document_root(doc);
+    if (!context_elem) return NULL;
+
+    XPathContext ctx_storage;
+    XPathContext* xpath_ctx = &ctx_storage;
+    xpath_context_init(xpath_ctx, doc, context_elem);
+    if (!xpath_ctx->document) return NULL;
+    xpath_ctx->context_position = pos;
+    xpath_ctx->context_size = size ? size : 1;
+
+    struct leptris_xpath_result* result =
+        leptris_xpath_compiled_eval_in(compiled, xpath_ctx);
+
+    xpath_context_cleanup(xpath_ctx);
+    return result;
+}
+
+LEPTRIS_API LeptrisXPathResult leptris_xpath_compiled_eval_vars(
+        LeptrisXPathCompiled compiled, LeptrisDocument doc,
+        LeptrisElement context, LeptrisXPathVariableSet variables) {
+    return compiled_eval_context(compiled, doc, context, NULL,
+                                 (XPathVariableSet*)variables, 1, 1);
+}
+
+LEPTRIS_API const char* leptris_xpath_compiled_text(LeptrisXPathCompiled compiled) {
+    return compiled ? compiled->expr : NULL;
+}
+
+LEPTRIS_API void leptris_xpath_compiled_free(LeptrisXPathCompiled compiled) {
+    if (!compiled) return;
+    xpath_ast_cache_release(compiled->ast);
+    free(compiled->expr);
+    free(compiled);
+}