mirror of
https://github.com/MadeOfJelly/MushMachine.git
synced 2024-11-13 10:43:01 +01:00
502 lines
18 KiB
C++
502 lines
18 KiB
C++
#pragma once
|
|
|
|
#include <cmath> // isfinite
|
|
#include <cstdint> // uint8_t
|
|
#include <functional> // function
|
|
#include <string> // string
|
|
#include <utility> // move
|
|
#include <vector> // vector
|
|
|
|
#include <nlohmann/detail/exceptions.hpp>
|
|
#include <nlohmann/detail/input/input_adapters.hpp>
|
|
#include <nlohmann/detail/input/json_sax.hpp>
|
|
#include <nlohmann/detail/input/lexer.hpp>
|
|
#include <nlohmann/detail/macro_scope.hpp>
|
|
#include <nlohmann/detail/meta/is_sax.hpp>
|
|
#include <nlohmann/detail/value_t.hpp>
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
////////////
|
|
// parser //
|
|
////////////
|
|
|
|
enum class parse_event_t : uint8_t
|
|
{
|
|
/// the parser read `{` and started to process a JSON object
|
|
object_start,
|
|
/// the parser read `}` and finished processing a JSON object
|
|
object_end,
|
|
/// the parser read `[` and started to process a JSON array
|
|
array_start,
|
|
/// the parser read `]` and finished processing a JSON array
|
|
array_end,
|
|
/// the parser read a key of a value in an object
|
|
key,
|
|
/// the parser finished reading a JSON value
|
|
value
|
|
};
|
|
|
|
template<typename BasicJsonType>
|
|
using parser_callback_t =
|
|
std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
|
|
|
|
/*!
|
|
@brief syntax analysis
|
|
|
|
This class implements a recursive descent parser.
|
|
*/
|
|
template<typename BasicJsonType, typename InputAdapterType>
|
|
class parser
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using lexer_t = lexer<BasicJsonType, InputAdapterType>;
|
|
using token_type = typename lexer_t::token_type;
|
|
|
|
public:
|
|
/// a parser reading from an input adapter
|
|
explicit parser(InputAdapterType&& adapter,
|
|
const parser_callback_t<BasicJsonType> cb = nullptr,
|
|
const bool allow_exceptions_ = true,
|
|
const bool skip_comments = false)
|
|
: callback(cb)
|
|
, m_lexer(std::move(adapter), skip_comments)
|
|
, allow_exceptions(allow_exceptions_)
|
|
{
|
|
// read first token
|
|
get_token();
|
|
}
|
|
|
|
/*!
|
|
@brief public parser interface
|
|
|
|
@param[in] strict whether to expect the last token to be EOF
|
|
@param[in,out] result parsed JSON value
|
|
|
|
@throw parse_error.101 in case of an unexpected token
|
|
@throw parse_error.102 if to_unicode fails or surrogate error
|
|
@throw parse_error.103 if to_unicode fails
|
|
*/
|
|
void parse(const bool strict, BasicJsonType& result)
|
|
{
|
|
if (callback)
|
|
{
|
|
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
|
|
sax_parse_internal(&sdp);
|
|
result.assert_invariant();
|
|
|
|
// in strict mode, input must be completely read
|
|
if (strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
sdp.parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_of_input, "value")));
|
|
}
|
|
|
|
// in case of an error, return discarded value
|
|
if (sdp.is_errored())
|
|
{
|
|
result = value_t::discarded;
|
|
return;
|
|
}
|
|
|
|
// set top-level value to null if it was discarded by the callback
|
|
// function
|
|
if (result.is_discarded())
|
|
{
|
|
result = nullptr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
|
|
sax_parse_internal(&sdp);
|
|
result.assert_invariant();
|
|
|
|
// in strict mode, input must be completely read
|
|
if (strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
sdp.parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_of_input, "value")));
|
|
}
|
|
|
|
// in case of an error, return discarded value
|
|
if (sdp.is_errored())
|
|
{
|
|
result = value_t::discarded;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief public accept interface
|
|
|
|
@param[in] strict whether to expect the last token to be EOF
|
|
@return whether the input is a proper JSON text
|
|
*/
|
|
bool accept(const bool strict = true)
|
|
{
|
|
json_sax_acceptor<BasicJsonType> sax_acceptor;
|
|
return sax_parse(&sax_acceptor, strict);
|
|
}
|
|
|
|
template<typename SAX>
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
bool sax_parse(SAX* sax, const bool strict = true)
|
|
{
|
|
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
|
|
const bool result = sax_parse_internal(sax);
|
|
|
|
// strict mode: next byte must be EOF
|
|
if (result && strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_of_input, "value")));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
template<typename SAX>
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
bool sax_parse_internal(SAX* sax)
|
|
{
|
|
// stack to remember the hierarchy of structured values we are parsing
|
|
// true = array; false = object
|
|
std::vector<bool> states;
|
|
// value to avoid a goto (see comment where set to true)
|
|
bool skip_to_state_evaluation = false;
|
|
|
|
while (true)
|
|
{
|
|
if (!skip_to_state_evaluation)
|
|
{
|
|
// invariant: get_token() was called before each iteration
|
|
switch (last_token)
|
|
{
|
|
case token_type::begin_object:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// closing } -> we are done
|
|
if (get_token() == token_type::end_object)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// parse key
|
|
if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::value_string, "object key")));
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// parse separator (:)
|
|
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::name_separator, "object separator")));
|
|
}
|
|
|
|
// remember we are now inside an object
|
|
states.push_back(false);
|
|
|
|
// parse values
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
case token_type::begin_array:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// closing ] -> we are done
|
|
if (get_token() == token_type::end_array)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// remember we are now inside an array
|
|
states.push_back(true);
|
|
|
|
// parse values (no need to call get_token)
|
|
continue;
|
|
}
|
|
|
|
case token_type::value_float:
|
|
{
|
|
const auto res = m_lexer.get_number_float();
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_false:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_null:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->null()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_true:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_integer:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_string:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_unsigned:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::parse_error:
|
|
{
|
|
// using "uninitialized" to avoid "expected" message
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::uninitialized, "value")));
|
|
}
|
|
|
|
default: // the last token was unexpected
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::literal_or_value, "value")));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
skip_to_state_evaluation = false;
|
|
}
|
|
|
|
// we reached this line after we successfully parsed a value
|
|
if (states.empty())
|
|
{
|
|
// empty stack: we reached the end of the hierarchy: done
|
|
return true;
|
|
}
|
|
|
|
if (states.back()) // array
|
|
{
|
|
// comma -> next value
|
|
if (get_token() == token_type::value_separator)
|
|
{
|
|
// parse a new value
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
// closing ]
|
|
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// We are done with this array. Before we can parse a
|
|
// new value, we need to evaluate the new state first.
|
|
// By setting skip_to_state_evaluation to false, we
|
|
// are effectively jumping to the beginning of this if.
|
|
JSON_ASSERT(!states.empty());
|
|
states.pop_back();
|
|
skip_to_state_evaluation = true;
|
|
continue;
|
|
}
|
|
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_array, "array")));
|
|
}
|
|
else // object
|
|
{
|
|
// comma -> next value
|
|
if (get_token() == token_type::value_separator)
|
|
{
|
|
// parse key
|
|
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::value_string, "object key")));
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// parse separator (:)
|
|
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
|
|
{
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::name_separator, "object separator")));
|
|
}
|
|
|
|
// parse values
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
// closing }
|
|
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// We are done with this object. Before we can parse a
|
|
// new value, we need to evaluate the new state first.
|
|
// By setting skip_to_state_evaluation to false, we
|
|
// are effectively jumping to the beginning of this if.
|
|
JSON_ASSERT(!states.empty());
|
|
states.pop_back();
|
|
skip_to_state_evaluation = true;
|
|
continue;
|
|
}
|
|
|
|
return sax->parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_object, "object")));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// get next token from lexer
|
|
token_type get_token()
|
|
{
|
|
return last_token = m_lexer.scan();
|
|
}
|
|
|
|
std::string exception_message(const token_type expected, const std::string& context)
|
|
{
|
|
std::string error_msg = "syntax error ";
|
|
|
|
if (!context.empty())
|
|
{
|
|
error_msg += "while parsing " + context + " ";
|
|
}
|
|
|
|
error_msg += "- ";
|
|
|
|
if (last_token == token_type::parse_error)
|
|
{
|
|
error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
|
|
m_lexer.get_token_string() + "'";
|
|
}
|
|
else
|
|
{
|
|
error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
|
|
}
|
|
|
|
if (expected != token_type::uninitialized)
|
|
{
|
|
error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
|
|
}
|
|
|
|
return error_msg;
|
|
}
|
|
|
|
private:
|
|
/// callback function
|
|
const parser_callback_t<BasicJsonType> callback = nullptr;
|
|
/// the type of the last read token
|
|
token_type last_token = token_type::uninitialized;
|
|
/// the lexer
|
|
lexer_t m_lexer;
|
|
/// whether to throw exceptions in case of errors
|
|
const bool allow_exceptions = true;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|