partially revert 'Added features that allow the reader to accept common non-standard JSON.'

revert '642befc836ac5093b528e7d8b4fd66b66735a98c',
but keep the *added* methods for `decodedNumber()` and `decodedDouble()`.

.gitignore

@@ -10,4 +10,27 @@
 /libs/
 /doc/doxyfile
 /dist/
+#/version
 #/include/json/version.h
+
+# MSVC project files:
+*.sln
+*.vcxproj
+*.filters
+*.user
+*.sdf
+*.opensdf
+*.suo
+
+# MSVC build files:
+*.lib
+*.obj
+*.tlog/
+*.pdb
+
+# CMake-generated files:
+CMakeFiles/
+CTestTestFile.cmake
+cmake_install.cmake
+pkg-config/jsoncpp.pc
+jsoncpp_lib_static.dir/

.travis.yml

@@ -7,7 +7,7 @@ language: cpp
 compiler:
   - gcc
   - clang
-script: cmake -DJSONCPP_WITH_CMAKE_PACKAGE=$CMAKE_PKG -DJSONCPP_LIB_BUILD_SHARED=$SHARED_LIB -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_VERBOSE_MAKEFILE=$VERBOSE_MAKE . && make
+script: cmake -DJSONCPP_WITH_CMAKE_PACKAGE=$CMAKE_PKG -DJSONCPP_LIB_BUILD_SHARED=$SHARED_LIB -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_VERBOSE_MAKEFILE=$VERBOSE_MAKE . && make && make jsoncpp_check
 env:
   matrix:
     - SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false

CMakeLists.txt

@@ -1,8 +1,10 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)
 PROJECT(jsoncpp)
 ENABLE_TESTING()
 
-OPTION(JSONCPP_WITH_TESTS "Compile and run JsonCpp test executables" ON)
+OPTION(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" ON)
 OPTION(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" ON)
 OPTION(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
 OPTION(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
@@ -54,17 +56,24 @@ MACRO(jsoncpp_parse_version VERSION_TEXT OUPUT_PREFIX)
 ENDMACRO(jsoncpp_parse_version)
 
 # Read out version from "version" file
-FILE(STRINGS "version" JSONCPP_VERSION)
+#FILE(STRINGS "version" JSONCPP_VERSION)
-
+#SET( JSONCPP_VERSION_MAJOR X )
+#SET( JSONCPP_VERSION_MINOR Y )
+#SET( JSONCPP_VERSION_PATCH Z )
+SET( JSONCPP_VERSION 0.10.1 )
 jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
-IF(NOT JSONCPP_VERSION_FOUND)
+#IF(NOT JSONCPP_VERSION_FOUND)
-    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
+#    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
-ENDIF(NOT JSONCPP_VERSION_FOUND)
+#ENDIF(NOT JSONCPP_VERSION_FOUND)
 
 MESSAGE(STATUS "JsonCpp Version: ${JSONCPP_VERSION_MAJOR}.${JSONCPP_VERSION_MINOR}.${JSONCPP_VERSION_PATCH}")
 # File version.h is only regenerated on CMake configure step
 CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/src/lib_json/version.h.in"
-                "${PROJECT_SOURCE_DIR}/include/json/version.h" )
+                "${PROJECT_SOURCE_DIR}/include/json/version.h"
+                NEWLINE_STYLE UNIX )
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/version.in"
+                "${PROJECT_SOURCE_DIR}/version"
+                NEWLINE_STYLE UNIX )
 
 macro(UseCompilationWarningAsError)
 	if ( MSVC )
@@ -85,10 +94,10 @@ endif( MSVC )
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   # using regular Clang or AppleClang
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # using GCC
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -Wextra -pedantic")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
 endif()
 
 IF(JSONCPP_WITH_WARNING_AS_ERROR)

README.md

@@ -7,17 +7,20 @@ pairs.
 
 [json-org]: http://json.org/
 
-JsonCpp is a C++ library that allows manipulating JSON values, including
+[JsonCpp][] is a C++ library that allows manipulating JSON values, including
 serialization and deserialization to and from strings. It can also preserve
 existing comment in unserialization/serialization steps, making it a convenient
 format to store user input files.
 
+[JsonCpp]: http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html
+
 ## A note on backward-compatibility
-Very soon, we are switching to C++11 only. For older compilers, try the `pre-C++11` branch.
+* `1.y.z` is built with C++11.
+* `0.y.z` can be used with older compilers.
+* Major versions maintain binary-compatibility.
 
 Using JsonCpp in your project
 -----------------------------
-
 The recommended approach to integrating JsonCpp in your project is to build
 the amalgamated source (a single `.cpp` file) with your own build system. This
 ensures consistency of compilation flags and ABI compatibility. See the section
@@ -28,13 +31,11 @@ should be included as follow:
 
     #include <json/json.h>
 
-If JsonCpp was build as a dynamic library on Windows, then your project needs to
+If JsonCpp was built as a dynamic library on Windows, then your project needs to
 define the macro `JSON_DLL`.
 
-
+Building and testing with CMake
-Building and testing with new CMake
+-------------------------------
------------------------------------
-
 [CMake][] is a C++ Makefiles/Solution generator. It is usually available on most
 Linux system as package. On Ubuntu:
 
@@ -75,10 +76,8 @@ the `-G` option).
 By default CMake hides compilation commands. This can be modified by specifying
 `-DCMAKE_VERBOSE_MAKEFILE=true` when generating makefiles.
 
-
 Building and testing with SCons
 -------------------------------
-
 **Note:** The SCons-based build system is deprecated. Please use CMake; see the
 section above.
 
@@ -107,14 +106,7 @@ If you are building with Microsoft Visual Studio 2008, you need to set up the
 environment by running `vcvars32.bat` (e.g. MSVC 2008 command prompt) before
 running SCons.
 
-
+# Running the tests manually
-Running the tests manually
---------------------------
-
-Note that test can be run using SCons using the `check` target:
-
-    scons platform=$PLATFORM check
-
 You need to run tests manually only if you are troubleshooting an issue.
 
 In the instructions below, replace `path/to/jsontest` with the path of the
@@ -137,20 +129,21 @@ In the instructions below, replace `path/to/jsontest` with the path of the
     # You can run the tests using valgrind:
     python rununittests.py --valgrind path/to/test_lib_json
 
+## Running the tests using scons
+Note that tests can be run using SCons using the `check` target:
+
+    scons platform=$PLATFORM check
 
 Building the documentation
 --------------------------
-
 Run the Python script `doxybuild.py` from the top directory:
 
     python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
 
 See `doxybuild.py --help` for options.
 
-
 Generating amalgamated source and header
 ----------------------------------------
-
 JsonCpp is provided with a script to generate a single header and a single
 source file to ease inclusion into an existing project. The amalgamated source
 can be generated at any time by running the following command from the
@@ -172,10 +165,8 @@ The amalgamated sources are generated by concatenating JsonCpp source in the
 correct order and defining the macro `JSON_IS_AMALGAMATION` to prevent inclusion
 of other headers.
 
-
 Adding a reader/writer test
 ---------------------------
-
 To add a test, you need to create two files in test/data:
 
 * a `TESTNAME.json` file, that contains the input document in JSON format.
@@ -195,10 +186,8 @@ The `TESTNAME.expected` file format is as follows:
 See the examples `test_complex_01.json` and `test_complex_01.expected` to better
 understand element paths.
 
-
 Understanding reader/writer test output
 ---------------------------------------
-
 When a test is run, output files are generated beside the input test files.
 Below is a short description of the content of each file:
 
@@ -215,10 +204,7 @@ Below is a short description of the content of each file:
 * `test_complex_01.process-output`: `jsontest` output, typically useful for
   understanding parsing errors.
 
-
 License
 -------
-
 See the `LICENSE` file for details. In summary, JsonCpp is licensed under the
 MIT license, or public domain if desired and recognized in your jurisdiction.
-

amalgamate.py

@@ -1,6 +1,6 @@
 """Amalgate json-cpp library sources into a single source and header file.
 
-Requires Python 2.6
+Works with python2.6+ and python3.4+.
 
 Example of invocation (must be invoked from json-cpp top directory):
 python amalgate.py
@@ -59,7 +59,7 @@ def amalgamate_source(source_top_dir=None,
     print("Amalgating header...")
     header = AmalgamationFile(source_top_dir)
     header.add_text("/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).")
-    header.add_text("/// It is intented to be used with #include <%s>" % header_include_path)
+    header.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
     header.add_file("LICENSE", wrap_in_comment=True)
     header.add_text("#ifndef JSON_AMALGATED_H_INCLUDED")
     header.add_text("# define JSON_AMALGATED_H_INCLUDED")
@@ -85,7 +85,7 @@ def amalgamate_source(source_top_dir=None,
     print("Amalgating forward header...")
     header = AmalgamationFile(source_top_dir)
     header.add_text("/// Json-cpp amalgated forward header (http://jsoncpp.sourceforge.net/).")
-    header.add_text("/// It is intented to be used with #include <%s>" % forward_header_include_path)
+    header.add_text('/// It is intended to be used with #include "%s"' % forward_header_include_path)
     header.add_text("/// This header provides forward declaration for all JsonCpp types.")
     header.add_file("LICENSE", wrap_in_comment=True)
     header.add_text("#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED")
@@ -105,15 +105,19 @@ def amalgamate_source(source_top_dir=None,
     print("Amalgating source...")
     source = AmalgamationFile(source_top_dir)
     source.add_text("/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/).")
-    source.add_text("/// It is intented to be used with #include <%s>" % header_include_path)
+    source.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
     source.add_file("LICENSE", wrap_in_comment=True)
     source.add_text("")
-    source.add_text("#include <%s>" % header_include_path)
+    source.add_text('#include "%s"' % header_include_path)
+    source.add_text("""
+#ifndef JSON_IS_AMALGAMATION
+#error "Compile with -I PATH_TO_JSON_DIRECTORY"
+#endif
+""")
     source.add_text("")
     lib_json = "src/lib_json"
     source.add_file(os.path.join(lib_json, "json_tool.h"))
     source.add_file(os.path.join(lib_json, "json_reader.cpp"))
-    source.add_file(os.path.join(lib_json, "json_batchallocator.h"))
     source.add_file(os.path.join(lib_json, "json_valueiterator.inl"))
     source.add_file(os.path.join(lib_json, "json_value.cpp"))
     source.add_file(os.path.join(lib_json, "json_writer.cpp"))

dev.makefile

@@ -1,5 +1,19 @@
-all: build test-amalgamate
+# This is only for jsoncpp developers/contributors.
+# We use this to sign releases, generate documentation, etc.
+VER?=$(shell cat version)
 
+default:
+	@echo "VER=${VER}"
+sign: jsoncpp-${VER}.tar.gz
+	gpg --armor --detach-sign $<
+	gpg --verify $<.asc
+	# Then upload .asc to the release.
+jsoncpp-%.tar.gz:
+	curl https://github.com/open-source-parsers/jsoncpp/archive/$*.tar.gz -o $@
+dox:
+	python doxybuild.py --doxygen=$$(which doxygen) --in doc/web_doxyfile.in
+	rsync -va --delete dist/doxygen/jsoncpp-api-html-${VER}/ ../jsoncpp-docs/doxygen/
+	# Then 'git add -A' and 'git push' in jsoncpp-docs.
 build:
 	mkdir -p build/debug
 	cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DJSONCPP_LIB_BUILD_SHARED=ON -G "Unix Makefiles" ../..
@@ -7,8 +21,12 @@ build:
 
 # Currently, this depends on include/json/version.h generated
 # by cmake.
-test-amalgamate: build
+test-amalgamate:
 	python2.7 amalgamate.py
 	python3.4 amalgamate.py
+	cd dist; gcc -I. -c jsoncpp.cpp
+
+clean:
+	\rm -rf *.gz *.asc dist/
 
 .PHONY: build

doc/doxyfile.in

@@ -1946,8 +1946,7 @@ INCLUDE_FILE_PATTERNS  = *.h
 PREDEFINED             = "_MSC_VER=1400" \
                          _CPPRTTI \
                          _WIN32 \
-                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION \
+                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-                         JSON_VALUE_USE_INTERNAL_MAP
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

doc/jsoncpp.dox

@@ -56,20 +56,24 @@ std::cin >> root;
 // You can also read into a particular sub-value.
 std::cin >> root["subtree"];
 
-// Get the value of the member of root named 'encoding', return 'UTF-8' if there is no
+// Get the value of the member of root named 'encoding',
-// such member.
+// and return 'UTF-8' if there is no such member.
 std::string encoding = root.get("encoding", "UTF-8" ).asString();
-// Get the value of the member of root named 'encoding'; return a 'null' value if
+
+// Get the value of the member of root named 'plug-ins'; return a 'null' value if
 // there is no such member.
 const Json::Value plugins = root["plug-ins"];
-for ( int index = 0; index < plugins.size(); ++index )  // Iterates over the sequence elements.
+
+// Iterate over the sequence elements.
+for ( int index = 0; index < plugins.size(); ++index )
    loadPlugIn( plugins[index].asString() );
    
+// Try other datatypes. Some are auto-convertible to others.
 foo::setIndentLength( root["indent"].get("length", 3).asInt() );
 foo::setIndentUseSpace( root["indent"].get("use_space", true).asBool() );
 
-// Since Json::Value has implicit constructor for all value types, it is not
+// Since Json::Value has an implicit constructor for all value types, it is not
-// necessary to explicitly construct the Json::Value object:
+// necessary to explicitly construct the Json::Value object.
 root["encoding"] = foo::getCurrentEncoding();
 root["indent"]["length"] = foo::getCurrentIndentLength();
 root["indent"]["use_space"] = foo::getCurrentIndentUseSpace();
@@ -92,13 +96,13 @@ features without losing binary-compatibility.
 \code
 // For convenience, use `writeString()` with a specialized builder.
 Json::StreamWriterBuilder wbuilder;
-wbuilder.settings_["indentation"] = "\t";  // simple Json::Value
+wbuilder["indentation"] = "\t";
 std::string document = Json::writeString(wbuilder, root);
 
 // Here, using a specialized Builder, we discard comments and
 // record errors as we parse.
 Json::CharReaderBuilder rbuilder;
-rbuilder.settings_["collectComments"] = false;  // simple Json::Value
+rbuilder["collectComments"] = false;
 std::string errs;
 bool ok = Json::parseFromStream(rbuilder, std::cin, &root, &errs);
 \endcode
@@ -152,6 +156,7 @@ Basically JsonCpp is licensed under MIT license, or public domain if desired
 and recognized in your jurisdiction.
 
 \author Baptiste Lepilleur <blep@users.sourceforge.net> (originator)
+\author Christopher Dunn <cdunn2001@gmail.com> (primary maintainer)
 \version \include version
 We make strong guarantees about binary-compatibility, consistent with
 <a href="http://apr.apache.org/versioning.html">the Apache versioning scheme</a>.

doc/web_doxyfile.in

@@ -1946,8 +1946,7 @@ INCLUDE_FILE_PATTERNS  = *.h
 PREDEFINED             = "_MSC_VER=1400" \
                          _CPPRTTI \
                          _WIN32 \
-                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION \
+                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-                         JSON_VALUE_USE_INTERNAL_MAP
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

doxybuild.py

@@ -31,7 +31,7 @@ def find_program(*filenames):
     paths = os.environ.get('PATH', '').split(os.pathsep)
     suffixes = ('win32' in sys.platform) and '.exe .com .bat .cmd' or ''
     for filename in filenames:
-        for name in [filename+ext for ext in suffixes.split()]:
+        for name in [filename+ext for ext in suffixes.split(' ')]:
             for directory in paths:
                 full_path = os.path.join(directory, name)
                 if os.path.isfile(full_path):

include/json/assertions.h

@@ -13,18 +13,30 @@
 #include "config.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
+/** It should not be possible for a maliciously designed file to
+ *  cause an abort() or seg-fault, so these macros are used only
+ *  for pre-condition violations and internal logic errors.
+ */
 #if JSON_USE_EXCEPTION
-#include <stdexcept>
+
-#define JSON_ASSERT(condition)                                                 \
+// @todo <= add detail about condition in exception
-  assert(condition); // @todo <= change this into an exception throw
+# define JSON_ASSERT(condition)                                                \
-#define JSON_FAIL_MESSAGE(message) do{std::ostringstream oss; oss << message; throw std::runtime_error(oss.str());}while(0)
+  {if (!(condition)) {Json::throwLogicError( "assert json failed" );}}
-//#define JSON_FAIL_MESSAGE(message) throw std::runtime_error(message)
+
+# define JSON_FAIL_MESSAGE(message)                                            \
+  {                                                                            \
+    std::ostringstream oss; oss << message;                                    \
+    Json::throwLogicError(oss.str());                                          \
+    abort();                                                                   \
+  }
+
 #else // JSON_USE_EXCEPTION
-#define JSON_ASSERT(condition) assert(condition);
+
+# define JSON_ASSERT(condition) assert(condition)
 
 // The call to assert() will show the failure message in debug builds. In
-// release bugs we abort, for a core-dump or debugger.
+// release builds we abort, for a core-dump or debugger.
-#define JSON_FAIL_MESSAGE(message)                                             \
+# define JSON_FAIL_MESSAGE(message)                                            \
   {                                                                            \
     std::ostringstream oss; oss << message;                                    \
     assert(false && oss.str().c_str());                                        \

include/json/config.h

@@ -15,17 +15,6 @@
 /// std::map
 /// as Value container.
 //#  define JSON_USE_CPPTL_SMALLMAP 1
-/// If defined, indicates that Json specific container should be used
-/// (hash table & simple deque container with customizable allocator).
-/// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
-//#  define JSON_VALUE_USE_INTERNAL_MAP 1
-/// Force usage of standard new/malloc based allocator instead of memory pool
-/// based allocator.
-/// The memory pools allocator used optimization (initializing Value and
-/// ValueInternalLink
-/// as if it was a POD) that may cause some validation tool to report errors.
-/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
-//#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
 
 // If non-zero, the library uses exceptions to report bad input instead of C
 // assertion macros. The default is to use exceptions.
@@ -81,6 +70,14 @@
 #if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
 /// Indicates that the following function is deprecated.
 #define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__clang__) && defined(__has_feature)
+#if __has_feature(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#endif
+#elif defined(__GNUC__) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#elif defined(__GNUC__) &&  (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message)  __attribute__((__deprecated__))
 #endif
 
 #if !defined(JSONCPP_DEPRECATED)

include/json/features.h

@@ -44,12 +44,6 @@ public:
   /// \c true if root must be either an array or an object value. Default: \c
   /// false.
   bool strictRoot_;
-
-  /// \c true if dropped null placeholders are allowed. Default: \c false.
-  bool allowDroppedNullPlaceholders_;
-
-  /// \c true if numeric object key are allowed. Default: \c false.
-  bool allowNumericKeys_;
 };
 
 } // namespace Json

include/json/forwards.h

@@ -31,12 +31,6 @@ class Value;
 class ValueIteratorBase;
 class ValueIterator;
 class ValueConstIterator;
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-class ValueMapAllocator;
-class ValueInternalLink;
-class ValueInternalArray;
-class ValueInternalMap;
-#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
 
 } // namespace Json
 

include/json/reader.h

@@ -35,18 +35,6 @@ public:
   typedef char Char;
   typedef const Char* Location;
 
-  /** \brief An error tagged with where in the JSON text it was encountered.
-   *
-   * The offsets give the [start, limit) range of bytes within the text. Note
-   * that this is bytes, not codepoints.
-   *
-   */
-  struct StructuredError {
-    size_t offset_start;
-    size_t offset_limit;
-    std::string message;
-  };
-
   /** \brief Constructs a Reader allowing all features
    * for parsing.
    */
@@ -110,7 +98,7 @@ public:
    *         during parsing.
    * \deprecated Use getFormattedErrorMessages() instead (typo fix).
    */
-  JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead")
+  JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
   std::string getFormatedErrorMessages() const;
 
   /** \brief Returns a user friendly string that list errors in the parsed
@@ -123,38 +111,6 @@ public:
    */
   std::string getFormattedErrorMessages() const;
 
-  /** \brief Returns a vector of structured erros encounted while parsing.
-   * \return A (possibly empty) vector of StructuredError objects. Currently
-   *         only one error can be returned, but the caller should tolerate
-   * multiple
-   *         errors.  This can occur if the parser recovers from a non-fatal
-   *         parse error and then encounters additional errors.
-   */
-  std::vector<StructuredError> getStructuredErrors() const;
-
-  /** \brief Add a semantic error message.
-   * \param value JSON Value location associated with the error
-   * \param message The error message.
-   * \return \c true if the error was successfully added, \c false if the
-   * Value offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const std::string& message);
-
-  /** \brief Add a semantic error message with extra context.
-   * \param value JSON Value location associated with the error
-   * \param message The error message.
-   * \param extra Additional JSON Value location to contextualize the error
-   * \return \c true if the error was successfully added, \c false if either
-   * Value offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const std::string& message, const Value& extra);
-
-  /** \brief Return whether there are any errors.
-   * \return \c true if there are no errors to report \c false if
-   * errors have occurred.
-   */
-  bool good() const;
-
 private:
   enum TokenType {
     tokenEndOfStream = 0,
@@ -270,6 +226,7 @@ public:
 
   class Factory {
   public:
+    virtual ~Factory() {}
     /** \brief Allocate a CharReader via operator new().
      * \throw std::exception if something goes wrong (e.g. invalid settings)
      */
@@ -279,13 +236,11 @@ public:
 
 /** \brief Build a CharReader implementation.
 
-  \deprecated This is experimental and will be altered before the next release.
-
 Usage:
 \code
   using namespace Json;
   CharReaderBuilder builder;
-  builder.settings_["collectComments"] = false;
+  builder["collectComments"] = false;
   Value value;
   std::string errs;
   bool ok = parseFromStream(builder, std::cin, &value, &errs);
@@ -298,21 +253,30 @@ public:
   /** Configuration of this builder.
     These are case-sensitive.
     Available settings (case-sensitive):
-    - "collectComments": false or true
+    - `"collectComments": false or true`
       - true to collect comment and allow writing them
         back during serialization, false to discard comments.
         This parameter is ignored if allowComments is false.
-    - "allowComments": false or true
+    - `"allowComments": false or true`
       - true if comments are allowed.
-    - "strictRoot": false or true
+    - `"strictRoot": false or true`
       - true if root must be either an array or an object value
-    - "allowDroppedNullPlaceholders": false or true
+    - `"allowDroppedNullPlaceholders": false or true`
       - true if dropped null placeholders are allowed. (See StreamWriterBuilder.)
-    - "allowNumericKeys": false or true
+    - `"allowNumericKeys": false or true`
       - true if numeric object keys are allowed.
-    - "stackLimit": integer
+    - `"allowSingleQuotes": false or true`
+      - true if '' are allowed for strings (both keys and values)
+    - `"stackLimit": integer`
+      - Exceeding stackLimit (recursive depth of `readValue()`) will
+        cause an exception.
       - This is a security issue (seg-faults caused by deeply nested JSON),
         so the default is low.
+    - `"failIfExtra": false or true`
+      - If true, `parse()` returns false when extra non-whitespace trails
+        the JSON value in the input string.
+    - `"rejectDupKeys": false or true`
+      - If true, `parse()` returns false when a key is duplicated within an object.
 
     You can examine 'settings_` yourself
     to see the defaults. You can also write and read them just like any
@@ -330,6 +294,11 @@ public:
    *   otherwise, indicate bad settings via 'invalid'.
    */
   bool validate(Json::Value* invalid) const;
+
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](std::string key);
+
   /** Called by ctor, but you can use this to reset settings_.
    * \pre 'settings' != NULL (but Json::null is fine)
    * \remark Defaults:
@@ -348,7 +317,7 @@ public:
   * Someday we might have a real StreamReader, but for now this
   * is convenient.
   */
-bool parseFromStream(
+bool JSON_API parseFromStream(
     CharReader::Factory const&,
     std::istream&,
     Value* root, std::string* errs);

include/json/value.h

@@ -11,6 +11,7 @@
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <string>
 #include <vector>
+#include <exception>
 
 #ifndef JSON_USE_CPPTL_SMALLMAP
 #include <map>
@@ -32,6 +33,31 @@
  */
 namespace Json {
 
+/** Base class for all exceptions we throw.
+ *
+ * We use nothing but these internally. Of course, STL can throw others.
+ */
+class JSON_API Exception;
+/** Exceptions which the user cannot easily avoid.
+ *
+ * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
+ * 
+ * \remark derived from Json::Exception
+ */
+class JSON_API RuntimeError;
+/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
+ *
+ * These are precondition-violations (user bugs) and internal errors (our bugs).
+ * 
+ * \remark derived from Json::Exception
+ */
+class JSON_API LogicError;
+
+/// used internally
+void throwRuntimeError(std::string const& msg);
+/// used internally
+void throwLogicError(std::string const& msg);
+
 /** \brief Type of the value held by a Value object.
  */
 enum ValueType {
@@ -74,14 +100,14 @@ enum CommentPlacement {
  */
 class JSON_API StaticString {
 public:
-  explicit StaticString(const char* czstring) : str_(czstring) {}
+  explicit StaticString(const char* czstring) : c_str_(czstring) {}
 
-  operator const char*() const { return str_; }
+  operator const char*() const { return c_str_; }
 
-  const char* c_str() const { return str_; }
+  const char* c_str() const { return c_str_; }
 
 private:
-  const char* str_;
+  const char* c_str_;
 };
 
 /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
@@ -99,26 +125,27 @@ private:
  * The type of the held value is represented by a #ValueType and
  * can be obtained using type().
  *
- * values of an #objectValue or #arrayValue can be accessed using operator[]()
+ * Values of an #objectValue or #arrayValue can be accessed using operator[]()
- *methods.
+ * methods.
- * Non const methods will automatically create the a #nullValue element
+ * Non-const methods will automatically create the a #nullValue element
  * if it does not exist.
- * The sequence of an #arrayValue will be automatically resize and initialized
+ * The sequence of an #arrayValue will be automatically resized and initialized
  * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
  *
- * The get() methods can be used to obtanis default value in the case the
+ * The get() methods can be used to obtain default value in the case the
- *required element
+ * required element does not exist.
- * does not exist.
  *
  * It is possible to iterate over the list of a #objectValue values using
  * the getMemberNames() method.
+ *
+ * \note #Value string-length fit in size_t, but keys must be < 2^30.
+ * (The reason is an implementation detail.) A #CharReader will raise an
+ * exception if a bound is exceeded to avoid security holes in your app,
+ * but the Value API does *not* check bounds. That is the responsibility
+ * of the caller.
  */
 class JSON_API Value {
   friend class ValueIteratorBase;
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-  friend class ValueInternalLink;
-  friend class ValueInternalMap;
-#endif
 public:
   typedef std::vector<std::string> Members;
   typedef ValueIterator iterator;
@@ -133,8 +160,11 @@ public:
   typedef Json::LargestUInt LargestUInt;
   typedef Json::ArrayIndex ArrayIndex;
 
-  static const Value& null;  ///! We regret this reference to a global instance; prefer the simpler Value().
+  static const Value& nullRef;
-  static const Value& nullRef;  ///! just a kludge for binary-compatibility; same as null
+#if !defined(__ARMEL__)
+  /// \deprecated This exists for binary compatibility only. Use nullRef.
+  static const Value null;
+#endif
   /// Minimum signed integer value that can be stored in a Json::Value.
   static const LargestInt minLargestInt;
   /// Maximum signed integer value that can be stored in a Json::Value.
@@ -160,7 +190,6 @@ public:
 
 private:
 #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
   class CZString {
   public:
     enum DuplicationPolicy {
@@ -169,20 +198,31 @@ private:
       duplicateOnCopy
     };
     CZString(ArrayIndex index);
-    CZString(const char* cstr, DuplicationPolicy allocate);
+    CZString(char const* str, unsigned length, DuplicationPolicy allocate);
-    CZString(const CZString& other);
+    CZString(CZString const& other);
     ~CZString();
     CZString& operator=(CZString other);
-    bool operator<(const CZString& other) const;
+    bool operator<(CZString const& other) const;
-    bool operator==(const CZString& other) const;
+    bool operator==(CZString const& other) const;
     ArrayIndex index() const;
-    const char* c_str() const;
+    //const char* c_str() const; ///< \deprecated
+    char const* data() const;
+    unsigned length() const;
     bool isStaticString() const;
 
   private:
     void swap(CZString& other);
-    const char* cstr_;
+
-    ArrayIndex index_;
+    struct StringStorage {
+      DuplicationPolicy policy_: 2;
+      unsigned length_: 30; // 1GB max
+    };
+
+    char const* cstr_;  // actually, a prefixed string, unless policy is noDup
+    union {
+      ArrayIndex index_;
+      StringStorage storage_;
+    };
   };
 
 public:
@@ -191,7 +231,6 @@ public:
 #else
   typedef CppTL::SmallMap<CZString, Value> ObjectValues;
 #endif // ifndef JSON_USE_CPPTL_SMALLMAP
-#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
 #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
 public:
@@ -218,20 +257,25 @@ Json::Value obj_value(Json::objectValue); // {}
   Value(UInt64 value);
 #endif // if defined(JSON_HAS_INT64)
   Value(double value);
-  Value(const char* value);
+  Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
-  Value(const char* beginValue, const char* endValue);
+  Value(const char* beginValue, const char* endValue); ///< Copy all, incl zeroes.
   /** \brief Constructs a value from a static string.
 
    * Like other value string constructor but do not duplicate the string for
    * internal storage. The given string must remain alive after the call to this
    * constructor.
+   * \note This works only for null-terminated strings. (We cannot change the
+   *   size of this class, so we have nowhere to store the length,
+   *   which might be computed later for various operations.)
+   *
    * Example of usage:
    * \code
-   * Json::Value aValue( StaticString("some text") );
+   * static StaticString foo("some text");
+   * Json::Value aValue(foo);
    * \endcode
    */
   Value(const StaticString& value);
-  Value(const std::string& value);
+  Value(const std::string& value); ///< Copy data() til size(). Embedded zeroes too.
 #ifdef JSON_USE_CPPTL
   Value(const CppTL::ConstString& value);
 #endif
@@ -240,8 +284,9 @@ Json::Value obj_value(Json::objectValue); // {}
   Value(const Value& other);
   ~Value();
 
-  // Deep copy, then swap(other).
+  /// Deep copy, then swap(other).
-  Value& operator=(Value other);
+  /// \note Over-write existing comments. To preserve comments, use #swapPayload().
+  Value &operator=(const Value &other);
   /// Swap everything.
   void swap(Value& other);
   /// Swap values but leave comments and source offsets in place.
@@ -258,8 +303,13 @@ Json::Value obj_value(Json::objectValue); // {}
   bool operator!=(const Value& other) const;
   int compare(const Value& other) const;
 
-  const char* asCString() const;
+  const char* asCString() const; ///< Embedded zeroes could cause you trouble!
-  std::string asString() const;
+  std::string asString() const; ///< Embedded zeroes are possible.
+  /** Get raw char* of string-value.
+   *  \return false if !string. (Seg-fault if str or end are NULL.)
+   */
+  bool getString(
+      char const** str, char const** end) const;
 #ifdef JSON_USE_CPPTL
   CppTL::ConstString asConstString() const;
 #endif
@@ -350,19 +400,23 @@ Json::Value obj_value(Json::objectValue); // {}
   Value& append(const Value& value);
 
   /// Access an object value by name, create a null member if it does not exist.
+  /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
+  ///  Exceeding that will cause an exception.
   Value& operator[](const char* key);
   /// Access an object value by name, returns null if there is no member with
   /// that name.
   const Value& operator[](const char* key) const;
   /// Access an object value by name, create a null member if it does not exist.
+  /// \param key may contain embedded nulls.
   Value& operator[](const std::string& key);
   /// Access an object value by name, returns null if there is no member with
   /// that name.
+  /// \param key may contain embedded nulls.
   const Value& operator[](const std::string& key) const;
   /** \brief Access an object value by name, create a null member if it does not
    exist.
 
-   * If the object as no entry for that name, then the member name used to store
+   * If the object has no entry for that name, then the member name used to store
    * the new entry is not duplicated.
    * Example of use:
    * \code
@@ -380,13 +434,29 @@ Json::Value obj_value(Json::objectValue); // {}
   const Value& operator[](const CppTL::ConstString& key) const;
 #endif
   /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
   Value get(const char* key, const Value& defaultValue) const;
   /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
+  Value get(const char* key, const char* end, const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
   Value get(const std::string& key, const Value& defaultValue) const;
 #ifdef JSON_USE_CPPTL
   /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
   Value get(const CppTL::ConstString& key, const Value& defaultValue) const;
 #endif
+  /// Most general and efficient version of isMember()const, get()const,
+  /// and operator[]const
+  /// \note As stated elsewhere, behavior is undefined if (end-key) >= 2^30
+  Value const* find(char const* key, char const* end) const;
+  /// Most general and efficient version of object-mutators.
+  /// \note As stated elsewhere, behavior is undefined if (end-key) >= 2^30
+  /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
+  Value const* demand(char const* key, char const* end);
   /// \brief Remove and return the named member.
   ///
   /// Do nothing if it did not exist.
@@ -396,14 +466,21 @@ Json::Value obj_value(Json::objectValue); // {}
   /// \deprecated
   Value removeMember(const char* key);
   /// Same as removeMember(const char*)
+  /// \param key may contain embedded nulls.
   /// \deprecated
   Value removeMember(const std::string& key);
+  /// Same as removeMember(const char* key, const char* end, Value* removed),
+  /// but 'key' is null-terminated.
+  bool removeMember(const char* key, Value* removed);
   /** \brief Remove the named map member.
 
       Update 'removed' iff removed.
+      \param key may contain embedded nulls.
       \return true iff removed (no exceptions)
   */
-  bool removeMember(const char* key, Value* removed);
+  bool removeMember(std::string const& key, Value* removed);
+  /// Same as removeMember(std::string const& key, Value* removed)
+  bool removeMember(const char* key, const char* end, Value* removed);
   /** \brief Remove the indexed array element.
 
       O(n) expensive operations.
@@ -413,9 +490,13 @@ Json::Value obj_value(Json::objectValue); // {}
   bool removeIndex(ArrayIndex i, Value* removed);
 
   /// Return true if the object has a member named key.
+  /// \note 'key' must be null-terminated.
   bool isMember(const char* key) const;
   /// Return true if the object has a member named key.
+  /// \param key may contain embedded nulls.
   bool isMember(const std::string& key) const;
+  /// Same as isMember(std::string const& key)const
+  bool isMember(const char* key, const char* end) const;
 #ifdef JSON_USE_CPPTL
   /// Return true if the object has a member named key.
   bool isMember(const CppTL::ConstString& key) const;
@@ -434,6 +515,7 @@ Json::Value obj_value(Json::objectValue); // {}
   //# endif
 
   /// \deprecated Always pass len.
+  JSONCPP_DEPRECATED("Use setComment(std::string const&) instead.")
   void setComment(const char* comment, CommentPlacement placement);
   /// Comments must be //... or /* ... */
   void setComment(const char* comment, size_t len, CommentPlacement placement);
@@ -451,31 +533,12 @@ Json::Value obj_value(Json::objectValue); // {}
   iterator begin();
   iterator end();
 
-  // Accessors for the [start, limit) range of bytes within the JSON text from
-  // which this value was parsed, if any.
-  void setOffsetStart(size_t start);
-  void setOffsetLimit(size_t limit);
-  size_t getOffsetStart() const;
-  size_t getOffsetLimit() const;
-
 private:
   void initBasic(ValueType type, bool allocated = false);
 
-  Value& resolveReference(const char* key, bool isStatic);
+  Value& resolveReference(const char* key);
+  Value& resolveReference(const char* key, const char* end);
 
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-  inline bool isItemAvailable() const { return itemIsUsed_ == 0; }
-
-  inline void setItemUsed(bool isUsed = true) { itemIsUsed_ = isUsed ? 1 : 0; }
-
-  inline bool isMemberNameStatic() const { return memberNameIsStatic_ == 0; }
-
-  inline void setMemberNameIsStatic(bool isStatic) {
-    memberNameIsStatic_ = isStatic ? 1 : 0;
-  }
-#endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
-
-private:
   struct CommentInfo {
     CommentInfo();
     ~CommentInfo();
@@ -499,26 +562,13 @@ private:
     LargestUInt uint_;
     double real_;
     bool bool_;
-    char* string_;
+    char* string_;  // actually ptr to unsigned, followed by str, unless !allocated_
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-    ValueInternalArray* array_;
-    ValueInternalMap* map_;
-#else
     ObjectValues* map_;
-#endif
   } value_;
   ValueType type_ : 8;
   unsigned int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
+                               // If not allocated_, string_ must be null-terminated.
-  unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container.
-  unsigned int memberNameIsStatic_ : 1;  // used by the ValueInternalMap container.
-#endif
   CommentInfo* comments_;
-
-  // [start, limit) byte offsets in the source JSON text from which this Value
-  // was extracted.
-  size_t start_;
-  size_t limit_;
 };
 
 /** \brief Experimental and untested: represents an element of the "path" to
@@ -584,345 +634,6 @@ private:
   Args args_;
 };
 
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-/** \brief Allocator to customize Value internal map.
- * Below is an example of a simple implementation (default implementation
- actually
- * use memory pool for speed).
- * \code
-   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;
-      }
-   };
- * \endcode
- */
-class JSON_API ValueMapAllocator {
-public:
-  virtual ~ValueMapAllocator();
-  virtual ValueInternalMap* newMap() = 0;
-  virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) = 0;
-  virtual void destructMap(ValueInternalMap* map) = 0;
-  virtual ValueInternalLink* allocateMapBuckets(unsigned int size) = 0;
-  virtual void releaseMapBuckets(ValueInternalLink* links) = 0;
-  virtual ValueInternalLink* allocateMapLink() = 0;
-  virtual void releaseMapLink(ValueInternalLink* link) = 0;
-};
-
-/** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
- * \internal previous_ & next_ allows for bidirectional traversal.
- */
-class JSON_API ValueInternalLink {
-public:
-  enum {
-    itemPerLink = 6
-  }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
-  enum InternalFlags {
-    flagAvailable = 0,
-    flagUsed = 1
-  };
-
-  ValueInternalLink();
-
-  ~ValueInternalLink();
-
-  Value items_[itemPerLink];
-  char* keys_[itemPerLink];
-  ValueInternalLink* previous_;
-  ValueInternalLink* next_;
-};
-
-/** \brief A linked page based hash-table implementation used internally by
- *Value.
- * \internal ValueInternalMap is a tradional bucket based hash-table, with a
- *linked
- * list in each bucket to handle collision. There is an addional twist in that
- * each node of the collision linked list is a page containing a fixed amount of
- * value. This provides a better compromise between memory usage and speed.
- *
- * Each bucket is made up of a chained list of ValueInternalLink. The last
- * link of a given bucket can be found in the 'previous_' field of the following
- *bucket.
- * The last link of the last bucket is stored in tailLink_ as it has no
- *following bucket.
- * Only the last link of a bucket may contains 'available' item. The last link
- *always
- * contains at least one element unless is it the bucket one very first link.
- */
-class JSON_API ValueInternalMap {
-  friend class ValueIteratorBase;
-  friend class Value;
-
-public:
-  typedef unsigned int HashKey;
-  typedef unsigned int BucketIndex;
-
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-  struct IteratorState {
-    IteratorState() : map_(0), link_(0), itemIndex_(0), bucketIndex_(0) {}
-    ValueInternalMap* map_;
-    ValueInternalLink* link_;
-    BucketIndex itemIndex_;
-    BucketIndex bucketIndex_;
-  };
-#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-  ValueInternalMap();
-  ValueInternalMap(const ValueInternalMap& other);
-  ValueInternalMap& operator=(ValueInternalMap other);
-  ~ValueInternalMap();
-
-  void swap(ValueInternalMap& other);
-
-  BucketIndex size() const;
-
-  void clear();
-
-  bool reserveDelta(BucketIndex growth);
-
-  bool reserve(BucketIndex newItemCount);
-
-  const Value* find(const char* key) const;
-
-  Value* find(const char* key);
-
-  Value& resolveReference(const char* key, bool isStatic);
-
-  void remove(const char* key);
-
-  void doActualRemove(ValueInternalLink* link,
-                      BucketIndex index,
-                      BucketIndex bucketIndex);
-
-  ValueInternalLink*& getLastLinkInBucket(BucketIndex bucketIndex);
-
-  Value& setNewItem(const char* key,
-                    bool isStatic,
-                    ValueInternalLink* link,
-                    BucketIndex index);
-
-  Value& unsafeAdd(const char* key, bool isStatic, HashKey hashedKey);
-
-  HashKey hash(const char* key) const;
-
-  int compare(const ValueInternalMap& other) const;
-
-private:
-  void makeBeginIterator(IteratorState& it) const;
-  void makeEndIterator(IteratorState& it) const;
-  static bool equals(const IteratorState& x, const IteratorState& other);
-  static void increment(IteratorState& iterator);
-  static void incrementBucket(IteratorState& iterator);
-  static void decrement(IteratorState& iterator);
-  static const char* key(const IteratorState& iterator);
-  static const char* key(const IteratorState& iterator, bool& isStatic);
-  static Value& value(const IteratorState& iterator);
-  static int distance(const IteratorState& x, const IteratorState& y);
-
-private:
-  ValueInternalLink* buckets_;
-  ValueInternalLink* tailLink_;
-  BucketIndex bucketsSize_;
-  BucketIndex itemCount_;
-};
-
-/** \brief A simplified deque implementation used internally by Value.
-* \internal
-* It is based on a list of fixed "page", each page contains a fixed number of
-*items.
-* Instead of using a linked-list, a array of pointer is used for fast item
-*look-up.
-* Look-up for an element is as follow:
-* - compute page index: pageIndex = itemIndex / itemsPerPage
-* - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
-*
-* Insertion is amortized constant time (only the array containing the index of
-*pointers
-* need to be reallocated when items are appended).
-*/
-class JSON_API ValueInternalArray {
-  friend class Value;
-  friend class ValueIteratorBase;
-
-public:
-  enum {
-    itemsPerPage = 8
-  }; // should be a power of 2 for fast divide and modulo.
-  typedef Value::ArrayIndex ArrayIndex;
-  typedef unsigned int PageIndex;
-
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-  struct IteratorState // Must be a POD
-      {
-    IteratorState() : array_(0), currentPageIndex_(0), currentItemIndex_(0) {}
-    ValueInternalArray* array_;
-    Value** currentPageIndex_;
-    unsigned int currentItemIndex_;
-  };
-#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-  ValueInternalArray();
-  ValueInternalArray(const ValueInternalArray& other);
-  ValueInternalArray& operator=(ValueInternalArray other);
-  ~ValueInternalArray();
-  void swap(ValueInternalArray& other);
-
-  void clear();
-  void resize(ArrayIndex newSize);
-
-  Value& resolveReference(ArrayIndex index);
-
-  Value* find(ArrayIndex index) const;
-
-  ArrayIndex size() const;
-
-  int compare(const ValueInternalArray& other) const;
-
-private:
-  static bool equals(const IteratorState& x, const IteratorState& other);
-  static void increment(IteratorState& iterator);
-  static void decrement(IteratorState& iterator);
-  static Value& dereference(const IteratorState& iterator);
-  static Value& unsafeDereference(const IteratorState& iterator);
-  static int distance(const IteratorState& x, const IteratorState& y);
-  static ArrayIndex indexOf(const IteratorState& iterator);
-  void makeBeginIterator(IteratorState& it) const;
-  void makeEndIterator(IteratorState& it) const;
-  void makeIterator(IteratorState& it, ArrayIndex index) const;
-
-  void makeIndexValid(ArrayIndex index);
-
-  Value** pages_;
-  ArrayIndex size_;
-  PageIndex pageCount_;
-};
-
-/** \brief Experimental: do not use. Allocator to customize Value internal
-array.
- * Below is an example of a simple implementation (actual implementation use
- * memory pool).
-   \code
-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 destruct( 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 );
-   if ( !newIndexes )
-      throw std::bad_alloc();
-   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 );
-}
-};
-   \endcode
- */
-class JSON_API ValueArrayAllocator {
-public:
-  virtual ~ValueArrayAllocator();
-  virtual ValueInternalArray* newArray() = 0;
-  virtual ValueInternalArray* newArrayCopy(const ValueInternalArray& other) = 0;
-  virtual void destructArray(ValueInternalArray* array) = 0;
-  /** \brief Reallocate array page index.
-   * Reallocates an array of pointer on each page.
-   * \param indexes [input] pointer on the current index. May be \c NULL.
-   *                [output] pointer on the new index of at least
-   *                         \a minNewIndexCount pages.
-   * \param indexCount [input] current number of pages in the index.
-   *                   [output] number of page the reallocated index can handle.
-   *                            \b MUST be >= \a minNewIndexCount.
-   * \param minNewIndexCount Minimum number of page the new index must be able
-   * to
-   *                         handle.
-   */
-  virtual void
-  reallocateArrayPageIndex(Value**& indexes,
-                           ValueInternalArray::PageIndex& indexCount,
-                           ValueInternalArray::PageIndex minNewIndexCount) = 0;
-  virtual void
-  releaseArrayPageIndex(Value** indexes,
-                        ValueInternalArray::PageIndex indexCount) = 0;
-  virtual Value* allocateArrayPage() = 0;
-  virtual void releaseArrayPage(Value* value) = 0;
-};
-#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
-
 /** \brief base class for Value iterators.
  *
  */
@@ -934,31 +645,37 @@ public:
   typedef ValueIteratorBase SelfType;
 
   ValueIteratorBase();
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
   explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
-#else
-  ValueIteratorBase(const ValueInternalArray::IteratorState& state);
-  ValueIteratorBase(const ValueInternalMap::IteratorState& state);
-#endif
 
   bool operator==(const SelfType& other) const { return isEqual(other); }
 
   bool operator!=(const SelfType& other) const { return !isEqual(other); }
 
   difference_type operator-(const SelfType& other) const {
-    return computeDistance(other);
+    return other.computeDistance(*this);
   }
 
   /// Return either the index or the member name of the referenced value as a
   /// Value.
   Value key() const;
 
-  /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+  /// Return the index of the referenced Value, or -1 if it is not an arrayValue.
   UInt index() const;
 
+  /// Return the member name of the referenced Value, or "" if it is not an
+  /// objectValue.
+  /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
+  std::string name() const;
+
   /// Return the member name of the referenced Value. "" if it is not an
   /// objectValue.
-  const char* memberName() const;
+  /// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls.
+  JSONCPP_DEPRECATED("Use `key = name();` instead.")
+  char const* memberName() const;
+  /// Return the member name of the referenced Value, or NULL if it is not an
+  /// objectValue.
+  /// \note Better version than memberName(). Allows embedded nulls.
+  char const* memberName(char const** end) const;
 
 protected:
   Value& deref() const;
@@ -974,17 +691,9 @@ protected:
   void copy(const SelfType& other);
 
 private:
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
   Value::ObjectValues::iterator current_;
   // Indicates that iterator is for a null value.
   bool isNull_;
-#else
-  union {
-    ValueInternalArray::IteratorState array_;
-    ValueInternalMap::IteratorState map_;
-  } iterator_;
-  bool isArray_;
-#endif
 };
 
 /** \brief const iterator for object and array value.
@@ -995,8 +704,8 @@ class JSON_API ValueConstIterator : public ValueIteratorBase {
 
 public:
   typedef const Value value_type;
-  typedef unsigned int size_t;
+  //typedef unsigned int size_t;
-  typedef int difference_type;
+  //typedef int difference_type;
   typedef const Value& reference;
   typedef const Value* pointer;
   typedef ValueConstIterator SelfType;
@@ -1006,12 +715,7 @@ public:
 private:
 /*! \internal Use by Value to create an iterator.
  */
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
   explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
-#else
-  ValueConstIterator(const ValueInternalArray::IteratorState& state);
-  ValueConstIterator(const ValueInternalMap::IteratorState& state);
-#endif
 public:
   SelfType& operator=(const ValueIteratorBase& other);
 
@@ -1062,12 +766,7 @@ public:
 private:
 /*! \internal Use by Value to create an iterator.
  */
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
   explicit ValueIterator(const Value::ObjectValues::iterator& current);
-#else
-  ValueIterator(const ValueInternalArray::IteratorState& state);
-  ValueIterator(const ValueInternalMap::IteratorState& state);
-#endif
 public:
   SelfType& operator=(const SelfType& other);
 

include/json/version.h

@@ -4,10 +4,10 @@
 #ifndef JSON_VERSION_H_INCLUDED
 # define JSON_VERSION_H_INCLUDED
 
-# define JSONCPP_VERSION_STRING "1.4.0"
+# define JSONCPP_VERSION_STRING "0.10.1"
-# define JSONCPP_VERSION_MAJOR 1
+# define JSONCPP_VERSION_MAJOR 0
-# define JSONCPP_VERSION_MINOR 4
+# define JSONCPP_VERSION_MINOR 10
-# define JSONCPP_VERSION_PATCH 0
+# define JSONCPP_VERSION_PATCH 1
 # define JSONCPP_VERSION_QUALIFIER
 # define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
 

include/json/writer.h

@@ -46,7 +46,7 @@ public:
   /** Write Value into document as configured in sub-class.
       Do not take ownership of sout, but maintain a reference during function.
       \pre sout != NULL
-      \return zero on success
+      \return zero on success (For now, we always return zero, so check the stream instead.)
       \throw std::exception possibly, depending on configuration
    */
   virtual int write(Value const& root, std::ostream* sout) = 0;
@@ -66,7 +66,7 @@ public:
 /** \brief Write into stringstream, then return string, for convenience.
  * A StreamWriter will be created from the factory, used, and then deleted.
  */
-std::string writeString(StreamWriter::Factory const& factory, Value const& root);
+std::string JSON_API writeString(StreamWriter::Factory const& factory, Value const& root);
 
 
 /** \brief Build a StreamWriter implementation.
@@ -76,8 +76,8 @@ Usage:
   using namespace Json;
   Value value = ...;
   StreamWriterBuilder builder;
-  builder.settings_["commentStyle"] = "None";
+  builder["commentStyle"] = "None";
-  builder.settings_["indentation"] = "   ";  // or whatever you like
+  builder["indentation"] = "   ";  // or whatever you like
   std::unique_ptr<Json::StreamWriter> writer(
       builder.newStreamWriter());
   writer->write(value, &std::cout);
@@ -119,6 +119,10 @@ public:
    *   otherwise, indicate bad settings via 'invalid'.
    */
   bool validate(Json::Value* invalid) const;
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](std::string key);
+
   /** Called by ctor, but you can use this to reset settings_.
    * \pre 'settings' != NULL (but Json::null is fine)
    * \remark Defaults:
@@ -128,7 +132,7 @@ public:
 };
 
 /** \brief Abstract class for writers.
- * \deprecated Use StreamWriter.
+ * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
  */
 class JSON_API Writer {
 public:
@@ -147,21 +151,13 @@ public:
  * \deprecated Use StreamWriterBuilder.
  */
 class JSON_API FastWriter : public Writer {
+
 public:
   FastWriter();
   virtual ~FastWriter() {}
 
   void enableYAMLCompatibility();
 
-  /** \brief Drop the "null" string from the writer's output for nullValues.
-   * Strictly speaking, this is not valid JSON. But when the output is being
-   * fed to a browser's Javascript, it makes for smaller output and the
-   * browser can handle the output just fine.
-   */
-  void dropNullPlaceholders();
-
-  void omitEndingLineFeed();
-
 public: // overridden from Writer
   virtual std::string write(const Value& root);
 
@@ -170,8 +166,6 @@ private:
 
   std::string document_;
   bool yamlCompatiblityEnabled_;
-  bool dropNullPlaceholders_;
-  bool omitEndingLineFeed_;
 };
 
 /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a

makefiles/vs71/lib_json.vcproj

@@ -178,15 +178,6 @@
 		<File
 			RelativePath="..\..\include\json\json.h">
 		</File>
-		<File
-			RelativePath="..\..\src\lib_json\json_batchallocator.h">
-		</File>
-		<File
-			RelativePath="..\..\src\lib_json\json_internalarray.inl">
-		</File>
-		<File
-			RelativePath="..\..\src\lib_json\json_internalmap.inl">
-		</File>
 		<File
 			RelativePath="..\..\src\lib_json\json_reader.cpp">
 		</File>

src/jsontestrunner/CMakeLists.txt

@@ -1,4 +1,4 @@
-FIND_PACKAGE(PythonInterp 2.6 REQUIRED)
+FIND_PACKAGE(PythonInterp 2.6)
 
 IF(JSONCPP_LIB_BUILD_SHARED)
   ADD_DEFINITIONS( -DJSON_DLL )
@@ -20,7 +20,7 @@ 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
+    ADD_CUSTOM_TARGET(jsoncpp_readerwriter_tests
                       "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
                       DEPENDS jsontestrunner_exe jsoncpp_test
                       )

src/lib_json/CMakeLists.txt

@@ -34,7 +34,6 @@ SOURCE_GROUP( "Public API" FILES ${PUBLIC_HEADERS} )
 SET(jsoncpp_sources
                 json_tool.h
                 json_reader.cpp
-                json_batchallocator.h
                 json_valueiterator.inl
                 json_value.cpp
                 json_writer.cpp

src/lib_json/json_batchallocator.h

@@ -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

src/lib_json/json_internalarray.inl

@@ -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

src/lib_json/json_internalmap.inl

@@ -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 &current->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 = &current->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

src/lib_json/json_reader.cpp

@@ -17,7 +17,6 @@
 #include <sstream>
 #include <memory>
 #include <set>
-#include <stdexcept>
 
 #if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
 #define snprintf _snprintf
@@ -43,17 +42,14 @@ typedef std::auto_ptr<CharReader>   CharReaderPtr;
 // ////////////////////////////////
 
 Features::Features()
-    : allowComments_(true), strictRoot_(false),
+    : allowComments_(true), strictRoot_(false)
-      allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
+{}
-
 Features Features::all() { return Features(); }
 
 Features Features::strictMode() {
   Features features;
   features.allowComments_ = false;
   features.strictRoot_ = true;
-  features.allowDroppedNullPlaceholders_ = false;
-  features.allowNumericKeys_ = false;
   return features;
 }
 
@@ -148,7 +144,7 @@ bool Reader::readValue() {
   // But this deprecated class has a security problem: Bad input can
   // cause a seg-fault. This seems like a fair, binary-compatible way
   // to prevent the problem.
-  if (stackDepth_g >= stackLimit_g) throw std::runtime_error("Exceeded stackLimit in readValue().");
+  if (stackDepth_g >= stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue().");
   ++stackDepth_g;
 
   Token token;
@@ -163,11 +159,9 @@ bool Reader::readValue() {
   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);
@@ -179,41 +173,22 @@ bool Reader::readValue() {
     {
     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 tokenArraySeparator:
-    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);
   }
 
@@ -441,12 +416,11 @@ bool Reader::readString() {
   return c == '"';
 }
 
-bool Reader::readObject(Token& tokenStart) {
+bool Reader::readObject(Token& /*tokenStart*/) {
   Token tokenName;
   std::string name;
   Value init(objectValue);
   currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
   while (readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
@@ -459,11 +433,6 @@ bool Reader::readObject(Token& tokenStart) {
     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;
     }
@@ -497,10 +466,9 @@ bool Reader::readObject(Token& tokenStart) {
       "Missing '}' or object member name", tokenName, tokenObjectEnd);
 }
 
-bool Reader::readArray(Token& tokenStart) {
+bool Reader::readArray(Token& /*tokenStart*/) {
   Value init(arrayValue);
   currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
   skipSpaces();
   if (*current_ == ']') // empty array
   {
@@ -540,8 +508,6 @@ bool Reader::decodeNumber(Token& token) {
   if (!decodeNumber(token, decoded))
     return false;
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -590,8 +556,6 @@ bool Reader::decodeDouble(Token& token) {
   if (!decodeDouble(token, decoded))
     return false;
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -637,8 +601,6 @@ bool Reader::decodeString(Token& token) {
     return false;
   Value decoded(decoded_string);
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -850,70 +812,21 @@ std::string Reader::getFormattedErrorMessages() const {
   return formattedMessage;
 }
 
-std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
+// Reader
-  std::vector<Reader::StructuredError> allErrors;
+/////////////////////////
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
-    const ErrorInfo& error = *itError;
-    Reader::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;
-}
-
-bool Reader::pushError(const Value& value, const std::string& message) {
-  size_t 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();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = 0;
-  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)
-    return false;
-  Token token;
-  token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = begin_ + extra.getOffsetStart();
-  errors_.push_back(info);
-  return true;
-}
-
-bool Reader::good() const {
-  return !errors_.size();
-}
 
 // exact copy of Features
 class OurFeatures {
 public:
   static OurFeatures all();
-  static OurFeatures strictMode();
   OurFeatures();
   bool allowComments_;
   bool strictRoot_;
   bool allowDroppedNullPlaceholders_;
   bool allowNumericKeys_;
+  bool allowSingleQuotes_;
+  bool failIfExtra_;
+  bool rejectDupKeys_;
   int stackLimit_;
 };  // OurFeatures
 
@@ -921,20 +834,15 @@ public:
 // ////////////////////////////////
 
 OurFeatures::OurFeatures()
-    : allowComments_(true), strictRoot_(false),
+    : allowComments_(true), strictRoot_(false)
-      allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
+    , allowDroppedNullPlaceholders_(false), allowNumericKeys_(false)
+    , allowSingleQuotes_(false)
+    , failIfExtra_(false)
+{
+}
 
 OurFeatures OurFeatures::all() { return OurFeatures(); }
 
-OurFeatures OurFeatures::strictMode() {
-  OurFeatures features;
-  features.allowComments_ = false;
-  features.strictRoot_ = true;
-  features.allowDroppedNullPlaceholders_ = false;
-  features.allowNumericKeys_ = false;
-  return features;
-}
-
 // Implementation of class Reader
 // ////////////////////////////////
 
@@ -955,10 +863,6 @@ public:
              Value& root,
              bool collectComments = true);
   std::string getFormattedErrorMessages() const;
-  std::vector<StructuredError> getStructuredErrors() const;
-  bool pushError(const Value& value, const std::string& message);
-  bool pushError(const Value& value, const std::string& message, const Value& extra);
-  bool good() const;
 
 private:
   OurReader(OurReader const&);  // no impl
@@ -1004,6 +908,7 @@ private:
   bool readCStyleComment();
   bool readCppStyleComment();
   bool readString();
+  bool readStringSingleQuote();
   void readNumber();
   bool readValue();
   bool readObject(Token& token);
@@ -1083,6 +988,12 @@ bool OurReader::parse(const char* beginDoc,
   bool successful = readValue();
   Token token;
   skipCommentTokens(token);
+  if (features_.failIfExtra_) {
+    if (token.type_ != tokenError && token.type_ != tokenEndOfStream) {
+      addError("Extra non-whitespace after JSON value.", token);
+      return false;
+    }
+  }
   if (collectComments_ && !commentsBefore_.empty())
     root.setComment(commentsBefore_, commentAfter);
   if (features_.strictRoot_) {
@@ -1102,7 +1013,7 @@ bool OurReader::parse(const char* beginDoc,
 }
 
 bool OurReader::readValue() {
-  if (stackDepth_ >= features_.stackLimit_) throw std::runtime_error("Exceeded stackLimit in readValue().");
+  if (stackDepth_ >= features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue().");
   ++stackDepth_;
   Token token;
   skipCommentTokens(token);
@@ -1116,11 +1027,9 @@ bool OurReader::readValue() {
   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);
@@ -1132,41 +1041,32 @@ bool OurReader::readValue() {
     {
     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 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 ...
-  // Else, fall through...
   default:
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
     return addError("Syntax error: value, object or array expected.", token);
   }
 
@@ -1211,6 +1111,12 @@ bool OurReader::readToken(Token& token) {
     token.type_ = tokenString;
     ok = readString();
     break;
+  case '\'':
+    if (features_.allowSingleQuotes_) {
+    token.type_ = tokenString;
+    ok = readStringSingleQuote();
+    break;
+    } // else continue
   case '/':
     token.type_ = tokenComment;
     ok = readComment();
@@ -1362,7 +1268,6 @@ void OurReader::readNumber() {
       c = (current_ = p) < end_ ? *p++ : 0;
   }
 }
-
 bool OurReader::readString() {
   Char c = 0;
   while (current_ != end_) {
@@ -1375,12 +1280,24 @@ bool OurReader::readString() {
   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& tokenStart) {
   Token tokenName;
   std::string name;
   Value init(objectValue);
   currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
   while (readToken(tokenName)) {
     bool initialTokenOk = true;
     while (tokenName.type_ == tokenComment && initialTokenOk)
@@ -1407,6 +1324,12 @@ bool OurReader::readObject(Token& tokenStart) {
       return addErrorAndRecover(
           "Missing ':' after object member name", colon, tokenObjectEnd);
     }
+    if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30");
+    if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
+      std::string msg = "Duplicate key: '" + name + "'";
+      return addErrorAndRecover(
+          msg, tokenName, tokenObjectEnd);
+    }
     Value& value = currentValue()[name];
     nodes_.push(&value);
     bool ok = readValue();
@@ -1434,7 +1357,6 @@ bool OurReader::readObject(Token& tokenStart) {
 bool OurReader::readArray(Token& tokenStart) {
   Value init(arrayValue);
   currentValue().swapPayload(init);
-  currentValue().setOffsetStart(tokenStart.start_ - begin_);
   skipSpaces();
   if (*current_ == ']') // empty array
   {
@@ -1474,8 +1396,6 @@ bool OurReader::decodeNumber(Token& token) {
   if (!decodeNumber(token, decoded))
     return false;
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -1524,8 +1444,6 @@ bool OurReader::decodeDouble(Token& token) {
   if (!decodeDouble(token, decoded))
     return false;
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -1571,8 +1489,6 @@ bool OurReader::decodeString(Token& token) {
     return false;
   Value decoded(decoded_string);
   currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
   return true;
 }
 
@@ -1779,60 +1695,6 @@ std::string OurReader::getFormattedErrorMessages() const {
   return formattedMessage;
 }
 
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
-  std::vector<OurReader::StructuredError> allErrors;
-  for (Errors::const_iterator itError = errors_.begin();
-       itError != errors_.end();
-       ++itError) {
-    const ErrorInfo& error = *itError;
-    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;
-}
-
-bool OurReader::pushError(const Value& value, const std::string& message) {
-  size_t 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();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = 0;
-  errors_.push_back(info);
-  return true;
-}
-
-bool OurReader::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)
-    return false;
-  Token token;
-  token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = begin_ + extra.getOffsetStart();
-  errors_.push_back(info);
-  return true;
-}
-
-bool OurReader::good() const {
-  return !errors_.size();
-}
-
 
 class OurCharReader : public CharReader {
   bool const collectComments_;
@@ -1869,7 +1731,10 @@ CharReader* CharReaderBuilder::newCharReader() const
   features.strictRoot_ = settings_["strictRoot"].asBool();
   features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool();
   features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
+  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
   features.stackLimit_ = settings_["stackLimit"].asInt();
+  features.failIfExtra_ = settings_["failIfExtra"].asBool();
+  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
   return new OurCharReader(collectComments, features);
 }
 static void getValidReaderKeys(std::set<std::string>* valid_keys)
@@ -1880,14 +1745,16 @@ static void getValidReaderKeys(std::set<std::string>* valid_keys)
   valid_keys->insert("strictRoot");
   valid_keys->insert("allowDroppedNullPlaceholders");
   valid_keys->insert("allowNumericKeys");
+  valid_keys->insert("allowSingleQuotes");
   valid_keys->insert("stackLimit");
+  valid_keys->insert("failIfExtra");
+  valid_keys->insert("rejectDupKeys");
 }
 bool CharReaderBuilder::validate(Json::Value* invalid) const
 {
   Json::Value my_invalid;
   if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
   Json::Value& inv = *invalid;
-  bool valid = true;
   std::set<std::string> valid_keys;
   getValidReaderKeys(&valid_keys);
   Value::Members keys = settings_.getMemberNames();
@@ -1898,7 +1765,11 @@ bool CharReaderBuilder::validate(Json::Value* invalid) const
       inv[key] = settings_[key];
     }
   }
-  return valid;
+  return 0u == inv.size();
+}
+Value& CharReaderBuilder::operator[](std::string key)
+{
+  return settings_[key];
 }
 // static
 void CharReaderBuilder::strictMode(Json::Value* settings)
@@ -1908,6 +1779,9 @@ void CharReaderBuilder::strictMode(Json::Value* settings)
   (*settings)["strictRoot"] = true;
   (*settings)["allowDroppedNullPlaceholders"] = false;
   (*settings)["allowNumericKeys"] = false;
+  (*settings)["allowSingleQuotes"] = false;
+  (*settings)["failIfExtra"] = true;
+  (*settings)["rejectDupKeys"] = true;
 //! [CharReaderBuilderStrictMode]
 }
 // static
@@ -1919,7 +1793,10 @@ void CharReaderBuilder::setDefaults(Json::Value* settings)
   (*settings)["strictRoot"] = false;
   (*settings)["allowDroppedNullPlaceholders"] = false;
   (*settings)["allowNumericKeys"] = false;
+  (*settings)["allowSingleQuotes"] = false;
   (*settings)["stackLimit"] = 1000;
+  (*settings)["failIfExtra"] = false;
+  (*settings)["rejectDupKeys"] = false;
 //! [CharReaderBuilderDefaults]
 }
 
@@ -1949,7 +1826,7 @@ std::istream& operator>>(std::istream& sin, Value& root) {
             "Error from reader: %s",
             errs.c_str());
 
-    JSON_FAIL_MESSAGE("reader error");
+    throwRuntimeError("reader error");
   }
   return sin;
 }

src/lib_json/json_valueiterator.inl

@@ -16,68 +16,29 @@ namespace Json {
 // //////////////////////////////////////////////////////////////////
 
 ValueIteratorBase::ValueIteratorBase()
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
     : current_(), isNull_(true) {
 }
-#else
-    : isArray_(true), isNull_(true) {
-  iterator_.array_ = ValueInternalArray::IteratorState();
-}
-#endif
 
-#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() 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() {
-#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
 }
 
 ValueIteratorBase::difference_type
 ValueIteratorBase::computeDistance(const SelfType& other) const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
 #ifdef JSON_USE_CPPTL_SMALLMAP
-  return current_ - other.current_;
+  return other.current_ - current_;
 #else
   // Iterator for null value are initialized using the default
   // constructor, which initialize current_ to the default
@@ -100,80 +61,58 @@ ValueIteratorBase::computeDistance(const SelfType& other) const {
   }
   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(StaticString(czstring.data()));
-    return Value(czstring.c_str());
+    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 {
+std::string ValueIteratorBase::name() const {
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
+  char const* key;
-  const char* name = (*current_).first.c_str();
+  char const* end;
+  key = memberName(&end);
+  if (!key) return std::string();
+  return std::string(key, end);
+}
+
+char const* ValueIteratorBase::memberName() const {
+  const char* name = (*current_).first.data();
   return name ? name : "";
-#else
+}
-  if (!isArray_)
+
-    return ValueInternalMap::key(iterator_.map_);
+char const* ValueIteratorBase::memberName(char const** end) const {
-  return "";
+  const char* name = (*current_).first.data();
-#endif
+  if (!name) {
+    *end = NULL;
+    return NULL;
+  }
+  *end = name + (*current_).first.length();
+  return name;
 }
 
 // //////////////////////////////////////////////////////////////////
@@ -186,19 +125,9 @@ const char* ValueIteratorBase::memberName() const {
 
 ValueConstIterator::ValueConstIterator() {}
 
-#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::
 operator=(const ValueIteratorBase& other) {
@@ -216,16 +145,8 @@ operator=(const ValueIteratorBase& other) {
 
 ValueIterator::ValueIterator() {}
 
-#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) {}

src/lib_json/json_writer.cpp

@@ -12,16 +12,25 @@
 #include <sstream>
 #include <utility>
 #include <set>
-#include <stdexcept>
+#include <cassert>
-#include <assert.h>
+#include <cstring>
-#include <math.h>
+#include <cstdio>
-#include <stdio.h>
-#include <string.h>
 
-#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
+#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
 #include <float.h>
 #define isfinite _finite
+#elif defined(__sun) && defined(__SVR4) //Solaris
+#include <ieeefp.h>
+#define isfinite finite
+#else
+#include <cmath>
+#define isfinite std::isfinite
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
 #define snprintf _snprintf
+#elif __cplusplus >= 201103L
+#define snprintf std::snprintf
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
@@ -29,11 +38,6 @@
 #pragma warning(disable : 4996)
 #endif
 
-#if defined(__sun) && defined(__SVR4) //Solaris
-#include <ieeefp.h>
-#define isfinite finite
-#endif
-
 namespace Json {
 
 #if __cplusplus >= 201103L
@@ -50,6 +54,16 @@ static bool containsControlCharacter(const char* str) {
   return false;
 }
 
+static bool containsControlCharacter0(const char* str, unsigned len) {
+  char const* end = str + len;
+  while (end != str) {
+    if (isControlCharacter(*str) || 0==*str)
+      return true;
+    ++str;
+  }
+  return false;
+}
+
 std::string valueToString(LargestInt value) {
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
@@ -184,6 +198,84 @@ std::string valueToQuotedString(const char* value) {
   return result;
 }
 
+// https://github.com/upcaste/upcaste/blob/master/src/upcore/src/cstring/strnpbrk.cpp
+static char const* strnpbrk(char const* s, char const* accept, size_t n) {
+  assert((s || !n) && accept);
+
+  char const* const end = s + n;
+  for (char const* cur = s; cur < end; ++cur) {
+    int const c = *cur;
+    for (char const* a = accept; *a; ++a) {
+      if (*a == c) {
+        return cur;
+      }
+    }
+  }
+  return NULL;
+}
+static std::string valueToQuotedStringN(const char* value, unsigned length) {
+  if (value == NULL)
+    return "";
+  // Not sure how to handle unicode...
+  if (strnpbrk(value, "\"\\\b\f\n\r\t", length) == NULL &&
+      !containsControlCharacter0(value, length))
+    return std::string("\"") + value + "\"";
+  // We have to walk value and escape any special characters.
+  // Appending to std::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 =
+      length * 2 + 3; // allescaped+quotes+NULL
+  std::string result;
+  result.reserve(maxsize); // to avoid lots of mallocs
+  result += "\"";
+  char const* end = value + length;
+  for (const char* c = value; c != end; ++c) {
+    switch (*c) {
+    case '\"':
+      result += "\\\"";
+      break;
+    case '\\':
+      result += "\\\\";
+      break;
+    case '\b':
+      result += "\\b";
+      break;
+    case '\f':
+      result += "\\f";
+      break;
+    case '\n':
+      result += "\\n";
+      break;
+    case '\r':
+      result += "\\r";
+      break;
+    case '\t':
+      result += "\\t";
+      break;
+    // 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.)
+    // 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)) || (*c == 0)) {
+        std::ostringstream oss;
+        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+            << std::setw(4) << static_cast<int>(*c);
+        result += oss.str();
+      } else {
+        result += *c;
+      }
+      break;
+    }
+  }
+  result += "\"";
+  return result;
+}
+
 // Class Writer
 // //////////////////////////////////////////////////////////////////
 Writer::~Writer() {}
@@ -192,28 +284,21 @@ Writer::~Writer() {}
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
+    : yamlCompatiblityEnabled_(false) {}
-      omitEndingLineFeed_(false) {}
 
 void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
 
-void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
-
-void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
-
 std::string FastWriter::write(const Value& root) {
   document_ = "";
   writeValue(root);
-  if (!omitEndingLineFeed_)
+  document_ += "\n";
-    document_ += "\n";
   return document_;
 }
 
 void FastWriter::writeValue(const Value& value) {
   switch (value.type()) {
   case nullValue:
-    if (!dropNullPlaceholders_)
+    document_ += "null";
-      document_ += "null";
     break;
   case intValue:
     document_ += valueToString(value.asLargestInt());
@@ -248,7 +333,7 @@ void FastWriter::writeValue(const Value& value) {
       const std::string& name = *it;
       if (it != members.begin())
         document_ += ',';
-      document_ += valueToQuotedString(name.c_str());
+      document_ += valueToQuotedStringN(name.data(), name.length());
       document_ += yamlCompatiblityEnabled_ ? ": " : ":";
       writeValue(value[name]);
     }
@@ -289,8 +374,15 @@ void StyledWriter::writeValue(const Value& value) {
     pushValue(valueToString(value.asDouble()));
     break;
   case stringValue:
-    pushValue(valueToQuotedString(value.asCString()));
+  {
+    // Is NULL is possible for value.string_?
+    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;
@@ -767,8 +859,15 @@ void BuiltStyledStreamWriter::writeValue(Value const& value) {
     pushValue(valueToString(value.asDouble()));
     break;
   case stringValue:
-    pushValue(valueToQuotedString(value.asCString()));
+  {
+    // Is NULL is possible for value.string_?
+    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;
@@ -787,7 +886,7 @@ void BuiltStyledStreamWriter::writeValue(Value const& value) {
         std::string const& name = *it;
         Value const& childValue = value[name];
         writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
+        writeWithIndent(valueToQuotedStringN(name.data(), name.length()));
         *sout_ << colonSymbol_;
         writeValue(childValue);
         if (++it == members.end()) {
@@ -978,7 +1077,7 @@ StreamWriter* StreamWriterBuilder::newStreamWriter() const
   } else if (cs_str == "None") {
     cs = CommentStyle::None;
   } else {
-    throw std::runtime_error("commentStyle must be 'All' or 'None'");
+    throwRuntimeError("commentStyle must be 'All' or 'None'");
   }
   std::string colonSymbol = " : ";
   if (eyc) {
@@ -1008,7 +1107,6 @@ bool StreamWriterBuilder::validate(Json::Value* invalid) const
   Json::Value my_invalid;
   if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
   Json::Value& inv = *invalid;
-  bool valid = true;
   std::set<std::string> valid_keys;
   getValidWriterKeys(&valid_keys);
   Value::Members keys = settings_.getMemberNames();
@@ -1019,7 +1117,11 @@ bool StreamWriterBuilder::validate(Json::Value* invalid) const
       inv[key] = settings_[key];
     }
   }
-  return valid;
+  return 0u == inv.size();
+}
+Value& StreamWriterBuilder::operator[](std::string key)
+{
+  return settings_[key];
 }
 // static
 void StreamWriterBuilder::setDefaults(Json::Value* settings)

src/test_lib_json/CMakeLists.txt

@@ -1,3 +1,4 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
 
 IF(JSONCPP_LIB_BUILD_SHARED)
   ADD_DEFINITIONS( -DJSON_DLL )
@@ -22,9 +23,19 @@ ENDIF(JSONCPP_LIB_BUILD_SHARED)
 # 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
+    IF(JSONCPP_LIB_BUILD_SHARED)
-                        POST_BUILD
+        # First, copy the shared lib, for Microsoft.
-                        COMMAND $<TARGET_FILE:jsoncpp_test>)
+        # Then, run the test executable.
+        ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
+                            POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:jsoncpp_lib> $<TARGET_FILE_DIR:jsoncpp_test>
+                            COMMAND $<TARGET_FILE:jsoncpp_test>)
+    ELSE(JSONCPP_LIB_BUILD_SHARED)
+        # Just run the test executable.
+        ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
+                            POST_BUILD
+                            COMMAND $<TARGET_FILE:jsoncpp_test>)
+    ENDIF(JSONCPP_LIB_BUILD_SHARED)
 ENDIF(JSONCPP_WITH_POST_BUILD_UNITTEST)
 
 SET_TARGET_PROPERTIES(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test) 

src/test_lib_json/main.cpp

@@ -6,7 +6,6 @@
 #include "jsontest.h"
 #include <json/config.h>
 #include <json/json.h>
-#include <stdexcept>
 #include <cstring>
 
 // Make numeric limits more convenient to talk about.
@@ -282,6 +281,8 @@ JSONTEST_FIXTURE(ValueTest, null) {
   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::null, null_);
 }
 
 JSONTEST_FIXTURE(ValueTest, strings) {
@@ -1497,34 +1498,124 @@ JSONTEST_FIXTURE(ValueTest, typeChecksThrowExceptions) {
 #endif
 }
 
-JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
+JSONTEST_FIXTURE(ValueTest, StaticString) {
-  Json::Value x;
+  char mutant[] = "hello";
-  JSONTEST_ASSERT(x.getOffsetStart() == 0);
+  Json::StaticString ss(mutant);
-  JSONTEST_ASSERT(x.getOffsetLimit() == 0);
+  std::string regular(mutant);
-  x.setOffsetStart(10);
+  mutant[1] = 'a';
-  x.setOffsetLimit(20);
+  JSONTEST_ASSERT_STRING_EQUAL("hallo", ss.c_str());
-  JSONTEST_ASSERT(x.getOffsetStart() == 10);
+  JSONTEST_ASSERT_STRING_EQUAL("hello", regular.c_str());
-  JSONTEST_ASSERT(x.getOffsetLimit() == 20);
+  {
-  Json::Value y(x);
+    Json::Value root;
-  JSONTEST_ASSERT(y.getOffsetStart() == 10);
+    root["top"] = ss;
-  JSONTEST_ASSERT(y.getOffsetLimit() == 20);
+    JSONTEST_ASSERT_STRING_EQUAL("hallo", root["top"].asString());
-  Json::Value z;
+    mutant[1] = 'u';
-  z.swap(y);
+    JSONTEST_ASSERT_STRING_EQUAL("hullo", root["top"].asString());
-  JSONTEST_ASSERT(z.getOffsetStart() == 10);
+  }
-  JSONTEST_ASSERT(z.getOffsetLimit() == 20);
+  {
-  JSONTEST_ASSERT(y.getOffsetStart() == 0);
+    Json::Value root;
-  JSONTEST_ASSERT(y.getOffsetLimit() == 0);
+    root["top"] = regular;
+    JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+    mutant[1] = 'u';
+    JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+  }
 }
 
-struct WriterTest : JsonTest::TestCase {};
+JSONTEST_FIXTURE(ValueTest, CommentBefore) {
+  Json::Value val; // fill val
+  val.setComment(std::string("// this comment should appear before"), Json::commentBefore);
+  Json::StreamWriterBuilder wbuilder;
+  wbuilder.settings_["commentStyle"] = "All";
+  {
+    char const expected[] = "// this comment should appear before\nnull";
+    std::string result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    std::string res2 = val.toStyledString();
+    std::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\"";
+    std::string result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    std::string res2 = val.toStyledString();
+    std::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\"";
+    std::string result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    std::string res2 = val.toStyledString();
+    std::string exp2 = "";
+    exp2 += expected;
+    exp2 += "\n";
+    JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+  }
+}
 
-JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
+JSONTEST_FIXTURE(ValueTest, zeroes) {
-  Json::FastWriter writer;
+  char const cstr[] = "h\0i";
-  Json::Value nullValue;
+  std::string binary(cstr, sizeof(cstr));  // include trailing 0
-  JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
+  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
+  }
+}
 
-  writer.dropNullPlaceholders();
+JSONTEST_FIXTURE(ValueTest, zeroesInKeys) {
-  JSONTEST_ASSERT(writer.write(nullValue) == "\n");
+  char const cstr[] = "h\0i";
+  std::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::nullRef).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::nullRef).asString());
+  }
 }
 
 struct StreamWriterTest : JsonTest::TestCase {};
@@ -1538,6 +1629,28 @@ JSONTEST_FIXTURE(StreamWriterTest, dropNullPlaceholders) {
   JSONTEST_ASSERT(Json::writeString(b, nullValue) == "");
 }
 
+JSONTEST_FIXTURE(StreamWriterTest, writeZeroes) {
+  std::string binary("hi", 3);  // include trailing 0
+  JSONTEST_ASSERT_EQUAL(3, binary.length());
+  std::string expected("\"hi\\u0000\"");  // unicoded zero
+  Json::StreamWriterBuilder b;
+  {
+    Json::Value root;
+    root = binary;
+    JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
+    std::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());
+    std::string out = Json::writeString(b, root["top"]);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, out);
+  }
+}
+
 struct ReaderTest : JsonTest::TestCase {};
 
 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
@@ -1546,7 +1659,6 @@ JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
   bool ok = reader.parse("{ \"property\" : \"value\" }", root);
   JSONTEST_ASSERT(ok);
   JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
-  JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
 }
 
 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
@@ -1558,25 +1670,6 @@ JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
                          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(ReaderTest, parseWithOneError) {
@@ -1587,13 +1680,6 @@ JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
                   "* 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) {
@@ -1604,13 +1690,6 @@ JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
                   "* 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) {
@@ -1621,12 +1700,6 @@ JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
                   "* 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");
 }
 
 struct CharReaderTest : JsonTest::TestCase {};
@@ -1741,6 +1814,440 @@ JSONTEST_FIXTURE(CharReaderTest, parseWithStackLimit) {
   }
 }
 
+struct CharReaderStrictModeTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(CharReaderStrictModeTest, dupKeys) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      "{ \"property\" : \"value\", \"key\" : \"val1\", \"key\" : \"val2\" }";
+  {
+    b.strictMode(&b.settings_);
+    Json::CharReader* reader(b.newCharReader());
+    std::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
+    delete reader;
+  }
+}
+struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue164) {
+  // This is interpretted as a string value followed by a colon.
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      " \"property\" : \"value\" }";
+  {
+  b.settings_["failIfExtra"] = false;
+  Json::CharReader* reader(b.newCharReader());
+  std::string errs;
+  bool ok = reader->parse(
+      doc, doc + std::strlen(doc),
+      &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(errs == "");
+  JSONTEST_ASSERT_EQUAL("property", root);
+  delete reader;
+  }
+  {
+  b.settings_["failIfExtra"] = true;
+  Json::CharReader* reader(b.newCharReader());
+  std::string errs;
+  bool ok = reader->parse(
+      doc, doc + std::strlen(doc),
+      &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT_STRING_EQUAL(errs,
+      "* Line 1, Column 13\n"
+      "  Extra non-whitespace after JSON value.\n");
+  JSONTEST_ASSERT_EQUAL("property", root);
+  delete reader;
+  }
+  {
+  b.settings_["failIfExtra"] = false;
+  b.strictMode(&b.settings_);
+  Json::CharReader* reader(b.newCharReader());
+  std::string errs;
+  bool ok = reader->parse(
+      doc, doc + std::strlen(doc),
+      &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT_STRING_EQUAL(errs,
+      "* Line 1, Column 13\n"
+      "  Extra non-whitespace after JSON value.\n");
+  JSONTEST_ASSERT_EQUAL("property", root);
+  delete reader;
+  }
+}
+JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue107) {
+  // This is interpretted as an int value followed by a colon.
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      "1:2:3";
+  b.settings_["failIfExtra"] = true;
+  Json::CharReader* reader(b.newCharReader());
+  std::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());
+  delete reader;
+}
+JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterObject) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  {
+  char const doc[] =
+      "{ \"property\" : \"value\" } //trailing\n//comment\n";
+  b.settings_["failIfExtra"] = true;
+  Json::CharReader* reader(b.newCharReader());
+  std::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"]);
+  delete reader;
+  }
+}
+JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterArray) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      "[ \"property\" , \"value\" ] //trailing\n//comment\n";
+  b.settings_["failIfExtra"] = true;
+  Json::CharReader* reader(b.newCharReader());
+  std::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]);
+  delete reader;
+}
+JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterBool) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      " true /*trailing\ncomment*/";
+  b.settings_["failIfExtra"] = true;
+  Json::CharReader* reader(b.newCharReader());
+  std::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());
+  delete reader;
+}
+struct CharReaderAllowDropNullTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(CharReaderAllowDropNullTest, issue178) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowDroppedNullPlaceholders"] = true;
+  Json::Value root;
+  std::string errs;
+  Json::CharReader* reader(b.newCharReader());
+  {
+    char const doc[] = "{\"a\":,\"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(Json::nullValue, root.get("a", true));
+  }
+  {
+    char const doc[] = "{\"a\":}";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(1u, root.size());
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, root.get("a", true));
+  }
+  {
+    char const doc[] = "[]";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs == "");
+    JSONTEST_ASSERT_EQUAL(0u, root.size());
+    JSONTEST_ASSERT_EQUAL(Json::arrayValue, root);
+  }
+  {
+    char const doc[] = "[null]";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs == "");
+    JSONTEST_ASSERT_EQUAL(1u, root.size());
+  }
+  {
+    char const doc[] = "[,]";
+    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());
+  }
+  {
+    char const doc[] = "[,,,]";
+    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());
+  }
+  {
+    char const doc[] = "[null,]";
+    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());
+  }
+  {
+    char const doc[] = "[,null]";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs == "");
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+  }
+  {
+    char const doc[] = "[,,]";
+    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());
+  }
+  {
+    char const doc[] = "[null,,]";
+    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());
+  }
+  {
+    char const doc[] = "[,null,]";
+    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());
+  }
+  {
+    char const doc[] = "[,,null]";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs == "");
+    JSONTEST_ASSERT_EQUAL(3u, root.size());
+  }
+  {
+    char const doc[] = "[[],,,]";
+    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());
+    JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[0u]);
+  }
+  {
+    char const doc[] = "[,[],,]";
+    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());
+    JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[1u]);
+  }
+  {
+    char const doc[] = "[,,,[]]";
+    bool ok = reader->parse(
+        doc, doc + std::strlen(doc),
+        &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs == "");
+    JSONTEST_ASSERT_EQUAL(4u, root.size());
+    JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[3u]);
+  }
+  delete reader;
+}
+
+struct CharReaderAllowSingleQuotesTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(CharReaderAllowSingleQuotesTest, issue182) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowSingleQuotes"] = true;
+  Json::Value root;
+  std::string errs;
+  Json::CharReader* 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(CharReaderAllowZeroesTest, issue176) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowSingleQuotes"] = true;
+  Json::Value root;
+  std::string errs;
+  Json::CharReader* 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 BuilderTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(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 IteratorTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE(IteratorTest, distance) {
+  Json::Value json;
+  json["k1"] = "a";
+  json["k2"] = "b";
+  int dist = 0;
+  std::string str;
+  for (Json::ValueIterator it = json.begin(); it != json.end(); ++it) {
+    dist = it - json.begin();
+    str = it->asString().c_str();
+  }
+  JSONTEST_ASSERT_EQUAL(1, dist);
+  JSONTEST_ASSERT_STRING_EQUAL("b", str);
+}
+
+JSONTEST_FIXTURE(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_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_EQUAL(-1, it.index());
+  ++it;
+  JSONTEST_ASSERT(it == json.end());
+}
+
+JSONTEST_FIXTURE(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());
+}
+
 int main(int argc, const char* argv[]) {
   JsonTest::Runner runner;
   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
@@ -1761,8 +2268,15 @@ int main(int argc, const char* argv[]) {
   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, ValueTest, StaticString);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, CommentBefore);
+  //JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nulls);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, zeroes);
+  JSONTEST_REGISTER_FIXTURE(runner, ValueTest, zeroesInKeys);
+
+  JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, dropNullPlaceholders);
+  JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, writeZeroes);
 
   JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
   JSONTEST_REGISTER_FIXTURE(
@@ -1779,8 +2293,25 @@ int main(int argc, const char* argv[]) {
   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithDetailError);
   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithStackLimit);
 
-  JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderStrictModeTest, dupKeys);
-  JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, dropNullPlaceholders);
+
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue164);
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue107);
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterObject);
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterArray);
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterBool);
+
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowDropNullTest, issue178);
+
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowSingleQuotesTest, issue182);
+
+  JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowZeroesTest, issue176);
+
+  JSONTEST_REGISTER_FIXTURE(runner, BuilderTest, settings);
+
+  JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, distance);
+  JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, names);
+  JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, indexes);
 
   return runner.runCommandLine(argc, argv);
 }

version

@@ -1 +1 @@
-1.4.0
+0.10.1

version.in

@@ -0,0 +1 @@
+@JSONCPP_VERSION@