/* * 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 */