struct json_node *json_parser_parse(json_parser_t p, const char *json_str)
{
int c;
struct json_node *n;
p->buf = json_str;
p->cp = p->buf;
p->err_msg = 0;
p->parse_level = 0;
p->max_level = 1000;
n = json_parse_value(p);
if (!n)
return 0;
if (p->err_msg)
{
json_remove_node(n);
return 0;
}
c = look_ch(p);
if (c != 0)
{
p->err_msg = "extra characters";
json_remove_node(n);
return 0;
}
return n;
}
int main(int argc, char **argv)
{
struct json_node *n;
int print = 0;
int ret;
char *arg;
while ((ret = options("p", argv, argc, &arg)) != YAZ_OPTIONS_EOF)
{
switch (ret)
{
case 'p':
print++;
break;
default:
usage(argv[0]);
}
}
n = do_parse_from_stdin();
if (!n)
exit(1);
if (print)
{
WRBUF result = wrbuf_alloc();
if (print > 1)
json_write_wrbuf_pretty(n, result);
else
json_write_wrbuf(n, result);
puts(wrbuf_cstr(result));
wrbuf_destroy(result);
}
json_remove_node(n);
return 0;
}
static struct json_node *json_parse_members(json_parser_t p)
{
struct json_node *n1 = json_parse_pair(p);
struct json_node *m0, *m1;
if (!n1)
return 0;
m0 = m1 = json_new_node(p, json_node_list);
m1->u.link[0] = n1;
while (look_ch(p) == ',')
{
struct json_node *n2, *m2;
move_ch(p);
n2 = json_parse_pair(p);
if (!n2)
{
json_remove_node(m0);
return 0;
}
m2 = json_new_node(p, json_node_list);
m2->u.link[0] = n2;
m1->u.link[1] = m2;
m1 = m2;
}
return m0;
}
static struct json_node *json_parse_array(json_parser_t p)
{
struct json_node *n;
if (look_ch(p) != '[')
{
p->err_msg = "expecting [";
return 0;
}
move_ch(p);
if (p->parse_level >= p->max_level)
{
p->err_msg = "Too much nesting";
return 0;
}
p->parse_level++;
n = json_new_node(p, json_node_array);
if (look_ch(p) != ']')
n->u.link[0] = json_parse_elements(p);
p->parse_level--;
if (look_ch(p) != ']')
{
if (!p->err_msg)
p->err_msg = "expecting ]";
json_remove_node(n);
return 0;
}
move_ch(p);
return n;
}
int read_recordtype_json_desc(void * root,void * record)
{
int ret;
void * data;
void * struct_template;
DB_RECORD * db_record=record;
DB_RECORD * struct_record;
struct struct_desc_record * struct_desc;
struct struct_recordtype * recordtype;
void * temp_node;
if(db_record->head.type <=0)
return -EINVAL;
struct_template=memdb_get_template(db_record->head.type,db_record->head.subtype);
if(struct_template==NULL)
return -EINVAL;
ret=Galloc0(&recordtype,sizeof(struct struct_recordtype));
if(ret<0)
return ret;
temp_node=json_find_elem("uuid",root);
if(temp_node==NULL)
return -EINVAL;
char * uuid_str=json_get_valuestr(temp_node);
if(!Isvaliduuid(uuid_str))
{
struct_record=memdb_find_byname(uuid_str,DB_STRUCT_DESC,0);
if(struct_record==NULL)
return -EINVAL;
Memcpy(recordtype->uuid,struct_record->head.uuid,DIGEST_SIZE);
ret=json_remove_node(temp_node);
}
ret=json_2_struct(root,recordtype,struct_template);
// namelist->elem_no=json_get_elemno(temp_node);
db_record->record=recordtype;
ret=memdb_comp_uuid(db_record);
if(ret<0)
return ret;
ret=memdb_store_record(db_record);
if(ret<0)
return ret;
ret=memdb_register_dynamicdb(recordtype->type,recordtype->subtype);
return ret;
}
static struct json_node *json_parse_object(json_parser_t p)
{
struct json_node *n;
if (look_ch(p) != '{')
{
p->err_msg = "{ expected";
return 0;
}
move_ch(p);
n = json_new_node(p, json_node_object);
if (look_ch(p) != '}')
{
struct json_node *m;
if (p->parse_level >= p->max_level)
{
p->err_msg = "Too much nesting";
json_remove_node(n);
return 0;
}
p->parse_level++;
m = json_parse_members(p);
p->parse_level--;
if (!m)
{
json_remove_node(n);
return 0;
}
n->u.link[0] = m;
}
if (look_ch(p) != '}')
{
p->err_msg = "Missing }";
json_remove_node(n);
return 0;
}
move_ch(p);
return n;
}
void json_remove_node(struct json_node *n)
{
if (!n)
return;
switch (n->type)
{
case json_node_object:
case json_node_array:
case json_node_list:
case json_node_pair:
json_remove_node(n->u.link[0]);
json_remove_node(n->u.link[1]);
break;
case json_node_string:
xfree(n->u.string);
break;
case json_node_number:
case json_node_true:
case json_node_false:
case json_node_null:
break;
}
xfree(n);
}
int json_append_array(struct json_node *dst, struct json_node *src)
{
if (dst && src &&
dst->type == json_node_array && src->type == json_node_array)
{
struct json_node **np = &dst->u.link[0];
while (*np)
np = &(*np)->u.link[1];
*np = src->u.link[0];
src->u.link[0] = 0;
json_remove_node(src);
return 0;
}
return -1;
}
static struct json_node *json_parse_pair(json_parser_t p)
{
struct json_node *s = json_parse_string(p);
struct json_node *v, *n;
if (!s)
return 0;
if (look_ch(p) != ':')
{
p->err_msg = "missing :";
json_remove_node(s);
return 0;
}
move_ch(p);
v = json_parse_value(p);
if (!v)
{
json_remove_node(s);
return 0;
}
n = json_new_node(p, json_node_pair);
n->u.link[0] = s;
n->u.link[1] = v;
return n;
}
