yeptris 0.6.5.4 → 0.6.7.2

data/vendor/libyeptris/src/include/yeptris/events.h

@@ -0,0 +1,157 @@
+/* events.h — the four consumption models over one engine (TODO.impl/12).
+ *
+ * push:     one callback per event (C users; ~1 µs/event through FFI —
+ *           bindings prefer the recorder's bulk drain).
+ * pull:     StAX-style cursor; zero C->host dispatch; event strings are
+ *           owned by the puller and valid UNTIL THE NEXT CALL.
+ * recorder: fixed-size records + one string arena; bulk drain, O(chunks)
+ *           host crossings. v1 buffers input until the final chunk; the
+ *           streaming feed (mid-document resumption) lands with
+ *           parse/feed.c and keeps this shape.
+ * iterparse: document-at-a-time over multi-document streams; one
+ *           document's events per call, memory bounded by the largest
+ *           document. Events valid UNTIL THE NEXT CALL.
+ *
+ * All four are sinks over the single parse engine: identical event
+ * streams, proven by the cross-model corpus check (test_events_cross).
+ */
+#ifndef YEPTRIS_EVENTS_H
+#define YEPTRIS_EVENTS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>   /* YeptrisStatus */
+#include <yeptris/resolve.h> /* YeptrisSchema */
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Event types (ABI-pinned order; mirrors the internal engine 1:1). */
+typedef enum {
+    YEPTRIS_EV_STREAM_START = 1,
+    YEPTRIS_EV_STREAM_END,
+    YEPTRIS_EV_DOCUMENT_START,
+    YEPTRIS_EV_DOCUMENT_END,
+    YEPTRIS_EV_SEQUENCE_START,
+    YEPTRIS_EV_SEQUENCE_END,
+    YEPTRIS_EV_MAPPING_START,
+    YEPTRIS_EV_MAPPING_END,
+    YEPTRIS_EV_SCALAR,
+    YEPTRIS_EV_ALIAS,
+} YeptrisEventType;
+
+/* Flag bits in YeptrisEventRecord.flags. */
+enum {
+    YEPTRIS_EF_FLOW = 1u << 0,     /* collection in flow style */
+    YEPTRIS_EF_EXPLICIT = 1u << 1, /* document with --- / ... marker */
+    YEPTRIS_EF_IMPLICIT = 1u << 2, /* plain scalar, no tag */
+};
+
+/* One event, string fields pointing into the owning model's storage. */
+typedef struct {
+    YeptrisEventType type;
+    int style;           /* YeptrisScalarStyle (dom.h) for scalars */
+    int flow;            /* collection: flow style */
+    int explicit_marker; /* document: --- / ... seen */
+    int implicit;        /* scalar: plain and untagged */
+    const char* value;   /* scalar content or alias name; NULL if empty */
+    size_t value_len;
+    const char* anchor; /* node property; NULL when absent */
+    size_t anchor_len;
+    const char* tag; /* resolved tag; NULL when absent */
+    size_t tag_len;
+    uint32_t line; /* 1-based node start */
+    uint32_t col;
+} YeptrisEvent;
+
+/* ---- push ------------------------------------------------------------- */
+
+/* Returns nonzero from the callback to abort the parse (surfaced as
+ * YEPTRIS_ERROR_PARSE with the last-error channel set). Event strings
+ * are valid only during the call. */
+typedef int (*yeptris_event_fn)(void* ctx, const YeptrisEvent* ev);
+
+YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptris_event_fn on_event,
+                                             void* ctx);
+
+/* ---- pull ------------------------------------------------------------- */
+
+YEPTRIS_API YeptrisPullParser yeptris_pull_new(const char* buf, size_t len);
+
+/* Next event (owned by the puller, valid until the next call), or
+ * NULL at stream end or on error — distinguish with yeptris_pull_status. */
+YEPTRIS_API const YeptrisEvent* yeptris_pull_next(YeptrisPullParser pull);
+
+/* Bulk cursor (the FFI shape): up to max events per call, strings in
+ * the puller's arena valid until the next pull call. Returns count. */
+YEPTRIS_API size_t yeptris_pull_next_batch(YeptrisPullParser pull, YeptrisEvent* out, size_t max);
+
+YEPTRIS_API YeptrisStatus yeptris_pull_status(const YeptrisPullParser pull, uint32_t* line,
+                                              uint32_t* col);
+YEPTRIS_API void yeptris_pull_free(YeptrisPullParser pull);
+
+/* ---- recorder --------------------------------------------------------- */
+
+/* Fixed-size record; strings slice the arena by offset+length. */
+typedef struct {
+    uint8_t type; /* YeptrisEventType */
+    uint8_t style;
+    uint8_t flags;  /* YEPTRIS_EF_* */
+    uint8_t tag_id; /* resolved implicit tag (YeptrisTagId, resolve.h) —
+                     * the typing SSOT, so hosts never re-scan. Uses the
+                     * struct's pad byte: sizeof stays 36 (ABI-pinned) */
+    uint32_t line;
+    uint32_t col;
+    uint32_t value_off;
+    uint32_t value_len;
+    uint32_t anchor_off;
+    uint32_t anchor_len;
+    uint32_t tag_off;
+    uint32_t tag_len;
+} YeptrisEventRecord;
+
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new(void);
+
+/* Same, with the implicit-typing schema for the parse (bindings pass
+ * compat_11 to reproduce Psych's typing). */
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new_ex(YeptrisSchema schema);
+
+/* Accumulates input; the parse advances whenever a complete document
+ * has arrived (its closing --- / ... marker line), and final != 0
+ * flushes the trailing document. Each feed's records — fixed-size
+ * array plus the arena — hold the documents closed by that chunk and
+ * are valid until the next feed: drain per chunk. Returns
+ * YEPTRIS_OK, YEPTRIS_ERROR_PARSE (terminal; drain what this feed
+ * recorded) or YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char* chunk, size_t len,
+                                                int final);
+
+/* Bulk accessors: the record array and the string arena. Valid until
+ * the next feed; reset at every feed entry (drain per chunk). */
+YEPTRIS_API const YeptrisEventRecord* yeptris_recorder_records(YeptrisRecorder rec, size_t* count);
+YEPTRIS_API const char* yeptris_recorder_arena(YeptrisRecorder rec, size_t* len);
+YEPTRIS_API void yeptris_recorder_free(YeptrisRecorder rec);
+
+/* ---- iterparse -------------------------------------------------------- */
+
+YEPTRIS_API YeptrisIterparse yeptris_iterparse_new(const char* buf, size_t len);
+
+/* The next document's events (owned by the iterator, valid until the
+ * next call): *count events, or NULL when the stream is exhausted.
+ * STREAM_START / STREAM_END frame the stream exactly once each; the
+ * DOCUMENT_* pair frames each yielded slice. */
+YEPTRIS_API const YeptrisEvent* yeptris_iterparse_next(YeptrisIterparse it, size_t* count);
+
+YEPTRIS_API YeptrisStatus yeptris_iterparse_status(const YeptrisIterparse it, uint32_t* line,
+                                                   uint32_t* col);
+YEPTRIS_API void yeptris_iterparse_free(YeptrisIterparse it);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_EVENTS_H */

data/vendor/libyeptris/src/include/yeptris/json.h

@@ -0,0 +1,45 @@
+/* json.h — strict JSON mode (TODO.impl/08C/21).
+ *
+ * YAML 1.2 strictly contains JSON, but users of json-c-shaped APIs
+ * want RFC 8259 semantics exactly: this entry validates the whole
+ * input against the strict grammar (scan/json.c is the one truth)
+ * before the engine runs, so an accepted input is guaranteed to be
+ * pure JSON and every invalid one fails with the violation offset.
+ * Charset note: JSON strings allow DEL and forbid raw C0 — the
+ * opposite corner of YAML c-printable — so this path validates
+ * UTF-8 well-formedness only, never the printable set.
+ */
+#ifndef YEPTRIS_JSON_H
+#define YEPTRIS_JSON_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/parse.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Parses one strict-JSON document. Same contract as yeptris_parse:
+ * a YeptrisDocument handle (queries via the DOM API) or NULL with
+ * *st set; violations carry the byte offset via yeptris_last_error. */
+YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* data, size_t len, YeptrisStatus* st);
+
+/* Serializes the document's FIRST document as strict JSON (flow
+ * collections, JSON escapes, shortest floats, null/true/false words).
+ * Returns a malloc'd NUL-terminated buffer (caller frees) with *len
+ * (may be NULL) set, or NULL on a NULL document / allocation
+ * failure / zero documents. */
+YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument doc, size_t* len);
+
+/* The compact variant: no padding spaces (JSON.generate's shape);
+ * compact == 0 is byte-identical to yeptris_serialize_json. */
+YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument doc, size_t* len, int compact);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_JSON_H */

data/vendor/libyeptris/src/include/yeptris/json.hpp

@@ -0,0 +1,258 @@
+// json.hpp — the nlohmann-flavored C++17 wrapper (TODO.impl/21).
+//
+// Value semantics over the C ABI: yeptris::json owns its document
+// (RAII), children are views into it. JSON in, JSON out — strict
+// parsing via yeptris_parse_json, output via the JSON writer.
+// Errors throw (nlohmann discipline); no exceptions in the C core.
+//
+// Deliberately a view, not a copy: j["k"] returns a child that stays
+// valid while the parent json lives (the nlohmann ergonomics without
+// the deep-template machinery).
+
+#ifndef YEPTRIS_JSON_HPP
+#define YEPTRIS_JSON_HPP
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include <yeptris/dom.h>
+#include <yeptris/json.h>
+
+namespace yeptris {
+
+class parse_error : public std::runtime_error {
+  public:
+    explicit parse_error(const char* msg) : std::runtime_error(msg) {}
+};
+
+class type_error : public std::logic_error {
+  public:
+    explicit type_error(const char* msg) : std::logic_error(msg) {}
+};
+
+class json {
+  public:
+    json() = default;
+
+    json(const json&) = delete;
+    json& operator=(const json&) = delete;
+
+    json(json&& other) noexcept : doc_(other.doc_), node_(other.node_), owns_(other.owns_) {
+        other.doc_ = nullptr;
+        other.node_ = nullptr;
+        other.owns_ = false;
+    }
+
+    json& operator=(json&& other) noexcept {
+        if (this != &other) {
+            destroy();
+            doc_ = other.doc_;
+            node_ = other.node_;
+            owns_ = other.owns_;
+            other.doc_ = nullptr;
+            other.node_ = nullptr;
+            other.owns_ = false;
+        }
+        return *this;
+    }
+
+    ~json() {
+        destroy();
+    }
+
+    static json parse(std::string_view text) {
+        YeptrisStatus st = YEPTRIS_OK;
+        YeptrisDocument d = yeptris_parse_json(text.data(), text.size(), &st);
+        if (d == nullptr) {
+            uint32_t line = 0, col = 0;
+            const char* msg = yeptris_last_error(&line, &col);
+            throw parse_error(msg ? msg : "not valid JSON");
+        }
+        json j;
+        j.doc_ = d;
+        j.node_ = yeptris_document_root(d, 0);
+        j.owns_ = true;
+        return j;
+    }
+
+    std::string dump() const {
+        check_root();
+        size_t len = 0;
+        char* out = yeptris_serialize_json(doc_, &len);
+        if (out == nullptr) {
+            throw std::runtime_error("serialization failed");
+        }
+        std::string s(out, len);
+        free(out);
+        return s;
+    }
+
+    // ---- type queries (nlohmann names) ----
+    bool is_object() const {
+        return kind() == YEPTRIS_NODE_MAPPING;
+    }
+    bool is_array() const {
+        return kind() == YEPTRIS_NODE_SEQUENCE;
+    }
+    bool is_string() const {
+        return kind() == YEPTRIS_NODE_SCALAR && !is_number() && !is_boolean() && !is_null();
+    }
+    bool is_number() const {
+        return is_number_integer() || is_number_float();
+    }
+    bool is_number_integer() const {
+        return typed_ok<int64_t>();
+    }
+    bool is_number_float() const {
+        return typed_ok<double>();
+    }
+    bool is_boolean() const {
+        return typed_ok<bool>();
+    }
+    bool is_null() const;
+
+    // ---- object access ----
+    json operator[](std::string_view key) const {
+        require(YEPTRIS_NODE_MAPPING, "object");
+        YeptrisNode n = yeptris_node_map_get(node_, key.data(), key.size());
+        if (n == nullptr) {
+            throw std::out_of_range("key not found");
+        }
+        return child(n);
+    }
+
+    json at(std::string_view key) const {
+        return (*this)[key];
+    }
+
+    bool contains(std::string_view key) const {
+        return kind() == YEPTRIS_NODE_MAPPING &&
+               yeptris_node_map_get(node_, key.data(), key.size()) != nullptr;
+    }
+
+    size_t size() const {
+        if (kind() == YEPTRIS_NODE_MAPPING) {
+            return yeptris_node_map_count(node_);
+        }
+        if (kind() == YEPTRIS_NODE_SEQUENCE) {
+            return yeptris_node_seq_count(node_);
+        }
+        return 0;
+    }
+
+    // ---- array access ----
+    json operator[](size_t index) const {
+        require(YEPTRIS_NODE_SEQUENCE, "array");
+        if (index >= yeptris_node_seq_count(node_)) {
+            throw std::out_of_range("index out of range");
+        }
+        return child(yeptris_node_seq_at(node_, index));
+    }
+
+    json at(size_t index) const {
+        return (*this)[index];
+    }
+
+    // ---- typed getters ----
+    std::string get_string() const {
+        if (kind() != YEPTRIS_NODE_SCALAR) {
+            throw type_error("not a scalar");
+        }
+        size_t len = 0;
+        const char* v = yeptris_node_value(node_, &len);
+        return std::string(v ? v : "", len); /* json-c semantics: the
+            raw text — "1" for numbers, "true" for booleans */
+    }
+
+    int64_t get_int() const {
+        int64_t v = 0;
+        if (yeptris_node_int(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not an integer");
+        }
+        return v;
+    }
+
+    double get_double() const {
+        double v = 0;
+        if (yeptris_node_float(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not a float");
+        }
+        return v;
+    }
+
+    bool get_bool() const {
+        int v = 0;
+        if (yeptris_node_bool(node_, &v) != YEPTRIS_OK) {
+            throw type_error("not a boolean");
+        }
+        return v != 0;
+    }
+
+  private:
+    json(YeptrisDocument doc, YeptrisNode node) : doc_(doc), node_(node), owns_(false) {}
+
+    json child(YeptrisNode n) const {
+        return json(doc_, n);
+    }
+
+    void destroy() {
+        if (owns_ && doc_ != nullptr) {
+            yeptris_document_free(doc_);
+        }
+        doc_ = nullptr;
+        node_ = nullptr;
+        owns_ = false;
+    }
+
+    void check_root() const {
+        if (doc_ == nullptr) {
+            throw std::logic_error("empty json");
+        }
+    }
+
+    int kind() const {
+        return node_ != nullptr ? (int)yeptris_node_kind(node_) : -1;
+    }
+
+    void require(int k, const char* what) const {
+        if (kind() != k) {
+            throw type_error(what);
+        }
+    }
+
+    template <typename T> bool typed_ok() const {
+        if (node_ == nullptr || kind() != YEPTRIS_NODE_SCALAR) {
+            return false;
+        }
+        if constexpr (std::is_same_v<T, int64_t>) {
+            int64_t v;
+            return yeptris_node_int(node_, &v) == YEPTRIS_OK;
+        } else if constexpr (std::is_same_v<T, double>) {
+            double v;
+            return yeptris_node_float(node_, &v) == YEPTRIS_OK;
+        } else {
+            int v;
+            return yeptris_node_bool(node_, &v) == YEPTRIS_OK;
+        }
+    }
+
+    YeptrisDocument doc_ = nullptr;
+    YeptrisNode node_ = nullptr;
+    bool owns_ = false;
+};
+
+inline bool json::is_null() const {
+    if (kind() != YEPTRIS_NODE_SCALAR) {
+        return false;
+    }
+    size_t len = 0;
+    const char* v = yeptris_node_value(node_, &len);
+    return len == 4 && v != nullptr && std::string_view(v, len) == "null";
+}
+
+} // namespace yeptris
+
+#endif // YEPTRIS_JSON_HPP

data/vendor/libyeptris/src/include/yeptris/jsonc_compat.h

@@ -0,0 +1,115 @@
+/* jsonc_compat.h — the json-c migration layer (TODO.impl/21).
+ *
+ * REAL json-c symbol names over the yeptris core: users link
+ * -lyeptris-jsonc instead of -ljson-c and change nothing else.
+ *
+ * Scope (v1, the read path): parsing, type queries, value getters,
+ * object/array access, and JSON output. The building API
+ * (json_object_new_ etc.) landed with DOM mutation
+ * (TODO.impl/11 phase 3): the new_object family, object_add,
+ * array_add, and the delete entry points.
+ *
+ * Lifetime: the object returned by json_tokener_parse owns the
+ * document; json_object_put frees it. Objects obtained by reference
+ * (children) are owned by their document — put on them is a no-op
+ * returning 1 (json-c children outlive callers the same way).
+ */
+#ifndef YEPTRIS_JSONC_COMPAT_H
+#define YEPTRIS_JSONC_COMPAT_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Values mirror json-c's json_type. */
+typedef enum {
+    json_type_null = 0,
+    json_type_boolean,
+    json_type_double,
+    json_type_int,
+    json_type_object,
+    json_type_array,
+    json_type_string
+} json_type;
+
+typedef struct json_object json_object;
+
+/* json-c's string flags for to_json_string_ext */
+#define JSON_C_TO_STRING_PLAIN 0
+#define JSON_C_TO_STRING_SPACED (1 << 0)
+#define JSON_C_TO_STRING_PRETTY (1 << 1)
+#define JSON_C_TO_STRING_PRETTY_TAB (1 << 2)
+#define JSON_C_TO_STRING_NOZERO (1 << 3)
+
+/* Parses one JSON document (strict; trailing whitespace allowed).
+ * Returns NULL on invalid input. The result owns its document —
+ * release with json_object_put. */
+json_object* json_tokener_parse(const char* str);
+json_object* json_tokener_parse_ex(const char* buf, int len);
+void json_tokener_free(json_object* obj);
+
+/* Lifetime: put on the ROOT frees the document (once); on a child it
+ * is a no-op returning 1. get returns the object unchanged. */
+int json_object_put(json_object* obj);
+json_object* json_object_get(json_object* obj);
+
+/* Type queries. */
+json_type json_object_get_type(const json_object* obj);
+int json_object_is_type(const json_object* obj, json_type type);
+
+/* Value getters (0 when the type does not match, like json-c). */
+const char* json_object_get_string(json_object* obj);
+int32_t json_object_get_int(const json_object* obj);
+int64_t json_object_get_int64(const json_object* obj);
+double json_object_get_double(const json_object* obj);
+int json_object_get_boolean(const json_object* obj);
+
+/* Object access: *value receives the field (a borrowed reference). */
+int json_object_object_get_ex(const json_object* obj, const char* key, json_object** value);
+size_t json_object_object_length(const json_object* obj);
+
+/* Array access (borrowed references). */
+size_t json_object_array_length(const json_object* obj);
+json_object* json_object_array_get_idx(const json_object* obj, size_t idx);
+
+/* Output: strict JSON. The returned pointer is owned by the object
+ * (freed with it) — json-c's contract. Roots only in v1: serializing
+ * an attached child returns NULL (subtree output arrives with the
+ * pretty printer). */
+const char* json_object_to_json_string(json_object* obj);
+const char* json_object_to_json_string_ext(json_object* obj, int flags);
+
+/* ---- Building (TODO.impl/21 v2, over DOM mutation 11/3) ----
+ *
+ * json-c semantics: new_* returns an unowned object; adding it to a
+ * parent transfers ownership (a put on it afterwards is a no-op); the
+ * caller's pointer stays valid until the ROOT is put. Values are
+ * copied. Duplicate keys replace in place (position kept). NULL val
+ * to object_add deletes the key (legacy json-c behavior). */
+json_object* json_object_new_object(void);
+json_object* json_object_new_array(void);
+json_object* json_object_new_string(const char* s);
+json_object* json_object_new_string_len(const char* s, int len);
+json_object* json_object_new_int(int32_t i);
+json_object* json_object_new_int64(int64_t i);
+json_object* json_object_new_double(double d);
+json_object* json_object_new_boolean(int b);
+
+/* 0 added, 1 replaced, -1 error (obj not an object, or OOM). */
+int json_object_object_add(json_object* obj, const char* key, json_object* val);
+int json_object_object_del(json_object* obj, const char* key);
+
+/* 0 ok, -1 error (obj not an array, or OOM). */
+int json_object_array_add(json_object* obj, json_object* val);
+int json_object_array_del_idx(json_object* obj, size_t idx, size_t count);
+
+/* index < len replaces in place; index == len appends. */
+int json_object_array_put_idx(json_object* obj, size_t idx, json_object* val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_JSONC_COMPAT_H */

data/vendor/libyeptris/src/include/yeptris/marshal.h

@@ -0,0 +1,52 @@
+/* marshal.h — Ruby Marshal 4.8 emission (TODO.restructure/21).
+ *
+ * The binding materialization fast path: the C side converts the
+ * value records directly into Ruby's Marshal wire format, so the host
+ * materializes the whole object graph with ONE core-C call
+ * (Marshal.load) instead of walking per-value records in Ruby.
+ *
+ * Semantics are pinned to the binding walks (the ':sym' plain scan,
+ * Psych's single-char y/n and dot-required floats, alias identity
+ * via object links). Constructs the format cannot express return
+ * YEPTRIS_ERROR_UNSUPPORTED — the host falls back to the record walk.
+ *
+ * Memory: *out is a single malloc'd buffer; free with
+ * yeptris_marshal_free exactly once. */
+#ifndef YEPTRIS_MARSHAL_H
+#define YEPTRIS_MARSHAL_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    /* the whole stream as one Ruby Array of documents (load_all) */
+    YEPTRIS_MARSHAL_ALL_DOCS = 0,
+    /* just the first document's root (load) */
+    YEPTRIS_MARSHAL_FIRST_DOC = 1,
+} YeptrisMarshalMode;
+
+/* Parses `data` and emits Marshal 4.8 bytes of the object graph the
+ * value stream describes. Returns YEPTRIS_OK, YEPTRIS_ERROR_PARSE /
+ * _MEMORY / _ARG, or YEPTRIS_ERROR_UNSUPPORTED (merge keys or
+ * timestamps: materialize those through the record walk). */
+YEPTRIS_API YeptrisStatus yeptris_marshal(const char* data, size_t len, YeptrisSchema schema,
+                                          YeptrisMarshalMode mode, char** out, size_t* out_len);
+
+/* The same emission for one node subtree of a built document — the
+ * bulk path behind Node#to_ruby (one call, not one per node). */
+YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len);
+
+YEPTRIS_API void yeptris_marshal_free(char* out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_MARSHAL_H */

data/vendor/libyeptris/src/include/yeptris/parse.h

@@ -0,0 +1,48 @@
+/* parse.h — the parse entry points (TODO.impl/07/11 public surface). */
+
+#ifndef YEPTRIS_PARSE_H
+#define YEPTRIS_PARSE_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Parses a YAML document set. buf must remain valid for the lifetime of
+ * the returned document (scalar values are borrowed zero-copy views).
+ * On failure returns NULL; *status (may be NULL) receives the code and
+ * yeptris_last_error() carries the message with line/column.
+ *
+ * Memory: the caller owns the document; free it with
+ * yeptris_document_free — one call releases everything. */
+YEPTRIS_API YeptrisDocument yeptris_parse(const char* buf, size_t len, YeptrisStatus* status);
+
+/* Per-parse options (TODO.impl/10): schema selects the implicit-typing
+ * resolver (default YEPTRIS_SCHEMA_12_CORE), max_depth caps nesting
+ * (0: the library default), strict/tab_policy/recover are reserved
+ * pins of the option shape (the strict grammar is the default today;
+ * lenient modes land with the recover work). Zero-initialized = the
+ * yeptris_parse defaults. */
+typedef struct YeptrisParseOptions {
+    YeptrisSchema schema;
+    int max_depth;
+    int strict;
+    int tab_policy;
+    int recover;
+} YeptrisParseOptions;
+
+YEPTRIS_API YeptrisDocument yeptris_parse_ex(const char* buf, size_t len,
+                                             const YeptrisParseOptions* opts,
+                                             YeptrisStatus* status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_PARSE_H */