mirror/json
1
0
Fork 0
mirror of https://github.com/nlohmann/json.git synced 2024-12-14 05:29:08 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
3d4f6a2940
json/include/nlohmann/detail/input/binary_reader.hpp
Niels Lohmann 3d4f6a2940
🔨 cleaner exception interface
2018-03-11 22:47:25 +01:00

1402 lines
41 KiB
C++
Raw Blame History

#pragma once
#include <algorithm> // generate_n
#include <array> // array
#include <cassert> // assert
#include <cmath> // ldexp
#include <cstddef> // size_t
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
#include <cstring> // memcpy
#include <iomanip> // setw, setfill
#include <ios> // hex
#include <iterator> // back_inserter
#include <limits> // numeric_limits
#include <sstream> // stringstream
#include <string> // char_traits, string
#include <utility> // make_pair, move
#include <nlohmann/detail/input/input_adapters.hpp>
#include <nlohmann/detail/input/json_sax.hpp>
#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/value_t.hpp>
namespace nlohmann
{
namespace detail
{
///////////////////
// binary reader //
///////////////////
/*!
@brief deserialization of CBOR and MessagePack values
*/
template<typename BasicJsonType>
class binary_reader
{
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using string_t = typename BasicJsonType::string_t;
using json_sax_t = json_sax<BasicJsonType>;
public:
/*!
@brief create a binary reader
@param[in] adapter input adapter to read from
*/
explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
{
assert(ia);
}
/*!
@brief create a JSON value from CBOR input
@param[in] strict whether to expect the input to be consumed completed
@return JSON value created from CBOR input
@throw parse_error.110 if input ended unexpectedly or the end of file was
not reached when @a strict was set to true
@throw parse_error.112 if unsupported byte was read
*/
BasicJsonType parse_cbor(const bool strict)
{
BasicJsonType result;
json_sax_dom_parser<BasicJsonType> sdp(result);
parse_cbor_sax_internal(&sdp);
result.assert_invariant();
if (strict)
{
get();
expect_eof();
}
return result;
}
/*!
@brief create a JSON value from MessagePack input
@param[in] strict whether to expect the input to be consumed completed
@return JSON value created from MessagePack input
@throw parse_error.110 if input ended unexpectedly or the end of file was
not reached when @a strict was set to true
@throw parse_error.112 if unsupported byte was read
*/
BasicJsonType parse_msgpack(const bool strict)
{
BasicJsonType result;
json_sax_dom_parser<BasicJsonType> sdp(result);
parse_msgpack_sax_internal(&sdp);
result.assert_invariant();
if (strict)
{
get();
expect_eof();
}
return result;
}
/*!
@brief create a JSON value from UBJSON input
@param[in] strict whether to expect the input to be consumed completed
@return JSON value created from UBJSON input
@throw parse_error.110 if input ended unexpectedly or the end of file was
not reached when @a strict was set to true
@throw parse_error.112 if unsupported byte was read
*/
BasicJsonType parse_ubjson(const bool strict)
{
BasicJsonType result;
json_sax_dom_parser<BasicJsonType> sdp(result);
parse_ubjson_sax_internal(&sdp);
result.assert_invariant();
if (strict)
{
get_ignore_noop();
expect_eof();
}
return result;
}
/*!
@brief determine system byte order
@return true if and only if system's byte order is little endian
@note from http://stackoverflow.com/a/1001328/266378
*/
static constexpr bool little_endianess(int num = 1) noexcept
{
return (*reinterpret_cast<char*>(&num) == 1);
}
private:
/*!
@param[in] get_char whether a new character should be retrieved from the
input (true, default) or whether the last read
character should be considered instead
*/
bool parse_cbor_sax_internal(json_sax_t* sax, const bool get_char = true)
{
switch (get_char ? get() : current)
{
// EOF
case std::char_traits<char>::eof():
return sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, "unexpected end of input"));
// Integer 0x00..0x17 (0..23)
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
return sax->number_unsigned(static_cast<number_unsigned_t>(current));
case 0x18: // Unsigned integer (one-byte uint8_t follows)
return sax->number_unsigned(get_number<uint8_t>());
case 0x19: // Unsigned integer (two-byte uint16_t follows)
return sax->number_unsigned(get_number<uint16_t>());
case 0x1A: // Unsigned integer (four-byte uint32_t follows)
return sax->number_unsigned(get_number<uint32_t>());
case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
return sax->number_unsigned(get_number<uint64_t>());
// Negative integer -1-0x00..-1-0x17 (-1..-24)
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
return sax->number_integer(static_cast<int8_t>(0x20 - 1 - current));
case 0x38: // Negative integer (one-byte uint8_t follows)
return sax->number_integer(static_cast<number_integer_t>(-1) - get_number<uint8_t>());
case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
return sax->number_integer(static_cast<number_integer_t>(-1) - get_number<uint16_t>());
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
return sax->number_integer(static_cast<number_integer_t>(-1) - get_number<uint32_t>());
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
return sax->number_integer(static_cast<number_integer_t>(-1) -
static_cast<number_integer_t>(get_number<uint64_t>()));
// UTF-8 string (0x00..0x17 bytes follow)
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
case 0x7F: // UTF-8 string (indefinite length)
return sax->string(get_cbor_string());
// array (0x00..0x17 data items follow)
case 0x80:
case 0x81:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x86:
case 0x87:
case 0x88:
case 0x89:
case 0x8A:
case 0x8B:
case 0x8C:
case 0x8D:
case 0x8E:
case 0x8F:
case 0x90:
case 0x91:
case 0x92:
case 0x93:
case 0x94:
case 0x95:
case 0x96:
case 0x97:
return get_cbor_array_sax(sax, static_cast<std::size_t>(current & 0x1F));
case 0x98: // array (one-byte uint8_t for n follows)
return get_cbor_array_sax(sax, static_cast<std::size_t>(get_number<uint8_t>()));
case 0x99: // array (two-byte uint16_t for n follow)
return get_cbor_array_sax(sax, static_cast<std::size_t>(get_number<uint16_t>()));
case 0x9A: // array (four-byte uint32_t for n follow)
return get_cbor_array_sax(sax, static_cast<std::size_t>(get_number<uint32_t>()));
case 0x9B: // array (eight-byte uint64_t for n follow)
return get_cbor_array_sax(sax, static_cast<std::size_t>(get_number<uint64_t>()));
case 0x9F: // array (indefinite length)
return get_cbor_array_sax(sax, json_sax_t::no_limit);
// map (0x00..0x17 pairs of data items follow)
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
case 0xA4:
case 0xA5:
case 0xA6:
case 0xA7:
case 0xA8:
case 0xA9:
case 0xAA:
case 0xAB:
case 0xAC:
case 0xAD:
case 0xAE:
case 0xAF:
case 0xB0:
case 0xB1:
case 0xB2:
case 0xB3:
case 0xB4:
case 0xB5:
case 0xB6:
case 0xB7:
return get_cbor_object_sax(sax, static_cast<std::size_t>(current & 0x1F));
case 0xB8: // map (one-byte uint8_t for n follows)
return get_cbor_object_sax(sax, static_cast<std::size_t>(get_number<uint8_t>()));
case 0xB9: // map (two-byte uint16_t for n follow)
return get_cbor_object_sax(sax, static_cast<std::size_t>(get_number<uint16_t>()));
case 0xBA: // map (four-byte uint32_t for n follow)
return get_cbor_object_sax(sax, static_cast<std::size_t>(get_number<uint32_t>()));
case 0xBB: // map (eight-byte uint64_t for n follow)
return get_cbor_object_sax(sax, static_cast<std::size_t>(get_number<uint64_t>()));
case 0xBF: // map (indefinite length)
return get_cbor_object_sax(sax, json_sax_t::no_limit);
case 0xF4: // false
return sax->boolean(false);
case 0xF5: // true
return sax->boolean(true);
case 0xF6: // null
return sax->null();
case 0xF9: // Half-Precision Float (two-byte IEEE 754)
{
const int byte1 = get();
unexpect_eof();
const int byte2 = get();
unexpect_eof();
// code from RFC 7049, Appendix D, Figure 3:
// As half-precision floating-point numbers were only added
// to IEEE 754 in 2008, today's programming platforms often
// still only have limited support for them. It is very
// easy to include at least decoding support for them even
// without such support. An example of a small decoder for
// half-precision floating-point numbers in the C language
// is shown in Fig. 3.
const int half = (byte1 << 8) + byte2;
const int exp = (half >> 10) & 0x1F;
const int mant = half & 0x3FF;
double val;
if (exp == 0)
{
val = std::ldexp(mant, -24);
}
else if (exp != 31)
{
val = std::ldexp(mant + 1024, exp - 25);
}
else
{
val = (mant == 0) ? std::numeric_limits<double>::infinity()
: std::numeric_limits<double>::quiet_NaN();
}
return sax->number_float((half & 0x8000) != 0 ? -val : val, "");
}
case 0xFA: // Single-Precision Float (four-byte IEEE 754)
return sax->number_float(static_cast<double>(get_number<float>()), "");
case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
return sax->number_float(get_number<double>(), "");
default: // anything else (0xFF is handled inside the other types)
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
return sax->parse_error(chars_read, ss.str(), parse_error::create(112, chars_read, "error reading CBOR; last byte: 0x" + ss.str()));
}
}
}
bool parse_msgpack_sax_internal(json_sax_t* sax)
{
switch (get())
{
// EOF
case std::char_traits<char>::eof():
return sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, "unexpected end of input"));
// positive fixint
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5C:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
return sax->number_unsigned(static_cast<number_unsigned_t>(current));
// fixmap
case 0x80:
case 0x81:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x86:
case 0x87:
case 0x88:
case 0x89:
case 0x8A:
case 0x8B:
case 0x8C:
case 0x8D:
case 0x8E:
case 0x8F:
return get_msgpack_object_sax(sax, static_cast<std::size_t>(current & 0x0F));
// fixarray
case 0x90:
case 0x91:
case 0x92:
case 0x93:
case 0x94:
case 0x95:
case 0x96:
case 0x97:
case 0x98:
case 0x99:
case 0x9A:
case 0x9B:
case 0x9C:
case 0x9D:
case 0x9E:
case 0x9F:
return get_msgpack_array_sax(sax, static_cast<std::size_t>(current & 0x0F));
// fixstr
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
case 0xA4:
case 0xA5:
case 0xA6:
case 0xA7:
case 0xA8:
case 0xA9:
case 0xAA:
case 0xAB:
case 0xAC:
case 0xAD:
case 0xAE:
case 0xAF:
case 0xB0:
case 0xB1:
case 0xB2:
case 0xB3:
case 0xB4:
case 0xB5:
case 0xB6:
case 0xB7:
case 0xB8:
case 0xB9:
case 0xBA:
case 0xBB:
case 0xBC:
case 0xBD:
case 0xBE:
case 0xBF:
return sax->string(get_msgpack_string());
case 0xC0: // nil
return sax->null();
case 0xC2: // false
return sax->boolean(false);
case 0xC3: // true
return sax->boolean(true);
case 0xCA: // float 32
return sax->number_float(static_cast<double>(get_number<float>()), "");
case 0xCB: // float 64
return sax->number_float(get_number<double>(), "");
case 0xCC: // uint 8
return sax->number_unsigned(get_number<uint8_t>());
case 0xCD: // uint 16
return sax->number_unsigned(get_number<uint16_t>());
case 0xCE: // uint 32
return sax->number_unsigned(get_number<uint32_t>());
case 0xCF: // uint 64
return sax->number_unsigned(get_number<uint64_t>());
case 0xD0: // int 8
return sax->number_integer(get_number<int8_t>());
case 0xD1: // int 16
return sax->number_integer(get_number<int16_t>());
case 0xD2: // int 32
return sax->number_integer(get_number<int32_t>());
case 0xD3: // int 64
return sax->number_integer(get_number<int64_t>());
case 0xD9: // str 8
case 0xDA: // str 16
case 0xDB: // str 32
return sax->string(get_msgpack_string());
case 0xDC: // array 16
return get_msgpack_array_sax(sax, static_cast<std::size_t>(get_number<uint16_t>()));
case 0xDD: // array 32
return get_msgpack_array_sax(sax, static_cast<std::size_t>(get_number<uint32_t>()));
case 0xDE: // map 16
return get_msgpack_object_sax(sax, static_cast<std::size_t>(get_number<uint16_t>()));
case 0xDF: // map 32
return get_msgpack_object_sax(sax, static_cast<std::size_t>(get_number<uint32_t>()));
// negative fixint
case 0xE0:
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xED:
case 0xEE:
case 0xEF:
case 0xF0:
case 0xF1:
case 0xF2:
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF6:
case 0xF7:
case 0xF8:
case 0xF9:
case 0xFA:
case 0xFB:
case 0xFC:
case 0xFD:
case 0xFE:
case 0xFF:
return sax->number_integer(static_cast<int8_t>(current));
default: // anything else
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
return sax->parse_error(chars_read, ss.str(), parse_error::create(112, chars_read, "error reading MessagePack; last byte: 0x" + ss.str()));
}
}
}
/*!
@param[in] get_char whether a new character should be retrieved from the
input (true, default) or whether the last read
character should be considered instead
*/
bool parse_ubjson_sax_internal(json_sax_t* sax, const bool get_char = true)
{
return get_ubjson_sax_value(sax, get_char ? get_ignore_noop() : current);
}
/*!
@brief get next character from the input
This function provides the interface to the used input adapter. It does
not throw in case the input reached EOF, but returns a -'ve valued
`std::char_traits<char>::eof()` in that case.
@return character read from the input
*/
int get()
{
++chars_read;
return (current = ia->get_character());
}
/*!
@return character read from the input after ignoring all 'N' entries
*/
int get_ignore_noop()
{
do
{
get();
}
while (current == 'N');
return current;
}
/*
@brief read a number from the input
@tparam NumberType the type of the number
@return number of type @a NumberType
@note This function needs to respect the system's endianess, because
bytes in CBOR and MessagePack are stored in network order (big
endian) and therefore need reordering on little endian systems.
@throw parse_error.110 if input has less than `sizeof(NumberType)` bytes
*/
template<typename NumberType> NumberType get_number()
{
// step 1: read input into array with system's byte order
std::array<uint8_t, sizeof(NumberType)> vec;
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{
get();
unexpect_eof();
// reverse byte order prior to conversion if necessary
if (is_little_endian)
{
vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
}
else
{
vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
}
}
// step 2: convert array into number of type T and return
NumberType result;
std::memcpy(&result, vec.data(), sizeof(NumberType));
return result;
}
/*!
@brief create a string by reading characters from the input
@param[in] len number of bytes to read
@note We can not reserve @a len bytes for the result, because @a len
may be too large. Usually, @ref unexpect_eof() detects the end of
the input before we run out of string memory.
@return string created by reading @a len bytes
@throw parse_error.110 if input has less than @a len bytes
*/
template<typename NumberType>
string_t get_string(const NumberType len)
{
string_t result;
std::generate_n(std::back_inserter(result), len, [this]()
{
get();
unexpect_eof();
return static_cast<char>(current);
});
return result;
}
/*!
@brief reads a CBOR string
This function first reads starting bytes to determine the expected
string length and then copies this number of bytes into a string.
Additionally, CBOR's strings with indefinite lengths are supported.
@return string
@throw parse_error.110 if input ended
@throw parse_error.113 if an unexpected byte is read
*/
string_t get_cbor_string()
{
unexpect_eof();
switch (current)
{
// UTF-8 string (0x00..0x17 bytes follow)
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
return get_string(current & 0x1F);
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
return get_string(get_number<uint8_t>());
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
return get_string(get_number<uint16_t>());
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
return get_string(get_number<uint32_t>());
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
return get_string(get_number<uint64_t>());
case 0x7F: // UTF-8 string (indefinite length)
{
string_t result;
while (get() != 0xFF)
{
result.append(get_cbor_string());
}
return result;
}
default:
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
JSON_THROW(parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str()));
}
}
}
bool get_cbor_array_sax(json_sax_t* sax, const std::size_t len)
{
if (not sax->start_array(len))
{
return false;
}
if (len != json_sax_t::no_limit)
for (std::size_t i = 0; i < len; ++i)
{
if (not parse_cbor_sax_internal(sax))
{
return false;
}
}
else
{
while (get() != 0xFF)
{
if (not parse_cbor_sax_internal(sax, false))
{
return false;
}
}
}
return sax->end_array();
}
bool get_cbor_object_sax(json_sax_t* sax, const std::size_t len)
{
if (not sax->start_object(len))
{
return false;
}
if (len != json_sax_t::no_limit)
{
for (std::size_t i = 0; i < len; ++i)
{
get();
if (not sax->key(get_cbor_string()))
{
return false;
}
if (not parse_cbor_sax_internal(sax))
{
return false;
}
}
}
else
{
while (get() != 0xFF)
{
if (not sax->key(get_cbor_string()))
{
return false;
}
if (not parse_cbor_sax_internal(sax))
{
return false;
}
}
}
return sax->end_object();
}
/*!
@brief reads a MessagePack string
This function first reads starting bytes to determine the expected
string length and then copies this number of bytes into a string.
@return string
@throw parse_error.110 if input ended
@throw parse_error.113 if an unexpected byte is read
*/
string_t get_msgpack_string()
{
unexpect_eof();
switch (current)
{
// fixstr
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
case 0xA4:
case 0xA5:
case 0xA6:
case 0xA7:
case 0xA8:
case 0xA9:
case 0xAA:
case 0xAB:
case 0xAC:
case 0xAD:
case 0xAE:
case 0xAF:
case 0xB0:
case 0xB1:
case 0xB2:
case 0xB3:
case 0xB4:
case 0xB5:
case 0xB6:
case 0xB7:
case 0xB8:
case 0xB9:
case 0xBA:
case 0xBB:
case 0xBC:
case 0xBD:
case 0xBE:
case 0xBF:
return get_string(current & 0x1F);
case 0xD9: // str 8
return get_string(get_number<uint8_t>());
case 0xDA: // str 16
return get_string(get_number<uint16_t>());
case 0xDB: // str 32
return get_string(get_number<uint32_t>());
default:
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
JSON_THROW(parse_error::create(113, chars_read,
"expected a MessagePack string; last byte: 0x" + ss.str()));
}
}
}
bool get_msgpack_array_sax(json_sax_t* sax, const std::size_t len)
{
if (not sax->start_array(len))
{
return false;
}
for (std::size_t i = 0; i < len; ++i)
{
if (not parse_msgpack_sax_internal(sax))
{
return false;
}
}
return sax->end_array();
}
bool get_msgpack_object_sax(json_sax_t* sax, const std::size_t len)
{
if (not sax->start_object(len))
{
return false;
}
for (std::size_t i = 0; i < len; ++i)
{
get();
if (not sax->key(get_msgpack_string()))
{
return false;
}
if (not parse_msgpack_sax_internal(sax))
{
return false;
}
}
return sax->end_object();
}
/*!
@brief reads a UBJSON string
This function is either called after reading the 'S' byte explicitly
indicating a string, or in case of an object key where the 'S' byte can be
left out.
@param[in] get_char whether a new character should be retrieved from the
input (true, default) or whether the last read
character should be considered instead
@return string
@throw parse_error.110 if input ended
@throw parse_error.113 if an unexpected byte is read
*/
string_t get_ubjson_string(const bool get_char = true)
{
if (get_char)
{
get(); // TODO: may we ignore N here?
}
unexpect_eof();
switch (current)
{
case 'U':
return get_string(get_number<uint8_t>());
case 'i':
return get_string(get_number<int8_t>());
case 'I':
return get_string(get_number<int16_t>());
case 'l':
return get_string(get_number<int32_t>());
case 'L':
return get_string(get_number<int64_t>());
default:
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
JSON_THROW(parse_error::create(113, chars_read,
"expected a UBJSON string; last byte: 0x" + ss.str()));
}
}
std::size_t get_ubjson_size_value()
{
switch (get_ignore_noop())
{
case 'U':
return static_cast<std::size_t>(get_number<uint8_t>());
case 'i':
return static_cast<std::size_t>(get_number<int8_t>());
case 'I':
return static_cast<std::size_t>(get_number<int16_t>());
case 'l':
return static_cast<std::size_t>(get_number<int32_t>());
case 'L':
return static_cast<std::size_t>(get_number<int64_t>());
default:
return std::size_t(-1);
}
}
/*!
@brief determine the type and size for a container
In the optimized UBJSON format, a type and a size can be provided to allow
for a more compact representation.
@return pair of the size and the type
*/
std::pair<std::size_t, int> get_ubjson_size_type()
{
std::size_t sz = string_t::npos;
int tc = 0;
get_ignore_noop();
if (current == '$')
{
tc = get(); // must not ignore 'N', because 'N' maybe the type
unexpect_eof();
get_ignore_noop();
if (current != '#')
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
JSON_THROW(parse_error::create(112, chars_read,
"expected '#' after UBJSON type information; last byte: 0x" + ss.str()));
}
sz = get_ubjson_size_value();
}
else if (current == '#')
{
sz = get_ubjson_size_value();
}
return std::make_pair(sz, tc);
}
bool get_ubjson_sax_value(json_sax_t* sax, const int prefix)
{
switch (prefix)
{
case std::char_traits<char>::eof(): // EOF
return sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, "unexpected end of input"));
case 'T': // true
return sax->boolean(true);
case 'F': // false
return sax->boolean(false);
case 'Z': // null
return sax->null();
case 'U':
return sax->number_unsigned(get_number<uint8_t>());
case 'i':
return sax->number_integer(get_number<int8_t>());
case 'I':
return sax->number_integer(get_number<int16_t>());
case 'l':
return sax->number_integer(get_number<int32_t>());
case 'L':
return sax->number_integer(get_number<int64_t>());
case 'd':
return sax->number_float(static_cast<double>(get_number<float>()), "");
case 'D':
return sax->number_float(get_number<double>(), "");
case 'C': // char
{
get();
unexpect_eof();
if (JSON_UNLIKELY(current > 127))
{
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
return sax->parse_error(chars_read, ss.str(), parse_error::create(113, chars_read, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + ss.str()));
}
return sax->string(string_t(1, static_cast<char>(current)));
}
case 'S': // string
return sax->string(get_ubjson_string());
case '[': // array
return get_ubjson_sax_array(sax);
case '{': // object
return get_ubjson_sax_object(sax);
default: // anything else
std::stringstream ss;
ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
JSON_THROW(parse_error::create(112, chars_read,
"error reading UBJSON; last byte: 0x" + ss.str()));
}
}
bool get_ubjson_sax_array(json_sax_t* sax)
{
const auto size_and_type = get_ubjson_size_type();
if (size_and_type.first != string_t::npos)
{
if (not sax->start_array(size_and_type.first))
{
return false;
}
if (size_and_type.second != 0)
{
if (size_and_type.second != 'N')
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (not get_ubjson_sax_value(sax, size_and_type.second))
{
return false;
}
}
}
}
else
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (not parse_ubjson_sax_internal(sax))
{
return false;
}
}
}
}
else
{
if (not sax->start_array())
{
return false;
}
while (current != ']')
{
if (not parse_ubjson_sax_internal(sax, false))
{
return false;
}
get_ignore_noop();
}
}
return sax->end_array();
}
bool get_ubjson_sax_object(json_sax_t* sax)
{
const auto size_and_type = get_ubjson_size_type();
if (size_and_type.first != string_t::npos)
{
if (not sax->start_object(size_and_type.first))
{
return false;
}
if (size_and_type.second != 0)
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (not sax->key(get_ubjson_string()))
{
return false;
}
if (not get_ubjson_sax_value(sax, size_and_type.second))
{
return false;
}
}
}
else
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (not sax->key(get_ubjson_string()))
{
return false;
}
if (not parse_ubjson_sax_internal(sax))
{
return false;
}
}
}
}
else
{
if (not sax->start_object())
{
return false;
}
while (current != '}')
{
if (not sax->key(get_ubjson_string(false)))
{
return false;
}
if (not parse_ubjson_sax_internal(sax))
{
return false;
}
get_ignore_noop();
}
}
return sax->end_object();
}
/*!
@brief throw if end of input is not reached
@throw parse_error.110 if input not ended
*/
void expect_eof() const
{
if (JSON_UNLIKELY(current != std::char_traits<char>::eof()))
{
JSON_THROW(parse_error::create(110, chars_read, "expected end of input"));
}
}
/*!
@briefthrow if end of input is reached
@throw parse_error.110 if input ended
*/
void unexpect_eof() const
{
if (JSON_UNLIKELY(current == std::char_traits<char>::eof()))
{
JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
}
}
private:
/// input adapter
input_adapter_t ia = nullptr;
/// the current character
int current = std::char_traits<char>::eof();
/// the number of characters read
std::size_t chars_read = 0;
/// whether we can assume little endianess
const bool is_little_endian = little_endianess();
};
}
}
Reference in New Issue View Git Blame Copy Permalink