summaryrefslogtreecommitdiff
path: root/thirdparty/lws/misc/lejp.c
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/lws/misc/lejp.c')
-rw-r--r--thirdparty/lws/misc/lejp.c709
1 files changed, 709 insertions, 0 deletions
diff --git a/thirdparty/lws/misc/lejp.c b/thirdparty/lws/misc/lejp.c
new file mode 100644
index 0000000000..5407c90f97
--- /dev/null
+++ b/thirdparty/lws/misc/lejp.c
@@ -0,0 +1,709 @@
+/*
+ * Lightweight Embedded JSON Parser
+ *
+ * Copyright (C) 2013 Andy Green <andy@warmcat.com>
+ * This code is licensed under LGPL 2.1
+ * http://www.gnu.org/licenses/lgpl-2.1.html
+ */
+
+#include <string.h>
+#include "lejp.h"
+
+#include <stdio.h>
+
+/**
+ * lejp_construct - prepare a struct lejp_ctx for use
+ *
+ * \param ctx: pointer to your struct lejp_ctx
+ * \param callback: your user callback which will received parsed tokens
+ * \param user: optional user data pointer untouched by lejp
+ * \param paths: your array of name elements you are interested in
+ * \param count_paths: ARRAY_SIZE() of @paths
+ *
+ * Prepares your context struct for use with lejp
+ */
+
+void
+lejp_construct(struct lejp_ctx *ctx,
+ signed char (*callback)(struct lejp_ctx *ctx, char reason), void *user,
+ const char * const *paths, unsigned char count_paths)
+{
+ ctx->st[0].s = 0;
+ ctx->st[0].p = 0;
+ ctx->st[0].i = 0;
+ ctx->st[0].b = 0;
+ ctx->sp = 0;
+ ctx->ipos = 0;
+ ctx->ppos = 0;
+ ctx->path_match = 0;
+ ctx->path[0] = '\0';
+ ctx->callback = callback;
+ ctx->user = user;
+ ctx->paths = paths;
+ ctx->count_paths = count_paths;
+ ctx->line = 1;
+ ctx->callback(ctx, LEJPCB_CONSTRUCTED);
+}
+
+/**
+ * lejp_destruct - retire a previously constructed struct lejp_ctx
+ *
+ * \param ctx: pointer to your struct lejp_ctx
+ *
+ * lejp does not perform any allocations, but since your user code might, this
+ * provides a one-time LEJPCB_DESTRUCTED callback at destruction time where
+ * you can clean up in your callback.
+ */
+
+void
+lejp_destruct(struct lejp_ctx *ctx)
+{
+ /* no allocations... just let callback know what it happening */
+ ctx->callback(ctx, LEJPCB_DESTRUCTED);
+}
+
+/**
+ * lejp_change_callback - switch to a different callback from now on
+ *
+ * \param ctx: pointer to your struct lejp_ctx
+ * \param callback: your user callback which will received parsed tokens
+ *
+ * This tells the old callback it was destroyed, in case you want to take any
+ * action because that callback "lost focus", then changes to the new
+ * callback and tells it first that it was constructed, and then started.
+ *
+ * Changing callback is a cheap and powerful trick to split out handlers
+ * according to information earlier in the parse. For example you may have
+ * a JSON pair "schema" whose value defines what can be expected for the rest
+ * of the JSON. Rather than having one huge callback for all cases, you can
+ * have an initial one looking for "schema" which then calls
+ * lejp_change_callback() to a handler specific for the schema.
+ *
+ * Notice that afterwards, you need to construct the context again anyway to
+ * parse another JSON object, and the callback is reset then to the main,
+ * schema-interpreting one. The construction action is very lightweight.
+ */
+
+void
+lejp_change_callback(struct lejp_ctx *ctx,
+ signed char (*callback)(struct lejp_ctx *ctx, char reason))
+{
+ ctx->callback(ctx, LEJPCB_DESTRUCTED);
+ ctx->callback = callback;
+ ctx->callback(ctx, LEJPCB_CONSTRUCTED);
+ ctx->callback(ctx, LEJPCB_START);
+}
+
+static void
+lejp_check_path_match(struct lejp_ctx *ctx)
+{
+ const char *p, *q;
+ int n;
+
+ /* we only need to check if a match is not active */
+ for (n = 0; !ctx->path_match && n < ctx->count_paths; n++) {
+ ctx->wildcount = 0;
+ p = ctx->path;
+ q = ctx->paths[n];
+ while (*p && *q) {
+ if (*q != '*') {
+ if (*p != *q)
+ break;
+ p++;
+ q++;
+ continue;
+ }
+ ctx->wild[ctx->wildcount++] = p - ctx->path;
+ q++;
+ /*
+ * if * has something after it, match to .
+ * if ends with *, eat everything.
+ * This implies match sequences must be ordered like
+ * x.*.*
+ * x.*
+ * if both options are possible
+ */
+ while (*p && (*p != '.' || !*q))
+ p++;
+ }
+ if (*p || *q)
+ continue;
+
+ ctx->path_match = n + 1;
+ ctx->path_match_len = ctx->ppos;
+ return;
+ }
+
+ if (!ctx->path_match)
+ ctx->wildcount = 0;
+}
+
+int
+lejp_get_wildcard(struct lejp_ctx *ctx, int wildcard, char *dest, int len)
+{
+ int n;
+
+ if (wildcard >= ctx->wildcount || !len)
+ return 0;
+
+ n = ctx->wild[wildcard];
+
+ while (--len && n < ctx->ppos && (n == ctx->wild[wildcard] || ctx->path[n] != '.'))
+ *dest++ = ctx->path[n++];
+
+ *dest = '\0';
+ n++;
+
+ return n - ctx->wild[wildcard];
+}
+
+/**
+ * lejp_parse - interpret some more incoming data incrementally
+ *
+ * \param ctx: previously constructed parsing context
+ * \param json: char buffer with the new data to interpret
+ * \param len: amount of data in the buffer
+ *
+ * Because lejp is a stream parser, it incrementally parses as new data
+ * becomes available, maintaining all state in the context struct. So an
+ * incomplete JSON is a normal situation, getting you a LEJP_CONTINUE
+ * return, signalling there's no error but to call again with more data when
+ * it comes to complete the parsing. Successful parsing completes with a
+ * 0 or positive integer indicating how much of the last input buffer was
+ * unused.
+ */
+
+int
+lejp_parse(struct lejp_ctx *ctx, const unsigned char *json, int len)
+{
+ unsigned char c, n, s, ret = LEJP_REJECT_UNKNOWN;
+ static const char esc_char[] = "\"\\/bfnrt";
+ static const char esc_tran[] = "\"\\/\b\f\n\r\t";
+ static const char tokens[] = "rue alse ull ";
+
+ if (!ctx->sp && !ctx->ppos)
+ ctx->callback(ctx, LEJPCB_START);
+
+ while (len--) {
+ c = *json++;
+
+ s = ctx->st[ctx->sp].s;
+
+ /* skip whitespace unless we should care */
+ if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '#') {
+ if (c == '\n') {
+ ctx->line++;
+ ctx->st[ctx->sp].s &= ~LEJP_FLAG_WS_COMMENTLINE;
+ }
+ if (!(s & LEJP_FLAG_WS_KEEP)) {
+ if (c == '#')
+ ctx->st[ctx->sp].s |=
+ LEJP_FLAG_WS_COMMENTLINE;
+ continue;
+ }
+ }
+
+ if (ctx->st[ctx->sp].s & LEJP_FLAG_WS_COMMENTLINE)
+ continue;
+
+ switch (s) {
+ case LEJP_IDLE:
+ if (c != '{') {
+ ret = LEJP_REJECT_IDLE_NO_BRACE;
+ goto reject;
+ }
+ if (ctx->callback(ctx, LEJPCB_OBJECT_START)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ ctx->st[ctx->sp].s = LEJP_MEMBERS;
+ break;
+ case LEJP_MEMBERS:
+ if (c == '}') {
+ ctx->st[ctx->sp].s = LEJP_IDLE;
+ ret = LEJP_REJECT_MEMBERS_NO_CLOSE;
+ goto reject;
+ }
+ ctx->st[ctx->sp].s = LEJP_M_P;
+ goto redo_character;
+ case LEJP_M_P:
+ if (c != '\"') {
+ ret = LEJP_REJECT_MP_NO_OPEN_QUOTE;
+ goto reject;
+ }
+ /* push */
+ ctx->st[ctx->sp].s = LEJP_MP_DELIM;
+ c = LEJP_MP_STRING;
+ goto add_stack_level;
+
+ case LEJP_MP_STRING:
+ if (c == '\"') {
+ if (!ctx->sp) {
+ ret = LEJP_REJECT_MP_STRING_UNDERRUN;
+ goto reject;
+ }
+ if (ctx->st[ctx->sp - 1].s != LEJP_MP_DELIM) {
+ ctx->buf[ctx->npos] = '\0';
+ if (ctx->callback(ctx,
+ LEJPCB_VAL_STR_END) < 0) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ }
+ /* pop */
+ ctx->sp--;
+ break;
+ }
+ if (c == '\\') {
+ ctx->st[ctx->sp].s = LEJP_MP_STRING_ESC;
+ break;
+ }
+ if (c < ' ') {/* "control characters" not allowed */
+ ret = LEJP_REJECT_MP_ILLEGAL_CTRL;
+ goto reject;
+ }
+ goto emit_string_char;
+
+ case LEJP_MP_STRING_ESC:
+ if (c == 'u') {
+ ctx->st[ctx->sp].s = LEJP_MP_STRING_ESC_U1;
+ ctx->uni = 0;
+ break;
+ }
+ for (n = 0; n < sizeof(esc_char); n++) {
+ if (c != esc_char[n])
+ continue;
+ /* found it */
+ c = esc_tran[n];
+ ctx->st[ctx->sp].s = LEJP_MP_STRING;
+ goto emit_string_char;
+ }
+ ret = LEJP_REJECT_MP_STRING_ESC_ILLEGAL_ESC;
+ /* illegal escape char */
+ goto reject;
+
+ case LEJP_MP_STRING_ESC_U1:
+ case LEJP_MP_STRING_ESC_U2:
+ case LEJP_MP_STRING_ESC_U3:
+ case LEJP_MP_STRING_ESC_U4:
+ ctx->uni <<= 4;
+ if (c >= '0' && c <= '9')
+ ctx->uni |= c - '0';
+ else
+ if (c >= 'a' && c <= 'f')
+ ctx->uni = c - 'a' + 10;
+ else
+ if (c >= 'A' && c <= 'F')
+ ctx->uni = c - 'A' + 10;
+ else {
+ ret = LEJP_REJECT_ILLEGAL_HEX;
+ goto reject;
+ }
+ ctx->st[ctx->sp].s++;
+ switch (s) {
+ case LEJP_MP_STRING_ESC_U2:
+ if (ctx->uni < 0x08)
+ break;
+ /*
+ * 0x08-0xff (0x0800 - 0xffff)
+ * emit 3-byte UTF-8
+ */
+ c = 0xe0 | ((ctx->uni >> 4) & 0xf);
+ goto emit_string_char;
+
+ case LEJP_MP_STRING_ESC_U3:
+ if (ctx->uni >= 0x080) {
+ /*
+ * 0x080 - 0xfff (0x0800 - 0xffff)
+ * middle 3-byte seq
+ * send ....XXXXXX..
+ */
+ c = 0x80 | ((ctx->uni >> 2) & 0x3f);
+ goto emit_string_char;
+ }
+ if (ctx->uni < 0x008)
+ break;
+ /*
+ * 0x008 - 0x7f (0x0080 - 0x07ff)
+ * start 2-byte seq
+ */
+ c = 0xc0 | (ctx->uni >> 2);
+ goto emit_string_char;
+
+ case LEJP_MP_STRING_ESC_U4:
+ if (ctx->uni >= 0x0080)
+ /* end of 2 or 3-byte seq */
+ c = 0x80 | (ctx->uni & 0x3f);
+ else
+ /* literal */
+ c = (unsigned char)ctx->uni;
+
+ ctx->st[ctx->sp].s = LEJP_MP_STRING;
+ goto emit_string_char;
+ default:
+ break;
+ }
+ break;
+
+ case LEJP_MP_DELIM:
+ if (c != ':') {
+ ret = LEJP_REJECT_MP_DELIM_MISSING_COLON;
+ goto reject;
+ }
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE;
+ ctx->path[ctx->ppos] = '\0';
+
+ lejp_check_path_match(ctx);
+ if (ctx->callback(ctx, LEJPCB_PAIR_NAME)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ break;
+
+ case LEJP_MP_VALUE:
+ if (c >= '0' && c <= '9') {
+ ctx->npos = 0;
+ ctx->dcount = 0;
+ ctx->f = 0;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_NUM_INT;
+ goto redo_character;
+ }
+ switch (c) {
+ case'\"':
+ /* push */
+ ctx->st[ctx->sp].s = LEJP_MP_COMMA_OR_END;
+ c = LEJP_MP_STRING;
+ ctx->npos = 0;
+ ctx->buf[0] = '\0';
+ if (ctx->callback(ctx, LEJPCB_VAL_STR_START)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ goto add_stack_level;
+
+ case '{':
+ /* push */
+ ctx->st[ctx->sp].s = LEJP_MP_COMMA_OR_END;
+ c = LEJP_MEMBERS;
+ lejp_check_path_match(ctx);
+ if (ctx->callback(ctx, LEJPCB_OBJECT_START)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ ctx->path_match = 0;
+ goto add_stack_level;
+
+ case '[':
+ /* push */
+ ctx->st[ctx->sp].s = LEJP_MP_ARRAY_END;
+ c = LEJP_MP_VALUE;
+ ctx->path[ctx->ppos++] = '[';
+ ctx->path[ctx->ppos++] = ']';
+ ctx->path[ctx->ppos] = '\0';
+ if (ctx->callback(ctx, LEJPCB_ARRAY_START)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ ctx->i[ctx->ipos++] = 0;
+ if (ctx->ipos > ARRAY_SIZE(ctx->i)) {
+ ret = LEJP_REJECT_MP_DELIM_ISTACK;
+ goto reject;
+ }
+ goto add_stack_level;
+
+ case 't': /* true */
+ ctx->uni = 0;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_TOK;
+ break;
+
+ case 'f':
+ ctx->uni = 4;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_TOK;
+ break;
+
+ case 'n':
+ ctx->uni = 4 + 5;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_TOK;
+ break;
+ default:
+ ret = LEJP_REJECT_MP_DELIM_BAD_VALUE_START;
+ goto reject;
+ }
+ break;
+
+ case LEJP_MP_VALUE_NUM_INT:
+ if (!ctx->npos && c == '-') {
+ ctx->f |= LEJP_SEEN_MINUS;
+ goto append_npos;
+ }
+
+ if (ctx->dcount < 10 && c >= '0' && c <= '9') {
+ if (ctx->f & LEJP_SEEN_POINT)
+ ctx->f |= LEJP_SEEN_POST_POINT;
+ ctx->dcount++;
+ goto append_npos;
+ }
+ if (c == '.') {
+ if (ctx->dcount || (ctx->f & LEJP_SEEN_POINT)) {
+ ret = LEJP_REJECT_MP_VAL_NUM_FORMAT;
+ goto reject;
+ }
+ ctx->f |= LEJP_SEEN_POINT;
+ goto append_npos;
+ }
+ /*
+ * before exponent, if we had . we must have had at
+ * least one more digit
+ */
+ if ((ctx->f &
+ (LEJP_SEEN_POINT | LEJP_SEEN_POST_POINT)) ==
+ LEJP_SEEN_POINT) {
+ ret = LEJP_REJECT_MP_VAL_NUM_INT_NO_FRAC;
+ goto reject;
+ }
+ if (c == 'e' || c == 'E') {
+ if (ctx->f & LEJP_SEEN_EXP) {
+ ret = LEJP_REJECT_MP_VAL_NUM_FORMAT;
+ goto reject;
+ }
+ ctx->f |= LEJP_SEEN_EXP;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_NUM_EXP;
+ goto append_npos;
+ }
+ /* if none of the above, did we even have a number? */
+ if (!ctx->dcount) {
+ ret = LEJP_REJECT_MP_VAL_NUM_FORMAT;
+ goto reject;
+ }
+
+ ctx->buf[ctx->npos] = '\0';
+ if (ctx->f & LEJP_SEEN_POINT) {
+ if (ctx->callback(ctx, LEJPCB_VAL_NUM_FLOAT)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ } else {
+ if (ctx->callback(ctx, LEJPCB_VAL_NUM_INT)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ }
+
+ /* then this is the post-number character, loop */
+ ctx->st[ctx->sp].s = LEJP_MP_COMMA_OR_END;
+ goto redo_character;
+
+ case LEJP_MP_VALUE_NUM_EXP:
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE_NUM_INT;
+ if (c >= '0' && c <= '9')
+ goto redo_character;
+ if (c == '+' || c == '-')
+ goto append_npos;
+ ret = LEJP_REJECT_MP_VAL_NUM_EXP_BAD_EXP;
+ goto reject;
+
+ case LEJP_MP_VALUE_TOK: /* true, false, null */
+ if (c != tokens[ctx->uni]) {
+ ret = LEJP_REJECT_MP_VAL_TOK_UNKNOWN;
+ goto reject;
+ }
+ ctx->uni++;
+ if (tokens[ctx->uni] != ' ')
+ break;
+ switch (ctx->uni) {
+ case 3:
+ ctx->buf[0] = '1';
+ ctx->buf[1] = '\0';
+ if (ctx->callback(ctx, LEJPCB_VAL_TRUE)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ break;
+ case 8:
+ ctx->buf[0] = '0';
+ ctx->buf[1] = '\0';
+ if (ctx->callback(ctx, LEJPCB_VAL_FALSE)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ break;
+ case 12:
+ ctx->buf[0] = '\0';
+ if (ctx->callback(ctx, LEJPCB_VAL_NULL)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ break;
+ }
+ ctx->st[ctx->sp].s = LEJP_MP_COMMA_OR_END;
+ break;
+
+ case LEJP_MP_COMMA_OR_END:
+ ctx->path[ctx->ppos] = '\0';
+ if (c == ',') {
+ /* increment this stack level's index */
+ ctx->st[ctx->sp].s = LEJP_M_P;
+ if (!ctx->sp) {
+ ctx->ppos = 0;
+ /*
+ * since we came back to root level,
+ * no path can still match
+ */
+ ctx->path_match = 0;
+ break;
+ }
+ ctx->ppos = ctx->st[ctx->sp - 1].p;
+ ctx->path[ctx->ppos] = '\0';
+ if (ctx->path_match &&
+ ctx->ppos <= ctx->path_match_len)
+ /*
+ * we shrank the path to be
+ * smaller than the matching point
+ */
+ ctx->path_match = 0;
+
+ if (ctx->st[ctx->sp - 1].s != LEJP_MP_ARRAY_END)
+ break;
+ /* top level is definitely an array... */
+ if (ctx->ipos)
+ ctx->i[ctx->ipos - 1]++;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE;
+ break;
+ }
+ if (c == ']') {
+ if (!ctx->sp) {
+ ret = LEJP_REJECT_MP_C_OR_E_UNDERF;
+ goto reject;
+ }
+ /* pop */
+ ctx->sp--;
+ if (ctx->st[ctx->sp].s != LEJP_MP_ARRAY_END) {
+ ret = LEJP_REJECT_MP_C_OR_E_NOTARRAY;
+ goto reject;
+ }
+ /* drop the path [n] bit */
+ ctx->ppos = ctx->st[ctx->sp - 1].p;
+ ctx->ipos = ctx->st[ctx->sp - 1].i;
+ ctx->path[ctx->ppos] = '\0';
+ if (ctx->path_match &&
+ ctx->ppos <= ctx->path_match_len)
+ /*
+ * we shrank the path to be
+ * smaller than the matching point
+ */
+ ctx->path_match = 0;
+
+ /* do LEJP_MP_ARRAY_END processing */
+ goto redo_character;
+ }
+ if (c == '}') {
+ if (ctx->sp == 0) {
+ lejp_check_path_match(ctx);
+ if (ctx->callback(ctx, LEJPCB_OBJECT_END)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ ctx->callback(ctx, LEJPCB_COMPLETE);
+ /* done, return unused amount */
+ return len;
+ }
+ /* pop */
+ ctx->sp--;
+ ctx->ppos = ctx->st[ctx->sp - 1].p;
+ ctx->ipos = ctx->st[ctx->sp - 1].i;
+ ctx->path[ctx->ppos] = '\0';
+ if (ctx->path_match &&
+ ctx->ppos <= ctx->path_match_len)
+ /*
+ * we shrank the path to be
+ * smaller than the matching point
+ */
+ ctx->path_match = 0;
+ lejp_check_path_match(ctx);
+ if (ctx->callback(ctx, LEJPCB_OBJECT_END)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ break;
+ }
+
+ ret = LEJP_REJECT_MP_C_OR_E_NEITHER;
+ goto reject;
+
+ case LEJP_MP_ARRAY_END:
+ ctx->path[ctx->ppos] = '\0';
+ if (c == ',') {
+ /* increment this stack level's index */
+ if (ctx->ipos)
+ ctx->i[ctx->ipos - 1]++;
+ ctx->st[ctx->sp].s = LEJP_MP_VALUE;
+ if (ctx->sp)
+ ctx->ppos = ctx->st[ctx->sp - 1].p;
+ ctx->path[ctx->ppos] = '\0';
+ break;
+ }
+ if (c != ']') {
+ ret = LEJP_REJECT_MP_ARRAY_END_MISSING;
+ goto reject;
+ }
+
+ ctx->st[ctx->sp].s = LEJP_MP_COMMA_OR_END;
+ ctx->callback(ctx, LEJPCB_ARRAY_END);
+ break;
+ }
+
+ continue;
+
+emit_string_char:
+ if (!ctx->sp || ctx->st[ctx->sp - 1].s != LEJP_MP_DELIM) {
+ /* assemble the string value into chunks */
+ ctx->buf[ctx->npos++] = c;
+ if (ctx->npos == sizeof(ctx->buf) - 1) {
+ if (ctx->callback(ctx, LEJPCB_VAL_STR_CHUNK)) {
+ ret = LEJP_REJECT_CALLBACK;
+ goto reject;
+ }
+ ctx->npos = 0;
+ }
+ continue;
+ }
+ /* name part of name:value pair */
+ ctx->path[ctx->ppos++] = c;
+ continue;
+
+add_stack_level:
+ /* push on to the object stack */
+ if (ctx->ppos && ctx->st[ctx->sp].s != LEJP_MP_COMMA_OR_END &&
+ ctx->st[ctx->sp].s != LEJP_MP_ARRAY_END)
+ ctx->path[ctx->ppos++] = '.';
+
+ ctx->st[ctx->sp].p = ctx->ppos;
+ ctx->st[ctx->sp].i = ctx->ipos;
+ if (++ctx->sp == ARRAY_SIZE(ctx->st)) {
+ ret = LEJP_REJECT_STACK_OVERFLOW;
+ goto reject;
+ }
+ ctx->path[ctx->ppos] = '\0';
+ ctx->st[ctx->sp].s = c;
+ ctx->st[ctx->sp].b = 0;
+ continue;
+
+append_npos:
+ if (ctx->npos >= sizeof(ctx->buf)) {
+ ret = LEJP_REJECT_NUM_TOO_LONG;
+ goto reject;
+ }
+ ctx->buf[ctx->npos++] = c;
+ continue;
+
+redo_character:
+ json--;
+ len++;
+ }
+
+ return LEJP_CONTINUE;
+
+reject:
+ ctx->callback(ctx, LEJPCB_FAILED);
+ return ret;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 05:49:44 +0000