From 62184316bb50db8ef4b10b8bb534ef23ad5fe986 Mon Sep 17 00:00:00 2001 From: Niels Lohmann Date: Sun, 4 Oct 2026 12:21:23 +0200 Subject: [PATCH] Use the input_format member instead of passing the format to binary_reader helpers The helpers (get_number, get_to, get_string, get_binary, get_bytes, emit_signed, emit_unsigned, emit_float, unexpect_eof, exception_message) are members of binary_reader, which already stores the format it was constructed with, so the parameter was redundant. Signed-off-by: Niels Lohmann --- .../nlohmann/detail/input/binary_reader.hpp | 434 +++++++++--------- single_include/nlohmann/json.hpp | 434 +++++++++--------- 2 files changed, 420 insertions(+), 448 deletions(-) diff --git a/include/nlohmann/detail/input/binary_reader.hpp b/include/nlohmann/detail/input/binary_reader.hpp index b7e92f4ed..51781ba8a 100644 --- a/include/nlohmann/detail/input/binary_reader.hpp +++ b/include/nlohmann/detail/input/binary_reader.hpp @@ -189,7 +189,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(current != char_traits::eof())) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read, - exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); + exception_message(concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); } } @@ -296,7 +296,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(document_size < 0 || static_cast(document_size) != chars_read - document_start)) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr)); + exception_message(concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr)); } return true; } @@ -311,7 +311,7 @@ class binary_reader // check_bson_document_size() measures the document from here const std::size_t document_start = chars_read; std::int32_t document_size{}; - if (!get_number(input_format_t::bson, document_size)) + if (!get_number(document_size)) { return false; } @@ -377,7 +377,7 @@ class binary_reader continue; } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("element list"))) { return false; } @@ -421,7 +421,7 @@ class binary_reader while (true) { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("cstring"))) { return false; } @@ -491,10 +491,10 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); + exception_message(concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!get_string(input_format_t::bson, len - static_cast(1), result))) + if (JSON_HEDLEY_UNLIKELY(!get_string(len - static_cast(1), result))) { return false; } @@ -503,8 +503,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, - "BSON string is not null-terminated", + exception_message("BSON string is not null-terminated", "string"), nullptr)); } @@ -527,18 +526,18 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); + exception_message(concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); } // All BSON binary values have a subtype std::uint8_t subtype{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::bson, subtype))) + if (JSON_HEDLEY_UNLIKELY(!get_number(subtype))) { return false; } result.set_subtype(subtype); - return get_binary(input_format_t::bson, len, result); + return get_binary(len, result); } /*! @@ -559,14 +558,14 @@ class binary_reader case 0x01: // double { double number{}; - return get_number(input_format_t::bson, number) && emit_float(input_format_t::bson, number); + return get_number(number) && emit_float(number); } case 0x02: // string { std::int32_t len{}; string_t value; - return get_number(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value); + return get_number(len) && get_bson_string(len, value) && sax->string(value); } case 0x03: // object @@ -583,13 +582,13 @@ class binary_reader { std::int32_t len{}; binary_t value; - return get_number(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value); + return get_number(len) && get_bson_binary(len, value) && sax->binary(value); } case 0x08: // boolean { std::uint8_t value{}; - return get_number(input_format_t::bson, value) && sax->boolean(value != 0); + return get_number(value) && sax->boolean(value != 0); } case 0x0A: // null @@ -600,19 +599,19 @@ class binary_reader case 0x10: // int32 { std::int32_t value{}; - return get_number(input_format_t::bson, value) && emit_signed(input_format_t::bson, value); + return get_number(value) && emit_signed(value); } case 0x12: // int64 { std::int64_t value{}; - return get_number(input_format_t::bson, value) && emit_signed(input_format_t::bson, value); + return get_number(value) && emit_signed(value); } case 0x11: // uint64 { std::uint64_t value{}; - return get_number(input_format_t::bson, value) && emit_unsigned(input_format_t::bson, value); + return get_number(value) && emit_unsigned(value); } default: // anything else is not supported (yet) @@ -634,7 +633,7 @@ class binary_reader bool get_cbor_negative_integer() { NumberType number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::cbor, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -650,7 +649,7 @@ class binary_reader // number_integer_t as number_float_t; compute it as long double so // that emit_float sees a finite value and can detect an overflow of // number_float_t - return emit_float(input_format_t::cbor, static_cast(-1) - static_cast(number)); + return emit_float(static_cast(-1) - static_cast(number)); } /*! @@ -675,7 +674,7 @@ class binary_reader { // EOF case char_traits::eof(): - return unexpect_eof(input_format_t::cbor, "value"); + return unexpect_eof("value"); // Integer 0x00..0x17 (0..23) case 0x00: @@ -707,25 +706,25 @@ class binary_reader case 0x18: // Unsigned integer (one-byte uint8_t follows) { std::uint8_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x19: // Unsigned integer (two-byte uint16_t follows) { std::uint16_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x1A: // Unsigned integer (four-byte uint32_t follows) { std::uint32_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x1B: // Unsigned integer (eight-byte uint64_t follows) { std::uint64_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } // Negative integer -1-0x00..-1-0x17 (-1..-24) @@ -867,27 +866,27 @@ class binary_reader case 0x98: // array (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0x99: // array (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0x9A: // array (four-byte uint32_t for n follow) { std::uint32_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size); + return get_number(len) && get_cbor_container_size(len, size, "array") && enter_array(size); } case 0x9B: // array (eight-byte uint64_t for n follow) { std::uint64_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size); + return get_number(len) && get_cbor_container_size(len, size, "array") && enter_array(size); } case 0x9F: // array (indefinite length) @@ -923,27 +922,27 @@ class binary_reader case 0xB8: // map (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xB9: // map (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xBA: // map (four-byte uint32_t for n follow) { std::uint32_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size); + return get_number(len) && get_cbor_container_size(len, size, "map") && enter_object(size); } case 0xBB: // map (eight-byte uint64_t for n follow) { std::uint64_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size); + return get_number(len) && get_cbor_container_size(len, size, "map") && enter_object(size); } case 0xBF: // map (indefinite length) @@ -984,7 +983,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } case cbor_tag_handler_t::ignore: @@ -995,7 +994,7 @@ class binary_reader case 0xD8: { std::uint8_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -1004,7 +1003,7 @@ class binary_reader case 0xD9: { std::uint16_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -1013,7 +1012,7 @@ class binary_reader case 0xDA: { std::uint32_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -1022,7 +1021,7 @@ class binary_reader case 0xDB: { std::uint64_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -1046,7 +1045,7 @@ class binary_reader case 0xD8: { std::uint8_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -1056,7 +1055,7 @@ class binary_reader case 0xD9: { std::uint16_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -1066,7 +1065,7 @@ class binary_reader case 0xDA: { std::uint32_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -1076,7 +1075,7 @@ class binary_reader case 0xDB: { std::uint64_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -1122,12 +1121,12 @@ class binary_reader case 0xF9: // Half-Precision Float (two-byte IEEE 754) { const auto byte1_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } const auto byte2_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -1170,20 +1169,20 @@ class binary_reader case 0xFA: // Single-Precision Float (four-byte IEEE 754) { float number{}; - return get_number(input_format_t::cbor, number) && emit_float(input_format_t::cbor, number); + return get_number(number) && emit_float(number); } case 0xFB: // Double-Precision Float (eight-byte IEEE 754) { double number{}; - return get_number(input_format_t::cbor, number) && emit_float(input_format_t::cbor, number); + return get_number(number) && emit_float(number); } default: // anything else (0xFF is handled inside the other types) { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } } } @@ -1232,38 +1231,38 @@ class binary_reader case 0x76: case 0x77: { - return get_string(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + return get_string(static_cast(current) & 0x1Fu, result); } case 0x78: // UTF-8 string (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x79: // UTF-8 string (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) { std::uint32_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) { std::uint64_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); + exception_message(concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); } } } @@ -1291,7 +1290,7 @@ class binary_reader while (true) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("string"))) { return false; } @@ -1400,7 +1399,7 @@ class binary_reader auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); + exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); } /*! @@ -1447,42 +1446,42 @@ class binary_reader case 0x56: case 0x57: { - return get_binary(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + return get_binary(static_cast(current) & 0x1Fu, result); } case 0x58: // Binary data (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x59: // Binary data (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x5A: // Binary data (four-byte uint32_t for n follow) { std::uint32_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x5B: // Binary data (eight-byte uint64_t for n follow) { std::uint64_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); + exception_message(concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); } } } @@ -1506,7 +1505,7 @@ class binary_reader while (true) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("binary"))) { return false; } @@ -1563,7 +1562,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(!value_in_range_of(len) || len == detail::unknown_size())) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format_t::cbor, concat("excessive ", context, " size"), "size"), nullptr)); + exception_message(concat("excessive ", context, " size"), "size"), nullptr)); } result = conditional_static_cast(len); return true; @@ -1700,7 +1699,7 @@ class binary_reader { // EOF case char_traits::eof(): - return unexpect_eof(input_format_t::msgpack, "value"); + return unexpect_eof("value"); // positive fixint case 0x00: @@ -1940,85 +1939,85 @@ class binary_reader case 0xCA: // float 32 { float number{}; - return get_number(input_format_t::msgpack, number) && emit_float(input_format_t::msgpack, number); + return get_number(number) && emit_float(number); } case 0xCB: // float 64 { double number{}; - return get_number(input_format_t::msgpack, number) && emit_float(input_format_t::msgpack, number); + return get_number(number) && emit_float(number); } case 0xCC: // uint 8 { std::uint8_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCD: // uint 16 { std::uint16_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCE: // uint 32 { std::uint32_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCF: // uint 64 { std::uint64_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xD0: // int 8 { std::int8_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD1: // int 16 { std::int16_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD2: // int 32 { std::int32_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD3: // int 64 { std::int64_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xDC: // array 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0xDD: // array 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && enter_array(conditional_static_cast(len)); + return get_number(len) && enter_array(conditional_static_cast(len)); } case 0xDE: // map 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xDF: // map 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && enter_object(conditional_static_cast(len)); + return get_number(len) && enter_object(conditional_static_cast(len)); } // negative fixint @@ -2060,7 +2059,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } } } @@ -2077,7 +2076,7 @@ class binary_reader */ bool get_msgpack_string(string_t& result) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("string"))) { return false; } @@ -2118,32 +2117,32 @@ class binary_reader case 0xBE: case 0xBF: { - return get_string(input_format_t::msgpack, static_cast(current) & 0x1Fu, result); + return get_string(static_cast(current) & 0x1Fu, result); } case 0xD9: // str 8 { std::uint8_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } case 0xDA: // str 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } case 0xDB: // str 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); + exception_message(concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); } } } @@ -2237,7 +2236,7 @@ class binary_reader auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::msgpack, concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); + exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); } /*! @@ -2264,31 +2263,31 @@ class binary_reader case 0xC4: // bin 8 { std::uint8_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC5: // bin 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC6: // bin 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC7: // ext 8 { std::uint8_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } @@ -2296,9 +2295,9 @@ class binary_reader { std::uint16_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } @@ -2306,49 +2305,49 @@ class binary_reader { std::uint32_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } case 0xD4: // fixext 1 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 1, result) && + return get_number(subtype) && + get_binary(1, result) && assign_and_return_true(subtype); } case 0xD5: // fixext 2 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 2, result) && + return get_number(subtype) && + get_binary(2, result) && assign_and_return_true(subtype); } case 0xD6: // fixext 4 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 4, result) && + return get_number(subtype) && + get_binary(4, result) && assign_and_return_true(subtype); } case 0xD7: // fixext 8 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 8, result) && + return get_number(subtype) && + get_binary(8, result) && assign_and_return_true(subtype); } case 0xD8: // fixext 16 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 16, result) && + return get_number(subtype) && + get_binary(16, result) && assign_and_return_true(subtype); } @@ -2553,7 +2552,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(len < 0)) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "string length must not be negative", "string"), nullptr)); + exception_message("string length must not be negative", "string"), nullptr)); } return true; } @@ -2583,7 +2582,7 @@ class binary_reader get(); } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("value"))) { return false; } @@ -2593,31 +2592,31 @@ class binary_reader case 'U': { std::uint8_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'i': { std::int8_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'I': { std::int16_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'l': { std::int32_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'L': { std::int64_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'u': @@ -2627,7 +2626,7 @@ class binary_reader break; } std::uint16_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'm': @@ -2637,7 +2636,7 @@ class binary_reader break; } std::uint32_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'M': @@ -2647,7 +2646,7 @@ class binary_reader break; } std::uint64_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } default: @@ -2664,7 +2663,7 @@ class binary_reader { message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token; } - return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "string"), nullptr)); } /*! @@ -2748,7 +2747,7 @@ class binary_reader case 'U': { std::uint8_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -2759,14 +2758,14 @@ class binary_reader case 'i': { std::int8_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char return true; @@ -2775,14 +2774,14 @@ class binary_reader case 'I': { std::int16_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); return true; @@ -2791,14 +2790,14 @@ class binary_reader case 'l': { std::int32_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); return true; @@ -2807,19 +2806,19 @@ class binary_reader case 'L': { std::int64_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } if (!value_in_range_of(number)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "integer value overflow", "size"), nullptr)); + exception_message("integer value overflow", "size"), nullptr)); } result = static_cast(number); return true; @@ -2832,7 +2831,7 @@ class binary_reader break; } std::uint16_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -2847,7 +2846,7 @@ class binary_reader break; } std::uint32_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -2862,14 +2861,14 @@ class binary_reader break; } std::uint64_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (!value_in_range_of(number)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "integer value overflow", "size"), nullptr)); + exception_message("integer value overflow", "size"), nullptr)); } result = detail::conditional_static_cast(number); return true; @@ -2883,7 +2882,7 @@ class binary_reader } if (is_ndarray) // ndarray dimensional vector can only contain integers and cannot embed another array { - return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message("ndarray dimensional vector is not allowed", "size"), nullptr)); } std::vector dim; if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim))) @@ -2919,15 +2918,15 @@ class binary_reader // as modular arithmetic can produce any value, not just 0 or SIZE_MAX. if (JSON_HEDLEY_UNLIKELY(i > 0 && result > (std::numeric_limits::max)() / i)) { - return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr)); } result *= i; // Additional post-multiplication check to catch any edge cases the pre-check might miss if (result == 0 || result == npos) { - return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!emit_unsigned(input_format, i))) + if (JSON_HEDLEY_UNLIKELY(!emit_unsigned(i))) { return false; } @@ -2953,7 +2952,7 @@ class binary_reader { message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token; } - return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "size"), nullptr)); } /*! @@ -2988,10 +2987,10 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); + exception_message(concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("type"))) { return false; } @@ -2999,13 +2998,13 @@ class binary_reader get_ignore_noop(); if (JSON_HEDLEY_UNLIKELY(current != '#')) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("value"))) { return false; } auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); + exception_message(concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); } const bool is_error = get_ubjson_size_value(result.first, is_ndarray); @@ -3025,7 +3024,7 @@ class binary_reader if (input_format == input_format_t::bjdata && is_ndarray && !inside_ndarray) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, - exception_message(input_format, "ndarray requires both type and size", "size"), nullptr)); + exception_message("ndarray requires both type and size", "size"), nullptr)); } return is_error; } @@ -3042,7 +3041,7 @@ class binary_reader switch (prefix) { case char_traits::eof(): // EOF - return unexpect_eof(input_format, "value"); + return unexpect_eof("value"); case 'T': // true return sax->boolean(true); @@ -3059,37 +3058,37 @@ class binary_reader break; } std::uint8_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'U': { std::uint8_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'i': { std::int8_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'I': { std::int16_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'l': { std::int32_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'L': { std::int64_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'u': @@ -3099,7 +3098,7 @@ class binary_reader break; } std::uint16_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'm': @@ -3109,7 +3108,7 @@ class binary_reader break; } std::uint32_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'M': @@ -3119,7 +3118,7 @@ class binary_reader break; } std::uint64_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'h': @@ -3129,12 +3128,12 @@ class binary_reader break; } const auto byte1_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } const auto byte2_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -3177,13 +3176,13 @@ class binary_reader case 'd': { float number{}; - return get_number(input_format, number) && emit_float(input_format, number); + return get_number(number) && emit_float(number); } case 'D': { double number{}; - return get_number(input_format, number) && emit_float(input_format, number); + return get_number(number) && emit_float(number); } case 'H': @@ -3194,7 +3193,7 @@ class binary_reader case 'C': // char { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("char"))) { return false; } @@ -3202,7 +3201,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); + exception_message(concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); } string_t s(1, static_cast(current)); return sax->string(s); @@ -3224,7 +3223,7 @@ class binary_reader break; } auto last_token = get_token_string(); - return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message("invalid byte: 0x" + last_token, "value"), nullptr)); } /*! @@ -3253,7 +3252,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr)); + exception_message("invalid byte: 0x" + last_token, "type"), nullptr)); } string_t type = it->second; // sax->string() takes a reference @@ -3288,7 +3287,7 @@ class binary_reader if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B') { binary_t result; - return get_binary(input_format, size_and_type.first, result) && sax->binary(result); + return get_binary(size_and_type.first, result) && sax->binary(result); } if (size_and_type.first != npos) @@ -3301,7 +3300,7 @@ class binary_reader && size_and_type.first > max_valueless_container_size)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "excessive array size", "size"), nullptr)); + exception_message("excessive array size", "size"), nullptr)); } if (JSON_HEDLEY_UNLIKELY(!enter_array(size_and_type.first, size_and_type.second))) @@ -3338,7 +3337,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr)); + exception_message("BJData object does not support ND-array size in optimized format", "object"), nullptr)); } if (size_and_type.first != npos) @@ -3368,7 +3367,7 @@ class binary_reader for (std::size_t i = 0; i < size; ++i) { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -3387,7 +3386,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input)) { return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, - exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); } switch (result_number) @@ -3427,7 +3426,7 @@ class binary_reader case token_type::literal_or_value: default: return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, - exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); } } @@ -3496,7 +3495,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bon8, concat(detail, ": 0x", last_token), context), nullptr)); + exception_message(concat(detail, ": 0x", last_token), context), nullptr)); } /*! @@ -3601,7 +3600,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "value"); + return unexpect_eof("value"); } // string: ASCII character @@ -3638,25 +3637,25 @@ class binary_reader case 0x8C: // int32 { std::int32_t number{}; - return get_number(input_format_t::bon8, number) && emit_bon8_integer(number); + return get_number(number) && emit_bon8_integer(number); } case 0x8D: // int64 { std::int64_t number{}; - return get_number(input_format_t::bon8, number) && emit_bon8_integer(number); + return get_number(number) && emit_bon8_integer(number); } case 0x8E: // binary32 { float number{}; - return get_number(input_format_t::bon8, number) && emit_float(input_format_t::bon8, number); + return get_number(number) && emit_float(number); } case 0x8F: // binary64 { double number{}; - return get_number(input_format_t::bon8, number) && emit_float(input_format_t::bon8, number); + return get_number(number) && emit_float(number); } case 0xF8: @@ -3733,9 +3732,9 @@ class binary_reader { if (number >= 0) { - return emit_unsigned(input_format_t::bon8, static_cast(number)); + return emit_unsigned(static_cast(number)); } - return emit_signed(input_format_t::bon8, number); + return emit_signed(number); } /*! @@ -3755,7 +3754,7 @@ class binary_reader */ bool get_bon8_integer(const char_int_type lead, const char_int_type second) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bon8, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -3787,7 +3786,7 @@ class binary_reader { if (JSON_HEDLEY_UNLIKELY(get_bon8() == char_traits::eof())) { - return unexpect_eof(input_format_t::bon8, "number"); + return unexpect_eof("number"); } value = (value << 8) | static_cast(current); } @@ -3810,7 +3809,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "key"); + return unexpect_eof("key"); } if (byte == 0xFF) @@ -3898,7 +3897,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "string"); + return unexpect_eof("string"); } // end of string @@ -3964,7 +3963,7 @@ class binary_reader { if (JSON_HEDLEY_UNLIKELY(get_bon8() == char_traits::eof())) { - return unexpect_eof(input_format_t::bon8, "string"); + return unexpect_eof("string"); } if (JSON_HEDLEY_UNLIKELY(!is_bon8_continuation(current))) { @@ -4003,7 +4002,7 @@ class binary_reader @return bool, whether the read was successful */ template - bool get_to(T& dest, const input_format_t format, const char* context) + bool get_to(T& dest, const char* context) { auto new_chars_read = ia.get_elements(&dest); chars_read += new_chars_read; @@ -4011,7 +4010,7 @@ class binary_reader { // in case of failure, advance position by 1 to report the failing location ++chars_read; - sax->parse_error(chars_read, "", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); + sax->parse_error(chars_read, "", parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr)); return false; } return true; @@ -4062,7 +4061,6 @@ class binary_reader @brief read a number from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[out] result number of type @a NumberType @return whether conversion completed @@ -4074,15 +4072,15 @@ class binary_reader on big endian systems. */ template - bool get_number(const input_format_t format, NumberType& result) + bool get_number(NumberType& result) { // read in the original format - if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!get_to(result, "number"))) { return false; } - if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata)) + if (is_little_endian != (InputIsLittleEndian || input_format == input_format_t::bjdata)) { byte_swap(result); } @@ -4099,7 +4097,6 @@ class binary_reader matters for narrower custom number types. @tparam NumberType a signed integer type - @param[in] format the current format (for diagnostics) @param[in] number the integer @return whether the SAX parser accepted the value @@ -4107,7 +4104,7 @@ class binary_reader @ref emit_float) */ template - bool emit_signed(const input_format_t format, const NumberType number) + bool emit_signed(const NumberType number) { if (JSON_HEDLEY_LIKELY(value_in_range_of(number))) { @@ -4117,7 +4114,7 @@ class binary_reader { return sax->number_unsigned(static_cast(number)); } - return emit_float(format, number); + return emit_float(number); } /*! @@ -4127,7 +4124,6 @@ class binary_reader number_unsigned_t is passed as number_float_t. @tparam NumberType an unsigned integer type - @param[in] format the current format (for diagnostics) @param[in] number the integer @return whether the SAX parser accepted the value @@ -4135,13 +4131,13 @@ class binary_reader @ref emit_float) */ template - bool emit_unsigned(const input_format_t format, const NumberType number) + bool emit_unsigned(const NumberType number) { if (JSON_HEDLEY_LIKELY(value_in_range_of(number))) { return sax->number_unsigned(static_cast(number)); } - return emit_float(format, number); + return emit_float(number); } /*! @@ -4153,20 +4149,19 @@ class binary_reader number_float_t cannot represent 2^64, e.g., a half-precision type. @tparam NumberType a floating-point or integer type - @param[in] format the current format (for diagnostics) @param[in] number the number @return whether the SAX parser accepted the value @throw out_of_range.406 if a finite @a number overflows number_float_t */ template - bool emit_float(const input_format_t format, const NumberType number) + bool emit_float(const NumberType number) { const auto result = static_cast(number); if (JSON_HEDLEY_UNLIKELY(std::isfinite(number) && !std::isfinite(result))) { return sax->parse_error(chars_read, get_token_string(), - out_of_range::create(406, exception_message(format, "number overflow", "value"), nullptr)); + out_of_range::create(406, exception_message("number overflow", "value"), nullptr)); } return sax->number_float(result, ""); } @@ -4175,7 +4170,6 @@ class binary_reader @brief create a string by reading characters from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[in] len number of characters to read @param[out] result string created by reading @a len bytes @@ -4186,15 +4180,14 @@ class binary_reader the input before we run out of string memory. */ template - bool get_string(const input_format_t format, - const NumberType len, + bool get_string(const NumberType len, string_t& result) { // get_bytes() appends to result, and CBOR indefinite-length strings // collect all their chunks in the same result; validating only the // newly read bytes keeps the check linear in the input size const std::size_t old_size = result.size(); - if (JSON_HEDLEY_UNLIKELY(!get_bytes(format, len, "string", result))) + if (JSON_HEDLEY_UNLIKELY(!get_bytes(len, "string", result))) { return false; } @@ -4208,7 +4201,7 @@ class binary_reader { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(format, "invalid string: ill-formed UTF-8 byte", "string"), nullptr)); + exception_message("invalid string: ill-formed UTF-8 byte", "string"), nullptr)); } return true; @@ -4218,7 +4211,6 @@ class binary_reader @brief create a byte array by reading bytes from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[in] len number of bytes to read @param[out] result byte array created by reading @a len bytes @@ -4229,11 +4221,10 @@ class binary_reader the input before we run out of memory. */ template - bool get_binary(const input_format_t format, - const NumberType len, + bool get_binary(const NumberType len, binary_t& result) { - return get_bytes(format, len, "binary", result); + return get_bytes(len, "binary", result); } /*! @@ -4241,7 +4232,6 @@ class binary_reader @tparam NumberType the type of the length @tparam ContainerType the destination container (string_t or binary_t) - @param[in] format the current format (for diagnostics) @param[in] len number of bytes to read @param[in] context further context information (for diagnostics) @param[out] result container the bytes are appended to @@ -4256,8 +4246,7 @@ class binary_reader detects a premature end of input. */ template - bool get_bytes(const input_format_t format, - NumberType len, + bool get_bytes(NumberType len, const char* context, ContainerType& result) { @@ -4286,7 +4275,7 @@ class binary_reader result.resize(old_size + bytes_read); ++chars_read; current = char_traits::eof(); - return unexpect_eof(format, context); + return unexpect_eof(context); } // a full chunk was read; get_elements() never returns more than requested JSON_ASSERT(bytes_read == wanted); @@ -4296,17 +4285,16 @@ class binary_reader } /*! - @param[in] format the current format (for diagnostics) @param[in] context further context information (for diagnostics) @return whether the last read character is not EOF */ - JSON_HEDLEY_NON_NULL(3) - bool unexpect_eof(const input_format_t format, const char* context) const + JSON_HEDLEY_NON_NULL(2) + bool unexpect_eof(const char* context) const { if (JSON_HEDLEY_UNLIKELY(current == char_traits::eof())) { return sax->parse_error(chars_read, "", - parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); + parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr)); } return true; } @@ -4322,18 +4310,16 @@ class binary_reader } /*! - @param[in] format the current format @param[in] detail a detailed error message @param[in] context further context information @return a message string to use in the parse_error exceptions */ - std::string exception_message(const input_format_t format, - const std::string& detail, + std::string exception_message(const std::string& detail, const std::string& context) const { std::string error_msg = "syntax error while parsing "; - switch (format) + switch (input_format) { case input_format_t::cbor: error_msg += "CBOR"; diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp index 7024b60a8..fb4880bc1 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -12956,7 +12956,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(current != char_traits::eof())) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read, - exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); + exception_message(concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); } } @@ -13063,7 +13063,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(document_size < 0 || static_cast(document_size) != chars_read - document_start)) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr)); + exception_message(concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr)); } return true; } @@ -13078,7 +13078,7 @@ class binary_reader // check_bson_document_size() measures the document from here const std::size_t document_start = chars_read; std::int32_t document_size{}; - if (!get_number(input_format_t::bson, document_size)) + if (!get_number(document_size)) { return false; } @@ -13144,7 +13144,7 @@ class binary_reader continue; } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("element list"))) { return false; } @@ -13188,7 +13188,7 @@ class binary_reader while (true) { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("cstring"))) { return false; } @@ -13258,10 +13258,10 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); + exception_message(concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!get_string(input_format_t::bson, len - static_cast(1), result))) + if (JSON_HEDLEY_UNLIKELY(!get_string(len - static_cast(1), result))) { return false; } @@ -13270,8 +13270,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, - "BSON string is not null-terminated", + exception_message("BSON string is not null-terminated", "string"), nullptr)); } @@ -13294,18 +13293,18 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); + exception_message(concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); } // All BSON binary values have a subtype std::uint8_t subtype{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::bson, subtype))) + if (JSON_HEDLEY_UNLIKELY(!get_number(subtype))) { return false; } result.set_subtype(subtype); - return get_binary(input_format_t::bson, len, result); + return get_binary(len, result); } /*! @@ -13326,14 +13325,14 @@ class binary_reader case 0x01: // double { double number{}; - return get_number(input_format_t::bson, number) && emit_float(input_format_t::bson, number); + return get_number(number) && emit_float(number); } case 0x02: // string { std::int32_t len{}; string_t value; - return get_number(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value); + return get_number(len) && get_bson_string(len, value) && sax->string(value); } case 0x03: // object @@ -13350,13 +13349,13 @@ class binary_reader { std::int32_t len{}; binary_t value; - return get_number(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value); + return get_number(len) && get_bson_binary(len, value) && sax->binary(value); } case 0x08: // boolean { std::uint8_t value{}; - return get_number(input_format_t::bson, value) && sax->boolean(value != 0); + return get_number(value) && sax->boolean(value != 0); } case 0x0A: // null @@ -13367,19 +13366,19 @@ class binary_reader case 0x10: // int32 { std::int32_t value{}; - return get_number(input_format_t::bson, value) && emit_signed(input_format_t::bson, value); + return get_number(value) && emit_signed(value); } case 0x12: // int64 { std::int64_t value{}; - return get_number(input_format_t::bson, value) && emit_signed(input_format_t::bson, value); + return get_number(value) && emit_signed(value); } case 0x11: // uint64 { std::uint64_t value{}; - return get_number(input_format_t::bson, value) && emit_unsigned(input_format_t::bson, value); + return get_number(value) && emit_unsigned(value); } default: // anything else is not supported (yet) @@ -13401,7 +13400,7 @@ class binary_reader bool get_cbor_negative_integer() { NumberType number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::cbor, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -13417,7 +13416,7 @@ class binary_reader // number_integer_t as number_float_t; compute it as long double so // that emit_float sees a finite value and can detect an overflow of // number_float_t - return emit_float(input_format_t::cbor, static_cast(-1) - static_cast(number)); + return emit_float(static_cast(-1) - static_cast(number)); } /*! @@ -13442,7 +13441,7 @@ class binary_reader { // EOF case char_traits::eof(): - return unexpect_eof(input_format_t::cbor, "value"); + return unexpect_eof("value"); // Integer 0x00..0x17 (0..23) case 0x00: @@ -13474,25 +13473,25 @@ class binary_reader case 0x18: // Unsigned integer (one-byte uint8_t follows) { std::uint8_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x19: // Unsigned integer (two-byte uint16_t follows) { std::uint16_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x1A: // Unsigned integer (four-byte uint32_t follows) { std::uint32_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } case 0x1B: // Unsigned integer (eight-byte uint64_t follows) { std::uint64_t number{}; - return get_number(input_format_t::cbor, number) && emit_unsigned(input_format_t::cbor, number); + return get_number(number) && emit_unsigned(number); } // Negative integer -1-0x00..-1-0x17 (-1..-24) @@ -13634,27 +13633,27 @@ class binary_reader case 0x98: // array (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0x99: // array (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0x9A: // array (four-byte uint32_t for n follow) { std::uint32_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size); + return get_number(len) && get_cbor_container_size(len, size, "array") && enter_array(size); } case 0x9B: // array (eight-byte uint64_t for n follow) { std::uint64_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size); + return get_number(len) && get_cbor_container_size(len, size, "array") && enter_array(size); } case 0x9F: // array (indefinite length) @@ -13690,27 +13689,27 @@ class binary_reader case 0xB8: // map (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xB9: // map (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xBA: // map (four-byte uint32_t for n follow) { std::uint32_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size); + return get_number(len) && get_cbor_container_size(len, size, "map") && enter_object(size); } case 0xBB: // map (eight-byte uint64_t for n follow) { std::uint64_t len{}; std::size_t size{}; - return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size); + return get_number(len) && get_cbor_container_size(len, size, "map") && enter_object(size); } case 0xBF: // map (indefinite length) @@ -13751,7 +13750,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } case cbor_tag_handler_t::ignore: @@ -13762,7 +13761,7 @@ class binary_reader case 0xD8: { std::uint8_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -13771,7 +13770,7 @@ class binary_reader case 0xD9: { std::uint16_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -13780,7 +13779,7 @@ class binary_reader case 0xDA: { std::uint32_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -13789,7 +13788,7 @@ class binary_reader case 0xDB: { std::uint64_t subtype_to_ignore{}; - if (!get_number(input_format_t::cbor, subtype_to_ignore)) + if (!get_number(subtype_to_ignore)) { return false; } @@ -13813,7 +13812,7 @@ class binary_reader case 0xD8: { std::uint8_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -13823,7 +13822,7 @@ class binary_reader case 0xD9: { std::uint16_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -13833,7 +13832,7 @@ class binary_reader case 0xDA: { std::uint32_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -13843,7 +13842,7 @@ class binary_reader case 0xDB: { std::uint64_t subtype{}; - if (!get_number(input_format_t::cbor, subtype)) + if (!get_number(subtype)) { return false; } @@ -13889,12 +13888,12 @@ class binary_reader case 0xF9: // Half-Precision Float (two-byte IEEE 754) { const auto byte1_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } const auto byte2_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -13937,20 +13936,20 @@ class binary_reader case 0xFA: // Single-Precision Float (four-byte IEEE 754) { float number{}; - return get_number(input_format_t::cbor, number) && emit_float(input_format_t::cbor, number); + return get_number(number) && emit_float(number); } case 0xFB: // Double-Precision Float (eight-byte IEEE 754) { double number{}; - return get_number(input_format_t::cbor, number) && emit_float(input_format_t::cbor, number); + return get_number(number) && emit_float(number); } default: // anything else (0xFF is handled inside the other types) { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } } } @@ -13999,38 +13998,38 @@ class binary_reader case 0x76: case 0x77: { - return get_string(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + return get_string(static_cast(current) & 0x1Fu, result); } case 0x78: // UTF-8 string (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x79: // UTF-8 string (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) { std::uint32_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) { std::uint64_t len{}; - return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); + return get_number(len) && get_string(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); + exception_message(concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); } } } @@ -14058,7 +14057,7 @@ class binary_reader while (true) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("string"))) { return false; } @@ -14167,7 +14166,7 @@ class binary_reader auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); + exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); } /*! @@ -14214,42 +14213,42 @@ class binary_reader case 0x56: case 0x57: { - return get_binary(input_format_t::cbor, static_cast(current) & 0x1Fu, result); + return get_binary(static_cast(current) & 0x1Fu, result); } case 0x58: // Binary data (one-byte uint8_t for n follows) { std::uint8_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x59: // Binary data (two-byte uint16_t for n follow) { std::uint16_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x5A: // Binary data (four-byte uint32_t for n follow) { std::uint32_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } case 0x5B: // Binary data (eight-byte uint64_t for n follow) { std::uint64_t len{}; - return get_number(input_format_t::cbor, len) && - get_binary(input_format_t::cbor, len, result); + return get_number(len) && + get_binary(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); + exception_message(concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); } } } @@ -14273,7 +14272,7 @@ class binary_reader while (true) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("binary"))) { return false; } @@ -14330,7 +14329,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(!value_in_range_of(len) || len == detail::unknown_size())) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format_t::cbor, concat("excessive ", context, " size"), "size"), nullptr)); + exception_message(concat("excessive ", context, " size"), "size"), nullptr)); } result = conditional_static_cast(len); return true; @@ -14467,7 +14466,7 @@ class binary_reader { // EOF case char_traits::eof(): - return unexpect_eof(input_format_t::msgpack, "value"); + return unexpect_eof("value"); // positive fixint case 0x00: @@ -14707,85 +14706,85 @@ class binary_reader case 0xCA: // float 32 { float number{}; - return get_number(input_format_t::msgpack, number) && emit_float(input_format_t::msgpack, number); + return get_number(number) && emit_float(number); } case 0xCB: // float 64 { double number{}; - return get_number(input_format_t::msgpack, number) && emit_float(input_format_t::msgpack, number); + return get_number(number) && emit_float(number); } case 0xCC: // uint 8 { std::uint8_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCD: // uint 16 { std::uint16_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCE: // uint 32 { std::uint32_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xCF: // uint 64 { std::uint64_t number{}; - return get_number(input_format_t::msgpack, number) && emit_unsigned(input_format_t::msgpack, number); + return get_number(number) && emit_unsigned(number); } case 0xD0: // int 8 { std::int8_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD1: // int 16 { std::int16_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD2: // int 32 { std::int32_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xD3: // int 64 { std::int64_t number{}; - return get_number(input_format_t::msgpack, number) && emit_signed(input_format_t::msgpack, number); + return get_number(number) && emit_signed(number); } case 0xDC: // array 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && enter_array(static_cast(len)); + return get_number(len) && enter_array(static_cast(len)); } case 0xDD: // array 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && enter_array(conditional_static_cast(len)); + return get_number(len) && enter_array(conditional_static_cast(len)); } case 0xDE: // map 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && enter_object(static_cast(len)); + return get_number(len) && enter_object(static_cast(len)); } case 0xDF: // map 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && enter_object(conditional_static_cast(len)); + return get_number(len) && enter_object(conditional_static_cast(len)); } // negative fixint @@ -14827,7 +14826,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr)); + exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr)); } } } @@ -14844,7 +14843,7 @@ class binary_reader */ bool get_msgpack_string(string_t& result) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("string"))) { return false; } @@ -14885,32 +14884,32 @@ class binary_reader case 0xBE: case 0xBF: { - return get_string(input_format_t::msgpack, static_cast(current) & 0x1Fu, result); + return get_string(static_cast(current) & 0x1Fu, result); } case 0xD9: // str 8 { std::uint8_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } case 0xDA: // str 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } case 0xDB: // str 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); + return get_number(len) && get_string(len, result); } default: { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); + exception_message(concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); } } } @@ -15004,7 +15003,7 @@ class binary_reader auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format_t::msgpack, concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); + exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr)); } /*! @@ -15031,31 +15030,31 @@ class binary_reader case 0xC4: // bin 8 { std::uint8_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC5: // bin 16 { std::uint16_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC6: // bin 32 { std::uint32_t len{}; - return get_number(input_format_t::msgpack, len) && - get_binary(input_format_t::msgpack, len, result); + return get_number(len) && + get_binary(len, result); } case 0xC7: // ext 8 { std::uint8_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } @@ -15063,9 +15062,9 @@ class binary_reader { std::uint16_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } @@ -15073,49 +15072,49 @@ class binary_reader { std::uint32_t len{}; std::int8_t subtype{}; - return get_number(input_format_t::msgpack, len) && - get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, len, result) && + return get_number(len) && + get_number(subtype) && + get_binary(len, result) && assign_and_return_true(subtype); } case 0xD4: // fixext 1 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 1, result) && + return get_number(subtype) && + get_binary(1, result) && assign_and_return_true(subtype); } case 0xD5: // fixext 2 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 2, result) && + return get_number(subtype) && + get_binary(2, result) && assign_and_return_true(subtype); } case 0xD6: // fixext 4 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 4, result) && + return get_number(subtype) && + get_binary(4, result) && assign_and_return_true(subtype); } case 0xD7: // fixext 8 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 8, result) && + return get_number(subtype) && + get_binary(8, result) && assign_and_return_true(subtype); } case 0xD8: // fixext 16 { std::int8_t subtype{}; - return get_number(input_format_t::msgpack, subtype) && - get_binary(input_format_t::msgpack, 16, result) && + return get_number(subtype) && + get_binary(16, result) && assign_and_return_true(subtype); } @@ -15320,7 +15319,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(len < 0)) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "string length must not be negative", "string"), nullptr)); + exception_message("string length must not be negative", "string"), nullptr)); } return true; } @@ -15350,7 +15349,7 @@ class binary_reader get(); } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("value"))) { return false; } @@ -15360,31 +15359,31 @@ class binary_reader case 'U': { std::uint8_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'i': { std::int8_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'I': { std::int16_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'l': { std::int32_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'L': { std::int64_t len{}; - return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result); + return get_number(len) && check_ubjson_string_length(len) && get_string(len, result); } case 'u': @@ -15394,7 +15393,7 @@ class binary_reader break; } std::uint16_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'm': @@ -15404,7 +15403,7 @@ class binary_reader break; } std::uint32_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } case 'M': @@ -15414,7 +15413,7 @@ class binary_reader break; } std::uint64_t len{}; - return get_number(input_format, len) && get_string(input_format, len, result); + return get_number(len) && get_string(len, result); } default: @@ -15431,7 +15430,7 @@ class binary_reader { message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token; } - return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "string"), nullptr)); } /*! @@ -15515,7 +15514,7 @@ class binary_reader case 'U': { std::uint8_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -15526,14 +15525,14 @@ class binary_reader case 'i': { std::int8_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char return true; @@ -15542,14 +15541,14 @@ class binary_reader case 'I': { std::int16_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); return true; @@ -15558,14 +15557,14 @@ class binary_reader case 'l': { std::int32_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } result = static_cast(number); return true; @@ -15574,19 +15573,19 @@ class binary_reader case 'L': { std::int64_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (number < 0) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); + exception_message("count in an optimized container must be positive", "size"), nullptr)); } if (!value_in_range_of(number)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "integer value overflow", "size"), nullptr)); + exception_message("integer value overflow", "size"), nullptr)); } result = static_cast(number); return true; @@ -15599,7 +15598,7 @@ class binary_reader break; } std::uint16_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -15614,7 +15613,7 @@ class binary_reader break; } std::uint32_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } @@ -15629,14 +15628,14 @@ class binary_reader break; } std::uint64_t number{}; - if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) + if (JSON_HEDLEY_UNLIKELY(!get_number(number))) { return false; } if (!value_in_range_of(number)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "integer value overflow", "size"), nullptr)); + exception_message("integer value overflow", "size"), nullptr)); } result = detail::conditional_static_cast(number); return true; @@ -15650,7 +15649,7 @@ class binary_reader } if (is_ndarray) // ndarray dimensional vector can only contain integers and cannot embed another array { - return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message("ndarray dimensional vector is not allowed", "size"), nullptr)); } std::vector dim; if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim))) @@ -15686,15 +15685,15 @@ class binary_reader // as modular arithmetic can produce any value, not just 0 or SIZE_MAX. if (JSON_HEDLEY_UNLIKELY(i > 0 && result > (std::numeric_limits::max)() / i)) { - return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr)); } result *= i; // Additional post-multiplication check to catch any edge cases the pre-check might miss if (result == 0 || result == npos) { - return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); + return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!emit_unsigned(input_format, i))) + if (JSON_HEDLEY_UNLIKELY(!emit_unsigned(i))) { return false; } @@ -15720,7 +15719,7 @@ class binary_reader { message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token; } - return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "size"), nullptr)); } /*! @@ -15755,10 +15754,10 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); + exception_message(concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); } - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("type"))) { return false; } @@ -15766,13 +15765,13 @@ class binary_reader get_ignore_noop(); if (JSON_HEDLEY_UNLIKELY(current != '#')) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("value"))) { return false; } auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); + exception_message(concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); } const bool is_error = get_ubjson_size_value(result.first, is_ndarray); @@ -15792,7 +15791,7 @@ class binary_reader if (input_format == input_format_t::bjdata && is_ndarray && !inside_ndarray) { return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, - exception_message(input_format, "ndarray requires both type and size", "size"), nullptr)); + exception_message("ndarray requires both type and size", "size"), nullptr)); } return is_error; } @@ -15809,7 +15808,7 @@ class binary_reader switch (prefix) { case char_traits::eof(): // EOF - return unexpect_eof(input_format, "value"); + return unexpect_eof("value"); case 'T': // true return sax->boolean(true); @@ -15826,37 +15825,37 @@ class binary_reader break; } std::uint8_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'U': { std::uint8_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'i': { std::int8_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'I': { std::int16_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'l': { std::int32_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'L': { std::int64_t number{}; - return get_number(input_format, number) && emit_signed(input_format, number); + return get_number(number) && emit_signed(number); } case 'u': @@ -15866,7 +15865,7 @@ class binary_reader break; } std::uint16_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'm': @@ -15876,7 +15875,7 @@ class binary_reader break; } std::uint32_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'M': @@ -15886,7 +15885,7 @@ class binary_reader break; } std::uint64_t number{}; - return get_number(input_format, number) && emit_unsigned(input_format, number); + return get_number(number) && emit_unsigned(number); } case 'h': @@ -15896,12 +15895,12 @@ class binary_reader break; } const auto byte1_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } const auto byte2_raw = get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -15944,13 +15943,13 @@ class binary_reader case 'd': { float number{}; - return get_number(input_format, number) && emit_float(input_format, number); + return get_number(number) && emit_float(number); } case 'D': { double number{}; - return get_number(input_format, number) && emit_float(input_format, number); + return get_number(number) && emit_float(number); } case 'H': @@ -15961,7 +15960,7 @@ class binary_reader case 'C': // char { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("char"))) { return false; } @@ -15969,7 +15968,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, - exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); + exception_message(concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); } string_t s(1, static_cast(current)); return sax->string(s); @@ -15991,7 +15990,7 @@ class binary_reader break; } auto last_token = get_token_string(); - return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr)); + return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message("invalid byte: 0x" + last_token, "value"), nullptr)); } /*! @@ -16020,7 +16019,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr)); + exception_message("invalid byte: 0x" + last_token, "type"), nullptr)); } string_t type = it->second; // sax->string() takes a reference @@ -16055,7 +16054,7 @@ class binary_reader if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B') { binary_t result; - return get_binary(input_format, size_and_type.first, result) && sax->binary(result); + return get_binary(size_and_type.first, result) && sax->binary(result); } if (size_and_type.first != npos) @@ -16068,7 +16067,7 @@ class binary_reader && size_and_type.first > max_valueless_container_size)) { return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, - exception_message(input_format, "excessive array size", "size"), nullptr)); + exception_message("excessive array size", "size"), nullptr)); } if (JSON_HEDLEY_UNLIKELY(!enter_array(size_and_type.first, size_and_type.second))) @@ -16105,7 +16104,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr)); + exception_message("BJData object does not support ND-array size in optimized format", "object"), nullptr)); } if (size_and_type.first != npos) @@ -16135,7 +16134,7 @@ class binary_reader for (std::size_t i = 0; i < size; ++i) { get(); - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -16154,7 +16153,7 @@ class binary_reader if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input)) { return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, - exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); } switch (result_number) @@ -16194,7 +16193,7 @@ class binary_reader case token_type::literal_or_value: default: return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, - exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); + exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); } } @@ -16263,7 +16262,7 @@ class binary_reader { auto last_token = get_token_string(); return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, - exception_message(input_format_t::bon8, concat(detail, ": 0x", last_token), context), nullptr)); + exception_message(concat(detail, ": 0x", last_token), context), nullptr)); } /*! @@ -16368,7 +16367,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "value"); + return unexpect_eof("value"); } // string: ASCII character @@ -16405,25 +16404,25 @@ class binary_reader case 0x8C: // int32 { std::int32_t number{}; - return get_number(input_format_t::bon8, number) && emit_bon8_integer(number); + return get_number(number) && emit_bon8_integer(number); } case 0x8D: // int64 { std::int64_t number{}; - return get_number(input_format_t::bon8, number) && emit_bon8_integer(number); + return get_number(number) && emit_bon8_integer(number); } case 0x8E: // binary32 { float number{}; - return get_number(input_format_t::bon8, number) && emit_float(input_format_t::bon8, number); + return get_number(number) && emit_float(number); } case 0x8F: // binary64 { double number{}; - return get_number(input_format_t::bon8, number) && emit_float(input_format_t::bon8, number); + return get_number(number) && emit_float(number); } case 0xF8: @@ -16500,9 +16499,9 @@ class binary_reader { if (number >= 0) { - return emit_unsigned(input_format_t::bon8, static_cast(number)); + return emit_unsigned(static_cast(number)); } - return emit_signed(input_format_t::bon8, number); + return emit_signed(number); } /*! @@ -16522,7 +16521,7 @@ class binary_reader */ bool get_bon8_integer(const char_int_type lead, const char_int_type second) { - if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bon8, "number"))) + if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("number"))) { return false; } @@ -16554,7 +16553,7 @@ class binary_reader { if (JSON_HEDLEY_UNLIKELY(get_bon8() == char_traits::eof())) { - return unexpect_eof(input_format_t::bon8, "number"); + return unexpect_eof("number"); } value = (value << 8) | static_cast(current); } @@ -16577,7 +16576,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "key"); + return unexpect_eof("key"); } if (byte == 0xFF) @@ -16665,7 +16664,7 @@ class binary_reader if (byte == char_traits::eof()) { - return unexpect_eof(input_format_t::bon8, "string"); + return unexpect_eof("string"); } // end of string @@ -16731,7 +16730,7 @@ class binary_reader { if (JSON_HEDLEY_UNLIKELY(get_bon8() == char_traits::eof())) { - return unexpect_eof(input_format_t::bon8, "string"); + return unexpect_eof("string"); } if (JSON_HEDLEY_UNLIKELY(!is_bon8_continuation(current))) { @@ -16770,7 +16769,7 @@ class binary_reader @return bool, whether the read was successful */ template - bool get_to(T& dest, const input_format_t format, const char* context) + bool get_to(T& dest, const char* context) { auto new_chars_read = ia.get_elements(&dest); chars_read += new_chars_read; @@ -16778,7 +16777,7 @@ class binary_reader { // in case of failure, advance position by 1 to report the failing location ++chars_read; - sax->parse_error(chars_read, "", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); + sax->parse_error(chars_read, "", parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr)); return false; } return true; @@ -16829,7 +16828,6 @@ class binary_reader @brief read a number from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[out] result number of type @a NumberType @return whether conversion completed @@ -16841,15 +16839,15 @@ class binary_reader on big endian systems. */ template - bool get_number(const input_format_t format, NumberType& result) + bool get_number(NumberType& result) { // read in the original format - if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number"))) + if (JSON_HEDLEY_UNLIKELY(!get_to(result, "number"))) { return false; } - if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata)) + if (is_little_endian != (InputIsLittleEndian || input_format == input_format_t::bjdata)) { byte_swap(result); } @@ -16866,7 +16864,6 @@ class binary_reader matters for narrower custom number types. @tparam NumberType a signed integer type - @param[in] format the current format (for diagnostics) @param[in] number the integer @return whether the SAX parser accepted the value @@ -16874,7 +16871,7 @@ class binary_reader @ref emit_float) */ template - bool emit_signed(const input_format_t format, const NumberType number) + bool emit_signed(const NumberType number) { if (JSON_HEDLEY_LIKELY(value_in_range_of(number))) { @@ -16884,7 +16881,7 @@ class binary_reader { return sax->number_unsigned(static_cast(number)); } - return emit_float(format, number); + return emit_float(number); } /*! @@ -16894,7 +16891,6 @@ class binary_reader number_unsigned_t is passed as number_float_t. @tparam NumberType an unsigned integer type - @param[in] format the current format (for diagnostics) @param[in] number the integer @return whether the SAX parser accepted the value @@ -16902,13 +16898,13 @@ class binary_reader @ref emit_float) */ template - bool emit_unsigned(const input_format_t format, const NumberType number) + bool emit_unsigned(const NumberType number) { if (JSON_HEDLEY_LIKELY(value_in_range_of(number))) { return sax->number_unsigned(static_cast(number)); } - return emit_float(format, number); + return emit_float(number); } /*! @@ -16920,20 +16916,19 @@ class binary_reader number_float_t cannot represent 2^64, e.g., a half-precision type. @tparam NumberType a floating-point or integer type - @param[in] format the current format (for diagnostics) @param[in] number the number @return whether the SAX parser accepted the value @throw out_of_range.406 if a finite @a number overflows number_float_t */ template - bool emit_float(const input_format_t format, const NumberType number) + bool emit_float(const NumberType number) { const auto result = static_cast(number); if (JSON_HEDLEY_UNLIKELY(std::isfinite(number) && !std::isfinite(result))) { return sax->parse_error(chars_read, get_token_string(), - out_of_range::create(406, exception_message(format, "number overflow", "value"), nullptr)); + out_of_range::create(406, exception_message("number overflow", "value"), nullptr)); } return sax->number_float(result, ""); } @@ -16942,7 +16937,6 @@ class binary_reader @brief create a string by reading characters from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[in] len number of characters to read @param[out] result string created by reading @a len bytes @@ -16953,15 +16947,14 @@ class binary_reader the input before we run out of string memory. */ template - bool get_string(const input_format_t format, - const NumberType len, + bool get_string(const NumberType len, string_t& result) { // get_bytes() appends to result, and CBOR indefinite-length strings // collect all their chunks in the same result; validating only the // newly read bytes keeps the check linear in the input size const std::size_t old_size = result.size(); - if (JSON_HEDLEY_UNLIKELY(!get_bytes(format, len, "string", result))) + if (JSON_HEDLEY_UNLIKELY(!get_bytes(len, "string", result))) { return false; } @@ -16975,7 +16968,7 @@ class binary_reader { return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, - exception_message(format, "invalid string: ill-formed UTF-8 byte", "string"), nullptr)); + exception_message("invalid string: ill-formed UTF-8 byte", "string"), nullptr)); } return true; @@ -16985,7 +16978,6 @@ class binary_reader @brief create a byte array by reading bytes from the input @tparam NumberType the type of the number - @param[in] format the current format (for diagnostics) @param[in] len number of bytes to read @param[out] result byte array created by reading @a len bytes @@ -16996,11 +16988,10 @@ class binary_reader the input before we run out of memory. */ template - bool get_binary(const input_format_t format, - const NumberType len, + bool get_binary(const NumberType len, binary_t& result) { - return get_bytes(format, len, "binary", result); + return get_bytes(len, "binary", result); } /*! @@ -17008,7 +16999,6 @@ class binary_reader @tparam NumberType the type of the length @tparam ContainerType the destination container (string_t or binary_t) - @param[in] format the current format (for diagnostics) @param[in] len number of bytes to read @param[in] context further context information (for diagnostics) @param[out] result container the bytes are appended to @@ -17023,8 +17013,7 @@ class binary_reader detects a premature end of input. */ template - bool get_bytes(const input_format_t format, - NumberType len, + bool get_bytes(NumberType len, const char* context, ContainerType& result) { @@ -17053,7 +17042,7 @@ class binary_reader result.resize(old_size + bytes_read); ++chars_read; current = char_traits::eof(); - return unexpect_eof(format, context); + return unexpect_eof(context); } // a full chunk was read; get_elements() never returns more than requested JSON_ASSERT(bytes_read == wanted); @@ -17063,17 +17052,16 @@ class binary_reader } /*! - @param[in] format the current format (for diagnostics) @param[in] context further context information (for diagnostics) @return whether the last read character is not EOF */ - JSON_HEDLEY_NON_NULL(3) - bool unexpect_eof(const input_format_t format, const char* context) const + JSON_HEDLEY_NON_NULL(2) + bool unexpect_eof(const char* context) const { if (JSON_HEDLEY_UNLIKELY(current == char_traits::eof())) { return sax->parse_error(chars_read, "", - parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); + parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr)); } return true; } @@ -17089,18 +17077,16 @@ class binary_reader } /*! - @param[in] format the current format @param[in] detail a detailed error message @param[in] context further context information @return a message string to use in the parse_error exceptions */ - std::string exception_message(const input_format_t format, - const std::string& detail, + std::string exception_message(const std::string& detail, const std::string& context) const { std::string error_msg = "syntax error while parsing "; - switch (format) + switch (input_format) { case input_format_t::cbor: error_msg += "CBOR";