json_parser.cc

/*
 * Copyright (c) 2015, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program 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 General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include"json_parser.h"
#include<mysql/cdk.h>
PUSH_SYS_WARNINGS_CDK
#include"rapidjson/reader.h"
#include"rapidjson/error/en.h"
POP_SYS_WARNINGS_CDK
#include<stack>


PUSH_SYS_WARNINGS_CDK
#include<stdlib.h>
POP_SYS_WARNINGS_CDK


/*
 The maximum absolute value that 64-bit signed integer can have.
 For most platforms it is the minimum negative LLONG_MIN.
 The absolute value for it cannot be obtained because
 ABS(LLONG_MAX) < ABS(LLONG_MIN). Therefore, we define a constant.
*/
#defineINTEGER_ABS_MAX9223372036854775808UL

usingnamespaceparser;
using cdk::string;
using cdk::JSON;
typedef cdk::JSON::Processor Processor;

voidJSON_parser::process(Expr_base::Processor &prc) const
{
 rapidjson::Reader m_parser;

/*
 Note: In-situ parsing could be faster but it would also destroy
 contents of m_json and we need it for error reporting.
*/

 rapidjson::GenericStringStream<rapidjson::UTF8<char>>
ss(const_cast<char*>(m_json.data()));

/*
 struct to be used as handler for rapidjson parser
*/
structProcessor_cvt
 {

structprocessors
 {
 Processor *m_obj = nullptr;
 Processor::Any_prc* m_key = nullptr;
 Processor::Any_prc::List_prc* m_arr = nullptr;

processors(Processor *obj)
 {
 m_obj = obj;
 }

processors(Processor::Any_prc* key)
 {
 m_key = key;
 }

processors(Processor::Any_prc::List_prc* arr)
 {
 m_arr = arr;
 }
 };

 std::stack<processors> m_stack;

Processor_cvt (Processor &prc)
 {
 m_stack.push(&prc);
 }

boolNull()
 {
if (m_stack.empty())
returnfalse;

if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->null();
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->null();
returntrue;
 }

boolBool(bool b)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->yesno(b);
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->yesno(b);
else
returnfalse;

returntrue;
 }

boolInt(int i)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->num(static_cast<int64_t>(i));
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->num(static_cast<int64_t>(i));
else
returnfalse;

returntrue;
 }

boolUint(unsigned u)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->num(static_cast<uint64_t>(u));
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->num(static_cast<uint64_t>(u));
else
returnfalse;

returntrue;
 }

boolInt64(int64_t i)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->num(i);
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->num(i);
else
returnfalse;

returntrue;
 }

boolUint64(uint64_t u)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->num(u);
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->num(u);
else
returnfalse;
returntrue;
 }

boolDouble(double d)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->num(d);
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->num(d);
else
returnfalse;
returntrue;
 }

boolRawNumber(constchar* /*str*/,
 rapidjson::SizeType /*length*/,
bool/*copy*/)
 {
// not needed
returnfalse;
 }

boolString(constchar* str, rapidjson::SizeType length, bool/*copy*/)
 {
if (m_stack.empty())
returnfalse;


if (m_stack.top().m_key)
 {
 m_stack.top().m_key->scalar()->str(std::string(str, length));
 m_stack.pop();
 }
elseif (m_stack.top().m_arr)
 m_stack.top().m_arr->list_el()->scalar()->str(std::string(str, length));

returntrue;
 }

boolKey(constchar* str, rapidjson::SizeType length, bool/*copy*/)
 {
if (m_stack.empty())
returnfalse;

if (m_stack.top().m_obj)
 m_stack.push(m_stack.top().m_obj->key_val(std::string(str, length)));
else
returnfalse;

returntrue;
 }

boolStartObject()
 {
if (m_stack.empty())
returnfalse;

if(m_stack.top().m_key)
 {
 m_stack.push(m_stack.top().m_key->doc());
 }
elseif (m_stack.top().m_arr)
 {
 m_stack.push(m_stack.top().m_arr->list_el()->doc());
 }
elseif (!m_stack.top().m_obj)
returnfalse;

 m_stack.top().m_obj->doc_begin();

returntrue;
 }


boolEndObject(rapidjson::SizeType )
 {
if(m_stack.empty())
returnfalse;

if (m_stack.top().m_obj)
 {
 m_stack.top().m_obj->doc_end();
 }

 m_stack.pop(); // Pop obj

if (!m_stack.empty() && m_stack.top().m_key)
 m_stack.pop(); // Pop key

returntrue;
 }
boolStartArray()
 {
if (m_stack.empty() )
returnfalse;

if (m_stack.top().m_key)
 {
 m_stack.push(m_stack.top().m_key->arr());
 }
elseif (m_stack.top().m_arr)
 {
 m_stack.push(m_stack.top().m_arr->list_el()->arr());
 }
elsereturnfalse;

 m_stack.top().m_arr->list_begin();

returntrue;
 }

boolEndArray(rapidjson::SizeType )
 {
if (m_stack.empty() )
returnfalse;

if (!m_stack.top().m_arr)
returnfalse;

 m_stack.top().m_arr->list_end();
 m_stack.pop();// Pop array
if (!m_stack.empty() && m_stack.top().m_key)
 m_stack.pop();// pop key

returntrue;
 }

 };

 Processor_cvt cvt(prc);

auto error = m_parser.Parse<>(ss, cvt);
if (error.IsError())
 {
throwJSON_parser::Error(m_json,
 error.Offset(),
rapidjson::GetParseError_En(error.Code()));
 }
}

voidjson_parse(const std::string &json, Processor &dp)
{
 JSON_parser parser(json);
 parser.process(dp);
}