/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 15 февр. 2021 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
namespace lsp
{
namespace json
{
//---------------------------------------------------------------------
// JSON DOM deserialization routines
status_t dom_drop_stack(lltl::parray *stack, status_t res)
{
for (size_t i=0, n=stack->size(); iuget(i);
if (node != NULL)
delete node;
}
stack->flush();
return res;
}
status_t dom_parse_item(Node **dst, lltl::parray *stack, const event_t *ev)
{
Node *out = NULL;
switch (ev->type)
{
case JE_OBJECT_START:
out = json::Object::allocate();
break;
case JE_ARRAY_START:
out = json::Array::allocate();
break;
case JE_STRING:
out = json::String::allocate(&ev->sValue);
break;
case JE_INTEGER:
out = json::Integer::allocate(ev->iValue);
break;
case JE_DOUBLE:
out = json::Double::allocate(ev->fValue);
break;
case JE_BOOL:
out = json::Boolean::allocate(ev->bValue);
break;
case JE_NULL:
out = json::Node::allocate();
break;
default:
return STATUS_BAD_FORMAT;
}
// Check result
if (out == NULL)
return STATUS_NO_MEM;
*dst = out;
return STATUS_OK;
}
status_t dom_parse(Parser *p, Node *node, bool strict)
{
Node out, *xnode = NULL;
event_t ev;
status_t res;
lltl::parray stack;
// Initialize tree
do
{
Node *last = stack.last();
Node::node_type_t type = (last != NULL) ? last->type() : Node::JN_NULL;
// Read next event
if ((res = p->read_next(&ev)) != STATUS_OK)
return dom_drop_stack(&stack, res);
switch (type)
{
case Node::JN_ARRAY:
{
// Pre-check tokens
if (ev.type == JE_ARRAY_END)
{
stack.pop();
if (stack.is_empty())
out.assign(last);
delete last;
break;
}
else if ((ev.type == JE_OBJECT_END) || (ev.type == JE_PROPERTY))
return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
Array ao(last);
// Parse simple item from event
if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
return dom_drop_stack(&stack, res);
if ((res = ao.add(xnode)) != STATUS_OK)
{
delete xnode;
return dom_drop_stack(&stack, res);
}
break;
}
case Node::JN_OBJECT:
{
// Pre-check tokens
if (ev.type == JE_OBJECT_END)
{
stack.pop();
if (stack.is_empty())
out.assign(last);
delete last;
break;
}
else if (ev.type != JE_PROPERTY)
return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
// Validate and remember the property name
Object jo(last);
if (jo.contains(&ev.sValue)) // Check that object already contains such key
return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
LSPString key;
if (!key.set(&ev.sValue))
return dom_drop_stack(&stack, STATUS_NO_MEM);
// Read next event
if ((res = p->read_next(&ev)) != STATUS_OK)
return dom_drop_stack(&stack, res);
// Parse simple item from event
if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
return dom_drop_stack(&stack, res);
if ((res = jo.set(&key, xnode)) != STATUS_OK)
{
delete xnode;
return dom_drop_stack(&stack, res);
}
break;
}
default:
{
// Parse simple item
if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
return dom_drop_stack(&stack, res);
break;
}
}
// Add extra node to the stack if it is present
if (xnode != NULL)
{
if ((xnode->is_array()) || (xnode->is_object()))
{
if (!stack.push(xnode))
{
delete xnode;
return dom_drop_stack(&stack, STATUS_NO_MEM);
}
}
else
delete xnode;
xnode = NULL;
}
} while (stack.size() > 0);
// Check for EOF
if (strict)
{
if ((res = p->read_next(&ev)) != STATUS_EOF)
return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
}
// Assign node and return
node->assign(out);
return STATUS_OK;
}
status_t dom_load(const char *path, Node *node, json_version_t version, const char *charset)
{
Parser p;
Node tmp;
status_t res = p.open(path, version, charset);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, true);
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
status_t dom_load(const LSPString *path, Node *node, json_version_t version, const char *charset)
{
Parser p;
Node tmp;
status_t res = p.open(path, version, charset);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, true);
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
status_t dom_load(const io::Path *path, Node *node, json_version_t version, const char *charset)
{
Parser p;
Node tmp;
status_t res = p.open(path, version, charset);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, true);
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
size_t build_wflags(size_t flags)
{
size_t wflags = 0;
if (flags & DOM_CLOSE)
wflags |= WRAP_CLOSE;
if (flags & DOM_DELETE)
wflags |= WRAP_DELETE;
return wflags;
}
status_t dom_parse(io::IInStream *is, Node *node, json_version_t version, size_t flags, const char *charset)
{
Parser p;
Node tmp;
size_t wflags = build_wflags(flags);
status_t res = p.wrap(is, version, wflags, charset);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, !(flags & DOM_FLEXIBLE));
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
status_t dom_parse(const LSPString *data, Node *node, json_version_t version)
{
Parser p;
Node tmp;
status_t res = p.wrap(data, version);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, true);
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
status_t dom_parse(const char *data, Node *node, json_version_t version, size_t flags, const char *charset)
{
Parser p;
Node tmp;
status_t res = p.wrap(data, version, charset);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, true);
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
status_t dom_parse(io::IInSequence *is, Node *node, json_version_t version, size_t flags)
{
Parser p;
Node tmp;
size_t wflags = build_wflags(flags);
status_t res = p.wrap(is, version, wflags);
if (res == STATUS_OK)
res = dom_parse(&p, &tmp, !(flags & DOM_FLEXIBLE));
if (res == STATUS_OK)
res = p.close();
else
p.close();
if (res == STATUS_OK)
node->assign(tmp);
return res;
}
//---------------------------------------------------------------------
// JSON DOM serialization routines
status_t dom_serialize(Serializer *s, const Node *node)
{
status_t res;
switch (node->type())
{
case Node::JN_NULL: return s->write_null();
case Node::JN_INT: return s->write_int(lsp::fixed_int(node->as_int().get()));
case Node::JN_DOUBLE: return s->write_double(node->as_double().get());
case Node::JN_BOOL: return s->write_bool(node->as_bool().get());
case Node::JN_STRING:
{
LSPString str;
if ((res = node->as_string().get(&str)) != STATUS_OK)
return res;
return s->write_string(&str);
}
case Node::JN_ARRAY:
{
// Start the array
if ((res = s->start_array()) != STATUS_OK)
return res;
// Serialize the array
Array av = node;
for (size_t i=0, n=av.size(); iend_array();
}
case Node::JN_OBJECT:
{
// Start the object
if ((res = s->start_object()) != STATUS_OK)
return res;
lltl::parray fields;
// Serialize the object
Object ov = node;
if ((res = ov.fields(&fields)) != STATUS_OK)
return res;
// Sort list of fields
fields.qsort();
for (size_t i=0, n=fields.size(); iwrite_property(field)) != STATUS_OK)
return res;
// Property value
Node on = ov.get(field);
if ((res = dom_serialize(s, &on)) != STATUS_OK)
return res;
}
// Complete the object
return s->end_object();
}
default:
break;
}
return STATUS_CORRUPTED;
}
status_t dom_save(const char *path, const Node *node, const serial_flags_t *settings, const char *charset)
{
Serializer s;
status_t res = s.open(path, settings, charset);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
status_t dom_save(const LSPString *path, const Node *node, const serial_flags_t *settings, const char *charset)
{
Serializer s;
status_t res = s.open(path, settings, charset);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
status_t dom_save(const io::Path *path, const Node *node, const serial_flags_t *settings, const char *charset)
{
Serializer s;
status_t res = s.open(path, settings, charset);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
status_t dom_write(io::IOutStream *os, const Node *node, const serial_flags_t *settings, size_t flags, const char *charset)
{
Serializer s;
status_t res = s.wrap(os, settings, flags, charset);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
status_t dom_write(LSPString *data, const Node *node, const serial_flags_t *settings)
{
Serializer s;
status_t res = s.wrap(data, settings);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
status_t dom_write(io::IOutSequence *os, const Node *node, const serial_flags_t *settings, size_t flags)
{
Serializer s;
status_t res = s.wrap(os, settings, flags);
if (res == STATUS_OK)
res = dom_serialize(&s, node);
status_t xres = s.close();
return (res != STATUS_OK) ? res : xres;
}
} /* namespace json */
} /* namespace lsp */