teptris 0.2.37-s390x-linux → 0.2.39-s390x-linux

data/ext/teptris_ext/engine/src/teptris/api.c

@@ -0,0 +1,362 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "teptris/dom/dom.h"
+#include "teptris/emit/emitter.h"
+#include "teptris/parse/parse.h"
+#include "teptris/teptris.h"
+
+teptris_status teptris_parse(const char *data, size_t len,
+                             const teptris_options *opts,
+                             teptris_document **out)
+{
+    *out = NULL;
+    teptris_document *doc = calloc(1, sizeof(teptris_document));
+    if (doc == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    teptris_arena_init(&doc->arena);
+    doc->max_depth = (opts != NULL && opts->max_depth != 0) ? opts->max_depth
+                                                           : 512;
+    doc->err.status = TEPTRIS_OK;
+    doc->err.message = "";
+
+    teptris_status st = teptris_parser_run(doc, data, len);
+    if (st != TEPTRIS_OK && doc->err.status == TEPTRIS_OK) {
+        doc->err.status = st;
+        if (st == TEPTRIS_ERR_ALLOC) {
+            snprintf(doc->err_msg, sizeof(doc->err_msg), "out of memory");
+        }
+        doc->err.message = doc->err_msg;
+    }
+    *out = doc;
+    return st;
+}
+
+void teptris_document_free(teptris_document *doc)
+{
+    if (doc == NULL) {
+        return;
+    }
+    teptris_arena_destroy(&doc->arena);
+    free(doc);
+}
+
+const teptris_error *teptris_document_error(const teptris_document *doc)
+{
+    return &doc->err;
+}
+
+const teptris_node *teptris_document_root(const teptris_document *doc)
+{
+    if (doc == NULL || doc->err.status != TEPTRIS_OK) {
+        return NULL;
+    }
+    return doc->root;
+}
+
+teptris_kind teptris_node_kind(const teptris_node *node)
+{
+    return (node != NULL) ? (teptris_kind)node->kind : TEPTRIS_STRING;
+}
+
+teptris_status teptris_node_string(const teptris_node *node, teptris_view *out)
+{
+    if (node == NULL || node->kind != TEPTRIS_STRING) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *out = node->as.str;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_node_integer(const teptris_node *node, int64_t *out)
+{
+    if (node == NULL || node->kind != TEPTRIS_INTEGER) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *out = node->as.i;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_node_float(const teptris_node *node, double *out)
+{
+    if (node == NULL || node->kind != TEPTRIS_FLOAT) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *out = node->as.f;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_node_boolean(const teptris_node *node, bool *out)
+{
+    if (node == NULL || node->kind != TEPTRIS_BOOLEAN) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *out = node->as.b;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_node_datetime(const teptris_node *node,
+                                     teptris_datetime *out)
+{
+    if (node == NULL || node->kind < TEPTRIS_DATETIME_OFFSET ||
+        node->kind > TEPTRIS_TIME_LOCAL) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *out = node->as.dt;
+    return TEPTRIS_OK;
+}
+
+size_t teptris_node_array_length(const teptris_node *node)
+{
+    return (node != NULL && node->kind == TEPTRIS_ARRAY) ? node->as.array.len
+                                                         : 0;
+}
+
+const teptris_node *teptris_node_array_at(const teptris_node *node,
+                                          size_t index)
+{
+    if (node == NULL || node->kind != TEPTRIS_ARRAY ||
+        index >= node->as.array.len) {
+        return NULL;
+    }
+    return node->as.array.items[index];
+}
+
+size_t teptris_node_table_length(const teptris_node *node)
+{
+    return (node != NULL && node->kind == TEPTRIS_TABLE) ? node->as.table.len
+                                                         : 0;
+}
+
+const teptris_node *teptris_node_table_at(const teptris_node *node,
+                                          size_t index, teptris_view *key_out)
+{
+    if (node == NULL || node->kind != TEPTRIS_TABLE ||
+        index >= node->as.table.len) {
+        return NULL;
+    }
+    if (key_out != NULL) {
+        *key_out = node->as.table.entries[index].key;
+    }
+    return node->as.table.entries[index].value;
+}
+
+const teptris_node *teptris_node_table_get(const teptris_node *node,
+                                           const char *key, size_t key_len)
+{
+    if (node == NULL || node->kind != TEPTRIS_TABLE || key == NULL) {
+        return NULL;
+    }
+    teptris_entry *e = teptris_dom_table_find(node, key, key_len);
+    return (e != NULL) ? e->value : NULL;
+}
+
+teptris_status teptris_document_emit(const teptris_document *doc, char **buf,
+                                     size_t *len)
+{
+    return teptris_emit_document(doc, buf, len);
+}
+
+teptris_status teptris_document_emit_json(const teptris_document *doc,
+                                          char **buf, size_t *len)
+{
+    return teptris_emit_document_json(doc, buf, len);
+}
+
+/* --------------------------------------------------- bulk flatten ----- */
+
+typedef struct {
+    uint8_t *p;
+    size_t len, cap;
+    teptris_status st;
+} flatbuf;
+
+static void fb_grow(flatbuf *b, size_t extra)
+{
+    if (b->st != TEPTRIS_OK) {
+        return;
+    }
+    if (b->len + extra <= b->cap) {
+        return;
+    }
+    size_t ncap = b->cap ? b->cap : 512;
+    while (b->len + extra > ncap) {
+        ncap *= 2;
+    }
+    uint8_t *np = realloc(b->p, ncap);
+    if (np == NULL) {
+        free(b->p);
+        b->p = NULL;
+        b->st = TEPTRIS_ERR_ALLOC;
+        return;
+    }
+    b->p = np;
+    b->cap = ncap;
+}
+
+static void fb_byte(flatbuf *b, uint8_t v)
+{
+    fb_grow(b, 1);
+    if (b->st == TEPTRIS_OK) {
+        b->p[b->len++] = v;
+    }
+}
+
+static void fb_u32(flatbuf *b, uint32_t v)
+{
+    fb_grow(b, 4);
+    if (b->st == TEPTRIS_OK) {
+        b->p[b->len++] = (uint8_t)v;
+        b->p[b->len++] = (uint8_t)(v >> 8);
+        b->p[b->len++] = (uint8_t)(v >> 16);
+        b->p[b->len++] = (uint8_t)(v >> 24);
+    }
+}
+
+static void fb_u64(flatbuf *b, uint64_t v)
+{
+    for (int i = 0; i < 8; i++) {
+        fb_byte(b, (uint8_t)(v >> (8 * i)));
+    }
+}
+
+static void fb_i64(flatbuf *b, int64_t v)
+{
+    uint64_t u;
+    memcpy(&u, &v, 8);
+    fb_u64(b, u);
+}
+
+static void fb_f64(flatbuf *b, double v)
+{
+    uint64_t u;
+    memcpy(&u, &v, 8);
+    fb_u64(b, u);
+}
+
+static void fb_dt(flatbuf *b, const teptris_datetime *d)
+{
+    fb_i64(b, d->year);
+    fb_byte(b, d->month);
+    fb_byte(b, d->day);
+    fb_byte(b, d->hour);
+    fb_byte(b, d->minute);
+    fb_byte(b, d->second);
+    fb_u32(b, d->nanosecond);
+    fb_i64(b, d->offset_seconds);
+}
+
+static teptris_status flatten_node(flatbuf *b, const teptris_node *n)
+{
+    switch (n->kind) {
+    case TEPTRIS_TABLE:
+        fb_byte(b, 0x01);
+        fb_u32(b, (uint32_t)n->as.table.len);
+        for (size_t i = 0; i < n->as.table.len; i++) {
+            fb_u32(b, (uint32_t)n->as.table.entries[i].key.len);
+            fb_grow(b, n->as.table.entries[i].key.len);
+            if (b->st != TEPTRIS_OK) {
+                return b->st;
+            }
+            memcpy(b->p + b->len, n->as.table.entries[i].key.ptr,
+                   n->as.table.entries[i].key.len);
+            b->len += n->as.table.entries[i].key.len;
+            teptris_status st = flatten_node(b, n->as.table.entries[i].value);
+            if (st != TEPTRIS_OK) {
+                return st;
+            }
+        }
+        return TEPTRIS_OK;
+    case TEPTRIS_ARRAY:
+        fb_byte(b, 0x02);
+        fb_u32(b, (uint32_t)n->as.array.len);
+        for (size_t i = 0; i < n->as.array.len; i++) {
+            teptris_status st = flatten_node(b, n->as.array.items[i]);
+            if (st != TEPTRIS_OK) {
+                return st;
+            }
+        }
+        return TEPTRIS_OK;
+    case TEPTRIS_STRING:
+        fb_byte(b, 0x03);
+        fb_u32(b, (uint32_t)n->as.str.len);
+        fb_grow(b, n->as.str.len);
+        if (b->st != TEPTRIS_OK) {
+            return b->st;
+        }
+        memcpy(b->p + b->len, n->as.str.ptr, n->as.str.len);
+        b->len += n->as.str.len;
+        return TEPTRIS_OK;
+    case TEPTRIS_INTEGER:
+        fb_byte(b, 0x04);
+        fb_i64(b, n->as.i);
+        return TEPTRIS_OK;
+    case TEPTRIS_FLOAT:
+        fb_byte(b, 0x05);
+        fb_f64(b, n->as.f);
+        return TEPTRIS_OK;
+    case TEPTRIS_BOOLEAN:
+        fb_byte(b, n->as.b ? 0x07 : 0x06);
+        return TEPTRIS_OK;
+    case TEPTRIS_DATETIME_OFFSET:
+    case TEPTRIS_DATETIME_LOCAL:
+    case TEPTRIS_DATE_LOCAL:
+    case TEPTRIS_TIME_LOCAL:
+        fb_byte(b, (uint8_t)(0x08 + (n->kind - TEPTRIS_DATETIME_OFFSET)));
+        fb_dt(b, &n->as.dt);
+        return TEPTRIS_OK;
+    default:
+        return TEPTRIS_ERR_STATE;
+    }
+}
+
+teptris_status teptris_document_flatten(const teptris_document *doc,
+                                        uint8_t **buf, size_t *len)
+{
+    if (doc == NULL || doc->root == NULL || buf == NULL || len == NULL) {
+        return TEPTRIS_ERR_ARG;
+    }
+    *buf = NULL;
+    *len = 0;
+    flatbuf b = {NULL, 0, 0, TEPTRIS_OK};
+    fb_grow(&b, 512);
+    teptris_status st = flatten_node(&b, doc->root);
+    if (st != TEPTRIS_OK) {
+        free(b.p);
+        return st;
+    }
+    *buf = b.p;
+    *len = b.len;
+    return TEPTRIS_OK;
+}
+
+void teptris_flatten_free(void *buf)
+{
+    free(buf);
+}
+
+const char *teptris_status_string(teptris_status status)
+{
+    switch (status) {
+    case TEPTRIS_OK:
+        return "ok";
+    case TEPTRIS_ERR_ALLOC:
+        return "out of memory";
+    case TEPTRIS_ERR_SYNTAX:
+        return "syntax error";
+    case TEPTRIS_ERR_SEMANTIC:
+        return "semantic error";
+    case TEPTRIS_ERR_ENCODING:
+        return "invalid encoding";
+    case TEPTRIS_ERR_DEPTH:
+        return "nesting too deep";
+    case TEPTRIS_ERR_ARG:
+        return "invalid argument";
+    case TEPTRIS_ERR_STATE:
+        return "invalid state";
+    default:
+        return "unknown status";
+    }
+}

data/ext/teptris_ext/engine/src/teptris/build.c

@@ -0,0 +1,355 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "teptris/dom/dom.h"
+#include "teptris/teptris.h"
+
+/* Dump-side document construction. The parser assembles nodes from
+ * text; the builder assembles them from materialized values so dump
+ * consumers share the emitter (single formatting source). */
+
+#define BUILDER_MAX_DEPTH 512
+
+enum arr_nature {
+    ARR_UNDECIDED = 0, /* no elements yet */
+    ARR_INLINE,        /* scalar/inline elements: renders [..] */
+    ARR_AOT_SECTIONS   /* table elements: renders [[..]] */
+};
+
+typedef struct bframe {
+    teptris_node *node;
+    bool is_array;
+    uint8_t nature; /* arr_nature when is_array */
+} bframe;
+
+struct teptris_builder {
+    teptris_document *doc; /* NULL once finish() transferred it */
+    bframe stack[BUILDER_MAX_DEPTH];
+    int depth; /* index of the current container */
+};
+
+static teptris_status doc_strdup(teptris_document *doc, const char *src,
+                                 size_t len, teptris_view *out)
+{
+    char *copy = teptris_arena_alloc(&doc->arena, len + 1);
+    if (copy == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    memcpy(copy, src, len);
+    copy[len] = '\0';
+    out->ptr = copy;
+    out->len = len;
+    return TEPTRIS_OK;
+}
+
+static bool datetime_ok(teptris_kind kind, const teptris_datetime *dt)
+{
+    if (dt->hour > 23 || dt->minute > 59 || dt->second > 60 ||
+        dt->nanosecond > 999999999 ||
+        dt->offset_seconds < -86399 || dt->offset_seconds > 86399) {
+        return false;
+    }
+    if (kind == TEPTRIS_TIME_LOCAL) {
+        /* time of day: no date component at all */
+        return dt->year == 0 && dt->month == 0 && dt->day == 0 &&
+               dt->offset_seconds == 0;
+    }
+    if (dt->year > 9999 || dt->month < 1 || dt->month > 12 ||
+        dt->day < 1 || dt->day > 31) {
+        return false;
+    }
+    if (kind == TEPTRIS_DATE_LOCAL &&
+        (dt->hour != 0 || dt->minute != 0 || dt->second != 0 ||
+         dt->nanosecond != 0)) {
+        return false;
+    }
+    if (kind != TEPTRIS_DATETIME_OFFSET && dt->offset_seconds != 0) {
+        return false;
+    }
+    return true;
+}
+
+static const bframe *current(const teptris_builder *b)
+{
+    return &b->stack[b->depth];
+}
+
+/* Attach node to the current container: keyed insert into a table, or
+ * element push into an array (deciding the array's nature). Returns
+ * the attached node for scalar field fills. */
+static teptris_status attach(teptris_builder *b, const char *key,
+                             size_t key_len, bool element_is_table,
+                             teptris_node *n, teptris_node **attached)
+{
+    const bframe *f = current(b);
+    if (f->is_array) {
+        if (element_is_table) {
+            if (f->nature == ARR_UNDECIDED) {
+                /* first element is a table: array of tables */
+                b->stack[b->depth].nature = ARR_AOT_SECTIONS;
+                f->node->flags |= ARR_AOT;
+            }
+            /* tables of an inline array render inline (open_table
+             * picked the flag from the array's nature) */
+        } else if (f->nature == ARR_AOT_SECTIONS) {
+            return TEPTRIS_ERR_ARG; /* [[..]] sections cannot mix values */
+        } else if (f->nature == ARR_UNDECIDED) {
+            b->stack[b->depth].nature = ARR_INLINE;
+        }
+        teptris_status st = teptris_dom_array_push(b->doc, f->node, n);
+        if (st != TEPTRIS_OK) {
+            return st;
+        }
+        *attached = n;
+        return TEPTRIS_OK;
+    }
+    if (key == NULL) {
+        return TEPTRIS_ERR_ARG; /* element push requires an array current */
+    }
+    teptris_view kview;
+    teptris_status st = doc_strdup(b->doc, key, key_len, &kview);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    uint64_t hash;
+    if (teptris_dom_table_find_h(f->node, kview.ptr, kview.len, &hash) != NULL) {
+        return TEPTRIS_ERR_ARG; /* duplicate key */
+    }
+    st = teptris_dom_table_insert_h(b->doc, f->node, kview, hash, n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    *attached = n;
+    return TEPTRIS_OK;
+}
+
+static teptris_status put_scalar(teptris_builder *b, const char *key,
+                                 size_t key_len, teptris_kind kind,
+                                 teptris_node **out)
+{
+    if (b->doc == NULL) {
+        return TEPTRIS_ERR_STATE;
+    }
+    teptris_node *n = teptris_dom_new_node(b->doc, kind);
+    if (n == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    return attach(b, key, key_len, false, n, out);
+}
+
+static teptris_status push_container(teptris_builder *b, const char *key,
+                                     size_t key_len, teptris_node *n,
+                                     bool n_is_array)
+{
+    teptris_node *attached;
+    teptris_status st = attach(b, key, key_len, !n_is_array, n, &attached);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    if (b->depth + 1 >= BUILDER_MAX_DEPTH) {
+        return TEPTRIS_ERR_DEPTH;
+    }
+    b->depth++;
+    b->stack[b->depth].node = n;
+    b->stack[b->depth].is_array = n_is_array;
+    b->stack[b->depth].nature = ARR_UNDECIDED;
+    return TEPTRIS_OK;
+}
+
+teptris_builder *teptris_builder_new(void)
+{
+    teptris_builder *b = calloc(1, sizeof(teptris_builder));
+    if (b == NULL) {
+        return NULL;
+    }
+    teptris_document *doc = calloc(1, sizeof(teptris_document));
+    if (doc == NULL) {
+        free(b);
+        return NULL;
+    }
+    teptris_arena_init(&doc->arena);
+    doc->max_depth = BUILDER_MAX_DEPTH;
+    doc->err.status = TEPTRIS_OK;
+    doc->err.message = "";
+    doc->root = teptris_dom_new_table(doc, TBL_EXPLICIT);
+    if (doc->root == NULL) {
+        teptris_arena_destroy(&doc->arena);
+        free(doc);
+        free(b);
+        return NULL;
+    }
+    b->doc = doc;
+    b->stack[0].node = doc->root;
+    return b;
+}
+
+void teptris_builder_free(teptris_builder *b)
+{
+    if (b == NULL) {
+        return;
+    }
+    teptris_document_free(b->doc); /* NULL after finish() */
+    free(b);
+}
+
+teptris_status teptris_builder_put_string(teptris_builder *b, const char *key,
+                                          size_t key_len, const char *val,
+                                          size_t val_len)
+{
+    teptris_node *n;
+    teptris_status st = put_scalar(b, key, key_len, TEPTRIS_STRING, &n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    return doc_strdup(b->doc, val, val_len, &n->as.str);
+}
+
+teptris_status teptris_builder_put_integer(teptris_builder *b, const char *key,
+                                           size_t key_len, int64_t v)
+{
+    teptris_node *n;
+    teptris_status st = put_scalar(b, key, key_len, TEPTRIS_INTEGER, &n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    n->as.i = v;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_put_float(teptris_builder *b, const char *key,
+                                         size_t key_len, double v)
+{
+    teptris_node *n;
+    teptris_status st = put_scalar(b, key, key_len, TEPTRIS_FLOAT, &n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    n->as.f = v;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_put_boolean(teptris_builder *b, const char *key,
+                                           size_t key_len, bool v)
+{
+    teptris_node *n;
+    teptris_status st = put_scalar(b, key, key_len, TEPTRIS_BOOLEAN, &n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    n->as.b = v;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_put_datetime(teptris_builder *b, const char *key,
+                                            size_t key_len, teptris_kind kind,
+                                            const teptris_datetime *dt)
+{
+    if (kind != TEPTRIS_DATETIME_OFFSET && kind != TEPTRIS_DATETIME_LOCAL &&
+        kind != TEPTRIS_DATE_LOCAL && kind != TEPTRIS_TIME_LOCAL) {
+        return TEPTRIS_ERR_ARG;
+    }
+    if (!datetime_ok(kind, dt)) {
+        return TEPTRIS_ERR_ARG;
+    }
+    teptris_node *n;
+    teptris_status st = put_scalar(b, key, key_len, kind, &n);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    n->as.dt = *dt;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_open_table(teptris_builder *b, const char *key,
+                                          size_t key_len)
+{
+    if (b->doc == NULL) {
+        return TEPTRIS_ERR_STATE;
+    }
+    const bframe *f = current(b);
+    uint8_t flags;
+    if (f->is_array) {
+        /* UNDECIDED means this is the first element: attach() turns the
+         * array into an AOT and the table renders as a section. */
+        flags = (f->nature == ARR_INLINE) ? TBL_INLINE : TBL_EXPLICIT;
+    } else if ((f->node->flags & TBL_INLINE) != 0) {
+        flags = TBL_INLINE; /* tables inside inline tables stay inline */
+    } else {
+        flags = TBL_EXPLICIT;
+    }
+    teptris_node *t = teptris_dom_new_table(b->doc, flags);
+    if (t == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    return push_container(b, key, key_len, t, false);
+}
+
+teptris_status teptris_builder_open_array(teptris_builder *b, const char *key,
+                                          size_t key_len)
+{
+    if (b->doc == NULL) {
+        return TEPTRIS_ERR_STATE;
+    }
+    teptris_node *a = teptris_dom_new_array(b->doc, 0);
+    if (a == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    teptris_status st = push_container(b, key, key_len, a, true);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    /* arrays in inline territory (inside an inline array or an inline
+     * table) can never become [[..]] sections: pin them inline */
+    const bframe *parent = &b->stack[b->depth - 1];
+    bool inline_territory =
+        (parent->is_array && parent->nature == ARR_INLINE) ||
+        (!parent->is_array && (parent->node->flags & TBL_INLINE) != 0);
+    if (inline_territory) {
+        b->stack[b->depth].nature = ARR_INLINE;
+    }
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_open_inline_array(teptris_builder *b,
+                                                 const char *key,
+                                                 size_t key_len)
+{
+    if (b->doc == NULL) {
+        return TEPTRIS_ERR_STATE;
+    }
+    teptris_node *a = teptris_dom_new_array(b->doc, 0);
+    if (a == NULL) {
+        return TEPTRIS_ERR_ALLOC;
+    }
+    teptris_status st = push_container(b, key, key_len, a, true);
+    if (st != TEPTRIS_OK) {
+        return st;
+    }
+    /* explicit inline mode: caller-side lookahead knows the array mixes
+     * tables with values (or wants [..] rendering) */
+    b->stack[b->depth].nature = ARR_INLINE;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_close(teptris_builder *b)
+{
+    if (b->doc == NULL || b->depth == 0) {
+        return TEPTRIS_ERR_STATE;
+    }
+    b->depth--;
+    return TEPTRIS_OK;
+}
+
+teptris_status teptris_builder_finish(teptris_builder *b, teptris_document **out)
+{
+    *out = NULL;
+    if (b->doc == NULL) {
+        return TEPTRIS_ERR_STATE;
+    }
+    if (b->depth != 0) {
+        return TEPTRIS_ERR_STATE; /* unclosed containers */
+    }
+    *out = b->doc;
+    b->doc = NULL;
+    return TEPTRIS_OK;
+}