/*
* Copyright (C) 2026 Linux Studio Plugins Project
* (C) 2026 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 16 окт. 2019 г.
*
* 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
#include
namespace lsp
{
namespace json
{
Parser::Parser()
{
pTokenizer = NULL;
pSequence = NULL;
nWFlags = 0;
enVersion = JSON_LEGACY;
sState.mode = READ_ROOT;
sState.flags = 0;
sCurrent.type = JE_UNKNOWN;
}
Parser::~Parser()
{
close();
}
status_t Parser::open(const char *path, json_version_t version, const char *charset)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream *ifs = new io::InFileStream();
if (ifs == NULL)
return STATUS_NO_MEM;
status_t res = ifs->open(path);
if (res == STATUS_OK)
{
res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ifs->close();
}
delete ifs;
return res;
}
status_t Parser::open(const LSPString *path, json_version_t version, const char *charset)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream *ifs = new io::InFileStream();
if (ifs == NULL)
return STATUS_NO_MEM;
status_t res = ifs->open(path);
if (res == STATUS_OK)
{
res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ifs->close();
}
delete ifs;
return res;
}
status_t Parser::open(const io::Path *path, json_version_t version, const char *charset)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream *ifs = new io::InFileStream();
if (ifs == NULL)
return STATUS_NO_MEM;
status_t res = ifs->open(path);
if (res == STATUS_OK)
{
res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ifs->close();
}
delete ifs;
return res;
}
status_t Parser::wrap(const char *str, json_version_t version, const char *charset)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (str == NULL)
return STATUS_BAD_ARGUMENTS;
io::InStringSequence *seq = new io::InStringSequence();
if (seq == NULL)
return STATUS_NO_MEM;
status_t res = seq->wrap(str, charset);
if (res == STATUS_OK)
{
if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
return res;
seq->close();
}
delete seq;
return res;
}
status_t Parser::wrap(const LSPString *str, json_version_t version)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (str == NULL)
return STATUS_BAD_ARGUMENTS;
io::InStringSequence *seq = new io::InStringSequence();
if (seq == NULL)
return STATUS_NO_MEM;
status_t res = seq->wrap(str);
if (res == STATUS_OK)
{
if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
return res;
seq->close();
}
delete seq;
return res;
}
status_t Parser::wrap(io::IInStream *is, json_version_t version, size_t flags, const char *charset)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (is == NULL)
return STATUS_BAD_ARGUMENTS;
io::InSequence *seq = new io::InSequence();
if (seq == NULL)
return STATUS_NO_MEM;
status_t res = seq->wrap(is, flags, charset);
if (res == STATUS_OK)
{
if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
return res;
seq->close();
}
delete seq;
return res;
}
status_t Parser::wrap(io::IInSequence *seq, json_version_t version, size_t flags)
{
if (pTokenizer != NULL)
return STATUS_BAD_STATE;
else if (seq == NULL)
return STATUS_BAD_ARGUMENTS;
Tokenizer *tok = new Tokenizer(seq);
if (tok == NULL)
return STATUS_NO_MEM;
pTokenizer = tok;
pSequence = seq;
nWFlags = flags;
enVersion = version;
sState.mode = READ_ROOT;
sState.flags = 0;
return STATUS_OK;
}
status_t Parser::close()
{
status_t res = STATUS_OK;
if (pTokenizer != NULL)
{
delete pTokenizer;
pTokenizer = NULL;
}
if (pSequence != NULL)
{
if (nWFlags & WRAP_CLOSE)
res = update_status(res, pSequence->close());
if (nWFlags & WRAP_DELETE)
delete pSequence;
pSequence = NULL;
}
sCurrent.type = JE_UNKNOWN;
sCurrent.sValue.truncate();
sStack.flush();
return res;
}
status_t Parser::push_state(pmode_t mode)
{
if (!sStack.add(&sState))
return STATUS_NO_MEM;
sState.mode = mode;
sState.flags = 0;
return STATUS_OK;
}
status_t Parser::pop_state()
{
state_t *st = sStack.last();
if (st == NULL)
return STATUS_BAD_STATE;
sState = *st;
return (sStack.pop()) ? STATUS_OK : STATUS_BAD_STATE;
}
token_t Parser::lookup_token()
{
return pTokenizer->get_token(true);
}
status_t Parser::get_current(event_t *ev)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
if (ev == NULL)
return STATUS_BAD_ARGUMENTS;
switch (sCurrent.type)
{
case JE_OBJECT_START:
case JE_OBJECT_END:
case JE_ARRAY_START:
case JE_ARRAY_END:
case JE_UNKNOWN:
case JE_NULL:
break;
case JE_PROPERTY:
case JE_STRING:
if (!ev->sValue.set(&sCurrent.sValue))
return STATUS_NO_MEM;
break;
case JE_INTEGER:
ev->iValue = sCurrent.iValue;
break;
case JE_DOUBLE:
ev->fValue = sCurrent.fValue;
break;
case JE_BOOL:
ev->bValue = sCurrent.bValue;
break;
default:
return STATUS_BAD_STATE;
}
ev->type = sCurrent.type;
return STATUS_OK;
}
status_t Parser::read_primitive(token_t tok)
{
switch (tok)
{
case JT_DQ_STRING:
if (!sCurrent.sValue.set(pTokenizer->text_value()))
return STATUS_NO_MEM;
sCurrent.type = JE_STRING;
break;
case JT_TRUE:
case JT_FALSE:
sCurrent.bValue = (tok == JT_TRUE);
sCurrent.type = JE_BOOL;
break;
case JT_NULL:
sCurrent.type = JE_NULL;
break;
case JT_DECIMAL:
sCurrent.iValue = pTokenizer->int_value();
sCurrent.type = JE_INTEGER;
break;
case JT_DOUBLE:
sCurrent.fValue = pTokenizer->float_value();
sCurrent.type = JE_DOUBLE;
break;
case JT_SQ_STRING: // Single-quoted strings are allowed since JSON5
case JT_IDENTIFIER:
if (enVersion < JSON_VERSION5)
return STATUS_BAD_TOKEN;
if (!sCurrent.sValue.set(pTokenizer->text_value()))
return STATUS_NO_MEM;
sCurrent.type = JE_STRING;
break;
case JT_HEXADECIMAL: // Hexadecimals are allowed since JSON5
if (enVersion < JSON_VERSION5)
return STATUS_BAD_TOKEN;
sCurrent.iValue = pTokenizer->int_value();
sCurrent.type = JE_INTEGER;
break;
default:
return STATUS_BAD_TOKEN;
}
return STATUS_OK;
}
status_t Parser::read_root()
{
while (true)
{
// Get token
token_t tok = lookup_token();
// Analyze token
switch (tok)
{
case JT_EOF: // End of input
return STATUS_EOF;
case JT_ERROR: // Error input
return pTokenizer->error();
case JT_SL_COMMENT: // Skip comments
case JT_ML_COMMENT:
if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
return STATUS_BAD_TOKEN;
break;
case JT_LQ_BRACE: // Start of array
if (sState.flags & PF_VALUE)
return STATUS_BAD_TOKEN;
sCurrent.type = JE_ARRAY_START;
sState.flags |= PF_VALUE;
return push_state(READ_ARRAY);
case JT_LC_BRACE: // Start of object
if (sState.flags & PF_VALUE)
return STATUS_BAD_TOKEN;
sCurrent.type = JE_OBJECT_START;
sState.flags |= PF_VALUE;
return push_state(READ_OBJECT);
case JT_SQ_STRING:
case JT_DQ_STRING:
case JT_TRUE:
case JT_FALSE:
case JT_NULL:
case JT_DECIMAL:
case JT_DOUBLE:
case JT_HEXADECIMAL:
if (sState.flags & PF_VALUE)
return STATUS_BAD_TOKEN;
sState.flags |= PF_VALUE;
return read_primitive(tok);
default:
return STATUS_BAD_TOKEN;
}
}
}
status_t Parser::read_array()
{
while (true)
{
// Get token
token_t tok = lookup_token();
// Analyze token
switch (tok)
{
case JT_EOF: // End of input
return STATUS_CORRUPTED;
case JT_ERROR: // Error input
return pTokenizer->error();
case JT_SL_COMMENT: // Skip comments
case JT_ML_COMMENT:
if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
return STATUS_BAD_TOKEN;
break;
case JT_COMMA: // Comma
if ((sState.flags & PF_ARRAY_ALL) != PF_VALUE)
return STATUS_BAD_TOKEN;
sState.flags |= PF_COMMA; // Add comma flag
break;
case JT_RQ_BRACE: // End of current array
// Closing brace after comma is allowed only since JSON5
if ((sState.flags & PF_COMMA) && (enVersion < JSON_VERSION5))
return STATUS_BAD_TOKEN;
sCurrent.type = JE_ARRAY_END;
return pop_state();
case JT_LQ_BRACE: // Start of sub-array
{
size_t flags = sState.flags & PF_ARRAY_ALL;
if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
return STATUS_BAD_TOKEN;
sState.flags = PF_VALUE;
sCurrent.type = JE_ARRAY_START;
return push_state(READ_ARRAY);
}
case JT_LC_BRACE: // Start of nested object
{
size_t flags = sState.flags & PF_ARRAY_ALL;
if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
return STATUS_BAD_TOKEN;
sState.flags = PF_VALUE;
sCurrent.type = JE_OBJECT_START;
return push_state(READ_OBJECT);
}
case JT_SQ_STRING:
case JT_DQ_STRING:
case JT_TRUE:
case JT_FALSE:
case JT_NULL:
case JT_DECIMAL:
case JT_DOUBLE:
case JT_HEXADECIMAL: // Read primitive type
{
size_t flags = sState.flags & PF_ARRAY_ALL;
if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
return STATUS_BAD_TOKEN;
sState.flags = PF_VALUE;
return read_primitive(tok);
}
default:
return STATUS_BAD_TOKEN;
}
}
}
status_t Parser::read_object()
{
status_t res;
while (true)
{
// Get token
token_t tok = lookup_token();
// Analyze token
switch (tok)
{
case JT_EOF: // End of input
return STATUS_CORRUPTED;
case JT_ERROR: // Error input
return pTokenizer->error();
case JT_SL_COMMENT: // Skip comments
case JT_ML_COMMENT:
if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
return STATUS_BAD_TOKEN;
break;
case JT_COMMA: // Comma
if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON | PF_VALUE))
return STATUS_BAD_TOKEN;
sState.flags |= PF_COMMA; // Add comma flag
break;
case JT_COLON: // Colon
if ((sState.flags & PF_OBJECT_ALL) != PF_PROPERTY)
return STATUS_BAD_TOKEN;
sState.flags |= PF_COLON;
break;
case JT_RC_BRACE: // End of current object
{
size_t flags = sState.flags & PF_OBJECT_ALL;
// If property is present, there should be a corresponding value
// JSON5 allows a comma before closing brace
if (flags == PF_OBJECT_ALL)
{
if (enVersion < JSON_VERSION5)
return STATUS_BAD_TOKEN;
}
else if ((flags != 0) && (flags != (PF_PROPERTY | PF_COLON | PF_VALUE)))
return STATUS_BAD_TOKEN;
sCurrent.type = JE_OBJECT_END;
return pop_state();
}
case JT_LQ_BRACE: // Start of array value
// Property should be defined first
if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
return STATUS_BAD_TOKEN;
sCurrent.type = JE_ARRAY_START;
sState.flags |= PF_VALUE;
return push_state(READ_ARRAY);
case JT_LC_BRACE: // Start of object value
// Property should be defined first
if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
return STATUS_BAD_TOKEN;
sCurrent.type = JE_OBJECT_START;
sState.flags |= PF_VALUE;
return push_state(READ_OBJECT);
case JT_SQ_STRING:
case JT_DQ_STRING:
case JT_IDENTIFIER: // Property name
{
size_t flags = sState.flags & PF_OBJECT_ALL;
if ((flags == 0) || (flags == PF_OBJECT_ALL)) // Property name?
{
if ((res = read_primitive(tok)) == STATUS_OK)
{
sState.flags = PF_PROPERTY;
sCurrent.type = JE_PROPERTY; // Override type of event
}
}
else if (flags == (PF_PROPERTY | PF_COLON)) // Value?
{
if ((res = read_primitive(tok)) == STATUS_OK)
sState.flags |= PF_VALUE;
}
else
res = STATUS_BAD_STATE;
return res;
}
case JT_TRUE:
case JT_FALSE:
case JT_NULL:
case JT_DECIMAL:
case JT_DOUBLE:
case JT_HEXADECIMAL: // Read primitive type
{
if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
return STATUS_BAD_TOKEN;
sState.flags |= PF_VALUE;
return read_primitive(tok);
}
default:
return STATUS_BAD_TOKEN;
}
}
}
status_t Parser::read_next(event_t *ev)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
status_t res;
// Root position?
switch (sState.mode)
{
case READ_ROOT:
res = read_root();
break;
case READ_ARRAY:
res = read_array();
break;
case READ_OBJECT:
res = read_object();
break;
default:
return STATUS_BAD_STATE;
}
// Deploy result if there is place to deploy
if ((res == STATUS_OK) && (ev != NULL))
res = get_current(ev);
return res;
}
status_t Parser::read_next_type(event_type_t *type)
{
event_t ev;
status_t res = read_next(&ev);
if ((res == STATUS_OK) && (type != NULL))
*type = ev.type;
return res;
}
status_t Parser::read_string(LSPString *dst)
{
event_t ev;
status_t res = read_next(&ev);
if (res != STATUS_OK)
return res;
switch (ev.type)
{
case JE_STRING: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
dst->swap(&ev.sValue);
return STATUS_OK;
}
status_t Parser::read_double(double *dst)
{
event_t ev;
status_t res = read_next(&ev);
if (res != STATUS_OK)
return res;
switch (ev.type)
{
case JE_DOUBLE: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = ev.fValue;
return STATUS_OK;
}
status_t Parser::read_int(ssize_t *dst)
{
event_t ev;
status_t res = read_next(&ev);
if (res != STATUS_OK)
return res;
switch (ev.type)
{
case JE_INTEGER: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = ev.iValue;
return STATUS_OK;
}
status_t Parser::read_int(size_t *dst)
{
event_t ev;
status_t res = read_next(&ev);
if (res != STATUS_OK)
return res;
switch (ev.type)
{
case JE_INTEGER: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (ev.iValue < 0)
return STATUS_UNDERFLOW;
if (dst != NULL)
*dst = size_t(ev.iValue);
return STATUS_OK;
}
status_t Parser::read_bool(bool *dst)
{
event_t ev;
status_t res = read_next(&ev);
if (res != STATUS_OK)
return res;
switch (ev.type)
{
case JE_BOOL: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = ev.bValue;
return STATUS_OK;
}
status_t Parser::get_string(LSPString *dst)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
switch (sCurrent.type)
{
case JE_STRING: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
return (dst->set(&sCurrent.sValue)) ? STATUS_OK : STATUS_NO_MEM;
return STATUS_OK;
}
status_t Parser::get_double(double *dst)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
switch (sCurrent.type)
{
case JE_DOUBLE: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = sCurrent.fValue;
return STATUS_OK;
}
status_t Parser::get_int(ssize_t *dst)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
switch (sCurrent.type)
{
case JE_INTEGER: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = sCurrent.iValue;
return STATUS_OK;
}
status_t Parser::get_bool(bool *dst)
{
if (pTokenizer == NULL)
return STATUS_BAD_STATE;
switch (sCurrent.type)
{
case JE_BOOL: break;
case JE_NULL: return STATUS_NULL;
default: return STATUS_BAD_TYPE;
}
if (dst != NULL)
*dst = sCurrent.bValue;
return STATUS_OK;
}
status_t Parser::skip_next()
{
status_t res = read_next(NULL);
if (res == STATUS_OK)
res = skip_current();
return res;
}
status_t Parser::skip_current()
{
status_t res;
switch (sCurrent.type)
{
case JE_OBJECT_START:
while (true)
{
// Get next event
if ((res = read_next(NULL)) != STATUS_OK)
return res;
// Analyze event type
if (sCurrent.type != JE_PROPERTY)
return (sCurrent.type == JE_OBJECT_END) ? STATUS_OK : STATUS_BAD_TOKEN;
// Skip the value after property
if ((res = read_next(NULL)) != STATUS_OK)
return res;
if ((res = skip_current()) != STATUS_OK)
return res;
}
break;
case JE_ARRAY_START:
while (true)
{
// Get next event
if ((res = read_next(NULL)) != STATUS_OK)
return res;
// Analyze event type
if (sCurrent.type == JE_ARRAY_END)
return STATUS_OK;
// Skip the value after property
if ((res = skip_current()) != STATUS_OK)
return res;
}
break;
case JE_PROPERTY:
// Skip the value after property
if ((res = read_next(NULL)) != STATUS_OK)
return res;
if ((res = skip_current()) != STATUS_OK)
return res;
break;
default:
break;
}
return STATUS_OK;
}
} /* namespace json */
} /* namespace lsp */