makiri 0.3.0 → 0.4.0

data/ext/makiri/xml/mkr_xml_node.h

@@ -13,6 +13,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include "../core/mkr_buf.h"   /* mkr_spanbuf_t (the arena hand-fill writer) */
 
 /* The XML representation's DOM node-type constants - the counterpart of Lexbor's
  * LXB_DOM_NODE_TYPE_* for HTML. The numeric values mirror the DOM/Lexbor
@@ -50,7 +51,9 @@ typedef enum {
  * lengths stay uint32 (the deliberate per-slice 4 GiB cap; see the enum note).
  * Names/values are arena-owned byte slices (case-preserved). */
 typedef struct mkr_xml_node {
-    uint8_t  type;                 /* mkr_xml_node_type_t */
+    mkr_xml_node_type_t type;      /* free: the next field is an 8-aligned pointer,
+                                    * so this sits in padding either way (node stays
+                                    * 128 B) - keep the real enum type for safety */
     struct mkr_xml_node *parent, *first_child, *last_child, *prev, *next;
     struct mkr_xml_node *attrs;    /* element: head of attribute list (type=ATTRIBUTE) */
     const char *qname;   /* element/attr raw "prefix:local" (contiguous; local/prefix slice into it) */
@@ -62,6 +65,17 @@ typedef struct mkr_xml_node {
     uint32_t line, col;            /* source position (element only; 0 = none) */
 } mkr_xml_node_t;
 
+/* A QName decomposed into its contiguous "prefix:local" parts (the same layout a
+ * built node carries): +qname+ is the whole name, +prefix+/+local+ slice into it
+ * (prefix points at +qname+; prefix_len 0 = unprefixed). The single value passed
+ * through the split/resolve/assign primitives below, so those never take the six
+ * fields as loose arguments. */
+typedef struct {
+    const char *qname;   uint32_t qname_len;
+    const char *prefix;  uint32_t prefix_len;   /* prefix_len 0 = unprefixed */
+    const char *local;   uint32_t local_len;
+} mkr_xml_qname_t;
+
 typedef struct mkr_xml_arena_chunk mkr_xml_arena_chunk_t;
 
 /* A document: its append-only arena, the root element (NULL until built), and
@@ -85,6 +99,14 @@ typedef struct mkr_xml_doc {
                                     * node: local/qname = name, prefix = public
                                     * (external) id, value = system id; a 0-length
                                     * prefix/value means that id is absent. */
+    void    *name_index;           /* lazily-built element-name index (mkr_xml_index.c),
+                                    * or NULL; dropped on every structural mutation. */
+    int      has_encoding_decl;    /* the parsed source's <?xml?> declaration carried an
+                                    * `encoding` pseudo-attribute. The serializer emits
+                                    * `encoding="UTF-8"` only when this is set (or an
+                                    * explicit encoding: is requested), so a built or
+                                    * declaration-less document round-trips to a bare
+                                    * `<?xml version="1.0"?>`, like Nokogiri. */
 } mkr_xml_doc_t;
 /* The PER-ELEMENT attribute cap (MKR_XML_MAX_ATTRS) is enforced by the tree
  * builder; the arena counts every node - attributes included - toward max_nodes. */
@@ -97,12 +119,21 @@ size_t         mkr_xml_doc_memsize(const mkr_xml_doc_t *doc);
  * The single overflow- and budget-checked alloc choke point is PRIVATE to
  * mkr_xml_node.c. Callers never get a void* to cast: nodes via *_node (zeroed,
  * type-validated), copied name/value bytes via *_bytes (the arena owns them).
- * mkr_xml_arena_scratch_bytes returns a raw, uninitialised char buffer of exactly
- * +len+ bytes for the one caller that must fill it itself (entity expansion). On
- * any failure doc->oom is set (sticky) and the wrapper returns NULL. */
-mkr_xml_node_t *mkr_xml_arena_node(mkr_xml_doc_t *doc, uint8_t type);
+ * A caller that must fill a buffer itself uses mkr_xml_arena_spanbuf (below),
+ * never a raw pointer. On any failure doc->oom is set (sticky) and the wrapper
+ * returns NULL. */
+mkr_xml_node_t *mkr_xml_arena_node(mkr_xml_doc_t *doc, mkr_xml_node_type_t type);
 const char     *mkr_xml_arena_bytes(mkr_xml_doc_t *doc, const char *src, uint32_t len);
-char           *mkr_xml_arena_scratch_bytes(mkr_xml_doc_t *doc, size_t len);
+
+/* Carve +cap+ arena bytes and return a bounded writer (core mkr_spanbuf) over
+ * them - the ONLY way to hand-fill arena bytes. The writer owns the cursor and
+ * the bounds check, so a write past the cut is impossible by construction (it is
+ * refused and latches ok=false, never overruns the next cut). Fill it with the
+ * core mkr_spanbuf_putc / _write, then mkr_spanbuf_finish; a NULL finish means
+ * the backing alloc failed (doc->oom set) OR a write was refused (doc->oom stays
+ * OK -> a broken invariant, i.e. our bug). On alloc failure the returned writer
+ * is already not-ok (buf == NULL), so every write is a safe no-op. */
+mkr_spanbuf_t mkr_xml_arena_spanbuf(mkr_xml_doc_t *doc, size_t cap);
 
 /* If attribute +a+ is an xmlns declaration, set the declared namespace prefix
  * (NULL/plen 0 for the default xmlns) and its URI as arena slices, and return 1;
@@ -111,6 +142,40 @@ char           *mkr_xml_arena_scratch_bytes(mkr_xml_doc_t *doc, size_t len);
 int mkr_xml_node_xmlns_decl(const mkr_xml_node_t *a, const char **prefix, uint32_t *plen,
                             const char **uri, uint32_t *ulen);
 
+/* If the raw name [name,len) is an xmlns declaration ("xmlns" or "xmlns:PREFIX"),
+ * set the out-params to the declared prefix ("" / 0 for the default xmlns) and
+ * return 1; else return 0. prefix/plen may be NULL when only the boolean is
+ * wanted. The single byte-level xmlns detector the parser, the namespace
+ * resolver, and mkr_xml_node_xmlns_decl all share (the node version just reads
+ * the value too). */
+int mkr_xml_xmlns_prefix(const char *name, uint32_t len, const char **prefix, uint32_t *plen);
+
+/* Pre-order (document-order) descendant iteration over +root+'s subtree without
+ * recursion: start at +root+, then `cur = mkr_xml_preorder_next(root, cur)` until
+ * NULL. Visits +root+ first. The one shared form of the iterative DFS the index
+ * build and the mutation namespace resolver both need (no scope/state threaded). */
+mkr_xml_node_t *mkr_xml_preorder_next(const mkr_xml_node_t *root, mkr_xml_node_t *cur);
+
+/* Validate [name,len) as a well-formed XML 1.0 QName (full NameStartChar/NameChar
+ * scan) and split it into +out+ (prefix_len 0 = unprefixed). 0 on success, -1 if
+ * malformed. For the mutation path, whose input is not pre-scanned; the tree
+ * builder keeps its own lighter split (the name is already scan_name'd). */
+int mkr_xml_qname_split(const char *name, uint32_t len, mkr_xml_qname_t *out);
+
+/* Copy +qn+'s name into +doc+'s arena as one contiguous slice and point
+ * node->qname/local/prefix into it (ns_uri is the caller's concern). 0 on
+ * success, -1 on arena OOM (node left untouched, so the caller stays fail-closed).
+ * The single arena-copy-and-assign both the tree builder and the mutators use. */
+int mkr_xml_qname_assign(mkr_xml_doc_t *doc, mkr_xml_node_t *node, const mkr_xml_qname_t *qn);
+
+/* The QName parts a built node already carries, as a mkr_xml_qname_t value. */
+static inline mkr_xml_qname_t
+mkr_xml_qname_of(const mkr_xml_node_t *n)
+{
+    mkr_xml_qname_t q = { n->qname, n->qname_len, n->prefix, n->prefix_len, n->local, n->local_len };
+    return q;
+}
+
 /* Self-test of the arena's secure-by-design properties (overflow, budgets,
  * alignment, zero-init, copy-on-store, whole-free). Returns 0 on success or the
  * 1-based index of the first failing check. Run from Makiri.__c_selftest. */