Upgrade jsoncpp to 1.9.4
Bug: 170642246
Change-Id: Id1fae5a1b6421117f923c616718ee4b3571231e0
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 608d3f7..0f82a74 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,5 +1,5 @@
-ADD_SUBDIRECTORY(lib_json)
-IF(JSONCPP_WITH_TESTS)
- ADD_SUBDIRECTORY(jsontestrunner)
- ADD_SUBDIRECTORY(test_lib_json)
-ENDIF(JSONCPP_WITH_TESTS)
+add_subdirectory(lib_json)
+if(JSONCPP_WITH_TESTS)
+ add_subdirectory(jsontestrunner)
+ add_subdirectory(test_lib_json)
+endif()
diff --git a/src/jsontestrunner/CMakeLists.txt b/src/jsontestrunner/CMakeLists.txt
index dd8e217..1fc71ea 100644
--- a/src/jsontestrunner/CMakeLists.txt
+++ b/src/jsontestrunner/CMakeLists.txt
@@ -1,22 +1,51 @@
-FIND_PACKAGE(PythonInterp 2.6 REQUIRED)
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+ # The new Python3 module is much more robust than the previous PythonInterp
+ find_package(Python3 COMPONENTS Interpreter)
+ # Set variables for backwards compatibility with cmake < 3.12.0
+ set(PYTHONINTERP_FOUND ${Python3_Interpreter_FOUND})
+ set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
+else()
+ set(Python_ADDITIONAL_VERSIONS 3.8)
+ find_package(PythonInterp 3)
+endif()
-IF(JSONCPP_LIB_BUILD_SHARED)
- ADD_DEFINITIONS( -DJSON_DLL )
-ENDIF(JSONCPP_LIB_BUILD_SHARED)
+add_executable(jsontestrunner_exe
+ main.cpp
+)
-ADD_EXECUTABLE(jsontestrunner_exe
- main.cpp
- )
-TARGET_LINK_LIBRARIES(jsontestrunner_exe jsoncpp_lib)
-SET_TARGET_PROPERTIES(jsontestrunner_exe PROPERTIES OUTPUT_NAME jsontestrunner_exe)
+if(BUILD_SHARED_LIBS)
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+ add_compile_definitions( JSON_DLL )
+ else()
+ add_definitions(-DJSON_DLL)
+ endif()
+ target_link_libraries(jsontestrunner_exe jsoncpp_lib)
+else()
+ target_link_libraries(jsontestrunner_exe jsoncpp_static)
+endif()
-IF(PYTHONINTERP_FOUND)
+set_target_properties(jsontestrunner_exe PROPERTIES OUTPUT_NAME jsontestrunner_exe)
+
+if(PYTHONINTERP_FOUND)
# Run end to end parser/writer tests
- SET(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../test)
- SET(RUNJSONTESTS_PATH ${TEST_DIR}/runjsontests.py)
- ADD_CUSTOM_TARGET(jsoncpp_readerwriter_tests ALL
- "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
- DEPENDS jsontestrunner_exe jsoncpp_test
- )
- ADD_CUSTOM_TARGET(jsoncpp_check DEPENDS jsoncpp_readerwriter_tests)
-ENDIF(PYTHONINTERP_FOUND)
+ set(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../test)
+ set(RUNJSONTESTS_PATH ${TEST_DIR}/runjsontests.py)
+
+ # Run unit tests in post-build
+ # (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
+ add_custom_target(jsoncpp_readerwriter_tests
+ "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+ DEPENDS jsontestrunner_exe jsoncpp_test
+ )
+ add_custom_target(jsoncpp_check DEPENDS jsoncpp_readerwriter_tests)
+
+ ## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
+ add_test(NAME jsoncpp_readerwriter
+ COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+ WORKING_DIRECTORY "${TEST_DIR}/data"
+ )
+ add_test(NAME jsoncpp_readerwriter_json_checker
+ COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" --with-json-checker $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+ WORKING_DIRECTORY "${TEST_DIR}/data"
+ )
+endif()
diff --git a/src/jsontestrunner/main.cpp b/src/jsontestrunner/main.cpp
index ba98587..3452c59 100644
--- a/src/jsontestrunner/main.cpp
+++ b/src/jsontestrunner/main.cpp
@@ -1,39 +1,49 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(disable : 4996)
+#endif
+
/* This executable is used for testing parser/writer using real JSON files.
*/
-#include <json/json.h>
#include <algorithm> // sort
-#include <stdio.h>
+#include <cstdio>
+#include <iostream>
+#include <json/json.h>
+#include <memory>
+#include <sstream>
-#if defined(_MSC_VER) && _MSC_VER >= 1310
-#pragma warning(disable : 4996) // disable fopen deprecation warning
-#endif
+struct Options {
+ Json::String path;
+ Json::Features features;
+ bool parseOnly;
+ using writeFuncType = Json::String (*)(Json::Value const&);
+ writeFuncType write;
+};
-static std::string normalizeFloatingPointStr(double value) {
+static Json::String normalizeFloatingPointStr(double value) {
char buffer[32];
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
- sprintf_s(buffer, sizeof(buffer), "%.16g", value);
-#else
- snprintf(buffer, sizeof(buffer), "%.16g", value);
-#endif
+ jsoncpp_snprintf(buffer, sizeof(buffer), "%.16g", value);
buffer[sizeof(buffer) - 1] = 0;
- std::string s(buffer);
- std::string::size_type index = s.find_last_of("eE");
- if (index != std::string::npos) {
- std::string::size_type hasSign =
+ Json::String s(buffer);
+ Json::String::size_type index = s.find_last_of("eE");
+ if (index != Json::String::npos) {
+ Json::String::size_type hasSign =
(s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
- std::string::size_type exponentStartIndex = index + 1 + hasSign;
- std::string normalized = s.substr(0, exponentStartIndex);
- std::string::size_type indexDigit =
+ Json::String::size_type exponentStartIndex = index + 1 + hasSign;
+ Json::String normalized = s.substr(0, exponentStartIndex);
+ Json::String::size_type indexDigit =
s.find_first_not_of('0', exponentStartIndex);
- std::string exponent = "0";
- if (indexDigit !=
- std::string::npos) // There is an exponent different from 0
+ Json::String exponent = "0";
+ if (indexDigit != Json::String::npos) // There is an exponent different
+ // from 0
{
exponent = s.substr(indexDigit);
}
@@ -42,25 +52,26 @@
return s;
}
-static std::string readInputTestFile(const char* path) {
+static Json::String readInputTestFile(const char* path) {
FILE* file = fopen(path, "rb");
if (!file)
- return std::string("");
+ return "";
fseek(file, 0, SEEK_END);
- long size = ftell(file);
+ auto const size = ftell(file);
+ auto const usize = static_cast<size_t>(size);
fseek(file, 0, SEEK_SET);
- std::string text;
- char* buffer = new char[size + 1];
+ auto buffer = new char[size + 1];
buffer[size] = 0;
- if (fread(buffer, 1, size, file) == (unsigned long)size)
+ Json::String text;
+ if (fread(buffer, 1, usize, file) == usize)
text = buffer;
fclose(file);
delete[] buffer;
return text;
}
-static void
-printValueTree(FILE* fout, Json::Value& value, const std::string& path = ".") {
+static void printValueTree(FILE* fout, Json::Value& value,
+ const Json::String& path = ".") {
if (value.hasComment(Json::commentBefore)) {
fprintf(fout, "%s\n", value.getComment(Json::commentBefore).c_str());
}
@@ -69,21 +80,15 @@
fprintf(fout, "%s=null\n", path.c_str());
break;
case Json::intValue:
- fprintf(fout,
- "%s=%s\n",
- path.c_str(),
+ fprintf(fout, "%s=%s\n", path.c_str(),
Json::valueToString(value.asLargestInt()).c_str());
break;
case Json::uintValue:
- fprintf(fout,
- "%s=%s\n",
- path.c_str(),
+ fprintf(fout, "%s=%s\n", path.c_str(),
Json::valueToString(value.asLargestUInt()).c_str());
break;
case Json::realValue:
- fprintf(fout,
- "%s=%s\n",
- path.c_str(),
+ fprintf(fout, "%s=%s\n", path.c_str(),
normalizeFloatingPointStr(value.asDouble()).c_str());
break;
case Json::stringValue:
@@ -94,14 +99,10 @@
break;
case Json::arrayValue: {
fprintf(fout, "%s=[]\n", path.c_str());
- int size = value.size();
- for (int index = 0; index < size; ++index) {
+ Json::ArrayIndex size = value.size();
+ for (Json::ArrayIndex index = 0; index < size; ++index) {
static char buffer[16];
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
- sprintf_s(buffer, sizeof(buffer), "[%d]", index);
-#else
- snprintf(buffer, sizeof(buffer), "[%d]", index);
-#endif
+ jsoncpp_snprintf(buffer, sizeof(buffer), "[%u]", index);
printValueTree(fout, value[index], path + buffer);
}
} break;
@@ -109,11 +110,8 @@
fprintf(fout, "%s={}\n", path.c_str());
Json::Value::Members members(value.getMemberNames());
std::sort(members.begin(), members.end());
- std::string suffix = *(path.end() - 1) == '.' ? "" : ".";
- for (Json::Value::Members::iterator it = members.begin();
- it != members.end();
- ++it) {
- const std::string& name = *it;
+ Json::String suffix = *(path.end() - 1) == '.' ? "" : ".";
+ for (const auto& name : members) {
printValueTree(fout, value[name], path + suffix + name);
}
} break;
@@ -126,152 +124,219 @@
}
}
-static int parseAndSaveValueTree(const std::string& input,
- const std::string& actual,
- const std::string& kind,
- Json::Value& root,
- const Json::Features& features,
- bool parseOnly) {
- Json::Reader reader(features);
- bool parsingSuccessful = reader.parse(input, root);
- if (!parsingSuccessful) {
- printf("Failed to parse %s file: \n%s\n",
- kind.c_str(),
- reader.getFormattedErrorMessages().c_str());
- return 1;
+static int parseAndSaveValueTree(const Json::String& input,
+ const Json::String& actual,
+ const Json::String& kind,
+ const Json::Features& features, bool parseOnly,
+ Json::Value* root, bool use_legacy) {
+ if (!use_legacy) {
+ Json::CharReaderBuilder builder;
+
+ builder.settings_["allowComments"] = features.allowComments_;
+ builder.settings_["strictRoot"] = features.strictRoot_;
+ builder.settings_["allowDroppedNullPlaceholders"] =
+ features.allowDroppedNullPlaceholders_;
+ builder.settings_["allowNumericKeys"] = features.allowNumericKeys_;
+
+ std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+ Json::String errors;
+ const bool parsingSuccessful =
+ reader->parse(input.data(), input.data() + input.size(), root, &errors);
+
+ if (!parsingSuccessful) {
+ std::cerr << "Failed to parse " << kind << " file: " << std::endl
+ << errors << std::endl;
+ return 1;
+ }
+
+ // We may instead check the legacy implementation (to ensure it doesn't
+ // randomly get broken).
+ } else {
+ Json::Reader reader(features);
+ const bool parsingSuccessful =
+ reader.parse(input.data(), input.data() + input.size(), *root);
+ if (!parsingSuccessful) {
+ std::cerr << "Failed to parse " << kind << " file: " << std::endl
+ << reader.getFormatedErrorMessages() << std::endl;
+ return 1;
+ }
}
if (!parseOnly) {
FILE* factual = fopen(actual.c_str(), "wt");
if (!factual) {
- printf("Failed to create %s actual file.\n", kind.c_str());
+ std::cerr << "Failed to create '" << kind << "' actual file."
+ << std::endl;
return 2;
}
- printValueTree(factual, root);
+ printValueTree(factual, *root);
fclose(factual);
}
return 0;
}
-
-static int rewriteValueTree(const std::string& rewritePath,
- const Json::Value& root,
- std::string& rewrite) {
- // Json::FastWriter writer;
- // writer.enableYAMLCompatibility();
+// static Json::String useFastWriter(Json::Value const& root) {
+// Json::FastWriter writer;
+// writer.enableYAMLCompatibility();
+// return writer.write(root);
+// }
+static Json::String useStyledWriter(Json::Value const& root) {
Json::StyledWriter writer;
- rewrite = writer.write(root);
+ return writer.write(root);
+}
+static Json::String useStyledStreamWriter(Json::Value const& root) {
+ Json::StyledStreamWriter writer;
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ return sout.str();
+}
+static Json::String useBuiltStyledStreamWriter(Json::Value const& root) {
+ Json::StreamWriterBuilder builder;
+ return Json::writeString(builder, root);
+}
+static int rewriteValueTree(const Json::String& rewritePath,
+ const Json::Value& root,
+ Options::writeFuncType write,
+ Json::String* rewrite) {
+ *rewrite = write(root);
FILE* fout = fopen(rewritePath.c_str(), "wt");
if (!fout) {
- printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
+ std::cerr << "Failed to create rewrite file: " << rewritePath << std::endl;
return 2;
}
- fprintf(fout, "%s\n", rewrite.c_str());
+ fprintf(fout, "%s\n", rewrite->c_str());
fclose(fout);
return 0;
}
-static std::string removeSuffix(const std::string& path,
- const std::string& extension) {
+static Json::String removeSuffix(const Json::String& path,
+ const Json::String& extension) {
if (extension.length() >= path.length())
- return std::string("");
- std::string suffix = path.substr(path.length() - extension.length());
+ return Json::String("");
+ Json::String suffix = path.substr(path.length() - extension.length());
if (suffix != extension)
- return std::string("");
+ return Json::String("");
return path.substr(0, path.length() - extension.length());
}
static void printConfig() {
// Print the configuration used to compile JsonCpp
#if defined(JSON_NO_INT64)
- printf("JSON_NO_INT64=1\n");
+ std::cout << "JSON_NO_INT64=1" << std::endl;
#else
- printf("JSON_NO_INT64=0\n");
+ std::cout << "JSON_NO_INT64=0" << std::endl;
#endif
}
static int printUsage(const char* argv[]) {
- printf("Usage: %s [--strict] input-json-file", argv[0]);
+ std::cout << "Usage: " << argv[0] << " [--strict] input-json-file"
+ << std::endl;
return 3;
}
-int parseCommandLine(int argc,
- const char* argv[],
- Json::Features& features,
- std::string& path,
- bool& parseOnly) {
- parseOnly = false;
+static int parseCommandLine(int argc, const char* argv[], Options* opts) {
+ opts->parseOnly = false;
+ opts->write = &useStyledWriter;
if (argc < 2) {
return printUsage(argv);
}
-
int index = 1;
- if (std::string(argv[1]) == "--json-checker") {
- features = Json::Features::strictMode();
- parseOnly = true;
+ if (Json::String(argv[index]) == "--json-checker") {
+ opts->features = Json::Features::strictMode();
+ opts->parseOnly = true;
++index;
}
-
- if (std::string(argv[1]) == "--json-config") {
+ if (Json::String(argv[index]) == "--json-config") {
printConfig();
return 3;
}
-
+ if (Json::String(argv[index]) == "--json-writer") {
+ ++index;
+ Json::String const writerName(argv[index++]);
+ if (writerName == "StyledWriter") {
+ opts->write = &useStyledWriter;
+ } else if (writerName == "StyledStreamWriter") {
+ opts->write = &useStyledStreamWriter;
+ } else if (writerName == "BuiltStyledStreamWriter") {
+ opts->write = &useBuiltStyledStreamWriter;
+ } else {
+ std::cerr << "Unknown '--json-writer' " << writerName << std::endl;
+ return 4;
+ }
+ }
if (index == argc || index + 1 < argc) {
return printUsage(argv);
}
-
- path = argv[index];
+ opts->path = argv[index];
return 0;
}
-int main(int argc, const char* argv[]) {
- std::string path;
- Json::Features features;
- bool parseOnly;
- int exitCode = parseCommandLine(argc, argv, features, path, parseOnly);
- if (exitCode != 0) {
+static int runTest(Options const& opts, bool use_legacy) {
+ int exitCode = 0;
+
+ Json::String input = readInputTestFile(opts.path.c_str());
+ if (input.empty()) {
+ std::cerr << "Invalid input file: " << opts.path << std::endl;
+ return 3;
+ }
+
+ Json::String basePath = removeSuffix(opts.path, ".json");
+ if (!opts.parseOnly && basePath.empty()) {
+ std::cerr << "Bad input path '" << opts.path
+ << "'. Must end with '.expected'" << std::endl;
+ return 3;
+ }
+
+ Json::String const actualPath = basePath + ".actual";
+ Json::String const rewritePath = basePath + ".rewrite";
+ Json::String const rewriteActualPath = basePath + ".actual-rewrite";
+
+ Json::Value root;
+ exitCode = parseAndSaveValueTree(input, actualPath, "input", opts.features,
+ opts.parseOnly, &root, use_legacy);
+ if (exitCode || opts.parseOnly) {
return exitCode;
}
- try {
- std::string input = readInputTestFile(path.c_str());
- if (input.empty()) {
- printf("Failed to read input or empty input: %s\n", path.c_str());
- return 3;
- }
-
- std::string basePath = removeSuffix(argv[1], ".json");
- if (!parseOnly && basePath.empty()) {
- printf("Bad input path. Path does not end with '.expected':\n%s\n",
- path.c_str());
- return 3;
- }
-
- std::string actualPath = basePath + ".actual";
- std::string rewritePath = basePath + ".rewrite";
- std::string rewriteActualPath = basePath + ".actual-rewrite";
-
- Json::Value root;
- exitCode = parseAndSaveValueTree(
- input, actualPath, "input", root, features, parseOnly);
- if (exitCode == 0 && !parseOnly) {
- std::string rewrite;
- exitCode = rewriteValueTree(rewritePath, root, rewrite);
- if (exitCode == 0) {
- Json::Value rewriteRoot;
- exitCode = parseAndSaveValueTree(rewrite,
- rewriteActualPath,
- "rewrite",
- rewriteRoot,
- features,
- parseOnly);
- }
- }
+ Json::String rewrite;
+ exitCode = rewriteValueTree(rewritePath, root, opts.write, &rewrite);
+ if (exitCode) {
+ return exitCode;
}
- catch (const std::exception& e) {
- printf("Unhandled exception:\n%s\n", e.what());
- exitCode = 1;
- }
+
+ Json::Value rewriteRoot;
+ exitCode = parseAndSaveValueTree(rewrite, rewriteActualPath, "rewrite",
+ opts.features, opts.parseOnly, &rewriteRoot,
+ use_legacy);
return exitCode;
}
+
+int main(int argc, const char* argv[]) {
+ Options opts;
+ try {
+ int exitCode = parseCommandLine(argc, argv, &opts);
+ if (exitCode != 0) {
+ std::cerr << "Failed to parse command-line." << std::endl;
+ return exitCode;
+ }
+
+ const int modern_return_code = runTest(opts, false);
+ if (modern_return_code) {
+ return modern_return_code;
+ }
+
+ const std::string filename =
+ opts.path.substr(opts.path.find_last_of("\\/") + 1);
+ const bool should_run_legacy = (filename.rfind("legacy_", 0) == 0);
+ if (should_run_legacy) {
+ return runTest(opts, true);
+ }
+ } catch (const std::exception& e) {
+ std::cerr << "Unhandled exception:" << std::endl << e.what() << std::endl;
+ return 1;
+ }
+}
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/src/jsontestrunner/sconscript b/src/jsontestrunner/sconscript
deleted file mode 100644
index 6e68e31..0000000
--- a/src/jsontestrunner/sconscript
+++ /dev/null
@@ -1,9 +0,0 @@
-Import( 'env_testing buildJSONTests' )
-
-buildJSONTests( env_testing, Split( """
- main.cpp
- """ ),
- 'jsontestrunner' )
-
-# For 'check' to work, 'libs' must be built first.
-env_testing.Depends('jsontestrunner', '#libs')
diff --git a/src/lib_json/CMakeLists.txt b/src/lib_json/CMakeLists.txt
index 418044d..af26476 100644
--- a/src/lib_json/CMakeLists.txt
+++ b/src/lib_json/CMakeLists.txt
@@ -1,57 +1,220 @@
-OPTION(JSONCPP_LIB_BUILD_SHARED "Build jsoncpp_lib as a shared library." OFF)
-IF(JSONCPP_LIB_BUILD_SHARED)
- SET(JSONCPP_LIB_TYPE SHARED)
- ADD_DEFINITIONS( -DJSON_DLL_BUILD )
-ELSE(JSONCPP_LIB_BUILD_SHARED)
- SET(JSONCPP_LIB_TYPE STATIC)
-ENDIF(JSONCPP_LIB_BUILD_SHARED)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.1.2)
+ #-Werror=* was introduced -after- GCC 4.1.2
+ add_compile_options("-Werror=strict-aliasing")
+endif()
+include(CheckIncludeFileCXX)
+include(CheckTypeSize)
+include(CheckStructHasMember)
+include(CheckCXXSymbolExists)
-if( CMAKE_COMPILER_IS_GNUCXX )
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=strict-aliasing")
-endif( CMAKE_COMPILER_IS_GNUCXX )
+check_include_file_cxx(clocale HAVE_CLOCALE)
+check_cxx_symbol_exists(localeconv clocale HAVE_LOCALECONV)
-SET( JSONCPP_INCLUDE_DIR ../../include )
+if(CMAKE_VERSION VERSION_LESS 3.0.0)
+ # The "LANGUAGE CXX" parameter is not supported in CMake versions below 3,
+ # so the C compiler and header has to be used.
+ check_include_file(locale.h HAVE_LOCALE_H)
+ set(CMAKE_EXTRA_INCLUDE_FILES locale.h)
+ check_type_size("struct lconv" LCONV_SIZE)
+ unset(CMAKE_EXTRA_INCLUDE_FILES)
+ check_struct_has_member("struct lconv" decimal_point locale.h HAVE_DECIMAL_POINT)
+else()
+ set(CMAKE_EXTRA_INCLUDE_FILES clocale)
+ check_type_size(lconv LCONV_SIZE LANGUAGE CXX)
+ unset(CMAKE_EXTRA_INCLUDE_FILES)
+ check_struct_has_member(lconv decimal_point clocale HAVE_DECIMAL_POINT LANGUAGE CXX)
+endif()
-SET( PUBLIC_HEADERS
+if(NOT (HAVE_CLOCALE AND HAVE_LCONV_SIZE AND HAVE_DECIMAL_POINT AND HAVE_LOCALECONV))
+ message(WARNING "Locale functionality is not supported")
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+ add_compile_definitions(JSONCPP_NO_LOCALE_SUPPORT)
+ else()
+ add_definitions(-DJSONCPP_NO_LOCALE_SUPPORT)
+ endif()
+endif()
+
+set(JSONCPP_INCLUDE_DIR ../../include)
+
+set(PUBLIC_HEADERS
${JSONCPP_INCLUDE_DIR}/json/config.h
${JSONCPP_INCLUDE_DIR}/json/forwards.h
- ${JSONCPP_INCLUDE_DIR}/json/features.h
+ ${JSONCPP_INCLUDE_DIR}/json/json_features.h
${JSONCPP_INCLUDE_DIR}/json/value.h
${JSONCPP_INCLUDE_DIR}/json/reader.h
+ ${JSONCPP_INCLUDE_DIR}/json/version.h
${JSONCPP_INCLUDE_DIR}/json/writer.h
${JSONCPP_INCLUDE_DIR}/json/assertions.h
- ${JSONCPP_INCLUDE_DIR}/json/version.h
- )
+)
-SOURCE_GROUP( "Public API" FILES ${PUBLIC_HEADERS} )
+source_group("Public API" FILES ${PUBLIC_HEADERS})
-ADD_LIBRARY( jsoncpp_lib ${JSONCPP_LIB_TYPE}
- ${PUBLIC_HEADERS}
- json_tool.h
- json_reader.cpp
- json_batchallocator.h
- json_valueiterator.inl
- json_value.cpp
- json_writer.cpp
- version.h.in
- )
-SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES OUTPUT_NAME jsoncpp )
-SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES VERSION ${JSONCPP_VERSION} SOVERSION ${JSONCPP_VERSION_MAJOR} )
+set(JSONCPP_SOURCES
+ json_tool.h
+ json_reader.cpp
+ json_valueiterator.inl
+ json_value.cpp
+ json_writer.cpp
+)
# Install instructions for this target
-IF(JSONCPP_WITH_CMAKE_PACKAGE)
- TARGET_INCLUDE_DIRECTORIES( jsoncpp_lib
- PUBLIC $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
- $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSON_INCLUDE_DIR}>
- )
- SET(INSTALL_EXPORT EXPORT jsoncpp)
-ELSE(JSONCPP_WITH_CMAKE_PACKAGE)
- SET(INSTALL_EXPORT)
-ENDIF(JSONCPP_WITH_CMAKE_PACKAGE)
+if(JSONCPP_WITH_CMAKE_PACKAGE)
+ set(INSTALL_EXPORT EXPORT jsoncpp)
+else()
+ set(INSTALL_EXPORT)
+endif()
-INSTALL( TARGETS jsoncpp_lib ${INSTALL_EXPORT}
- RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
- LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
- ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR}
+# Specify compiler features required when compiling a given target.
+# See https://cmake.org/cmake/help/v3.1/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html#prop_gbl:CMAKE_CXX_KNOWN_FEATURES
+# for complete list of features available
+list(APPEND REQUIRED_FEATURES
+ cxx_std_11 # Compiler mode is aware of C++ 11.
+ #MSVC 1900 cxx_alignas # Alignment control alignas, as defined in N2341.
+ #MSVC 1900 cxx_alignof # Alignment control alignof, as defined in N2341.
+ #MSVC 1900 cxx_attributes # Generic attributes, as defined in N2761.
+ cxx_auto_type # Automatic type deduction, as defined in N1984.
+ #MSVC 1900 cxx_constexpr # Constant expressions, as defined in N2235.
+ cxx_decltype # Decltype, as defined in N2343.
+ cxx_default_function_template_args # Default template arguments for function templates, as defined in DR226
+ cxx_defaulted_functions # Defaulted functions, as defined in N2346.
+ #MSVC 1900 cxx_defaulted_move_initializers # Defaulted move initializers, as defined in N3053.
+ cxx_delegating_constructors # Delegating constructors, as defined in N1986.
+ #MSVC 1900 cxx_deleted_functions # Deleted functions, as defined in N2346.
+ cxx_enum_forward_declarations # Enum forward declarations, as defined in N2764.
+ cxx_explicit_conversions # Explicit conversion operators, as defined in N2437.
+ cxx_extended_friend_declarations # Extended friend declarations, as defined in N1791.
+ cxx_extern_templates # Extern templates, as defined in N1987.
+ cxx_final # Override control final keyword, as defined in N2928, N3206 and N3272.
+ #MSVC 1900 cxx_func_identifier # Predefined __func__ identifier, as defined in N2340.
+ #MSVC 1900 cxx_generalized_initializers # Initializer lists, as defined in N2672.
+ #MSVC 1900 cxx_inheriting_constructors # Inheriting constructors, as defined in N2540.
+ #MSVC 1900 cxx_inline_namespaces # Inline namespaces, as defined in N2535.
+ cxx_lambdas # Lambda functions, as defined in N2927.
+ #MSVC 1900 cxx_local_type_template_args # Local and unnamed types as template arguments, as defined in N2657.
+ cxx_long_long_type # long long type, as defined in N1811.
+ #MSVC 1900 cxx_noexcept # Exception specifications, as defined in N3050.
+ #MSVC 1900 cxx_nonstatic_member_init # Non-static data member initialization, as defined in N2756.
+ cxx_nullptr # Null pointer, as defined in N2431.
+ cxx_override # Override control override keyword, as defined in N2928, N3206 and N3272.
+ cxx_range_for # Range-based for, as defined in N2930.
+ cxx_raw_string_literals # Raw string literals, as defined in N2442.
+ #MSVC 1900 cxx_reference_qualified_functions # Reference qualified functions, as defined in N2439.
+ cxx_right_angle_brackets # Right angle bracket parsing, as defined in N1757.
+ cxx_rvalue_references # R-value references, as defined in N2118.
+ #MSVC 1900 cxx_sizeof_member # Size of non-static data members, as defined in N2253.
+ cxx_static_assert # Static assert, as defined in N1720.
+ cxx_strong_enums # Strongly typed enums, as defined in N2347.
+ #MSVC 1900 cxx_thread_local # Thread-local variables, as defined in N2659.
+ cxx_trailing_return_types # Automatic function return type, as defined in N2541.
+ #MSVC 1900 cxx_unicode_literals # Unicode string literals, as defined in N2442.
+ cxx_uniform_initialization # Uniform initialization, as defined in N2640.
+ #MSVC 1900 cxx_unrestricted_unions # Unrestricted unions, as defined in N2544.
+ #MSVC 1900 cxx_user_literals # User-defined literals, as defined in N2765.
+ cxx_variadic_macros # Variadic macros, as defined in N1653.
+ cxx_variadic_templates # Variadic templates, as defined in N2242.
)
+
+
+if(BUILD_SHARED_LIBS)
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+ add_compile_definitions(JSON_DLL_BUILD)
+ else()
+ add_definitions(-DJSON_DLL_BUILD)
+ endif()
+
+ set(SHARED_LIB ${PROJECT_NAME}_lib)
+ add_library(${SHARED_LIB} SHARED ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+ set_target_properties(${SHARED_LIB} PROPERTIES
+ OUTPUT_NAME jsoncpp
+ VERSION ${PROJECT_VERSION}
+ SOVERSION ${PROJECT_SOVERSION}
+ POSITION_INDEPENDENT_CODE ON
+ )
+
+ # Set library's runtime search path on OSX
+ if(APPLE)
+ set_target_properties(${SHARED_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+ endif()
+
+ target_compile_features(${SHARED_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+ if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+ target_include_directories(${SHARED_LIB} PUBLIC
+ $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+ $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+ )
+ endif()
+
+ list(APPEND CMAKE_TARGETS ${SHARED_LIB})
+endif()
+
+if(BUILD_STATIC_LIBS)
+ set(STATIC_LIB ${PROJECT_NAME}_static)
+ add_library(${STATIC_LIB} STATIC ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+
+ # avoid name clashes on windows as the shared import lib is alse named jsoncpp.lib
+ if(NOT DEFINED STATIC_SUFFIX AND BUILD_SHARED_LIBS)
+ set(STATIC_SUFFIX "_static")
+ endif()
+
+ set_target_properties(${STATIC_LIB} PROPERTIES
+ OUTPUT_NAME jsoncpp${STATIC_SUFFIX}
+ VERSION ${PROJECT_VERSION}
+ )
+
+ # Set library's runtime search path on OSX
+ if(APPLE)
+ set_target_properties(${STATIC_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+ endif()
+
+ target_compile_features(${STATIC_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+ if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+ target_include_directories(${STATIC_LIB} PUBLIC
+ $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+ $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+ )
+ endif()
+
+ list(APPEND CMAKE_TARGETS ${STATIC_LIB})
+endif()
+
+if(BUILD_OBJECT_LIBS)
+ set(OBJECT_LIB ${PROJECT_NAME}_object)
+ add_library(${OBJECT_LIB} OBJECT ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+
+ set_target_properties(${OBJECT_LIB} PROPERTIES
+ OUTPUT_NAME jsoncpp
+ VERSION ${PROJECT_VERSION}
+ SOVERSION ${PROJECT_SOVERSION}
+ POSITION_INDEPENDENT_CODE ON
+ )
+
+ # Set library's runtime search path on OSX
+ if(APPLE)
+ set_target_properties(${OBJECT_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+ endif()
+
+ target_compile_features(${OBJECT_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+ if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+ target_include_directories(${OBJECT_LIB} PUBLIC
+ $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+ $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+ )
+ endif()
+
+ list(APPEND CMAKE_TARGETS ${OBJECT_LIB})
+endif()
+
+install(TARGETS ${CMAKE_TARGETS} ${INSTALL_EXPORT}
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ OBJECTS DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
diff --git a/src/lib_json/json_batchallocator.h b/src/lib_json/json_batchallocator.h
deleted file mode 100644
index 2fbef7a..0000000
--- a/src/lib_json/json_batchallocator.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
-#define JSONCPP_BATCHALLOCATOR_H_INCLUDED
-
-#include <stdlib.h>
-#include <assert.h>
-
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-namespace Json {
-
-/* Fast memory allocator.
- *
- * This memory allocator allocates memory for a batch of object (specified by
- * the page size, the number of object in each page).
- *
- * It does not allow the destruction of a single object. All the allocated
- * objects can be destroyed at once. The memory can be either released or reused
- * for future allocation.
- *
- * The in-place new operator must be used to construct the object using the
- * pointer returned by allocate.
- */
-template <typename AllocatedType, const unsigned int objectPerAllocation>
-class BatchAllocator {
-public:
- BatchAllocator(unsigned int objectsPerPage = 255)
- : freeHead_(0), objectsPerPage_(objectsPerPage) {
- // printf( "Size: %d => %s\n", sizeof(AllocatedType),
- // typeid(AllocatedType).name() );
- assert(sizeof(AllocatedType) * objectPerAllocation >=
- sizeof(AllocatedType*)); // We must be able to store a slist in the
- // object free space.
- assert(objectsPerPage >= 16);
- batches_ = allocateBatch(0); // allocated a dummy page
- currentBatch_ = batches_;
- }
-
- ~BatchAllocator() {
- for (BatchInfo* batch = batches_; batch;) {
- BatchInfo* nextBatch = batch->next_;
- free(batch);
- batch = nextBatch;
- }
- }
-
- /// allocate space for an array of objectPerAllocation object.
- /// @warning it is the responsability of the caller to call objects
- /// constructors.
- AllocatedType* allocate() {
- if (freeHead_) // returns node from free list.
- {
- AllocatedType* object = freeHead_;
- freeHead_ = *(AllocatedType**)object;
- return object;
- }
- if (currentBatch_->used_ == currentBatch_->end_) {
- currentBatch_ = currentBatch_->next_;
- while (currentBatch_ && currentBatch_->used_ == currentBatch_->end_)
- currentBatch_ = currentBatch_->next_;
-
- if (!currentBatch_) // no free batch found, allocate a new one
- {
- currentBatch_ = allocateBatch(objectsPerPage_);
- currentBatch_->next_ = batches_; // insert at the head of the list
- batches_ = currentBatch_;
- }
- }
- AllocatedType* allocated = currentBatch_->used_;
- currentBatch_->used_ += objectPerAllocation;
- return allocated;
- }
-
- /// Release the object.
- /// @warning it is the responsability of the caller to actually destruct the
- /// object.
- void release(AllocatedType* object) {
- assert(object != 0);
- *(AllocatedType**)object = freeHead_;
- freeHead_ = object;
- }
-
-private:
- struct BatchInfo {
- BatchInfo* next_;
- AllocatedType* used_;
- AllocatedType* end_;
- AllocatedType buffer_[objectPerAllocation];
- };
-
- // disabled copy constructor and assignement operator.
- BatchAllocator(const BatchAllocator&);
- void operator=(const BatchAllocator&);
-
- static BatchInfo* allocateBatch(unsigned int objectsPerPage) {
- const unsigned int mallocSize =
- sizeof(BatchInfo) - sizeof(AllocatedType) * objectPerAllocation +
- sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
- BatchInfo* batch = static_cast<BatchInfo*>(malloc(mallocSize));
- batch->next_ = 0;
- batch->used_ = batch->buffer_;
- batch->end_ = batch->buffer_ + objectsPerPage;
- return batch;
- }
-
- BatchInfo* batches_;
- BatchInfo* currentBatch_;
- /// Head of a single linked list within the allocated space of freeed object
- AllocatedType* freeHead_;
- unsigned int objectsPerPage_;
-};
-
-} // namespace Json
-
-#endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
-
-#endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
diff --git a/src/lib_json/json_internalarray.inl b/src/lib_json/json_internalarray.inl
deleted file mode 100644
index 9ee15e9..0000000
--- a/src/lib_json/json_internalarray.inl
+++ /dev/null
@@ -1,360 +0,0 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-// included by json_value.cpp
-
-namespace Json {
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalArray
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueArrayAllocator::~ValueArrayAllocator() {}
-
-// //////////////////////////////////////////////////////////////////
-// class DefaultValueArrayAllocator
-// //////////////////////////////////////////////////////////////////
-#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueArrayAllocator : public ValueArrayAllocator {
-public: // overridden from ValueArrayAllocator
- virtual ~DefaultValueArrayAllocator() {}
-
- virtual ValueInternalArray* newArray() { return new ValueInternalArray(); }
-
- virtual ValueInternalArray* newArrayCopy(const ValueInternalArray& other) {
- return new ValueInternalArray(other);
- }
-
- virtual void destructArray(ValueInternalArray* array) { delete array; }
-
- virtual void
- reallocateArrayPageIndex(Value**& indexes,
- ValueInternalArray::PageIndex& indexCount,
- ValueInternalArray::PageIndex minNewIndexCount) {
- ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1;
- if (minNewIndexCount > newIndexCount)
- newIndexCount = minNewIndexCount;
- void* newIndexes = realloc(indexes, sizeof(Value*) * newIndexCount);
- JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
- indexCount = newIndexCount;
- indexes = static_cast<Value**>(newIndexes);
- }
- virtual void releaseArrayPageIndex(Value** indexes,
- ValueInternalArray::PageIndex indexCount) {
- if (indexes)
- free(indexes);
- }
-
- virtual Value* allocateArrayPage() {
- return static_cast<Value*>(
- malloc(sizeof(Value) * ValueInternalArray::itemsPerPage));
- }
-
- virtual void releaseArrayPage(Value* value) {
- if (value)
- free(value);
- }
-};
-
-#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-/// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueArrayAllocator : public ValueArrayAllocator {
-public: // overridden from ValueArrayAllocator
- virtual ~DefaultValueArrayAllocator() {}
-
- virtual ValueInternalArray* newArray() {
- ValueInternalArray* array = arraysAllocator_.allocate();
- new (array) ValueInternalArray(); // placement new
- return array;
- }
-
- virtual ValueInternalArray* newArrayCopy(const ValueInternalArray& other) {
- ValueInternalArray* array = arraysAllocator_.allocate();
- new (array) ValueInternalArray(other); // placement new
- return array;
- }
-
- virtual void destructArray(ValueInternalArray* array) {
- if (array) {
- array->~ValueInternalArray();
- arraysAllocator_.release(array);
- }
- }
-
- virtual void
- reallocateArrayPageIndex(Value**& indexes,
- ValueInternalArray::PageIndex& indexCount,
- ValueInternalArray::PageIndex minNewIndexCount) {
- ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1;
- if (minNewIndexCount > newIndexCount)
- newIndexCount = minNewIndexCount;
- void* newIndexes = realloc(indexes, sizeof(Value*) * newIndexCount);
- JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
- indexCount = newIndexCount;
- indexes = static_cast<Value**>(newIndexes);
- }
- virtual void releaseArrayPageIndex(Value** indexes,
- ValueInternalArray::PageIndex indexCount) {
- if (indexes)
- free(indexes);
- }
-
- virtual Value* allocateArrayPage() {
- return static_cast<Value*>(pagesAllocator_.allocate());
- }
-
- virtual void releaseArrayPage(Value* value) {
- if (value)
- pagesAllocator_.release(value);
- }
-
-private:
- BatchAllocator<ValueInternalArray, 1> arraysAllocator_;
- BatchAllocator<Value, ValueInternalArray::itemsPerPage> pagesAllocator_;
-};
-#endif // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-
-static ValueArrayAllocator*& arrayAllocator() {
- static DefaultValueArrayAllocator defaultAllocator;
- static ValueArrayAllocator* arrayAllocator = &defaultAllocator;
- return arrayAllocator;
-}
-
-static struct DummyArrayAllocatorInitializer {
- DummyArrayAllocatorInitializer() {
- arrayAllocator(); // ensure arrayAllocator() statics are initialized before
- // main().
- }
-} dummyArrayAllocatorInitializer;
-
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalArray
-// //////////////////////////////////////////////////////////////////
-bool ValueInternalArray::equals(const IteratorState& x,
- const IteratorState& other) {
- return x.array_ == other.array_ &&
- x.currentItemIndex_ == other.currentItemIndex_ &&
- x.currentPageIndex_ == other.currentPageIndex_;
-}
-
-void ValueInternalArray::increment(IteratorState& it) {
- JSON_ASSERT_MESSAGE(
- it.array_ && (it.currentPageIndex_ - it.array_->pages_) * itemsPerPage +
- it.currentItemIndex_ !=
- it.array_->size_,
- "ValueInternalArray::increment(): moving iterator beyond end");
- ++(it.currentItemIndex_);
- if (it.currentItemIndex_ == itemsPerPage) {
- it.currentItemIndex_ = 0;
- ++(it.currentPageIndex_);
- }
-}
-
-void ValueInternalArray::decrement(IteratorState& it) {
- JSON_ASSERT_MESSAGE(
- it.array_ && it.currentPageIndex_ == it.array_->pages_ &&
- it.currentItemIndex_ == 0,
- "ValueInternalArray::decrement(): moving iterator beyond end");
- if (it.currentItemIndex_ == 0) {
- it.currentItemIndex_ = itemsPerPage - 1;
- --(it.currentPageIndex_);
- } else {
- --(it.currentItemIndex_);
- }
-}
-
-Value& ValueInternalArray::unsafeDereference(const IteratorState& it) {
- return (*(it.currentPageIndex_))[it.currentItemIndex_];
-}
-
-Value& ValueInternalArray::dereference(const IteratorState& it) {
- JSON_ASSERT_MESSAGE(
- it.array_ && (it.currentPageIndex_ - it.array_->pages_) * itemsPerPage +
- it.currentItemIndex_ <
- it.array_->size_,
- "ValueInternalArray::dereference(): dereferencing invalid iterator");
- return unsafeDereference(it);
-}
-
-void ValueInternalArray::makeBeginIterator(IteratorState& it) const {
- it.array_ = const_cast<ValueInternalArray*>(this);
- it.currentItemIndex_ = 0;
- it.currentPageIndex_ = pages_;
-}
-
-void ValueInternalArray::makeIterator(IteratorState& it,
- ArrayIndex index) const {
- it.array_ = const_cast<ValueInternalArray*>(this);
- it.currentItemIndex_ = index % itemsPerPage;
- it.currentPageIndex_ = pages_ + index / itemsPerPage;
-}
-
-void ValueInternalArray::makeEndIterator(IteratorState& it) const {
- makeIterator(it, size_);
-}
-
-ValueInternalArray::ValueInternalArray() : pages_(0), size_(0), pageCount_(0) {}
-
-ValueInternalArray::ValueInternalArray(const ValueInternalArray& other)
- : pages_(0), size_(other.size_), pageCount_(0) {
- PageIndex minNewPages = other.size_ / itemsPerPage;
- arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages);
- JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages,
- "ValueInternalArray::reserve(): bad reallocation");
- IteratorState itOther;
- other.makeBeginIterator(itOther);
- Value* value;
- for (ArrayIndex index = 0; index < size_; ++index, increment(itOther)) {
- if (index % itemsPerPage == 0) {
- PageIndex pageIndex = index / itemsPerPage;
- value = arrayAllocator()->allocateArrayPage();
- pages_[pageIndex] = value;
- }
- new (value) Value(dereference(itOther));
- }
-}
-
-ValueInternalArray& ValueInternalArray::operator=(ValueInternalArray other) {
- swap(other);
- return *this;
-}
-
-ValueInternalArray::~ValueInternalArray() {
- // destroy all constructed items
- IteratorState it;
- IteratorState itEnd;
- makeBeginIterator(it);
- makeEndIterator(itEnd);
- for (; !equals(it, itEnd); increment(it)) {
- Value* value = &dereference(it);
- value->~Value();
- }
- // release all pages
- PageIndex lastPageIndex = size_ / itemsPerPage;
- for (PageIndex pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex)
- arrayAllocator()->releaseArrayPage(pages_[pageIndex]);
- // release pages index
- arrayAllocator()->releaseArrayPageIndex(pages_, pageCount_);
-}
-
-void ValueInternalArray::swap(ValueInternalArray& other) {
- Value** tempPages = pages_;
- pages_ = other.pages_;
- other.pages_ = tempPages;
- ArrayIndex tempSize = size_;
- size_ = other.size_;
- other.size_ = tempSize;
- PageIndex tempPageCount = pageCount_;
- pageCount_ = other.pageCount_;
- other.pageCount_ = tempPageCount;
-}
-
-void ValueInternalArray::clear() {
- ValueInternalArray dummy;
- swap(dummy);
-}
-
-void ValueInternalArray::resize(ArrayIndex newSize) {
- if (newSize == 0)
- clear();
- else if (newSize < size_) {
- IteratorState it;
- IteratorState itEnd;
- makeIterator(it, newSize);
- makeIterator(itEnd, size_);
- for (; !equals(it, itEnd); increment(it)) {
- Value* value = &dereference(it);
- value->~Value();
- }
- PageIndex pageIndex = (newSize + itemsPerPage - 1) / itemsPerPage;
- PageIndex lastPageIndex = size_ / itemsPerPage;
- for (; pageIndex < lastPageIndex; ++pageIndex)
- arrayAllocator()->releaseArrayPage(pages_[pageIndex]);
- size_ = newSize;
- } else if (newSize > size_)
- resolveReference(newSize);
-}
-
-void ValueInternalArray::makeIndexValid(ArrayIndex index) {
- // Need to enlarge page index ?
- if (index >= pageCount_ * itemsPerPage) {
- PageIndex minNewPages = (index + 1) / itemsPerPage;
- arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages);
- JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages,
- "ValueInternalArray::reserve(): bad reallocation");
- }
-
- // Need to allocate new pages ?
- ArrayIndex nextPageIndex = (size_ % itemsPerPage) != 0
- ? size_ - (size_ % itemsPerPage) + itemsPerPage
- : size_;
- if (nextPageIndex <= index) {
- PageIndex pageIndex = nextPageIndex / itemsPerPage;
- PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1;
- for (; pageToAllocate-- > 0; ++pageIndex)
- pages_[pageIndex] = arrayAllocator()->allocateArrayPage();
- }
-
- // Initialize all new entries
- IteratorState it;
- IteratorState itEnd;
- makeIterator(it, size_);
- size_ = index + 1;
- makeIterator(itEnd, size_);
- for (; !equals(it, itEnd); increment(it)) {
- Value* value = &dereference(it);
- new (value) Value(); // Construct a default value using placement new
- }
-}
-
-Value& ValueInternalArray::resolveReference(ArrayIndex index) {
- if (index >= size_)
- makeIndexValid(index);
- return pages_[index / itemsPerPage][index % itemsPerPage];
-}
-
-Value* ValueInternalArray::find(ArrayIndex index) const {
- if (index >= size_)
- return 0;
- return &(pages_[index / itemsPerPage][index % itemsPerPage]);
-}
-
-ValueInternalArray::ArrayIndex ValueInternalArray::size() const {
- return size_;
-}
-
-int ValueInternalArray::distance(const IteratorState& x,
- const IteratorState& y) {
- return indexOf(y) - indexOf(x);
-}
-
-ValueInternalArray::ArrayIndex
-ValueInternalArray::indexOf(const IteratorState& iterator) {
- if (!iterator.array_)
- return ArrayIndex(-1);
- return ArrayIndex((iterator.currentPageIndex_ - iterator.array_->pages_) *
- itemsPerPage +
- iterator.currentItemIndex_);
-}
-
-int ValueInternalArray::compare(const ValueInternalArray& other) const {
- int sizeDiff(size_ - other.size_);
- if (sizeDiff != 0)
- return sizeDiff;
-
- for (ArrayIndex index = 0; index < size_; ++index) {
- int diff = pages_[index / itemsPerPage][index % itemsPerPage].compare(
- other.pages_[index / itemsPerPage][index % itemsPerPage]);
- if (diff != 0)
- return diff;
- }
- return 0;
-}
-
-} // namespace Json
diff --git a/src/lib_json/json_internalmap.inl b/src/lib_json/json_internalmap.inl
deleted file mode 100644
index ef3f330..0000000
--- a/src/lib_json/json_internalmap.inl
+++ /dev/null
@@ -1,473 +0,0 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-// included by json_value.cpp
-
-namespace Json {
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalMap
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-/** \internal MUST be safely initialized using memset( this, 0,
- * sizeof(ValueInternalLink) );
- * This optimization is used by the fast allocator.
- */
-ValueInternalLink::ValueInternalLink() : previous_(0), next_(0) {}
-
-ValueInternalLink::~ValueInternalLink() {
- for (int index = 0; index < itemPerLink; ++index) {
- if (!items_[index].isItemAvailable()) {
- if (!items_[index].isMemberNameStatic())
- free(keys_[index]);
- } else
- break;
- }
-}
-
-ValueMapAllocator::~ValueMapAllocator() {}
-
-#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueMapAllocator : public ValueMapAllocator {
-public: // overridden from ValueMapAllocator
- virtual ValueInternalMap* newMap() { return new ValueInternalMap(); }
-
- virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) {
- return new ValueInternalMap(other);
- }
-
- virtual void destructMap(ValueInternalMap* map) { delete map; }
-
- virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
- return new ValueInternalLink[size];
- }
-
- virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
-
- virtual ValueInternalLink* allocateMapLink() {
- return new ValueInternalLink();
- }
-
- virtual void releaseMapLink(ValueInternalLink* link) { delete link; }
-};
-#else
-/// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueMapAllocator : public ValueMapAllocator {
-public: // overridden from ValueMapAllocator
- virtual ValueInternalMap* newMap() {
- ValueInternalMap* map = mapsAllocator_.allocate();
- new (map) ValueInternalMap(); // placement new
- return map;
- }
-
- virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) {
- ValueInternalMap* map = mapsAllocator_.allocate();
- new (map) ValueInternalMap(other); // placement new
- return map;
- }
-
- virtual void destructMap(ValueInternalMap* map) {
- if (map) {
- map->~ValueInternalMap();
- mapsAllocator_.release(map);
- }
- }
-
- virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
- return new ValueInternalLink[size];
- }
-
- virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
-
- virtual ValueInternalLink* allocateMapLink() {
- ValueInternalLink* link = linksAllocator_.allocate();
- memset(link, 0, sizeof(ValueInternalLink));
- return link;
- }
-
- virtual void releaseMapLink(ValueInternalLink* link) {
- link->~ValueInternalLink();
- linksAllocator_.release(link);
- }
-
-private:
- BatchAllocator<ValueInternalMap, 1> mapsAllocator_;
- BatchAllocator<ValueInternalLink, 1> linksAllocator_;
-};
-#endif
-
-static ValueMapAllocator*& mapAllocator() {
- static DefaultValueMapAllocator defaultAllocator;
- static ValueMapAllocator* mapAllocator = &defaultAllocator;
- return mapAllocator;
-}
-
-static struct DummyMapAllocatorInitializer {
- DummyMapAllocatorInitializer() {
- mapAllocator(); // ensure mapAllocator() statics are initialized before
- // main().
- }
-} dummyMapAllocatorInitializer;
-
-// h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32.
-
-/*
-use linked list hash map.
-buckets array is a container.
-linked list element contains 6 key/values. (memory = (16+4) * 6 + 4 = 124)
-value have extra state: valid, available, deleted
-*/
-
-ValueInternalMap::ValueInternalMap()
- : buckets_(0), tailLink_(0), bucketsSize_(0), itemCount_(0) {}
-
-ValueInternalMap::ValueInternalMap(const ValueInternalMap& other)
- : buckets_(0), tailLink_(0), bucketsSize_(0), itemCount_(0) {
- reserve(other.itemCount_);
- IteratorState it;
- IteratorState itEnd;
- other.makeBeginIterator(it);
- other.makeEndIterator(itEnd);
- for (; !equals(it, itEnd); increment(it)) {
- bool isStatic;
- const char* memberName = key(it, isStatic);
- const Value& aValue = value(it);
- resolveReference(memberName, isStatic) = aValue;
- }
-}
-
-ValueInternalMap& ValueInternalMap::operator=(ValueInternalMap other) {
- swap(other);
- return *this;
-}
-
-ValueInternalMap::~ValueInternalMap() {
- if (buckets_) {
- for (BucketIndex bucketIndex = 0; bucketIndex < bucketsSize_;
- ++bucketIndex) {
- ValueInternalLink* link = buckets_[bucketIndex].next_;
- while (link) {
- ValueInternalLink* linkToRelease = link;
- link = link->next_;
- mapAllocator()->releaseMapLink(linkToRelease);
- }
- }
- mapAllocator()->releaseMapBuckets(buckets_);
- }
-}
-
-void ValueInternalMap::swap(ValueInternalMap& other) {
- ValueInternalLink* tempBuckets = buckets_;
- buckets_ = other.buckets_;
- other.buckets_ = tempBuckets;
- ValueInternalLink* tempTailLink = tailLink_;
- tailLink_ = other.tailLink_;
- other.tailLink_ = tempTailLink;
- BucketIndex tempBucketsSize = bucketsSize_;
- bucketsSize_ = other.bucketsSize_;
- other.bucketsSize_ = tempBucketsSize;
- BucketIndex tempItemCount = itemCount_;
- itemCount_ = other.itemCount_;
- other.itemCount_ = tempItemCount;
-}
-
-void ValueInternalMap::clear() {
- ValueInternalMap dummy;
- swap(dummy);
-}
-
-ValueInternalMap::BucketIndex ValueInternalMap::size() const {
- return itemCount_;
-}
-
-bool ValueInternalMap::reserveDelta(BucketIndex growth) {
- return reserve(itemCount_ + growth);
-}
-
-bool ValueInternalMap::reserve(BucketIndex newItemCount) {
- if (!buckets_ && newItemCount > 0) {
- buckets_ = mapAllocator()->allocateMapBuckets(1);
- bucketsSize_ = 1;
- tailLink_ = &buckets_[0];
- }
- // BucketIndex idealBucketCount = (newItemCount +
- // ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink;
- return true;
-}
-
-const Value* ValueInternalMap::find(const char* key) const {
- if (!bucketsSize_)
- return 0;
- HashKey hashedKey = hash(key);
- BucketIndex bucketIndex = hashedKey % bucketsSize_;
- for (const ValueInternalLink* current = &buckets_[bucketIndex]; current != 0;
- current = current->next_) {
- for (BucketIndex index = 0; index < ValueInternalLink::itemPerLink;
- ++index) {
- if (current->items_[index].isItemAvailable())
- return 0;
- if (strcmp(key, current->keys_[index]) == 0)
- return ¤t->items_[index];
- }
- }
- return 0;
-}
-
-Value* ValueInternalMap::find(const char* key) {
- const ValueInternalMap* constThis = this;
- return const_cast<Value*>(constThis->find(key));
-}
-
-Value& ValueInternalMap::resolveReference(const char* key, bool isStatic) {
- HashKey hashedKey = hash(key);
- if (bucketsSize_) {
- BucketIndex bucketIndex = hashedKey % bucketsSize_;
- ValueInternalLink** previous = 0;
- BucketIndex index;
- for (ValueInternalLink* current = &buckets_[bucketIndex]; current != 0;
- previous = ¤t->next_, current = current->next_) {
- for (index = 0; index < ValueInternalLink::itemPerLink; ++index) {
- if (current->items_[index].isItemAvailable())
- return setNewItem(key, isStatic, current, index);
- if (strcmp(key, current->keys_[index]) == 0)
- return current->items_[index];
- }
- }
- }
-
- reserveDelta(1);
- return unsafeAdd(key, isStatic, hashedKey);
-}
-
-void ValueInternalMap::remove(const char* key) {
- HashKey hashedKey = hash(key);
- if (!bucketsSize_)
- return;
- BucketIndex bucketIndex = hashedKey % bucketsSize_;
- for (ValueInternalLink* link = &buckets_[bucketIndex]; link != 0;
- link = link->next_) {
- BucketIndex index;
- for (index = 0; index < ValueInternalLink::itemPerLink; ++index) {
- if (link->items_[index].isItemAvailable())
- return;
- if (strcmp(key, link->keys_[index]) == 0) {
- doActualRemove(link, index, bucketIndex);
- return;
- }
- }
- }
-}
-
-void ValueInternalMap::doActualRemove(ValueInternalLink* link,
- BucketIndex index,
- BucketIndex bucketIndex) {
- // find last item of the bucket and swap it with the 'removed' one.
- // set removed items flags to 'available'.
- // if last page only contains 'available' items, then desallocate it (it's
- // empty)
- ValueInternalLink*& lastLink = getLastLinkInBucket(index);
- BucketIndex lastItemIndex = 1; // a link can never be empty, so start at 1
- for (; lastItemIndex < ValueInternalLink::itemPerLink;
- ++lastItemIndex) // may be optimized with dicotomic search
- {
- if (lastLink->items_[lastItemIndex].isItemAvailable())
- break;
- }
-
- BucketIndex lastUsedIndex = lastItemIndex - 1;
- Value* valueToDelete = &link->items_[index];
- Value* valueToPreserve = &lastLink->items_[lastUsedIndex];
- if (valueToDelete != valueToPreserve)
- valueToDelete->swap(*valueToPreserve);
- if (lastUsedIndex == 0) // page is now empty
- { // remove it from bucket linked list and delete it.
- ValueInternalLink* linkPreviousToLast = lastLink->previous_;
- if (linkPreviousToLast != 0) // can not deleted bucket link.
- {
- mapAllocator()->releaseMapLink(lastLink);
- linkPreviousToLast->next_ = 0;
- lastLink = linkPreviousToLast;
- }
- } else {
- Value dummy;
- valueToPreserve->swap(dummy); // restore deleted to default Value.
- valueToPreserve->setItemUsed(false);
- }
- --itemCount_;
-}
-
-ValueInternalLink*&
-ValueInternalMap::getLastLinkInBucket(BucketIndex bucketIndex) {
- if (bucketIndex == bucketsSize_ - 1)
- return tailLink_;
- ValueInternalLink*& previous = buckets_[bucketIndex + 1].previous_;
- if (!previous)
- previous = &buckets_[bucketIndex];
- return previous;
-}
-
-Value& ValueInternalMap::setNewItem(const char* key,
- bool isStatic,
- ValueInternalLink* link,
- BucketIndex index) {
- char* duplicatedKey = makeMemberName(key);
- ++itemCount_;
- link->keys_[index] = duplicatedKey;
- link->items_[index].setItemUsed();
- link->items_[index].setMemberNameIsStatic(isStatic);
- return link->items_[index]; // items already default constructed.
-}
-
-Value&
-ValueInternalMap::unsafeAdd(const char* key, bool isStatic, HashKey hashedKey) {
- JSON_ASSERT_MESSAGE(bucketsSize_ > 0,
- "ValueInternalMap::unsafeAdd(): internal logic error.");
- BucketIndex bucketIndex = hashedKey % bucketsSize_;
- ValueInternalLink*& previousLink = getLastLinkInBucket(bucketIndex);
- ValueInternalLink* link = previousLink;
- BucketIndex index;
- for (index = 0; index < ValueInternalLink::itemPerLink; ++index) {
- if (link->items_[index].isItemAvailable())
- break;
- }
- if (index == ValueInternalLink::itemPerLink) // need to add a new page
- {
- ValueInternalLink* newLink = mapAllocator()->allocateMapLink();
- index = 0;
- link->next_ = newLink;
- previousLink = newLink;
- link = newLink;
- }
- return setNewItem(key, isStatic, link, index);
-}
-
-ValueInternalMap::HashKey ValueInternalMap::hash(const char* key) const {
- HashKey hash = 0;
- while (*key)
- hash += *key++ * 37;
- return hash;
-}
-
-int ValueInternalMap::compare(const ValueInternalMap& other) const {
- int sizeDiff(itemCount_ - other.itemCount_);
- if (sizeDiff != 0)
- return sizeDiff;
- // Strict order guaranty is required. Compare all keys FIRST, then compare
- // values.
- IteratorState it;
- IteratorState itEnd;
- makeBeginIterator(it);
- makeEndIterator(itEnd);
- for (; !equals(it, itEnd); increment(it)) {
- if (!other.find(key(it)))
- return 1;
- }
-
- // All keys are equals, let's compare values
- makeBeginIterator(it);
- for (; !equals(it, itEnd); increment(it)) {
- const Value* otherValue = other.find(key(it));
- int valueDiff = value(it).compare(*otherValue);
- if (valueDiff != 0)
- return valueDiff;
- }
- return 0;
-}
-
-void ValueInternalMap::makeBeginIterator(IteratorState& it) const {
- it.map_ = const_cast<ValueInternalMap*>(this);
- it.bucketIndex_ = 0;
- it.itemIndex_ = 0;
- it.link_ = buckets_;
-}
-
-void ValueInternalMap::makeEndIterator(IteratorState& it) const {
- it.map_ = const_cast<ValueInternalMap*>(this);
- it.bucketIndex_ = bucketsSize_;
- it.itemIndex_ = 0;
- it.link_ = 0;
-}
-
-bool ValueInternalMap::equals(const IteratorState& x,
- const IteratorState& other) {
- return x.map_ == other.map_ && x.bucketIndex_ == other.bucketIndex_ &&
- x.link_ == other.link_ && x.itemIndex_ == other.itemIndex_;
-}
-
-void ValueInternalMap::incrementBucket(IteratorState& iterator) {
- ++iterator.bucketIndex_;
- JSON_ASSERT_MESSAGE(
- iterator.bucketIndex_ <= iterator.map_->bucketsSize_,
- "ValueInternalMap::increment(): attempting to iterate beyond end.");
- if (iterator.bucketIndex_ == iterator.map_->bucketsSize_)
- iterator.link_ = 0;
- else
- iterator.link_ = &(iterator.map_->buckets_[iterator.bucketIndex_]);
- iterator.itemIndex_ = 0;
-}
-
-void ValueInternalMap::increment(IteratorState& iterator) {
- JSON_ASSERT_MESSAGE(iterator.map_,
- "Attempting to iterator using invalid iterator.");
- ++iterator.itemIndex_;
- if (iterator.itemIndex_ == ValueInternalLink::itemPerLink) {
- JSON_ASSERT_MESSAGE(
- iterator.link_ != 0,
- "ValueInternalMap::increment(): attempting to iterate beyond end.");
- iterator.link_ = iterator.link_->next_;
- if (iterator.link_ == 0)
- incrementBucket(iterator);
- } else if (iterator.link_->items_[iterator.itemIndex_].isItemAvailable()) {
- incrementBucket(iterator);
- }
-}
-
-void ValueInternalMap::decrement(IteratorState& iterator) {
- if (iterator.itemIndex_ == 0) {
- JSON_ASSERT_MESSAGE(iterator.map_,
- "Attempting to iterate using invalid iterator.");
- if (iterator.link_ == &iterator.map_->buckets_[iterator.bucketIndex_]) {
- JSON_ASSERT_MESSAGE(iterator.bucketIndex_ > 0,
- "Attempting to iterate beyond beginning.");
- --(iterator.bucketIndex_);
- }
- iterator.link_ = iterator.link_->previous_;
- iterator.itemIndex_ = ValueInternalLink::itemPerLink - 1;
- }
-}
-
-const char* ValueInternalMap::key(const IteratorState& iterator) {
- JSON_ASSERT_MESSAGE(iterator.link_,
- "Attempting to iterate using invalid iterator.");
- return iterator.link_->keys_[iterator.itemIndex_];
-}
-
-const char* ValueInternalMap::key(const IteratorState& iterator,
- bool& isStatic) {
- JSON_ASSERT_MESSAGE(iterator.link_,
- "Attempting to iterate using invalid iterator.");
- isStatic = iterator.link_->items_[iterator.itemIndex_].isMemberNameStatic();
- return iterator.link_->keys_[iterator.itemIndex_];
-}
-
-Value& ValueInternalMap::value(const IteratorState& iterator) {
- JSON_ASSERT_MESSAGE(iterator.link_,
- "Attempting to iterate using invalid iterator.");
- return iterator.link_->items_[iterator.itemIndex_];
-}
-
-int ValueInternalMap::distance(const IteratorState& x, const IteratorState& y) {
- int offset = 0;
- IteratorState it = x;
- while (!equals(it, y))
- increment(it);
- return offset;
-}
-
-} // namespace Json
diff --git a/src/lib_json/json_reader.cpp b/src/lib_json/json_reader.cpp
index 6136230..19922a8 100644
--- a/src/lib_json/json_reader.cpp
+++ b/src/lib_json/json_reader.cpp
@@ -1,41 +1,69 @@
-// Copyright 2007-2011 Baptiste Lepilleur
+// Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors
+// Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
+#include "json_tool.h"
#include <json/assertions.h>
#include <json/reader.h>
#include <json/value.h>
-#include "json_tool.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <iostream>
-#include <fstream>
-#include <utility>
-#include <cstdio>
+#include <algorithm>
#include <cassert>
#include <cstring>
+#include <iostream>
#include <istream>
+#include <limits>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <utility>
-#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
-#define snprintf _snprintf
+#include <cstdio>
+#if __cplusplus >= 201103L
+
+#if !defined(sscanf)
+#define sscanf std::sscanf
#endif
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#endif //__cplusplus
+
+#if defined(_MSC_VER)
+#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
+#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
+#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+#endif //_MSC_VER
+
+#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
+// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
+// time to change the stack limit
+#if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
+#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
+#endif
+
+static size_t const stackLimit_g =
+ JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
+
namespace Json {
+#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
+using CharReaderPtr = std::unique_ptr<CharReader>;
+#else
+using CharReaderPtr = std::auto_ptr<CharReader>;
+#endif
+
// Implementation of class Features
// ////////////////////////////////
-Features::Features()
- : allowComments_(true), strictRoot_(false),
- allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
+Features::Features() = default;
-Features Features::all() { return Features(); }
+Features Features::all() { return {}; }
Features Features::strictMode() {
Features features;
@@ -49,67 +77,39 @@
// Implementation of class Reader
// ////////////////////////////////
-static inline bool in(Reader::Char c,
- Reader::Char c1,
- Reader::Char c2,
- Reader::Char c3,
- Reader::Char c4) {
- return c == c1 || c == c2 || c == c3 || c == c4;
-}
-
-static inline bool in(Reader::Char c,
- Reader::Char c1,
- Reader::Char c2,
- Reader::Char c3,
- Reader::Char c4,
- Reader::Char c5) {
- return c == c1 || c == c2 || c == c3 || c == c4 || c == c5;
-}
-
-static bool containsNewLine(Reader::Location begin, Reader::Location end) {
- for (; begin < end; ++begin)
- if (*begin == '\n' || *begin == '\r')
- return true;
- return false;
+bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
+ return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
// Class Reader
// //////////////////////////////////////////////////////////////////
-Reader::Reader()
- : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
- lastValue_(), commentsBefore_(), features_(Features::all()),
- collectComments_() {}
+Reader::Reader() : features_(Features::all()) {}
-Reader::Reader(const Features& features)
- : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
- lastValue_(), commentsBefore_(), features_(features), collectComments_() {
-}
+Reader::Reader(const Features& features) : features_(features) {}
-bool
-Reader::parse(const std::string& document, Value& root, bool collectComments) {
- document_ = document;
+bool Reader::parse(const std::string& document, Value& root,
+ bool collectComments) {
+ document_.assign(document.begin(), document.end());
const char* begin = document_.c_str();
const char* end = begin + document_.length();
return parse(begin, end, root, collectComments);
}
-bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
- // std::istream_iterator<char> begin(sin);
+bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
+ // std::istream_iterator<char> begin(is);
// std::istream_iterator<char> end;
// Those would allow streamed input from a file, if parse() were a
// template function.
- // Since std::string is reference-counted, this at least does not
+ // Since String is reference-counted, this at least does not
// create an extra copy.
- std::string doc;
- std::getline(sin, doc, (char)EOF);
- return parse(doc, root, collectComments);
+ String doc;
+ std::getline(is, doc, static_cast<char> EOF);
+ return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
}
-bool Reader::parse(const char* beginDoc,
- const char* endDoc,
- Value& root,
+bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
@@ -119,9 +119,9 @@
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
- lastValueEnd_ = 0;
- lastValue_ = 0;
- commentsBefore_ = "";
+ lastValueEnd_ = nullptr;
+ lastValue_ = nullptr;
+ commentsBefore_.clear();
errors_.clear();
while (!nodes_.empty())
nodes_.pop();
@@ -149,21 +149,20 @@
}
bool Reader::readValue() {
+ // readValue() may call itself only if it calls readObject() or ReadArray().
+ // These methods execute nodes_.push() just before and nodes_.pop)() just
+ // after calling readValue(). parse() executes one nodes_.push(), so > instead
+ // of >=.
+ if (nodes_.size() > stackLimit_g)
+ throwRuntimeError("Exceeded stackLimit in readValue().");
+
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
- // Remove newline characters at the end of the comments
- size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
- if (lastNonNewline != std::string::npos) {
- commentsBefore_.erase(lastNonNewline + 1);
- } else {
- commentsBefore_.clear();
- }
-
currentValue().setComment(commentsBefore_, commentBefore);
- commentsBefore_ = "";
+ commentsBefore_.clear();
}
switch (token.type_) {
@@ -181,32 +180,37 @@
case tokenString:
successful = decodeString(token);
break;
- case tokenTrue:
- currentValue() = true;
+ case tokenTrue: {
+ Value v(true);
+ currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
- break;
- case tokenFalse:
- currentValue() = false;
+ } break;
+ case tokenFalse: {
+ Value v(false);
+ currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
- break;
- case tokenNull:
- currentValue() = Value();
+ } break;
+ case tokenNull: {
+ Value v;
+ currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
- break;
+ } break;
case tokenArraySeparator:
+ case tokenObjectEnd:
+ case tokenArrayEnd:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
- currentValue() = Value();
+ Value v;
+ currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
- }
- // Else, fall through...
+ } // Else, fall through...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
@@ -231,13 +235,6 @@
}
}
-bool Reader::expectToken(TokenType type, Token& token, const char* message) {
- readToken(token);
- if (token.type_ != type)
- return addError(message, token);
- return true;
-}
-
bool Reader::readToken(Token& token) {
skipSpaces();
token.start_ = current_;
@@ -306,7 +303,7 @@
if (!ok)
token.type_ = tokenError;
token.end_ = current_;
- return true;
+ return ok;
}
void Reader::skipSpaces() {
@@ -319,7 +316,7 @@
}
}
-bool Reader::match(Location pattern, int patternLength) {
+bool Reader::match(const Char* pattern, int patternLength) {
if (end_ - current_ < patternLength)
return false;
int index = patternLength;
@@ -353,19 +350,39 @@
return true;
}
-void
-Reader::addComment(Location begin, Location end, CommentPlacement placement) {
+String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
+ String normalized;
+ normalized.reserve(static_cast<size_t>(end - begin));
+ Reader::Location current = begin;
+ while (current != end) {
+ char c = *current++;
+ if (c == '\r') {
+ if (current != end && *current == '\n')
+ // convert dos EOL
+ ++current;
+ // convert Mac EOL
+ normalized += '\n';
+ } else {
+ normalized += c;
+ }
+ }
+ return normalized;
+}
+
+void Reader::addComment(Location begin, Location end,
+ CommentPlacement placement) {
assert(collectComments_);
+ const String& normalized = normalizeEOL(begin, end);
if (placement == commentAfterOnSameLine) {
- assert(lastValue_ != 0);
- lastValue_->setComment(std::string(begin, end), placement);
+ assert(lastValue_ != nullptr);
+ lastValue_->setComment(normalized, placement);
} else {
- commentsBefore_ += std::string(begin, end);
+ commentsBefore_ += normalized;
}
}
bool Reader::readCStyleComment() {
- while (current_ != end_) {
+ while ((current_ + 1) < end_) {
Char c = getNextChar();
if (c == '*' && *current_ == '/')
break;
@@ -376,23 +393,43 @@
bool Reader::readCppStyleComment() {
while (current_ != end_) {
Char c = getNextChar();
- if (c == '\r' || c == '\n')
+ if (c == '\n')
break;
+ if (c == '\r') {
+ // Consume DOS EOL. It will be normalized in addComment.
+ if (current_ != end_ && *current_ == '\n')
+ getNextChar();
+ // Break on Moc OS 9 EOL.
+ break;
+ }
}
return true;
}
void Reader::readNumber() {
- while (current_ != end_) {
- if (!(*current_ >= '0' && *current_ <= '9') &&
- !in(*current_, '.', 'e', 'E', '+', '-'))
- break;
- ++current_;
+ Location p = current_;
+ char c = '0'; // stopgap for already consumed character
+ // integral part
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ // fractional part
+ if (c == '.') {
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ }
+ // exponential part
+ if (c == 'e' || c == 'E') {
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ if (c == '+' || c == '-')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
}
}
bool Reader::readString() {
- Char c = 0;
+ Char c = '\0';
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
@@ -403,11 +440,12 @@
return c == '"';
}
-bool Reader::readObject(Token& tokenStart) {
+bool Reader::readObject(Token& token) {
Token tokenName;
- std::string name;
- currentValue() = Value(objectValue);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
+ String name;
+ Value init(objectValue);
+ currentValue().swapPayload(init);
+ currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
@@ -416,7 +454,7 @@
break;
if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
return true;
- name = "";
+ name.clear();
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
@@ -431,8 +469,8 @@
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
- return addErrorAndRecover(
- "Missing ':' after object member name", colon, tokenObjectEnd);
+ return addErrorAndRecover("Missing ':' after object member name", colon,
+ tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
@@ -445,8 +483,8 @@
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
- return addErrorAndRecover(
- "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
+ return addErrorAndRecover("Missing ',' or '}' in object declaration",
+ comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
@@ -454,15 +492,16 @@
if (comma.type_ == tokenObjectEnd)
return true;
}
- return addErrorAndRecover(
- "Missing '}' or object member name", tokenName, tokenObjectEnd);
+ return addErrorAndRecover("Missing '}' or object member name", tokenName,
+ tokenObjectEnd);
}
-bool Reader::readArray(Token& tokenStart) {
- currentValue() = Value(arrayValue);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
+bool Reader::readArray(Token& token) {
+ Value init(arrayValue);
+ currentValue().swapPayload(init);
+ currentValue().setOffsetStart(token.start_ - begin_);
skipSpaces();
- if (*current_ == ']') // empty array
+ if (current_ != end_ && *current_ == ']') // empty array
{
Token endArray;
readToken(endArray);
@@ -477,19 +516,19 @@
if (!ok) // error already set
return recoverFromError(tokenArrayEnd);
- Token token;
+ Token currentToken;
// Accept Comment after last item in the array.
- ok = readToken(token);
- while (token.type_ == tokenComment && ok) {
- ok = readToken(token);
+ ok = readToken(currentToken);
+ while (currentToken.type_ == tokenComment && ok) {
+ ok = readToken(currentToken);
}
- bool badTokenType =
- (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+ bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
+ currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) {
- return addErrorAndRecover(
- "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
+ return addErrorAndRecover("Missing ',' or ']' in array declaration",
+ currentToken, tokenArrayEnd);
}
- if (token.type_ == tokenArrayEnd)
+ if (currentToken.type_ == tokenArrayEnd)
break;
}
return true;
@@ -499,20 +538,13 @@
Value decoded;
if (!decodeNumber(token, decoded))
return false;
- currentValue() = decoded;
+ currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeNumber(Token& token, Value& decoded) {
- bool isDouble = false;
- for (Location inspect = token.start_; inspect != token.end_; ++inspect) {
- isDouble = isDouble || in(*inspect, '.', 'e', 'E', '+') ||
- (*inspect == '-' && inspect != token.start_);
- }
- if (isDouble)
- return decodeDouble(token, decoded);
// Attempts to parse the number as an integer. If the number is
// larger than the maximum supported value of an integer then
// we decode the number as a double.
@@ -520,18 +552,18 @@
bool isNegative = *current == '-';
if (isNegative)
++current;
+ // TODO: Help the compiler do the div and mod at compile time or get rid of
+ // them.
Value::LargestUInt maxIntegerValue =
- isNegative ? Value::LargestUInt(-Value::minLargestInt)
+ isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
: Value::maxLargestUInt;
Value::LargestUInt threshold = maxIntegerValue / 10;
Value::LargestUInt value = 0;
while (current < token.end_) {
Char c = *current++;
if (c < '0' || c > '9')
- return addError("'" + std::string(token.start_, token.end_) +
- "' is not a number.",
- token);
- Value::UInt digit(c - '0');
+ return decodeDouble(token, decoded);
+ auto digit(static_cast<Value::UInt>(c - '0'));
if (value >= threshold) {
// We've hit or exceeded the max value divided by 10 (rounded down). If
// a) we've only just touched the limit, b) this is the last digit, and
@@ -544,7 +576,9 @@
}
value = value * 10 + digit;
}
- if (isNegative)
+ if (isNegative && value == maxIntegerValue)
+ decoded = Value::minLargestInt;
+ else if (isNegative)
decoded = -Value::LargestInt(value);
else if (value <= Value::LargestUInt(Value::maxInt))
decoded = Value::LargestInt(value);
@@ -557,7 +591,7 @@
Value decoded;
if (!decodeDouble(token, decoded))
return false;
- currentValue() = decoded;
+ currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
@@ -565,59 +599,35 @@
bool Reader::decodeDouble(Token& token, Value& decoded) {
double value = 0;
- const int bufferSize = 32;
- int count;
- int length = int(token.end_ - token.start_);
-
- // Sanity check to avoid buffer overflow exploits.
- if (length < 0) {
- return addError("Unable to parse token length", token);
- }
-
- // Avoid using a string constant for the format control string given to
- // sscanf, as this can cause hard to debug crashes on OS X. See here for more
- // info:
- //
- // http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
- char format[] = "%lf";
-
- if (length <= bufferSize) {
- Char buffer[bufferSize + 1];
- memcpy(buffer, token.start_, length);
- buffer[length] = 0;
- count = sscanf(buffer, format, &value);
- } else {
- std::string buffer(token.start_, token.end_);
- count = sscanf(buffer.c_str(), format, &value);
- }
-
- if (count != 1)
- return addError("'" + std::string(token.start_, token.end_) +
- "' is not a number.",
- token);
+ String buffer(token.start_, token.end_);
+ IStringStream is(buffer);
+ if (!(is >> value))
+ return addError(
+ "'" + String(token.start_, token.end_) + "' is not a number.", token);
decoded = value;
return true;
}
bool Reader::decodeString(Token& token) {
- std::string decoded;
- if (!decodeString(token, decoded))
+ String decoded_string;
+ if (!decodeString(token, decoded_string))
return false;
- currentValue() = decoded;
+ Value decoded(decoded_string);
+ currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
-bool Reader::decodeString(Token& token, std::string& decoded) {
- decoded.reserve(token.end_ - token.start_ - 2);
+bool Reader::decodeString(Token& token, String& decoded) {
+ decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while (current != end) {
Char c = *current++;
if (c == '"')
break;
- else if (c == '\\') {
+ if (c == '\\') {
if (current == end)
return addError("Empty escape sequence in string", token, current);
Char escape = *current++;
@@ -662,10 +672,8 @@
return true;
}
-bool Reader::decodeUnicodeCodePoint(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode) {
+bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
+ Location end, unsigned int& unicode) {
if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
return false;
@@ -674,10 +682,9 @@
if (end - current < 6)
return addError(
"additional six characters expected to parse unicode surrogate pair.",
- token,
- current);
- unsigned int surrogatePair;
+ token, current);
if (*(current++) == '\\' && *(current++) == 'u') {
+ unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else
@@ -685,22 +692,19 @@
} else
return addError("expecting another \\u token to begin the second half of "
"a unicode surrogate pair",
- token,
- current);
+ token, current);
}
return true;
}
-bool Reader::decodeUnicodeEscapeSequence(Token& token,
- Location& current,
+bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end,
- unsigned int& unicode) {
+ unsigned int& ret_unicode) {
if (end - current < 4)
return addError(
- "Bad unicode escape sequence in string: four digits expected.",
- token,
+ "Bad unicode escape sequence in string: four digits expected.", token,
current);
- unicode = 0;
+ int unicode = 0;
for (int index = 0; index < 4; ++index) {
Char c = *current++;
unicode *= 16;
@@ -713,14 +717,13 @@
else
return addError(
"Bad unicode escape sequence in string: hexadecimal digit expected.",
- token,
- current);
+ token, current);
}
+ ret_unicode = static_cast<unsigned int>(unicode);
return true;
}
-bool
-Reader::addError(const std::string& message, Token& token, Location extra) {
+bool Reader::addError(const String& message, Token& token, Location extra) {
ErrorInfo info;
info.token_ = token;
info.message_ = message;
@@ -730,7 +733,7 @@
}
bool Reader::recoverFromError(TokenType skipUntilToken) {
- int errorCount = int(errors_.size());
+ size_t const errorCount = errors_.size();
Token skip;
for (;;) {
if (!readToken(skip))
@@ -742,8 +745,7 @@
return false;
}
-bool Reader::addErrorAndRecover(const std::string& message,
- Token& token,
+bool Reader::addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken) {
addError(message, token);
return recoverFromError(skipUntilToken);
@@ -757,8 +759,7 @@
return *current_++;
}
-void Reader::getLocationLineAndColumn(Location location,
- int& line,
+void Reader::getLocationLineAndColumn(Location location, int& line,
int& column) const {
Location current = begin_;
Location lastLineStart = current;
@@ -780,33 +781,22 @@
++line;
}
-std::string Reader::getLocationLineAndColumn(Location location) const {
+String Reader::getLocationLineAndColumn(Location location) const {
int line, column;
getLocationLineAndColumn(location, line, column);
char buffer[18 + 16 + 16 + 1];
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
-#if defined(WINCE)
- _snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
-#else
- sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
-#endif
-#else
- snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
-#endif
+ jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
return buffer;
}
// Deprecated. Preserved for backward compatibility
-std::string Reader::getFormatedErrorMessages() const {
+String Reader::getFormatedErrorMessages() const {
return getFormattedErrorMessages();
}
-std::string Reader::getFormattedErrorMessages() const {
- std::string formattedMessage;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
+String Reader::getFormattedErrorMessages() const {
+ String formattedMessage;
+ for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
@@ -819,10 +809,7 @@
std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
std::vector<Reader::StructuredError> allErrors;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
+ for (const auto& error : errors_) {
Reader::StructuredError structured;
structured.offset_start = error.token_.start_ - begin_;
structured.offset_limit = error.token_.end_ - begin_;
@@ -832,28 +819,27 @@
return allErrors;
}
-bool Reader::pushError(const Value& value, const std::string& message) {
- size_t length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const String& message) {
+ ptrdiff_t const length = end_ - begin_;
+ if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
token.start_ = begin_ + value.getOffsetStart();
- token.end_ = end_ + value.getOffsetLimit();
+ token.end_ = begin_ + value.getOffsetLimit();
ErrorInfo info;
info.token_ = token;
info.message_ = message;
- info.extra_ = 0;
+ info.extra_ = nullptr;
errors_.push_back(info);
return true;
}
-bool Reader::pushError(const Value& value, const std::string& message, const Value& extra) {
- size_t length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length
- || extra.getOffsetLimit() > length)
+bool Reader::pushError(const Value& value, const String& message,
+ const Value& extra) {
+ ptrdiff_t const length = end_ - begin_;
+ if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
+ extra.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
@@ -867,19 +853,1139 @@
return true;
}
-bool Reader::good() const {
- return !errors_.size();
+bool Reader::good() const { return errors_.empty(); }
+
+// Originally copied from the Features class (now deprecated), used internally
+// for features implementation.
+class OurFeatures {
+public:
+ static OurFeatures all();
+ bool allowComments_;
+ bool allowTrailingCommas_;
+ bool strictRoot_;
+ bool allowDroppedNullPlaceholders_;
+ bool allowNumericKeys_;
+ bool allowSingleQuotes_;
+ bool failIfExtra_;
+ bool rejectDupKeys_;
+ bool allowSpecialFloats_;
+ bool skipBom_;
+ size_t stackLimit_;
+}; // OurFeatures
+
+OurFeatures OurFeatures::all() { return {}; }
+
+// Implementation of class Reader
+// ////////////////////////////////
+
+// Originally copied from the Reader class (now deprecated), used internally
+// for implementing JSON reading.
+class OurReader {
+public:
+ using Char = char;
+ using Location = const Char*;
+ struct StructuredError {
+ ptrdiff_t offset_start;
+ ptrdiff_t offset_limit;
+ String message;
+ };
+
+ explicit OurReader(OurFeatures const& features);
+ bool parse(const char* beginDoc, const char* endDoc, Value& root,
+ bool collectComments = true);
+ String getFormattedErrorMessages() const;
+ std::vector<StructuredError> getStructuredErrors() const;
+
+private:
+ OurReader(OurReader const&); // no impl
+ void operator=(OurReader const&); // no impl
+
+ enum TokenType {
+ tokenEndOfStream = 0,
+ tokenObjectBegin,
+ tokenObjectEnd,
+ tokenArrayBegin,
+ tokenArrayEnd,
+ tokenString,
+ tokenNumber,
+ tokenTrue,
+ tokenFalse,
+ tokenNull,
+ tokenNaN,
+ tokenPosInf,
+ tokenNegInf,
+ tokenArraySeparator,
+ tokenMemberSeparator,
+ tokenComment,
+ tokenError
+ };
+
+ class Token {
+ public:
+ TokenType type_;
+ Location start_;
+ Location end_;
+ };
+
+ class ErrorInfo {
+ public:
+ Token token_;
+ String message_;
+ Location extra_;
+ };
+
+ using Errors = std::deque<ErrorInfo>;
+
+ bool readToken(Token& token);
+ void skipSpaces();
+ void skipBom(bool skipBom);
+ bool match(const Char* pattern, int patternLength);
+ bool readComment();
+ bool readCStyleComment(bool* containsNewLineResult);
+ bool readCppStyleComment();
+ bool readString();
+ bool readStringSingleQuote();
+ bool readNumber(bool checkInf);
+ bool readValue();
+ bool readObject(Token& token);
+ bool readArray(Token& token);
+ bool decodeNumber(Token& token);
+ bool decodeNumber(Token& token, Value& decoded);
+ bool decodeString(Token& token);
+ bool decodeString(Token& token, String& decoded);
+ bool decodeDouble(Token& token);
+ bool decodeDouble(Token& token, Value& decoded);
+ bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
+ unsigned int& unicode);
+ bool decodeUnicodeEscapeSequence(Token& token, Location& current,
+ Location end, unsigned int& unicode);
+ bool addError(const String& message, Token& token, Location extra = nullptr);
+ bool recoverFromError(TokenType skipUntilToken);
+ bool addErrorAndRecover(const String& message, Token& token,
+ TokenType skipUntilToken);
+ void skipUntilSpace();
+ Value& currentValue();
+ Char getNextChar();
+ void getLocationLineAndColumn(Location location, int& line,
+ int& column) const;
+ String getLocationLineAndColumn(Location location) const;
+ void addComment(Location begin, Location end, CommentPlacement placement);
+ void skipCommentTokens(Token& token);
+
+ static String normalizeEOL(Location begin, Location end);
+ static bool containsNewLine(Location begin, Location end);
+
+ using Nodes = std::stack<Value*>;
+
+ Nodes nodes_{};
+ Errors errors_{};
+ String document_{};
+ Location begin_ = nullptr;
+ Location end_ = nullptr;
+ Location current_ = nullptr;
+ Location lastValueEnd_ = nullptr;
+ Value* lastValue_ = nullptr;
+ bool lastValueHasAComment_ = false;
+ String commentsBefore_{};
+
+ OurFeatures const features_;
+ bool collectComments_ = false;
+}; // OurReader
+
+// complete copy of Read impl, for OurReader
+
+bool OurReader::containsNewLine(OurReader::Location begin,
+ OurReader::Location end) {
+ return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
-std::istream& operator>>(std::istream& sin, Value& root) {
- Json::Reader reader;
- bool ok = reader.parse(sin, root, true);
- if (!ok) {
- fprintf(stderr,
- "Error from reader: %s",
- reader.getFormattedErrorMessages().c_str());
+OurReader::OurReader(OurFeatures const& features) : features_(features) {}
- JSON_FAIL_MESSAGE("reader error");
+bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
+ bool collectComments) {
+ if (!features_.allowComments_) {
+ collectComments = false;
+ }
+
+ begin_ = beginDoc;
+ end_ = endDoc;
+ collectComments_ = collectComments;
+ current_ = begin_;
+ lastValueEnd_ = nullptr;
+ lastValue_ = nullptr;
+ commentsBefore_.clear();
+ errors_.clear();
+ while (!nodes_.empty())
+ nodes_.pop();
+ nodes_.push(&root);
+
+ // skip byte order mark if it exists at the beginning of the UTF-8 text.
+ skipBom(features_.skipBom_);
+ bool successful = readValue();
+ nodes_.pop();
+ Token token;
+ skipCommentTokens(token);
+ if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
+ addError("Extra non-whitespace after JSON value.", token);
+ return false;
+ }
+ if (collectComments_ && !commentsBefore_.empty())
+ root.setComment(commentsBefore_, commentAfter);
+ if (features_.strictRoot_) {
+ if (!root.isArray() && !root.isObject()) {
+ // Set error location to start of doc, ideally should be first token found
+ // in doc
+ token.type_ = tokenError;
+ token.start_ = beginDoc;
+ token.end_ = endDoc;
+ addError(
+ "A valid JSON document must be either an array or an object value.",
+ token);
+ return false;
+ }
+ }
+ return successful;
+}
+
+bool OurReader::readValue() {
+ // To preserve the old behaviour we cast size_t to int.
+ if (nodes_.size() > features_.stackLimit_)
+ throwRuntimeError("Exceeded stackLimit in readValue().");
+ Token token;
+ skipCommentTokens(token);
+ bool successful = true;
+
+ if (collectComments_ && !commentsBefore_.empty()) {
+ currentValue().setComment(commentsBefore_, commentBefore);
+ commentsBefore_.clear();
+ }
+
+ switch (token.type_) {
+ case tokenObjectBegin:
+ successful = readObject(token);
+ currentValue().setOffsetLimit(current_ - begin_);
+ break;
+ case tokenArrayBegin:
+ successful = readArray(token);
+ currentValue().setOffsetLimit(current_ - begin_);
+ break;
+ case tokenNumber:
+ successful = decodeNumber(token);
+ break;
+ case tokenString:
+ successful = decodeString(token);
+ break;
+ case tokenTrue: {
+ Value v(true);
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenFalse: {
+ Value v(false);
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenNull: {
+ Value v;
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenNaN: {
+ Value v(std::numeric_limits<double>::quiet_NaN());
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenPosInf: {
+ Value v(std::numeric_limits<double>::infinity());
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenNegInf: {
+ Value v(-std::numeric_limits<double>::infinity());
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ } break;
+ case tokenArraySeparator:
+ case tokenObjectEnd:
+ case tokenArrayEnd:
+ if (features_.allowDroppedNullPlaceholders_) {
+ // "Un-read" the current token and mark the current value as a null
+ // token.
+ current_--;
+ Value v;
+ currentValue().swapPayload(v);
+ currentValue().setOffsetStart(current_ - begin_ - 1);
+ currentValue().setOffsetLimit(current_ - begin_);
+ break;
+ } // else, fall through ...
+ default:
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ return addError("Syntax error: value, object or array expected.", token);
+ }
+
+ if (collectComments_) {
+ lastValueEnd_ = current_;
+ lastValueHasAComment_ = false;
+ lastValue_ = ¤tValue();
+ }
+
+ return successful;
+}
+
+void OurReader::skipCommentTokens(Token& token) {
+ if (features_.allowComments_) {
+ do {
+ readToken(token);
+ } while (token.type_ == tokenComment);
+ } else {
+ readToken(token);
+ }
+}
+
+bool OurReader::readToken(Token& token) {
+ skipSpaces();
+ token.start_ = current_;
+ Char c = getNextChar();
+ bool ok = true;
+ switch (c) {
+ case '{':
+ token.type_ = tokenObjectBegin;
+ break;
+ case '}':
+ token.type_ = tokenObjectEnd;
+ break;
+ case '[':
+ token.type_ = tokenArrayBegin;
+ break;
+ case ']':
+ token.type_ = tokenArrayEnd;
+ break;
+ case '"':
+ token.type_ = tokenString;
+ ok = readString();
+ break;
+ case '\'':
+ if (features_.allowSingleQuotes_) {
+ token.type_ = tokenString;
+ ok = readStringSingleQuote();
+ } else {
+ // If we don't allow single quotes, this is a failure case.
+ ok = false;
+ }
+ break;
+ case '/':
+ token.type_ = tokenComment;
+ ok = readComment();
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ token.type_ = tokenNumber;
+ readNumber(false);
+ break;
+ case '-':
+ if (readNumber(true)) {
+ token.type_ = tokenNumber;
+ } else {
+ token.type_ = tokenNegInf;
+ ok = features_.allowSpecialFloats_ && match("nfinity", 7);
+ }
+ break;
+ case '+':
+ if (readNumber(true)) {
+ token.type_ = tokenNumber;
+ } else {
+ token.type_ = tokenPosInf;
+ ok = features_.allowSpecialFloats_ && match("nfinity", 7);
+ }
+ break;
+ case 't':
+ token.type_ = tokenTrue;
+ ok = match("rue", 3);
+ break;
+ case 'f':
+ token.type_ = tokenFalse;
+ ok = match("alse", 4);
+ break;
+ case 'n':
+ token.type_ = tokenNull;
+ ok = match("ull", 3);
+ break;
+ case 'N':
+ if (features_.allowSpecialFloats_) {
+ token.type_ = tokenNaN;
+ ok = match("aN", 2);
+ } else {
+ ok = false;
+ }
+ break;
+ case 'I':
+ if (features_.allowSpecialFloats_) {
+ token.type_ = tokenPosInf;
+ ok = match("nfinity", 7);
+ } else {
+ ok = false;
+ }
+ break;
+ case ',':
+ token.type_ = tokenArraySeparator;
+ break;
+ case ':':
+ token.type_ = tokenMemberSeparator;
+ break;
+ case 0:
+ token.type_ = tokenEndOfStream;
+ break;
+ default:
+ ok = false;
+ break;
+ }
+ if (!ok)
+ token.type_ = tokenError;
+ token.end_ = current_;
+ return ok;
+}
+
+void OurReader::skipSpaces() {
+ while (current_ != end_) {
+ Char c = *current_;
+ if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
+ ++current_;
+ else
+ break;
+ }
+}
+
+void OurReader::skipBom(bool skipBom) {
+ // The default behavior is to skip BOM.
+ if (skipBom) {
+ if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) {
+ begin_ += 3;
+ current_ = begin_;
+ }
+ }
+}
+
+bool OurReader::match(const Char* pattern, int patternLength) {
+ if (end_ - current_ < patternLength)
+ return false;
+ int index = patternLength;
+ while (index--)
+ if (current_[index] != pattern[index])
+ return false;
+ current_ += patternLength;
+ return true;
+}
+
+bool OurReader::readComment() {
+ const Location commentBegin = current_ - 1;
+ const Char c = getNextChar();
+ bool successful = false;
+ bool cStyleWithEmbeddedNewline = false;
+
+ const bool isCStyleComment = (c == '*');
+ const bool isCppStyleComment = (c == '/');
+ if (isCStyleComment) {
+ successful = readCStyleComment(&cStyleWithEmbeddedNewline);
+ } else if (isCppStyleComment) {
+ successful = readCppStyleComment();
+ }
+
+ if (!successful)
+ return false;
+
+ if (collectComments_) {
+ CommentPlacement placement = commentBefore;
+
+ if (!lastValueHasAComment_) {
+ if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+ if (isCppStyleComment || !cStyleWithEmbeddedNewline) {
+ placement = commentAfterOnSameLine;
+ lastValueHasAComment_ = true;
+ }
+ }
+ }
+
+ addComment(commentBegin, current_, placement);
+ }
+ return true;
+}
+
+String OurReader::normalizeEOL(OurReader::Location begin,
+ OurReader::Location end) {
+ String normalized;
+ normalized.reserve(static_cast<size_t>(end - begin));
+ OurReader::Location current = begin;
+ while (current != end) {
+ char c = *current++;
+ if (c == '\r') {
+ if (current != end && *current == '\n')
+ // convert dos EOL
+ ++current;
+ // convert Mac EOL
+ normalized += '\n';
+ } else {
+ normalized += c;
+ }
+ }
+ return normalized;
+}
+
+void OurReader::addComment(Location begin, Location end,
+ CommentPlacement placement) {
+ assert(collectComments_);
+ const String& normalized = normalizeEOL(begin, end);
+ if (placement == commentAfterOnSameLine) {
+ assert(lastValue_ != nullptr);
+ lastValue_->setComment(normalized, placement);
+ } else {
+ commentsBefore_ += normalized;
+ }
+}
+
+bool OurReader::readCStyleComment(bool* containsNewLineResult) {
+ *containsNewLineResult = false;
+
+ while ((current_ + 1) < end_) {
+ Char c = getNextChar();
+ if (c == '*' && *current_ == '/')
+ break;
+ if (c == '\n')
+ *containsNewLineResult = true;
+ }
+
+ return getNextChar() == '/';
+}
+
+bool OurReader::readCppStyleComment() {
+ while (current_ != end_) {
+ Char c = getNextChar();
+ if (c == '\n')
+ break;
+ if (c == '\r') {
+ // Consume DOS EOL. It will be normalized in addComment.
+ if (current_ != end_ && *current_ == '\n')
+ getNextChar();
+ // Break on Moc OS 9 EOL.
+ break;
+ }
+ }
+ return true;
+}
+
+bool OurReader::readNumber(bool checkInf) {
+ Location p = current_;
+ if (checkInf && p != end_ && *p == 'I') {
+ current_ = ++p;
+ return false;
+ }
+ char c = '0'; // stopgap for already consumed character
+ // integral part
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ // fractional part
+ if (c == '.') {
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ }
+ // exponential part
+ if (c == 'e' || c == 'E') {
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ if (c == '+' || c == '-')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ while (c >= '0' && c <= '9')
+ c = (current_ = p) < end_ ? *p++ : '\0';
+ }
+ return true;
+}
+bool OurReader::readString() {
+ Char c = 0;
+ while (current_ != end_) {
+ c = getNextChar();
+ if (c == '\\')
+ getNextChar();
+ else if (c == '"')
+ break;
+ }
+ return c == '"';
+}
+
+bool OurReader::readStringSingleQuote() {
+ Char c = 0;
+ while (current_ != end_) {
+ c = getNextChar();
+ if (c == '\\')
+ getNextChar();
+ else if (c == '\'')
+ break;
+ }
+ return c == '\'';
+}
+
+bool OurReader::readObject(Token& token) {
+ Token tokenName;
+ String name;
+ Value init(objectValue);
+ currentValue().swapPayload(init);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ while (readToken(tokenName)) {
+ bool initialTokenOk = true;
+ while (tokenName.type_ == tokenComment && initialTokenOk)
+ initialTokenOk = readToken(tokenName);
+ if (!initialTokenOk)
+ break;
+ if (tokenName.type_ == tokenObjectEnd &&
+ (name.empty() ||
+ features_.allowTrailingCommas_)) // empty object or trailing comma
+ return true;
+ name.clear();
+ if (tokenName.type_ == tokenString) {
+ if (!decodeString(tokenName, name))
+ return recoverFromError(tokenObjectEnd);
+ } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+ Value numberName;
+ if (!decodeNumber(tokenName, numberName))
+ return recoverFromError(tokenObjectEnd);
+ name = numberName.asString();
+ } else {
+ break;
+ }
+ if (name.length() >= (1U << 30))
+ throwRuntimeError("keylength >= 2^30");
+ if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
+ String msg = "Duplicate key: '" + name + "'";
+ return addErrorAndRecover(msg, tokenName, tokenObjectEnd);
+ }
+
+ Token colon;
+ if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+ return addErrorAndRecover("Missing ':' after object member name", colon,
+ tokenObjectEnd);
+ }
+ Value& value = currentValue()[name];
+ nodes_.push(&value);
+ bool ok = readValue();
+ nodes_.pop();
+ if (!ok) // error already set
+ return recoverFromError(tokenObjectEnd);
+
+ Token comma;
+ if (!readToken(comma) ||
+ (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
+ comma.type_ != tokenComment)) {
+ return addErrorAndRecover("Missing ',' or '}' in object declaration",
+ comma, tokenObjectEnd);
+ }
+ bool finalizeTokenOk = true;
+ while (comma.type_ == tokenComment && finalizeTokenOk)
+ finalizeTokenOk = readToken(comma);
+ if (comma.type_ == tokenObjectEnd)
+ return true;
+ }
+ return addErrorAndRecover("Missing '}' or object member name", tokenName,
+ tokenObjectEnd);
+}
+
+bool OurReader::readArray(Token& token) {
+ Value init(arrayValue);
+ currentValue().swapPayload(init);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ int index = 0;
+ for (;;) {
+ skipSpaces();
+ if (current_ != end_ && *current_ == ']' &&
+ (index == 0 ||
+ (features_.allowTrailingCommas_ &&
+ !features_.allowDroppedNullPlaceholders_))) // empty array or trailing
+ // comma
+ {
+ Token endArray;
+ readToken(endArray);
+ return true;
+ }
+ Value& value = currentValue()[index++];
+ nodes_.push(&value);
+ bool ok = readValue();
+ nodes_.pop();
+ if (!ok) // error already set
+ return recoverFromError(tokenArrayEnd);
+
+ Token currentToken;
+ // Accept Comment after last item in the array.
+ ok = readToken(currentToken);
+ while (currentToken.type_ == tokenComment && ok) {
+ ok = readToken(currentToken);
+ }
+ bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
+ currentToken.type_ != tokenArrayEnd);
+ if (!ok || badTokenType) {
+ return addErrorAndRecover("Missing ',' or ']' in array declaration",
+ currentToken, tokenArrayEnd);
+ }
+ if (currentToken.type_ == tokenArrayEnd)
+ break;
+ }
+ return true;
+}
+
+bool OurReader::decodeNumber(Token& token) {
+ Value decoded;
+ if (!decodeNumber(token, decoded))
+ return false;
+ currentValue().swapPayload(decoded);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ return true;
+}
+
+bool OurReader::decodeNumber(Token& token, Value& decoded) {
+ // Attempts to parse the number as an integer. If the number is
+ // larger than the maximum supported value of an integer then
+ // we decode the number as a double.
+ Location current = token.start_;
+ const bool isNegative = *current == '-';
+ if (isNegative) {
+ ++current;
+ }
+
+ // We assume we can represent the largest and smallest integer types as
+ // unsigned integers with separate sign. This is only true if they can fit
+ // into an unsigned integer.
+ static_assert(Value::maxLargestInt <= Value::maxLargestUInt,
+ "Int must be smaller than UInt");
+
+ // We need to convert minLargestInt into a positive number. The easiest way
+ // to do this conversion is to assume our "threshold" value of minLargestInt
+ // divided by 10 can fit in maxLargestInt when absolute valued. This should
+ // be a safe assumption.
+ static_assert(Value::minLargestInt <= -Value::maxLargestInt,
+ "The absolute value of minLargestInt must be greater than or "
+ "equal to maxLargestInt");
+ static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt,
+ "The absolute value of minLargestInt must be only 1 magnitude "
+ "larger than maxLargest Int");
+
+ static constexpr Value::LargestUInt positive_threshold =
+ Value::maxLargestUInt / 10;
+ static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10;
+
+ // For the negative values, we have to be more careful. Since typically
+ // -Value::minLargestInt will cause an overflow, we first divide by 10 and
+ // then take the inverse. This assumes that minLargestInt is only a single
+ // power of 10 different in magnitude, which we check above. For the last
+ // digit, we take the modulus before negating for the same reason.
+ static constexpr auto negative_threshold =
+ Value::LargestUInt(-(Value::minLargestInt / 10));
+ static constexpr auto negative_last_digit =
+ Value::UInt(-(Value::minLargestInt % 10));
+
+ const Value::LargestUInt threshold =
+ isNegative ? negative_threshold : positive_threshold;
+ const Value::UInt max_last_digit =
+ isNegative ? negative_last_digit : positive_last_digit;
+
+ Value::LargestUInt value = 0;
+ while (current < token.end_) {
+ Char c = *current++;
+ if (c < '0' || c > '9')
+ return decodeDouble(token, decoded);
+
+ const auto digit(static_cast<Value::UInt>(c - '0'));
+ if (value >= threshold) {
+ // We've hit or exceeded the max value divided by 10 (rounded down). If
+ // a) we've only just touched the limit, meaing value == threshold,
+ // b) this is the last digit, or
+ // c) it's small enough to fit in that rounding delta, we're okay.
+ // Otherwise treat this number as a double to avoid overflow.
+ if (value > threshold || current != token.end_ ||
+ digit > max_last_digit) {
+ return decodeDouble(token, decoded);
+ }
+ }
+ value = value * 10 + digit;
+ }
+
+ if (isNegative) {
+ // We use the same magnitude assumption here, just in case.
+ const auto last_digit = static_cast<Value::UInt>(value % 10);
+ decoded = -Value::LargestInt(value / 10) * 10 - last_digit;
+ } else if (value <= Value::LargestUInt(Value::maxLargestInt)) {
+ decoded = Value::LargestInt(value);
+ } else {
+ decoded = value;
+ }
+
+ return true;
+}
+
+bool OurReader::decodeDouble(Token& token) {
+ Value decoded;
+ if (!decodeDouble(token, decoded))
+ return false;
+ currentValue().swapPayload(decoded);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ return true;
+}
+
+bool OurReader::decodeDouble(Token& token, Value& decoded) {
+ double value = 0;
+ const String buffer(token.start_, token.end_);
+ IStringStream is(buffer);
+ if (!(is >> value)) {
+ return addError(
+ "'" + String(token.start_, token.end_) + "' is not a number.", token);
+ }
+ decoded = value;
+ return true;
+}
+
+bool OurReader::decodeString(Token& token) {
+ String decoded_string;
+ if (!decodeString(token, decoded_string))
+ return false;
+ Value decoded(decoded_string);
+ currentValue().swapPayload(decoded);
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ return true;
+}
+
+bool OurReader::decodeString(Token& token, String& decoded) {
+ decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
+ Location current = token.start_ + 1; // skip '"'
+ Location end = token.end_ - 1; // do not include '"'
+ while (current != end) {
+ Char c = *current++;
+ if (c == '"')
+ break;
+ if (c == '\\') {
+ if (current == end)
+ return addError("Empty escape sequence in string", token, current);
+ Char escape = *current++;
+ switch (escape) {
+ case '"':
+ decoded += '"';
+ break;
+ case '/':
+ decoded += '/';
+ break;
+ case '\\':
+ decoded += '\\';
+ break;
+ case 'b':
+ decoded += '\b';
+ break;
+ case 'f':
+ decoded += '\f';
+ break;
+ case 'n':
+ decoded += '\n';
+ break;
+ case 'r':
+ decoded += '\r';
+ break;
+ case 't':
+ decoded += '\t';
+ break;
+ case 'u': {
+ unsigned int unicode;
+ if (!decodeUnicodeCodePoint(token, current, end, unicode))
+ return false;
+ decoded += codePointToUTF8(unicode);
+ } break;
+ default:
+ return addError("Bad escape sequence in string", token, current);
+ }
+ } else {
+ decoded += c;
+ }
+ }
+ return true;
+}
+
+bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
+ Location end, unsigned int& unicode) {
+
+ if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+ return false;
+ if (unicode >= 0xD800 && unicode <= 0xDBFF) {
+ // surrogate pairs
+ if (end - current < 6)
+ return addError(
+ "additional six characters expected to parse unicode surrogate pair.",
+ token, current);
+ if (*(current++) == '\\' && *(current++) == 'u') {
+ unsigned int surrogatePair;
+ if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+ unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+ } else
+ return false;
+ } else
+ return addError("expecting another \\u token to begin the second half of "
+ "a unicode surrogate pair",
+ token, current);
+ }
+ return true;
+}
+
+bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
+ Location end,
+ unsigned int& ret_unicode) {
+ if (end - current < 4)
+ return addError(
+ "Bad unicode escape sequence in string: four digits expected.", token,
+ current);
+ int unicode = 0;
+ for (int index = 0; index < 4; ++index) {
+ Char c = *current++;
+ unicode *= 16;
+ if (c >= '0' && c <= '9')
+ unicode += c - '0';
+ else if (c >= 'a' && c <= 'f')
+ unicode += c - 'a' + 10;
+ else if (c >= 'A' && c <= 'F')
+ unicode += c - 'A' + 10;
+ else
+ return addError(
+ "Bad unicode escape sequence in string: hexadecimal digit expected.",
+ token, current);
+ }
+ ret_unicode = static_cast<unsigned int>(unicode);
+ return true;
+}
+
+bool OurReader::addError(const String& message, Token& token, Location extra) {
+ ErrorInfo info;
+ info.token_ = token;
+ info.message_ = message;
+ info.extra_ = extra;
+ errors_.push_back(info);
+ return false;
+}
+
+bool OurReader::recoverFromError(TokenType skipUntilToken) {
+ size_t errorCount = errors_.size();
+ Token skip;
+ for (;;) {
+ if (!readToken(skip))
+ errors_.resize(errorCount); // discard errors caused by recovery
+ if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
+ break;
+ }
+ errors_.resize(errorCount);
+ return false;
+}
+
+bool OurReader::addErrorAndRecover(const String& message, Token& token,
+ TokenType skipUntilToken) {
+ addError(message, token);
+ return recoverFromError(skipUntilToken);
+}
+
+Value& OurReader::currentValue() { return *(nodes_.top()); }
+
+OurReader::Char OurReader::getNextChar() {
+ if (current_ == end_)
+ return 0;
+ return *current_++;
+}
+
+void OurReader::getLocationLineAndColumn(Location location, int& line,
+ int& column) const {
+ Location current = begin_;
+ Location lastLineStart = current;
+ line = 0;
+ while (current < location && current != end_) {
+ Char c = *current++;
+ if (c == '\r') {
+ if (*current == '\n')
+ ++current;
+ lastLineStart = current;
+ ++line;
+ } else if (c == '\n') {
+ lastLineStart = current;
+ ++line;
+ }
+ }
+ // column & line start at 1
+ column = int(location - lastLineStart) + 1;
+ ++line;
+}
+
+String OurReader::getLocationLineAndColumn(Location location) const {
+ int line, column;
+ getLocationLineAndColumn(location, line, column);
+ char buffer[18 + 16 + 16 + 1];
+ jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+ return buffer;
+}
+
+String OurReader::getFormattedErrorMessages() const {
+ String formattedMessage;
+ for (const auto& error : errors_) {
+ formattedMessage +=
+ "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+ formattedMessage += " " + error.message_ + "\n";
+ if (error.extra_)
+ formattedMessage +=
+ "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+ }
+ return formattedMessage;
+}
+
+std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
+ std::vector<OurReader::StructuredError> allErrors;
+ for (const auto& error : errors_) {
+ OurReader::StructuredError structured;
+ structured.offset_start = error.token_.start_ - begin_;
+ structured.offset_limit = error.token_.end_ - begin_;
+ structured.message = error.message_;
+ allErrors.push_back(structured);
+ }
+ return allErrors;
+}
+
+class OurCharReader : public CharReader {
+ bool const collectComments_;
+ OurReader reader_;
+
+public:
+ OurCharReader(bool collectComments, OurFeatures const& features)
+ : collectComments_(collectComments), reader_(features) {}
+ bool parse(char const* beginDoc, char const* endDoc, Value* root,
+ String* errs) override {
+ bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
+ if (errs) {
+ *errs = reader_.getFormattedErrorMessages();
+ }
+ return ok;
+ }
+};
+
+CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
+CharReaderBuilder::~CharReaderBuilder() = default;
+CharReader* CharReaderBuilder::newCharReader() const {
+ bool collectComments = settings_["collectComments"].asBool();
+ OurFeatures features = OurFeatures::all();
+ features.allowComments_ = settings_["allowComments"].asBool();
+ features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
+ features.strictRoot_ = settings_["strictRoot"].asBool();
+ features.allowDroppedNullPlaceholders_ =
+ settings_["allowDroppedNullPlaceholders"].asBool();
+ features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
+ features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
+
+ // Stack limit is always a size_t, so we get this as an unsigned int
+ // regardless of it we have 64-bit integer support enabled.
+ features.stackLimit_ = static_cast<size_t>(settings_["stackLimit"].asUInt());
+ features.failIfExtra_ = settings_["failIfExtra"].asBool();
+ features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
+ features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
+ features.skipBom_ = settings_["skipBom"].asBool();
+ return new OurCharReader(collectComments, features);
+}
+
+bool CharReaderBuilder::validate(Json::Value* invalid) const {
+ static const auto& valid_keys = *new std::set<String>{
+ "collectComments",
+ "allowComments",
+ "allowTrailingCommas",
+ "strictRoot",
+ "allowDroppedNullPlaceholders",
+ "allowNumericKeys",
+ "allowSingleQuotes",
+ "stackLimit",
+ "failIfExtra",
+ "rejectDupKeys",
+ "allowSpecialFloats",
+ "skipBom",
+ };
+ for (auto si = settings_.begin(); si != settings_.end(); ++si) {
+ auto key = si.name();
+ if (valid_keys.count(key))
+ continue;
+ if (invalid)
+ (*invalid)[std::move(key)] = *si;
+ else
+ return false;
+ }
+ return invalid ? invalid->empty() : true;
+}
+
+Value& CharReaderBuilder::operator[](const String& key) {
+ return settings_[key];
+}
+// static
+void CharReaderBuilder::strictMode(Json::Value* settings) {
+ //! [CharReaderBuilderStrictMode]
+ (*settings)["allowComments"] = false;
+ (*settings)["allowTrailingCommas"] = false;
+ (*settings)["strictRoot"] = true;
+ (*settings)["allowDroppedNullPlaceholders"] = false;
+ (*settings)["allowNumericKeys"] = false;
+ (*settings)["allowSingleQuotes"] = false;
+ (*settings)["stackLimit"] = 1000;
+ (*settings)["failIfExtra"] = true;
+ (*settings)["rejectDupKeys"] = true;
+ (*settings)["allowSpecialFloats"] = false;
+ (*settings)["skipBom"] = true;
+ //! [CharReaderBuilderStrictMode]
+}
+// static
+void CharReaderBuilder::setDefaults(Json::Value* settings) {
+ //! [CharReaderBuilderDefaults]
+ (*settings)["collectComments"] = true;
+ (*settings)["allowComments"] = true;
+ (*settings)["allowTrailingCommas"] = true;
+ (*settings)["strictRoot"] = false;
+ (*settings)["allowDroppedNullPlaceholders"] = false;
+ (*settings)["allowNumericKeys"] = false;
+ (*settings)["allowSingleQuotes"] = false;
+ (*settings)["stackLimit"] = 1000;
+ (*settings)["failIfExtra"] = false;
+ (*settings)["rejectDupKeys"] = false;
+ (*settings)["allowSpecialFloats"] = false;
+ (*settings)["skipBom"] = true;
+ //! [CharReaderBuilderDefaults]
+}
+
+//////////////////////////////////
+// global functions
+
+bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
+ String* errs) {
+ OStringStream ssin;
+ ssin << sin.rdbuf();
+ String doc = ssin.str();
+ char const* begin = doc.data();
+ char const* end = begin + doc.size();
+ // Note that we do not actually need a null-terminator.
+ CharReaderPtr const reader(fact.newCharReader());
+ return reader->parse(begin, end, root, errs);
+}
+
+IStream& operator>>(IStream& sin, Value& root) {
+ CharReaderBuilder b;
+ String errs;
+ bool ok = parseFromStream(b, sin, &root, &errs);
+ if (!ok) {
+ throwRuntimeError(errs);
}
return sin;
}
diff --git a/src/lib_json/json_tool.h b/src/lib_json/json_tool.h
index f9b61c3..2d7b7d9 100644
--- a/src/lib_json/json_tool.h
+++ b/src/lib_json/json_tool.h
@@ -1,4 +1,4 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
@@ -6,6 +6,19 @@
#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+#if !defined(JSON_IS_AMALGAMATION)
+#include <json/config.h>
+#endif
+
+// Also support old flag NO_LOCALE_SUPPORT
+#ifdef NO_LOCALE_SUPPORT
+#define JSONCPP_NO_LOCALE_SUPPORT
+#endif
+
+#ifndef JSONCPP_NO_LOCALE_SUPPORT
+#include <clocale>
+#endif
+
/* This header provides common string manipulation support, such as UTF-8,
* portable conversion from/to string...
*
@@ -13,10 +26,18 @@
*/
namespace Json {
+static inline char getDecimalPoint() {
+#ifdef JSONCPP_NO_LOCALE_SUPPORT
+ return '\0';
+#else
+ struct lconv* lc = localeconv();
+ return lc ? *(lc->decimal_point) : '\0';
+#endif
+}
/// Converts a unicode code-point to UTF-8.
-static inline std::string codePointToUTF8(unsigned int cp) {
- std::string result;
+static inline String codePointToUTF8(unsigned int cp) {
+ String result;
// based on description from http://en.wikipedia.org/wiki/UTF-8
@@ -30,8 +51,8 @@
} else if (cp <= 0xFFFF) {
result.resize(3);
result[2] = static_cast<char>(0x80 | (0x3f & cp));
- result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
- result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
+ result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+ result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
} else if (cp <= 0x10FFFF) {
result.resize(4);
result[3] = static_cast<char>(0x80 | (0x3f & cp));
@@ -43,9 +64,6 @@
return result;
}
-/// Returns true if ch is a control character (in range [0,32[).
-static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
-
enum {
/// Constant that specify the size of the buffer that must be passed to
/// uintToString.
@@ -53,17 +71,17 @@
};
// Defines a char buffer for use with uintToString().
-typedef char UIntToStringBuffer[uintToStringBufferSize];
+using UIntToStringBuffer = char[uintToStringBufferSize];
/** Converts an unsigned integer to string.
- * @param value Unsigned interger to convert to string
+ * @param value Unsigned integer to convert to string
* @param current Input/Output string buffer.
* Must have at least uintToStringBufferSize chars free.
*/
static inline void uintToString(LargestUInt value, char*& current) {
*--current = 0;
do {
- *--current = char(value % 10) + '0';
+ *--current = static_cast<char>(value % 10U + static_cast<unsigned>('0'));
value /= 10;
} while (value != 0);
}
@@ -73,15 +91,44 @@
* We had a sophisticated way, but it did not work in WinCE.
* @see https://github.com/open-source-parsers/jsoncpp/pull/9
*/
-static inline void fixNumericLocale(char* begin, char* end) {
- while (begin < end) {
+template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) {
+ for (; begin != end; ++begin) {
if (*begin == ',') {
*begin = '.';
}
- ++begin;
+ }
+ return begin;
+}
+
+template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) {
+ char decimalPoint = getDecimalPoint();
+ if (decimalPoint == '\0' || decimalPoint == '.') {
+ return;
+ }
+ for (; begin != end; ++begin) {
+ if (*begin == '.') {
+ *begin = decimalPoint;
+ }
}
}
-} // namespace Json {
+/**
+ * Return iterator that would be the new end of the range [begin,end), if we
+ * were to delete zeros in the end of string, but not the last zero before '.'.
+ */
+template <typename Iter> Iter fixZerosInTheEnd(Iter begin, Iter end) {
+ for (; begin != end; --end) {
+ if (*(end - 1) != '0') {
+ return end;
+ }
+ // Don't delete the last zero before the decimal point.
+ if (begin != (end - 1) && *(end - 2) == '.') {
+ return end;
+ }
+ }
+ return end;
+}
+
+} // namespace Json
#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
diff --git a/src/lib_json/json_value.cpp b/src/lib_json/json_value.cpp
index b73deac..0872ff5 100644
--- a/src/lib_json/json_value.cpp
+++ b/src/lib_json/json_value.cpp
@@ -1,4 +1,4 @@
-// Copyright 2011 Baptiste Lepilleur
+// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
@@ -7,23 +7,55 @@
#include <json/assertions.h>
#include <json/value.h>
#include <json/writer.h>
-#ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-#include "json_batchallocator.h"
-#endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <math.h>
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <iostream>
#include <sstream>
#include <utility>
-#include <cstring>
-#include <cassert>
-#ifdef JSON_USE_CPPTL
-#include <cpptl/conststring.h>
+
+// Provide implementation equivalent of std::snprintf for older _MSC compilers
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#include <stdarg.h>
+static int msvc_pre1900_c99_vsnprintf(char* outBuf, size_t size,
+ const char* format, va_list ap) {
+ int count = -1;
+ if (size != 0)
+ count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+ if (count == -1)
+ count = _vscprintf(format, ap);
+ return count;
+}
+
+int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+ const char* format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap);
+ va_end(ap);
+ return count;
+}
#endif
-#include <cstddef> // size_t
+
+// Disable warning C4702 : unreachable code
+#if defined(_MSC_VER)
+#pragma warning(disable : 4702)
+#endif
#define JSON_ASSERT_UNREACHABLE assert(false)
namespace Json {
+template <typename T>
+static std::unique_ptr<T> cloneUnique(const std::unique_ptr<T>& p) {
+ std::unique_ptr<T> r;
+ if (p) {
+ r = std::unique_ptr<T>(new T(*p));
+ }
+ return r;
+}
// This is a walkaround to avoid the static initialization of Value::null.
// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of
@@ -33,37 +65,34 @@
#else
#define ALIGNAS(byte_alignment)
#endif
-static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
-const unsigned char& kNullRef = kNull[0];
-const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
-const Int Value::minInt = Int(~(UInt(-1) / 2));
-const Int Value::maxInt = Int(UInt(-1) / 2);
-const UInt Value::maxUInt = UInt(-1);
-#if defined(JSON_HAS_INT64)
-const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2));
-const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2);
-const UInt64 Value::maxUInt64 = UInt64(-1);
-// The constant is hard-coded because some compiler have trouble
-// converting Value::maxUInt64 to a double correctly (AIX/xlC).
-// Assumes that UInt64 is a 64 bits integer.
-static const double maxUInt64AsDouble = 18446744073709551615.0;
-#endif // defined(JSON_HAS_INT64)
-const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));
-const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);
-const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
+// static
+Value const& Value::nullSingleton() {
+ static Value const nullStatic;
+ return nullStatic;
+}
-/// Unknown size marker
-static const unsigned int unknown = (unsigned)-1;
+#if JSON_USE_NULLREF
+// for backwards compatibility, we'll leave these global references around, but
+// DO NOT use them in JSONCPP library code any more!
+// static
+Value const& Value::null = Value::nullSingleton();
+
+// static
+Value const& Value::nullRef = Value::nullSingleton();
+#endif
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
- return d >= min && d <= max;
+ // The casts can lose precision, but we are looking only for
+ // an approximate range. Might fail on edge cases though. ~cdunn
+ return d >= static_cast<double>(min) && d <= static_cast<double>(max);
}
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double integerToDouble(Json::UInt64 value) {
- return static_cast<double>(Int64(value / 2)) * 2.0 + Int64(value & 1);
+ return static_cast<double>(Int64(value / 2)) * 2.0 +
+ static_cast<double>(Int64(value & 1));
}
template <typename T> static inline double integerToDouble(T value) {
@@ -83,28 +112,76 @@
* computed using strlen(value).
* @return Pointer on the duplicate instance of string.
*/
-static inline char* duplicateStringValue(const char* value,
- unsigned int length = unknown) {
- if (length == unknown)
- length = (unsigned int)strlen(value);
-
+static inline char* duplicateStringValue(const char* value, size_t length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
- if (length >= (unsigned)Value::maxInt)
+ if (length >= static_cast<size_t>(Value::maxInt))
length = Value::maxInt - 1;
- char* newString = static_cast<char*>(malloc(length + 1));
- JSON_ASSERT_MESSAGE(newString != 0,
- "in Json::Value::duplicateStringValue(): "
+ auto newString = static_cast<char*>(malloc(length + 1));
+ if (newString == nullptr) {
+ throwRuntimeError("in Json::Value::duplicateStringValue(): "
"Failed to allocate string value buffer");
+ }
memcpy(newString, value, length);
newString[length] = 0;
return newString;
}
-/** Free the string duplicated by duplicateStringValue().
+/* Record the length as a prefix.
*/
-static inline void releaseStringValue(char* value) { free(value); }
+static inline char* duplicateAndPrefixStringValue(const char* value,
+ unsigned int length) {
+ // Avoid an integer overflow in the call to malloc below by limiting length
+ // to a sane value.
+ JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
+ sizeof(unsigned) - 1U,
+ "in Json::Value::duplicateAndPrefixStringValue(): "
+ "length too big for prefixing");
+ size_t actualLength = sizeof(length) + length + 1;
+ auto newString = static_cast<char*>(malloc(actualLength));
+ if (newString == nullptr) {
+ throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
+ "Failed to allocate string value buffer");
+ }
+ *reinterpret_cast<unsigned*>(newString) = length;
+ memcpy(newString + sizeof(unsigned), value, length);
+ newString[actualLength - 1U] =
+ 0; // to avoid buffer over-run accidents by users later
+ return newString;
+}
+inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
+ unsigned* length, char const** value) {
+ if (!isPrefixed) {
+ *length = static_cast<unsigned>(strlen(prefixed));
+ *value = prefixed;
+ } else {
+ *length = *reinterpret_cast<unsigned const*>(prefixed);
+ *value = prefixed + sizeof(unsigned);
+ }
+}
+/** Free the string duplicated by
+ * duplicateStringValue()/duplicateAndPrefixStringValue().
+ */
+#if JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value) {
+ unsigned length = 0;
+ char const* valueDecoded;
+ decodePrefixedString(true, value, &length, &valueDecoded);
+ size_t const size = sizeof(unsigned) + length + 1U;
+ memset(value, 0, size);
+ free(value);
+}
+static inline void releaseStringValue(char* value, unsigned length) {
+ // length==0 => we allocated the strings memory
+ size_t size = (length == 0) ? strlen(value) : length;
+ memset(value, 0, size);
+ free(value);
+}
+#else // !JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value) { free(value); }
+static inline void releaseStringValue(char* value, unsigned) { free(value); }
+#endif // JSONCPP_USING_SECURE_MEMORY
} // namespace Json
@@ -116,41 +193,34 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_IS_AMALGAMATION)
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-#include "json_internalarray.inl"
-#include "json_internalmap.inl"
-#endif // JSON_VALUE_USE_INTERNAL_MAP
#include "json_valueiterator.inl"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::CommentInfo
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-Value::CommentInfo::CommentInfo() : comment_(0) {}
-
-Value::CommentInfo::~CommentInfo() {
- if (comment_)
- releaseStringValue(comment_);
+#if JSON_USE_EXCEPTION
+Exception::Exception(String msg) : msg_(std::move(msg)) {}
+Exception::~Exception() noexcept = default;
+char const* Exception::what() const noexcept { return msg_.c_str(); }
+RuntimeError::RuntimeError(String const& msg) : Exception(msg) {}
+LogicError::LogicError(String const& msg) : Exception(msg) {}
+JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
+ throw RuntimeError(msg);
}
-
-void Value::CommentInfo::setComment(const char* text) {
- if (comment_)
- releaseStringValue(comment_);
- JSON_ASSERT(text != 0);
- JSON_ASSERT_MESSAGE(
- text[0] == '\0' || text[0] == '/',
- "in Json::Value::setComment(): Comments must start with /");
- // It seems that /**/ style comments are acceptable as well.
- comment_ = duplicateStringValue(text);
+JSONCPP_NORETURN void throwLogicError(String const& msg) {
+ throw LogicError(msg);
}
+#else // !JSON_USE_EXCEPTION
+JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
+ std::cerr << msg << std::endl;
+ abort();
+}
+JSONCPP_NORETURN void throwLogicError(String const& msg) {
+ std::cerr << msg << std::endl;
+ abort();
+}
+#endif
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -159,29 +229,49 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-// Notes: index_ indicates if the string was allocated when
+// Notes: policy_ indicates if the string was allocated when
// a string is stored.
-Value::CZString::CZString(ArrayIndex index) : cstr_(0), index_(index) {}
+Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {}
-Value::CZString::CZString(const char* cstr, DuplicationPolicy allocate)
- : cstr_(allocate == duplicate ? duplicateStringValue(cstr) : cstr),
- index_(allocate) {}
+Value::CZString::CZString(char const* str, unsigned length,
+ DuplicationPolicy allocate)
+ : cstr_(str) {
+ // allocate != duplicate
+ storage_.policy_ = allocate & 0x3;
+ storage_.length_ = length & 0x3FFFFFFF;
+}
-Value::CZString::CZString(const CZString& other)
- : cstr_(other.index_ != noDuplication && other.cstr_ != 0
- ? duplicateStringValue(other.cstr_)
- : other.cstr_),
- index_(other.cstr_
- ? static_cast<ArrayIndex>(other.index_ == noDuplication
- ? noDuplication : duplicate)
- : other.index_) {}
+Value::CZString::CZString(const CZString& other) {
+ cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr
+ ? duplicateStringValue(other.cstr_, other.storage_.length_)
+ : other.cstr_);
+ storage_.policy_ =
+ static_cast<unsigned>(
+ other.cstr_
+ ? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
+ noDuplication
+ ? noDuplication
+ : duplicate)
+ : static_cast<DuplicationPolicy>(other.storage_.policy_)) &
+ 3U;
+ storage_.length_ = other.storage_.length_;
+}
+
+Value::CZString::CZString(CZString&& other)
+ : cstr_(other.cstr_), index_(other.index_) {
+ other.cstr_ = nullptr;
+}
Value::CZString::~CZString() {
- if (cstr_ && index_ == duplicate)
- releaseStringValue(const_cast<char*>(cstr_));
+ if (cstr_ && storage_.policy_ == duplicate) {
+ releaseStringValue(const_cast<char*>(cstr_),
+ storage_.length_ + 1U); // +1 for null terminating
+ // character for sake of
+ // completeness but not actually
+ // necessary
+ }
}
void Value::CZString::swap(CZString& other) {
@@ -189,30 +279,58 @@
std::swap(index_, other.index_);
}
-Value::CZString& Value::CZString::operator=(CZString other) {
- swap(other);
+Value::CZString& Value::CZString::operator=(const CZString& other) {
+ cstr_ = other.cstr_;
+ index_ = other.index_;
+ return *this;
+}
+
+Value::CZString& Value::CZString::operator=(CZString&& other) {
+ cstr_ = other.cstr_;
+ index_ = other.index_;
+ other.cstr_ = nullptr;
return *this;
}
bool Value::CZString::operator<(const CZString& other) const {
- if (cstr_)
- return strcmp(cstr_, other.cstr_) < 0;
- return index_ < other.index_;
+ if (!cstr_)
+ return index_ < other.index_;
+ // return strcmp(cstr_, other.cstr_) < 0;
+ // Assume both are strings.
+ unsigned this_len = this->storage_.length_;
+ unsigned other_len = other.storage_.length_;
+ unsigned min_len = std::min<unsigned>(this_len, other_len);
+ JSON_ASSERT(this->cstr_ && other.cstr_);
+ int comp = memcmp(this->cstr_, other.cstr_, min_len);
+ if (comp < 0)
+ return true;
+ if (comp > 0)
+ return false;
+ return (this_len < other_len);
}
bool Value::CZString::operator==(const CZString& other) const {
- if (cstr_)
- return strcmp(cstr_, other.cstr_) == 0;
- return index_ == other.index_;
+ if (!cstr_)
+ return index_ == other.index_;
+ // return strcmp(cstr_, other.cstr_) == 0;
+ // Assume both are strings.
+ unsigned this_len = this->storage_.length_;
+ unsigned other_len = other.storage_.length_;
+ if (this_len != other_len)
+ return false;
+ JSON_ASSERT(this->cstr_ && other.cstr_);
+ int comp = memcmp(this->cstr_, other.cstr_, this_len);
+ return comp == 0;
}
ArrayIndex Value::CZString::index() const { return index_; }
-const char* Value::CZString::c_str() const { return cstr_; }
-
-bool Value::CZString::isStaticString() const { return index_ == noDuplication; }
-
-#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+// const char* Value::CZString::c_str() const { return cstr_; }
+const char* Value::CZString::data() const { return cstr_; }
+unsigned Value::CZString::length() const { return storage_.length_; }
+bool Value::CZString::isStaticString() const {
+ return storage_.policy_ == noDuplication;
+}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -227,6 +345,7 @@
* This optimization is used in ValueInternalMap fast allocator.
*/
Value::Value(ValueType type) {
+ static char const emptyString[] = "";
initBasic(type);
switch (type) {
case nullValue:
@@ -239,21 +358,13 @@
value_.real_ = 0.0;
break;
case stringValue:
- value_.string_ = 0;
+ // allocated_ == false, so this is safe.
+ value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
break;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
case arrayValue:
case objectValue:
value_.map_ = new ObjectValues();
break;
-#else
- case arrayValue:
- value_.array_ = arrayAllocator()->newArray();
- break;
- case objectValue:
- value_.map_ = mapAllocator()->newMap();
- break;
-#endif
case booleanValue:
value_.bool_ = false;
break;
@@ -289,19 +400,22 @@
Value::Value(const char* value) {
initBasic(stringValue, true);
- value_.string_ = duplicateStringValue(value);
+ JSON_ASSERT_MESSAGE(value != nullptr,
+ "Null Value Passed to Value Constructor");
+ value_.string_ = duplicateAndPrefixStringValue(
+ value, static_cast<unsigned>(strlen(value)));
}
-Value::Value(const char* beginValue, const char* endValue) {
+Value::Value(const char* begin, const char* end) {
initBasic(stringValue, true);
value_.string_ =
- duplicateStringValue(beginValue, (unsigned int)(endValue - beginValue));
+ duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
}
-Value::Value(const std::string& value) {
+Value::Value(const String& value) {
initBasic(stringValue, true);
- value_.string_ =
- duplicateStringValue(value.c_str(), (unsigned int)value.length());
+ value_.string_ = duplicateAndPrefixStringValue(
+ value.data(), static_cast<unsigned>(value.length()));
}
Value::Value(const StaticString& value) {
@@ -309,120 +423,61 @@
value_.string_ = const_cast<char*>(value.c_str());
}
-#ifdef JSON_USE_CPPTL
-Value::Value(const CppTL::ConstString& value) {
- initBasic(stringValue, true);
- value_.string_ = duplicateStringValue(value, value.length());
-}
-#endif
-
Value::Value(bool value) {
initBasic(booleanValue);
value_.bool_ = value;
}
-Value::Value(const Value& other)
- : type_(other.type_), allocated_(false)
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- ,
- itemIsUsed_(0)
-#endif
- ,
- comments_(0), start_(other.start_), limit_(other.limit_) {
- switch (type_) {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- value_ = other.value_;
- break;
- case stringValue:
- if (other.value_.string_) {
- value_.string_ = duplicateStringValue(other.value_.string_);
- allocated_ = true;
- } else {
- value_.string_ = 0;
- allocated_ = false;
- }
- break;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- value_.map_ = new ObjectValues(*other.value_.map_);
- break;
-#else
- case arrayValue:
- value_.array_ = arrayAllocator()->newArrayCopy(*other.value_.array_);
- break;
- case objectValue:
- value_.map_ = mapAllocator()->newMapCopy(*other.value_.map_);
- break;
-#endif
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- if (other.comments_) {
- comments_ = new CommentInfo[numberOfCommentPlacement];
- for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
- const CommentInfo& otherComment = other.comments_[comment];
- if (otherComment.comment_)
- comments_[comment].setComment(otherComment.comment_);
- }
- }
+Value::Value(const Value& other) {
+ dupPayload(other);
+ dupMeta(other);
+}
+
+Value::Value(Value&& other) {
+ initBasic(nullValue);
+ swap(other);
}
Value::~Value() {
- switch (type_) {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- break;
- case stringValue:
- if (allocated_)
- releaseStringValue(value_.string_);
- break;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- delete value_.map_;
- break;
-#else
- case arrayValue:
- arrayAllocator()->destructArray(value_.array_);
- break;
- case objectValue:
- mapAllocator()->destructMap(value_.map_);
- break;
-#endif
- default:
- JSON_ASSERT_UNREACHABLE;
- }
-
- if (comments_)
- delete[] comments_;
+ releasePayload();
+ value_.uint_ = 0;
}
-Value& Value::operator=(Value other) {
- swap(other);
+Value& Value::operator=(const Value& other) {
+ Value(other).swap(*this);
return *this;
}
-void Value::swap(Value& other) {
- ValueType temp = type_;
- type_ = other.type_;
- other.type_ = temp;
+Value& Value::operator=(Value&& other) {
+ other.swap(*this);
+ return *this;
+}
+
+void Value::swapPayload(Value& other) {
+ std::swap(bits_, other.bits_);
std::swap(value_, other.value_);
- int temp2 = allocated_;
- allocated_ = other.allocated_;
- other.allocated_ = temp2;
+}
+
+void Value::copyPayload(const Value& other) {
+ releasePayload();
+ dupPayload(other);
+}
+
+void Value::swap(Value& other) {
+ swapPayload(other);
+ std::swap(comments_, other.comments_);
std::swap(start_, other.start_);
std::swap(limit_, other.limit_);
}
-ValueType Value::type() const { return type_; }
+void Value::copy(const Value& other) {
+ copyPayload(other);
+ dupMeta(other);
+}
+
+ValueType Value::type() const {
+ return static_cast<ValueType>(bits_.value_type_);
+}
int Value::compare(const Value& other) const {
if (*this < other)
@@ -433,10 +488,10 @@
}
bool Value::operator<(const Value& other) const {
- int typeDelta = type_ - other.type_;
+ int typeDelta = type() - other.type();
if (typeDelta)
- return typeDelta < 0 ? true : false;
- switch (type_) {
+ return typeDelta < 0;
+ switch (type()) {
case nullValue:
return false;
case intValue:
@@ -447,24 +502,35 @@
return value_.real_ < other.value_.real_;
case booleanValue:
return value_.bool_ < other.value_.bool_;
- case stringValue:
- return (value_.string_ == 0 && other.value_.string_) ||
- (other.value_.string_ && value_.string_ &&
- strcmp(value_.string_, other.value_.string_) < 0);
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ case stringValue: {
+ if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
+ return other.value_.string_ != nullptr;
+ }
+ unsigned this_len;
+ unsigned other_len;
+ char const* this_str;
+ char const* other_str;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+ &this_str);
+ decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
+ &other_str);
+ unsigned min_len = std::min<unsigned>(this_len, other_len);
+ JSON_ASSERT(this_str && other_str);
+ int comp = memcmp(this_str, other_str, min_len);
+ if (comp < 0)
+ return true;
+ if (comp > 0)
+ return false;
+ return (this_len < other_len);
+ }
case arrayValue:
case objectValue: {
- int delta = int(value_.map_->size() - other.value_.map_->size());
- if (delta)
- return delta < 0;
+ auto thisSize = value_.map_->size();
+ auto otherSize = other.value_.map_->size();
+ if (thisSize != otherSize)
+ return thisSize < otherSize;
return (*value_.map_) < (*other.value_.map_);
}
-#else
- case arrayValue:
- return value_.array_->compare(*(other.value_.array_)) < 0;
- case objectValue:
- return value_.map_->compare(*(other.value_.map_)) < 0;
-#endif
default:
JSON_ASSERT_UNREACHABLE;
}
@@ -478,14 +544,9 @@
bool Value::operator>(const Value& other) const { return other < *this; }
bool Value::operator==(const Value& other) const {
- // if ( type_ != other.type_ )
- // GCC 2.95.3 says:
- // attempt to take address of bit-field structure member `Json::Value::type_'
- // Beats me, but a temp solves the problem.
- int temp = other.type_;
- if (type_ != temp)
+ if (type() != other.type())
return false;
- switch (type_) {
+ switch (type()) {
case nullValue:
return true;
case intValue:
@@ -496,21 +557,28 @@
return value_.real_ == other.value_.real_;
case booleanValue:
return value_.bool_ == other.value_.bool_;
- case stringValue:
- return (value_.string_ == other.value_.string_) ||
- (other.value_.string_ && value_.string_ &&
- strcmp(value_.string_, other.value_.string_) == 0);
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ case stringValue: {
+ if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
+ return (value_.string_ == other.value_.string_);
+ }
+ unsigned this_len;
+ unsigned other_len;
+ char const* this_str;
+ char const* other_str;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+ &this_str);
+ decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
+ &other_str);
+ if (this_len != other_len)
+ return false;
+ JSON_ASSERT(this_str && other_str);
+ int comp = memcmp(this_str, other_str, this_len);
+ return comp == 0;
+ }
case arrayValue:
case objectValue:
return value_.map_->size() == other.value_.map_->size() &&
(*value_.map_) == (*other.value_.map_);
-#else
- case arrayValue:
- return value_.array_->compare(*(other.value_.array_)) == 0;
- case objectValue:
- return value_.map_->compare(*(other.value_.map_)) == 0;
-#endif
default:
JSON_ASSERT_UNREACHABLE;
}
@@ -520,17 +588,56 @@
bool Value::operator!=(const Value& other) const { return !(*this == other); }
const char* Value::asCString() const {
- JSON_ASSERT_MESSAGE(type_ == stringValue,
+ JSON_ASSERT_MESSAGE(type() == stringValue,
"in Json::Value::asCString(): requires stringValue");
- return value_.string_;
+ if (value_.string_ == nullptr)
+ return nullptr;
+ unsigned this_len;
+ char const* this_str;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+ &this_str);
+ return this_str;
}
-std::string Value::asString() const {
- switch (type_) {
+#if JSONCPP_USING_SECURE_MEMORY
+unsigned Value::getCStringLength() const {
+ JSON_ASSERT_MESSAGE(type() == stringValue,
+ "in Json::Value::asCString(): requires stringValue");
+ if (value_.string_ == 0)
+ return 0;
+ unsigned this_len;
+ char const* this_str;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+ &this_str);
+ return this_len;
+}
+#endif
+
+bool Value::getString(char const** begin, char const** end) const {
+ if (type() != stringValue)
+ return false;
+ if (value_.string_ == nullptr)
+ return false;
+ unsigned length;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
+ begin);
+ *end = *begin + length;
+ return true;
+}
+
+String Value::asString() const {
+ switch (type()) {
case nullValue:
return "";
- case stringValue:
- return value_.string_ ? value_.string_ : "";
+ case stringValue: {
+ if (value_.string_ == nullptr)
+ return "";
+ unsigned this_len;
+ char const* this_str;
+ decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+ &this_str);
+ return String(this_str, this_len);
+ }
case booleanValue:
return value_.bool_ ? "true" : "false";
case intValue:
@@ -544,14 +651,8 @@
}
}
-#ifdef JSON_USE_CPPTL
-CppTL::ConstString Value::asConstString() const {
- return CppTL::ConstString(asString().c_str());
-}
-#endif
-
Value::Int Value::asInt() const {
- switch (type_) {
+ switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
return Int(value_.int_);
@@ -573,7 +674,7 @@
}
Value::UInt Value::asUInt() const {
- switch (type_) {
+ switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
return UInt(value_.int_);
@@ -597,7 +698,7 @@
#if defined(JSON_HAS_INT64)
Value::Int64 Value::asInt64() const {
- switch (type_) {
+ switch (type()) {
case intValue:
return Int64(value_.int_);
case uintValue:
@@ -618,7 +719,7 @@
}
Value::UInt64 Value::asUInt64() const {
- switch (type_) {
+ switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
return UInt64(value_.int_);
@@ -656,7 +757,7 @@
}
double Value::asDouble() const {
- switch (type_) {
+ switch (type()) {
case intValue:
return static_cast<double>(value_.int_);
case uintValue:
@@ -678,21 +779,22 @@
}
float Value::asFloat() const {
- switch (type_) {
+ switch (type()) {
case intValue:
return static_cast<float>(value_.int_);
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<float>(value_.uint_);
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- return integerToDouble(value_.uint_);
+ // This can fail (silently?) if the value is bigger than MAX_FLOAT.
+ return static_cast<float>(integerToDouble(value_.uint_));
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
case realValue:
return static_cast<float>(value_.real_);
case nullValue:
return 0.0;
case booleanValue:
- return value_.bool_ ? 1.0f : 0.0f;
+ return value_.bool_ ? 1.0F : 0.0F;
default:
break;
}
@@ -700,17 +802,20 @@
}
bool Value::asBool() const {
- switch (type_) {
+ switch (type()) {
case booleanValue:
return value_.bool_;
case nullValue:
return false;
case intValue:
- return value_.int_ ? true : false;
+ return value_.int_ != 0;
case uintValue:
- return value_.uint_ ? true : false;
- case realValue:
- return value_.real_ ? true : false;
+ return value_.uint_ != 0;
+ case realValue: {
+ // According to JavaScript language zero or NaN is regarded as false
+ const auto value_classification = std::fpclassify(value_.real_);
+ return value_classification != FP_ZERO && value_classification != FP_NAN;
+ }
default:
break;
}
@@ -721,30 +826,30 @@
switch (other) {
case nullValue:
return (isNumeric() && asDouble() == 0.0) ||
- (type_ == booleanValue && value_.bool_ == false) ||
- (type_ == stringValue && asString() == "") ||
- (type_ == arrayValue && value_.map_->size() == 0) ||
- (type_ == objectValue && value_.map_->size() == 0) ||
- type_ == nullValue;
+ (type() == booleanValue && !value_.bool_) ||
+ (type() == stringValue && asString().empty()) ||
+ (type() == arrayValue && value_.map_->empty()) ||
+ (type() == objectValue && value_.map_->empty()) ||
+ type() == nullValue;
case intValue:
return isInt() ||
- (type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
- type_ == booleanValue || type_ == nullValue;
+ (type() == realValue && InRange(value_.real_, minInt, maxInt)) ||
+ type() == booleanValue || type() == nullValue;
case uintValue:
return isUInt() ||
- (type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
- type_ == booleanValue || type_ == nullValue;
+ (type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
+ type() == booleanValue || type() == nullValue;
case realValue:
- return isNumeric() || type_ == booleanValue || type_ == nullValue;
+ return isNumeric() || type() == booleanValue || type() == nullValue;
case booleanValue:
- return isNumeric() || type_ == booleanValue || type_ == nullValue;
+ return isNumeric() || type() == booleanValue || type() == nullValue;
case stringValue:
- return isNumeric() || type_ == booleanValue || type_ == stringValue ||
- type_ == nullValue;
+ return isNumeric() || type() == booleanValue || type() == stringValue ||
+ type() == nullValue;
case arrayValue:
- return type_ == arrayValue || type_ == nullValue;
+ return type() == arrayValue || type() == nullValue;
case objectValue:
- return type_ == objectValue || type_ == nullValue;
+ return type() == objectValue || type() == nullValue;
}
JSON_ASSERT_UNREACHABLE;
return false;
@@ -752,7 +857,7 @@
/// Number of values in array or object
ArrayIndex Value::size() const {
- switch (type_) {
+ switch (type()) {
case nullValue:
case intValue:
case uintValue:
@@ -760,7 +865,6 @@
case booleanValue:
case stringValue:
return 0;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
case arrayValue: // size of the array is highest index + 1
if (!value_.map_->empty()) {
ObjectValues::const_iterator itLast = value_.map_->end();
@@ -770,12 +874,6 @@
return 0;
case objectValue:
return ArrayIndex(value_.map_->size());
-#else
- case arrayValue:
- return Int(value_.array_->size());
- case objectValue:
- return Int(value_.map_->size());
-#endif
}
JSON_ASSERT_UNREACHABLE;
return 0; // unreachable;
@@ -783,78 +881,60 @@
bool Value::empty() const {
if (isNull() || isArray() || isObject())
- return size() == 0u;
- else
- return false;
+ return size() == 0U;
+ return false;
}
-bool Value::operator!() const { return isNull(); }
+Value::operator bool() const { return !isNull(); }
void Value::clear() {
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
- type_ == objectValue,
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue ||
+ type() == objectValue,
"in Json::Value::clear(): requires complex value");
start_ = 0;
limit_ = 0;
- switch (type_) {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ switch (type()) {
case arrayValue:
case objectValue:
value_.map_->clear();
break;
-#else
- case arrayValue:
- value_.array_->clear();
- break;
- case objectValue:
- value_.map_->clear();
- break;
-#endif
default:
break;
}
}
void Value::resize(ArrayIndex newSize) {
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::resize(): requires arrayValue");
- if (type_ == nullValue)
+ if (type() == nullValue)
*this = Value(arrayValue);
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
ArrayIndex oldSize = size();
if (newSize == 0)
clear();
else if (newSize > oldSize)
- (*this)[newSize - 1];
+ this->operator[](newSize - 1);
else {
for (ArrayIndex index = newSize; index < oldSize; ++index) {
value_.map_->erase(index);
}
- assert(size() == newSize);
+ JSON_ASSERT(size() == newSize);
}
-#else
- value_.array_->resize(newSize);
-#endif
}
Value& Value::operator[](ArrayIndex index) {
JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == arrayValue,
+ type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex): requires arrayValue");
- if (type_ == nullValue)
+ if (type() == nullValue)
*this = Value(arrayValue);
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
CZString key(index);
- ObjectValues::iterator it = value_.map_->lower_bound(key);
+ auto it = value_.map_->lower_bound(key);
if (it != value_.map_->end() && (*it).first == key)
return (*it).second;
- ObjectValues::value_type defaultValue(key, null);
+ ObjectValues::value_type defaultValue(key, nullSingleton());
it = value_.map_->insert(it, defaultValue);
return (*it).second;
-#else
- return value_.array_->resolveReference(index);
-#endif
}
Value& Value::operator[](int index) {
@@ -866,20 +946,15 @@
const Value& Value::operator[](ArrayIndex index) const {
JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == arrayValue,
+ type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
- if (type_ == nullValue)
- return null;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ if (type() == nullValue)
+ return nullSingleton();
CZString key(index);
ObjectValues::const_iterator it = value_.map_->find(key);
if (it == value_.map_->end())
- return null;
+ return nullSingleton();
return (*it).second;
-#else
- Value* value = value_.array_->find(index);
- return value ? *value : null;
-#endif
}
const Value& Value::operator[](int index) const {
@@ -889,214 +964,304 @@
return (*this)[ArrayIndex(index)];
}
-Value& Value::operator[](const char* key) {
- return resolveReference(key, false);
-}
-
void Value::initBasic(ValueType type, bool allocated) {
- type_ = type;
- allocated_ = allocated;
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- itemIsUsed_ = 0;
-#endif
- comments_ = 0;
+ setType(type);
+ setIsAllocated(allocated);
+ comments_ = Comments{};
start_ = 0;
limit_ = 0;
}
-Value& Value::resolveReference(const char* key, bool isStatic) {
+void Value::dupPayload(const Value& other) {
+ setType(other.type());
+ setIsAllocated(false);
+ switch (type()) {
+ case nullValue:
+ case intValue:
+ case uintValue:
+ case realValue:
+ case booleanValue:
+ value_ = other.value_;
+ break;
+ case stringValue:
+ if (other.value_.string_ && other.isAllocated()) {
+ unsigned len;
+ char const* str;
+ decodePrefixedString(other.isAllocated(), other.value_.string_, &len,
+ &str);
+ value_.string_ = duplicateAndPrefixStringValue(str, len);
+ setIsAllocated(true);
+ } else {
+ value_.string_ = other.value_.string_;
+ }
+ break;
+ case arrayValue:
+ case objectValue:
+ value_.map_ = new ObjectValues(*other.value_.map_);
+ break;
+ default:
+ JSON_ASSERT_UNREACHABLE;
+ }
+}
+
+void Value::releasePayload() {
+ switch (type()) {
+ case nullValue:
+ case intValue:
+ case uintValue:
+ case realValue:
+ case booleanValue:
+ break;
+ case stringValue:
+ if (isAllocated())
+ releasePrefixedStringValue(value_.string_);
+ break;
+ case arrayValue:
+ case objectValue:
+ delete value_.map_;
+ break;
+ default:
+ JSON_ASSERT_UNREACHABLE;
+ }
+}
+
+void Value::dupMeta(const Value& other) {
+ comments_ = other.comments_;
+ start_ = other.start_;
+ limit_ = other.limit_;
+}
+
+// Access an object value by name, create a null member if it does not exist.
+// @pre Type of '*this' is object or null.
+// @param key is null-terminated.
+Value& Value::resolveReference(const char* key) {
JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
+ type() == nullValue || type() == objectValue,
"in Json::Value::resolveReference(): requires objectValue");
- if (type_ == nullValue)
+ if (type() == nullValue)
*this = Value(objectValue);
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey(
- key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);
- ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
+ CZString actualKey(key, static_cast<unsigned>(strlen(key)),
+ CZString::noDuplication); // NOTE!
+ auto it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey)
return (*it).second;
- ObjectValues::value_type defaultValue(actualKey, null);
+ ObjectValues::value_type defaultValue(actualKey, nullSingleton());
it = value_.map_->insert(it, defaultValue);
Value& value = (*it).second;
return value;
-#else
- return value_.map_->resolveReference(key, isStatic);
-#endif
+}
+
+// @param key is not null-terminated.
+Value& Value::resolveReference(char const* key, char const* end) {
+ JSON_ASSERT_MESSAGE(
+ type() == nullValue || type() == objectValue,
+ "in Json::Value::resolveReference(key, end): requires objectValue");
+ if (type() == nullValue)
+ *this = Value(objectValue);
+ CZString actualKey(key, static_cast<unsigned>(end - key),
+ CZString::duplicateOnCopy);
+ auto it = value_.map_->lower_bound(actualKey);
+ if (it != value_.map_->end() && (*it).first == actualKey)
+ return (*it).second;
+
+ ObjectValues::value_type defaultValue(actualKey, nullSingleton());
+ it = value_.map_->insert(it, defaultValue);
+ Value& value = (*it).second;
+ return value;
}
Value Value::get(ArrayIndex index, const Value& defaultValue) const {
const Value* value = &((*this)[index]);
- return value == &null ? defaultValue : *value;
+ return value == &nullSingleton() ? defaultValue : *value;
}
bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
-const Value& Value::operator[](const char* key) const {
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
- "in Json::Value::operator[](char const*)const: requires objectValue");
- if (type_ == nullValue)
- return null;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey(key, CZString::noDuplication);
+Value const* Value::find(char const* begin, char const* end) const {
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+ "in Json::Value::find(begin, end): requires "
+ "objectValue or nullValue");
+ if (type() == nullValue)
+ return nullptr;
+ CZString actualKey(begin, static_cast<unsigned>(end - begin),
+ CZString::noDuplication);
ObjectValues::const_iterator it = value_.map_->find(actualKey);
if (it == value_.map_->end())
- return null;
- return (*it).second;
-#else
- const Value* value = value_.map_->find(key);
- return value ? *value : null;
-#endif
+ return nullptr;
+ return &(*it).second;
+}
+Value* Value::demand(char const* begin, char const* end) {
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+ "in Json::Value::demand(begin, end): requires "
+ "objectValue or nullValue");
+ return &resolveReference(begin, end);
+}
+const Value& Value::operator[](const char* key) const {
+ Value const* found = find(key, key + strlen(key));
+ if (!found)
+ return nullSingleton();
+ return *found;
+}
+Value const& Value::operator[](const String& key) const {
+ Value const* found = find(key.data(), key.data() + key.length());
+ if (!found)
+ return nullSingleton();
+ return *found;
}
-Value& Value::operator[](const std::string& key) {
- return (*this)[key.c_str()];
+Value& Value::operator[](const char* key) {
+ return resolveReference(key, key + strlen(key));
}
-const Value& Value::operator[](const std::string& key) const {
- return (*this)[key.c_str()];
+Value& Value::operator[](const String& key) {
+ return resolveReference(key.data(), key.data() + key.length());
}
Value& Value::operator[](const StaticString& key) {
- return resolveReference(key, true);
+ return resolveReference(key.c_str());
}
-#ifdef JSON_USE_CPPTL
-Value& Value::operator[](const CppTL::ConstString& key) {
- return (*this)[key.c_str()];
-}
+Value& Value::append(const Value& value) { return append(Value(value)); }
-const Value& Value::operator[](const CppTL::ConstString& key) const {
- return (*this)[key.c_str()];
-}
-#endif
-
-Value& Value::append(const Value& value) { return (*this)[size()] = value; }
-
-Value Value::get(const char* key, const Value& defaultValue) const {
- const Value* value = &((*this)[key]);
- return value == &null ? defaultValue : *value;
-}
-
-Value Value::get(const std::string& key, const Value& defaultValue) const {
- return get(key.c_str(), defaultValue);
-}
-
-Value Value::removeMember(const char* key) {
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
- "in Json::Value::removeMember(): requires objectValue");
- if (type_ == nullValue)
- return null;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey(key, CZString::noDuplication);
- ObjectValues::iterator it = value_.map_->find(actualKey);
- if (it == value_.map_->end())
- return null;
- Value old(it->second);
- value_.map_->erase(it);
- return old;
-#else
- Value* value = value_.map_->find(key);
- if (value) {
- Value old(*value);
- value_.map_.remove(key);
- return old;
- } else {
- return null;
+Value& Value::append(Value&& value) {
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
+ "in Json::Value::append: requires arrayValue");
+ if (type() == nullValue) {
+ *this = Value(arrayValue);
}
-#endif
+ return this->value_.map_->emplace(size(), std::move(value)).first->second;
}
-Value Value::removeMember(const std::string& key) {
- return removeMember(key.c_str());
+bool Value::insert(ArrayIndex index, const Value& newValue) {
+ return insert(index, Value(newValue));
}
-#ifdef JSON_USE_CPPTL
-Value Value::get(const CppTL::ConstString& key,
- const Value& defaultValue) const {
- return get(key.c_str(), defaultValue);
-}
-#endif
-
-bool Value::isMember(const char* key) const {
- const Value* value = &((*this)[key]);
- return value != &null;
+bool Value::insert(ArrayIndex index, Value&& newValue) {
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
+ "in Json::Value::insert: requires arrayValue");
+ ArrayIndex length = size();
+ if (index > length) {
+ return false;
+ }
+ for (ArrayIndex i = length; i > index; i--) {
+ (*this)[i] = std::move((*this)[i - 1]);
+ }
+ (*this)[index] = std::move(newValue);
+ return true;
}
-bool Value::isMember(const std::string& key) const {
- return isMember(key.c_str());
+Value Value::get(char const* begin, char const* end,
+ Value const& defaultValue) const {
+ Value const* found = find(begin, end);
+ return !found ? defaultValue : *found;
+}
+Value Value::get(char const* key, Value const& defaultValue) const {
+ return get(key, key + strlen(key), defaultValue);
+}
+Value Value::get(String const& key, Value const& defaultValue) const {
+ return get(key.data(), key.data() + key.length(), defaultValue);
}
-#ifdef JSON_USE_CPPTL
-bool Value::isMember(const CppTL::ConstString& key) const {
- return isMember(key.c_str());
+bool Value::removeMember(const char* begin, const char* end, Value* removed) {
+ if (type() != objectValue) {
+ return false;
+ }
+ CZString actualKey(begin, static_cast<unsigned>(end - begin),
+ CZString::noDuplication);
+ auto it = value_.map_->find(actualKey);
+ if (it == value_.map_->end())
+ return false;
+ if (removed)
+ *removed = std::move(it->second);
+ value_.map_->erase(it);
+ return true;
}
-#endif
+bool Value::removeMember(const char* key, Value* removed) {
+ return removeMember(key, key + strlen(key), removed);
+}
+bool Value::removeMember(String const& key, Value* removed) {
+ return removeMember(key.data(), key.data() + key.length(), removed);
+}
+void Value::removeMember(const char* key) {
+ JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+ "in Json::Value::removeMember(): requires objectValue");
+ if (type() == nullValue)
+ return;
+
+ CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
+ value_.map_->erase(actualKey);
+}
+void Value::removeMember(const String& key) { removeMember(key.c_str()); }
+
+bool Value::removeIndex(ArrayIndex index, Value* removed) {
+ if (type() != arrayValue) {
+ return false;
+ }
+ CZString key(index);
+ auto it = value_.map_->find(key);
+ if (it == value_.map_->end()) {
+ return false;
+ }
+ if (removed)
+ *removed = it->second;
+ ArrayIndex oldSize = size();
+ // shift left all items left, into the place of the "removed"
+ for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
+ CZString keey(i);
+ (*value_.map_)[keey] = (*this)[i + 1];
+ }
+ // erase the last one ("leftover")
+ CZString keyLast(oldSize - 1);
+ auto itLast = value_.map_->find(keyLast);
+ value_.map_->erase(itLast);
+ return true;
+}
+
+bool Value::isMember(char const* begin, char const* end) const {
+ Value const* value = find(begin, end);
+ return nullptr != value;
+}
+bool Value::isMember(char const* key) const {
+ return isMember(key, key + strlen(key));
+}
+bool Value::isMember(String const& key) const {
+ return isMember(key.data(), key.data() + key.length());
+}
Value::Members Value::getMemberNames() const {
JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
+ type() == nullValue || type() == objectValue,
"in Json::Value::getMemberNames(), value must be objectValue");
- if (type_ == nullValue)
+ if (type() == nullValue)
return Value::Members();
Members members;
members.reserve(value_.map_->size());
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
ObjectValues::const_iterator it = value_.map_->begin();
ObjectValues::const_iterator itEnd = value_.map_->end();
- for (; it != itEnd; ++it)
- members.push_back(std::string((*it).first.c_str()));
-#else
- ValueInternalMap::IteratorState it;
- ValueInternalMap::IteratorState itEnd;
- value_.map_->makeBeginIterator(it);
- value_.map_->makeEndIterator(itEnd);
- for (; !ValueInternalMap::equals(it, itEnd); ValueInternalMap::increment(it))
- members.push_back(std::string(ValueInternalMap::key(it)));
-#endif
+ for (; it != itEnd; ++it) {
+ members.push_back(String((*it).first.data(), (*it).first.length()));
+ }
return members;
}
-//
-//# ifdef JSON_USE_CPPTL
-// EnumMemberNames
-// Value::enumMemberNames() const
-//{
-// if ( type_ == objectValue )
-// {
-// return CppTL::Enum::any( CppTL::Enum::transform(
-// CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
-// MemberNamesTransform() ) );
-// }
-// return EnumMemberNames();
-//}
-//
-//
-// EnumValues
-// Value::enumValues() const
-//{
-// if ( type_ == objectValue || type_ == arrayValue )
-// return CppTL::Enum::anyValues( *(value_.map_),
-// CppTL::Type<const Value &>() );
-// return EnumValues();
-//}
-//
-//# endif
static bool IsIntegral(double d) {
double integral_part;
return modf(d, &integral_part) == 0.0;
}
-bool Value::isNull() const { return type_ == nullValue; }
+bool Value::isNull() const { return type() == nullValue; }
-bool Value::isBool() const { return type_ == booleanValue; }
+bool Value::isBool() const { return type() == booleanValue; }
bool Value::isInt() const {
- switch (type_) {
+ switch (type()) {
case intValue:
+#if defined(JSON_HAS_INT64)
return value_.int_ >= minInt && value_.int_ <= maxInt;
+#else
+ return true;
+#endif
case uintValue:
return value_.uint_ <= UInt(maxInt);
case realValue:
@@ -1109,11 +1274,19 @@
}
bool Value::isUInt() const {
- switch (type_) {
+ switch (type()) {
case intValue:
+#if defined(JSON_HAS_INT64)
return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+#else
+ return value_.int_ >= 0;
+#endif
case uintValue:
+#if defined(JSON_HAS_INT64)
return value_.uint_ <= maxUInt;
+#else
+ return true;
+#endif
case realValue:
return value_.real_ >= 0 && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
@@ -1125,7 +1298,7 @@
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
- switch (type_) {
+ switch (type()) {
case intValue:
return true;
case uintValue:
@@ -1145,7 +1318,7 @@
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
- switch (type_) {
+ switch (type()) {
case intValue:
return value_.int_ >= 0;
case uintValue:
@@ -1164,140 +1337,145 @@
}
bool Value::isIntegral() const {
+ switch (type()) {
+ case intValue:
+ case uintValue:
+ return true;
+ case realValue:
#if defined(JSON_HAS_INT64)
- return isInt64() || isUInt64();
+ // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+ // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+ // require the value to be strictly less than the limit.
+ return value_.real_ >= double(minInt64) &&
+ value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
#else
- return isInt() || isUInt();
-#endif
+ return value_.real_ >= minInt && value_.real_ <= maxUInt &&
+ IsIntegral(value_.real_);
+#endif // JSON_HAS_INT64
+ default:
+ break;
+ }
+ return false;
}
-bool Value::isDouble() const { return type_ == realValue || isIntegral(); }
-
-bool Value::isNumeric() const { return isIntegral() || isDouble(); }
-
-bool Value::isString() const { return type_ == stringValue; }
-
-bool Value::isArray() const { return type_ == arrayValue; }
-
-bool Value::isObject() const { return type_ == objectValue; }
-
-void Value::setComment(const char* comment, CommentPlacement placement) {
- if (!comments_)
- comments_ = new CommentInfo[numberOfCommentPlacement];
- comments_[placement].setComment(comment);
+bool Value::isDouble() const {
+ return type() == intValue || type() == uintValue || type() == realValue;
}
-void Value::setComment(const std::string& comment, CommentPlacement placement) {
- setComment(comment.c_str(), placement);
+bool Value::isNumeric() const { return isDouble(); }
+
+bool Value::isString() const { return type() == stringValue; }
+
+bool Value::isArray() const { return type() == arrayValue; }
+
+bool Value::isObject() const { return type() == objectValue; }
+
+Value::Comments::Comments(const Comments& that)
+ : ptr_{cloneUnique(that.ptr_)} {}
+
+Value::Comments::Comments(Comments&& that) : ptr_{std::move(that.ptr_)} {}
+
+Value::Comments& Value::Comments::operator=(const Comments& that) {
+ ptr_ = cloneUnique(that.ptr_);
+ return *this;
+}
+
+Value::Comments& Value::Comments::operator=(Comments&& that) {
+ ptr_ = std::move(that.ptr_);
+ return *this;
+}
+
+bool Value::Comments::has(CommentPlacement slot) const {
+ return ptr_ && !(*ptr_)[slot].empty();
+}
+
+String Value::Comments::get(CommentPlacement slot) const {
+ if (!ptr_)
+ return {};
+ return (*ptr_)[slot];
+}
+
+void Value::Comments::set(CommentPlacement slot, String comment) {
+ if (!ptr_) {
+ ptr_ = std::unique_ptr<Array>(new Array());
+ }
+ // check comments array boundry.
+ if (slot < CommentPlacement::numberOfCommentPlacement) {
+ (*ptr_)[slot] = std::move(comment);
+ }
+}
+
+void Value::setComment(String comment, CommentPlacement placement) {
+ if (!comment.empty() && (comment.back() == '\n')) {
+ // Always discard trailing newline, to aid indentation.
+ comment.pop_back();
+ }
+ JSON_ASSERT(!comment.empty());
+ JSON_ASSERT_MESSAGE(
+ comment[0] == '\0' || comment[0] == '/',
+ "in Json::Value::setComment(): Comments must start with /");
+ comments_.set(placement, std::move(comment));
}
bool Value::hasComment(CommentPlacement placement) const {
- return comments_ != 0 && comments_[placement].comment_ != 0;
+ return comments_.has(placement);
}
-std::string Value::getComment(CommentPlacement placement) const {
- if (hasComment(placement))
- return comments_[placement].comment_;
- return "";
+String Value::getComment(CommentPlacement placement) const {
+ return comments_.get(placement);
}
-void Value::setOffsetStart(size_t start) { start_ = start; }
+void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
-void Value::setOffsetLimit(size_t limit) { limit_ = limit; }
+void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
-size_t Value::getOffsetStart() const { return start_; }
+ptrdiff_t Value::getOffsetStart() const { return start_; }
-size_t Value::getOffsetLimit() const { return limit_; }
+ptrdiff_t Value::getOffsetLimit() const { return limit_; }
-std::string Value::toStyledString() const {
- StyledWriter writer;
- return writer.write(*this);
+String Value::toStyledString() const {
+ StreamWriterBuilder builder;
+
+ String out = this->hasComment(commentBefore) ? "\n" : "";
+ out += Json::writeString(builder, *this);
+ out += '\n';
+
+ return out;
}
Value::const_iterator Value::begin() const {
- switch (type_) {
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if (value_.array_) {
- ValueInternalArray::IteratorState it;
- value_.array_->makeBeginIterator(it);
- return const_iterator(it);
- }
- break;
- case objectValue:
- if (value_.map_) {
- ValueInternalMap::IteratorState it;
- value_.map_->makeBeginIterator(it);
- return const_iterator(it);
- }
- break;
-#else
+ switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->begin());
break;
-#endif
default:
break;
}
- return const_iterator();
+ return {};
}
Value::const_iterator Value::end() const {
- switch (type_) {
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if (value_.array_) {
- ValueInternalArray::IteratorState it;
- value_.array_->makeEndIterator(it);
- return const_iterator(it);
- }
- break;
- case objectValue:
- if (value_.map_) {
- ValueInternalMap::IteratorState it;
- value_.map_->makeEndIterator(it);
- return const_iterator(it);
- }
- break;
-#else
+ switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->end());
break;
-#endif
default:
break;
}
- return const_iterator();
+ return {};
}
Value::iterator Value::begin() {
- switch (type_) {
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if (value_.array_) {
- ValueInternalArray::IteratorState it;
- value_.array_->makeBeginIterator(it);
- return iterator(it);
- }
- break;
- case objectValue:
- if (value_.map_) {
- ValueInternalMap::IteratorState it;
- value_.map_->makeBeginIterator(it);
- return iterator(it);
- }
- break;
-#else
+ switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->begin());
break;
-#endif
default:
break;
}
@@ -1305,29 +1483,12 @@
}
Value::iterator Value::end() {
- switch (type_) {
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if (value_.array_) {
- ValueInternalArray::IteratorState it;
- value_.array_->makeEndIterator(it);
- return iterator(it);
- }
- break;
- case objectValue:
- if (value_.map_) {
- ValueInternalMap::IteratorState it;
- value_.map_->makeEndIterator(it);
- return iterator(it);
- }
- break;
-#else
+ switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->end());
break;
-#endif
default:
break;
}
@@ -1337,27 +1498,23 @@
// class PathArgument
// //////////////////////////////////////////////////////////////////
-PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
+PathArgument::PathArgument() = default;
PathArgument::PathArgument(ArrayIndex index)
- : key_(), index_(index), kind_(kindIndex) {}
+ : index_(index), kind_(kindIndex) {}
-PathArgument::PathArgument(const char* key)
- : key_(key), index_(), kind_(kindKey) {}
+PathArgument::PathArgument(const char* key) : key_(key), kind_(kindKey) {}
-PathArgument::PathArgument(const std::string& key)
- : key_(key.c_str()), index_(), kind_(kindKey) {}
+PathArgument::PathArgument(String key) : key_(std::move(key)), kind_(kindKey) {}
// class Path
// //////////////////////////////////////////////////////////////////
-Path::Path(const std::string& path,
- const PathArgument& a1,
- const PathArgument& a2,
- const PathArgument& a3,
- const PathArgument& a4,
+Path::Path(const String& path, const PathArgument& a1, const PathArgument& a2,
+ const PathArgument& a3, const PathArgument& a4,
const PathArgument& a5) {
InArgs in;
+ in.reserve(5);
in.push_back(&a1);
in.push_back(&a2);
in.push_back(&a3);
@@ -1366,10 +1523,10 @@
makePath(path, in);
}
-void Path::makePath(const std::string& path, const InArgs& in) {
+void Path::makePath(const String& path, const InArgs& in) {
const char* current = path.c_str();
const char* end = current + path.length();
- InArgs::const_iterator itInArg = in.begin();
+ auto itInArg = in.begin();
while (current != end) {
if (*current == '[') {
++current;
@@ -1381,24 +1538,23 @@
index = index * 10 + ArrayIndex(*current - '0');
args_.push_back(index);
}
- if (current == end || *current++ != ']')
+ if (current == end || *++current != ']')
invalidPath(path, int(current - path.c_str()));
} else if (*current == '%') {
addPathInArg(path, in, itInArg, PathArgument::kindKey);
++current;
- } else if (*current == '.') {
+ } else if (*current == '.' || *current == ']') {
++current;
} else {
const char* beginName = current;
while (current != end && !strchr("[.", *current))
++current;
- args_.push_back(std::string(beginName, current));
+ args_.push_back(String(beginName, current));
}
}
}
-void Path::addPathInArg(const std::string& /*path*/,
- const InArgs& in,
+void Path::addPathInArg(const String& /*path*/, const InArgs& in,
InArgs::const_iterator& itInArg,
PathArgument::Kind kind) {
if (itInArg == in.end()) {
@@ -1406,31 +1562,33 @@
} else if ((*itInArg)->kind_ != kind) {
// Error: bad argument type
} else {
- args_.push_back(**itInArg);
+ args_.push_back(**itInArg++);
}
}
-void Path::invalidPath(const std::string& /*path*/, int /*location*/) {
+void Path::invalidPath(const String& /*path*/, int /*location*/) {
// Error: invalid path.
}
const Value& Path::resolve(const Value& root) const {
const Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
+ for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_)) {
- // Error: unable to resolve path (array value expected at position...
+ // Error: unable to resolve path (array value expected at position... )
+ return Value::nullSingleton();
}
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject()) {
// Error: unable to resolve path (object value expected at position...)
+ return Value::nullSingleton();
}
node = &((*node)[arg.key_]);
- if (node == &Value::null) {
+ if (node == &Value::nullSingleton()) {
// Error: unable to resolve path (object has no member named '' at
// position...)
+ return Value::nullSingleton();
}
}
}
@@ -1439,8 +1597,7 @@
Value Path::resolve(const Value& root, const Value& defaultValue) const {
const Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
+ for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_))
return defaultValue;
@@ -1449,7 +1606,7 @@
if (!node->isObject())
return defaultValue;
node = &((*node)[arg.key_]);
- if (node == &Value::null)
+ if (node == &Value::nullSingleton())
return defaultValue;
}
}
@@ -1458,8 +1615,7 @@
Value& Path::make(Value& root) const {
Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
+ for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray()) {
// Error: node is not an array at position ...
diff --git a/src/lib_json/json_valueiterator.inl b/src/lib_json/json_valueiterator.inl
index a9f7df6..d6128b8 100644
--- a/src/lib_json/json_valueiterator.inl
+++ b/src/lib_json/json_valueiterator.inl
@@ -1,4 +1,4 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
@@ -15,70 +15,21 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-ValueIteratorBase::ValueIteratorBase()
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- : current_(), isNull_(true) {
-}
-#else
- : isArray_(true), isNull_(true) {
- iterator_.array_ = ValueInternalArray::IteratorState();
-}
-#endif
+ValueIteratorBase::ValueIteratorBase() : current_() {}
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
ValueIteratorBase::ValueIteratorBase(
const Value::ObjectValues::iterator& current)
: current_(current), isNull_(false) {}
-#else
-ValueIteratorBase::ValueIteratorBase(
- const ValueInternalArray::IteratorState& state)
- : isArray_(true) {
- iterator_.array_ = state;
-}
-ValueIteratorBase::ValueIteratorBase(
- const ValueInternalMap::IteratorState& state)
- : isArray_(false) {
- iterator_.map_ = state;
-}
-#endif
+Value& ValueIteratorBase::deref() { return current_->second; }
+const Value& ValueIteratorBase::deref() const { return current_->second; }
-Value& ValueIteratorBase::deref() const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- return current_->second;
-#else
- if (isArray_)
- return ValueInternalArray::dereference(iterator_.array_);
- return ValueInternalMap::value(iterator_.map_);
-#endif
-}
+void ValueIteratorBase::increment() { ++current_; }
-void ValueIteratorBase::increment() {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- ++current_;
-#else
- if (isArray_)
- ValueInternalArray::increment(iterator_.array_);
- ValueInternalMap::increment(iterator_.map_);
-#endif
-}
-
-void ValueIteratorBase::decrement() {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- --current_;
-#else
- if (isArray_)
- ValueInternalArray::decrement(iterator_.array_);
- ValueInternalMap::decrement(iterator_.map_);
-#endif
-}
+void ValueIteratorBase::decrement() { --current_; }
ValueIteratorBase::difference_type
ValueIteratorBase::computeDistance(const SelfType& other) const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-#ifdef JSON_USE_CPPTL_SMALLMAP
- return current_ - other.current_;
-#else
// Iterator for null value are initialized using the default
// constructor, which initialize current_ to the default
// std::map::iterator. As begin() and end() are two instance
@@ -99,81 +50,59 @@
++myDistance;
}
return myDistance;
-#endif
-#else
- if (isArray_)
- return ValueInternalArray::distance(iterator_.array_,
- other.iterator_.array_);
- return ValueInternalMap::distance(iterator_.map_, other.iterator_.map_);
-#endif
}
bool ValueIteratorBase::isEqual(const SelfType& other) const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
if (isNull_) {
return other.isNull_;
}
return current_ == other.current_;
-#else
- if (isArray_)
- return ValueInternalArray::equals(iterator_.array_, other.iterator_.array_);
- return ValueInternalMap::equals(iterator_.map_, other.iterator_.map_);
-#endif
}
void ValueIteratorBase::copy(const SelfType& other) {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
current_ = other.current_;
isNull_ = other.isNull_;
-#else
- if (isArray_)
- iterator_.array_ = other.iterator_.array_;
- iterator_.map_ = other.iterator_.map_;
-#endif
}
Value ValueIteratorBase::key() const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
const Value::CZString czstring = (*current_).first;
- if (czstring.c_str()) {
+ if (czstring.data()) {
if (czstring.isStaticString())
- return Value(StaticString(czstring.c_str()));
- return Value(czstring.c_str());
+ return Value(StaticString(czstring.data()));
+ return Value(czstring.data(), czstring.data() + czstring.length());
}
return Value(czstring.index());
-#else
- if (isArray_)
- return Value(ValueInternalArray::indexOf(iterator_.array_));
- bool isStatic;
- const char* memberName = ValueInternalMap::key(iterator_.map_, isStatic);
- if (isStatic)
- return Value(StaticString(memberName));
- return Value(memberName);
-#endif
}
UInt ValueIteratorBase::index() const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
const Value::CZString czstring = (*current_).first;
- if (!czstring.c_str())
+ if (!czstring.data())
return czstring.index();
return Value::UInt(-1);
-#else
- if (isArray_)
- return Value::UInt(ValueInternalArray::indexOf(iterator_.array_));
- return Value::UInt(-1);
-#endif
}
-const char* ValueIteratorBase::memberName() const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
- const char* name = (*current_).first.c_str();
- return name ? name : "";
-#else
- if (!isArray_)
- return ValueInternalMap::key(iterator_.map_);
- return "";
-#endif
+String ValueIteratorBase::name() const {
+ char const* keey;
+ char const* end;
+ keey = memberName(&end);
+ if (!keey)
+ return String();
+ return String(keey, end);
+}
+
+char const* ValueIteratorBase::memberName() const {
+ const char* cname = (*current_).first.data();
+ return cname ? cname : "";
+}
+
+char const* ValueIteratorBase::memberName(char const** end) const {
+ const char* cname = (*current_).first.data();
+ if (!cname) {
+ *end = nullptr;
+ return nullptr;
+ }
+ *end = cname + (*current_).first.length();
+ return cname;
}
// //////////////////////////////////////////////////////////////////
@@ -184,21 +113,14 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-ValueConstIterator::ValueConstIterator() {}
+ValueConstIterator::ValueConstIterator() = default;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
ValueConstIterator::ValueConstIterator(
const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
-#else
-ValueConstIterator::ValueConstIterator(
- const ValueInternalArray::IteratorState& state)
- : ValueIteratorBase(state) {}
-ValueConstIterator::ValueConstIterator(
- const ValueInternalMap::IteratorState& state)
- : ValueIteratorBase(state) {}
-#endif
+ValueConstIterator::ValueConstIterator(ValueIterator const& other)
+ : ValueIteratorBase(other) {}
ValueConstIterator& ValueConstIterator::
operator=(const ValueIteratorBase& other) {
@@ -214,24 +136,17 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-ValueIterator::ValueIterator() {}
+ValueIterator::ValueIterator() = default;
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
-#else
-ValueIterator::ValueIterator(const ValueInternalArray::IteratorState& state)
- : ValueIteratorBase(state) {}
-
-ValueIterator::ValueIterator(const ValueInternalMap::IteratorState& state)
- : ValueIteratorBase(state) {}
-#endif
ValueIterator::ValueIterator(const ValueConstIterator& other)
- : ValueIteratorBase(other) {}
+ : ValueIteratorBase(other) {
+ throwRuntimeError("ConstIterator to Iterator should never be allowed.");
+}
-ValueIterator::ValueIterator(const ValueIterator& other)
- : ValueIteratorBase(other) {}
+ValueIterator::ValueIterator(const ValueIterator& other) = default;
ValueIterator& ValueIterator::operator=(const SelfType& other) {
copy(other);
diff --git a/src/lib_json/json_writer.cpp b/src/lib_json/json_writer.cpp
index 89964ea..8bf02db 100644
--- a/src/lib_json/json_writer.cpp
+++ b/src/lib_json/json_writer.cpp
@@ -1,55 +1,113 @@
-// Copyright 2011 Baptiste Lepilleur
+// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
-#include <json/writer.h>
#include "json_tool.h"
+#include <json/writer.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <utility>
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <sstream>
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <cstring>
#include <iomanip>
-#include <math.h>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <utility>
-#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
-#include <float.h>
-#define isfinite _finite
-#define snprintf _snprintf
+#if __cplusplus >= 201103L
+#include <cmath>
+#include <cstdio>
+
+#if !defined(isnan)
+#define isnan std::isnan
#endif
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#if !defined(isfinite)
+#define isfinite std::isfinite
+#endif
+
+#else
+#include <cmath>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#if !defined(isnan)
+#include <float.h>
+#define isnan _isnan
+#endif
+
+#if !defined(isfinite)
+#include <float.h>
+#define isfinite _finite
+#endif
+
+#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
+#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
+#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+
+#endif //_MSC_VER
+
+#if defined(__sun) && defined(__SVR4) // Solaris
+#if !defined(isfinite)
+#include <ieeefp.h>
+#define isfinite finite
+#endif
+#endif
+
+#if defined(__hpux)
+#if !defined(isfinite)
+#if defined(__ia64) && !defined(finite)
+#define isfinite(x) \
+ ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
+#endif
+#endif
+#endif
+
+#if !defined(isnan)
+// IEEE standard states that NaN values will not compare to themselves
+#define isnan(x) (x != x)
+#endif
+
+#if !defined(__APPLE__)
+#if !defined(isfinite)
+#define isfinite finite
+#endif
+#endif
+#endif
+
+#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
namespace Json {
-static bool containsControlCharacter(const char* str) {
- while (*str) {
- if (isControlCharacter(*(str++)))
- return true;
- }
- return false;
-}
+#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
+using StreamWriterPtr = std::unique_ptr<StreamWriter>;
+#else
+using StreamWriterPtr = std::auto_ptr<StreamWriter>;
+#endif
-std::string valueToString(LargestInt value) {
+String valueToString(LargestInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
- bool isNegative = value < 0;
- if (isNegative)
- value = -value;
- uintToString(LargestUInt(value), current);
- if (isNegative)
+ if (value == Value::minLargestInt) {
+ uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
*--current = '-';
+ } else if (value < 0) {
+ uintToString(LargestUInt(-value), current);
+ *--current = '-';
+ } else {
+ uintToString(LargestUInt(value), current);
+ }
assert(current >= buffer);
return current;
}
-std::string valueToString(LargestUInt value) {
+String valueToString(LargestUInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
uintToString(value, current);
@@ -59,71 +117,175 @@
#if defined(JSON_HAS_INT64)
-std::string valueToString(Int value) {
- return valueToString(LargestInt(value));
-}
+String valueToString(Int value) { return valueToString(LargestInt(value)); }
-std::string valueToString(UInt value) {
- return valueToString(LargestUInt(value));
-}
+String valueToString(UInt value) { return valueToString(LargestUInt(value)); }
#endif // # if defined(JSON_HAS_INT64)
-std::string valueToString(double value) {
- // Allocate a buffer that is more than large enough to store the 16 digits of
- // precision requested below.
- char buffer[32];
- int len = -1;
-
-// Print into the buffer. We need not request the alternative representation
-// that always has a decimal point because JSON doesn't distingish the
-// concepts of reals and integers.
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
- // visual studio 2005 to
- // avoid warning.
-#if defined(WINCE)
- len = _snprintf(buffer, sizeof(buffer), "%.16g", value);
-#else
- len = sprintf_s(buffer, sizeof(buffer), "%.16g", value);
-#endif
-#else
- if (isfinite(value)) {
- len = snprintf(buffer, sizeof(buffer), "%.16g", value);
- } else {
- // IEEE standard states that NaN values will not compare to themselves
- if (value != value) {
- len = snprintf(buffer, sizeof(buffer), "null");
- } else if (value < 0) {
- len = snprintf(buffer, sizeof(buffer), "-1e+9999");
- } else {
- len = snprintf(buffer, sizeof(buffer), "1e+9999");
- }
- // For those, we do not need to call fixNumLoc, but it is fast.
+namespace {
+String valueToString(double value, bool useSpecialFloats,
+ unsigned int precision, PrecisionType precisionType) {
+ // Print into the buffer. We need not request the alternative representation
+ // that always has a decimal point because JSON doesn't distinguish the
+ // concepts of reals and integers.
+ if (!isfinite(value)) {
+ static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
+ {"null", "-1e+9999", "1e+9999"}};
+ return reps[useSpecialFloats ? 0 : 1]
+ [isnan(value) ? 0 : (value < 0) ? 1 : 2];
}
-#endif
- assert(len >= 0);
- fixNumericLocale(buffer, buffer + len);
+
+ String buffer(size_t(36), '\0');
+ while (true) {
+ int len = jsoncpp_snprintf(
+ &*buffer.begin(), buffer.size(),
+ (precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f",
+ precision, value);
+ assert(len >= 0);
+ auto wouldPrint = static_cast<size_t>(len);
+ if (wouldPrint >= buffer.size()) {
+ buffer.resize(wouldPrint + 1);
+ continue;
+ }
+ buffer.resize(wouldPrint);
+ break;
+ }
+
+ buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end());
+
+ // strip the zero padding from the right
+ if (precisionType == PrecisionType::decimalPlaces) {
+ buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end()), buffer.end());
+ }
+
+ // try to ensure we preserve the fact that this was given to us as a double on
+ // input
+ if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) {
+ buffer += ".0";
+ }
return buffer;
}
+} // namespace
-std::string valueToString(bool value) { return value ? "true" : "false"; }
+String valueToString(double value, unsigned int precision,
+ PrecisionType precisionType) {
+ return valueToString(value, false, precision, precisionType);
+}
-std::string valueToQuotedString(const char* value) {
- if (value == NULL)
+String valueToString(bool value) { return value ? "true" : "false"; }
+
+static bool doesAnyCharRequireEscaping(char const* s, size_t n) {
+ assert(s || !n);
+
+ return std::any_of(s, s + n, [](unsigned char c) {
+ return c == '\\' || c == '"' || c < 0x20 || c > 0x7F;
+ });
+}
+
+static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
+ const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
+
+ unsigned int firstByte = static_cast<unsigned char>(*s);
+
+ if (firstByte < 0x80)
+ return firstByte;
+
+ if (firstByte < 0xE0) {
+ if (e - s < 2)
+ return REPLACEMENT_CHARACTER;
+
+ unsigned int calculated =
+ ((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
+ s += 1;
+ // oversized encoded characters are invalid
+ return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
+ }
+
+ if (firstByte < 0xF0) {
+ if (e - s < 3)
+ return REPLACEMENT_CHARACTER;
+
+ unsigned int calculated = ((firstByte & 0x0F) << 12) |
+ ((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
+ (static_cast<unsigned int>(s[2]) & 0x3F);
+ s += 2;
+ // surrogates aren't valid codepoints itself
+ // shouldn't be UTF-8 encoded
+ if (calculated >= 0xD800 && calculated <= 0xDFFF)
+ return REPLACEMENT_CHARACTER;
+ // oversized encoded characters are invalid
+ return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
+ }
+
+ if (firstByte < 0xF8) {
+ if (e - s < 4)
+ return REPLACEMENT_CHARACTER;
+
+ unsigned int calculated = ((firstByte & 0x07) << 18) |
+ ((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
+ ((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
+ (static_cast<unsigned int>(s[3]) & 0x3F);
+ s += 3;
+ // oversized encoded characters are invalid
+ return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
+ }
+
+ return REPLACEMENT_CHARACTER;
+}
+
+static const char hex2[] = "000102030405060708090a0b0c0d0e0f"
+ "101112131415161718191a1b1c1d1e1f"
+ "202122232425262728292a2b2c2d2e2f"
+ "303132333435363738393a3b3c3d3e3f"
+ "404142434445464748494a4b4c4d4e4f"
+ "505152535455565758595a5b5c5d5e5f"
+ "606162636465666768696a6b6c6d6e6f"
+ "707172737475767778797a7b7c7d7e7f"
+ "808182838485868788898a8b8c8d8e8f"
+ "909192939495969798999a9b9c9d9e9f"
+ "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
+ "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+ "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
+ "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+ "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
+ "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+static String toHex16Bit(unsigned int x) {
+ const unsigned int hi = (x >> 8) & 0xff;
+ const unsigned int lo = x & 0xff;
+ String result(4, ' ');
+ result[0] = hex2[2 * hi];
+ result[1] = hex2[2 * hi + 1];
+ result[2] = hex2[2 * lo];
+ result[3] = hex2[2 * lo + 1];
+ return result;
+}
+
+static void appendRaw(String& result, unsigned ch) {
+ result += static_cast<char>(ch);
+}
+
+static void appendHex(String& result, unsigned ch) {
+ result.append("\\u").append(toHex16Bit(ch));
+}
+
+static String valueToQuotedStringN(const char* value, unsigned length,
+ bool emitUTF8 = false) {
+ if (value == nullptr)
return "";
- // Not sure how to handle unicode...
- if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL &&
- !containsControlCharacter(value))
- return std::string("\"") + value + "\"";
+
+ if (!doesAnyCharRequireEscaping(value, length))
+ return String("\"") + value + "\"";
// We have to walk value and escape any special characters.
- // Appending to std::string is not efficient, but this should be rare.
+ // Appending to String is not efficient, but this should be rare.
// (Note: forward slashes are *not* rare, but I am not escaping them.)
- std::string::size_type maxsize =
- strlen(value) * 2 + 3; // allescaped+quotes+NULL
- std::string result;
+ String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
+ String result;
result.reserve(maxsize); // to avoid lots of mallocs
result += "\"";
- for (const char* c = value; *c != 0; ++c) {
+ char const* end = value + length;
+ for (const char* c = value; c != end; ++c) {
switch (*c) {
case '\"':
result += "\\\"";
@@ -149,49 +311,68 @@
// case '/':
// Even though \/ is considered a legal escape in JSON, a bare
// slash is also legal, so I see no reason to escape it.
- // (I hope I am not misunderstanding something.
+ // (I hope I am not misunderstanding something.)
// blep notes: actually escaping \/ may be useful in javascript to avoid </
// sequence.
// Should add a flag to allow this compatibility mode and prevent this
// sequence from occurring.
- default:
- if (isControlCharacter(*c)) {
- std::ostringstream oss;
- oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
- << std::setw(4) << static_cast<int>(*c);
- result += oss.str();
+ default: {
+ if (emitUTF8) {
+ unsigned codepoint = static_cast<unsigned char>(*c);
+ if (codepoint < 0x20) {
+ appendHex(result, codepoint);
+ } else {
+ appendRaw(result, codepoint);
+ }
} else {
- result += *c;
+ unsigned codepoint = utf8ToCodepoint(c, end); // modifies `c`
+ if (codepoint < 0x20) {
+ appendHex(result, codepoint);
+ } else if (codepoint < 0x80) {
+ appendRaw(result, codepoint);
+ } else if (codepoint < 0x10000) {
+ // Basic Multilingual Plane
+ appendHex(result, codepoint);
+ } else {
+ // Extended Unicode. Encode 20 bits as a surrogate pair.
+ codepoint -= 0x10000;
+ appendHex(result, 0xd800 + ((codepoint >> 10) & 0x3ff));
+ appendHex(result, 0xdc00 + (codepoint & 0x3ff));
+ }
}
- break;
+ } break;
}
}
result += "\"";
return result;
}
+String valueToQuotedString(const char* value) {
+ return valueToQuotedStringN(value, static_cast<unsigned int>(strlen(value)));
+}
+
// Class Writer
// //////////////////////////////////////////////////////////////////
-Writer::~Writer() {}
+Writer::~Writer() = default;
// Class FastWriter
// //////////////////////////////////////////////////////////////////
FastWriter::FastWriter()
- : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
- omitEndingLineFeed_(false) {}
-void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
+ = default;
+
+void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; }
void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
-std::string FastWriter::write(const Value& root) {
- document_ = "";
+String FastWriter::write(const Value& root) {
+ document_.clear();
writeValue(root);
if (!omitEndingLineFeed_)
- document_ += "\n";
+ document_ += '\n';
return document_;
}
@@ -210,16 +391,22 @@
case realValue:
document_ += valueToString(value.asDouble());
break;
- case stringValue:
- document_ += valueToQuotedString(value.asCString());
+ case stringValue: {
+ // Is NULL possible for value.string_? No.
+ char const* str;
+ char const* end;
+ bool ok = value.getString(&str, &end);
+ if (ok)
+ document_ += valueToQuotedStringN(str, static_cast<unsigned>(end - str));
break;
+ }
case booleanValue:
document_ += valueToString(value.asBool());
break;
case arrayValue: {
document_ += '[';
- int size = value.size();
- for (int index = 0; index < size; ++index) {
+ ArrayIndex size = value.size();
+ for (ArrayIndex index = 0; index < size; ++index) {
if (index > 0)
document_ += ',';
writeValue(value[index]);
@@ -229,13 +416,13 @@
case objectValue: {
Value::Members members(value.getMemberNames());
document_ += '{';
- for (Value::Members::iterator it = members.begin(); it != members.end();
- ++it) {
- const std::string& name = *it;
+ for (auto it = members.begin(); it != members.end(); ++it) {
+ const String& name = *it;
if (it != members.begin())
document_ += ',';
- document_ += valueToQuotedString(name.c_str());
- document_ += yamlCompatiblityEnabled_ ? ": " : ":";
+ document_ += valueToQuotedStringN(name.data(),
+ static_cast<unsigned>(name.length()));
+ document_ += yamlCompatibilityEnabled_ ? ": " : ":";
writeValue(value[name]);
}
document_ += '}';
@@ -246,17 +433,16 @@
// Class StyledWriter
// //////////////////////////////////////////////////////////////////
-StyledWriter::StyledWriter()
- : rightMargin_(74), indentSize_(3), addChildValues_() {}
+StyledWriter::StyledWriter() = default;
-std::string StyledWriter::write(const Value& root) {
- document_ = "";
+String StyledWriter::write(const Value& root) {
+ document_.clear();
addChildValues_ = false;
- indentString_ = "";
+ indentString_.clear();
writeCommentBeforeValue(root);
writeValue(root);
writeCommentAfterValueOnSameLine(root);
- document_ += "\n";
+ document_ += '\n';
return document_;
}
@@ -274,9 +460,17 @@
case realValue:
pushValue(valueToString(value.asDouble()));
break;
- case stringValue:
- pushValue(valueToQuotedString(value.asCString()));
+ case stringValue: {
+ // Is NULL possible for value.string_? No.
+ char const* str;
+ char const* end;
+ bool ok = value.getString(&str, &end);
+ if (ok)
+ pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
+ else
+ pushValue("");
break;
+ }
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
@@ -290,9 +484,9 @@
else {
writeWithIndent("{");
indent();
- Value::Members::iterator it = members.begin();
+ auto it = members.begin();
for (;;) {
- const std::string& name = *it;
+ const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
@@ -317,7 +511,7 @@
if (size == 0)
pushValue("[]");
else {
- bool isArrayMultiLine = isMultineArray(value);
+ bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
@@ -355,24 +549,26 @@
}
}
-bool StyledWriter::isMultineArray(const Value& value) {
- int size = value.size();
+bool StyledWriter::isMultilineArray(const Value& value) {
+ ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
- for (int index = 0; index < size && !isMultiLine; ++index) {
+ for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
- isMultiLine =
- isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0);
+ isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+ !childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
- int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
- for (int index = 0; index < size; ++index) {
+ ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+ for (ArrayIndex index = 0; index < size; ++index) {
+ if (hasCommentForValue(value[index])) {
+ isMultiLine = true;
+ }
writeValue(value[index]);
- lineLength += int(childValues_[index].length());
+ lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
@@ -380,7 +576,7 @@
return isMultiLine;
}
-void StyledWriter::pushValue(const std::string& value) {
+void StyledWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
@@ -398,15 +594,15 @@
document_ += indentString_;
}
-void StyledWriter::writeWithIndent(const std::string& value) {
+void StyledWriter::writeWithIndent(const String& value) {
writeIndent();
document_ += value;
}
-void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); }
+void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); }
void StyledWriter::unindent() {
- assert(int(indentString_.size()) >= indentSize_);
+ assert(indentString_.size() >= indentSize_);
indentString_.resize(indentString_.size() - indentSize_);
}
@@ -414,29 +610,29 @@
if (!root.hasComment(commentBefore))
return;
- document_ += "\n";
+ document_ += '\n';
writeIndent();
- std::string normalizedComment = normalizeEOL(root.getComment(commentBefore));
- std::string::const_iterator iter = normalizedComment.begin();
- while (iter != normalizedComment.end()) {
+ const String& comment = root.getComment(commentBefore);
+ String::const_iterator iter = comment.begin();
+ while (iter != comment.end()) {
document_ += *iter;
- if (*iter == '\n' && *(iter + 1) == '/')
+ if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
writeIndent();
++iter;
}
- // Comments are stripped of newlines, so add one here
- document_ += "\n";
+ // Comments are stripped of trailing newlines, so add one here
+ document_ += '\n';
}
void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
- document_ += " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
+ document_ += " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
- document_ += "\n";
- document_ += normalizeEOL(root.getComment(commentAfter));
- document_ += "\n";
+ document_ += '\n';
+ document_ += root.getComment(commentAfter);
+ document_ += '\n';
}
}
@@ -446,41 +642,26 @@
value.hasComment(commentAfter);
}
-std::string StyledWriter::normalizeEOL(const std::string& text) {
- std::string normalized;
- normalized.reserve(text.length());
- const char* begin = text.c_str();
- const char* end = begin + text.length();
- const char* current = begin;
- while (current != end) {
- char c = *current++;
- if (c == '\r') // mac or dos EOL
- {
- if (*current == '\n') // convert dos EOL
- ++current;
- normalized += '\n';
- } else // handle unix EOL & other char
- normalized += c;
- }
- return normalized;
-}
-
// Class StyledStreamWriter
// //////////////////////////////////////////////////////////////////
-StyledStreamWriter::StyledStreamWriter(std::string indentation)
- : document_(NULL), rightMargin_(74), indentation_(indentation),
- addChildValues_() {}
+StyledStreamWriter::StyledStreamWriter(String indentation)
+ : document_(nullptr), indentation_(std::move(indentation)),
+ addChildValues_(), indented_(false) {}
-void StyledStreamWriter::write(std::ostream& out, const Value& root) {
+void StyledStreamWriter::write(OStream& out, const Value& root) {
document_ = &out;
addChildValues_ = false;
- indentString_ = "";
+ indentString_.clear();
+ indented_ = true;
writeCommentBeforeValue(root);
+ if (!indented_)
+ writeIndent();
+ indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*document_ << "\n";
- document_ = NULL; // Forget the stream, for safety.
+ document_ = nullptr; // Forget the stream, for safety.
}
void StyledStreamWriter::writeValue(const Value& value) {
@@ -497,9 +678,17 @@
case realValue:
pushValue(valueToString(value.asDouble()));
break;
- case stringValue:
- pushValue(valueToQuotedString(value.asCString()));
+ case stringValue: {
+ // Is NULL possible for value.string_? No.
+ char const* str;
+ char const* end;
+ bool ok = value.getString(&str, &end);
+ if (ok)
+ pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
+ else
+ pushValue("");
break;
+ }
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
@@ -513,9 +702,9 @@
else {
writeWithIndent("{");
indent();
- Value::Members::iterator it = members.begin();
+ auto it = members.begin();
for (;;) {
- const std::string& name = *it;
+ const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
@@ -540,7 +729,7 @@
if (size == 0)
pushValue("[]");
else {
- bool isArrayMultiLine = isMultineArray(value);
+ bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
@@ -552,8 +741,11 @@
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
- writeIndent();
+ if (!indented_)
+ writeIndent();
+ indented_ = true;
writeValue(childValue);
+ indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
@@ -578,24 +770,26 @@
}
}
-bool StyledStreamWriter::isMultineArray(const Value& value) {
- int size = value.size();
+bool StyledStreamWriter::isMultilineArray(const Value& value) {
+ ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
- for (int index = 0; index < size && !isMultiLine; ++index) {
+ for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
- isMultiLine =
- isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0);
+ isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+ !childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
- int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
- for (int index = 0; index < size; ++index) {
+ ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+ for (ArrayIndex index = 0; index < size; ++index) {
+ if (hasCommentForValue(value[index])) {
+ isMultiLine = true;
+ }
writeValue(value[index]);
- lineLength += int(childValues_[index].length());
+ lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
@@ -603,7 +797,7 @@
return isMultiLine;
}
-void StyledStreamWriter::pushValue(const std::string& value) {
+void StyledStreamWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
@@ -611,24 +805,18 @@
}
void StyledStreamWriter::writeIndent() {
- /*
- Some comments in this method would have been nice. ;-)
-
- if ( !document_.empty() )
- {
- char last = document_[document_.length()-1];
- if ( last == ' ' ) // already indented
- return;
- if ( last != '\n' ) // Comments may add new-line
- *document_ << '\n';
- }
- */
+ // blep intended this to look at the so-far-written string
+ // to determine whether we are already indented, but
+ // with a stream we cannot do that. So we rely on some saved state.
+ // The caller checks indented_.
*document_ << '\n' << indentString_;
}
-void StyledStreamWriter::writeWithIndent(const std::string& value) {
- writeIndent();
+void StyledStreamWriter::writeWithIndent(const String& value) {
+ if (!indented_)
+ writeIndent();
*document_ << value;
+ indented_ = false;
}
void StyledStreamWriter::indent() { indentString_ += indentation_; }
@@ -641,19 +829,30 @@
void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
if (!root.hasComment(commentBefore))
return;
- *document_ << normalizeEOL(root.getComment(commentBefore));
- *document_ << "\n";
+
+ if (!indented_)
+ writeIndent();
+ const String& comment = root.getComment(commentBefore);
+ String::const_iterator iter = comment.begin();
+ while (iter != comment.end()) {
+ *document_ << *iter;
+ if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
+ // writeIndent(); // would include newline
+ *document_ << indentString_;
+ ++iter;
+ }
+ indented_ = false;
}
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
- *document_ << " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
+ *document_ << ' ' << root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
- *document_ << "\n";
- *document_ << normalizeEOL(root.getComment(commentAfter));
- *document_ << "\n";
+ writeIndent();
+ *document_ << root.getComment(commentAfter);
}
+ indented_ = false;
}
bool StyledStreamWriter::hasCommentForValue(const Value& value) {
@@ -662,28 +861,397 @@
value.hasComment(commentAfter);
}
-std::string StyledStreamWriter::normalizeEOL(const std::string& text) {
- std::string normalized;
- normalized.reserve(text.length());
- const char* begin = text.c_str();
- const char* end = begin + text.length();
- const char* current = begin;
- while (current != end) {
- char c = *current++;
- if (c == '\r') // mac or dos EOL
- {
- if (*current == '\n') // convert dos EOL
- ++current;
- normalized += '\n';
- } else // handle unix EOL & other char
- normalized += c;
+//////////////////////////
+// BuiltStyledStreamWriter
+
+/// Scoped enums are not available until C++11.
+struct CommentStyle {
+ /// Decide whether to write comments.
+ enum Enum {
+ None, ///< Drop all comments.
+ Most, ///< Recover odd behavior of previous versions (not implemented yet).
+ All ///< Keep all comments.
+ };
+};
+
+struct BuiltStyledStreamWriter : public StreamWriter {
+ BuiltStyledStreamWriter(String indentation, CommentStyle::Enum cs,
+ String colonSymbol, String nullSymbol,
+ String endingLineFeedSymbol, bool useSpecialFloats,
+ bool emitUTF8, unsigned int precision,
+ PrecisionType precisionType);
+ int write(Value const& root, OStream* sout) override;
+
+private:
+ void writeValue(Value const& value);
+ void writeArrayValue(Value const& value);
+ bool isMultilineArray(Value const& value);
+ void pushValue(String const& value);
+ void writeIndent();
+ void writeWithIndent(String const& value);
+ void indent();
+ void unindent();
+ void writeCommentBeforeValue(Value const& root);
+ void writeCommentAfterValueOnSameLine(Value const& root);
+ static bool hasCommentForValue(const Value& value);
+
+ using ChildValues = std::vector<String>;
+
+ ChildValues childValues_;
+ String indentString_;
+ unsigned int rightMargin_;
+ String indentation_;
+ CommentStyle::Enum cs_;
+ String colonSymbol_;
+ String nullSymbol_;
+ String endingLineFeedSymbol_;
+ bool addChildValues_ : 1;
+ bool indented_ : 1;
+ bool useSpecialFloats_ : 1;
+ bool emitUTF8_ : 1;
+ unsigned int precision_;
+ PrecisionType precisionType_;
+};
+BuiltStyledStreamWriter::BuiltStyledStreamWriter(
+ String indentation, CommentStyle::Enum cs, String colonSymbol,
+ String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
+ bool emitUTF8, unsigned int precision, PrecisionType precisionType)
+ : rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
+ colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
+ endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
+ addChildValues_(false), indented_(false),
+ useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
+ precision_(precision), precisionType_(precisionType) {}
+int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
+ sout_ = sout;
+ addChildValues_ = false;
+ indented_ = true;
+ indentString_.clear();
+ writeCommentBeforeValue(root);
+ if (!indented_)
+ writeIndent();
+ indented_ = true;
+ writeValue(root);
+ writeCommentAfterValueOnSameLine(root);
+ *sout_ << endingLineFeedSymbol_;
+ sout_ = nullptr;
+ return 0;
+}
+void BuiltStyledStreamWriter::writeValue(Value const& value) {
+ switch (value.type()) {
+ case nullValue:
+ pushValue(nullSymbol_);
+ break;
+ case intValue:
+ pushValue(valueToString(value.asLargestInt()));
+ break;
+ case uintValue:
+ pushValue(valueToString(value.asLargestUInt()));
+ break;
+ case realValue:
+ pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
+ precisionType_));
+ break;
+ case stringValue: {
+ // Is NULL is possible for value.string_? No.
+ char const* str;
+ char const* end;
+ bool ok = value.getString(&str, &end);
+ if (ok)
+ pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str),
+ emitUTF8_));
+ else
+ pushValue("");
+ break;
}
- return normalized;
+ case booleanValue:
+ pushValue(valueToString(value.asBool()));
+ break;
+ case arrayValue:
+ writeArrayValue(value);
+ break;
+ case objectValue: {
+ Value::Members members(value.getMemberNames());
+ if (members.empty())
+ pushValue("{}");
+ else {
+ writeWithIndent("{");
+ indent();
+ auto it = members.begin();
+ for (;;) {
+ String const& name = *it;
+ Value const& childValue = value[name];
+ writeCommentBeforeValue(childValue);
+ writeWithIndent(valueToQuotedStringN(
+ name.data(), static_cast<unsigned>(name.length()), emitUTF8_));
+ *sout_ << colonSymbol_;
+ writeValue(childValue);
+ if (++it == members.end()) {
+ writeCommentAfterValueOnSameLine(childValue);
+ break;
+ }
+ *sout_ << ",";
+ writeCommentAfterValueOnSameLine(childValue);
+ }
+ unindent();
+ writeWithIndent("}");
+ }
+ } break;
+ }
}
-std::ostream& operator<<(std::ostream& sout, const Value& root) {
- Json::StyledStreamWriter writer;
- writer.write(sout, root);
+void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
+ unsigned size = value.size();
+ if (size == 0)
+ pushValue("[]");
+ else {
+ bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value);
+ if (isMultiLine) {
+ writeWithIndent("[");
+ indent();
+ bool hasChildValue = !childValues_.empty();
+ unsigned index = 0;
+ for (;;) {
+ Value const& childValue = value[index];
+ writeCommentBeforeValue(childValue);
+ if (hasChildValue)
+ writeWithIndent(childValues_[index]);
+ else {
+ if (!indented_)
+ writeIndent();
+ indented_ = true;
+ writeValue(childValue);
+ indented_ = false;
+ }
+ if (++index == size) {
+ writeCommentAfterValueOnSameLine(childValue);
+ break;
+ }
+ *sout_ << ",";
+ writeCommentAfterValueOnSameLine(childValue);
+ }
+ unindent();
+ writeWithIndent("]");
+ } else // output on a single line
+ {
+ assert(childValues_.size() == size);
+ *sout_ << "[";
+ if (!indentation_.empty())
+ *sout_ << " ";
+ for (unsigned index = 0; index < size; ++index) {
+ if (index > 0)
+ *sout_ << ((!indentation_.empty()) ? ", " : ",");
+ *sout_ << childValues_[index];
+ }
+ if (!indentation_.empty())
+ *sout_ << " ";
+ *sout_ << "]";
+ }
+ }
+}
+
+bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
+ ArrayIndex const size = value.size();
+ bool isMultiLine = size * 3 >= rightMargin_;
+ childValues_.clear();
+ for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
+ Value const& childValue = value[index];
+ isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+ !childValue.empty());
+ }
+ if (!isMultiLine) // check if line length > max line length
+ {
+ childValues_.reserve(size);
+ addChildValues_ = true;
+ ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+ for (ArrayIndex index = 0; index < size; ++index) {
+ if (hasCommentForValue(value[index])) {
+ isMultiLine = true;
+ }
+ writeValue(value[index]);
+ lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+ }
+ addChildValues_ = false;
+ isMultiLine = isMultiLine || lineLength >= rightMargin_;
+ }
+ return isMultiLine;
+}
+
+void BuiltStyledStreamWriter::pushValue(String const& value) {
+ if (addChildValues_)
+ childValues_.push_back(value);
+ else
+ *sout_ << value;
+}
+
+void BuiltStyledStreamWriter::writeIndent() {
+ // blep intended this to look at the so-far-written string
+ // to determine whether we are already indented, but
+ // with a stream we cannot do that. So we rely on some saved state.
+ // The caller checks indented_.
+
+ if (!indentation_.empty()) {
+ // In this case, drop newlines too.
+ *sout_ << '\n' << indentString_;
+ }
+}
+
+void BuiltStyledStreamWriter::writeWithIndent(String const& value) {
+ if (!indented_)
+ writeIndent();
+ *sout_ << value;
+ indented_ = false;
+}
+
+void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
+
+void BuiltStyledStreamWriter::unindent() {
+ assert(indentString_.size() >= indentation_.size());
+ indentString_.resize(indentString_.size() - indentation_.size());
+}
+
+void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
+ if (cs_ == CommentStyle::None)
+ return;
+ if (!root.hasComment(commentBefore))
+ return;
+
+ if (!indented_)
+ writeIndent();
+ const String& comment = root.getComment(commentBefore);
+ String::const_iterator iter = comment.begin();
+ while (iter != comment.end()) {
+ *sout_ << *iter;
+ if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
+ // writeIndent(); // would write extra newline
+ *sout_ << indentString_;
+ ++iter;
+ }
+ indented_ = false;
+}
+
+void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
+ Value const& root) {
+ if (cs_ == CommentStyle::None)
+ return;
+ if (root.hasComment(commentAfterOnSameLine))
+ *sout_ << " " + root.getComment(commentAfterOnSameLine);
+
+ if (root.hasComment(commentAfter)) {
+ writeIndent();
+ *sout_ << root.getComment(commentAfter);
+ }
+}
+
+// static
+bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
+ return value.hasComment(commentBefore) ||
+ value.hasComment(commentAfterOnSameLine) ||
+ value.hasComment(commentAfter);
+}
+
+///////////////
+// StreamWriter
+
+StreamWriter::StreamWriter() : sout_(nullptr) {}
+StreamWriter::~StreamWriter() = default;
+StreamWriter::Factory::~Factory() = default;
+StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); }
+StreamWriterBuilder::~StreamWriterBuilder() = default;
+StreamWriter* StreamWriterBuilder::newStreamWriter() const {
+ const String indentation = settings_["indentation"].asString();
+ const String cs_str = settings_["commentStyle"].asString();
+ const String pt_str = settings_["precisionType"].asString();
+ const bool eyc = settings_["enableYAMLCompatibility"].asBool();
+ const bool dnp = settings_["dropNullPlaceholders"].asBool();
+ const bool usf = settings_["useSpecialFloats"].asBool();
+ const bool emitUTF8 = settings_["emitUTF8"].asBool();
+ unsigned int pre = settings_["precision"].asUInt();
+ CommentStyle::Enum cs = CommentStyle::All;
+ if (cs_str == "All") {
+ cs = CommentStyle::All;
+ } else if (cs_str == "None") {
+ cs = CommentStyle::None;
+ } else {
+ throwRuntimeError("commentStyle must be 'All' or 'None'");
+ }
+ PrecisionType precisionType(significantDigits);
+ if (pt_str == "significant") {
+ precisionType = PrecisionType::significantDigits;
+ } else if (pt_str == "decimal") {
+ precisionType = PrecisionType::decimalPlaces;
+ } else {
+ throwRuntimeError("precisionType must be 'significant' or 'decimal'");
+ }
+ String colonSymbol = " : ";
+ if (eyc) {
+ colonSymbol = ": ";
+ } else if (indentation.empty()) {
+ colonSymbol = ":";
+ }
+ String nullSymbol = "null";
+ if (dnp) {
+ nullSymbol.clear();
+ }
+ if (pre > 17)
+ pre = 17;
+ String endingLineFeedSymbol;
+ return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
+ endingLineFeedSymbol, usf, emitUTF8, pre,
+ precisionType);
+}
+
+bool StreamWriterBuilder::validate(Json::Value* invalid) const {
+ static const auto& valid_keys = *new std::set<String>{
+ "indentation",
+ "commentStyle",
+ "enableYAMLCompatibility",
+ "dropNullPlaceholders",
+ "useSpecialFloats",
+ "emitUTF8",
+ "precision",
+ "precisionType",
+ };
+ for (auto si = settings_.begin(); si != settings_.end(); ++si) {
+ auto key = si.name();
+ if (valid_keys.count(key))
+ continue;
+ if (invalid)
+ (*invalid)[std::move(key)] = *si;
+ else
+ return false;
+ }
+ return invalid ? invalid->empty() : true;
+}
+
+Value& StreamWriterBuilder::operator[](const String& key) {
+ return settings_[key];
+}
+// static
+void StreamWriterBuilder::setDefaults(Json::Value* settings) {
+ //! [StreamWriterBuilderDefaults]
+ (*settings)["commentStyle"] = "All";
+ (*settings)["indentation"] = "\t";
+ (*settings)["enableYAMLCompatibility"] = false;
+ (*settings)["dropNullPlaceholders"] = false;
+ (*settings)["useSpecialFloats"] = false;
+ (*settings)["emitUTF8"] = false;
+ (*settings)["precision"] = 17;
+ (*settings)["precisionType"] = "significant";
+ //! [StreamWriterBuilderDefaults]
+}
+
+String writeString(StreamWriter::Factory const& factory, Value const& root) {
+ OStringStream sout;
+ StreamWriterPtr const writer(factory.newStreamWriter());
+ writer->write(root, &sout);
+ return sout.str();
+}
+
+OStream& operator<<(OStream& sout, Value const& root) {
+ StreamWriterBuilder builder;
+ StreamWriterPtr const writer(builder.newStreamWriter());
+ writer->write(root, &sout);
return sout;
}
diff --git a/src/lib_json/sconscript b/src/lib_json/sconscript
deleted file mode 100644
index 6e7c6c8..0000000
--- a/src/lib_json/sconscript
+++ /dev/null
@@ -1,8 +0,0 @@
-Import( 'env buildLibrary' )
-
-buildLibrary( env, Split( """
- json_reader.cpp
- json_value.cpp
- json_writer.cpp
- """ ),
- 'json' )
diff --git a/src/lib_json/version.h.in b/src/lib_json/version.h.in
deleted file mode 100644
index 761ca3a..0000000
--- a/src/lib_json/version.h.in
+++ /dev/null
@@ -1,14 +0,0 @@
-// DO NOT EDIT. This file is generated by CMake from "version"
-// and "version.h.in" files.
-// Run CMake configure step to update it.
-#ifndef JSON_VERSION_H_INCLUDED
-# define JSON_VERSION_H_INCLUDED
-
-# define JSONCPP_VERSION_STRING "@JSONCPP_VERSION@"
-# define JSONCPP_VERSION_MAJOR @JSONCPP_VERSION_MAJOR@
-# define JSONCPP_VERSION_MINOR @JSONCPP_VERSION_MINOR@
-# define JSONCPP_VERSION_PATCH @JSONCPP_VERSION_PATCH@
-# define JSONCPP_VERSION_QUALIFIER
-# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
-
-#endif // JSON_VERSION_H_INCLUDED
diff --git a/src/test_lib_json/CMakeLists.txt b/src/test_lib_json/CMakeLists.txt
index 420d659..1c3fce9 100644
--- a/src/test_lib_json/CMakeLists.txt
+++ b/src/test_lib_json/CMakeLists.txt
@@ -1,22 +1,39 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
-IF(JSONCPP_LIB_BUILD_SHARED)
- ADD_DEFINITIONS( -DJSON_DLL )
-ENDIF(JSONCPP_LIB_BUILD_SHARED)
+add_executable(jsoncpp_test
+ jsontest.cpp
+ jsontest.h
+ fuzz.cpp
+ fuzz.h
+ main.cpp
+)
-ADD_EXECUTABLE( jsoncpp_test
- jsontest.cpp
- jsontest.h
- main.cpp
- )
-TARGET_LINK_LIBRARIES(jsoncpp_test jsoncpp_lib)
+if(BUILD_SHARED_LIBS)
+ if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+ add_compile_definitions( JSON_DLL )
+ else()
+ add_definitions( -DJSON_DLL )
+ endif()
+ target_link_libraries(jsoncpp_test jsoncpp_lib)
+else()
+ target_link_libraries(jsoncpp_test jsoncpp_static)
+endif()
+
+# another way to solve issue #90
+#set_target_properties(jsoncpp_test PROPERTIES COMPILE_FLAGS -ffloat-store)
+
+## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
+add_test(NAME jsoncpp_test
+ COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+)
+set_target_properties(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test)
# Run unit tests in post-build
# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
-IF(JSONCPP_WITH_POST_BUILD_UNITTEST)
- ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
- POST_BUILD
- COMMAND $<TARGET_FILE:jsoncpp_test>)
-ENDIF(JSONCPP_WITH_POST_BUILD_UNITTEST)
-
-SET_TARGET_PROPERTIES(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test)
+if(JSONCPP_WITH_POST_BUILD_UNITTEST)
+ add_custom_command(TARGET jsoncpp_test
+ POST_BUILD
+ COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+ )
+endif()
diff --git a/src/test_lib_json/fuzz.cpp b/src/test_lib_json/fuzz.cpp
new file mode 100644
index 0000000..5b75c22
--- /dev/null
+++ b/src/test_lib_json/fuzz.cpp
@@ -0,0 +1,54 @@
+// Copyright 2007-2019 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#include "fuzz.h"
+
+#include <cstdint>
+#include <json/config.h>
+#include <json/json.h>
+#include <memory>
+#include <string>
+
+namespace Json {
+class Exception;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ Json::CharReaderBuilder builder;
+
+ if (size < sizeof(uint32_t)) {
+ return 0;
+ }
+
+ const uint32_t hash_settings = static_cast<uint32_t>(data[0]) |
+ (static_cast<uint32_t>(data[1]) << 8) |
+ (static_cast<uint32_t>(data[2]) << 16) |
+ (static_cast<uint32_t>(data[3]) << 24);
+ data += sizeof(uint32_t);
+ size -= sizeof(uint32_t);
+
+ builder.settings_["failIfExtra"] = hash_settings & (1 << 0);
+ builder.settings_["allowComments_"] = hash_settings & (1 << 1);
+ builder.settings_["strictRoot_"] = hash_settings & (1 << 2);
+ builder.settings_["allowDroppedNullPlaceholders_"] = hash_settings & (1 << 3);
+ builder.settings_["allowNumericKeys_"] = hash_settings & (1 << 4);
+ builder.settings_["allowSingleQuotes_"] = hash_settings & (1 << 5);
+ builder.settings_["failIfExtra_"] = hash_settings & (1 << 6);
+ builder.settings_["rejectDupKeys_"] = hash_settings & (1 << 7);
+ builder.settings_["allowSpecialFloats_"] = hash_settings & (1 << 8);
+ builder.settings_["collectComments"] = hash_settings & (1 << 9);
+ builder.settings_["allowTrailingCommas_"] = hash_settings & (1 << 10);
+
+ std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+
+ Json::Value root;
+ const auto data_str = reinterpret_cast<const char*>(data);
+ try {
+ reader->parse(data_str, data_str + size, &root, nullptr);
+ } catch (Json::Exception const&) {
+ }
+ // Whether it succeeded or not doesn't matter.
+ return 0;
+}
diff --git a/src/test_lib_json/fuzz.dict b/src/test_lib_json/fuzz.dict
new file mode 100644
index 0000000..725423d
--- /dev/null
+++ b/src/test_lib_json/fuzz.dict
@@ -0,0 +1,54 @@
+#
+# AFL dictionary for JSON
+# -----------------------
+#
+# Just the very basics.
+#
+# Inspired by a dictionary by Jakub Wilk <jwilk@jwilk.net>
+#
+# https://github.com/rc0r/afl-fuzz/blob/master/dictionaries/json.dict
+#
+
+"0"
+",0"
+":0"
+"0:"
+"-1.2e+3"
+
+"true"
+"false"
+"null"
+
+"\"\""
+",\"\""
+":\"\""
+"\"\":"
+
+"{}"
+",{}"
+":{}"
+"{\"\":0}"
+"{{}}"
+
+"[]"
+",[]"
+":[]"
+"[0]"
+"[[]]"
+
+"''"
+"\\"
+"\\b"
+"\\f"
+"\\n"
+"\\r"
+"\\t"
+"\\u0000"
+"\\x00"
+"\\0"
+"\\uD800\\uDC00"
+"\\uDBFF\\uDFFF"
+
+"\"\":0"
+"//"
+"/**/"
diff --git a/src/test_lib_json/fuzz.h b/src/test_lib_json/fuzz.h
new file mode 100644
index 0000000..0816d27
--- /dev/null
+++ b/src/test_lib_json/fuzz.h
@@ -0,0 +1,14 @@
+// Copyright 2007-2010 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef FUZZ_H_INCLUDED
+#define FUZZ_H_INCLUDED
+
+#include <cstddef>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+#endif // ifndef FUZZ_H_INCLUDED
diff --git a/src/test_lib_json/jsontest.cpp b/src/test_lib_json/jsontest.cpp
index ef9c543..0b7d12b 100644
--- a/src/test_lib_json/jsontest.cpp
+++ b/src/test_lib_json/jsontest.cpp
@@ -1,11 +1,11 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
#include "jsontest.h"
-#include <stdio.h>
+#include <cstdio>
#include <string>
#if defined(_MSC_VER)
@@ -73,28 +73,27 @@
// class TestResult
// //////////////////////////////////////////////////////////////////
-TestResult::TestResult()
- : predicateId_(1), lastUsedPredicateId_(0), messageTarget_(0) {
+TestResult::TestResult() {
// The root predicate has id 0
rootPredicateNode_.id_ = 0;
- rootPredicateNode_.next_ = 0;
+ rootPredicateNode_.next_ = nullptr;
predicateStackTail_ = &rootPredicateNode_;
}
-void TestResult::setTestName(const std::string& name) { name_ = name; }
+void TestResult::setTestName(const Json::String& name) { name_ = name; }
-TestResult&
-TestResult::addFailure(const char* file, unsigned int line, const char* expr) {
+TestResult& TestResult::addFailure(const char* file, unsigned int line,
+ const char* expr) {
/// Walks the PredicateContext stack adding them to failures_ if not already
/// added.
unsigned int nestingLevel = 0;
PredicateContext* lastNode = rootPredicateNode_.next_;
- for (; lastNode != 0; lastNode = lastNode->next_) {
+ for (; lastNode != nullptr; lastNode = lastNode->next_) {
if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
{
lastUsedPredicateId_ = lastNode->id_;
- addFailureInfo(
- lastNode->file_, lastNode->line_, lastNode->expr_, nestingLevel);
+ addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,
+ nestingLevel);
// Link the PredicateContext to the failure for message target when
// popping the PredicateContext.
lastNode->failure_ = &(failures_.back());
@@ -108,10 +107,8 @@
return *this;
}
-void TestResult::addFailureInfo(const char* file,
- unsigned int line,
- const char* expr,
- unsigned int nestingLevel) {
+void TestResult::addFailureInfo(const char* file, unsigned int line,
+ const char* expr, unsigned int nestingLevel) {
Failure failure;
failure.file_ = file;
failure.line_ = line;
@@ -124,32 +121,22 @@
TestResult& TestResult::popPredicateContext() {
PredicateContext* lastNode = &rootPredicateNode_;
- while (lastNode->next_ != 0 && lastNode->next_->next_ != 0) {
+ while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {
lastNode = lastNode->next_;
}
// Set message target to popped failure
PredicateContext* tail = lastNode->next_;
- if (tail != 0 && tail->failure_ != 0) {
+ if (tail != nullptr && tail->failure_ != nullptr) {
messageTarget_ = tail->failure_;
}
// Remove tail from list
predicateStackTail_ = lastNode;
- lastNode->next_ = 0;
+ lastNode->next_ = nullptr;
return *this;
}
bool TestResult::failed() const { return !failures_.empty(); }
-unsigned int TestResult::getAssertionNestingLevel() const {
- unsigned int level = 0;
- const PredicateContext* lastNode = &rootPredicateNode_;
- while (lastNode->next_ != 0) {
- lastNode = lastNode->next_;
- ++level;
- }
- return level;
-}
-
void TestResult::printFailure(bool printTestName) const {
if (failures_.empty()) {
return;
@@ -160,12 +147,10 @@
}
// Print in reverse to display the callstack in the right order
- Failures::const_iterator itEnd = failures_.end();
- for (Failures::const_iterator it = failures_.begin(); it != itEnd; ++it) {
- const Failure& failure = *it;
- std::string indent(failure.nestingLevel_ * 2, ' ');
+ for (const auto& failure : failures_) {
+ Json::String indent(failure.nestingLevel_ * 2, ' ');
if (failure.file_) {
- printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);
+ printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);
}
if (!failure.expr_.empty()) {
printf("%s\n", failure.expr_.c_str());
@@ -173,19 +158,19 @@
printf("\n");
}
if (!failure.message_.empty()) {
- std::string reindented = indentText(failure.message_, indent + " ");
+ Json::String reindented = indentText(failure.message_, indent + " ");
printf("%s\n", reindented.c_str());
}
}
}
-std::string TestResult::indentText(const std::string& text,
- const std::string& indent) {
- std::string reindented;
- std::string::size_type lastIndex = 0;
+Json::String TestResult::indentText(const Json::String& text,
+ const Json::String& indent) {
+ Json::String reindented;
+ Json::String::size_type lastIndex = 0;
while (lastIndex < text.size()) {
- std::string::size_type nextIndex = text.find('\n', lastIndex);
- if (nextIndex == std::string::npos) {
+ Json::String::size_type nextIndex = text.find('\n', lastIndex);
+ if (nextIndex == Json::String::npos) {
nextIndex = text.size() - 1;
}
reindented += indent;
@@ -195,8 +180,8 @@
return reindented;
}
-TestResult& TestResult::addToLastFailure(const std::string& message) {
- if (messageTarget_ != 0) {
+TestResult& TestResult::addToLastFailure(const Json::String& message) {
+ if (messageTarget_ != nullptr) {
messageTarget_->message_ += message;
}
return *this;
@@ -217,9 +202,9 @@
// class TestCase
// //////////////////////////////////////////////////////////////////
-TestCase::TestCase() : result_(0) {}
+TestCase::TestCase() = default;
-TestCase::~TestCase() {}
+TestCase::~TestCase() = default;
void TestCase::run(TestResult& result) {
result_ = &result;
@@ -229,25 +214,23 @@
// class Runner
// //////////////////////////////////////////////////////////////////
-Runner::Runner() {}
+Runner::Runner() = default;
Runner& Runner::add(TestCaseFactory factory) {
tests_.push_back(factory);
return *this;
}
-unsigned int Runner::testCount() const {
- return static_cast<unsigned int>(tests_.size());
-}
+size_t Runner::testCount() const { return tests_.size(); }
-std::string Runner::testNameAt(unsigned int index) const {
+Json::String Runner::testNameAt(size_t index) const {
TestCase* test = tests_[index]();
- std::string name = test->testName();
+ Json::String name = test->testName();
delete test;
return name;
}
-void Runner::runTestAt(unsigned int index, TestResult& result) const {
+void Runner::runTestAt(size_t index, TestResult& result) const {
TestCase* test = tests_[index]();
result.setTestName(test->testName());
printf("Testing %s: ", test->testName());
@@ -257,8 +240,7 @@
#endif // if JSON_USE_EXCEPTION
test->run(result);
#if JSON_USE_EXCEPTION
- }
- catch (const std::exception& e) {
+ } catch (const std::exception& e) {
result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
<< e.what();
}
@@ -270,9 +252,9 @@
}
bool Runner::runAllTest(bool printSummary) const {
- unsigned int count = testCount();
+ size_t const count = testCount();
std::deque<TestResult> failures;
- for (unsigned int index = 0; index < count; ++index) {
+ for (size_t index = 0; index < count; ++index) {
TestResult result;
runTestAt(index, result);
if (result.failed()) {
@@ -282,31 +264,26 @@
if (failures.empty()) {
if (printSummary) {
- printf("All %d tests passed\n", count);
+ printf("All %zu tests passed\n", count);
}
return true;
- } else {
- for (unsigned int index = 0; index < failures.size(); ++index) {
- TestResult& result = failures[index];
- result.printFailure(count > 1);
- }
-
- if (printSummary) {
- unsigned int failedCount = static_cast<unsigned int>(failures.size());
- unsigned int passedCount = count - failedCount;
- printf("%d/%d tests passed (%d failure(s))\n",
- passedCount,
- count,
- failedCount);
- }
- return false;
}
+ for (auto& result : failures) {
+ result.printFailure(count > 1);
+ }
+
+ if (printSummary) {
+ size_t const failedCount = failures.size();
+ size_t const passedCount = count - failedCount;
+ printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
+ failedCount);
+ }
+ return false;
}
-bool Runner::testIndex(const std::string& testName,
- unsigned int& indexOut) const {
- unsigned int count = testCount();
- for (unsigned int index = 0; index < count; ++index) {
+bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {
+ const size_t count = testCount();
+ for (size_t index = 0; index < count; ++index) {
if (testNameAt(index) == testName) {
indexOut = index;
return true;
@@ -316,26 +293,27 @@
}
void Runner::listTests() const {
- unsigned int count = testCount();
- for (unsigned int index = 0; index < count; ++index) {
+ const size_t count = testCount();
+ for (size_t index = 0; index < count; ++index) {
printf("%s\n", testNameAt(index).c_str());
}
}
int Runner::runCommandLine(int argc, const char* argv[]) const {
- typedef std::deque<std::string> TestNames;
+ // typedef std::deque<String> TestNames;
Runner subrunner;
for (int index = 1; index < argc; ++index) {
- std::string opt = argv[index];
+ Json::String opt = argv[index];
if (opt == "--list-tests") {
listTests();
return 0;
- } else if (opt == "--test-auto") {
+ }
+ if (opt == "--test-auto") {
preventDialogOnCrash();
} else if (opt == "--test") {
++index;
if (index < argc) {
- unsigned int testNameIndex;
+ size_t testNameIndex;
if (testIndex(argv[index], testNameIndex)) {
subrunner.add(tests_[testNameIndex]);
} else {
@@ -362,8 +340,8 @@
#if defined(_MSC_VER) && defined(_DEBUG)
// Hook MSVCRT assertions to prevent dialog from appearing
-static int
-msvcrtSilentReportHook(int reportType, char* message, int* /*returnValue*/) {
+static int msvcrtSilentReportHook(int reportType, char* message,
+ int* /*returnValue*/) {
// The default CRT handling of error and assertion is to display
// an error dialog to the user.
// Instead, when an error or an assertion occurs, we force the
@@ -398,8 +376,8 @@
_CrtSetReportHook(&msvcrtSilentReportHook);
#endif // if defined(_MSC_VER)
-// @todo investiguate this handler (for buffer overflow)
-// _set_security_error_handler
+ // @todo investigate this handler (for buffer overflow)
+ // _set_security_error_handler
#if defined(_WIN32)
// Prevents the system from popping a dialog for debugging if the
@@ -426,12 +404,21 @@
// Assertion functions
// //////////////////////////////////////////////////////////////////
-TestResult& checkStringEqual(TestResult& result,
- const std::string& expected,
- const std::string& actual,
- const char* file,
- unsigned int line,
- const char* expr) {
+Json::String ToJsonString(const char* toConvert) {
+ return Json::String(toConvert);
+}
+
+Json::String ToJsonString(Json::String in) { return in; }
+
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in) {
+ return Json::String(in.data(), in.data() + in.length());
+}
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+ const Json::String& actual, const char* file,
+ unsigned int line, const char* expr) {
if (expected != actual) {
result.addFailure(file, line, expr);
result << "Expected: '" << expected << "'\n";
diff --git a/src/test_lib_json/jsontest.h b/src/test_lib_json/jsontest.h
index 5c56a40..4e8af0f 100644
--- a/src/test_lib_json/jsontest.h
+++ b/src/test_lib_json/jsontest.h
@@ -1,4 +1,4 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
@@ -6,11 +6,12 @@
#ifndef JSONTEST_H_INCLUDED
#define JSONTEST_H_INCLUDED
+#include <cstdio>
+#include <deque>
+#include <iomanip>
#include <json/config.h>
#include <json/value.h>
#include <json/writer.h>
-#include <stdio.h>
-#include <deque>
#include <sstream>
#include <string>
@@ -32,8 +33,8 @@
public:
const char* file_;
unsigned int line_;
- std::string expr_;
- std::string message_;
+ Json::String expr_;
+ Json::String message_;
unsigned int nestingLevel_;
};
@@ -41,7 +42,7 @@
/// Must be a POD to allow inline initialisation without stepping
/// into the debugger.
struct PredicateContext {
- typedef unsigned int Id;
+ using Id = unsigned int;
Id id_;
const char* file_;
unsigned int line_;
@@ -60,16 +61,16 @@
/// Not encapsulated to prevent step into when debugging failed assertions
/// Incremented by one on assertion predicate entry, decreased by one
/// by addPredicateContext().
- PredicateContext::Id predicateId_;
+ PredicateContext::Id predicateId_{1};
/// \internal Implementation detail for predicate macros
PredicateContext* predicateStackTail_;
- void setTestName(const std::string& name);
+ void setTestName(const Json::String& name);
/// Adds an assertion failure.
- TestResult&
- addFailure(const char* file, unsigned int line, const char* expr = 0);
+ TestResult& addFailure(const char* file, unsigned int line,
+ const char* expr = nullptr);
/// Removes the last PredicateContext added to the predicate stack
/// chained list.
@@ -82,10 +83,8 @@
// Generic operator that will work with anything ostream can deal with.
template <typename T> TestResult& operator<<(const T& value) {
- std::ostringstream oss;
- oss.precision(16);
- oss.setf(std::ios_base::floatfield);
- oss << value;
+ Json::OStringStream oss;
+ oss << std::setprecision(16) << std::hexfloat << value;
return addToLastFailure(oss.str());
}
@@ -96,23 +95,20 @@
TestResult& operator<<(Json::UInt64 value);
private:
- TestResult& addToLastFailure(const std::string& message);
- unsigned int getAssertionNestingLevel() const;
+ TestResult& addToLastFailure(const Json::String& message);
/// Adds a failure or a predicate context
- void addFailureInfo(const char* file,
- unsigned int line,
- const char* expr,
+ void addFailureInfo(const char* file, unsigned int line, const char* expr,
unsigned int nestingLevel);
- static std::string indentText(const std::string& text,
- const std::string& indent);
+ static Json::String indentText(const Json::String& text,
+ const Json::String& indent);
- typedef std::deque<Failure> Failures;
+ using Failures = std::deque<Failure>;
Failures failures_;
- std::string name_;
+ Json::String name_;
PredicateContext rootPredicateNode_;
- PredicateContext::Id lastUsedPredicateId_;
+ PredicateContext::Id lastUsedPredicateId_{0};
/// Failure which is the target of the messages added using operator <<
- Failure* messageTarget_;
+ Failure* messageTarget_{nullptr};
};
class TestCase {
@@ -126,14 +122,14 @@
virtual const char* testName() const = 0;
protected:
- TestResult* result_;
+ TestResult* result_{nullptr};
private:
virtual void runTestCase() = 0;
};
/// Function pointer type for TestCase factory
-typedef TestCase* (*TestCaseFactory)();
+using TestCaseFactory = TestCase* (*)();
class Runner {
public:
@@ -152,37 +148,33 @@
bool runAllTest(bool printSummary) const;
/// Returns the number of test case in the suite
- unsigned int testCount() const;
+ size_t testCount() const;
/// Returns the name of the test case at the specified index
- std::string testNameAt(unsigned int index) const;
+ Json::String testNameAt(size_t index) const;
/// Runs the test case at the specified index using the specified TestResult
- void runTestAt(unsigned int index, TestResult& result) const;
+ void runTestAt(size_t index, TestResult& result) const;
static void printUsage(const char* appName);
private: // prevents copy construction and assignment
- Runner(const Runner& other);
- Runner& operator=(const Runner& other);
+ Runner(const Runner& other) = delete;
+ Runner& operator=(const Runner& other) = delete;
private:
void listTests() const;
- bool testIndex(const std::string& testName, unsigned int& index) const;
+ bool testIndex(const Json::String& testName, size_t& indexOut) const;
static void preventDialogOnCrash();
private:
- typedef std::deque<TestCaseFactory> Factories;
+ using Factories = std::deque<TestCaseFactory>;
Factories tests_;
};
template <typename T, typename U>
-TestResult& checkEqual(TestResult& result,
- const T& expected,
- const U& actual,
- const char* file,
- unsigned int line,
- const char* expr) {
+TestResult& checkEqual(TestResult& result, T expected, U actual,
+ const char* file, unsigned int line, const char* expr) {
if (static_cast<U>(expected) != actual) {
result.addFailure(file, line, expr);
result << "Expected: " << static_cast<U>(expected) << "\n";
@@ -191,12 +183,15 @@
return result;
}
-TestResult& checkStringEqual(TestResult& result,
- const std::string& expected,
- const std::string& actual,
- const char* file,
- unsigned int line,
- const char* expr);
+Json::String ToJsonString(const char* toConvert);
+Json::String ToJsonString(Json::String in);
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in);
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+ const Json::String& actual, const char* file,
+ unsigned int line, const char* expr);
} // namespace JsonTest
@@ -206,55 +201,46 @@
#define JSONTEST_ASSERT(expr) \
if (expr) { \
} else \
- result_->addFailure(__FILE__, __LINE__, #expr)
+ result_->addFailure(__FILE__, __LINE__, #expr)
/// \brief Asserts that the given predicate is true.
/// The predicate may do other assertions and be a member function of the
/// fixture.
#define JSONTEST_ASSERT_PRED(expr) \
- { \
+ do { \
JsonTest::PredicateContext _minitest_Context = { \
- result_->predicateId_, __FILE__, __LINE__, #expr \
- }; \
+ result_->predicateId_, __FILE__, __LINE__, #expr, NULL, NULL}; \
result_->predicateStackTail_->next_ = &_minitest_Context; \
result_->predicateId_ += 1; \
result_->predicateStackTail_ = &_minitest_Context; \
(expr); \
result_->popPredicateContext(); \
- }
+ } while (0)
/// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_EQUAL(expected, actual) \
- JsonTest::checkEqual(*result_, \
- expected, \
- actual, \
- __FILE__, \
- __LINE__, \
+ JsonTest::checkEqual(*result_, expected, actual, __FILE__, __LINE__, \
#expected " == " #actual)
/// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual) \
- JsonTest::checkStringEqual(*result_, \
- std::string(expected), \
- std::string(actual), \
- __FILE__, \
- __LINE__, \
- #expected " == " #actual)
+ JsonTest::checkStringEqual(*result_, JsonTest::ToJsonString(expected), \
+ JsonTest::ToJsonString(actual), __FILE__, \
+ __LINE__, #expected " == " #actual)
/// \brief Asserts that a given expression throws an exception
#define JSONTEST_ASSERT_THROWS(expr) \
- { \
+ do { \
bool _threw = false; \
try { \
expr; \
- } \
- catch (...) { \
+ } catch (...) { \
_threw = true; \
} \
if (!_threw) \
- result_->addFailure( \
- __FILE__, __LINE__, "expected exception thrown: " #expr); \
- }
+ result_->addFailure(__FILE__, __LINE__, \
+ "expected exception thrown: " #expr); \
+ } while (0)
/// \brief Begin a fixture test case.
#define JSONTEST_FIXTURE(FixtureType, name) \
@@ -264,9 +250,9 @@
return new Test##FixtureType##name(); \
} \
\
- public: /* overidden from TestCase */ \
- virtual const char* testName() const { return #FixtureType "/" #name; } \
- virtual void runTestCase(); \
+ public: /* overridden from TestCase */ \
+ const char* testName() const override { return #FixtureType "/" #name; } \
+ void runTestCase() override; \
}; \
\
void Test##FixtureType##name::runTestCase()
@@ -277,4 +263,26 @@
#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name) \
(runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE_V2(FixtureType, name, collections) \
+ class Test##FixtureType##name : public FixtureType { \
+ public: \
+ static JsonTest::TestCase* factory() { \
+ return new Test##FixtureType##name(); \
+ } \
+ static bool collect() { \
+ (collections).push_back(JSONTEST_FIXTURE_FACTORY(FixtureType, name)); \
+ return true; \
+ } \
+ \
+ public: /* overridden from TestCase */ \
+ const char* testName() const override { return #FixtureType "/" #name; } \
+ void runTestCase() override; \
+ }; \
+ \
+ static bool test##FixtureType##name##collect = \
+ Test##FixtureType##name::collect(); \
+ \
+ void Test##FixtureType##name::runTestCase()
+
#endif // ifndef JSONTEST_H_INCLUDED
diff --git a/src/test_lib_json/main.cpp b/src/test_lib_json/main.cpp
index 13fc21d..991c247 100644
--- a/src/test_lib_json/main.cpp
+++ b/src/test_lib_json/main.cpp
@@ -1,12 +1,31 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(disable : 4996)
+#endif
+
+#include "fuzz.h"
#include "jsontest.h"
+#include <cmath>
+#include <cstring>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
#include <json/config.h>
#include <json/json.h>
-#include <stdexcept>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <string>
+
+using CharReaderPtr = std::unique_ptr<Json::CharReader>;
// Make numeric limits more convenient to talk about.
// Assumes int type in 32 bits.
@@ -17,8 +36,8 @@
#define kint64min Json::Value::minInt64
#define kuint64max Json::Value::maxUInt64
-static const double kdint64max = double(kint64max);
-static const float kfint64max = float(kint64max);
+// static const double kdint64max = double(kint64max);
+// static const float kfint64max = float(kint64max);
static const float kfint32max = float(kint32max);
static const float kfuint32max = float(kuint32max);
@@ -35,33 +54,33 @@
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double uint64ToDouble(Json::UInt64 value) {
return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
- Json::Int64(value & 1);
+ static_cast<double>(Json::Int64(value & 1));
}
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+// local_ is the collection for the testcases in this code file.
+static std::deque<JsonTest::TestCaseFactory> local_;
+#define JSONTEST_FIXTURE_LOCAL(FixtureType, name) \
+ JSONTEST_FIXTURE_V2(FixtureType, name, local_)
+
struct ValueTest : JsonTest::TestCase {
Json::Value null_;
- Json::Value emptyArray_;
- Json::Value emptyObject_;
- Json::Value integer_;
- Json::Value unsignedInteger_;
- Json::Value smallUnsignedInteger_;
- Json::Value real_;
- Json::Value float_;
+ Json::Value emptyArray_{Json::arrayValue};
+ Json::Value emptyObject_{Json::objectValue};
+ Json::Value integer_{123456789};
+ Json::Value unsignedInteger_{34567890};
+ Json::Value smallUnsignedInteger_{Json::Value::UInt(Json::Value::maxInt)};
+ Json::Value real_{1234.56789};
+ Json::Value float_{0.00390625f};
Json::Value array1_;
Json::Value object1_;
- Json::Value emptyString_;
- Json::Value string1_;
- Json::Value string_;
- Json::Value true_;
- Json::Value false_;
+ Json::Value emptyString_{""};
+ Json::Value string1_{"a"};
+ Json::Value string_{"sometext with space"};
+ Json::Value true_{true};
+ Json::Value false_{false};
- ValueTest()
- : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
- integer_(123456789), unsignedInteger_(34567890u),
- smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
- real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
- string_("sometext with space"), true_(true), false_(false) {
+ ValueTest() {
array1_.append(1234);
object1_["id"] = 1234;
}
@@ -70,19 +89,19 @@
/// Initialize all checks to \c false by default.
IsCheck();
- bool isObject_;
- bool isArray_;
- bool isBool_;
- bool isString_;
- bool isNull_;
+ bool isObject_{false};
+ bool isArray_{false};
+ bool isBool_{false};
+ bool isString_{false};
+ bool isNull_{false};
- bool isInt_;
- bool isInt64_;
- bool isUInt_;
- bool isUInt64_;
- bool isIntegral_;
- bool isDouble_;
- bool isNumeric_;
+ bool isInt_{false};
+ bool isInt64_{false};
+ bool isUInt_{false};
+ bool isUInt64_{false};
+ bool isIntegral_{false};
+ bool isDouble_{false};
+ bool isNumeric_{false};
};
void checkConstMemberCount(const Json::Value& value,
@@ -98,54 +117,52 @@
/// Normalize the representation of floating-point number by stripped leading
/// 0 in exponent.
- static std::string normalizeFloatingPointStr(const std::string& s);
+ static Json::String normalizeFloatingPointStr(const Json::String& s);
};
-std::string ValueTest::normalizeFloatingPointStr(const std::string& s) {
- std::string::size_type index = s.find_last_of("eE");
- if (index != std::string::npos) {
- std::string::size_type hasSign =
- (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
- std::string::size_type exponentStartIndex = index + 1 + hasSign;
- std::string normalized = s.substr(0, exponentStartIndex);
- std::string::size_type indexDigit =
- s.find_first_not_of('0', exponentStartIndex);
- std::string exponent = "0";
- if (indexDigit !=
- std::string::npos) // There is an exponent different from 0
- {
- exponent = s.substr(indexDigit);
- }
- return normalized + exponent;
+Json::String ValueTest::normalizeFloatingPointStr(const Json::String& s) {
+ auto index = s.find_last_of("eE");
+ if (index == s.npos)
+ return s;
+ std::size_t signWidth = (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+ auto exponentStartIndex = index + 1 + signWidth;
+ Json::String normalized = s.substr(0, exponentStartIndex);
+ auto indexDigit = s.find_first_not_of('0', exponentStartIndex);
+ Json::String exponent = "0";
+ if (indexDigit != s.npos) { // nonzero exponent
+ exponent = s.substr(indexDigit);
}
- return s;
+ return normalized + exponent;
}
-JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
- JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
- JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
- JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
- JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
- normalizeFloatingPointStr("1234.0e0"));
- JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
- normalizeFloatingPointStr("1234.0e+0"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e10",
- normalizeFloatingPointStr("1234e010"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
- normalizeFloatingPointStr("1234e+010"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
- normalizeFloatingPointStr("1234e-010"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
- normalizeFloatingPointStr("1234e+100"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
- normalizeFloatingPointStr("1234e-100"));
- JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
- normalizeFloatingPointStr("1234e+001"));
+JSONTEST_FIXTURE_LOCAL(ValueTest, checkNormalizeFloatingPointStr) {
+ struct TestData {
+ std::string in;
+ std::string out;
+ } const testData[] = {
+ {"0.0", "0.0"},
+ {"0e0", "0e0"},
+ {"1234.0", "1234.0"},
+ {"1234.0e0", "1234.0e0"},
+ {"1234.0e-1", "1234.0e-1"},
+ {"1234.0e+0", "1234.0e+0"},
+ {"1234.0e+001", "1234.0e+1"},
+ {"1234e-1", "1234e-1"},
+ {"1234e+000", "1234e+0"},
+ {"1234e+001", "1234e+1"},
+ {"1234e10", "1234e10"},
+ {"1234e010", "1234e10"},
+ {"1234e+010", "1234e+10"},
+ {"1234e-010", "1234e-10"},
+ {"1234e+100", "1234e+100"},
+ {"1234e-100", "1234e-100"},
+ };
+ for (const auto& td : testData) {
+ JSONTEST_ASSERT_STRING_EQUAL(normalizeFloatingPointStr(td.in), td.out);
+ }
}
-JSONTEST_FIXTURE(ValueTest, memberCount) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, memberCount) {
JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
@@ -158,9 +175,12 @@
JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(false_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(string1_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(float_, 0));
}
-JSONTEST_FIXTURE(ValueTest, objects) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
// Types
IsCheck checks;
checks.isObject_ = true;
@@ -192,15 +212,71 @@
JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
+ // Access through find()
+ const char idKey[] = "id";
+ const Json::Value* foundId = object1_.find(idKey, idKey + strlen(idKey));
+ JSONTEST_ASSERT(foundId != nullptr);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);
+
+ const char unknownIdKey[] = "unknown id";
+ const Json::Value* foundUnknownId =
+ object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));
+ JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);
+
+ // Access through demand()
+ const char yetAnotherIdKey[] = "yet another id";
+ const Json::Value* foundYetAnotherId =
+ object1_.find(yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
+ JSONTEST_ASSERT_EQUAL(nullptr, foundYetAnotherId);
+ Json::Value* demandedYetAnotherId = object1_.demand(
+ yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
+ JSONTEST_ASSERT(demandedYetAnotherId != nullptr);
+ *demandedYetAnotherId = "baz";
+
+ JSONTEST_ASSERT_EQUAL(Json::Value("baz"), object1_["yet another id"]);
+
// Access through non-const reference
JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
object1_["some other id"] = "foo";
JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+
+ // Remove.
+ Json::Value got;
+ bool did;
+ did = object1_.removeMember("some other id", &got);
+ JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
+ JSONTEST_ASSERT_EQUAL(true, did);
+ got = Json::Value("bar");
+ did = object1_.removeMember("some other id", &got);
+ JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
+ JSONTEST_ASSERT_EQUAL(false, did);
+
+ object1_["some other id"] = "foo";
+ Json::Value* gotPtr = nullptr;
+ did = object1_.removeMember("some other id", gotPtr);
+ JSONTEST_ASSERT_EQUAL(nullptr, gotPtr);
+ JSONTEST_ASSERT_EQUAL(true, did);
+
+ // Using other removeMember interfaces, the test idea is the same as above.
+ object1_["some other id"] = "foo";
+ const Json::String key("some other id");
+ did = object1_.removeMember(key, &got);
+ JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
+ JSONTEST_ASSERT_EQUAL(true, did);
+ got = Json::Value("bar");
+ did = object1_.removeMember(key, &got);
+ JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
+ JSONTEST_ASSERT_EQUAL(false, did);
+
+ object1_["some other id"] = "foo";
+ object1_.removeMember(key);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, object1_[key]);
}
-JSONTEST_FIXTURE(ValueTest, arrays) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrays) {
const unsigned int index0 = 0;
// Types
@@ -240,9 +316,125 @@
array1_[2] = Json::Value(17);
JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
+ Json::Value got;
+ JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));
+ JSONTEST_ASSERT_EQUAL(Json::Value(17), got);
+ JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, resizeArray) {
+ Json::Value array;
+ {
+ for (Json::ArrayIndex i = 0; i < 10; i++)
+ array[i] = i;
+ JSONTEST_ASSERT_EQUAL(array.size(), 10);
+ // The length set is greater than the length of the array.
+ array.resize(15);
+ JSONTEST_ASSERT_EQUAL(array.size(), 15);
+
+ // The length set is less than the length of the array.
+ array.resize(5);
+ JSONTEST_ASSERT_EQUAL(array.size(), 5);
+
+ // The length of the array is set to 0.
+ array.resize(0);
+ JSONTEST_ASSERT_EQUAL(array.size(), 0);
+ }
+ {
+ for (Json::ArrayIndex i = 0; i < 10; i++)
+ array[i] = i;
+ JSONTEST_ASSERT_EQUAL(array.size(), 10);
+ array.clear();
+ JSONTEST_ASSERT_EQUAL(array.size(), 0);
+ }
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, getArrayValue) {
+ Json::Value array;
+ for (Json::ArrayIndex i = 0; i < 5; i++)
+ array[i] = i;
+
+ JSONTEST_ASSERT_EQUAL(array.size(), 5);
+ const Json::Value defaultValue(10);
+ Json::ArrayIndex index = 0;
+ for (; index <= 4; index++)
+ JSONTEST_ASSERT_EQUAL(index, array.get(index, defaultValue).asInt());
+
+ index = 4;
+ JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), true);
+ index = 5;
+ JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
+ JSONTEST_ASSERT_EQUAL(defaultValue, array.get(index, defaultValue));
+ JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrayIssue252) {
+ int count = 5;
+ Json::Value root;
+ Json::Value item;
+ root["array"] = Json::Value::nullSingleton();
+ for (int i = 0; i < count; i++) {
+ item["a"] = i;
+ item["b"] = i;
+ root["array"][i] = item;
+ }
+ // JSONTEST_ASSERT_EQUAL(5, root["array"].size());
}
-JSONTEST_FIXTURE(ValueTest, null) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
+ Json::Value array;
+ const Json::Value str0("index2");
+ const Json::Value str1("index3");
+ array.append("index0"); // append rvalue
+ array.append("index1");
+ array.append(str0); // append lvalue
+
+ std::vector<Json::Value*> vec; // storage value address for checking
+ for (Json::ArrayIndex i = 0; i < 3; i++) {
+ vec.push_back(&array[i]);
+ }
+ JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[0]); // check append
+ JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[2]);
+
+ // insert lvalue at the head
+ JSONTEST_ASSERT(array.insert(0, str1));
+ JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[2]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[3]);
+ // checking address
+ for (Json::ArrayIndex i = 0; i < 3; i++) {
+ JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+ }
+ vec.push_back(&array[3]);
+ // insert rvalue at middle
+ JSONTEST_ASSERT(array.insert(2, "index4"));
+ JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
+ // checking address
+ for (Json::ArrayIndex i = 0; i < 4; i++) {
+ JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+ }
+ vec.push_back(&array[4]);
+ // insert rvalue at the tail
+ JSONTEST_ASSERT(array.insert(5, "index5"));
+ JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
+ JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array[5]);
+ // checking address
+ for (Json::ArrayIndex i = 0; i < 5; i++) {
+ JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+ }
+ vec.push_back(&array[5]);
+ // beyond max array size, it should not be allowed to insert into its tail
+ JSONTEST_ASSERT(!array.insert(10, "index10"));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, null) {
JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
IsCheck checks;
@@ -265,9 +457,17 @@
JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
+
+ JSONTEST_ASSERT_EQUAL(Json::Value::nullSingleton(), null_);
+
+ // Test using a Value in a boolean context (false iff null)
+ JSONTEST_ASSERT_EQUAL(null_, false);
+ JSONTEST_ASSERT_EQUAL(object1_, true);
+ JSONTEST_ASSERT_EQUAL(!null_, true);
+ JSONTEST_ASSERT_EQUAL(!object1_, false);
}
-JSONTEST_FIXTURE(ValueTest, strings) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, strings) {
JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
IsCheck checks;
@@ -296,7 +496,7 @@
JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
}
-JSONTEST_FIXTURE(ValueTest, bools) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, bools) {
JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
IsCheck checks;
@@ -338,7 +538,7 @@
JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
}
-JSONTEST_FIXTURE(ValueTest, integers) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
IsCheck checks;
Json::Value val;
@@ -443,7 +643,7 @@
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
// Zero (signed constructor arg)
val = Json::Value(0);
@@ -527,7 +727,7 @@
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
// 2^20 (signed constructor arg)
val = Json::Value(1 << 20);
@@ -610,8 +810,9 @@
JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1048576",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1048576.0",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// -2^20
val = Json::Value(-(1 << 20));
@@ -851,8 +1052,9 @@
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1099511627776",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1099511627776.0",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// -2^40
val = Json::Value(-(Json::Int64(1) << 40));
@@ -923,11 +1125,12 @@
JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)),
- val.asFloat());
+ JSONTEST_ASSERT_EQUAL(float(Json::UInt64(1) << 63), val.asFloat());
+
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "9.2233720368547758e+18",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// int64 min
val = Json::Value(Json::Int64(kint64min));
@@ -974,11 +1177,12 @@
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "-9.2233720368547758e+18",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// 10^19
- const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>(1e19);
+ const auto ten_to_19 = static_cast<Json::UInt64>(1e19);
val = Json::Value(Json::UInt64(ten_to_19));
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
@@ -1021,8 +1225,9 @@
JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1e+19",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1e+19",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// uint64 max
val = Json::Value(Json::UInt64(kuint64max));
@@ -1065,12 +1270,13 @@
JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1.8446744073709552e+19",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
#endif
}
-JSONTEST_FIXTURE(ValueTest, nonIntegers) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, nonIntegers) {
IsCheck checks;
Json::Value val;
@@ -1155,8 +1361,9 @@
JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("2147483647.5",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(
+ "2147483647.5",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A bit under int32 min
val = Json::Value(kint32min - 0.5);
@@ -1180,11 +1387,12 @@
JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL(-Json::Int64(1) << 31, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 31), val.asLargestInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("-2147483648.5",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(
+ "-2147483648.5",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A bit over uint32 max
val = Json::Value(kuint32max + 0.5);
@@ -1213,30 +1421,35 @@
val.asLargestUInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("4294967295.5",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(
+ "4294967295.5",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
val = Json::Value(1.2345678901234);
- JSONTEST_ASSERT_STRING_EQUAL("1.2345678901234",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1.2345678901234001",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A 16-digit floating point number.
val = Json::Value(2199023255552000.0f);
- JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
- JSONTEST_ASSERT_STRING_EQUAL("2199023255552000",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(float(2199023255552000.0f), val.asFloat());
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "2199023255552000.0",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A very large floating point number.
val = Json::Value(3.402823466385289e38);
JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
- JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "3.402823466385289e+38",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// An even larger floating point number.
val = Json::Value(1.2345678e300);
JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
- JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300",
- normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "1.2345678e+300",
+ normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
}
void ValueTest::checkConstMemberCount(const Json::Value& value,
@@ -1263,11 +1476,7 @@
JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
}
-ValueTest::IsCheck::IsCheck()
- : isObject_(false), isArray_(false), isBool_(false), isString_(false),
- isNull_(false), isInt_(false), isInt64_(false), isUInt_(false),
- isUInt64_(false), isIntegral_(false), isDouble_(false),
- isNumeric_(false) {}
+ValueTest::IsCheck::IsCheck() = default;
void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
@@ -1290,31 +1499,35 @@
#endif
}
-JSONTEST_FIXTURE(ValueTest, compareNull) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareNull) {
JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
+ JSONTEST_ASSERT_PRED(
+ checkIsEqual(Json::Value::nullSingleton(), Json::Value()));
+ JSONTEST_ASSERT_PRED(
+ checkIsEqual(Json::Value::nullSingleton(), Json::Value::nullSingleton()));
}
-JSONTEST_FIXTURE(ValueTest, compareInt) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareInt) {
JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
}
-JSONTEST_FIXTURE(ValueTest, compareUInt) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareUInt) {
JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
}
-JSONTEST_FIXTURE(ValueTest, compareDouble) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareDouble) {
JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
}
-JSONTEST_FIXTURE(ValueTest, compareString) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareString) {
JSONTEST_ASSERT_PRED(checkIsLess("", " "));
JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
@@ -1325,13 +1538,13 @@
JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
}
-JSONTEST_FIXTURE(ValueTest, compareBoolean) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareBoolean) {
JSONTEST_ASSERT_PRED(checkIsLess(false, true));
JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
}
-JSONTEST_FIXTURE(ValueTest, compareArray) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareArray) {
// array compare size then content
Json::Value emptyArray(Json::arrayValue);
Json::Value l1aArray;
@@ -1346,32 +1559,60 @@
l2bArray.append(10);
JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
- JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l1bArray));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1bArray, l2aArray));
JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l1bArray, Json::Value(l1bArray)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l2aArray, Json::Value(l2aArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
}
-JSONTEST_FIXTURE(ValueTest, compareObject) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareObject) {
// object compare size then content
Json::Value emptyObject(Json::objectValue);
Json::Value l1aObject;
l1aObject["key1"] = 0;
Json::Value l1bObject;
- l1aObject["key1"] = 10;
+ l1bObject["key1"] = 10;
Json::Value l2aObject;
l2aObject["key1"] = 0;
l2aObject["key2"] = 0;
+ Json::Value l2bObject;
+ l2bObject["key1"] = 10;
+ l2bObject["key2"] = 0;
JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
- JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
- JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l1bObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1bObject, l2aObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(l2aObject, l2bObject));
JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l1bObject, Json::Value(l1bObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l2bObject, Json::Value(l2bObject)));
+ {
+ Json::Value aObject;
+ aObject["a"] = 10;
+ Json::Value bObject;
+ bObject["b"] = 0;
+ Json::Value cObject;
+ cObject["c"] = 20;
+ cObject["f"] = 15;
+ Json::Value dObject;
+ dObject["d"] = -2;
+ dObject["e"] = 10;
+ JSONTEST_ASSERT_PRED(checkIsLess(aObject, bObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(bObject, cObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(cObject, dObject));
+ JSONTEST_ASSERT_PRED(checkIsEqual(aObject, Json::Value(aObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(bObject, Json::Value(bObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(cObject, Json::Value(cObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(dObject, Json::Value(dObject)));
+ }
}
-JSONTEST_FIXTURE(ValueTest, compareType) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareType) {
// object of different type are ordered according to their type
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
@@ -1384,6 +1625,58 @@
Json::Value(Json::objectValue)));
}
+JSONTEST_FIXTURE_LOCAL(ValueTest, CopyObject) {
+ Json::Value arrayVal;
+ arrayVal.append("val1");
+ arrayVal.append("val2");
+ arrayVal.append("val3");
+ Json::Value stringVal("string value");
+ Json::Value copy1, copy2;
+ {
+ Json::Value arrayCopy, stringCopy;
+ arrayCopy.copy(arrayVal);
+ stringCopy.copy(stringVal);
+ JSONTEST_ASSERT_PRED(checkIsEqual(arrayCopy, arrayVal));
+ JSONTEST_ASSERT_PRED(checkIsEqual(stringCopy, stringVal));
+ arrayCopy.append("val4");
+ JSONTEST_ASSERT(arrayCopy.size() == 4);
+ arrayVal.append("new4");
+ arrayVal.append("new5");
+ JSONTEST_ASSERT(arrayVal.size() == 5);
+ JSONTEST_ASSERT(!(arrayCopy == arrayVal));
+ stringCopy = "another string";
+ JSONTEST_ASSERT(!(stringCopy == stringVal));
+ copy1.copy(arrayCopy);
+ copy2.copy(stringCopy);
+ }
+ JSONTEST_ASSERT(arrayVal.size() == 5);
+ JSONTEST_ASSERT(stringVal == "string value");
+ JSONTEST_ASSERT(copy1.size() == 4);
+ JSONTEST_ASSERT(copy2 == "another string");
+ copy1.copy(stringVal);
+ JSONTEST_ASSERT(copy1 == "string value");
+ copy2.copy(arrayVal);
+ JSONTEST_ASSERT(copy2.size() == 5);
+ {
+ Json::Value srcObject, objectCopy, otherObject;
+ srcObject["key0"] = 10;
+ objectCopy.copy(srcObject);
+ JSONTEST_ASSERT(srcObject["key0"] == 10);
+ JSONTEST_ASSERT(objectCopy["key0"] == 10);
+ JSONTEST_ASSERT(srcObject.getMemberNames().size() == 1);
+ JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 1);
+ otherObject["key1"] = 15;
+ otherObject["key2"] = 16;
+ JSONTEST_ASSERT(otherObject.getMemberNames().size() == 2);
+ objectCopy.copy(otherObject);
+ JSONTEST_ASSERT(objectCopy["key1"] == 15);
+ JSONTEST_ASSERT(objectCopy["key2"] == 16);
+ JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 2);
+ otherObject["key1"] = 20;
+ JSONTEST_ASSERT(objectCopy["key1"] == 15);
+ }
+}
+
void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
JSONTEST_ASSERT(x < y);
JSONTEST_ASSERT(y > x);
@@ -1414,7 +1707,7 @@
JSONTEST_ASSERT(y.compare(x) == 0);
}
-JSONTEST_FIXTURE(ValueTest, typeChecksThrowExceptions) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, typeChecksThrowExceptions) {
#if JSON_USE_EXCEPTION
Json::Value intVal(1);
@@ -1480,7 +1773,7 @@
#endif
}
-JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, offsetAccessors) {
Json::Value x;
JSONTEST_ASSERT(x.getOffsetStart() == 0);
JSONTEST_ASSERT(x.getOffsetLimit() == 0);
@@ -1499,9 +1792,312 @@
JSONTEST_ASSERT(y.getOffsetLimit() == 0);
}
-struct WriterTest : JsonTest::TestCase {};
+JSONTEST_FIXTURE_LOCAL(ValueTest, StaticString) {
+ char mutant[] = "hello";
+ Json::StaticString ss(mutant);
+ Json::String regular(mutant);
+ mutant[1] = 'a';
+ JSONTEST_ASSERT_STRING_EQUAL("hallo", ss.c_str());
+ JSONTEST_ASSERT_STRING_EQUAL("hello", regular.c_str());
+ {
+ Json::Value root;
+ root["top"] = ss;
+ JSONTEST_ASSERT_STRING_EQUAL("hallo", root["top"].asString());
+ mutant[1] = 'u';
+ JSONTEST_ASSERT_STRING_EQUAL("hullo", root["top"].asString());
+ }
+ {
+ Json::Value root;
+ root["top"] = regular;
+ JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+ mutant[1] = 'u';
+ JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+ }
+}
-JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
+JSONTEST_FIXTURE_LOCAL(ValueTest, WideString) {
+ // https://github.com/open-source-parsers/jsoncpp/issues/756
+ const std::string uni = u8"\u5f0f\uff0c\u8fdb"; // "式，进"
+ std::string styled;
+ {
+ Json::Value v;
+ v["abc"] = uni;
+ styled = v.toStyledString();
+ }
+ Json::Value root;
+ {
+ JSONCPP_STRING errs;
+ std::istringstream iss(styled);
+ bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
+ JSONTEST_ASSERT(ok);
+ if (!ok) {
+ std::cerr << "errs: " << errs << std::endl;
+ }
+ }
+ JSONTEST_ASSERT_STRING_EQUAL(root["abc"].asString(), uni);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, CommentBefore) {
+ Json::Value val; // fill val
+ val.setComment(Json::String("// this comment should appear before"),
+ Json::commentBefore);
+ Json::StreamWriterBuilder wbuilder;
+ wbuilder.settings_["commentStyle"] = "All";
+ {
+ char const expected[] = "// this comment should appear before\nnull";
+ Json::String result = Json::writeString(wbuilder, val);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ Json::String res2 = val.toStyledString();
+ Json::String exp2 = "\n";
+ exp2 += expected;
+ exp2 += "\n";
+ JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+ }
+ Json::Value other = "hello";
+ val.swapPayload(other);
+ {
+ char const expected[] = "// this comment should appear before\n\"hello\"";
+ Json::String result = Json::writeString(wbuilder, val);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ Json::String res2 = val.toStyledString();
+ Json::String exp2 = "\n";
+ exp2 += expected;
+ exp2 += "\n";
+ JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+ JSONTEST_ASSERT_STRING_EQUAL("null\n", other.toStyledString());
+ }
+ val = "hello";
+ // val.setComment("// this comment should appear before",
+ // Json::CommentPlacement::commentBefore); Assignment over-writes comments.
+ {
+ char const expected[] = "\"hello\"";
+ Json::String result = Json::writeString(wbuilder, val);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ Json::String res2 = val.toStyledString();
+ Json::String exp2;
+ exp2 += expected;
+ exp2 += "\n";
+ JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, zeroes) {
+ char const cstr[] = "h\0i";
+ Json::String binary(cstr, sizeof(cstr)); // include trailing 0
+ JSONTEST_ASSERT_EQUAL(4U, binary.length());
+ Json::StreamWriterBuilder b;
+ {
+ Json::Value root;
+ root = binary;
+ JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
+ }
+ {
+ char const top[] = "top";
+ Json::Value root;
+ root[top] = binary;
+ JSONTEST_ASSERT_STRING_EQUAL(binary, root[top].asString());
+ Json::Value removed;
+ bool did;
+ did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
+ JSONTEST_ASSERT(did);
+ JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString());
+ did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
+ JSONTEST_ASSERT(!did);
+ JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString()); // still
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, zeroesInKeys) {
+ char const cstr[] = "h\0i";
+ Json::String binary(cstr, sizeof(cstr)); // include trailing 0
+ JSONTEST_ASSERT_EQUAL(4U, binary.length());
+ {
+ Json::Value root;
+ root[binary] = "there";
+ JSONTEST_ASSERT_STRING_EQUAL("there", root[binary].asString());
+ JSONTEST_ASSERT(!root.isMember("h"));
+ JSONTEST_ASSERT(root.isMember(binary));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "there", root.get(binary, Json::Value::nullSingleton()).asString());
+ Json::Value removed;
+ bool did;
+ did = root.removeMember(binary.data(), binary.data() + binary.length(),
+ &removed);
+ JSONTEST_ASSERT(did);
+ JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString());
+ did = root.removeMember(binary.data(), binary.data() + binary.length(),
+ &removed);
+ JSONTEST_ASSERT(!did);
+ JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString()); // still
+ JSONTEST_ASSERT(!root.isMember(binary));
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "", root.get(binary, Json::Value::nullSingleton()).asString());
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, specialFloats) {
+ Json::StreamWriterBuilder b;
+ b.settings_["useSpecialFloats"] = true;
+
+ Json::Value v = std::numeric_limits<double>::quiet_NaN();
+ Json::String expected = "NaN";
+ Json::String result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ v = std::numeric_limits<double>::infinity();
+ expected = "Infinity";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ v = -std::numeric_limits<double>::infinity();
+ expected = "-Infinity";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, precision) {
+ Json::StreamWriterBuilder b;
+ b.settings_["precision"] = 5;
+
+ Json::Value v = 100.0 / 3;
+ Json::String expected = "33.333";
+ Json::String result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ v = 0.25000000;
+ expected = "0.25";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ v = 0.2563456;
+ expected = "0.25635";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 1;
+ expected = "0.3";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 17;
+ v = 1234857476305.256345694873740545068;
+ expected = "1234857476305.2563";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 24;
+ v = 0.256345694873740545068;
+ expected = "0.25634569487374054";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 5;
+ b.settings_["precisionType"] = "decimal";
+ v = 0.256345694873740545068;
+ expected = "0.25635";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 1;
+ b.settings_["precisionType"] = "decimal";
+ v = 0.256345694873740545068;
+ expected = "0.3";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+ b.settings_["precision"] = 10;
+ b.settings_["precisionType"] = "decimal";
+ v = 0.23300000;
+ expected = "0.233";
+ result = Json::writeString(b, v);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, searchValueByPath) {
+ Json::Value root, subroot;
+ root["property1"][0] = 0;
+ root["property1"][1] = 1;
+ subroot["object"] = "object";
+ root["property2"] = subroot;
+
+ const Json::Value defaultValue("error");
+ Json::FastWriter writer;
+
+ {
+ const Json::String expected("{"
+ "\"property1\":[0,1],"
+ "\"property2\":{\"object\":\"object\"}"
+ "}\n");
+ Json::String outcome = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+
+ // Array member exists.
+ const Json::Path path1(".property1.[%]", 1);
+ Json::Value result = path1.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
+ result = path1.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
+
+ // Array member does not exist.
+ const Json::Path path2(".property1.[2]");
+ result = path2.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+ result = path2.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+ // Access array path form error
+ const Json::Path path3(".property1.0");
+ result = path3.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+ result = path3.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+ // Object member exists.
+ const Json::Path path4(".property2.%", "object");
+ result = path4.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
+ result = path4.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
+
+ // Object member does not exist.
+ const Json::Path path5(".property2.hello");
+ result = path5.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+ result = path5.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+ // Access object path form error
+ const Json::Path path6(".property2.[0]");
+ result = path5.resolve(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+ result = path6.resolve(root, defaultValue);
+ JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+ // resolve will not change the value
+ outcome = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+ }
+ {
+ const Json::String expected("{"
+ "\"property1\":[0,1,null],"
+ "\"property2\":{"
+ "\"hello\":null,"
+ "\"object\":\"object\"}}\n");
+ Json::Path path1(".property1.[%]", 2);
+ Json::Value& value1 = path1.make(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, value1);
+
+ Json::Path path2(".property2.%", "hello");
+ Json::Value& value2 = path2.make(root);
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, value2);
+
+ // make will change the value
+ const Json::String outcome = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+ }
+}
+struct FastWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, dropNullPlaceholders) {
Json::FastWriter writer;
Json::Value nullValue;
JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
@@ -1510,128 +2106,1816 @@
JSONTEST_ASSERT(writer.write(nullValue) == "\n");
}
-struct ReaderTest : JsonTest::TestCase {};
-
-JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
- Json::Reader reader;
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, enableYAMLCompatibility) {
+ Json::FastWriter writer;
Json::Value root;
- bool ok = reader.parse("{ \"property\" : \"value\" }", root);
- JSONTEST_ASSERT(ok);
- JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
- JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
+ root["hello"] = "world";
+
+ JSONTEST_ASSERT(writer.write(root) == "{\"hello\":\"world\"}\n");
+
+ writer.enableYAMLCompatibility();
+ JSONTEST_ASSERT(writer.write(root) == "{\"hello\": \"world\"}\n");
}
-JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
- "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
- "null, \"false\" : false }",
- root);
- JSONTEST_ASSERT(ok);
- JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
- JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
- JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
- JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
- JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
- JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
- JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
- JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
- JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
- JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
- JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
- JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
- JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
- JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
- JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
- JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
- JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
- JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
- JSONTEST_ASSERT(root.getOffsetStart() == 0);
- JSONTEST_ASSERT(root.getOffsetLimit() == 110);
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, omitEndingLineFeed) {
+ Json::FastWriter writer;
+ Json::Value nullValue;
+
+ JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
+
+ writer.omitEndingLineFeed();
+ JSONTEST_ASSERT(writer.write(nullValue) == "null");
}
-JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
- Json::Reader reader;
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNumericValue) {
+ Json::FastWriter writer;
+ const Json::String expected("{"
+ "\"emptyValue\":null,"
+ "\"false\":false,"
+ "\"null\":\"null\","
+ "\"number\":-6200000000000000.0,"
+ "\"real\":1.256,"
+ "\"uintValue\":17"
+ "}\n");
Json::Value root;
- bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
+ root["emptyValue"] = Json::nullValue;
+ root["false"] = false;
+ root["null"] = "null";
+ root["number"] = -6.2e+15;
+ root["real"] = 1.256;
+ root["uintValue"] = Json::Value(17U);
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeArrays) {
+ Json::FastWriter writer;
+ const Json::String expected("{"
+ "\"property1\":[\"value1\",\"value2\"],"
+ "\"property2\":[]"
+ "}\n");
+ Json::Value root;
+ root["property1"][0] = "value1";
+ root["property1"][1] = "value2";
+ root["property2"] = Json::arrayValue;
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNestedObjects) {
+ Json::FastWriter writer;
+ const Json::String expected("{"
+ "\"object1\":{"
+ "\"bool\":true,"
+ "\"nested\":123"
+ "},"
+ "\"object2\":{}"
+ "}\n");
+ Json::Value root, child;
+ child["nested"] = 123;
+ child["bool"] = true;
+ root["object1"] = child;
+ root["object2"] = Json::objectValue;
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+struct StyledWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNumericValue) {
+ Json::StyledWriter writer;
+ const Json::String expected("{\n"
+ " \"emptyValue\" : null,\n"
+ " \"false\" : false,\n"
+ " \"null\" : \"null\",\n"
+ " \"number\" : -6200000000000000.0,\n"
+ " \"real\" : 1.256,\n"
+ " \"uintValue\" : 17\n"
+ "}\n");
+ Json::Value root;
+ root["emptyValue"] = Json::nullValue;
+ root["false"] = false;
+ root["null"] = "null";
+ root["number"] = -6.2e+15;
+ root["real"] = 1.256;
+ root["uintValue"] = Json::Value(17U);
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeArrays) {
+ Json::StyledWriter writer;
+ const Json::String expected("{\n"
+ " \"property1\" : [ \"value1\", \"value2\" ],\n"
+ " \"property2\" : []\n"
+ "}\n");
+ Json::Value root;
+ root["property1"][0] = "value1";
+ root["property1"][1] = "value2";
+ root["property2"] = Json::arrayValue;
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNestedObjects) {
+ Json::StyledWriter writer;
+ const Json::String expected("{\n"
+ " \"object1\" : {\n"
+ " \"bool\" : true,\n"
+ " \"nested\" : 123\n"
+ " },\n"
+ " \"object2\" : {}\n"
+ "}\n");
+ Json::Value root, child;
+ child["nested"] = 123;
+ child["bool"] = true;
+ root["object1"] = child;
+ root["object2"] = Json::objectValue;
+
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, multiLineArray) {
+ Json::StyledWriter writer;
+ {
+ // Array member has more than 20 print effect rendering lines
+ const Json::String expected("[\n "
+ "0,\n 1,\n 2,\n "
+ "3,\n 4,\n 5,\n "
+ "6,\n 7,\n 8,\n "
+ "9,\n 10,\n 11,\n "
+ "12,\n 13,\n 14,\n "
+ "15,\n 16,\n 17,\n "
+ "18,\n 19,\n 20\n]\n");
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 21; i++)
+ root[i] = i;
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ // Array members do not exceed 21 print effects to render a single line
+ const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 10; i++)
+ root[i] = i;
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeValueWithComment) {
+ Json::StyledWriter writer;
+ {
+ const Json::String expected("\n//commentBeforeValue\n\"hello\"\n");
+ Json::Value root = "hello";
+ root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
+ Json::Value root = "hello";
+ root.setComment(Json::String("//commentAfterValueOnSameLine"),
+ Json::commentAfterOnSameLine);
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ const Json::String expected("\"hello\"\n//commentAfter\n\n");
+ Json::Value root = "hello";
+ root.setComment(Json::String("//commentAfter"), Json::commentAfter);
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+}
+
+struct StyledStreamWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNumericValue) {
+ Json::StyledStreamWriter writer;
+ const Json::String expected("{\n"
+ "\t\"emptyValue\" : null,\n"
+ "\t\"false\" : false,\n"
+ "\t\"null\" : \"null\",\n"
+ "\t\"number\" : -6200000000000000.0,\n"
+ "\t\"real\" : 1.256,\n"
+ "\t\"uintValue\" : 17\n"
+ "}\n");
+
+ Json::Value root;
+ root["emptyValue"] = Json::nullValue;
+ root["false"] = false;
+ root["null"] = "null";
+ root["number"] = -6.2e+15; // big float number
+ root["real"] = 1.256; // float number
+ root["uintValue"] = Json::Value(17U);
+
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeArrays) {
+ Json::StyledStreamWriter writer;
+ const Json::String expected("{\n"
+ "\t\"property1\" : [ \"value1\", \"value2\" ],\n"
+ "\t\"property2\" : []\n"
+ "}\n");
+ Json::Value root;
+ root["property1"][0] = "value1";
+ root["property1"][1] = "value2";
+ root["property2"] = Json::arrayValue;
+
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNestedObjects) {
+ Json::StyledStreamWriter writer;
+ const Json::String expected("{\n"
+ "\t\"object1\" : \n"
+ "\t"
+ "{\n"
+ "\t\t\"bool\" : true,\n"
+ "\t\t\"nested\" : 123\n"
+ "\t},\n"
+ "\t\"object2\" : {}\n"
+ "}\n");
+ Json::Value root, child;
+ child["nested"] = 123;
+ child["bool"] = true;
+ root["object1"] = child;
+ root["object2"] = Json::objectValue;
+
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, multiLineArray) {
+ {
+ // Array member has more than 20 print effect rendering lines
+ const Json::String expected("[\n\t0,"
+ "\n\t1,"
+ "\n\t2,"
+ "\n\t3,"
+ "\n\t4,"
+ "\n\t5,"
+ "\n\t6,"
+ "\n\t7,"
+ "\n\t8,"
+ "\n\t9,"
+ "\n\t10,"
+ "\n\t11,"
+ "\n\t12,"
+ "\n\t13,"
+ "\n\t14,"
+ "\n\t15,"
+ "\n\t16,"
+ "\n\t17,"
+ "\n\t18,"
+ "\n\t19,"
+ "\n\t20\n]\n");
+ Json::StyledStreamWriter writer;
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 21; i++)
+ root[i] = i;
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ Json::StyledStreamWriter writer;
+ // Array members do not exceed 21 print effects to render a single line
+ const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 10; i++)
+ root[i] = i;
+ Json::OStringStream sout;
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeValueWithComment) {
+ Json::StyledStreamWriter writer("\t");
+ {
+ const Json::String expected("//commentBeforeValue\n\"hello\"\n");
+ Json::Value root = "hello";
+ Json::OStringStream sout;
+ root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
+ Json::Value root = "hello";
+ Json::OStringStream sout;
+ root.setComment(Json::String("//commentAfterValueOnSameLine"),
+ Json::commentAfterOnSameLine);
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ const Json::String expected("\"hello\"\n//commentAfter\n");
+ Json::Value root = "hello";
+ Json::OStringStream sout;
+ root.setComment(Json::String("//commentAfter"), Json::commentAfter);
+ writer.write(sout, root);
+ const Json::String result = sout.str();
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+}
+
+struct StreamWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNumericValue) {
+ Json::StreamWriterBuilder writer;
+ const Json::String expected("{\n"
+ "\t\"emptyValue\" : null,\n"
+ "\t\"false\" : false,\n"
+ "\t\"null\" : \"null\",\n"
+ "\t\"number\" : -6200000000000000.0,\n"
+ "\t\"real\" : 1.256,\n"
+ "\t\"uintValue\" : 17\n"
+ "}");
+ Json::Value root;
+ root["emptyValue"] = Json::nullValue;
+ root["false"] = false;
+ root["null"] = "null";
+ root["number"] = -6.2e+15;
+ root["real"] = 1.256;
+ root["uintValue"] = Json::Value(17U);
+
+ const Json::String result = Json::writeString(writer, root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeArrays) {
+ Json::StreamWriterBuilder writer;
+ const Json::String expected("{\n"
+ "\t\"property1\" : \n"
+ "\t[\n"
+ "\t\t\"value1\",\n"
+ "\t\t\"value2\"\n"
+ "\t],\n"
+ "\t\"property2\" : []\n"
+ "}");
+
+ Json::Value root;
+ root["property1"][0] = "value1";
+ root["property1"][1] = "value2";
+ root["property2"] = Json::arrayValue;
+
+ const Json::String result = Json::writeString(writer, root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNestedObjects) {
+ Json::StreamWriterBuilder writer;
+ const Json::String expected("{\n"
+ "\t\"object1\" : \n"
+ "\t{\n"
+ "\t\t\"bool\" : true,\n"
+ "\t\t\"nested\" : 123\n"
+ "\t},\n"
+ "\t\"object2\" : {}\n"
+ "}");
+
+ Json::Value root, child;
+ child["nested"] = 123;
+ child["bool"] = true;
+ root["object1"] = child;
+ root["object2"] = Json::objectValue;
+
+ const Json::String result = Json::writeString(writer, root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, multiLineArray) {
+ Json::StreamWriterBuilder wb;
+ wb.settings_["commentStyle"] = "None";
+ {
+ // When wb.settings_["commentStyle"] = "None", the effect of
+ // printing multiple lines will be displayed when there are
+ // more than 20 array members.
+ const Json::String expected("[\n\t0,"
+ "\n\t1,"
+ "\n\t2,"
+ "\n\t3,"
+ "\n\t4,"
+ "\n\t5,"
+ "\n\t6,"
+ "\n\t7,"
+ "\n\t8,"
+ "\n\t9,"
+ "\n\t10,"
+ "\n\t11,"
+ "\n\t12,"
+ "\n\t13,"
+ "\n\t14,"
+ "\n\t15,"
+ "\n\t16,"
+ "\n\t17,"
+ "\n\t18,"
+ "\n\t19,"
+ "\n\t20\n]");
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 21; i++)
+ root[i] = i;
+ const Json::String result = Json::writeString(wb, root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+ {
+ // Array members do not exceed 21 print effects to render a single line
+ const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]");
+ Json::Value root;
+ for (Json::ArrayIndex i = 0; i < 10; i++)
+ root[i] = i;
+ const Json::String result = Json::writeString(wb, root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, dropNullPlaceholders) {
+ Json::StreamWriterBuilder b;
+ Json::Value nullValue;
+ b.settings_["dropNullPlaceholders"] = false;
+ JSONTEST_ASSERT(Json::writeString(b, nullValue) == "null");
+ b.settings_["dropNullPlaceholders"] = true;
+ JSONTEST_ASSERT(Json::writeString(b, nullValue).empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, enableYAMLCompatibility) {
+ Json::StreamWriterBuilder b;
+ Json::Value root;
+ root["hello"] = "world";
+
+ b.settings_["indentation"] = "";
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+
+ b.settings_["enableYAMLCompatibility"] = true;
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\": \"world\"}");
+
+ b.settings_["enableYAMLCompatibility"] = false;
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, indentation) {
+ Json::StreamWriterBuilder b;
+ Json::Value root;
+ root["hello"] = "world";
+
+ b.settings_["indentation"] = "";
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+
+ b.settings_["indentation"] = "\t";
+ JSONTEST_ASSERT(Json::writeString(b, root) ==
+ "{\n\t\"hello\" : \"world\"\n}");
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeZeroes) {
+ Json::String binary("hi", 3); // include trailing 0
+ JSONTEST_ASSERT_EQUAL(3, binary.length());
+ Json::String expected(R"("hi\u0000")"); // unicoded zero
+ Json::StreamWriterBuilder b;
+ {
+ Json::Value root;
+ root = binary;
+ JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
+ Json::String out = Json::writeString(b, root);
+ JSONTEST_ASSERT_EQUAL(expected.size(), out.size());
+ JSONTEST_ASSERT_STRING_EQUAL(expected, out);
+ }
+ {
+ Json::Value root;
+ root["top"] = binary;
+ JSONTEST_ASSERT_STRING_EQUAL(binary, root["top"].asString());
+ Json::String out = Json::writeString(b, root["top"]);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, out);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, unicode) {
+ // Create a Json value containing UTF-8 string with some chars that need
+ // escape (tab,newline).
+ Json::Value root;
+ root["test"] = "\t\n\xF0\x91\xA2\xA1\x3D\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7";
+
+ Json::StreamWriterBuilder b;
+
+ // Default settings - should be unicode escaped.
+ JSONTEST_ASSERT(Json::writeString(b, root) ==
+ "{\n\t\"test\" : "
+ "\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
+
+ b.settings_["emitUTF8"] = true;
+
+ // Should not be unicode escaped.
+ JSONTEST_ASSERT(
+ Json::writeString(b, root) ==
+ "{\n\t\"test\" : "
+ "\"\\t\\n\xF0\x91\xA2\xA1=\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7\"\n}");
+
+ b.settings_["emitUTF8"] = false;
+
+ // Should be unicode escaped.
+ JSONTEST_ASSERT(Json::writeString(b, root) ==
+ "{\n\t\"test\" : "
+ "\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
+}
+
+// Control chars should be escaped regardless of UTF-8 input encoding.
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeControlCharacters) {
+ auto uEscape = [](unsigned ch) {
+ static const char h[] = "0123456789abcdef";
+ std::string r = "\\u";
+ r += h[(ch >> (3 * 4)) & 0xf];
+ r += h[(ch >> (2 * 4)) & 0xf];
+ r += h[(ch >> (1 * 4)) & 0xf];
+ r += h[(ch >> (0 * 4)) & 0xf];
+ return r;
+ };
+ auto shortEscape = [](unsigned ch) -> const char* {
+ switch (ch) {
+ case '\"':
+ return "\\\"";
+ case '\\':
+ return "\\\\";
+ case '\b':
+ return "\\b";
+ case '\f':
+ return "\\f";
+ case '\n':
+ return "\\n";
+ case '\r':
+ return "\\r";
+ case '\t':
+ return "\\t";
+ default:
+ return nullptr;
+ }
+ };
+
+ Json::StreamWriterBuilder b;
+
+ for (bool emitUTF8 : {true, false}) {
+ b.settings_["emitUTF8"] = emitUTF8;
+
+ for (unsigned i = 0; i != 0x100; ++i) {
+ if (!emitUTF8 && i >= 0x80)
+ break; // The algorithm would try to parse UTF-8, so stop here.
+
+ std::string raw({static_cast<char>(i)});
+ std::string esc = raw;
+ if (i < 0x20)
+ esc = uEscape(i);
+ if (const char* shEsc = shortEscape(i))
+ esc = shEsc;
+
+ // std::cout << "emit=" << emitUTF8 << ", i=" << std::hex << i << std::dec
+ // << std::endl;
+
+ Json::Value root;
+ root["test"] = raw;
+ JSONTEST_ASSERT_STRING_EQUAL(
+ std::string("{\n\t\"test\" : \"").append(esc).append("\"\n}"),
+ Json::writeString(b, root))
+ << ", emit=" << emitUTF8 << ", i=" << i << ", raw=\"" << raw << "\""
+ << ", esc=\"" << esc << "\"";
+ }
+ }
+}
+
+#ifdef _WIN32
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeTabCharacterWindows) {
+ // Get the current locale before changing it
+ std::string currentLocale = setlocale(LC_ALL, NULL);
+ setlocale(LC_ALL, "English_United States.1252");
+
+ Json::Value root;
+ root["test"] = "\tTabTesting\t";
+
+ Json::StreamWriterBuilder b;
+
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+ "\"\\tTabTesting\\t\"\n}");
+
+ b.settings_["emitUTF8"] = true;
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+ "\"\\tTabTesting\\t\"\n}");
+
+ b.settings_["emitUTF8"] = false;
+ JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+ "\"\\tTabTesting\\t\"\n}");
+
+ // Restore the locale
+ if (!currentLocale.empty())
+ setlocale(LC_ALL, currentLocale.c_str());
+}
+#endif
+
+struct ReaderTest : JsonTest::TestCase {
+ void setStrictMode() {
+ reader = std::unique_ptr<Json::Reader>(
+ new Json::Reader(Json::Features{}.strictMode()));
+ }
+
+ void setFeatures(Json::Features& features) {
+ reader = std::unique_ptr<Json::Reader>(new Json::Reader(features));
+ }
+
+ void checkStructuredErrors(
+ const std::vector<Json::Reader::StructuredError>& actual,
+ const std::vector<Json::Reader::StructuredError>& expected) {
+ JSONTEST_ASSERT_EQUAL(expected.size(), actual.size());
+ for (size_t i = 0; i < actual.size(); ++i) {
+ const auto& a = actual[i];
+ const auto& e = expected[i];
+ JSONTEST_ASSERT_EQUAL(e.offset_start, a.offset_start) << i;
+ JSONTEST_ASSERT_EQUAL(e.offset_limit, a.offset_limit) << i;
+ JSONTEST_ASSERT_EQUAL(e.message, a.message) << i;
+ }
+ }
+
+ template <typename Input> void checkParse(Input&& input) {
+ JSONTEST_ASSERT(reader->parse(input, root));
+ }
+
+ template <typename Input>
+ void
+ checkParse(Input&& input,
+ const std::vector<Json::Reader::StructuredError>& structured) {
+ JSONTEST_ASSERT(!reader->parse(input, root));
+ checkStructuredErrors(reader->getStructuredErrors(), structured);
+ }
+
+ template <typename Input>
+ void checkParse(Input&& input,
+ const std::vector<Json::Reader::StructuredError>& structured,
+ const std::string& formatted) {
+ checkParse(input, structured);
+ JSONTEST_ASSERT_EQUAL(formatted, reader->getFormattedErrorMessages());
+ }
+
+ std::unique_ptr<Json::Reader> reader{new Json::Reader()};
+ Json::Value root;
+};
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrors) {
+ checkParse(R"({ "property" : "value" })");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseObject) {
+ checkParse(R"({"property"})",
+ {{11, 12, "Missing ':' after object member name"}},
+ "* Line 1, Column 12\n Missing ':' after object member name\n");
+ checkParse(
+ R"({"property" : "value" )",
+ {{22, 22, "Missing ',' or '}' in object declaration"}},
+ "* Line 1, Column 23\n Missing ',' or '}' in object declaration\n");
+ checkParse(R"({"property" : "value", )",
+ {{23, 23, "Missing '}' or object member name"}},
+ "* Line 1, Column 24\n Missing '}' or object member name\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseArray) {
+ checkParse(
+ R"([ "value" )", {{10, 10, "Missing ',' or ']' in array declaration"}},
+ "* Line 1, Column 11\n Missing ',' or ']' in array declaration\n");
+ checkParse(
+ R"([ "value1" "value2" ] )",
+ {{11, 19, "Missing ',' or ']' in array declaration"}},
+ "* Line 1, Column 12\n Missing ',' or ']' in array declaration\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseString) {
+ checkParse(R"([ "\u8a2a" ])");
+ checkParse(
+ R"([ "\ud801" ])",
+ {{2, 10,
+ "additional six characters expected to parse unicode surrogate "
+ "pair."}},
+ "* Line 1, Column 3\n"
+ " additional six characters expected to parse unicode surrogate pair.\n"
+ "See Line 1, Column 10 for detail.\n");
+ checkParse(R"([ "\ud801\d1234" ])",
+ {{2, 16,
+ "expecting another \\u token to begin the "
+ "second half of a unicode surrogate pair"}},
+ "* Line 1, Column 3\n"
+ " expecting another \\u token to begin the "
+ "second half of a unicode surrogate pair\n"
+ "See Line 1, Column 12 for detail.\n");
+ checkParse(R"([ "\ua3t@" ])",
+ {{2, 10,
+ "Bad unicode escape sequence in string: "
+ "hexadecimal digit expected."}},
+ "* Line 1, Column 3\n"
+ " Bad unicode escape sequence in string: "
+ "hexadecimal digit expected.\n"
+ "See Line 1, Column 9 for detail.\n");
+ checkParse(
+ R"([ "\ua3t" ])",
+ {{2, 9, "Bad unicode escape sequence in string: four digits expected."}},
+ "* Line 1, Column 3\n"
+ " Bad unicode escape sequence in string: four digits expected.\n"
+ "See Line 1, Column 6 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseComment) {
+ checkParse(
+ R"({ /*commentBeforeValue*/ "property" : "value" }//commentAfterValue)"
+ "\n");
+ checkParse(" true //comment1\n//comment2\r//comment3\r\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, streamParseWithNoErrors) {
+ std::string styled = R"({ "property" : "value" })";
+ std::istringstream iss(styled);
+ checkParse(iss);
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrorsTestingOffsets) {
+ checkParse(R"({)"
+ R"( "property" : ["value", "value2"],)"
+ R"( "obj" : { "nested" : -6.2e+15, "bool" : true},)"
+ R"( "null" : null,)"
+ R"( "false" : false)"
+ R"( })");
+ auto checkOffsets = [&](const Json::Value& v, int start, int limit) {
+ JSONTEST_ASSERT_EQUAL(start, v.getOffsetStart());
+ JSONTEST_ASSERT_EQUAL(limit, v.getOffsetLimit());
+ };
+ checkOffsets(root, 0, 115);
+ checkOffsets(root["property"], 15, 34);
+ checkOffsets(root["property"][0], 16, 23);
+ checkOffsets(root["property"][1], 25, 33);
+ checkOffsets(root["obj"], 44, 81);
+ checkOffsets(root["obj"]["nested"], 57, 65);
+ checkOffsets(root["obj"]["bool"], 76, 80);
+ checkOffsets(root["null"], 92, 96);
+ checkOffsets(root["false"], 108, 113);
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithOneError) {
+ checkParse(R"({ "property" :: "value" })",
+ {{14, 15, "Syntax error: value, object or array expected."}},
+ "* Line 1, Column 15\n Syntax error: value, object or array "
+ "expected.\n");
+ checkParse("s", {{0, 1, "Syntax error: value, object or array expected."}},
+ "* Line 1, Column 1\n Syntax error: value, object or array "
+ "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseSpecialFloat) {
+ checkParse(R"({ "a" : Infi })",
+ {{8, 9, "Syntax error: value, object or array expected."}},
+ "* Line 1, Column 9\n Syntax error: value, object or array "
+ "expected.\n");
+ checkParse(R"({ "a" : Infiniaa })",
+ {{8, 9, "Syntax error: value, object or array expected."}},
+ "* Line 1, Column 9\n Syntax error: value, object or array "
+ "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, strictModeParseNumber) {
+ setStrictMode();
+ checkParse(
+ "123",
+ {{0, 3,
+ "A valid JSON document must be either an array or an object value."}},
+ "* Line 1, Column 1\n"
+ " A valid JSON document must be either an array or an object value.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseChineseWithOneError) {
+ checkParse(R"({ "pr)"
+ u8"\u4f50\u85e4" // 佐藤
+ R"(erty" :: "value" })",
+ {{18, 19, "Syntax error: value, object or array expected."}},
+ "* Line 1, Column 19\n Syntax error: value, object or array "
+ "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithDetailError) {
+ checkParse(R"({ "property" : "v\alue" })",
+ {{15, 23, "Bad escape sequence in string"}},
+ "* Line 1, Column 16\n"
+ " Bad escape sequence in string\n"
+ "See Line 1, Column 20 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, pushErrorTest) {
+ checkParse(R"({ "AUTHOR" : 123 })");
+ if (!root["AUTHOR"].isString()) {
+ JSONTEST_ASSERT(
+ reader->pushError(root["AUTHOR"], "AUTHOR must be a string"));
+ }
+ JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
+ "* Line 1, Column 14\n"
+ " AUTHOR must be a string\n");
+
+ checkParse(R"({ "AUTHOR" : 123 })");
+ if (!root["AUTHOR"].isString()) {
+ JSONTEST_ASSERT(reader->pushError(root["AUTHOR"], "AUTHOR must be a string",
+ root["AUTHOR"]));
+ }
+ JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
+ "* Line 1, Column 14\n"
+ " AUTHOR must be a string\n"
+ "See Line 1, Column 14 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, allowNumericKeysTest) {
+ Json::Features features;
+ features.allowNumericKeys_ = true;
+ setFeatures(features);
+ checkParse(R"({ 123 : "abc" })");
+}
+
+struct CharReaderTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrors) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ Json::Value root;
+ char const doc[] = R"({ "property" : "value" })";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrorsTestingOffsets) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ Json::Value root;
+ char const doc[] = "{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
+ "{ \"nested\" : -6.2e+15, \"num\" : +123, \"bool\" : "
+ "true}, \"null\" : null, \"false\" : false }";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseNumber) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ Json::Value root;
+ {
+ // if intvalue > threshold, treat the number as a double.
+ // 21 digits
+ char const doc[] = "[111111111111111111111]";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL(1.1111111111111111e+020, root[0]);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseString) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = "[\"\"]";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL("", root[0]);
+ }
+ {
+ char const doc[] = R"(["\u8A2a"])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL(u8"\u8A2a", root[0].asString()); // "訪"
+ }
+ {
+ char const doc[] = R"([ "\uD801" ])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+ " additional six characters expected to "
+ "parse unicode surrogate pair.\n"
+ "See Line 1, Column 10 for detail.\n");
+ }
+ {
+ char const doc[] = R"([ "\uD801\d1234" ])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+ " expecting another \\u token to begin the "
+ "second half of a unicode surrogate pair\n"
+ "See Line 1, Column 12 for detail.\n");
+ }
+ {
+ char const doc[] = R"([ "\ua3t@" ])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+ " Bad unicode escape sequence in string: "
+ "hexadecimal digit expected.\n"
+ "See Line 1, Column 9 for detail.\n");
+ }
+ {
+ char const doc[] = R"([ "\ua3t" ])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(
+ errs ==
+ "* Line 1, Column 3\n"
+ " Bad unicode escape sequence in string: four digits expected.\n"
+ "See Line 1, Column 6 for detail.\n");
+ }
+ {
+ b.settings_["allowSingleQuotes"] = true;
+ CharReaderPtr charreader(b.newCharReader());
+ char const doc[] = R"({'a': 'x\ty', "b":'x\\y'})";
+ bool ok = charreader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_STRING_EQUAL("x\ty", root["a"].asString());
+ JSONTEST_ASSERT_STRING_EQUAL("x\\y", root["b"].asString());
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseComment) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = "//comment1\n { //comment2\n \"property\" :"
+ " \"value\" //comment3\n } //comment4\n";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+ }
+ {
+ char const doc[] = "{ \"property\" //comment\n : \"value\" }";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 14\n"
+ " Missing ':' after object member name\n");
+ }
+ {
+ char const doc[] = "//comment1\n [ //comment2\n \"value\" //comment3\n,"
+ " //comment4\n true //comment5\n ] //comment6\n";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL("value", root[0]);
+ JSONTEST_ASSERT_EQUAL(true, root[1]);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseObjectWithErrors) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = R"({ "property" : "value" )";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 24\n"
+ " Missing ',' or '}' in object declaration\n");
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+ }
+ {
+ char const doc[] = R"({ "property" : "value" ,)";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 25\n"
+ " Missing '}' or object member name\n");
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseArrayWithErrors) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = "[ \"value\" ";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 11\n"
+ " Missing ',' or ']' in array declaration\n");
+ JSONTEST_ASSERT_EQUAL("value", root[0]);
+ }
+ {
+ char const doc[] = R"([ "value1" "value2" ])";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(errs == "* Line 1, Column 12\n"
+ " Missing ',' or ']' in array declaration\n");
+ JSONTEST_ASSERT_EQUAL("value1", root[0]);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithOneError) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ Json::Value root;
+ char const doc[] = R"({ "property" :: "value" })";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
- JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ JSONTEST_ASSERT(errs ==
"* Line 1, Column 15\n Syntax error: value, object or array "
"expected.\n");
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT(errors.size() == 1);
- JSONTEST_ASSERT(errors.at(0).offset_start == 14);
- JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
- JSONTEST_ASSERT(errors.at(0).message ==
- "Syntax error: value, object or array expected.");
}
-JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
- Json::Reader reader;
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseChineseWithOneError) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
Json::Value root;
- bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
+ char const doc[] = "{ \"pr佐藤erty\" :: \"value\" }";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
- JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ JSONTEST_ASSERT(errs ==
"* Line 1, Column 19\n Syntax error: value, object or array "
"expected.\n");
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT(errors.size() == 1);
- JSONTEST_ASSERT(errors.at(0).offset_start == 18);
- JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
- JSONTEST_ASSERT(errors.at(0).message ==
- "Syntax error: value, object or array expected.");
}
-JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
- Json::Reader reader;
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithDetailError) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
Json::Value root;
- bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
+ char const doc[] = R"({ "property" : "v\alue" })";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
- JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ JSONTEST_ASSERT(errs ==
"* Line 1, Column 16\n Bad escape sequence in string\nSee "
"Line 1, Column 20 for detail.\n");
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT(errors.size() == 1);
- JSONTEST_ASSERT(errors.at(0).offset_start == 15);
- JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
- JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithStackLimit) {
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] = R"({ "property" : "value" })";
+ {
+ b.settings_["stackLimit"] = 2;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+ }
+ {
+ b.settings_["stackLimit"] = 1;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ JSONTEST_ASSERT_THROWS(
+ reader->parse(doc, doc + std::strlen(doc), &root, &errs));
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, testOperator) {
+ const std::string styled = R"({ "property" : "value" })";
+ std::istringstream iss(styled);
+ Json::Value root;
+ iss >> root;
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+}
+
+struct CharReaderStrictModeTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderStrictModeTest, dupKeys) {
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] =
+ R"({ "property" : "value", "key" : "val1", "key" : "val2" })";
+ {
+ b.strictMode(&b.settings_);
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 41\n"
+ " Duplicate key: 'key'\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL("val1", root["key"]); // so far
+ }
+}
+struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue164) {
+ // This is interpreted as a string value followed by a colon.
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] = R"( "property" : "value" })";
+ {
+ b.settings_["failIfExtra"] = false;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_EQUAL("property", root);
+ }
+ {
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
+ " Extra non-whitespace after JSON value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL("property", root);
+ }
+ {
+ b.strictMode(&b.settings_);
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
+ " Extra non-whitespace after JSON value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL("property", root);
+ }
+ {
+ b.strictMode(&b.settings_);
+ b.settings_["failIfExtra"] = false;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "* Line 1, Column 1\n"
+ " A valid JSON document must be either an array or an object value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL("property", root);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue107) {
+ // This is interpreted as an int value followed by a colon.
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] = "1:2:3";
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 2\n"
+ " Extra non-whitespace after JSON value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL(1, root.asInt());
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterObject) {
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ {
+ char const doc[] = "{ \"property\" : \"value\" } //trailing\n//comment\n";
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL("value", root["property"]);
+ }
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterArray) {
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] = "[ \"property\" , \"value\" ] //trailing\n//comment\n";
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL("value", root[1u]);
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterBool) {
+ Json::CharReaderBuilder b;
+ Json::Value root;
+ char const doc[] = " true /*trailing\ncomment*/";
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::String errs;
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(true, root.asBool());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, parseComment) {
+ Json::CharReaderBuilder b;
+ b.settings_["failIfExtra"] = true;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = " true //comment1\n//comment2\r//comment3\r\n";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(true, root.asBool());
+ }
+ {
+ char const doc[] = " true //com\rment";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
+ " Extra non-whitespace after JSON value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL(true, root.asBool());
+ }
+ {
+ char const doc[] = " true //com\nment";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
+ " Extra non-whitespace after JSON value.\n",
+ errs);
+ JSONTEST_ASSERT_EQUAL(true, root.asBool());
+ }
+}
+
+struct CharReaderAllowDropNullTest : JsonTest::TestCase {
+ using Value = Json::Value;
+ using ValueCheck = std::function<void(const Value&)>;
+
+ Value nullValue = Value{Json::nullValue};
+ Value emptyArray = Value{Json::arrayValue};
+
+ ValueCheck checkEq(const Value& v) {
+ return [=](const Value& root) { JSONTEST_ASSERT_EQUAL(root, v); };
+ }
+
+ static ValueCheck objGetAnd(std::string idx, ValueCheck f) {
+ return [=](const Value& root) { f(root.get(idx, true)); };
+ }
+
+ static ValueCheck arrGetAnd(int idx, ValueCheck f) {
+ return [=](const Value& root) { f(root[idx]); };
+ }
+};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowDropNullTest, issue178) {
+ struct TestSpec {
+ int line;
+ std::string doc;
+ size_t rootSize;
+ ValueCheck onRoot;
+ };
+ const TestSpec specs[] = {
+ {__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
+ {__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
+ {__LINE__, R"({"a":})", 1, objGetAnd("a", checkEq(nullValue))},
+ {__LINE__, "[]", 0, checkEq(emptyArray)},
+ {__LINE__, "[null]", 1, nullptr},
+ {__LINE__, "[,]", 2, nullptr},
+ {__LINE__, "[,,,]", 4, nullptr},
+ {__LINE__, "[null,]", 2, nullptr},
+ {__LINE__, "[,null]", 2, nullptr},
+ {__LINE__, "[,,]", 3, nullptr},
+ {__LINE__, "[null,,]", 3, nullptr},
+ {__LINE__, "[,null,]", 3, nullptr},
+ {__LINE__, "[,,null]", 3, nullptr},
+ {__LINE__, "[[],,,]", 4, arrGetAnd(0, checkEq(emptyArray))},
+ {__LINE__, "[,[],,]", 4, arrGetAnd(1, checkEq(emptyArray))},
+ {__LINE__, "[,,,[]]", 4, arrGetAnd(3, checkEq(emptyArray))},
+ };
+ for (const auto& spec : specs) {
+ Json::CharReaderBuilder b;
+ b.settings_["allowDroppedNullPlaceholders"] = true;
+ std::unique_ptr<Json::CharReader> reader(b.newCharReader());
+
+ Json::Value root;
+ Json::String errs;
+ bool ok = reader->parse(spec.doc.data(), spec.doc.data() + spec.doc.size(),
+ &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL(errs, "");
+ if (spec.onRoot) {
+ spec.onRoot(root);
+ }
+ }
+}
+
+struct CharReaderAllowNumericKeysTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowNumericKeysTest, allowNumericKeys) {
+ Json::CharReaderBuilder b;
+ b.settings_["allowNumericKeys"] = true;
+ Json::Value root;
+ Json::String errs;
+ CharReaderPtr reader(b.newCharReader());
+ char const doc[] = "{15:true,-16:true,12.01:true}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(3u, root.size());
+ JSONTEST_ASSERT_EQUAL(true, root.get("15", false));
+ JSONTEST_ASSERT_EQUAL(true, root.get("-16", false));
+ JSONTEST_ASSERT_EQUAL(true, root.get("12.01", false));
+}
+
+struct CharReaderAllowSingleQuotesTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSingleQuotesTest, issue182) {
+ Json::CharReaderBuilder b;
+ b.settings_["allowSingleQuotes"] = true;
+ Json::Value root;
+ Json::String errs;
+ CharReaderPtr reader(b.newCharReader());
+ {
+ char const doc[] = "{'a':true,\"b\":true}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
+ JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
+ }
+ {
+ char const doc[] = "{'a': 'x', \"b\":'y'}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
+ JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
+ }
+}
+
+struct CharReaderAllowZeroesTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowZeroesTest, issue176) {
+ Json::CharReaderBuilder b;
+ b.settings_["allowSingleQuotes"] = true;
+ Json::Value root;
+ Json::String errs;
+ CharReaderPtr reader(b.newCharReader());
+ {
+ char const doc[] = "{'a':true,\"b\":true}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
+ JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
+ }
+ {
+ char const doc[] = "{'a': 'x', \"b\":'y'}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
+ JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
+ }
+}
+
+struct CharReaderAllowSpecialFloatsTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, specialFloat) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ {
+ char const doc[] = "{\"a\": NaN}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "* Line 1, Column 7\n"
+ " Syntax error: value, object or array expected.\n",
+ errs);
+ }
+ {
+ char const doc[] = "{\"a\": Infinity}";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT_STRING_EQUAL(
+ "* Line 1, Column 7\n"
+ " Syntax error: value, object or array expected.\n",
+ errs);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, issue209) {
+ Json::CharReaderBuilder b;
+ b.settings_["allowSpecialFloats"] = true;
+ Json::Value root;
+ Json::String errs;
+ CharReaderPtr reader(b.newCharReader());
+ {
+ char const doc[] = R"({"a":NaN,"b":Infinity,"c":-Infinity,"d":+Infinity})";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(4u, root.size());
+ double n = root["a"].asDouble();
+ JSONTEST_ASSERT(std::isnan(n));
+ JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+ root.get("b", 0.0));
+ JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
+ root.get("c", 0.0));
+ JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+ root.get("d", 0.0));
+ }
+
+ struct TestData {
+ int line;
+ bool ok;
+ Json::String in;
+ };
+ const TestData test_data[] = {
+ {__LINE__, true, "{\"a\":9}"}, //
+ {__LINE__, false, "{\"a\":0Infinity}"}, //
+ {__LINE__, false, "{\"a\":1Infinity}"}, //
+ {__LINE__, false, "{\"a\":9Infinity}"}, //
+ {__LINE__, false, "{\"a\":0nfinity}"}, //
+ {__LINE__, false, "{\"a\":1nfinity}"}, //
+ {__LINE__, false, "{\"a\":9nfinity}"}, //
+ {__LINE__, false, "{\"a\":nfinity}"}, //
+ {__LINE__, false, "{\"a\":.nfinity}"}, //
+ {__LINE__, false, "{\"a\":9nfinity}"}, //
+ {__LINE__, false, "{\"a\":-nfinity}"}, //
+ {__LINE__, true, "{\"a\":Infinity}"}, //
+ {__LINE__, false, "{\"a\":.Infinity}"}, //
+ {__LINE__, false, "{\"a\":_Infinity}"}, //
+ {__LINE__, false, "{\"a\":_nfinity}"}, //
+ {__LINE__, true, "{\"a\":-Infinity}"}, //
+ {__LINE__, true, "{\"a\":+Infinity}"} //
+ };
+ for (const auto& td : test_data) {
+ bool ok = reader->parse(&*td.in.begin(), &*td.in.begin() + td.in.size(),
+ &root, &errs);
+ JSONTEST_ASSERT(td.ok == ok) << "line:" << td.line << "\n"
+ << " expected: {"
+ << "ok:" << td.ok << ", in:\'" << td.in << "\'"
+ << "}\n"
+ << " actual: {"
+ << "ok:" << ok << "}\n";
+ }
+
+ {
+ char const doc[] = R"({"posInf": +Infinity, "NegInf": -Infinity})";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT_STRING_EQUAL("", errs);
+ JSONTEST_ASSERT_EQUAL(2u, root.size());
+ JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+ root["posInf"].asDouble());
+ JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
+ root["NegInf"].asDouble());
+ }
+}
+
+struct EscapeSequenceTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, readerParseEscapeSequence) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
+ "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+ "\"\\u0278\",\"\\ud852\\udf62\"]\n",
+ root);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages().empty());
+ JSONTEST_ASSERT(reader.getStructuredErrors().empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, charReaderParseEscapeSequence) {
+ Json::CharReaderBuilder b;
+ CharReaderPtr reader(b.newCharReader());
+ Json::Value root;
+ Json::String errs;
+ char const doc[] = "[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
+ "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+ "\"\\u0278\",\"\\ud852\\udf62\"]";
+ bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, writeEscapeSequence) {
+ Json::FastWriter writer;
+ const Json::String expected("[\"\\\"\",\"\\\\\",\"\\b\","
+ "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+ "\"\\u0278\",\"\\ud852\\udf62\"]\n");
+ Json::Value root;
+ root[0] = "\"";
+ root[1] = "\\";
+ root[2] = "\b";
+ root[3] = "\f";
+ root[4] = "\n";
+ root[5] = "\r";
+ root[6] = "\t";
+ root[7] = "ɸ";
+ root[8] = "𤭢";
+ const Json::String result = writer.write(root);
+ JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+struct BuilderTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(BuilderTest, settings) {
+ {
+ Json::Value errs;
+ Json::CharReaderBuilder rb;
+ JSONTEST_ASSERT_EQUAL(false, rb.settings_.isMember("foo"));
+ JSONTEST_ASSERT_EQUAL(true, rb.validate(&errs));
+ rb["foo"] = "bar";
+ JSONTEST_ASSERT_EQUAL(true, rb.settings_.isMember("foo"));
+ JSONTEST_ASSERT_EQUAL(false, rb.validate(&errs));
+ }
+ {
+ Json::Value errs;
+ Json::StreamWriterBuilder wb;
+ JSONTEST_ASSERT_EQUAL(false, wb.settings_.isMember("foo"));
+ JSONTEST_ASSERT_EQUAL(true, wb.validate(&errs));
+ wb["foo"] = "bar";
+ JSONTEST_ASSERT_EQUAL(true, wb.settings_.isMember("foo"));
+ JSONTEST_ASSERT_EQUAL(false, wb.validate(&errs));
+ }
+}
+
+struct BomTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(BomTest, skipBom) {
+ const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
+ Json::Value root;
+ JSONCPP_STRING errs;
+ std::istringstream iss(with_bom);
+ bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
+ // The default behavior is to skip the BOM, so we can parse it normally.
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(errs.empty());
+ JSONTEST_ASSERT_STRING_EQUAL(root["key"].asString(), "value");
+}
+JSONTEST_FIXTURE_LOCAL(BomTest, notSkipBom) {
+ const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
+ Json::Value root;
+ JSONCPP_STRING errs;
+ std::istringstream iss(with_bom);
+ Json::CharReaderBuilder b;
+ b.settings_["skipBom"] = false;
+ bool ok = parseFromStream(b, iss, &root, &errs);
+ // Detect the BOM, and failed on it.
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(!errs.empty());
+}
+
+struct IteratorTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, convert) {
+ Json::Value j;
+ const Json::Value& cj = j;
+ auto it = j.begin();
+ Json::Value::const_iterator cit;
+ cit = it;
+ JSONTEST_ASSERT(cit == cj.begin());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, decrement) {
+ Json::Value json;
+ json["k1"] = "a";
+ json["k2"] = "b";
+ std::vector<std::string> values;
+ for (auto it = json.end(); it != json.begin();) {
+ --it;
+ values.push_back(it->asString());
+ }
+ JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, reverseIterator) {
+ Json::Value json;
+ json["k1"] = "a";
+ json["k2"] = "b";
+ std::vector<std::string> values;
+ using Iter = decltype(json.begin());
+ auto re = std::reverse_iterator<Iter>(json.begin());
+ for (auto it = std::reverse_iterator<Iter>(json.end()); it != re; ++it) {
+ values.push_back(it->asString());
+ }
+ JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, distance) {
+ {
+ Json::Value json;
+ json["k1"] = "a";
+ json["k2"] = "b";
+ int i = 0;
+ auto it = json.begin();
+ for (;; ++it, ++i) {
+ auto dist = it - json.begin();
+ JSONTEST_ASSERT_EQUAL(i, dist);
+ if (it == json.end())
+ break;
+ }
+ }
+ {
+ Json::Value empty;
+ JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.end());
+ JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.begin());
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, nullValues) {
+ {
+ Json::Value json;
+ auto end = json.end();
+ auto endCopy = end;
+ JSONTEST_ASSERT(endCopy == end);
+ endCopy = end;
+ JSONTEST_ASSERT(endCopy == end);
+ }
+ {
+ // Same test, now with const Value.
+ const Json::Value json;
+ auto end = json.end();
+ auto endCopy = end;
+ JSONTEST_ASSERT(endCopy == end);
+ endCopy = end;
+ JSONTEST_ASSERT(endCopy == end);
+ }
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, staticStringKey) {
+ Json::Value json;
+ json[Json::StaticString("k1")] = "a";
+ JSONTEST_ASSERT_EQUAL(Json::Value("k1"), json.begin().key());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, names) {
+ Json::Value json;
+ json["k1"] = "a";
+ json["k2"] = "b";
+ Json::ValueIterator it = json.begin();
+ JSONTEST_ASSERT(it != json.end());
+ JSONTEST_ASSERT_EQUAL(Json::Value("k1"), it.key());
+ JSONTEST_ASSERT_STRING_EQUAL("k1", it.name());
+ JSONTEST_ASSERT_STRING_EQUAL("k1", it.memberName());
+ JSONTEST_ASSERT_EQUAL(-1, it.index());
+ ++it;
+ JSONTEST_ASSERT(it != json.end());
+ JSONTEST_ASSERT_EQUAL(Json::Value("k2"), it.key());
+ JSONTEST_ASSERT_STRING_EQUAL("k2", it.name());
+ JSONTEST_ASSERT_STRING_EQUAL("k2", it.memberName());
+ JSONTEST_ASSERT_EQUAL(-1, it.index());
+ ++it;
+ JSONTEST_ASSERT(it == json.end());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, indexes) {
+ Json::Value json;
+ json[0] = "a";
+ json[1] = "b";
+ Json::ValueIterator it = json.begin();
+ JSONTEST_ASSERT(it != json.end());
+ JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(0)), it.key());
+ JSONTEST_ASSERT_STRING_EQUAL("", it.name());
+ JSONTEST_ASSERT_EQUAL(0, it.index());
+ ++it;
+ JSONTEST_ASSERT(it != json.end());
+ JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(1)), it.key());
+ JSONTEST_ASSERT_STRING_EQUAL("", it.name());
+ JSONTEST_ASSERT_EQUAL(1, it.index());
+ ++it;
+ JSONTEST_ASSERT(it == json.end());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, constness) {
+ Json::Value const v;
+ JSONTEST_ASSERT_THROWS(
+ Json::Value::iterator it(v.begin())); // Compile, but throw.
+
+ Json::Value value;
+
+ for (int i = 9; i < 12; ++i) {
+ Json::OStringStream out;
+ out << std::setw(2) << i;
+ Json::String str = out.str();
+ value[str] = str;
+ }
+
+ Json::OStringStream out;
+ // in old code, this will get a compile error
+ Json::Value::const_iterator iter = value.begin();
+ for (; iter != value.end(); ++iter) {
+ out << *iter << ',';
+ }
+ Json::String expected = R"(" 9","10","11",)";
+ JSONTEST_ASSERT_STRING_EQUAL(expected, out.str());
+}
+
+struct RValueTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(RValueTest, moveConstruction) {
+ Json::Value json;
+ json["key"] = "value";
+ Json::Value moved = std::move(json);
+ JSONTEST_ASSERT(moved != json); // Possibly not nullValue; definitely not
+ // equal.
+ JSONTEST_ASSERT_EQUAL(Json::objectValue, moved.type());
+ JSONTEST_ASSERT_EQUAL(Json::stringValue, moved["key"].type());
+}
+
+struct FuzzTest : JsonTest::TestCase {};
+
+// Build and run the fuzz test without any fuzzer, so that it's guaranteed not
+// go out of date, even if it's never run as an actual fuzz test.
+JSONTEST_FIXTURE_LOCAL(FuzzTest, fuzzDoesntCrash) {
+ const std::string example = "{}";
+ JSONTEST_ASSERT_EQUAL(
+ 0,
+ LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t*>(example.c_str()),
+ example.size()));
}
int main(int argc, const char* argv[]) {
JsonTest::Runner runner;
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
- JSONTEST_REGISTER_FIXTURE(runner, ValueTest, typeChecksThrowExceptions);
- JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
- JSONTEST_REGISTER_FIXTURE(
- runner, ReaderTest, parseWithNoErrorsTestingOffsets);
- JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
- JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
- JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
-
- JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
+ for (auto& local : local_) {
+ runner.add(local);
+ }
return runner.runCommandLine(argc, argv);
}
+
+struct MemberTemplateAs : JsonTest::TestCase {
+ template <typename T, typename F>
+ JsonTest::TestResult& EqEval(T v, F f) const {
+ const Json::Value j = v;
+ return JSONTEST_ASSERT_EQUAL(j.as<T>(), f(j));
+ }
+};
+
+JSONTEST_FIXTURE_LOCAL(MemberTemplateAs, BehavesSameAsNamedAs) {
+ const Json::Value jstr = "hello world";
+ JSONTEST_ASSERT_STRING_EQUAL(jstr.as<const char*>(), jstr.asCString());
+ JSONTEST_ASSERT_STRING_EQUAL(jstr.as<Json::String>(), jstr.asString());
+ EqEval(Json::Int(64), [](const Json::Value& j) { return j.asInt(); });
+ EqEval(Json::UInt(64), [](const Json::Value& j) { return j.asUInt(); });
+#if defined(JSON_HAS_INT64)
+ EqEval(Json::Int64(64), [](const Json::Value& j) { return j.asInt64(); });
+ EqEval(Json::UInt64(64), [](const Json::Value& j) { return j.asUInt64(); });
+#endif // if defined(JSON_HAS_INT64)
+ EqEval(Json::LargestInt(64),
+ [](const Json::Value& j) { return j.asLargestInt(); });
+ EqEval(Json::LargestUInt(64),
+ [](const Json::Value& j) { return j.asLargestUInt(); });
+
+ EqEval(69.69f, [](const Json::Value& j) { return j.asFloat(); });
+ EqEval(69.69, [](const Json::Value& j) { return j.asDouble(); });
+ EqEval(false, [](const Json::Value& j) { return j.asBool(); });
+ EqEval(true, [](const Json::Value& j) { return j.asBool(); });
+}
+
+class MemberTemplateIs : public JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(MemberTemplateIs, BehavesSameAsNamedIs) {
+ const Json::Value values[] = {true, 142, 40.63, "hello world"};
+ for (const Json::Value& j : values) {
+ JSONTEST_ASSERT_EQUAL(j.is<bool>(), j.isBool());
+ JSONTEST_ASSERT_EQUAL(j.is<Json::Int>(), j.isInt());
+ JSONTEST_ASSERT_EQUAL(j.is<Json::Int64>(), j.isInt64());
+ JSONTEST_ASSERT_EQUAL(j.is<Json::UInt>(), j.isUInt());
+ JSONTEST_ASSERT_EQUAL(j.is<Json::UInt64>(), j.isUInt64());
+ JSONTEST_ASSERT_EQUAL(j.is<double>(), j.isDouble());
+ JSONTEST_ASSERT_EQUAL(j.is<Json::String>(), j.isString());
+ }
+}
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/src/test_lib_json/sconscript b/src/test_lib_json/sconscript
deleted file mode 100644
index 915fd01..0000000
--- a/src/test_lib_json/sconscript
+++ /dev/null
@@ -1,10 +0,0 @@
-Import( 'env_testing buildUnitTests' )
-
-buildUnitTests( env_testing, Split( """
- main.cpp
- jsontest.cpp
- """ ),
- 'test_lib_json' )
-
-# For 'check' to work, 'libs' must be built first.
-env_testing.Depends('test_lib_json', '#libs')