1150 lines
29 KiB
C
1150 lines
29 KiB
C
/*
|
|
* $Id$
|
|
*
|
|
Copyright (c) 2016-2018 Chung, Hyung-Hwan. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <mio-json.h>
|
|
#include <mio-chr.h>
|
|
#include <mio-fmt.h>
|
|
#include "mio-prv.h"
|
|
|
|
#define MIO_JSON_TOKEN_NAME_ALIGN 64
|
|
|
|
/* ========================================================================= */
|
|
|
|
static void clear_token (mio_json_t* json)
|
|
{
|
|
json->tok.len = 0;
|
|
if (json->tok_capa > 0) json->tok.ptr[json->tok.len] = '\0';
|
|
}
|
|
|
|
static int add_char_to_token (mio_json_t* json, mio_ooch_t ch)
|
|
{
|
|
if (json->tok.len >= json->tok_capa)
|
|
{
|
|
mio_ooch_t* tmp;
|
|
mio_oow_t newcapa;
|
|
|
|
newcapa = MIO_ALIGN_POW2(json->tok.len + 2, MIO_JSON_TOKEN_NAME_ALIGN); /* +2 here because of -1 when setting newcapa */
|
|
tmp = (mio_ooch_t*)mio_reallocmem(json->mio, json->tok.ptr, newcapa * MIO_SIZEOF(*tmp));
|
|
if (!tmp) return -1;
|
|
|
|
json->tok_capa = newcapa - 1; /* -1 to secure space for terminating null */
|
|
json->tok.ptr = tmp;
|
|
}
|
|
|
|
json->tok.ptr[json->tok.len++] = ch;
|
|
json->tok.ptr[json->tok.len] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
static int add_chars_to_token (mio_json_t* json, const mio_ooch_t* ptr, mio_oow_t len)
|
|
{
|
|
mio_oow_t i;
|
|
|
|
if (json->tok_capa - json->tok.len > len)
|
|
{
|
|
mio_ooch_t* tmp;
|
|
mio_oow_t newcapa;
|
|
|
|
newcapa = MIO_ALIGN_POW2(json->tok.len + len + 1, MIO_JSON_TOKEN_NAME_ALIGN);
|
|
tmp = (mio_ooch_t*)mio_reallocmem(json->mio, json->tok.ptr, newcapa * MIO_SIZEOF(*tmp));
|
|
if (!tmp) return -1;
|
|
|
|
json->tok_capa = newcapa - 1;
|
|
json->tok.ptr = tmp;
|
|
}
|
|
|
|
for (i = 0; i < len; i++)
|
|
json->tok.ptr[json->tok.len++] = ptr[i];
|
|
json->tok.ptr[json->tok.len] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
static MIO_INLINE mio_ooch_t unescape (mio_ooch_t c)
|
|
{
|
|
switch (c)
|
|
{
|
|
case 'a': return '\a';
|
|
case 'b': return '\b';
|
|
case 'f': return '\f';
|
|
case 'n': return '\n';
|
|
case 'r': return '\r';
|
|
case 't': return '\t';
|
|
case 'v': return '\v';
|
|
default: return c;
|
|
}
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int push_read_state (mio_json_t* json, mio_json_state_t state)
|
|
{
|
|
mio_json_state_node_t* ss;
|
|
|
|
ss = (mio_json_state_node_t*)mio_callocmem(json->mio, MIO_SIZEOF(*ss));
|
|
if (MIO_UNLIKELY(!ss)) return -1;
|
|
|
|
ss->state = state;
|
|
ss->level = json->state_stack->level; /* copy from the parent */
|
|
ss->next = json->state_stack;
|
|
|
|
json->state_stack = ss;
|
|
return 0;
|
|
}
|
|
|
|
static void pop_read_state (mio_json_t* json)
|
|
{
|
|
mio_json_state_node_t* ss;
|
|
|
|
ss = json->state_stack;
|
|
MIO_ASSERT (json->mio, ss != MIO_NULL && ss != &json->state_top);
|
|
json->state_stack = ss->next;
|
|
|
|
if (json->state_stack->state == MIO_JSON_STATE_IN_ARRAY)
|
|
{
|
|
json->state_stack->u.ia.got_value = 1;
|
|
}
|
|
else if (json->state_stack->state == MIO_JSON_STATE_IN_DIC)
|
|
{
|
|
json->state_stack->u.id.state++;
|
|
}
|
|
|
|
/* TODO: don't free this. move it to the free list? */
|
|
mio_freemem (json->mio, ss);
|
|
}
|
|
|
|
static void pop_all_read_states (mio_json_t* json)
|
|
{
|
|
while (json->state_stack != &json->state_top) pop_read_state (json);
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int invoke_data_inst (mio_json_t* json, mio_json_inst_t inst)
|
|
{
|
|
if (json->state_stack->state == MIO_JSON_STATE_IN_DIC && json->state_stack->u.id.state == 1)
|
|
{
|
|
if (inst != MIO_JSON_INST_STRING)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "dictionary key not a string - %.*js", json->tok.len, json->tok.ptr);
|
|
return -1;
|
|
}
|
|
|
|
inst = MIO_JSON_INST_KEY;
|
|
}
|
|
|
|
return json->instcb(json, inst, json->state_stack->level, &json->tok);
|
|
}
|
|
|
|
static int handle_string_value_char (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
int ret = 1;
|
|
|
|
if (json->state_stack->u.sv.escaped == 3)
|
|
{
|
|
if (c >= '0' && c <= '7')
|
|
{
|
|
json->state_stack->u.sv.acc = json->state_stack->u.sv.acc * 8 + c - '0';
|
|
json->state_stack->u.sv.digit_count++;
|
|
if (json->state_stack->u.sv.digit_count >= json->state_stack->u.sv.escaped) goto add_sv_acc;
|
|
}
|
|
else
|
|
{
|
|
ret = 0;
|
|
goto add_sv_acc;
|
|
}
|
|
}
|
|
else if (json->state_stack->u.sv.escaped >= 2)
|
|
{
|
|
if (c >= '0' && c <= '9')
|
|
{
|
|
json->state_stack->u.sv.acc = json->state_stack->u.sv.acc * 16 + c - '0';
|
|
json->state_stack->u.sv.digit_count++;
|
|
if (json->state_stack->u.sv.digit_count >= json->state_stack->u.sv.escaped) goto add_sv_acc;
|
|
}
|
|
else if (c >= 'a' && c <= 'f')
|
|
{
|
|
json->state_stack->u.sv.acc = json->state_stack->u.sv.acc * 16 + c - 'a' + 10;
|
|
json->state_stack->u.sv.digit_count++;
|
|
if (json->state_stack->u.sv.digit_count >= json->state_stack->u.sv.escaped) goto add_sv_acc;
|
|
}
|
|
else if (c >= 'A' && c <= 'F')
|
|
{
|
|
json->state_stack->u.sv.acc = json->state_stack->u.sv.acc * 16 + c - 'A' + 10;
|
|
json->state_stack->u.sv.digit_count++;
|
|
if (json->state_stack->u.sv.digit_count >= json->state_stack->u.sv.escaped) goto add_sv_acc;
|
|
}
|
|
else
|
|
{
|
|
ret = 0;
|
|
add_sv_acc:
|
|
#if defined(MIO_OOCH_IS_UCH)
|
|
if (add_char_to_token(json, json->state_stack->u.sv.acc) <= -1) return -1;
|
|
#else
|
|
/* convert the character to utf8 */
|
|
{
|
|
mio_bch_t bcsbuf[MIO_BCSIZE_MAX];
|
|
mio_oow_t n;
|
|
|
|
n = json->mio->_cmgr->uctobc(json->state_stack->u.sv.acc, bcsbuf, MIO_COUNTOF(bcsbuf));
|
|
if (n == 0 || n > MIO_COUNTOF(bcsbuf))
|
|
{
|
|
/* illegal character or buffer to small */
|
|
mio_seterrbfmt (json->mio, MIO_EECERR, "unable to convert %jc", json->state_stack->u.sv.acc);
|
|
return -1;
|
|
}
|
|
|
|
if (add_chars_to_token(json, bcsbuf, n) <= -1) return -1;
|
|
}
|
|
#endif
|
|
json->state_stack->u.sv.escaped = 0;
|
|
}
|
|
}
|
|
else if (json->state_stack->u.sv.escaped == 1)
|
|
{
|
|
if (c >= '0' && c <= '8')
|
|
{
|
|
json->state_stack->u.sv.escaped = 3;
|
|
json->state_stack->u.sv.digit_count = 0;
|
|
json->state_stack->u.sv.acc = c - '0';
|
|
}
|
|
else if (c == 'x')
|
|
{
|
|
json->state_stack->u.sv.escaped = 2;
|
|
json->state_stack->u.sv.digit_count = 0;
|
|
json->state_stack->u.sv.acc = 0;
|
|
}
|
|
else if (c == 'u')
|
|
{
|
|
/* TOOD: handle UTF-16 surrogate pair U+1D11E -> \uD834\uDD1E*/
|
|
json->state_stack->u.sv.escaped = 4;
|
|
json->state_stack->u.sv.digit_count = 0;
|
|
json->state_stack->u.sv.acc = 0;
|
|
}
|
|
else if (c == 'U')
|
|
{
|
|
json->state_stack->u.sv.escaped = 8;
|
|
json->state_stack->u.sv.digit_count = 0;
|
|
json->state_stack->u.sv.acc = 0;
|
|
}
|
|
else
|
|
{
|
|
json->state_stack->u.sv.escaped = 0;
|
|
if (add_char_to_token(json, unescape(c)) <= -1) return -1;
|
|
}
|
|
}
|
|
else if (c == '\\')
|
|
{
|
|
json->state_stack->u.sv.escaped = 1;
|
|
}
|
|
else if (c == '\"')
|
|
{
|
|
pop_read_state (json);
|
|
if (invoke_data_inst(json, MIO_JSON_INST_STRING) <= -1) return -1;
|
|
}
|
|
else
|
|
{
|
|
if (add_char_to_token(json, c) <= -1) return -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int handle_numeric_value_char (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
if (mio_is_ooch_digit(c) || (json->tok.len == 0 && (c == '+' || c == '-')))
|
|
{
|
|
if (add_char_to_token(json, c) <= -1) return -1;
|
|
return 1;
|
|
}
|
|
else if (!json->state_stack->u.nv.dotted && c == '.' &&
|
|
json->tok.len > 0 && mio_is_ooch_digit(json->tok.ptr[json->tok.len - 1]))
|
|
{
|
|
if (add_char_to_token(json, c) <= -1) return -1;
|
|
json->state_stack->u.nv.dotted = 1;
|
|
return 1;
|
|
}
|
|
|
|
pop_read_state (json);
|
|
|
|
MIO_ASSERT (json->mio, json->tok.len > 0);
|
|
if (!mio_is_ooch_digit(json->tok.ptr[json->tok.len - 1]))
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "invalid numeric value - %.*js", json->tok.len, json->tok.ptr);
|
|
return -1;
|
|
}
|
|
if (invoke_data_inst(json, MIO_JSON_INST_NUMBER) <= -1) return -1;
|
|
return 0; /* start over */
|
|
}
|
|
|
|
static int handle_word_value_char (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
mio_json_inst_t inst;
|
|
|
|
if (mio_is_ooch_alpha(c))
|
|
{
|
|
if (add_char_to_token(json, c) <= -1) return -1;
|
|
return 1;
|
|
}
|
|
|
|
pop_read_state (json);
|
|
|
|
if (mio_comp_oochars_bcstr(json->tok.ptr, json->tok.len, "null", 0) == 0) inst = MIO_JSON_INST_NIL;
|
|
else if (mio_comp_oochars_bcstr(json->tok.ptr, json->tok.len, "true", 0) == 0) inst = MIO_JSON_INST_TRUE;
|
|
else if (mio_comp_oochars_bcstr(json->tok.ptr, json->tok.len, "false", 0) == 0) inst = MIO_JSON_INST_FALSE;
|
|
else
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "invalid word value - %.*js", json->tok.len, json->tok.ptr);
|
|
return -1;
|
|
}
|
|
|
|
if (invoke_data_inst(json, inst) <= -1) return -1;
|
|
return 0; /* start over */
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int handle_start_char (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
printf ("HANDLE START CHAR [%c]\n", c);
|
|
if (c == '[')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_ARRAY) <= -1) return -1;
|
|
json->state_stack->u.ia.got_value = 0;
|
|
if (json->instcb(json, MIO_JSON_INST_START_ARRAY, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
json->state_stack->level++;
|
|
return 1;
|
|
}
|
|
else if (c == '{')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_DIC) <= -1) return -1;
|
|
json->state_stack->u.id.state = 0;
|
|
if (json->instcb(json, MIO_JSON_INST_START_DIC, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
json->state_stack->level++;
|
|
return 1;
|
|
}
|
|
#if 0
|
|
/* this check is not needed for screening in feed_json_data() */
|
|
else if (mio_is_ooch_space(c))
|
|
{
|
|
/* do nothing */
|
|
return 1;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "not starting with [ or { - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static int handle_char_in_array (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
if (c == ']')
|
|
{
|
|
if (json->instcb(json, MIO_JSON_INST_END_ARRAY, json->state_stack->level - 1, MIO_NULL) <= -1) return -1;
|
|
pop_read_state (json);
|
|
return 1;
|
|
}
|
|
else if (c == ',')
|
|
{
|
|
if (!json->state_stack->u.ia.got_value)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "redundant comma in array - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
json->state_stack->u.ia.got_value = 0;
|
|
return 1;
|
|
}
|
|
else if (mio_is_ooch_space(c))
|
|
{
|
|
/* do nothing */
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if (json->state_stack->u.ia.got_value)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "comma required in array - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
|
|
if (c == '\"')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_STRING_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
return 1;
|
|
}
|
|
/* TOOD: else if (c == '#') MIO radixed number
|
|
*/
|
|
else if (mio_is_ooch_digit(c) || c == '+' || c == '-')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_NUMERIC_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
json->state_stack->u.nv.dotted = 0;
|
|
return 0; /* start over */
|
|
}
|
|
else if (mio_is_ooch_alpha(c))
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_WORD_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
return 0; /* start over */
|
|
}
|
|
else if (c == '[')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_ARRAY) <= -1) return -1;
|
|
json->state_stack->u.ia.got_value = 0;
|
|
if (json->instcb(json, MIO_JSON_INST_START_ARRAY, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
json->state_stack->level++;
|
|
return 1;
|
|
}
|
|
else if (c == '{')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_DIC) <= -1) return -1;
|
|
json->state_stack->u.id.state = 0;
|
|
if (json->instcb(json, MIO_JSON_INST_START_DIC, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
json->state_stack->level++;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "wrong character inside array - %jc[%d]", (mio_ooch_t)c, (int)c);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int handle_char_in_dic (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
if (c == '}')
|
|
{
|
|
if (json->instcb(json, MIO_JSON_INST_END_DIC, json->state_stack->level - 1, MIO_NULL) <= -1) return -1;
|
|
pop_read_state (json);
|
|
return 1;
|
|
}
|
|
else if (c == ':')
|
|
{
|
|
if (json->state_stack->u.id.state != 1)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "redundant colon in dictionary - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
json->state_stack->u.id.state++;
|
|
return 1;
|
|
}
|
|
else if (c == ',')
|
|
{
|
|
if (json->state_stack->u.id.state != 3)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "redundant comma in dicitonary - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
json->state_stack->u.id.state = 0;
|
|
return 1;
|
|
}
|
|
else if (mio_is_ooch_space(c))
|
|
{
|
|
/* do nothing */
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if (json->state_stack->u.id.state == 1)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "colon required in dicitonary - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
else if (json->state_stack->u.id.state == 3)
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "comma required in dicitonary - %jc", (mio_ooch_t)c);
|
|
return -1;
|
|
}
|
|
|
|
if (c == '\"')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_STRING_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
return 1;
|
|
}
|
|
/* TOOD: else if (c == '#') MIO radixed number
|
|
*/
|
|
else if (mio_is_ooch_digit(c) || c == '+' || c == '-')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_NUMERIC_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
json->state_stack->u.nv.dotted = 0;
|
|
return 0; /* start over */
|
|
}
|
|
else if (mio_is_ooch_alpha(c))
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_WORD_VALUE) <= -1) return -1;
|
|
clear_token (json);
|
|
return 0; /* start over */
|
|
}
|
|
else if (c == '[')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_ARRAY) <= -1) return -1;
|
|
json->state_stack->u.ia.got_value = 0;
|
|
json->state_stack->level++;
|
|
if (json->instcb(json, MIO_JSON_INST_START_ARRAY, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
return 1;
|
|
}
|
|
else if (c == '{')
|
|
{
|
|
if (push_read_state(json, MIO_JSON_STATE_IN_DIC) <= -1) return -1;
|
|
json->state_stack->u.id.state = 0;
|
|
json->state_stack->level++;
|
|
if (json->instcb(json, MIO_JSON_INST_START_DIC, json->state_stack->level, MIO_NULL) <= -1) return -1;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EINVAL, "wrong character inside dictionary - %jc[%d]", (mio_ooch_t)c, (int)c);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int handle_char (mio_json_t* json, mio_ooci_t c)
|
|
{
|
|
int x;
|
|
|
|
start_over:
|
|
if (c == MIO_OOCI_EOF)
|
|
{
|
|
if (json->state_stack->state == MIO_JSON_STATE_START)
|
|
{
|
|
/* no input data */
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
mio_seterrbfmt (json->mio, MIO_EBADRE, "unexpected end of data");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
switch (json->state_stack->state)
|
|
{
|
|
case MIO_JSON_STATE_START:
|
|
x = handle_start_char(json, c);
|
|
break;
|
|
|
|
case MIO_JSON_STATE_IN_ARRAY:
|
|
x = handle_char_in_array(json, c);
|
|
break;
|
|
|
|
case MIO_JSON_STATE_IN_DIC:
|
|
x = handle_char_in_dic(json, c);
|
|
break;
|
|
|
|
case MIO_JSON_STATE_IN_WORD_VALUE:
|
|
x = handle_word_value_char(json, c);
|
|
break;
|
|
|
|
case MIO_JSON_STATE_IN_STRING_VALUE:
|
|
x = handle_string_value_char(json, c);
|
|
break;
|
|
|
|
case MIO_JSON_STATE_IN_NUMERIC_VALUE:
|
|
x = handle_numeric_value_char(json, c);
|
|
break;
|
|
|
|
default:
|
|
mio_seterrbfmt (json->mio, MIO_EINTERN, "internal error - must not be called for state %d", (int)json->state_stack->state);
|
|
return -1;
|
|
}
|
|
|
|
if (x <= -1) return -1;
|
|
if (x == 0) goto start_over;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int feed_json_data (mio_json_t* json, const mio_bch_t* data, mio_oow_t len, mio_oow_t* xlen, int stop_if_ever_completed)
|
|
{
|
|
const mio_bch_t* ptr;
|
|
const mio_bch_t* end;
|
|
int ever_completed = 0;
|
|
|
|
ptr = data;
|
|
end = ptr + len;
|
|
|
|
while (ptr < end)
|
|
{
|
|
mio_ooci_t c;
|
|
const mio_bch_t* optr;
|
|
|
|
#if defined(MIO_OOCH_IS_UCH)
|
|
mio_ooch_t uc;
|
|
mio_oow_t bcslen;
|
|
mio_oow_t n;
|
|
|
|
optr = ptr;
|
|
bcslen = end - ptr;
|
|
n = json->mio->_cmgr->bctouc(ptr, bcslen, &uc);
|
|
if (n == 0)
|
|
{
|
|
/* invalid sequence */
|
|
uc = *ptr;
|
|
n = 1;
|
|
}
|
|
else if (n > bcslen)
|
|
{
|
|
/* incomplete sequence */
|
|
*xlen = ptr - data;
|
|
return 0; /* feed more for incomplete sequence */
|
|
}
|
|
|
|
ptr += n;
|
|
c = uc;
|
|
#else
|
|
optr = ptr;
|
|
c = *ptr++;
|
|
#endif
|
|
|
|
if (json->state_stack->state == MIO_JSON_STATE_START && mio_is_ooch_space(c)) continue; /* skip white space */
|
|
if (stop_if_ever_completed && ever_completed)
|
|
{
|
|
*xlen = optr - data;
|
|
return 2;
|
|
}
|
|
|
|
/* handle a signle character */
|
|
if (handle_char(json, c) <= -1) goto oops;
|
|
if (json->state_stack->state == MIO_JSON_STATE_START) ever_completed = 1;
|
|
}
|
|
|
|
*xlen = ptr - data;
|
|
return (stop_if_ever_completed && ever_completed)? 2: 1;
|
|
|
|
oops:
|
|
/* TODO: compute the number of processed bytes so far and return it via a parameter??? */
|
|
/*printf ("feed oops....\n");*/
|
|
return -1;
|
|
}
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
mio_json_t* mio_json_open (mio_t* mio, mio_oow_t xtnsize)
|
|
{
|
|
mio_json_t* json;
|
|
|
|
json = (mio_json_t*)mio_allocmem(mio, MIO_SIZEOF(*json) + xtnsize);
|
|
if (MIO_LIKELY(json))
|
|
{
|
|
if (mio_json_init(json, mio) <= -1)
|
|
{
|
|
mio_freemem (mio, json);
|
|
return MIO_NULL;
|
|
}
|
|
else
|
|
{
|
|
MIO_MEMSET (json + 1, 0, xtnsize);
|
|
}
|
|
}
|
|
|
|
return json;
|
|
}
|
|
|
|
void mio_json_close (mio_json_t* json)
|
|
{
|
|
mio_json_fini (json);
|
|
mio_freemem (json->mio, json);
|
|
}
|
|
|
|
static int do_nothing_on_inst (mio_json_t* json, mio_json_inst_t inst, mio_oow_t level, const mio_oocs_t* str)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int mio_json_init (mio_json_t* json, mio_t* mio)
|
|
{
|
|
MIO_MEMSET (json, 0, MIO_SIZEOF(*json));
|
|
|
|
json->mio = mio;
|
|
json->instcb = do_nothing_on_inst;
|
|
json->state_top.state = MIO_JSON_STATE_START;
|
|
json->state_top.next = MIO_NULL;
|
|
json->state_stack = &json->state_top;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void mio_json_fini (mio_json_t* json)
|
|
{
|
|
pop_all_read_states (json);
|
|
if (json->tok.ptr)
|
|
{
|
|
mio_freemem (json->mio, json->tok.ptr);
|
|
json->tok.ptr = MIO_NULL;
|
|
}
|
|
}
|
|
/* ========================================================================= */
|
|
|
|
void mio_json_setinstcb (mio_json_t* json, mio_json_instcb_t instcb)
|
|
{
|
|
json->instcb = instcb;
|
|
}
|
|
|
|
mio_json_state_t mio_json_getstate (mio_json_t* json)
|
|
{
|
|
return json->state_stack->state;
|
|
}
|
|
|
|
void mio_json_resetstates (mio_json_t* json)
|
|
{
|
|
pop_all_read_states (json);
|
|
MIO_ASSERT (json->mio, json->state_stack == &json->state_top);
|
|
json->state_stack->state = MIO_JSON_STATE_START;
|
|
}
|
|
|
|
int mio_json_feed (mio_json_t* json, const void* ptr, mio_oow_t len, mio_oow_t* rem, int stop_if_ever_completed)
|
|
{
|
|
int x;
|
|
mio_oow_t total, ylen;
|
|
const mio_bch_t* buf;
|
|
|
|
buf = (const mio_bch_t*)ptr;
|
|
total = 0;
|
|
while (total < len)
|
|
{
|
|
x = feed_json_data(json, &buf[total], len - total, &ylen, stop_if_ever_completed);
|
|
if (x <= -1) return -1;
|
|
|
|
total += ylen;
|
|
if (x == 0) break; /* incomplete sequence encountered */
|
|
|
|
if (stop_if_ever_completed && x >= 2)
|
|
{
|
|
*rem = len - total;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
*rem = len - total;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
static int push_write_state (mio_jsonwr_t* jsonwr, mio_json_state_t state)
|
|
{
|
|
mio_jsonwr_state_node_t* ss;
|
|
|
|
ss = (mio_jsonwr_state_node_t*)mio_callocmem(jsonwr->mio, MIO_SIZEOF(*ss));
|
|
if (MIO_UNLIKELY(!ss)) return -1;
|
|
|
|
ss->state = state;
|
|
ss->level = jsonwr->state_stack->level; /* copy from the parent */
|
|
ss->next = jsonwr->state_stack;
|
|
|
|
jsonwr->state_stack = ss;
|
|
return 0;
|
|
}
|
|
|
|
static void pop_write_state (mio_jsonwr_t* jsonwr)
|
|
{
|
|
mio_jsonwr_state_node_t* ss;
|
|
|
|
ss = jsonwr->state_stack;
|
|
MIO_ASSERT (jsonwr->mio, ss != MIO_NULL && ss != &jsonwr->state_top);
|
|
jsonwr->state_stack = ss->next;
|
|
|
|
/* TODO: don't free this. move it to the free list? */
|
|
mio_freemem (jsonwr->mio, ss);
|
|
}
|
|
|
|
static void pop_all_write_states (mio_jsonwr_t* jsonwr)
|
|
{
|
|
while (jsonwr->state_stack != &jsonwr->state_top) pop_write_state (jsonwr);
|
|
}
|
|
|
|
mio_jsonwr_t* mio_jsonwr_open (mio_t* mio, mio_oow_t xtnsize)
|
|
{
|
|
mio_jsonwr_t* jsonwr;
|
|
|
|
jsonwr = (mio_jsonwr_t*)mio_allocmem(mio, MIO_SIZEOF(*jsonwr) + xtnsize);
|
|
if (MIO_LIKELY(jsonwr))
|
|
{
|
|
if (mio_jsonwr_init(jsonwr, mio) <= -1)
|
|
{
|
|
mio_freemem (mio, jsonwr);
|
|
return MIO_NULL;
|
|
}
|
|
else
|
|
{
|
|
MIO_MEMSET (jsonwr + 1, 0, xtnsize);
|
|
}
|
|
}
|
|
|
|
return jsonwr;
|
|
}
|
|
|
|
void mio_jsonwr_close (mio_jsonwr_t* jsonwr)
|
|
{
|
|
mio_jsonwr_fini (jsonwr);
|
|
mio_freemem (jsonwr->mio, jsonwr);
|
|
}
|
|
|
|
static int write_nothing (mio_jsonwr_t* jsonwr, const mio_bch_t* dptr, mio_oow_t dlen, void* ctx)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int mio_jsonwr_init (mio_jsonwr_t* jsonwr, mio_t* mio)
|
|
{
|
|
MIO_MEMSET (jsonwr, 0, MIO_SIZEOF(*jsonwr));
|
|
|
|
jsonwr->mio = mio;
|
|
jsonwr->writecb = write_nothing;
|
|
|
|
jsonwr->state_top.state = MIO_JSON_STATE_START;
|
|
jsonwr->state_top.next = MIO_NULL;
|
|
jsonwr->state_stack = &jsonwr->state_top;
|
|
return 0;
|
|
}
|
|
|
|
static int flush_wbuf (mio_jsonwr_t* jsonwr)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (jsonwr->writecb(jsonwr, jsonwr->wbuf, jsonwr->wbuf_len, jsonwr->wctx) <= -1) ret = -1;
|
|
jsonwr->wbuf_len = 0; /* reset the buffer length regardless of writing result */
|
|
|
|
return ret;
|
|
}
|
|
|
|
void mio_jsonwr_fini (mio_jsonwr_t* jsonwr)
|
|
{
|
|
if (jsonwr->wbuf_len > 0) flush_wbuf (jsonwr); /* don't care about actual write failure */
|
|
pop_all_write_states (jsonwr);
|
|
}
|
|
|
|
/* ========================================================================= */
|
|
|
|
void mio_jsonwr_setwritecb (mio_jsonwr_t* jsonwr, mio_jsonwr_writecb_t writecb, void* ctx)
|
|
{
|
|
jsonwr->writecb = writecb;
|
|
jsonwr->wctx = ctx;
|
|
}
|
|
|
|
static int escape_char (mio_uch_t uch, mio_uch_t* xch)
|
|
{
|
|
int x = 1;
|
|
|
|
switch (uch)
|
|
{
|
|
case '\"':
|
|
case '\\':
|
|
*xch = uch;
|
|
break;
|
|
|
|
case '\b':
|
|
*xch = 'b';
|
|
break;
|
|
|
|
case '\f':
|
|
*xch = 'f';
|
|
break;
|
|
|
|
case '\n':
|
|
*xch = 'n';
|
|
break;
|
|
|
|
case '\r':
|
|
*xch = 'r';
|
|
break;
|
|
|
|
case '\t':
|
|
*xch = 't';
|
|
break;
|
|
|
|
default:
|
|
x = (uch >= 0 && uch <= 0x1f)? 2: 0;
|
|
break;
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
static int write_bytes_noesc (mio_jsonwr_t* jsonwr, const mio_bch_t* dptr, mio_oow_t dlen)
|
|
{
|
|
mio_oow_t rem;
|
|
do
|
|
{
|
|
rem = MIO_COUNTOF(jsonwr->wbuf) - jsonwr->wbuf_len;
|
|
|
|
if (dlen <= rem)
|
|
{
|
|
MIO_MEMCPY (&jsonwr->wbuf[jsonwr->wbuf_len], dptr, dlen);
|
|
jsonwr->wbuf_len += dlen;
|
|
if (dlen == rem && flush_wbuf(jsonwr) <= -1) return -1;
|
|
break;
|
|
}
|
|
|
|
MIO_MEMCPY (&jsonwr->wbuf[jsonwr->wbuf_len], dptr, rem);
|
|
jsonwr->wbuf_len += rem;
|
|
dptr += rem;
|
|
dlen -= rem;
|
|
if (flush_wbuf(jsonwr) <= -1) return -1;
|
|
}
|
|
while (dlen > 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int write_bytes_esc (mio_jsonwr_t* jsonwr, const mio_bch_t* dptr, mio_oow_t dlen)
|
|
{
|
|
const mio_bch_t* dend = dptr + dlen;
|
|
|
|
while (dptr < dend)
|
|
{
|
|
int e;
|
|
mio_uch_t ec;
|
|
e = escape_char(*dptr, &ec);
|
|
if (e <= 0)
|
|
{
|
|
jsonwr->wbuf[jsonwr->wbuf_len++] = *dptr;
|
|
if (jsonwr->wbuf_len >= MIO_COUNTOF(jsonwr->wbuf) && flush_wbuf(jsonwr) <= -1) return -1;
|
|
}
|
|
else if (e == 1)
|
|
{
|
|
jsonwr->wbuf[jsonwr->wbuf_len++] = '\\';
|
|
if (jsonwr->wbuf_len >= MIO_COUNTOF(jsonwr->wbuf) && flush_wbuf(jsonwr) <= -1) return -1;
|
|
jsonwr->wbuf[jsonwr->wbuf_len++] = ec;
|
|
if (jsonwr->wbuf_len >= MIO_COUNTOF(jsonwr->wbuf) && flush_wbuf(jsonwr) <= -1) return -1;
|
|
}
|
|
else
|
|
{
|
|
mio_bch_t bcsbuf[7];
|
|
bcsbuf[0] = '\\';
|
|
bcsbuf[1] = 'u';
|
|
mio_fmt_uintmax_to_bcstr(&bcsbuf[2], 5, *dptr, 10, 4, '0', MIO_NULL);
|
|
if (write_bytes_noesc(jsonwr, bcsbuf, 6) <= -1) return -1;
|
|
}
|
|
|
|
dptr++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int write_uchars (mio_jsonwr_t* jsonwr, int escape, const mio_uch_t* ptr, mio_oow_t len)
|
|
{
|
|
mio_t* mio = mio_jsonwr_getmio(jsonwr);
|
|
const mio_uch_t* end = ptr + len;
|
|
mio_bch_t bcsbuf[MIO_BCSIZE_MAX + 4];
|
|
mio_oow_t n;
|
|
|
|
while (ptr < end)
|
|
{
|
|
if (escape)
|
|
{
|
|
int e;
|
|
mio_uch_t ec;
|
|
e = escape_char(*ptr, &ec);
|
|
if (e <= 0) goto no_escape;
|
|
else if (e == 1)
|
|
{
|
|
bcsbuf[0] = '\\';
|
|
bcsbuf[1] = ec;
|
|
n = 2;
|
|
}
|
|
else
|
|
{
|
|
bcsbuf[0] = '\\';
|
|
bcsbuf[1] = 'u';
|
|
mio_fmt_uintmax_to_bcstr(&bcsbuf[2], 5, *ptr, 10, 4, '0', MIO_NULL);
|
|
n = 6;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
no_escape:
|
|
n = mio->_cmgr->uctobc(*ptr, bcsbuf, MIO_COUNTOF(bcsbuf));
|
|
if (n == 0)
|
|
{
|
|
mio_seterrnum (mio, MIO_EECERR);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
ptr++;
|
|
if (write_bytes_noesc(jsonwr, bcsbuf, n) <= -1) return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define WRITE_BYTES_NOESC(jsonwr,dptr,dlen) do { if (write_bytes_noesc(jsonwr, dptr, dlen) <= -1) return -1; } while(0)
|
|
#define WRITE_BYTES_ESC(jsonwr,dptr,dlen) do { if (write_bytes_esc(jsonwr, dptr, dlen) <= -1) return -1; } while(0)
|
|
|
|
#define WRITE_UCHARS(jsonwr,esc,dptr,dlen) do { if (write_uchars(jsonwr, esc, dptr, dlen) <= -1) return -1; } while(0)
|
|
|
|
#define WRITE_LINE_BREAK(jsonwr) WRITE_BYTES_NOESC(jsonwr, "\n", 1)
|
|
|
|
#define WRITE_COMMA(jsonwr) do { WRITE_BYTES_NOESC(jsonwr, ",", 1); if (jsonwr->pretty) WRITE_LINE_BREAK(jsonwr); } while(0)
|
|
|
|
#define PREACTION_FOR_VLAUE(jsonwr,sn) do { \
|
|
if (sn->state != MIO_JSON_STATE_IN_ARRAY && !(sn->state == MIO_JSON_STATE_IN_DIC && sn->dic_awaiting_val)) goto incompatible_inst; \
|
|
if (sn->index > 0 && sn->state == MIO_JSON_STATE_IN_ARRAY) WRITE_COMMA (jsonwr); \
|
|
sn->index++; \
|
|
sn->dic_awaiting_val = 0; \
|
|
if (jsonwr->pretty && sn->state == MIO_JSON_STATE_IN_ARRAY) WRITE_INDENT (jsonwr); \
|
|
} while(0)
|
|
|
|
#define WRITE_INDENT(jsonwr) do { mio_oow_t i; for (i = 0; i < jsonwr->state_stack->level; i++) WRITE_BYTES_NOESC (jsonwr, "\t", 1); } while(0)
|
|
|
|
int mio_jsonwr_write (mio_jsonwr_t* jsonwr, mio_json_inst_t inst, int is_uchars, const void* dptr, mio_oow_t dlen)
|
|
{
|
|
mio_jsonwr_state_node_t* sn = jsonwr->state_stack;
|
|
|
|
/* ============================= */
|
|
jsonwr->pretty = 1;
|
|
/* ============================= */
|
|
|
|
switch (inst)
|
|
{
|
|
case MIO_JSON_INST_START_ARRAY:
|
|
if (sn->state != MIO_JSON_STATE_START && sn->state != MIO_JSON_STATE_IN_ARRAY &&
|
|
!(sn->state == MIO_JSON_STATE_IN_DIC && sn->dic_awaiting_val)) goto incompatible_inst;
|
|
if (sn->index > 0) WRITE_COMMA (jsonwr);
|
|
sn->index++;
|
|
sn->dic_awaiting_val = 0;
|
|
if (jsonwr->pretty) WRITE_INDENT (jsonwr);
|
|
WRITE_BYTES_NOESC (jsonwr, "[", 1);
|
|
if (jsonwr->pretty) WRITE_LINE_BREAK (jsonwr);
|
|
if (push_write_state(jsonwr, MIO_JSON_STATE_IN_ARRAY) <= -1) return -1;
|
|
jsonwr->state_stack->level++;
|
|
break;
|
|
|
|
case MIO_JSON_INST_START_DIC:
|
|
if (sn->state != MIO_JSON_STATE_START && sn->state != MIO_JSON_STATE_IN_ARRAY &&
|
|
!(sn->state == MIO_JSON_STATE_IN_DIC && !sn->dic_awaiting_val)) goto incompatible_inst;
|
|
if (sn->index > 0) WRITE_COMMA (jsonwr);
|
|
sn->index++;
|
|
sn->dic_awaiting_val = 0;
|
|
if (jsonwr->pretty) WRITE_INDENT (jsonwr);
|
|
WRITE_BYTES_NOESC (jsonwr, "{", 1);
|
|
if (jsonwr->pretty) WRITE_LINE_BREAK (jsonwr);
|
|
if (push_write_state (jsonwr, MIO_JSON_STATE_IN_DIC) <= -1) return -1;
|
|
jsonwr->state_stack->level++;
|
|
break;
|
|
|
|
case MIO_JSON_INST_END_ARRAY:
|
|
if (sn->state != MIO_JSON_STATE_IN_ARRAY) goto incompatible_inst;
|
|
pop_write_state (jsonwr);
|
|
if (jsonwr->pretty)
|
|
{
|
|
WRITE_LINE_BREAK (jsonwr);
|
|
WRITE_INDENT (jsonwr);
|
|
}
|
|
WRITE_BYTES_NOESC (jsonwr, "]", 1);
|
|
if (jsonwr->state_stack->state == MIO_JSON_STATE_START)
|
|
{
|
|
/* end of json */
|
|
if (jsonwr->pretty) WRITE_LINE_BREAK (jsonwr);
|
|
if (jsonwr->wbuf_len > 0 && flush_wbuf(jsonwr) <= -1) return -1;
|
|
}
|
|
break;
|
|
|
|
case MIO_JSON_INST_END_DIC:
|
|
if (sn->state != MIO_JSON_STATE_IN_DIC || sn->dic_awaiting_val) goto incompatible_inst;
|
|
pop_write_state (jsonwr);
|
|
if (jsonwr->pretty)
|
|
{
|
|
WRITE_LINE_BREAK (jsonwr);
|
|
WRITE_INDENT (jsonwr);
|
|
}
|
|
WRITE_BYTES_NOESC (jsonwr, "}", 1);
|
|
if (jsonwr->state_stack->state == MIO_JSON_STATE_START)
|
|
{
|
|
/* end of json */
|
|
if (jsonwr->pretty) WRITE_LINE_BREAK (jsonwr);
|
|
if (jsonwr->wbuf_len > 0 && flush_wbuf(jsonwr) <= -1) return -1;
|
|
}
|
|
break;
|
|
|
|
case MIO_JSON_INST_KEY:
|
|
if (sn->state != MIO_JSON_STATE_IN_DIC || sn->dic_awaiting_val) goto incompatible_inst;
|
|
if (sn->index > 0) WRITE_COMMA (jsonwr);
|
|
if (jsonwr->pretty) WRITE_INDENT (jsonwr);
|
|
WRITE_BYTES_NOESC (jsonwr, "\"", 1);
|
|
if (is_uchars) WRITE_UCHARS (jsonwr, 1, dptr, dlen);
|
|
else WRITE_BYTES_ESC (jsonwr, dptr, dlen);
|
|
WRITE_BYTES_NOESC (jsonwr, "\": ", 3);
|
|
sn->dic_awaiting_val = 1;
|
|
break;
|
|
|
|
case MIO_JSON_INST_NIL:
|
|
PREACTION_FOR_VLAUE (jsonwr, sn);
|
|
WRITE_BYTES_NOESC (jsonwr, "nil", 3);
|
|
break;
|
|
|
|
case MIO_JSON_INST_TRUE:
|
|
PREACTION_FOR_VLAUE (jsonwr, sn);
|
|
WRITE_BYTES_NOESC (jsonwr, "true", 4);
|
|
break;
|
|
|
|
case MIO_JSON_INST_FALSE:
|
|
PREACTION_FOR_VLAUE (jsonwr, sn);
|
|
WRITE_BYTES_NOESC (jsonwr, "false", 5);
|
|
break;
|
|
|
|
case MIO_JSON_INST_NUMBER:
|
|
PREACTION_FOR_VLAUE (jsonwr, sn);
|
|
if (is_uchars)
|
|
WRITE_UCHARS (jsonwr, 0, dptr, dlen);
|
|
else
|
|
WRITE_BYTES_NOESC (jsonwr, dptr, dlen);
|
|
break;
|
|
|
|
case MIO_JSON_INST_STRING:
|
|
PREACTION_FOR_VLAUE (jsonwr, sn);
|
|
WRITE_BYTES_NOESC (jsonwr, "\"", 1);
|
|
if (is_uchars) WRITE_UCHARS (jsonwr, 1, dptr, dlen);
|
|
else WRITE_BYTES_ESC (jsonwr, dptr, dlen);
|
|
WRITE_BYTES_NOESC (jsonwr, "\"", 1);
|
|
break;
|
|
|
|
default:
|
|
incompatible_inst:
|
|
flush_wbuf(jsonwr);
|
|
mio_seterrbfmt (jsonwr->mio, MIO_EINVAL, "incompatiable write instruction - %d", (int)inst);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|