teptris 0.2.36-x86_64-linux → 0.2.38-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afb8e42fa0385bd45f96b312b7f1ebcba3335fe99a51ac9f0db8b920b29bced8
-  data.tar.gz: b48758047d5ee7f6c3e142f8b821ee0acdde70653a32212fd40ccc6ea79a0857
+  metadata.gz: ab9f038bc4784b948475584f5b56d6c815d1f37e1b122708a48395872d9e3635
+  data.tar.gz: aa29ac1fa9c7b2715d23ef44db846024a3e123aa4384a2dfed185d29f57cde32
 SHA512:
-  metadata.gz: bc37dfcf7eefc085ab46aec1c1c4052a89bb0ce54453dcf301451f8ae74311d534e6f59f95efffb63f3554c00ba62994b806b324224a43d052c46315a5b83320
-  data.tar.gz: 8170acc497f6cab20278ba09a71eab2ec0bc9e4cd253f2aa6b93604cc2ea020c12a9e41c99914d3a59f767a542e17f830da035858f1d162aa7ba59dfb751c65c
+  metadata.gz: 82cf78d9770fcd0e41aec5a1a1e0eca3178942e535376dc0fae4594e95156e820024f3316f01766199dbc575f41bf547106fc5145a8778e023ab07cb120c2583
+  data.tar.gz: fc1518bb6b12ad9ca32903db8ca5352d447f2dc4dee55fd600a4f2e23d6f389b7284e5128e1880b590dcbd0e952b35d09b50660eaed10cd48d74e032f78a3009

data/ext/teptris_ext/engine/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 teptris contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/teptris_ext/engine/src/include/teptris/plan.h

@@ -0,0 +1,123 @@
+#ifndef TEPTRIS_PLAN_H
+#define TEPTRIS_PLAN_H
+
+#include <stdint.h>
+
+#include "teptris/teptris.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TEPTRIS_PLAN_ABI_VERSION 1
+
+typedef struct teptris_plan teptris_plan;
+typedef struct teptris_plan_result teptris_plan_result;
+
+typedef enum {
+    TEPTRIS_PLAN_SCALAR = 1,
+    TEPTRIS_PLAN_COLLECTION = 2,
+    TEPTRIS_PLAN_NESTED = 3,
+    TEPTRIS_PLAN_RAW = 4,
+} teptris_plan_row_kind;
+
+/* Result node kinds (walk output). */
+enum {
+    TEPTRIS_PLAN_MISSING = 0,
+    TEPTRIS_PLAN_SCALAR_RESULT = 1,
+    TEPTRIS_PLAN_ARRAY = 2,
+    TEPTRIS_PLAN_TABLE = 3,
+    TEPTRIS_PLAN_RAW_RESULT = 4,
+};
+
+typedef struct teptris_plan_row {
+    const char *name; /* table key */
+    uint8_t kind;     /* teptris_plan_row_kind */
+    uint32_t sub;     /* sub-plan index (NESTED only) */
+} teptris_plan_row;
+
+/* Flattened plan tree: plan p owns rows [first_row[p], first_row[p+1]).
+ * The builder deep-copies; caller memory is transient. */
+typedef struct teptris_plan_spec {
+    uint32_t abi_version;
+    uint32_t plan_count;
+    const teptris_plan_row *plans;
+    const uint32_t *plan_first_row; /* plan_count + 1 entries */
+} teptris_plan_spec;
+
+TEPTRIS_API teptris_plan *teptris_plan_build(const teptris_plan_spec *spec,
+                                             teptris_status *status);
+TEPTRIS_API void teptris_plan_free(teptris_plan *plan);
+
+/* Walk a TABLE node against the plan's root. Results are addressed by
+ * ROW INDEX (the plan's row order); keys absent from the document (or
+ * type-mismatched rows) read as MISSING. */
+TEPTRIS_API teptris_plan_result *teptris_plan_walk(const teptris_plan *plan,
+                                                   const teptris_node *node,
+                                                   teptris_status *status);
+TEPTRIS_API void teptris_plan_result_free(teptris_plan_result *result);
+
+TEPTRIS_API uint8_t teptris_plan_result_kind_at(const teptris_plan_result *r,
+                                                uint32_t row);
+TEPTRIS_API uint8_t teptris_plan_result_value_kind_at(
+    const teptris_plan_result *r, uint32_t row);
+TEPTRIS_API teptris_status teptris_plan_result_string_at(
+    const teptris_plan_result *r, uint32_t row, teptris_view *out);
+TEPTRIS_API teptris_status teptris_plan_result_integer_at(
+    const teptris_plan_result *r, uint32_t row, int64_t *out);
+TEPTRIS_API teptris_status teptris_plan_result_float_at(
+    const teptris_plan_result *r, uint32_t row, double *out);
+TEPTRIS_API teptris_status teptris_plan_result_boolean_at(
+    const teptris_plan_result *r, uint32_t row, bool *out);
+TEPTRIS_API teptris_status teptris_plan_result_datetime_at(
+    const teptris_plan_result *r, uint32_t row, teptris_datetime *out);
+TEPTRIS_API uint32_t teptris_plan_result_array_len_at(
+    const teptris_plan_result *r, uint32_t row);
+TEPTRIS_API uint8_t teptris_plan_result_array_value_kind_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i);
+TEPTRIS_API uint8_t teptris_plan_result_array_kind_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i);
+TEPTRIS_API teptris_status teptris_plan_result_array_string_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i, teptris_view *out);
+TEPTRIS_API teptris_status teptris_plan_result_array_integer_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i, int64_t *out);
+/* RAW rows: the untouched document subtree (read with the normal
+ * teptris_node_* API). */
+/* Borrowed sub-result over a TABLE-kind row (NESTED): its plan rows
+ * stay addressable with the same accessors. */
+TEPTRIS_API teptris_plan_result *teptris_plan_result_row_view(
+    const teptris_plan_result *r, uint32_t row);
+TEPTRIS_API teptris_status teptris_plan_result_array_float_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i, double *out);
+TEPTRIS_API teptris_status teptris_plan_result_array_boolean_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i, bool *out);
+TEPTRIS_API teptris_status teptris_plan_result_array_datetime_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i,
+    teptris_datetime *out);
+/* Plan row metadata (assembly drivers): kind/sub/name by plan+row. */
+TEPTRIS_API uint8_t teptris_plan_row_kind_at(const teptris_plan *p,
+                                          uint32_t plan_idx, uint32_t row);
+TEPTRIS_API uint32_t teptris_plan_row_sub_at(const teptris_plan *p,
+                                          uint32_t plan_idx, uint32_t row);
+TEPTRIS_API const char *teptris_plan_row_name_at(const teptris_plan *p,
+                                              uint32_t plan_idx, uint32_t row);
+/* Borrowed sub-result over an ARRAY element (e.g. a table from an
+ * array-of-tables): its plan rows are addressable with the same
+ * accessors. Shares the parent result's lifetime; release the wrapper
+ * with teptris_plan_result_view_free (the tree itself is not freed). */
+TEPTRIS_API teptris_plan_result *teptris_plan_result_array_entry_at(
+    const teptris_plan_result *r, uint32_t row, uint32_t i);
+TEPTRIS_API void teptris_plan_result_view_free(teptris_plan_result *view);
+
+TEPTRIS_API const teptris_node *teptris_plan_result_raw_at(
+    const teptris_plan_result *r, uint32_t row);
+
+TEPTRIS_API uint32_t teptris_plan_row_count(const teptris_plan *plan,
+                                            uint32_t plan_idx);
+TEPTRIS_API uint32_t teptris_plan_abi_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TEPTRIS_PLAN_H */

data/ext/teptris_ext/engine/src/include/teptris/teptris.h

@@ -0,0 +1,208 @@
+#ifndef TEPTRIS_TEPTRIS_H
+#define TEPTRIS_TEPTRIS_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "teptris/version.h"
+
+/* Export annotation: the shared library builds with TEPTRIS_BUILDING_DLL
+ * (dllexport); consumers may define TEPTRIS_USE_DLL for dllimport, and
+ * static builds link plainly. Non-Windows platforms export by default. */
+#if defined(_WIN32)
+#  if defined(TEPTRIS_BUILDING_DLL)
+#    define TEPTRIS_API __declspec(dllexport)
+#  elif defined(TEPTRIS_USE_DLL)
+#    define TEPTRIS_API __declspec(dllimport)
+#  else
+#    define TEPTRIS_API
+#  endif
+#else
+#  define TEPTRIS_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Opaque handles. Every node handed out by the read API is owned by its
+ * document and valid until teptris_document_free. */
+typedef struct teptris_document teptris_document;
+typedef struct teptris_node teptris_node;
+
+typedef enum teptris_status {
+    TEPTRIS_OK = 0,
+    TEPTRIS_ERR_ALLOC,
+    TEPTRIS_ERR_SYNTAX,
+    TEPTRIS_ERR_SEMANTIC,
+    TEPTRIS_ERR_ENCODING,
+    TEPTRIS_ERR_DEPTH,
+    TEPTRIS_ERR_ARG,
+    TEPTRIS_ERR_STATE
+} teptris_status;
+
+typedef enum teptris_kind {
+    TEPTRIS_STRING = 0,
+    TEPTRIS_INTEGER,
+    TEPTRIS_FLOAT,
+    TEPTRIS_BOOLEAN,
+    TEPTRIS_DATETIME_OFFSET,
+    TEPTRIS_DATETIME_LOCAL,
+    TEPTRIS_DATE_LOCAL,
+    TEPTRIS_TIME_LOCAL,
+    TEPTRIS_ARRAY,
+    TEPTRIS_TABLE
+} teptris_kind;
+
+/* Views are (ptr, len); string values are additionally NUL-terminated.
+ * Table keys are views into the parse input and may not be. */
+typedef struct teptris_view {
+    const char *ptr;
+    size_t len;
+} teptris_view;
+
+typedef struct teptris_datetime {
+    int32_t year;                /* valid for DATE/DATETIME kinds */
+    uint8_t month, day;          /* 1-based */
+    uint8_t hour, minute, second; /* second may be 60 (leap second) */
+    uint32_t nanosecond;
+    int32_t offset_seconds;      /* valid for DATETIME_OFFSET only */
+} teptris_datetime;
+
+typedef struct teptris_error {
+    teptris_status status;
+    size_t line;   /* 1-based */
+    size_t column; /* 1-based */
+    const char *message; /* NUL-terminated, document-owned */
+} teptris_error;
+
+typedef struct teptris_options {
+    uint32_t max_depth; /* 0 = default (512) */
+    uint32_t _reserved[3];
+} teptris_options;
+
+/* Parse a TOML 1.0 document. On failure the status is returned AND *out
+ * is set (non-NULL) so the error can be read; free it either way.
+ * Table-key views point into `data`: the caller must keep the input
+ * buffer alive for the lifetime of the document.
+ * Memory: *out must be freed with teptris_document_free. */
+TEPTRIS_API teptris_status teptris_parse(const char *data, size_t len,
+                             const teptris_options *opts,
+                             teptris_document **out);
+
+/* Memory: frees every allocation reachable from the document. */
+TEPTRIS_API void teptris_document_free(teptris_document *doc);
+
+TEPTRIS_API const teptris_error * teptris_document_error(const teptris_document *doc);
+TEPTRIS_API const teptris_node * teptris_document_root(const teptris_document *doc);
+
+TEPTRIS_API teptris_kind teptris_node_kind(const teptris_node *node);
+
+/* Type-checked scalar accessors: return TEPTRIS_ERR_ARG on kind mismatch
+ * (or TEPTRIS_ERR_STATE with a NULL node). */
+TEPTRIS_API teptris_status teptris_node_string(const teptris_node *node, teptris_view *out);
+TEPTRIS_API teptris_status teptris_node_integer(const teptris_node *node, int64_t *out);
+TEPTRIS_API teptris_status teptris_node_float(const teptris_node *node, double *out);
+TEPTRIS_API teptris_status teptris_node_boolean(const teptris_node *node, bool *out);
+TEPTRIS_API teptris_status teptris_node_datetime(const teptris_node *node,
+                                     teptris_datetime *out);
+
+TEPTRIS_API size_t teptris_node_array_length(const teptris_node *node);
+TEPTRIS_API const teptris_node * teptris_node_array_at(const teptris_node *node, size_t index);
+
+/* Iteration is in insertion order. */
+TEPTRIS_API size_t teptris_node_table_length(const teptris_node *node);
+TEPTRIS_API const teptris_node * teptris_node_table_at(const teptris_node *node, size_t index,
+                                          teptris_view *key_out);
+TEPTRIS_API const teptris_node * teptris_node_table_get(const teptris_node *node,
+                                           const char *key, size_t key_len);
+
+/* Emit canonical TOML (deterministic; parse(emit(d)) == d).
+ * Memory: *buf is malloc'd; caller frees with free(). */
+TEPTRIS_API teptris_status teptris_document_emit(const teptris_document *doc,
+                                     char **buf, size_t *len);
+
+/* Emit the toml-test wire shape: scalars as {"type":..,"value":..},
+ * tables as objects, arrays as lists, insertion order.
+ * Memory: *buf is malloc'd; caller frees with free(). */
+TEPTRIS_API teptris_status teptris_document_emit_json(const teptris_document *doc,
+                                          char **buf, size_t *len);
+
+/* Bulk drain for FFI/ctypes bindings: the whole tree in ONE crossing as
+ * a self-describing flat buffer (explicit little-endian):
+ *   table  0x01 u32 n *(u32 klen key node)
+ *   array  0x02 u32 n *(node)
+ *   string 0x03 u32 len bytes
+ *   int    0x04 i64
+ *   float  0x05 f64
+ *   bool   0x06 / 0x07
+ *   dt     0x08..0x0B (offset/local-dt/date/time) i64 y u8 mo d h mi s u32 ns i64 off (25 B)
+ * Memory: *buf is malloc'd; free with teptris_flatten_free. */
+TEPTRIS_API teptris_status teptris_document_flatten(const teptris_document *doc,
+                                        uint8_t **buf, size_t *len);
+TEPTRIS_API void teptris_flatten_free(void *buf);
+
+TEPTRIS_API const char * teptris_status_string(teptris_status status);
+TEPTRIS_API const char * teptris_version_string(void);
+
+/* ------------------------------------------------------------- builder --
+ * Construct a document from materialized values (the dump side of
+ * parse): every emission flows through teptris_document_emit, so the
+ * emitter stays the single source of formatting truth.
+ *
+ * Stack discipline: open_* pushes a container, teptris_builder_close
+ * pops it; scalars attach to the current container. A NULL key means
+ * "element of the current array"; a keyed call requires a table
+ * current. Array nature is derived: the first table element makes the
+ * array an array-of-tables ([[..]] sections); scalars make it inline;
+ * mixing them is TEPTRIS_ERR_ARG. Tables reachable only as array
+ * elements or from inline tables render inline ({..}); tables under a
+ * section render as [..] sections.
+ *
+ * Keys and strings are copied into the document (no parse input is
+ * kept alive). Duplicate keys are TEPTRIS_ERR_ARG.
+ * Memory: the builder owns its document until teptris_builder_finish
+ * transfers it; otherwise teptris_builder_free destroys it. */
+typedef struct teptris_builder teptris_builder;
+
+TEPTRIS_API teptris_builder *teptris_builder_new(void);
+TEPTRIS_API void teptris_builder_free(teptris_builder *b);
+
+TEPTRIS_API teptris_status teptris_builder_put_string(teptris_builder *b,
+                                        const char *key, size_t key_len,
+                                        const char *val, size_t val_len);
+TEPTRIS_API teptris_status teptris_builder_put_integer(teptris_builder *b,
+                                        const char *key, size_t key_len,
+                                        int64_t v);
+TEPTRIS_API teptris_status teptris_builder_put_float(teptris_builder *b,
+                                        const char *key, size_t key_len,
+                                        double v);
+TEPTRIS_API teptris_status teptris_builder_put_boolean(teptris_builder *b,
+                                        const char *key, size_t key_len,
+                                        bool v);
+/* kind is one of TEPTRIS_DATETIME_OFFSET, TEPTRIS_DATETIME_LOCAL,
+ * TEPTRIS_DATE_LOCAL, TEPTRIS_TIME_LOCAL; fields must be zero where
+ * the kind does not use them (offset only for OFFSET). */
+TEPTRIS_API teptris_status teptris_builder_put_datetime(teptris_builder *b,
+                                        const char *key, size_t key_len,
+                                        teptris_kind kind,
+                                        const teptris_datetime *dt);
+
+TEPTRIS_API teptris_status teptris_builder_open_table(teptris_builder *b,
+                                        const char *key, size_t key_len);
+TEPTRIS_API teptris_status teptris_builder_open_array(teptris_builder *b,
+                                        const char *key, size_t key_len);
+/* like open_array but pinned inline ([..]) — for callers whose
+ * lookahead knows the array is not a homogeneous table array */
+TEPTRIS_API teptris_status teptris_builder_open_inline_array(teptris_builder *b,
+                                        const char *key, size_t key_len);
+TEPTRIS_API teptris_status teptris_builder_close(teptris_builder *b);
+TEPTRIS_API teptris_status teptris_builder_finish(teptris_builder *b,
+                                        teptris_document **out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TEPTRIS_TEPTRIS_H */

data/ext/teptris_ext/engine/src/include/teptris/version.h

@@ -0,0 +1,9 @@
+#ifndef TEPTRIS_VERSION_H
+#define TEPTRIS_VERSION_H
+
+#define TEPTRIS_VERSION_MAJOR 0
+#define TEPTRIS_VERSION_MINOR 1
+#define TEPTRIS_VERSION_PATCH 24
+#define TEPTRIS_VERSION_STRING "0.1.24"
+
+#endif /* TEPTRIS_VERSION_H */