0.7.0

This reverts commit 45cd9490cd.

Ignored ValueInternal* changes, since those did not produce symbols for
Debian build. (They must not have used the INTERNAL stuff.)

  https://github.com/open-source-parsers/jsoncpp/issues/78

Conflicts:
	include/json/value.h
	src/lib_json/json_internalarray.inl
	src/lib_json/json_internalmap.inl
	src/lib_json/json_value.cpp

.clang-format

@@ -0,0 +1,47 @@
+---
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: false
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: false
+ColumnLimit:     80
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+DerivePointerBinding: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: false
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 60
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerBindsToType: true
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: false
+Standard:        Cpp03
+IndentWidth:     2
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Attach
+IndentFunctionDeclarationAfterType: false
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+...
+

.gitignore

@@ -0,0 +1,13 @@
+/build/
+*.pyc
+*.swp
+*.actual
+*.actual-rewrite
+*.process-output
+*.rewrite
+/bin/
+/buildscons/
+/libs/
+/doc/doxyfile
+/dist/
+/include/json/version.h

.travis.yml

@@ -0,0 +1,18 @@
+# Build matrix / environment variable are explained on:
+# http://about.travis-ci.org/docs/user/build-configuration/
+# This file can be validated on:
+# http://lint.travis-ci.org/
+before_install: sudo apt-get install cmake
+language: cpp
+compiler:
+  - gcc
+  - clang
+script: cmake -DJSONCPP_LIB_BUILD_SHARED=$SHARED_LIBRARY -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_VERBOSE_MAKEFILE=$VERBOSE_MAKE . && make
+env:
+  matrix:
+    - SHARED_LIBRARY=ON BUILD_TYPE=release VERBOSE_MAKE=false
+    - SHARED_LIBRARY=OFF BUILD_TYPE=release VERBOSE_MAKE=false
+    - SHARED_LIBRARY=OFF BUILD_TYPE=debug VERBOSE VERBOSE_MAKE=true
+notifications:
+  email:
+    - aaronjjacobs@gmail.com

CMakeLists.txt

@@ -0,0 +1,117 @@
+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_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)
+OPTION(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" OFF)
+
+# Ensures that CMAKE_BUILD_TYPE is visible in cmake-gui on Unix
+IF(NOT WIN32)
+    IF(NOT CMAKE_BUILD_TYPE)
+        SET(CMAKE_BUILD_TYPE Release CACHE STRING
+            "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage."
+            FORCE)
+    ENDIF(NOT CMAKE_BUILD_TYPE)
+ENDIF(NOT WIN32)
+
+SET(RUNTIME_INSTALL_DIR bin
+    CACHE PATH "Install dir for executables and dlls")
+SET(ARCHIVE_INSTALL_DIR lib
+    CACHE PATH "Install dir for static libraries")
+SET(LIBRARY_INSTALL_DIR lib
+    CACHE PATH "Install dir for shared libraries")
+SET(INCLUDE_INSTALL_DIR include
+    CACHE PATH "Install dir for headers")
+SET(PACKAGE_INSTALL_DIR lib/cmake
+    CACHE PATH "Install dir for cmake package config files")
+MARK_AS_ADVANCED( RUNTIME_INSTALL_DIR ARCHIVE_INSTALL_DIR INCLUDE_INSTALL_DIR PACKAGE_INSTALL_DIR )
+
+# This ensures shared DLL are in the same dir as executable on Windows.
+# Put all executables / libraries are in a project global directory.
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
+    CACHE PATH "Single directory for all static libraries.")
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
+    CACHE PATH "Single directory for all dynamic libraries on Unix.")
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
+    CACHE PATH "Single directory for all executable and dynamic libraries on Windows.")
+MARK_AS_ADVANCED( CMAKE_RUNTIME_OUTPUT_DIRECTORY CMAKE_LIBRARY_OUTPUT_DIRECTORY CMAKE_ARCHIVE_OUTPUT_DIRECTORY )
+
+# Set variable named ${VAR_NAME} to value ${VALUE}
+FUNCTION(set_using_dynamic_name VAR_NAME VALUE)
+    SET( "${VAR_NAME}" "${VALUE}" PARENT_SCOPE)
+ENDFUNCTION(set_using_dynamic_name)
+
+# Extract major, minor, patch from version text
+# Parse a version string "X.Y.Z" and outputs
+# version parts in ${OUPUT_PREFIX}_MAJOR, _MINOR, _PATCH.
+# If parse succeeds then ${OUPUT_PREFIX}_FOUND is TRUE.
+MACRO(jsoncpp_parse_version VERSION_TEXT OUPUT_PREFIX)
+    SET(VERSION_REGEX "[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9_]+)?")
+    IF( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        STRING(REGEX MATCHALL "[0-9]+|-([A-Za-z0-9_]+)" VERSION_PARTS ${VERSION_TEXT})
+        LIST(GET VERSION_PARTS 0 ${OUPUT_PREFIX}_MAJOR)
+        LIST(GET VERSION_PARTS 1 ${OUPUT_PREFIX}_MINOR)
+        LIST(GET VERSION_PARTS 2 ${OUPUT_PREFIX}_PATCH)
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" TRUE )
+    ELSE( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" FALSE )
+    ENDIF( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+ENDMACRO(jsoncpp_parse_version)
+
+# Read out version from "version" file
+FILE(STRINGS "version" JSONCPP_VERSION)
+
+jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
+IF(NOT JSONCPP_VERSION_FOUND)
+    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
+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" )
+
+macro(UseCompilationWarningAsError)
+	if ( MSVC )
+        # Only enabled in debug because some old versions of VS STL generate
+        # warnings when compiled in release configuration.
+		set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /WX ")
+	endif( MSVC )
+endmacro()
+
+# Include our configuration header
+INCLUDE_DIRECTORIES( ${jsoncpp_SOURCE_DIR}/include )
+
+if ( MSVC )
+    # Only enabled in debug because some old versions of VS STL generate
+    # unreachable code warning when compiled in release configuration.
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /W4 ")
+endif( MSVC )
+
+IF(JSONCPP_WITH_WARNING_AS_ERROR)
+    UseCompilationWarningAsError()
+ENDIF(JSONCPP_WITH_WARNING_AS_ERROR)
+
+IF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
+	CONFIGURE_FILE(
+		"pkg-config/jsoncpp.pc.in"
+		"pkg-config/jsoncpp.pc"
+		@ONLY)
+	INSTALL(FILES "${CMAKE_BINARY_DIR}/pkg-config/jsoncpp.pc"
+		DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig")
+ENDIF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
+
+IF(JSONCPP_WITH_CMAKE_PACKAGE)
+        INSTALL(EXPORT jsoncpp
+                DESTINATION ${PACKAGE_INSTALL_DIR}/jsoncpp
+                FILE        jsoncppConfig.cmake)
+ENDIF(JSONCPP_WITH_CMAKE_PACKAGE)
+
+# Build the different applications
+ADD_SUBDIRECTORY( src )
+
+#install the includes
+ADD_SUBDIRECTORY( include )

NEWS.txt

@@ -1,3 +1,69 @@
+New in SVN
+----------
+
+ *  Updated the type system's behavior, in order to better support backwards
+    compatibility with code that was written before 64-bit integer support was
+    introduced. Here's how it works now:
+
+     *  isInt, isInt64, isUInt, and isUInt64 return true if and only if the
+        value can be exactly represented as that type. In particular, a value
+        constructed with a double like 17.0 will now return true for all of
+        these methods.
+
+     *  isDouble and isFloat now return true for all numeric values, since all
+        numeric values can be converted to a double or float without
+        truncation. Note however that the conversion may not be exact -- for
+        example, doubles cannot exactly represent all integers above 2^53 + 1.
+
+     *  isBool, isNull, isString, isArray, and isObject now return true if and
+        only if the value is of that type.
+
+     *  isConvertibleTo(fooValue) indicates that it is safe to call asFoo.
+        (For each type foo, isFoo always implies isConvertibleTo(fooValue).)
+        asFoo returns an approximate or exact representation as appropriate.
+        For example, a double value may be truncated when asInt is called.
+
+     *  For backwards compatibility with old code, isConvertibleTo(intValue)
+        may return false even if type() == intValue. This is because the value
+        may have been constructed with a 64-bit integer larger than maxInt,
+        and calling asInt() would cause an exception. If you're writing new
+        code, use isInt64 to find out whether the value is exactly
+        representable using an Int64, or asDouble() combined with minInt64 and
+        maxInt64 to figure out whether it is approximately representable.
+
+* Value
+  - Patch #10: BOOST_FOREACH compatibility. Made Json::iterator more 
+    standard compliant, added missing iterator_category and value_type 
+	typedefs (contribued by Robert A. Iannucci).
+		
+* Compilation
+
+  - New CMake based build system. Based in part on contribution from
+    Igor Okulist and Damien Buhl (Patch #14).
+    
+  - New header json/version.h now contains version number macros
+    (JSONCPP_VERSION_MAJOR, JSONCPP_VERSION_MINOR, JSONCPP_VERSION_PATCH
+    and JSONCPP_VERSION_HEXA).
+
+  - Patch #11: added missing JSON_API on some classes causing link issues
+    when building as a dynamic library on Windows 
+	(contributed by Francis Bolduc).
+    
+  - Visual Studio DLL: suppressed warning "C4251: <data member>: <type> 
+    needs to have dll-interface to be used by..." via pragma push/pop
+    in json-cpp headers.
+    
+  - Added Travis CI intregration: https://travis-ci.org/blep/jsoncpp-mirror
+		
+* Bug fixes
+  - Patch #15: Copy constructor does not initialize allocated_ for stringValue
+    (contributed by rmongia).
+
+  - Patch #16: Missing field copy in Json::Value::iterator causing infinite 
+    loop when using experimental internal map (#define JSON_VALUE_USE_INTERNAL_MAP)
+	(contributed by Ming-Lin Kao).
+		
+
   New in JsonCpp 0.6.0:
   ---------------------
 
@@ -88,11 +154,19 @@
     length of 32 characters.
 	
   - Fixed Value::operator <= implementation (had the semantic of operator >=).
-    Found when addigin unit tests for comparison operators.
+    Found when adding unit tests for comparison operators.
     
   - Value::compare() is now const and has an actual implementation with
     unit tests.
 
+  - Bug #2407932: strpbrk() can fail for NULL pointer.
+
+  - Bug #3306345: Fixed minor typo in Path::resolve().
+
+  - Bug #3314841/#3306896: errors in amalgamate.py
+
+  - Fixed some Coverity warnings and line-endings.
+    
 * License
   
   - See file LICENSE for details. Basically JsonCpp is now licensed under 

README.md

@@ -0,0 +1,224 @@
+Introduction
+------------
+
+[JSON][json-org] is a lightweight data-interchange format. It can represent
+numbers, strings, ordered sequences of values, and collections of name/value
+pairs.
+
+[json-org]: http://json.org/
+
+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.
+
+## A note on backward-compatibility
+Very soon, we are switching to C++11 only. For older compilers, try the `pre-C++11` branch.
+
+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
+"Generating amalgamated source and header" for instructions.
+  
+The `include/` should be added to your compiler include path. Jsoncpp headers
+should be included as follow:
+
+    #include <json/json.h>
+
+If JsonCpp was build as a dynamic library on Windows, then your project needs to
+define the macro `JSON_DLL`.
+
+
+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:
+
+    sudo apt-get install cmake
+
+[CMake]: http://www.cmake.org
+
+Note that Python is also required to run the JSON reader/writer tests. If
+missing, the build will skip running those tests.
+
+When running CMake, a few parameters are required:
+
+* a build directory where the makefiles/solution are generated. It is also used
+  to store objects, libraries and executables files.
+* the generator to use: makefiles or Visual Studio solution? What version or
+  Visual Studio, 32 or 64 bits solution? 
+
+Steps for generating solution/makefiles using `cmake-gui`:
+
+* Make "source code" point to the source directory.
+* Make "where to build the binary" point to the directory to use for the build.
+* Click on the "Grouped" check box.
+* Review JsonCpp build options (tick `JSONCPP_LIB_BUILD_SHARED` to build as a
+  dynamic library).
+* Click the configure button at the bottom, then the generate button.
+* The generated solution/makefiles can be found in the binary directory.
+
+Alternatively, from the command-line on Unix in the source directory:
+
+    mkdir -p build/debug
+    cd build/debug
+    cmake -DCMAKE_BUILD_TYPE=debug -DJSONCPP_LIB_BUILD_SHARED=OFF -G "Unix Makefiles" ../..
+    make
+
+Running `cmake -`" will display the list of available generators (passed using
+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.
+
+JsonCpp can use [Scons][] as a build system. Note that SCons requires Python to
+be installed.
+
+[SCons]: http://www.scons.org/
+
+Invoke SCons as follows:
+
+    scons platform=$PLATFORM [TARGET]
+
+where `$PLATFORM` may be one of:
+
+* `suncc`: Sun C++ (Solaris)
+* `vacpp`: Visual Age C++ (AIX)
+* `mingw`
+* `msvc6`: Microsoft Visual Studio 6 service pack 5-6
+* `msvc70`: Microsoft Visual Studio 2002
+* `msvc71`: Microsoft Visual Studio 2003
+* `msvc80`: Microsoft Visual Studio 2005
+* `msvc90`: Microsoft Visual Studio 2008
+* `linux-gcc`: Gnu C++ (linux, also reported to work for Mac OS X)
+
+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
+--------------------------
+
+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
+`jsontest` executable that was compiled on your platform.
+
+    cd test
+    # This will run the Reader/Writer tests
+    python runjsontests.py path/to/jsontest
+    
+    # This will run the Reader/Writer tests, using JSONChecker test suite
+    # (http://www.json.org/JSON_checker/).
+    # Notes: not all tests pass: JsonCpp is too lenient (for example,
+    # it allows an integer to start with '0'). The goal is to improve
+    # strict mode parsing to get all tests to pass.
+    python runjsontests.py --with-json-checker path/to/jsontest
+    
+    # This will run the unit tests (mostly Value)
+    python rununittests.py path/to/test_lib_json
+    
+    # You can run the tests using valgrind:
+    python rununittests.py --valgrind path/to/test_lib_json
+
+
+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
+top-directory (this requires Python 2.6):
+
+    python amalgamate.py
+
+It is possible to specify header name. See the `-h` option for detail.
+
+By default, the following files are generated:
+* `dist/jsoncpp.cpp`: source file that needs to be added to your project.
+* `dist/json/json.h`: corresponding header file for use in your project. It is
+  equivalent to including `json/json.h` in non-amalgamated source. This header
+  only depends on standard headers.
+* `dist/json/json-forwards.h`: header that provides forward declaration of all
+  JsonCpp types.
+
+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.
+* a `TESTNAME.expected` file, that contains a flatened representation of the
+  input document.
+
+The `TESTNAME.expected` file format is as follows:
+
+* each line represents a JSON element of the element tree represented by the
+  input document.
+* each line has two parts: the path to access the element separated from the
+  element value by `=`. Array and object values are always empty (i.e.
+  represented by either `[]` or `{}`).
+* element path: `.` represents the root element, and is used to separate object
+  members. `[N]` is used to specify the value of an array element at index `N`.
+
+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:
+
+* `test_complex_01.json`: input JSON document.
+* `test_complex_01.expected`: flattened JSON element tree used to check if
+  parsing was corrected.
+* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest`
+  from reading `test_complex_01.json`.
+* `test_complex_01.rewrite`: JSON document written by `jsontest` using the
+  `Json::Value` parsed from `test_complex_01.json` and serialized using
+  `Json::StyledWritter`.
+* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by
+  `jsontest` from reading `test_complex_01.rewrite`.
+* `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.
+

README.txt

@@ -1,172 +0,0 @@
-* Introduction:
-  =============
-
-JSON (JavaScript Object Notation) is a lightweight data-interchange format. 
-It can represent integer, real number, string, an ordered sequence of 
-value, and a collection of name/value pairs.
-
-JsonCpp (http://jsoncpp.sourceforge.net/) is a simple API to manipulate 
-JSON value, handle serialization and unserialization to string.
-
-It can also preserve existing comment in unserialization/serialization steps,
-making it a convenient format to store user input files.
-
-Unserialization parsing is user friendly and provides precise error reports.
-
-
-* Building/Testing:
-  =================
-
-JsonCpp uses Scons (http://www.scons.org) as a build system. Scons requires
-python to be installed (http://www.python.org).
-
-You download scons-local distribution from the following url:
-http://sourceforge.net/projects/scons/files/scons-local/1.2.0/
-
-Unzip it in the directory where you found this README file. scons.py Should be 
-at the same level as README.
-
-python scons.py platform=PLTFRM [TARGET]
-where PLTFRM may be one of:
-	suncc Sun C++ (Solaris)
-	vacpp Visual Age C++ (AIX)
-	mingw 
-	msvc6 Microsoft Visual Studio 6 service pack 5-6
-	msvc70 Microsoft Visual Studio 2002
-	msvc71 Microsoft Visual Studio 2003
-	msvc80 Microsoft Visual Studio 2005
-	msvc90 Microsoft Visual Studio 2008
-	linux-gcc Gnu C++ (linux, also reported to work for Mac OS X)
-
-Notes: if you are building with Microsoft Visual Studio 2008, you need to 
-setup the environment by running vcvars32.bat (e.g. MSVC 2008 command prompt)
-before running scons.
-	
-Adding platform is fairly simple. You need to change the Sconstruct file 
-to do so.
-	
-and TARGET may be:
-	check: build library and run unit tests.
-
-    
-* Running the test manually:
-  ==========================
-
-Notes that test can be run by scons using the 'check' target (see above).
-
-You need to run test manually only if you are troubleshooting an issue.
-
-In the instruction below, replace "path to jsontest.exe" with the path
-of the 'jsontest' executable that was compiled on your platform.
-  
-cd test
-# This will run the Reader/Writer tests
-python runjsontests.py "path to jsontest.exe"
-
-# This will run the Reader/Writer tests, using JSONChecker test suite
-# (http://www.json.org/JSON_checker/).
-# Notes: not all tests pass: JsonCpp is too lenient (for example,
-# it allows an integer to start with '0'). The goal is to improve
-# strict mode parsing to get all tests to pass.
-python runjsontests.py --with-json-checker "path to jsontest.exe"
-
-# This will run the unit tests (mostly Value)
-python rununittests.py "path to test_lib_json.exe"
-
-You can run the tests using valgrind:
-python rununittests.py --valgrind "path to test_lib_json.exe"
-
-
-* Building the documentation:
-  ===========================
-
-Run the python script doxybuild.py from the top directory:
-
-python doxybuild.py --open --with-dot
-
-See doxybuild.py --help for options. 
-
-Notes that the documentation is also available for download as a tarball. 
-The documentation of the latest release is available online at:
-http://jsoncpp.sourceforge.net/
-
-* Generating amalgamated source and header
-  ========================================
-
-JsonCpp is provided with a script to generate a single header and a single
-source file to ease inclusion in an existing project.
-
-The amalgamated source can be generated at any time by running the following
-command from the top-directory (requires python 2.6):
-
-python amalgamate.py
-
-It is possible to specify header name. See -h options for detail. By default,
-the following files are generated:
-- dist/jsoncpp.cpp: source file that need to be added to your project
-- dist/json/json.h: header file corresponding to use in your project. It is
-equivalent to including json/json.h in non-amalgamated source. This header
-only depends on standard headers. 
-- dist/json/json-forwards.h: header the provides forward declaration
-of all JsonCpp types. This typically what should be included in headers to
-speed-up compilation.
-
-The amalgamated sources are generated by concatenating JsonCpp source in the
-correct order and defining macro JSON_IS_AMALGAMATION to prevent inclusion
-of other headers.
-
-* Using json-cpp in your project:
-  ===============================
-
-include/ should be added to your compiler include path. jsoncpp headers 
-should be included as follow:
-
-#include <json/json.h>
-  
-
-* 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.
-- a TESTNAME.expected file, that contains a flatened representation of 
-  the input document.
-  
-TESTNAME.expected file format:
-- each line represents a JSON element of the element tree represented 
-  by the input document.
-- each line has two parts: the path to access the element separated from
-  the element value by '='. Array and object values are always empty 
-  (e.g. represented by either [] or {}).
-- element path: '.' represented the root element, and is used to separate 
-  object members. [N] is used to specify the value of an array element
-  at index N.
-See test_complex_01.json and test_complex_01.expected to better understand
-element path.
-
-
-* Understanding reader/writer test output:
-  ========================================
-
-When a test is run, output files are generated aside the input test files. 
-Below is a short description of the content of each file:
-
-- test_complex_01.json: input JSON document
-- test_complex_01.expected: flattened JSON element tree used to check if 
-    parsing was corrected.
-
-- test_complex_01.actual: flattened JSON element tree produced by 
-    jsontest.exe from reading test_complex_01.json
-- test_complex_01.rewrite: JSON document written by jsontest.exe using the
-    Json::Value parsed from test_complex_01.json and serialized using
-    Json::StyledWritter.
-- test_complex_01.actual-rewrite: flattened JSON element tree produced by 
-    jsontest.exe from reading test_complex_01.rewrite.
-test_complex_01.process-output: jsontest.exe output, typically useful to
-    understand parsing error.
-
-* License
-  =======
-  
-See file LICENSE for details. Basically JsonCpp is licensed under 
-MIT license, or public domain if desired and recognized in your jurisdiction.

SConstruct

@@ -119,7 +119,7 @@ elif platform == 'mingw':
     env.Append( CPPDEFINES=[ "WIN32", "NDEBUG", "_MT" ] )
 elif platform.startswith('linux-gcc'):
     env.Tool( 'default' )
-    env.Append( LIBS = ['pthread'], CCFLAGS = "-Wall" )
+    env.Append( LIBS = ['pthread'], CCFLAGS = os.environ.get("CXXFLAGS", "-Wall"), LINKFLAGS=os.environ.get("LDFLAGS", "") )
     env['SHARED_LIB_ENABLED'] = True
 else:
     print "UNSUPPORTED PLATFORM."

amalgamate.py

@@ -15,36 +15,36 @@ class AmalgamationFile:
         self.blocks = []
 
     def add_text( self, text ):
-        if not text.endswith( '\n' ):
-            text += '\n'
+        if not text.endswith( "\n" ):
+            text += "\n"
         self.blocks.append( text )
 
     def add_file( self, relative_input_path, wrap_in_comment=False ):
         def add_marker( prefix ):
-            self.add_text( '' )
-            self.add_text( '// ' + '/'*70 )
-            self.add_text( '// %s of content of file: %s' % (prefix, relative_input_path.replace('\\','/')) )
-            self.add_text( '// ' + '/'*70 )
-            self.add_text( '' )
-        add_marker( 'Beginning' )
-        f = open( os.path.join( self.top_dir, relative_input_path ), 'rt' )
+            self.add_text( "" )
+            self.add_text( "// " + "/"*70 )
+            self.add_text( "// %s of content of file: %s" % (prefix, relative_input_path.replace("\\","/")) )
+            self.add_text( "// " + "/"*70 )
+            self.add_text( "" )
+        add_marker( "Beginning" )
+        f = open( os.path.join( self.top_dir, relative_input_path ), "rt" )
         content = f.read()
         if wrap_in_comment:
-            content = '/*\n' + content + '\n*/'
+            content = "/*\n" + content + "\n*/"
         self.add_text( content )
         f.close()
-        add_marker( 'End' )
-        self.add_text( '\n\n\n\n' )
+        add_marker( "End" )
+        self.add_text( "\n\n\n\n" )
 
     def get_value( self ):
-        return ''.join( self.blocks ).replace('\r\n','\n')
+        return "".join( self.blocks ).replace("\r\n","\n")
 
     def write_to( self, output_path ):
         output_dir = os.path.dirname( output_path )
         if output_dir and not os.path.isdir( output_dir ):
             os.makedirs( output_dir )
-        f = open( output_path, 'wb' )
-        f.write( self.get_value() )
+        f = open( output_path, "wb" )
+        f.write( str.encode(self.get_value(), 'UTF-8') )
         f.close()
 
 def amalgamate_source( source_top_dir=None,
@@ -56,66 +56,69 @@ def amalgamate_source( source_top_dir=None,
            target_source_path: output .cpp path
            header_include_path: generated header path relative to target_source_path.
     """
-    print 'Amalgating header...'
+    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_file( 'LICENSE', wrap_in_comment=True )
-    header.add_text( '#ifndef JSON_AMALGATED_H_INCLUDED' )
-    header.add_text( '# define JSON_AMALGATED_H_INCLUDED' )
-    header.add_text( '/// If defined, indicates that the source file is amalgated' )
-    header.add_text( '/// to prevent private header inclusion.' )
-    header.add_text( '#define JSON_IS_AMALGATED' )
-    header.add_file( 'include/json/config.h' )
-    header.add_file( 'include/json/forwards.h' )
-    header.add_file( 'include/json/features.h' )
-    header.add_file( 'include/json/value.h' )
-    header.add_file( 'include/json/reader.h' )
-    header.add_file( 'include/json/writer.h' )
-    header.add_text( '#endif //ifndef JSON_AMALGATED_H_INCLUDED' )
+    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_file( "LICENSE", wrap_in_comment=True )
+    header.add_text( "#ifndef JSON_AMALGATED_H_INCLUDED" )
+    header.add_text( "# define JSON_AMALGATED_H_INCLUDED" )
+    header.add_text( "/// If defined, indicates that the source file is amalgated" )
+    header.add_text( "/// to prevent private header inclusion." )
+    header.add_text( "#define JSON_IS_AMALGAMATION" )
+    header.add_file( "include/json/version.h" )
+    header.add_file( "include/json/config.h" )
+    header.add_file( "include/json/forwards.h" )
+    header.add_file( "include/json/features.h" )
+    header.add_file( "include/json/value.h" )
+    header.add_file( "include/json/reader.h" )
+    header.add_file( "include/json/writer.h" )
+    header.add_file( "include/json/assertions.h" )
+    header.add_text( "#endif //ifndef JSON_AMALGATED_H_INCLUDED" )
 
     target_header_path = os.path.join( os.path.dirname(target_source_path), header_include_path )
-    print 'Writing amalgated header to %r' % target_header_path
+    print ("Writing amalgated header to %r" % target_header_path)
     header.write_to( target_header_path )
 
     base, ext = os.path.splitext( header_include_path )
-    forward_header_include_path = base + '-forwards' + ext
-    print 'Amalgating forward header...'
+    forward_header_include_path = base + "-forwards" + ext
+    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( '/// 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' )
-    header.add_text( '# define JSON_FORWARD_AMALGATED_H_INCLUDED' )
-    header.add_text( '/// If defined, indicates that the source file is amalgated' )
-    header.add_text( '/// to prevent private header inclusion.' )
-    header.add_text( '#define JSON_IS_AMALGATED' )
-    header.add_file( 'include/json/config.h' )
-    header.add_file( 'include/json/forwards.h' )
-    header.add_text( '#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED' )
+    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( "/// 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" )
+    header.add_text( "# define JSON_FORWARD_AMALGATED_H_INCLUDED" )
+    header.add_text( "/// If defined, indicates that the source file is amalgated" )
+    header.add_text( "/// to prevent private header inclusion." )
+    header.add_text( "#define JSON_IS_AMALGAMATION" )
+    header.add_file( "include/json/config.h" )
+    header.add_file( "include/json/forwards.h" )
+    header.add_text( "#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED" )
 
     target_forward_header_path = os.path.join( os.path.dirname(target_source_path),
                                                forward_header_include_path )
-    print 'Writing amalgated forward header to %r' % target_forward_header_path
+    print ("Writing amalgated forward header to %r" % target_forward_header_path)
     header.write_to( target_forward_header_path )
 
-    print 'Amalgating source...'
+    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_file( 'LICENSE', wrap_in_comment=True )
-    source.add_text( '' )
-    source.add_text( '#include <%s>' % header_include_path )
-    source.add_text( '' )
-    source.add_file( 'src/lib_json\json_tool.h' )
-    source.add_file( 'src/lib_json\json_reader.cpp' )
-    source.add_file( 'src/lib_json\json_batchallocator.h' )
-    source.add_file( 'src/lib_json\json_valueiterator.inl' )
-    source.add_file( 'src/lib_json\json_value.cpp' )
-    source.add_file( 'src/lib_json\json_writer.cpp' )
+    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_file( "LICENSE", wrap_in_comment=True )
+    source.add_text( "" )
+    source.add_text( "#include <%s>" % header_include_path )
+    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") )
 
-    print 'Writing amalgated source to %r' % target_source_path
+    print ("Writing amalgated source to %r" % target_source_path)
     source.write_to( target_source_path )
 
 def main():
@@ -125,11 +128,11 @@ Generate a single amalgated source and header file from the sources.
     from optparse import OptionParser
     parser = OptionParser(usage=usage)
     parser.allow_interspersed_args = False
-    parser.add_option('-s', '--source', dest="target_source_path", action='store', default='dist/jsoncpp.cpp',
+    parser.add_option("-s", "--source", dest="target_source_path", action="store", default="dist/jsoncpp.cpp",
         help="""Output .cpp source path. [Default: %default]""")
-    parser.add_option('-i', '--include', dest="header_include_path", action='store', default='json/json.h',
+    parser.add_option("-i", "--include", dest="header_include_path", action="store", default="json/json.h",
         help="""Header include path. Used to include the header from the amalgated source file. [Default: %default]""")
-    parser.add_option('-t', '--top-dir', dest="top_dir", action='store', default=os.getcwd(),
+    parser.add_option("-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(),
         help="""Source top-directory. [Default: %default]""")
     parser.enable_interspersed_args()
     options, args = parser.parse_args()
@@ -138,10 +141,10 @@ Generate a single amalgated source and header file from the sources.
                              target_source_path=options.target_source_path,
                              header_include_path=options.header_include_path )
     if msg:
-        sys.stderr.write( msg + '\n' )
+        sys.stderr.write( msg + "\n" )
         sys.exit( 1 )
     else:
-        print 'Source succesfully amalagated'
+        print ("Source succesfully amalagated")
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

dev.makefile

@@ -0,0 +1,14 @@
+all: build test-amalgamate
+
+build:
+	mkdir -p build/debug
+	cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DJSONCPP_LIB_BUILD_SHARED=ON -G "Unix Makefiles" ../..
+	make -C build/debug
+
+# Currently, this depends on include/json/version.h generated
+# by cmake.
+test-amalgamate: build
+	python2.7 amalgamate.py
+	python3.4 amalgamate.py
+
+.PHONY: build

devtools/agent_vmw7.json

@@ -0,0 +1,33 @@
+{
+    "cmake_variants" : [
+        {"name": "generator",
+         "generators": [
+            {"generator": [
+                "Visual Studio 7 .NET 2003",
+                "Visual Studio 9 2008",
+                "Visual Studio 9 2008 Win64",
+                "Visual Studio 10",
+                "Visual Studio 10 Win64",
+                "Visual Studio 11",
+                "Visual Studio 11 Win64"
+                ] 
+            },
+            {"generator": ["MinGW Makefiles"], 
+             "env_prepend": [{"path": "c:/wut/prg/MinGW/bin"}]
+            }
+         ] 
+        },
+        {"name": "shared_dll",
+         "variables": [
+            ["JSONCPP_LIB_BUILD_SHARED=true"],
+            ["JSONCPP_LIB_BUILD_SHARED=false"]
+          ]
+        },
+        {"name": "build_type",
+         "build_types": [
+            "debug", 
+            "release" 
+            ]
+        }
+    ]
+}

devtools/agent_vmxp.json

@@ -0,0 +1,26 @@
+{
+    "cmake_variants" : [
+        {"name": "generator",
+         "generators": [
+            {"generator": [
+                "Visual Studio 6",
+                "Visual Studio 7",
+                "Visual Studio 8 2005"
+                ] 
+            }
+         ] 
+        },
+        {"name": "shared_dll",
+         "variables": [
+            ["JSONCPP_LIB_BUILD_SHARED=true"],
+            ["JSONCPP_LIB_BUILD_SHARED=false"]
+          ]
+        },
+        {"name": "build_type",
+         "build_types": [
+            "debug", 
+            "release" 
+            ]
+        }
+    ]
+}

devtools/batchbuild.py

@@ -0,0 +1,280 @@
+import collections
+import itertools
+import json
+import os
+import os.path
+import re
+import shutil
+import string
+import subprocess
+import sys
+import cgi
+
+class BuildDesc:
+    def __init__(self, prepend_envs=None, variables=None, build_type=None, generator=None):
+        self.prepend_envs = prepend_envs or [] # [ { "var": "value" } ]
+        self.variables = variables or []
+        self.build_type = build_type
+        self.generator = generator
+
+    def merged_with( self, build_desc ):
+        """Returns a new BuildDesc by merging field content.
+           Prefer build_desc fields to self fields for single valued field.
+        """
+        return BuildDesc( self.prepend_envs + build_desc.prepend_envs,
+                          self.variables + build_desc.variables,
+                          build_desc.build_type or self.build_type,
+                          build_desc.generator or self.generator )
+
+    def env( self ):
+        environ = os.environ.copy()
+        for values_by_name in self.prepend_envs:
+            for var, value in values_by_name.items():
+                var = var.upper()
+                if type(value) is unicode:
+                    value = value.encode( sys.getdefaultencoding() )
+                if var in environ:
+                    environ[var] = value + os.pathsep + environ[var]
+                else:
+                    environ[var] = value
+        return environ
+
+    def cmake_args( self ):
+        args = ["-D%s" % var for var in self.variables]
+        # skip build type for Visual Studio solution as it cause warning
+        if self.build_type and 'Visual' not in self.generator:
+            args.append( "-DCMAKE_BUILD_TYPE=%s" % self.build_type )
+        if self.generator:
+            args.extend( ['-G', self.generator] )
+        return args
+
+    def __repr__( self ):
+        return "BuildDesc( %s, build_type=%s )" %  (" ".join( self.cmake_args()), self.build_type)
+
+class BuildData:
+    def __init__( self, desc, work_dir, source_dir ):
+        self.desc = desc
+        self.work_dir = work_dir
+        self.source_dir = source_dir
+        self.cmake_log_path = os.path.join( work_dir, 'batchbuild_cmake.log' )
+        self.build_log_path = os.path.join( work_dir, 'batchbuild_build.log' )
+        self.cmake_succeeded = False
+        self.build_succeeded = False
+
+    def execute_build(self):
+        print 'Build %s' % self.desc
+        self._make_new_work_dir( )
+        self.cmake_succeeded = self._generate_makefiles( )
+        if self.cmake_succeeded:
+            self.build_succeeded = self._build_using_makefiles( )
+        return self.build_succeeded
+
+    def _generate_makefiles(self):
+        print '  Generating makefiles: ',
+        cmd = ['cmake'] + self.desc.cmake_args( ) + [os.path.abspath( self.source_dir )]
+        succeeded = self._execute_build_subprocess( cmd, self.desc.env(), self.cmake_log_path )
+        print 'done' if succeeded else 'FAILED'
+        return succeeded
+
+    def _build_using_makefiles(self):
+        print '  Building:',
+        cmd = ['cmake', '--build', self.work_dir]
+        if self.desc.build_type:
+            cmd += ['--config', self.desc.build_type]
+        succeeded = self._execute_build_subprocess( cmd, self.desc.env(), self.build_log_path )
+        print 'done' if succeeded else 'FAILED'
+        return succeeded
+
+    def _execute_build_subprocess(self, cmd, env, log_path):
+        process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.work_dir,
+                                    env=env )
+        stdout, _ = process.communicate( )
+        succeeded = (process.returncode == 0)
+        with open( log_path, 'wb' ) as flog:
+            log = ' '.join( cmd ) + '\n' + stdout + '\nExit code: %r\n' % process.returncode
+            flog.write( fix_eol( log ) )
+        return succeeded
+
+    def _make_new_work_dir(self):
+        if os.path.isdir( self.work_dir ):
+            print '  Removing work directory', self.work_dir
+            shutil.rmtree( self.work_dir, ignore_errors=True )
+        if not os.path.isdir( self.work_dir ):
+            os.makedirs( self.work_dir )
+
+def fix_eol( stdout ):
+    """Fixes wrong EOL produced by cmake --build on Windows (\r\r\n instead of \r\n).
+    """
+    return re.sub( '\r*\n', os.linesep, stdout )
+
+def load_build_variants_from_config( config_path ):
+    with open( config_path, 'rb' ) as fconfig:
+        data = json.load( fconfig )
+    variants = data[ 'cmake_variants' ]
+    build_descs_by_axis = collections.defaultdict( list )
+    for axis in variants:
+        axis_name = axis["name"]
+        build_descs = []
+        if "generators" in axis:
+            for generator_data in axis["generators"]:
+                for generator in generator_data["generator"]:
+                    build_desc = BuildDesc( generator=generator,
+                                            prepend_envs=generator_data.get("env_prepend") )
+                    build_descs.append( build_desc )
+        elif "variables" in axis:
+            for variables in axis["variables"]:
+                build_desc = BuildDesc( variables=variables )
+                build_descs.append( build_desc )
+        elif "build_types" in axis:
+            for build_type in axis["build_types"]:
+                build_desc = BuildDesc( build_type=build_type )
+                build_descs.append( build_desc )
+        build_descs_by_axis[axis_name].extend( build_descs )
+    return build_descs_by_axis
+
+def generate_build_variants( build_descs_by_axis ):
+    """Returns a list of BuildDesc generated for the partial BuildDesc for each axis."""
+    axis_names = build_descs_by_axis.keys()
+    build_descs = []
+    for axis_name, axis_build_descs in build_descs_by_axis.items():
+        if len(build_descs):
+            # for each existing build_desc and each axis build desc, create a new build_desc
+            new_build_descs = []
+            for prototype_build_desc, axis_build_desc in itertools.product( build_descs, axis_build_descs):
+                new_build_descs.append( prototype_build_desc.merged_with( axis_build_desc ) )
+            build_descs = new_build_descs
+        else:
+            build_descs = axis_build_descs
+    return build_descs
+
+HTML_TEMPLATE = string.Template('''<html>
+<head>
+    <title>$title</title>
+    <style type="text/css">
+    td.failed {background-color:#f08080;}
+    td.ok {background-color:#c0eec0;}
+    </style>
+</head>
+<body>
+<table border="1">
+<thead>
+    <tr>
+        <th>Variables</th>
+        $th_vars
+    </tr>
+    <tr>
+        <th>Build type</th>
+        $th_build_types
+    </tr>
+</thead>
+<tbody>
+$tr_builds
+</tbody>
+</table>
+</body></html>''')
+
+def generate_html_report( html_report_path, builds ):
+    report_dir = os.path.dirname( html_report_path )
+    # Vertical axis: generator
+    # Horizontal: variables, then build_type
+    builds_by_generator = collections.defaultdict( list )
+    variables = set()
+    build_types_by_variable = collections.defaultdict( set )
+    build_by_pos_key = {} # { (generator, var_key, build_type): build }
+    for build in builds:
+        builds_by_generator[build.desc.generator].append( build )
+        var_key = tuple(sorted(build.desc.variables))
+        variables.add( var_key )
+        build_types_by_variable[var_key].add( build.desc.build_type )
+        pos_key = (build.desc.generator, var_key, build.desc.build_type)
+        build_by_pos_key[pos_key] = build
+    variables = sorted( variables )
+    th_vars = []
+    th_build_types = []
+    for variable in variables:
+        build_types = sorted( build_types_by_variable[variable] )
+        nb_build_type = len(build_types_by_variable[variable])
+        th_vars.append( '<th colspan="%d">%s</th>' % (nb_build_type, cgi.escape( ' '.join( variable ) ) ) )
+        for build_type in build_types:
+            th_build_types.append( '<th>%s</th>' % cgi.escape(build_type) )
+    tr_builds = []
+    for generator in sorted( builds_by_generator ):
+        tds = [ '<td>%s</td>\n' % cgi.escape( generator ) ]
+        for variable in variables:
+            build_types = sorted( build_types_by_variable[variable] )
+            for build_type in build_types:
+                pos_key = (generator, variable, build_type)
+                build = build_by_pos_key.get(pos_key)
+                if build:
+                    cmake_status = 'ok' if build.cmake_succeeded else 'FAILED'
+                    build_status = 'ok' if build.build_succeeded else 'FAILED'
+                    cmake_log_url = os.path.relpath( build.cmake_log_path, report_dir )
+                    build_log_url = os.path.relpath( build.build_log_path, report_dir )
+                    td = '<td class="%s"><a href="%s" class="%s">CMake: %s</a>' % (
+                        build_status.lower(), cmake_log_url, cmake_status.lower(), cmake_status)
+                    if build.cmake_succeeded:
+                        td += '<br><a href="%s" class="%s">Build: %s</a>' % (
+                            build_log_url, build_status.lower(), build_status)
+                    td += '</td>'
+                else:
+                    td = '<td></td>'
+                tds.append( td )
+        tr_builds.append( '<tr>%s</tr>' % '\n'.join( tds ) )
+    html = HTML_TEMPLATE.substitute(
+        title='Batch build report',
+        th_vars=' '.join(th_vars),
+        th_build_types=' '.join( th_build_types),
+        tr_builds='\n'.join( tr_builds ) )
+    with open( html_report_path, 'wt' ) as fhtml:
+        fhtml.write( html )
+    print 'HTML report generated in:', html_report_path
+
+def main():
+    usage = r"""%prog WORK_DIR SOURCE_DIR CONFIG_JSON_PATH [CONFIG2_JSON_PATH...]
+Build a given CMake based project located in SOURCE_DIR with multiple generators/options.dry_run
+as described in CONFIG_JSON_PATH building in WORK_DIR.
+
+Example of call:
+python devtools\batchbuild.py e:\buildbots\jsoncpp\build . devtools\agent_vmw7.json
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = True
+#    parser.add_option('-v', '--verbose', dest="verbose", action='store_true',
+#        help="""Be verbose.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    if len(args) < 3:
+        parser.error( "Missing one of WORK_DIR SOURCE_DIR CONFIG_JSON_PATH." )
+    work_dir = args[0]
+    source_dir = args[1].rstrip('/\\')
+    config_paths = args[2:]
+    for config_path in config_paths:
+        if not os.path.isfile( config_path ):
+            parser.error( "Can not read: %r" % config_path )
+
+    # generate build variants
+    build_descs = []
+    for config_path in config_paths:
+        build_descs_by_axis = load_build_variants_from_config( config_path )
+        build_descs.extend( generate_build_variants( build_descs_by_axis ) )
+    print 'Build variants (%d):' % len(build_descs)
+    # assign build directory for each variant
+    if not os.path.isdir( work_dir ):
+        os.makedirs( work_dir )
+    builds = []
+    with open( os.path.join( work_dir, 'matrix-dir-map.txt' ), 'wt' ) as fmatrixmap:
+        for index, build_desc in enumerate( build_descs ):
+            build_desc_work_dir = os.path.join( work_dir, '%03d' % (index+1) )
+            builds.append( BuildData( build_desc, build_desc_work_dir, source_dir ) )
+            fmatrixmap.write( '%s: %s\n' % (build_desc_work_dir, build_desc) )
+    for build in builds:
+        build.execute_build()
+    html_report_path = os.path.join( work_dir, 'batchbuild-report.html' )
+    generate_html_report( html_report_path, builds )
+    print 'Done'
+        
+
+if __name__ == '__main__':
+    main()
+

doc/footer.html

@@ -1,23 +1,3 @@
 <hr>
-<table width="100%">
-  <tr>
-    <td width="10%" align="left" valign="center">
-      <a href="http://sourceforge.net"> 
-      <img
-      src="http://sourceforge.net/sflogo.php?group_id=144446"
-      width="88" height="31" border="0" alt="SourceForge Logo"></a>
-    </td>
-    <td width="20%" align="left" valign="center">
-      hosts this site.
-    </td>
-    <td>
-    </td>
-    <td align="right" valign="center">
-      Send comments to:<br>
-      <a href="mailto:jsoncpp-devel@lists.sourceforge.net">Json-cpp Developers</a>
-    </td>
-  </tr>
-</table>
-
 </body> 
 </html>

doc/header.html

@@ -11,12 +11,12 @@ JsonCpp - JSON data format manipulation library
 <table width="100%">
   <tr>
     <td width="40%" align="left" valign="center">
-      <a href="http://sourceforge.net/projects/jsoncpp/">
+      <a href="https://github.com/open-source-parsers/jsoncpp">
       JsonCpp project page
       </a>
     </td>
     <td width="40%" align="right" valign="center">
-      <a href="http://jsoncpp.sourceforge.net">JsonCpp home page</a>
+      <a href="https://github.com/open-source-parsers/jsoncpp">JsonCpp home page</a>
     </td>
   </tr>
 </table>

doc/jsoncpp.dox

@@ -25,10 +25,11 @@ Here is an example of JSON data:
     "indent" : { "length" : 3, "use_space": true }
 }
 \endverbatim
+<code>jsoncpp</code> supports comments as <i>meta-data</i>.
 
 \section _features Features
 - read and write JSON document
-- attach C and C++ style comments to element during parsing
+- attach C++ style comments to element during parsing
 - rewrite JSON document preserving original comments
 
 Notes: Comments used to be supported in JSON but where removed for 
@@ -84,43 +85,35 @@ std::cout << root;
 
 \section _pbuild Build instructions
 The build instructions are located in the file 
-<a HREF="README.txt">README.txt</a> in the top-directory of the project.
+<a HREF="https://github.com/open-source-parsers/jsoncpp/blob/master/README.md">README.md</a> in the top-directory of the project.
 
-Permanent link to the latest revision of the file in subversion: 
-<a HREF="http://jsoncpp.svn.sourceforge.net/viewvc/jsoncpp/trunk/jsoncpp/README.txt?view=markup">latest README.txt</a>
-
-\section _pdownload Download
-The sources can be downloaded from 
-<a HREF="http://sourceforge.net/projects/jsoncpp/files/">SourceForge download page</a>.
-
-The latest version of the source is available in the project's subversion repository: 
-<a HREF="http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/">
-http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/</a>
-
-To checkout the source, see the following 
-<a HREF="http://sourceforge.net/scm/?type=svn&group_id=144446">instructions</a>.
+The latest version of the source is available in the project's GitHub repository:
+<a HREF="https://github.com/open-source-parsers/jsoncpp/">
+jsoncpp</a>
 
 \section _news What's New?
 The description of latest changes can be found in 
-<a HREF="NEWS.txt">NEWS.txt</a> in the top-directory of the project.
-
-Permanent link to the latest revision of the file in subversion: 
-<a HREF="http://svn.sourceforge.net/viewcvs.cgi/jsoncpp/README.txt?view=markup">latest NEWS.txt</a>
-
-\section _plinks Project links
-- <a HREF="http://jsoncpp.sourceforge.net">json-cpp home</a>
-- <a HREF="http://www.sourceforge.net/projects/jsoncpp/">json-cpp sourceforge project</a>
+<a HREF="https://github.com/open-source-parsers/jsoncpp/wiki/NEWS">
+  the NEWS wiki
+</a>.
 
 \section _rlinks Related links
 - <a HREF="http://www.json.org/">JSON</a> Specification and alternate language implementations.
 - <a HREF="http://www.yaml.org/">YAML</a> A data format designed for human readability.
 - <a HREF="http://www.cl.cam.ac.uk/~mgk25/unicode.html">UTF-8 and Unicode FAQ</a>.
 
+\section _plinks Old project links
+- <a href="https://sourceforge.net/projects/jsoncpp/">https://sourceforge.net/projects/jsoncpp/</a>
+- <a href="http://jsoncpp.sourceforge.net">http://jsoncpp.sourceforge.net</a>
+- <a href="http://sourceforge.net/projects/jsoncpp/files/">http://sourceforge.net/projects/jsoncpp/files/</a>
+- <a href="http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/">http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/</a>
+- <a href="http://jsoncpp.sourceforge.net/old.html">http://jsoncpp.sourceforge.net/old.html</a>
+
 \section _license License
-See file <a HREF="LICENSE">LICENSE</a> in the top-directory of the project.
+See file <a href="https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE"><code>LICENSE</code></a> in the top-directory of the project.
 
 Basically JsonCpp is licensed under MIT license, or public domain if desired 
 and recognized in your jurisdiction.
 
-\author Baptiste Lepilleur <blep@users.sourceforge.net>
+\author Baptiste Lepilleur <blep@users.sourceforge.net> (originator)
 */

doc/roadmap.dox

@@ -1,37 +1,3 @@
 /*! \page roadmap JsonCpp roadmap
-  \section ms_release Makes JsonCpp ready for release
-  - Build system clean-up:
-	- Fix build on Windows (shared-library build is broken)
-	- Add enable/disable flag for static and shared library build
-	- Enhance help
-  - Platform portability check: (Notes: was ok on last check)
-	- linux/gcc, 
-	- solaris/cc, 
-	- windows/msvc678, 
-	- aix/vacpp
-  - Add JsonCpp version to header as numeric for use in preprocessor test
-  - Remove buggy experimental hash stuff
-  \section ms_strict Adds a strict mode to reader/parser
-	Strict JSON support as specific in RFC 4627 (http://www.ietf.org/rfc/rfc4627.txt?number=4627).
-	- Enforce only object or array as root element
-	- Disable comment support
-    - Get jsonchecker failing tests to pass in strict mode
-  \section ms_writer Writter control
-    Provides more control to determine how specific items are serialized when JSON allow choice:
-	- Optionally allow escaping of non-ASCII characters using unicode escape sequence "\\u".
-	- Optionally allow escaping of "/" using "\/".
-  \section ms_separation Expose json reader/writer API that do not impose using Json::Value.
-	Some typical use-case involve an application specific structure to/from a JSON document.
-    - Event base parser to allow unserializing a Json document directly in datastructure instead of
-      using the intermediate Json::Value.
-    - Stream based parser to serialized a Json document without using Json::Value as input.
-	- Performance oriented parser/writer:
-		- Provides an event based parser. Should allow pulling & skipping events for ease of use.
-		- Provides a JSON document builder: fast only.
-  \section ms_perfo Performance tuning
-    - Provides support for static property name definition avoiding allocation 
-    - Static property dictionnary can be provided to JSON reader
-    - Performance scenario & benchmarking
-  \section testing Testing
-    - Adds more tests for unicode parsing (e.g. including surrogate and error detection).
+  Moved to: https://github.com/open-source-parsers/jsoncpp/wiki/Roadmap
 */

doxybuild.py

@@ -116,7 +116,7 @@ def build_doc( options,  make_release=False ):
     ok = run_doxygen( options.doxygen_path, 'doc/doxyfile', 'doc', is_silent=options.silent )
     if not options.silent:
         print open(warning_log_path, 'rb').read()
-    index_path = os.path.abspath(os.path.join(subst_keys['%HTML_OUTPUT%'], 'index.html'))
+    index_path = os.path.abspath(os.path.join('doc', subst_keys['%HTML_OUTPUT%'], 'index.html'))
     print 'Generated documentation can be found in:'
     print index_path
     if options.open:

include/CMakeLists.txt

@@ -0,0 +1,2 @@
+FILE(GLOB INCLUDE_FILES "json/*.h")
+INSTALL(FILES ${INCLUDE_FILES} DESTINATION ${INCLUDE_INSTALL_DIR}/json)

include/json/assertions.h

@@ -0,0 +1,41 @@
+// 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 CPPTL_JSON_ASSERTIONS_H_INCLUDED
+#define CPPTL_JSON_ASSERTIONS_H_INCLUDED
+
+#include <stdlib.h>
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+#if JSON_USE_EXCEPTION
+#include <stdexcept>
+#define JSON_ASSERT(condition)                                                 \
+  assert(condition); // @todo <= change this into an exception throw
+#define JSON_FAIL_MESSAGE(message) throw std::runtime_error(message);
+#else // JSON_USE_EXCEPTION
+#define JSON_ASSERT(condition) assert(condition);
+
+// The call to assert() will show the failure message in debug builds. In
+// release bugs we write to invalid memory in order to crash hard, so that a
+// debugger or crash reporter gets the chance to take over. We still call exit()
+// afterward in order to tell the compiler that this macro doesn't return.
+#define JSON_FAIL_MESSAGE(message)                                             \
+  {                                                                            \
+    assert(false&& message);                                                   \
+    strcpy(reinterpret_cast<char*>(666), message);                             \
+    exit(123);                                                                 \
+  }
+
+#endif
+
+#define JSON_ASSERT_MESSAGE(condition, message)                                \
+  if (!(condition)) {                                                          \
+    JSON_FAIL_MESSAGE(message)                                                 \
+  }
+
+#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED

include/json/autolink.h

@@ -12,7 +12,8 @@
 #include <cpptl/cpptl_autolink.h>
 #endif
 
-# if !defined(JSON_NO_AUTOLINK)  &&  !defined(JSON_DLL_BUILD)  &&  !defined(JSON_IN_CPPTL)
+#if !defined(JSON_NO_AUTOLINK) && !defined(JSON_DLL_BUILD) &&                  \
+    !defined(JSON_IN_CPPTL)
 #define CPPTL_AUTOLINK_NAME "json"
 #undef CPPTL_AUTOLINK_DLL
 #ifdef JSON_DLL

include/json/config.h

@@ -11,29 +11,33 @@
 
 /// If defined, indicates that json may leverage CppTL library
 //#  define JSON_USE_CPPTL 1
-/// If defined, indicates that cpptl vector based map should be used instead of std::map
+/// If defined, indicates that cpptl vector based map should be used instead of
+/// 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
+/// 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 defined, indicates that Json use exception to report invalid type manipulation
-/// instead of C assert macro.
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
 #define JSON_USE_EXCEPTION 1
+#endif
 
 /// If defined, indicates that the source file is amalgated
 /// to prevent private header inclusion.
 /// Remarks: it is automatically defined in the generated amalgated header.
 // #define JSON_IS_AMALGAMATION
 
-
 #ifdef JSON_IN_CPPTL
 #include <cpptl/config.h>
 #ifndef JSON_USE_CPPTL
@@ -44,14 +48,22 @@
 #ifdef JSON_IN_CPPTL
 #define JSON_API CPPTL_API
 #elif defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER)
 #define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
 #elif defined(JSON_DLL)
+#if defined(_MSC_VER)
 #define JSON_API __declspec(dllimport)
-# else
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_IN_CPPTL
+#if !defined(JSON_API)
 #define JSON_API
 #endif
 
-// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for integer
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
 // Storages, and 64 bits integer support is disabled.
 // #define JSON_NO_INT64 1
 
@@ -59,6 +71,11 @@
 // Microsoft Visual Studio 6 only support conversion from __int64 to double
 // (no conversion from unsigned __int64).
 #define JSON_USE_INT64_DOUBLE_CONVERSION 1
+// Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255'
+// characters in the debug information)
+// All projects I've ever seen with VS6 were using this globally (not bothering
+// with pragma push/pop).
+#pragma warning(disable : 4786)
 #endif // if defined(_MSC_VER)  &&  _MSC_VER < 1200 // MSVC 6
 
 #if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
@@ -92,5 +109,4 @@ namespace Json {
 #endif // if defined(JSON_NO_INT64)
 } // end namespace Json
 
-
 #endif // JSON_CONFIG_H_INCLUDED

include/json/features.h

@@ -16,17 +16,18 @@ namespace Json {
  * This configuration object can be used to force the Reader or Writer
  * to behave in a standard conforming way.
  */
-   class JSON_API Features
-   {
+class JSON_API Features {
 public:
-      /** \brief A configuration that allows all features and assumes all strings are UTF-8.
+  /** \brief A configuration that allows all features and assumes all strings
+   * are UTF-8.
    * - C & C++ comments are allowed
    * - Root object can be any JSON value
    * - Assumes Value strings are encoded in UTF-8
    */
   static Features all();
 
-      /** \brief A configuration that is strictly compatible with the JSON specification.
+  /** \brief A configuration that is strictly compatible with the JSON
+   * specification.
    * - Comments are forbidden.
    * - Root object must be either an array or an object value.
    * - Assumes Value strings are encoded in UTF-8
@@ -40,8 +41,15 @@ namespace Json {
   /// \c true if comments are allowed. Default: \c true.
   bool allowComments_;
 
-      /// \c true if root must be either an array or an object value. Default: \c false.
+  /// \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

@@ -40,5 +40,4 @@ namespace Json {
 
 } // namespace Json
 
-
 #endif // JSON_FORWARDS_H_INCLUDED

include/json/reader.h

@@ -11,21 +11,40 @@
 #include "value.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <deque>
+#include <iosfwd>
 #include <stack>
 #include <string>
-# include <iostream>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
 namespace Json {
 
-   /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a Value.
+/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
+ *Value.
  *
  */
-   class JSON_API Reader
-   {
+class JSON_API Reader {
 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.
    */
@@ -36,61 +55,106 @@ namespace Json {
    */
   Reader(const Features& features);
 
-      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document.
    * \param document UTF-8 encoded string containing the document to read.
    * \param root [out] Contains the root value of the document if it was
    *             successfully parsed.
-       * \param collectComments \c true to collect comment and allow writing them back during
+   * \param collectComments \c true to collect comment and allow writing them
+   * back during
    *                        serialization, \c false to discard comments.
-       *                        This parameter is ignored if Features::allowComments_
+   *                        This parameter is ignored if
+   * Features::allowComments_
    *                        is \c false.
-       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
    */
-      bool parse( const std::string &document, 
-                  Value &root,
-                  bool collectComments = true );
+  bool
+  parse(const std::string& document, Value& root, bool collectComments = true);
 
-      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
-       * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the document to read.
-       * \param endDoc Pointer on the end of the UTF-8 encoded string of the document to read. 
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   document.
+   * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
+   document to read.
+   * \param endDoc Pointer on the end of the UTF-8 encoded string of the
+   document to read.
    \               Must be >= beginDoc.
    * \param root [out] Contains the root value of the document if it was
    *             successfully parsed.
-       * \param collectComments \c true to collect comment and allow writing them back during
+   * \param collectComments \c true to collect comment and allow writing them
+   back during
    *                        serialization, \c false to discard comments.
-       *                        This parameter is ignored if Features::allowComments_
+   *                        This parameter is ignored if
+   Features::allowComments_
    *                        is \c false.
-       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+   * \return \c true if the document was successfully parsed, \c false if an
+   error occurred.
    */
-      bool parse( const char *beginDoc, const char *endDoc, 
+  bool parse(const char* beginDoc,
+             const char* endDoc,
              Value& root,
              bool collectComments = true);
 
   /// \brief Parse from input stream.
   /// \see Json::operator>>(std::istream&, Json::Value&).
-      bool parse( std::istream &is,
-                  Value &root,
-                  bool collectComments = true );
+  bool parse(std::istream& is, Value& root, bool collectComments = true);
 
-      /** \brief Returns a user friendly string that list errors in the parsed document.
-       * \return Formatted error message with the list of errors with their location in 
-       *         the parsed document. An empty string is returned if no error occurred
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   * \return Formatted error message with the list of errors with their location
+   * in
+   *         the parsed document. An empty string is returned if no error
+   * occurred
    *         during parsing.
    * \deprecated Use getFormattedErrorMessages() instead (typo fix).
    */
   JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead")
   std::string getFormatedErrorMessages() const;
 
-      /** \brief Returns a user friendly string that list errors in the parsed document.
-       * \return Formatted error message with the list of errors with their location in 
-       *         the parsed document. An empty string is returned if no error occurred
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   * \return Formatted error message with the list of errors with their location
+   * in
+   *         the parsed document. An empty string is returned if no error
+   * occurred
    *         during parsing.
    */
   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
-      {
+  enum TokenType {
     tokenEndOfStream = 0,
     tokenObjectBegin,
     tokenObjectEnd,
@@ -107,16 +171,14 @@ namespace Json {
     tokenError
   };
 
-      class Token
-      {
+  class Token {
   public:
     TokenType type_;
     Location start_;
     Location end_;
   };
 
-      class ErrorInfo
-      {
+  class ErrorInfo {
   public:
     Token token_;
     std::string message_;
@@ -128,8 +190,7 @@ namespace Json {
   bool expectToken(TokenType type, Token& token, const char* message);
   bool readToken(Token& token);
   void skipSpaces();
-      bool match( Location pattern, 
-                  int patternLength );
+  bool match(Location pattern, int patternLength);
   bool readComment();
   bool readCStyleComment();
   bool readCppStyleComment();
@@ -139,9 +200,11 @@ namespace Json {
   bool readObject(Token& token);
   bool readArray(Token& token);
   bool decodeNumber(Token& token);
+  bool decodeNumber(Token& token, Value& decoded);
   bool decodeString(Token& token);
   bool decodeString(Token& token, std::string& decoded);
   bool decodeDouble(Token& token);
+  bool decodeDouble(Token& token, Value& decoded);
   bool decodeUnicodeCodePoint(Token& token,
                               Location& current,
                               Location end,
@@ -150,9 +213,7 @@ namespace Json {
                                    Location& current,
                                    Location end,
                                    unsigned int& unicode);
-      bool addError( const std::string &message, 
-                     Token &token,
-                     Location extra = 0 );
+  bool addError(const std::string& message, Token& token, Location extra = 0);
   bool recoverFromError(TokenType skipUntilToken);
   bool addErrorAndRecover(const std::string& message,
                           Token& token,
@@ -160,13 +221,10 @@ namespace Json {
   void skipUntilSpace();
   Value& currentValue();
   Char getNextChar();
-      void getLocationLineAndColumn( Location location,
-                                     int &line,
-                                     int &column ) const;
+  void
+  getLocationLineAndColumn(Location location, int& line, int& column) const;
   std::string getLocationLineAndColumn(Location location) const;
-      void addComment( Location begin, 
-                       Location end, 
-                       CommentPlacement placement );
+  void addComment(Location begin, Location end, CommentPlacement placement);
   void skipCommentTokens(Token& token);
 
   typedef std::stack<Value*> Nodes;
@@ -207,8 +265,12 @@ namespace Json {
  \throw std::exception on parse error.
  \see Json::operator<<()
 */
-   std::istream& operator>>( std::istream&, Value& );
+JSON_API std::istream& operator>>(std::istream&, Value&);
 
 } // namespace Json
 
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
 #endif // CPPTL_JSON_READER_H_INCLUDED

include/json/value.h

@@ -21,14 +21,20 @@
 #include <cpptl/forwards.h>
 #endif
 
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
 /** \brief JSON (JavaScript Object Notation).
  */
 namespace Json {
 
 /** \brief Type of the value held by a Value object.
  */
-   enum ValueType
-   {
+enum ValueType {
   nullValue = 0, ///< 'null' value
   intValue,      ///< signed integer value
   uintValue,     ///< unsigned integer value
@@ -39,11 +45,11 @@ namespace Json {
   objectValue    ///< object value (collection of name/value pairs).
 };
 
-   enum CommentPlacement
-   {
+enum CommentPlacement {
   commentBefore = 0,      ///< a comment placed on the line before a value
   commentAfterOnSameLine, ///< a comment just after a value on the same line
-      commentAfter,             ///< a comment on the line after a value (only make sense for root value)
+  commentAfter, ///< a comment on the line after a value (only make sense for
+  /// root value)
   numberOfCommentPlacement
 };
 
@@ -66,23 +72,13 @@ namespace Json {
  * object[code] = 1234;
  * \endcode
  */
-   class JSON_API StaticString
-   {
+class JSON_API StaticString {
 public:
-      explicit StaticString( const char *czstring )
-         : str_( czstring )
-      {
-      }
+  explicit StaticString(const char* czstring) : str_(czstring) {}
 
-      operator const char *() const
-      {
-         return str_;
-      }
+  operator const char*() const { return str_; }
 
-      const char *c_str() const
-      {
-         return str_;
-      }
+  const char* c_str() const { return str_; }
 
 private:
   const char* str_;
@@ -103,20 +99,21 @@ namespace Json {
  * 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[]() methods. 
+ * values of an #objectValue or #arrayValue can be accessed using operator[]()
+ *methods.
  * 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
  * 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 required element
+ * The get() methods can be used to obtanis default value in the case the
+ *required element
  * does not exist.
  *
  * It is possible to iterate over the list of a #objectValue values using
  * the getMemberNames() method.
  */
-   class JSON_API Value 
-   {
+class JSON_API Value {
   friend class ValueIteratorBase;
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
   friend class ValueInternalLink;
@@ -136,7 +133,7 @@ namespace Json {
   typedef Json::LargestUInt LargestUInt;
   typedef Json::ArrayIndex ArrayIndex;
 
-      static const Value null;
+  static const Value& null;
   /// 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.
@@ -151,21 +148,21 @@ namespace Json {
   /// Maximum unsigned int value that can be stored in a Json::Value.
   static const UInt maxUInt;
 
+#if defined(JSON_HAS_INT64)
   /// Minimum signed 64 bits int value that can be stored in a Json::Value.
   static const Int64 minInt64;
   /// Maximum signed 64 bits int value that can be stored in a Json::Value.
   static const Int64 maxInt64;
   /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
   static const UInt64 maxUInt64;
+#endif // defined(JSON_HAS_INT64)
 
 private:
 #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-      class CZString 
-      {
+  class CZString {
   public:
-         enum DuplicationPolicy 
-         {
+    enum DuplicationPolicy {
       noDuplication = 0,
       duplicate,
       duplicateOnCopy
@@ -180,6 +177,7 @@ namespace Json {
     ArrayIndex index() const;
     const char* c_str() const;
     bool isStaticString() const;
+
   private:
     void swap(CZString& other);
     const char* cstr_;
@@ -265,8 +263,10 @@ namespace Json {
 #endif
   Int asInt() const;
   UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
   Int64 asInt64() const;
   UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
   LargestInt asLargestInt() const;
   LargestUInt asLargestUInt() const;
   float asFloat() const;
@@ -276,7 +276,9 @@ namespace Json {
   bool isNull() const;
   bool isBool() const;
   bool isInt() const;
+  bool isInt64() const;
   bool isUInt() const;
+  bool isUInt64() const;
   bool isIntegral() const;
   bool isDouble() const;
   bool isNumeric() const;
@@ -309,14 +311,16 @@ namespace Json {
   void resize(ArrayIndex size);
 
   /// Access an array element (zero based index ).
-      /// If the array contains less than index element, then null value are inserted
+  /// If the array contains less than index element, then null value are
+  /// inserted
   /// in the array so that its size is index+1.
   /// (You may need to say 'value[0u]' to get your compiler to distinguish
   ///  this from the operator[] which takes a string.)
   Value& operator[](ArrayIndex index);
 
   /// Access an array element (zero based index ).
-      /// If the array contains less than index element, then null value are inserted
+  /// If the array contains less than index element, then null value are
+  /// inserted
   /// in the array so that its size is index+1.
   /// (You may need to say 'value[0u]' to get your compiler to distinguish
   ///  this from the operator[] which takes a string.)
@@ -332,10 +336,10 @@ namespace Json {
   ///  this from the operator[] which takes a string.)
   const Value& operator[](int index) const;
 
-      /// If the array contains at least index+1 elements, returns the element value, 
+  /// If the array contains at least index+1 elements, returns the element
+  /// value,
   /// otherwise returns defaultValue.
-      Value get( ArrayIndex index, 
-                 const Value &defaultValue ) const;
+  Value get(ArrayIndex index, const Value& defaultValue) const;
   /// Return true if index < size().
   bool isValidIndex(ArrayIndex index) const;
   /// \brief Append value to array at the end.
@@ -345,13 +349,16 @@ namespace Json {
 
   /// Access an object value by name, create a null member if it does not exist.
   Value& operator[](const char* key);
-      /// Access an object value by name, returns null if there is no member with that name.
+  /// 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.
   Value& operator[](const std::string& key);
-      /// Access an object value by name, returns null if there is no member with that name.
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
   const Value& operator[](const std::string& key) const;
-      /** \brief Access an object value by name, create a null member if it does not exist.
+  /** \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
    * the new entry is not duplicated.
@@ -366,19 +373,17 @@ namespace Json {
 #ifdef JSON_USE_CPPTL
   /// Access an object value by name, create a null member if it does not exist.
   Value& operator[](const CppTL::ConstString& key);
-      /// Access an object value by name, returns null if there is no member with that name.
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
   const Value& operator[](const CppTL::ConstString& key) const;
 #endif
   /// Return the member named key if it exist, defaultValue otherwise.
-      Value get( const char *key, 
-                 const Value &defaultValue ) const;
+  Value get(const char* key, const Value& defaultValue) const;
   /// Return the member named key if it exist, defaultValue otherwise.
-      Value get( const std::string &key,
-                 const Value &defaultValue ) const;
+  Value get(const std::string& key, const Value& defaultValue) const;
 #ifdef JSON_USE_CPPTL
   /// Return the member named key if it exist, defaultValue otherwise.
-      Value get( const CppTL::ConstString &key,
-                 const Value &defaultValue ) const;
+  Value get(const CppTL::ConstString& key, const Value& defaultValue) const;
 #endif
   /// \brief Remove and return the named member.
   ///
@@ -412,11 +417,9 @@ namespace Json {
   //# endif
 
   /// Comments must be //... or /* ... */
-      void setComment( const char *comment,
-                       CommentPlacement placement );
+  void setComment(const char* comment, CommentPlacement placement);
   /// Comments must be //... or /* ... */
-      void setComment( const std::string &comment,
-                       CommentPlacement placement );
+  void setComment(const std::string& comment, CommentPlacement placement);
   bool hasComment(CommentPlacement placement) const;
   /// Include delimiters and embedded newlines.
   std::string getComment(CommentPlacement placement) const;
@@ -429,35 +432,30 @@ namespace Json {
   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:
-      Value &resolveReference( const char *key, 
-                               bool isStatic );
+  Value& resolveReference(const char* key, bool isStatic);
 
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
-      inline bool isItemAvailable() const
-      {
-         return itemIsUsed_ == 0;
-      }
+  inline bool isItemAvailable() const { return itemIsUsed_ == 0; }
 
-      inline void setItemUsed( bool isUsed = true )
-      {
-         itemIsUsed_ = isUsed ? 1 : 0;
-      }
+  inline void setItemUsed(bool isUsed = true) { itemIsUsed_ = isUsed ? 1 : 0; }
 
-      inline bool isMemberNameStatic() const
-      {
-         return memberNameIsStatic_ == 0;
-      }
+  inline bool isMemberNameStatic() const { return memberNameIsStatic_ == 0; }
 
-      inline void setMemberNameIsStatic( bool isStatic )
-      {
+  inline void setMemberNameIsStatic(bool isStatic) {
     memberNameIsStatic_ = isStatic ? 1 : 0;
   }
 #endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
 
 private:
-      struct CommentInfo
-      {
+  struct CommentInfo {
     CommentInfo();
     ~CommentInfo();
 
@@ -475,8 +473,7 @@ namespace Json {
   //   }
   //};
 
-      union ValueHolder
-      {
+  union ValueHolder {
     LargestInt int_;
     LargestUInt uint_;
     double real_;
@@ -496,13 +493,17 @@ namespace Json {
   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 access a node.
+/** \brief Experimental and untested: represents an element of the "path" to
+ * access a node.
  */
-   class PathArgument
-   {
+class JSON_API PathArgument {
 public:
   friend class Path;
 
@@ -512,8 +513,7 @@ namespace Json {
   PathArgument(const std::string& key);
 
 private:
-      enum Kind
-      {
+  enum Kind {
     kindNone = 0,
     kindIndex,
     kindKey
@@ -534,8 +534,7 @@ namespace Json {
  * - ".%" => member name is provided as parameter
  * - ".[%]" => index is provied as parameter
  */
-   class Path
-   {
+class JSON_API Path {
 public:
   Path(const std::string& path,
        const PathArgument& a1 = PathArgument(),
@@ -545,32 +544,29 @@ namespace Json {
        const PathArgument& a5 = PathArgument());
 
   const Value& resolve(const Value& root) const;
-      Value resolve( const Value &root, 
-                     const Value &defaultValue ) const;
-      /// Creates the "path" to access the specified node and returns a reference on the node.
+  Value resolve(const Value& root, const Value& defaultValue) const;
+  /// Creates the "path" to access the specified node and returns a reference on
+  /// the node.
   Value& make(Value& root) const;
 
 private:
   typedef std::vector<const PathArgument*> InArgs;
   typedef std::vector<PathArgument> Args;
 
-      void makePath( const std::string &path,
-                     const InArgs &in );
+  void makePath(const std::string& path, const InArgs& in);
   void addPathInArg(const std::string& path,
                     const InArgs& in,
                     InArgs::const_iterator& itInArg,
                     PathArgument::Kind kind);
-      void invalidPath( const std::string &path, 
-                        int location );
+  void invalidPath(const std::string& path, int location);
 
   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
+ * Below is an example of a simple implementation (default implementation
+ actually
  * use memory pool for speed).
  * \code
    class DefaultValueMapAllocator : public ValueMapAllocator
@@ -613,8 +609,7 @@ namespace Json {
    };
  * \endcode
  */
-   class JSON_API ValueMapAllocator
-   {
+class JSON_API ValueMapAllocator {
 public:
   virtual ~ValueMapAllocator();
   virtual ValueInternalMap* newMap() = 0;
@@ -629,10 +624,11 @@ namespace Json {
 /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
  * \internal previous_ & next_ allows for bidirectional traversal.
  */
-   class JSON_API ValueInternalLink
-   {
+class JSON_API ValueInternalLink {
 public:
-      enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
+  enum {
+    itemPerLink = 6
+  }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
   enum InternalFlags {
     flagAvailable = 0,
     flagUsed = 1
@@ -648,37 +644,34 @@ namespace Json {
   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
+/** \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
+ * 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
-   {
+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) 
-         {
-         }
+  struct IteratorState {
+    IteratorState() : map_(0), link_(0), itemIndex_(0), bucketIndex_(0) {}
     ValueInternalMap* map_;
     ValueInternalLink* link_;
     BucketIndex itemIndex_;
@@ -688,7 +681,7 @@ namespace Json {
 
   ValueInternalMap();
   ValueInternalMap(const ValueInternalMap& other);
-      ValueInternalMap &operator =( const ValueInternalMap &other );
+  ValueInternalMap& operator=(ValueInternalMap other);
   ~ValueInternalMap();
 
   void swap(ValueInternalMap& other);
@@ -705,8 +698,7 @@ namespace Json {
 
   Value* find(const char* key);
 
-      Value &resolveReference( const char *key, 
-                               bool isStatic );
+  Value& resolveReference(const char* key, bool isStatic);
 
   void remove(const char* key);
 
@@ -721,9 +713,7 @@ namespace Json {
                     ValueInternalLink* link,
                     BucketIndex index);
 
-      Value &unsafeAdd( const char *key, 
-                        bool isStatic, 
-                        HashKey hashedKey );
+  Value& unsafeAdd(const char* key, bool isStatic, HashKey hashedKey);
 
   HashKey hash(const char* key) const;
 
@@ -750,33 +740,33 @@ namespace Json {
 
 /** \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.
+* 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
+* 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
-   {
+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.
+  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) 
-         {
-         }
+    IteratorState() : array_(0), currentPageIndex_(0), currentItemIndex_(0) {}
     ValueInternalArray* array_;
     Value** currentPageIndex_;
     unsigned int currentItemIndex_;
@@ -785,7 +775,7 @@ namespace Json {
 
   ValueInternalArray();
   ValueInternalArray(const ValueInternalArray& other);
-      ValueInternalArray &operator =( const ValueInternalArray &other );
+  ValueInternalArray& operator=(ValueInternalArray other);
   ~ValueInternalArray();
   void swap(ValueInternalArray& other);
 
@@ -819,7 +809,8 @@ namespace Json {
   PageIndex pageCount_;
 };
 
-   /** \brief Experimental: do not use. Allocator to customize Value internal array.
+/** \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
@@ -846,8 +837,10 @@ public: // overridden from ValueArrayAllocator
 }
 
 virtual void reallocateArrayPageIndex( Value **&indexes,
-                                          ValueInternalArray::PageIndex &indexCount,
-                                          ValueInternalArray::PageIndex minNewIndexCount )
+                                       ValueInternalArray::PageIndex
+&indexCount,
+                                       ValueInternalArray::PageIndex
+minNewIndexCount )
 {
    ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
    if ( minNewIndexCount > newIndexCount )
@@ -867,7 +860,8 @@ public: // overridden from ValueArrayAllocator
 
 virtual Value *allocateArrayPage()
 {
-      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   return static_cast<Value *>( malloc( sizeof(Value) *
+ValueInternalArray::itemsPerPage ) );
 }
 
 virtual void releaseArrayPage( Value *value )
@@ -878,8 +872,7 @@ public: // overridden from ValueArrayAllocator
 };
    \endcode
  */
-   class JSON_API ValueArrayAllocator
-   {
+class JSON_API ValueArrayAllocator {
 public:
   virtual ~ValueArrayAllocator();
   virtual ValueInternalArray* newArray() = 0;
@@ -893,26 +886,28 @@ public: // overridden from ValueArrayAllocator
    * \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
+   * \param minNewIndexCount Minimum number of page the new index must be able
+   * to
    *                         handle.
    */
-      virtual void reallocateArrayPageIndex( Value **&indexes, 
+  virtual void
+  reallocateArrayPageIndex(Value**& indexes,
                            ValueInternalArray::PageIndex& indexCount,
                            ValueInternalArray::PageIndex minNewIndexCount) = 0;
-      virtual void releaseArrayPageIndex( Value **indexes, 
+  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.
  *
  */
-   class ValueIteratorBase
-   {
+class JSON_API ValueIteratorBase {
 public:
+  typedef std::bidirectional_iterator_tag iterator_category;
   typedef unsigned int size_t;
   typedef int difference_type;
   typedef ValueIteratorBase SelfType;
@@ -925,28 +920,23 @@ public: // overridden from ValueArrayAllocator
   ValueIteratorBase(const ValueInternalMap::IteratorState& state);
 #endif
 
-      bool operator ==( const SelfType &other ) const
-      {
-         return isEqual( other );
-      }
+  bool operator==(const SelfType& other) const { return isEqual(other); }
 
-      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
-      {
+  difference_type operator-(const SelfType& other) const {
     return computeDistance(other);
   }
 
-      /// Return either the index or the member name of the referenced value as a Value.
+  /// 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.
   UInt index() const;
 
-      /// Return the member name of the referenced Value. "" if it is not an objectValue.
+  /// Return the member name of the referenced Value. "" if it is not an
+  /// objectValue.
   const char* memberName() const;
 
 protected:
@@ -968,8 +958,7 @@ public: // overridden from ValueArrayAllocator
   // Indicates that iterator is for a null value.
   bool isNull_;
 #else
-      union
-      {
+  union {
     ValueInternalArray::IteratorState array_;
     ValueInternalMap::IteratorState map_;
   } iterator_;
@@ -980,10 +969,11 @@ public: // overridden from ValueArrayAllocator
 /** \brief const iterator for object and array value.
  *
  */
-   class ValueConstIterator : public ValueIteratorBase
-   {
+class JSON_API ValueConstIterator : public ValueIteratorBase {
   friend class Value;
+
 public:
+  typedef const Value value_type;
   typedef unsigned int size_t;
   typedef int difference_type;
   typedef const Value& reference;
@@ -991,6 +981,7 @@ public: // overridden from ValueArrayAllocator
   typedef ValueConstIterator SelfType;
 
   ValueConstIterator();
+
 private:
 /*! \internal Use by Value to create an iterator.
  */
@@ -1003,45 +994,40 @@ public: // overridden from ValueArrayAllocator
 public:
   SelfType& operator=(const ValueIteratorBase& other);
 
-      SelfType operator++( int )
-      {
+  SelfType operator++(int) {
     SelfType temp(*this);
     ++*this;
     return temp;
   }
 
-      SelfType operator--( int )
-      {
+  SelfType operator--(int) {
     SelfType temp(*this);
     --*this;
     return temp;
   }
 
-      SelfType &operator--()
-      {
+  SelfType& operator--() {
     decrement();
     return *this;
   }
 
-      SelfType &operator++()
-      {
+  SelfType& operator++() {
     increment();
     return *this;
   }
 
-      reference operator *() const
-      {
-         return deref();
-      }
-   };
+  reference operator*() const { return deref(); }
 
+  pointer operator->() const { return &deref(); }
+};
 
 /** \brief Iterator for object and array value.
  */
-   class ValueIterator : public ValueIteratorBase
-   {
+class JSON_API ValueIterator : public ValueIteratorBase {
   friend class Value;
+
 public:
+  typedef Value value_type;
   typedef unsigned int size_t;
   typedef int difference_type;
   typedef Value& reference;
@@ -1051,6 +1037,7 @@ public: // overridden from ValueArrayAllocator
   ValueIterator();
   ValueIterator(const ValueConstIterator& other);
   ValueIterator(const ValueIterator& other);
+
 private:
 /*! \internal Use by Value to create an iterator.
  */
@@ -1061,43 +1048,39 @@ public: // overridden from ValueArrayAllocator
   ValueIterator(const ValueInternalMap::IteratorState& state);
 #endif
 public:
-
   SelfType& operator=(const SelfType& other);
 
-      SelfType operator++( int )
-      {
+  SelfType operator++(int) {
     SelfType temp(*this);
     ++*this;
     return temp;
   }
 
-      SelfType operator--( int )
-      {
+  SelfType operator--(int) {
     SelfType temp(*this);
     --*this;
     return temp;
   }
 
-      SelfType &operator--()
-      {
+  SelfType& operator--() {
     decrement();
     return *this;
   }
 
-      SelfType &operator++()
-      {
+  SelfType& operator++() {
     increment();
     return *this;
   }
 
-      reference operator *() const
-      {
-         return deref();
-      }
-   };
+  reference operator*() const { return deref(); }
 
+  pointer operator->() const { return &deref(); }
+};
 
 } // namespace Json
 
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
 #endif // CPPTL_JSON_H_INCLUDED

include/json/version.h

@@ -0,0 +1,14 @@
+// DO NOT EDIT. This file is generated by CMake from  "version"
+// and "version.h.in" files.
+// Run CMake configure step to update it.
+#ifndef JSON_VERSION_H_INCLUDED
+# define JSON_VERSION_H_INCLUDED
+
+# define JSONCPP_VERSION_STRING "0.7.0"
+# define JSONCPP_VERSION_MAJOR 0
+# define JSONCPP_VERSION_MINOR 7
+# define JSONCPP_VERSION_PATCH 0
+# define JSONCPP_VERSION_QUALIFIER
+# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
+
+#endif // JSON_VERSION_H_INCLUDED

include/json/writer.h

@@ -11,7 +11,13 @@
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <vector>
 #include <string>
-# include <iostream>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
 namespace Json {
 
@@ -19,28 +25,37 @@ namespace Json {
 
 /** \brief Abstract class for writers.
  */
-   class JSON_API Writer
-   {
+class JSON_API Writer {
 public:
   virtual ~Writer();
 
   virtual std::string write(const Value& root) = 0;
 };
 
-   /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
+/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
+ *without formatting (not human friendly).
  *
-    * The JSON document is written in a single line. It is not intended for 'human' consumption,
+ * The JSON document is written in a single line. It is not intended for 'human'
+ *consumption,
  * but may be usefull to support feature such as RPC where bandwith is limited.
  * \sa Reader, Value
  */
-   class JSON_API FastWriter : public Writer
-   {
+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);
 
@@ -49,28 +64,34 @@ namespace Json {
 
   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 human friendly way.
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ *human friendly way.
  *
  * The rules for line break and indent are as follow:
  * - Object value:
  *     - if empty then print {} without indent and line break
-    *     - if not empty the print '{', line break & indent, print one value per line
+ *     - if not empty the print '{', line break & indent, print one value per
+ *line
  *       and then unindent and line break and print '}'.
  * - Array value:
  *     - if empty then print [] without indent and line break
-    *     - if the array contains no object value, empty array or some other value types,
-    *       and all the values fit on one lines, then print the array on a single line.
+ *     - if the array contains no object value, empty array or some other value
+ *types,
+ *       and all the values fit on one lines, then print the array on a single
+ *line.
  *     - otherwise, it the values do not fit on one line, or the array contains
  *       object or non empty array, then print one value per line.
  *
-    * If the Value have comments then they are outputed according to their #CommentPlacement.
+ * If the Value have comments then they are outputed according to their
+ *#CommentPlacement.
  *
  * \sa Reader, Value, Value::setComment()
  */
-   class JSON_API StyledWriter: public Writer
-   {
+class JSON_API StyledWriter : public Writer {
 public:
   StyledWriter();
   virtual ~StyledWriter() {}
@@ -106,28 +127,32 @@ namespace Json {
   bool addChildValues_;
 };
 
-   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ human friendly way,
      to a stream rather than to a string.
  *
  * The rules for line break and indent are as follow:
  * - Object value:
  *     - if empty then print {} without indent and line break
-    *     - if not empty the print '{', line break & indent, print one value per line
+ *     - if not empty the print '{', line break & indent, print one value per
+ line
  *       and then unindent and line break and print '}'.
  * - Array value:
  *     - if empty then print [] without indent and line break
-    *     - if the array contains no object value, empty array or some other value types,
-    *       and all the values fit on one lines, then print the array on a single line.
+ *     - if the array contains no object value, empty array or some other value
+ types,
+ *       and all the values fit on one lines, then print the array on a single
+ line.
  *     - otherwise, it the values do not fit on one line, or the array contains
  *       object or non empty array, then print one value per line.
  *
-    * If the Value have comments then they are outputed according to their #CommentPlacement.
+ * If the Value have comments then they are outputed according to their
+ #CommentPlacement.
  *
  * \param indentation Each level will be indented by this amount extra.
  * \sa Reader, Value, Value::setComment()
  */
-   class JSON_API StyledStreamWriter
-   {
+class JSON_API StyledStreamWriter {
 public:
   StyledStreamWriter(std::string indentation = "\t");
   ~StyledStreamWriter() {}
@@ -136,7 +161,8 @@ namespace Json {
   /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
    * \param out Stream to write to. (Can be ostringstream, e.g.)
    * \param root Value to serialize.
-       * \note There is no point in deriving from Writer, since write() should not return a value.
+   * \note There is no point in deriving from Writer, since write() should not
+   * return a value.
    */
   void write(std::ostream& out, const Value& root);
 
@@ -176,10 +202,12 @@ namespace Json {
 
 /// \brief Output using the StyledStreamWriter.
 /// \see Json::operator>>()
-   std::ostream& operator<<( std::ostream&, const Value &root );
+JSON_API std::ostream& operator<<(std::ostream&, const Value& root);
 
 } // namespace Json
 
-
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
 #endif // JSON_WRITER_H_INCLUDED

makefiles/msvc2010/jsoncpp.sln

@@ -0,0 +1,42 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_json", "lib_json.vcxproj", "{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jsontest", "jsontest.vcxproj", "{25AF2DD2-D396-4668-B188-488C33B8E620}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_lib_json", "test_lib_json.vcxproj", "{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Debug|Win32.Build.0 = Debug|Win32
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Debug|x64.ActiveCfg = Debug|x64
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Debug|x64.Build.0 = Debug|x64
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Release|Win32.ActiveCfg = Release|Win32
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Release|Win32.Build.0 = Release|Win32
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Release|x64.ActiveCfg = Release|x64
+		{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}.Release|x64.Build.0 = Release|x64
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Debug|Win32.ActiveCfg = Debug|Win32
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Debug|Win32.Build.0 = Debug|Win32
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Debug|x64.ActiveCfg = Debug|Win32
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Release|Win32.ActiveCfg = Release|Win32
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Release|Win32.Build.0 = Release|Win32
+		{25AF2DD2-D396-4668-B188-488C33B8E620}.Release|x64.ActiveCfg = Release|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Debug|Win32.Build.0 = Debug|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Debug|x64.ActiveCfg = Debug|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Release|Win32.ActiveCfg = Release|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Release|Win32.Build.0 = Release|Win32
+		{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}.Release|x64.ActiveCfg = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

makefiles/msvc2010/jsontest.vcxproj

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{25AF2DD2-D396-4668-B188-488C33B8E620}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../build/vs71/debug/jsontest\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../build/vs71/debug/jsontest\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../build/vs71/release/jsontest\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../build/vs71/release/jsontest\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)jsontest.exe</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>$(OutDir)jsontest.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)jsontest.exe</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\jsontestrunner\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="lib_json.vcxproj">
+      <Project>{1e6c2c1c-6453-4129-ae3f-0ee8e6599c89}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

makefiles/msvc2010/jsontest.vcxproj.filters

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{903591b3-ade3-4ce4-b1f9-1e175e62b014}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\jsontestrunner\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

makefiles/msvc2010/lib_json.vcxproj

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\lib_json\json_reader.cpp" />
+    <ClCompile Include="..\..\src\lib_json\json_value.cpp" />
+    <ClCompile Include="..\..\src\lib_json\json_writer.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\json\reader.h" />
+    <ClInclude Include="..\..\include\json\value.h" />
+    <ClInclude Include="..\..\include\json\writer.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1E6C2C1C-6453-4129-AE3F-0EE8E6599C89}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>jsoncpp</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../include</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../include</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../include</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../include</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

makefiles/msvc2010/lib_json.vcxproj.filters

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{c110bc57-c46e-476c-97ea-84d8014f431c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{ed718592-5acf-47b5-8f2b-b8224590da6a}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\lib_json\json_reader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\lib_json\json_value.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\lib_json\json_writer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\json\reader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\json\value.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\json\writer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

makefiles/msvc2010/test_lib_json.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B7A96B78-2782-40D2-8F37-A2DEF2B9C26D}</ProjectGuid>
+    <RootNamespace>test_lib_json</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../build/vs71/debug/test_lib_json\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../build/vs71/debug/test_lib_json\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../build/vs71/release/test_lib_json\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../build/vs71/release/test_lib_json\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)test_lib_json.exe</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>$(OutDir)test_lib_json.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Message>Running all unit tests</Message>
+      <Command>$(TargetPath)</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)test_lib_json.exe</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Message>Running all unit tests</Message>
+      <Command>$(TargetPath)</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test_lib_json\jsontest.cpp" />
+    <ClCompile Include="..\..\src\test_lib_json\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\src\test_lib_json\jsontest.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="lib_json.vcxproj">
+      <Project>{1e6c2c1c-6453-4129-ae3f-0ee8e6599c89}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

makefiles/msvc2010/test_lib_json.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test_lib_json\jsontest.cpp">
+      <Filter>Source Filter</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\test_lib_json\main.cpp">
+      <Filter>Source Filter</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Source Filter">
+      <UniqueIdentifier>{bf40cbfc-8e98-40b4-b9f3-7e8d579cbae2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{5fd39074-89e6-4939-aa3f-694fefd296b1}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\src\test_lib_json\jsontest.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

makerelease.py

@@ -10,6 +10,9 @@ python makerelease.py --force --retag --platform=msvc6,msvc71,msvc80,mingw -uble
 
 Example of invocation when doing a release:
 python makerelease.py 0.5.0 0.6.0-dev
+
+Note: This was for Subversion. Now that we are in GitHub, we do not
+need to build versioned tarballs anymore, so makerelease.py is defunct.
 """
 import os.path
 import subprocess

pkg-config/jsoncpp.pc.in

@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: jsoncpp
+Description: A C++ library for interacting with JSON
+Version: @JSONCPP_VERSION@
+URL: https://github.com/open-source-parsers/jsoncpp
+Libs: -L${libdir} -ljsoncpp
+Cflags: -I${includedir}

src/CMakeLists.txt

@@ -0,0 +1,5 @@
+ADD_SUBDIRECTORY(lib_json)
+IF(JSONCPP_WITH_TESTS)
+    ADD_SUBDIRECTORY(jsontestrunner)
+    ADD_SUBDIRECTORY(test_lib_json)
+ENDIF(JSONCPP_WITH_TESTS)

src/jsontestrunner/CMakeLists.txt

@@ -0,0 +1,22 @@
+FIND_PACKAGE(PythonInterp 2.6 REQUIRED)
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+  ADD_DEFINITIONS( -DJSON_DLL )
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+ADD_EXECUTABLE(jsontestrunner_exe
+               main.cpp
+               )
+TARGET_LINK_LIBRARIES(jsontestrunner_exe jsoncpp_lib)
+SET_TARGET_PROPERTIES(jsontestrunner_exe PROPERTIES OUTPUT_NAME jsontestrunner_exe)
+
+IF(PYTHONINTERP_FOUND)
+    # Run end to end parser/writer tests
+    SET(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../test)
+    SET(RUNJSONTESTS_PATH ${TEST_DIR}/runjsontests.py)
+    ADD_CUSTOM_TARGET(jsoncpp_readerwriter_tests ALL
+                      "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+                      DEPENDS jsontestrunner_exe jsoncpp_test
+                      )
+    ADD_CUSTOM_TARGET(jsoncpp_check DEPENDS jsoncpp_readerwriter_tests)
+ENDIF(PYTHONINTERP_FOUND)

src/jsontestrunner/main.cpp

@@ -6,7 +6,6 @@
 /* This executable is used for testing parser/writer using real JSON files.
  */
 
-
 #include <json/json.h>
 #include <algorithm> // sort
 #include <stdio.h>
@@ -15,9 +14,35 @@
 #pragma warning(disable : 4996) // disable fopen deprecation warning
 #endif
 
-static std::string
-readInputTestFile( const char *path )
+static std::string normalizeFloatingPointStr(double value) {
+  char buffer[32];
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
+  sprintf_s(buffer, sizeof(buffer), "%.16g", value);
+#else
+  snprintf(buffer, sizeof(buffer), "%.16g", value);
+#endif
+  buffer[sizeof(buffer) - 1] = 0;
+  std::string s(buffer);
+  std::string::size_type index = s.find_last_of("eE");
+  if (index != std::string::npos) {
+    std::string::size_type hasSign =
+        (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+    std::string::size_type exponentStartIndex = index + 1 + hasSign;
+    std::string normalized = s.substr(0, exponentStartIndex);
+    std::string::size_type indexDigit =
+        s.find_first_not_of('0', exponentStartIndex);
+    std::string exponent = "0";
+    if (indexDigit !=
+        std::string::npos) // There is an exponent different from 0
     {
+      exponent = s.substr(indexDigit);
+    }
+    return normalized + exponent;
+  }
+  return s;
+}
+
+static std::string readInputTestFile(const char* path) {
   FILE* file = fopen(path, "rb");
   if (!file)
     return std::string("");
@@ -34,23 +59,32 @@ readInputTestFile( const char *path )
   return text;
 }
 
-
 static void
-printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
-{
-   switch ( value.type() )
-   {
+printValueTree(FILE* fout, Json::Value& value, const std::string& path = ".") {
+  if (value.hasComment(Json::commentBefore)) {
+    fprintf(fout, "%s\n", value.getComment(Json::commentBefore).c_str());
+  }
+  switch (value.type()) {
   case Json::nullValue:
     fprintf(fout, "%s=null\n", path.c_str());
     break;
   case Json::intValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestInt() ).c_str() );
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            Json::valueToString(value.asLargestInt()).c_str());
     break;
   case Json::uintValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestUInt() ).c_str() );
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            Json::valueToString(value.asLargestUInt()).c_str());
     break;
   case Json::realValue:
-      fprintf( fout, "%s=%.16g\n", path.c_str(), value.asDouble() );
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            normalizeFloatingPointStr(value.asDouble()).c_str());
     break;
   case Json::stringValue:
     fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
@@ -58,62 +92,58 @@ printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
   case Json::booleanValue:
     fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
     break;
-   case Json::arrayValue:
-      {
+  case Json::arrayValue: {
     fprintf(fout, "%s=[]\n", path.c_str());
     int size = value.size();
-         for ( int index =0; index < size; ++index )
-         {
+    for (int index = 0; index < size; ++index) {
       static char buffer[16];
-            sprintf( buffer, "[%d]", index );
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
+      sprintf_s(buffer, sizeof(buffer), "[%d]", index);
+#else
+      snprintf(buffer, sizeof(buffer), "[%d]", index);
+#endif
       printValueTree(fout, value[index], path + buffer);
     }
-      }
-      break;
-   case Json::objectValue:
-      {
+  } break;
+  case Json::objectValue: {
     fprintf(fout, "%s={}\n", path.c_str());
     Json::Value::Members members(value.getMemberNames());
     std::sort(members.begin(), members.end());
     std::string suffix = *(path.end() - 1) == '.' ? "" : ".";
     for (Json::Value::Members::iterator it = members.begin();
          it != members.end();
-               ++it )
-         {
+         ++it) {
       const std::string& name = *it;
       printValueTree(fout, value[name], path + suffix + name);
     }
-      }
-      break;
+  } break;
   default:
     break;
   }
+
+  if (value.hasComment(Json::commentAfter)) {
+    fprintf(fout, "%s\n", value.getComment(Json::commentAfter).c_str());
+  }
 }
 
-
-static int
-parseAndSaveValueTree( const std::string &input, 
+static int parseAndSaveValueTree(const std::string& input,
                                  const std::string& actual,
                                  const std::string& kind,
                                  Json::Value& root,
                                  const Json::Features& features,
-                       bool parseOnly )
-{
+                                 bool parseOnly) {
   Json::Reader reader(features);
   bool parsingSuccessful = reader.parse(input, root);
-   if ( !parsingSuccessful )
-   {
+  if (!parsingSuccessful) {
     printf("Failed to parse %s file: \n%s\n",
            kind.c_str(),
            reader.getFormattedErrorMessages().c_str());
     return 1;
   }
 
-   if ( !parseOnly )
-   {
+  if (!parseOnly) {
     FILE* factual = fopen(actual.c_str(), "wt");
-      if ( !factual )
-      {
+    if (!factual) {
       printf("Failed to create %s actual file.\n", kind.c_str());
       return 2;
     }
@@ -123,19 +153,15 @@ parseAndSaveValueTree( const std::string &input,
   return 0;
 }
 
-
-static int
-rewriteValueTree( const std::string &rewritePath, 
+static int rewriteValueTree(const std::string& rewritePath,
                             const Json::Value& root,
-                  std::string &rewrite )
-{
+                            std::string& rewrite) {
   // Json::FastWriter writer;
   // writer.enableYAMLCompatibility();
   Json::StyledWriter writer;
   rewrite = writer.write(root);
   FILE* fout = fopen(rewritePath.c_str(), "wt");
-   if ( !fout )
-   {
+  if (!fout) {
     printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
     return 2;
   }
@@ -144,11 +170,8 @@ rewriteValueTree( const std::string &rewritePath,
   return 0;
 }
 
-
-static std::string
-removeSuffix( const std::string &path, 
-              const std::string &extension )
-{
+static std::string removeSuffix(const std::string& path,
+                                const std::string& extension) {
   if (extension.length() >= path.length())
     return std::string("");
   std::string suffix = path.substr(path.length() - extension.length());
@@ -157,10 +180,7 @@ removeSuffix( const std::string &path,
   return path.substr(0, path.length() - extension.length());
 }
 
-
-static void
-printConfig()
-{
+static void printConfig() {
 // Print the configuration used to compile JsonCpp
 #if defined(JSON_NO_INT64)
   printf("JSON_NO_INT64=1\n");
@@ -169,42 +189,34 @@ printConfig()
 #endif
 }
 
-
-static int 
-printUsage( const char *argv[] )
-{
+static int printUsage(const char* argv[]) {
   printf("Usage: %s [--strict] input-json-file", argv[0]);
   return 3;
 }
 
-
-int
-parseCommandLine( int argc, const char *argv[], 
-                  Json::Features &features, std::string &path,
-                  bool &parseOnly )
-{
+int parseCommandLine(int argc,
+                     const char* argv[],
+                     Json::Features& features,
+                     std::string& path,
+                     bool& parseOnly) {
   parseOnly = false;
-   if ( argc < 2 )
-   {
+  if (argc < 2) {
     return printUsage(argv);
   }
 
   int index = 1;
-   if ( std::string(argv[1]) == "--json-checker" )
-   {
+  if (std::string(argv[1]) == "--json-checker") {
     features = Json::Features::strictMode();
     parseOnly = true;
     ++index;
   }
 
-   if ( std::string(argv[1]) == "--json-config" )
-   {
+  if (std::string(argv[1]) == "--json-config") {
     printConfig();
     return 3;
   }
 
-   if ( index == argc  ||  index + 1 < argc )
-   {
+  if (index == argc || index + 1 < argc) {
     return printUsage(argv);
   }
 
@@ -212,31 +224,26 @@ parseCommandLine( int argc, const char *argv[],
   return 0;
 }
 
-
-int main( int argc, const char *argv[] )
-{
+int main(int argc, const char* argv[]) {
   std::string path;
   Json::Features features;
   bool parseOnly;
   int exitCode = parseCommandLine(argc, argv, features, path, parseOnly);
-   if ( exitCode != 0 )
-   {
+  if (exitCode != 0) {
     return exitCode;
   }
 
-   try
-   {
+  try {
     std::string input = readInputTestFile(path.c_str());
-      if ( input.empty() )
-      {
+    if (input.empty()) {
       printf("Failed to read input or empty input: %s\n", path.c_str());
       return 3;
     }
 
     std::string basePath = removeSuffix(argv[1], ".json");
-      if ( !parseOnly  &&  basePath.empty() )
-      {
-         printf( "Bad input path. Path does not end with '.expected':\n%s\n", path.c_str() );
+    if (!parseOnly && basePath.empty()) {
+      printf("Bad input path. Path does not end with '.expected':\n%s\n",
+             path.c_str());
       return 3;
     }
 
@@ -245,25 +252,26 @@ int main( int argc, const char *argv[] )
     std::string rewriteActualPath = basePath + ".actual-rewrite";
 
     Json::Value root;
-      exitCode = parseAndSaveValueTree( input, actualPath, "input", root, features, parseOnly );
-      if ( exitCode == 0  &&  !parseOnly )
-      {
+    exitCode = parseAndSaveValueTree(
+        input, actualPath, "input", root, features, parseOnly);
+    if (exitCode == 0 && !parseOnly) {
       std::string rewrite;
       exitCode = rewriteValueTree(rewritePath, root, rewrite);
-         if ( exitCode == 0 )
-         {
+      if (exitCode == 0) {
         Json::Value rewriteRoot;
-            exitCode = parseAndSaveValueTree( rewrite, rewriteActualPath, 
-               "rewrite", rewriteRoot, features, parseOnly );
+        exitCode = parseAndSaveValueTree(rewrite,
+                                         rewriteActualPath,
+                                         "rewrite",
+                                         rewriteRoot,
+                                         features,
+                                         parseOnly);
       }
     }
   }
-   catch ( const std::exception &e )
-   {
+  catch (const std::exception& e) {
     printf("Unhandled exception:\n%s\n", e.what());
     exitCode = 1;
   }
 
   return exitCode;
 }
-

src/lib_json/CMakeLists.txt

@@ -0,0 +1,57 @@
+OPTION(JSONCPP_LIB_BUILD_SHARED "Build jsoncpp_lib as a shared library." OFF)
+IF(JSONCPP_LIB_BUILD_SHARED)
+  SET(JSONCPP_LIB_TYPE SHARED)
+  ADD_DEFINITIONS( -DJSON_DLL_BUILD )
+ELSE(JSONCPP_LIB_BUILD_SHARED)
+  SET(JSONCPP_LIB_TYPE STATIC)
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+
+if( CMAKE_COMPILER_IS_GNUCXX )
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=strict-aliasing")
+endif( CMAKE_COMPILER_IS_GNUCXX )
+
+SET( JSONCPP_INCLUDE_DIR ../../include )
+
+SET( PUBLIC_HEADERS
+    ${JSONCPP_INCLUDE_DIR}/json/config.h
+    ${JSONCPP_INCLUDE_DIR}/json/forwards.h
+    ${JSONCPP_INCLUDE_DIR}/json/features.h
+    ${JSONCPP_INCLUDE_DIR}/json/value.h
+    ${JSONCPP_INCLUDE_DIR}/json/reader.h
+    ${JSONCPP_INCLUDE_DIR}/json/writer.h
+    ${JSONCPP_INCLUDE_DIR}/json/assertions.h
+    ${JSONCPP_INCLUDE_DIR}/json/version.h
+    )
+
+SOURCE_GROUP( "Public API" FILES ${PUBLIC_HEADERS} )
+
+ADD_LIBRARY( jsoncpp_lib ${JSONCPP_LIB_TYPE}
+             ${PUBLIC_HEADERS} 
+             json_tool.h
+             json_reader.cpp
+             json_batchallocator.h
+             json_valueiterator.inl
+             json_value.cpp
+             json_writer.cpp
+             version.h.in
+             )
+SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES OUTPUT_NAME jsoncpp )
+SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES VERSION ${JSONCPP_VERSION} SOVERSION ${JSONCPP_VERSION_MAJOR} )
+
+# Install instructions for this target
+IF(JSONCPP_WITH_CMAKE_PACKAGE)
+    TARGET_INCLUDE_DIRECTORIES( jsoncpp_lib
+                                PUBLIC $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
+                                       $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSON_INCLUDE_DIR}>
+                                )
+    SET(INSTALL_EXPORT EXPORT jsoncpp)
+ELSE(JSONCPP_WITH_CMAKE_PACKAGE)
+    SET(INSTALL_EXPORT)
+ENDIF(JSONCPP_WITH_CMAKE_PACKAGE)
+
+INSTALL( TARGETS jsoncpp_lib ${INSTALL_EXPORT}
+         RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
+         LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
+         ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR}
+)

src/lib_json/json_batchallocator.h

@@ -18,35 +18,30 @@ namespace Json {
  * 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.
+ * 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.
+ * 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
-{
+template <typename AllocatedType, const unsigned int objectPerAllocation>
+class BatchAllocator {
 public:
-   typedef AllocatedType Type;
-
   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.
+      : 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;  )
-      {
+  ~BatchAllocator() {
+    for (BatchInfo* batch = batches_; batch;) {
       BatchInfo* nextBatch = batch->next_;
       free(batch);
       batch = nextBatch;
@@ -54,17 +49,16 @@ public:
   }
 
   /// allocate space for an array of objectPerAllocation object.
-   /// @warning it is the responsability of the caller to call objects constructors.
-   AllocatedType *allocate()
-   {
+  /// @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_ )
-      {
+    if (currentBatch_->used_ == currentBatch_->end_) {
       currentBatch_ = currentBatch_->next_;
       while (currentBatch_ && currentBatch_->used_ == currentBatch_->end_)
         currentBatch_ = currentBatch_->next_;
@@ -82,17 +76,16 @@ public:
   }
 
   /// Release the object.
-   /// @warning it is the responsability of the caller to actually destruct the object.
-   void release( AllocatedType *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
-   {
+  struct BatchInfo {
     BatchInfo* next_;
     AllocatedType* used_;
     AllocatedType* end_;
@@ -103,10 +96,10 @@ private:
   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;
+  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_;
@@ -121,10 +114,8 @@ private:
   unsigned int objectsPerPage_;
 };
 
-
 } // namespace Json
 
 #endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
 
 #endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
-

src/lib_json/json_internalarray.inl

@@ -15,63 +15,48 @@ namespace Json {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueArrayAllocator::~ValueArrayAllocator()
-{
-}
+ValueArrayAllocator::~ValueArrayAllocator() {}
 
 // //////////////////////////////////////////////////////////////////
 // class DefaultValueArrayAllocator
 // //////////////////////////////////////////////////////////////////
 #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueArrayAllocator : public ValueArrayAllocator
-{
+class DefaultValueArrayAllocator : public ValueArrayAllocator {
 public: // overridden from ValueArrayAllocator
-   virtual ~DefaultValueArrayAllocator()
-   {
-   }
+  virtual ~DefaultValueArrayAllocator() {}
 
-   virtual ValueInternalArray *newArray()
-   {
-      return new ValueInternalArray();
-   }
+  virtual ValueInternalArray* newArray() { return new ValueInternalArray(); }
 
-   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
-   {
+  virtual ValueInternalArray* newArrayCopy(const ValueInternalArray& other) {
     return new ValueInternalArray(other);
   }
 
-   virtual void destructArray( ValueInternalArray *array )
-   {
-      delete array;
-   }
+  virtual void destructArray(ValueInternalArray* array) { delete array; }
 
-   virtual void reallocateArrayPageIndex( Value **&indexes, 
+  virtual void
+  reallocateArrayPageIndex(Value**& indexes,
                            ValueInternalArray::PageIndex& indexCount,
-                                          ValueInternalArray::PageIndex minNewIndexCount )
-   {
+                           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();
+    JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
     indexCount = newIndexCount;
     indexes = static_cast<Value**>(newIndexes);
   }
   virtual void releaseArrayPageIndex(Value** indexes,
-                                       ValueInternalArray::PageIndex indexCount )
-   {
+                                     ValueInternalArray::PageIndex indexCount) {
     if (indexes)
       free(indexes);
   }
 
-   virtual Value *allocateArrayPage()
-   {
-      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+  virtual Value* allocateArrayPage() {
+    return static_cast<Value*>(
+        malloc(sizeof(Value) * ValueInternalArray::itemsPerPage));
   }
 
-   virtual void releaseArrayPage( Value *value )
-   {
+  virtual void releaseArrayPage(Value* value) {
     if (value)
       free(value);
   }
@@ -79,188 +64,145 @@ public: // overridden from ValueArrayAllocator
 
 #else  // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
 /// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueArrayAllocator : public ValueArrayAllocator
-{
+class DefaultValueArrayAllocator : public ValueArrayAllocator {
 public: // overridden from ValueArrayAllocator
-   virtual ~DefaultValueArrayAllocator()
-   {
-   }
+  virtual ~DefaultValueArrayAllocator() {}
 
-   virtual ValueInternalArray *newArray()
-   {
+  virtual ValueInternalArray* newArray() {
     ValueInternalArray* array = arraysAllocator_.allocate();
     new (array) ValueInternalArray(); // placement new
     return array;
   }
 
-   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
-   {
+  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 )
-      {
+  virtual void destructArray(ValueInternalArray* array) {
+    if (array) {
       array->~ValueInternalArray();
       arraysAllocator_.release(array);
     }
   }
 
-   virtual void reallocateArrayPageIndex( Value **&indexes, 
+  virtual void
+  reallocateArrayPageIndex(Value**& indexes,
                            ValueInternalArray::PageIndex& indexCount,
-                                          ValueInternalArray::PageIndex minNewIndexCount )
-   {
+                           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();
+    JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
     indexCount = newIndexCount;
     indexes = static_cast<Value**>(newIndexes);
   }
   virtual void releaseArrayPageIndex(Value** indexes,
-                                       ValueInternalArray::PageIndex indexCount )
-   {
+                                     ValueInternalArray::PageIndex indexCount) {
     if (indexes)
       free(indexes);
   }
 
-   virtual Value *allocateArrayPage()
-   {
+  virtual Value* allocateArrayPage() {
     return static_cast<Value*>(pagesAllocator_.allocate());
   }
 
-   virtual void releaseArrayPage( Value *value )
-   {
+  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 ValueArrayAllocator*& arrayAllocator() {
   static DefaultValueArrayAllocator defaultAllocator;
   static ValueArrayAllocator* arrayAllocator = &defaultAllocator;
   return arrayAllocator;
 }
 
 static struct DummyArrayAllocatorInitializer {
-   DummyArrayAllocatorInitializer() 
-   {
-      arrayAllocator();      // ensure arrayAllocator() statics are initialized before main().
+  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_;
+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_,
+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 )
-   {
+  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,
+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 )
-   {
+  if (it.currentItemIndex_ == 0) {
     it.currentItemIndex_ = itemsPerPage - 1;
     --(it.currentPageIndex_);
-   }
-   else
-   {
+  } else {
     --(it.currentItemIndex_);
   }
 }
 
-
-Value &
-ValueInternalArray::unsafeDereference( const IteratorState &it )
-{
+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_,
+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
-{
+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
-{
+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
-{
+void ValueInternalArray::makeEndIterator(IteratorState& it) const {
   makeIterator(it, size_);
 }
 
-
-ValueInternalArray::ValueInternalArray()
-   : pages_( 0 )
-   , size_( 0 )
-   , pageCount_( 0 )
-{
-}
-
+ValueInternalArray::ValueInternalArray() : pages_(0), size_(0), pageCount_(0) {}
 
 ValueInternalArray::ValueInternalArray(const ValueInternalArray& other)
-   : pages_( 0 )
-   , pageCount_( 0 )
-   , size_( other.size_ )
-{
+    : pages_(0), size_(other.size_), pageCount_(0) {
   PageIndex minNewPages = other.size_ / itemsPerPage;
   arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages);
   JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages,
@@ -268,10 +210,8 @@ ValueInternalArray::ValueInternalArray( const ValueInternalArray &other )
   IteratorState itOther;
   other.makeBeginIterator(itOther);
   Value* value;
-   for ( ArrayIndex index = 0; index < size_; ++index, increment(itOther) )
-   {
-      if ( index % itemsPerPage == 0 )
-      {
+  for (ArrayIndex index = 0; index < size_; ++index, increment(itOther)) {
+    if (index % itemsPerPage == 0) {
       PageIndex pageIndex = index / itemsPerPage;
       value = arrayAllocator()->allocateArrayPage();
       pages_[pageIndex] = value;
@@ -280,25 +220,18 @@ ValueInternalArray::ValueInternalArray( const ValueInternalArray &other )
   }
 }
 
-
-ValueInternalArray &
-ValueInternalArray::operator =( const ValueInternalArray &other )
-{
-   ValueInternalArray temp( other );
-   swap( temp );
+ValueInternalArray& ValueInternalArray::operator=(ValueInternalArray other) {
+  swap(other);
   return *this;
 }
 
-
-ValueInternalArray::~ValueInternalArray()
-{
+ValueInternalArray::~ValueInternalArray() {
   // destroy all constructed items
   IteratorState it;
   IteratorState itEnd;
   makeBeginIterator(it);
   makeEndIterator(itEnd);
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
+  for (; !equals(it, itEnd); increment(it)) {
     Value* value = &dereference(it);
     value->~Value();
   }
@@ -310,10 +243,7 @@ ValueInternalArray::~ValueInternalArray()
   arrayAllocator()->releaseArrayPageIndex(pages_, pageCount_);
 }
 
-
-void 
-ValueInternalArray::swap( ValueInternalArray &other )
-{
+void ValueInternalArray::swap(ValueInternalArray& other) {
   Value** tempPages = pages_;
   pages_ = other.pages_;
   other.pages_ = tempPages;
@@ -325,27 +255,20 @@ ValueInternalArray::swap( ValueInternalArray &other )
   other.pageCount_ = tempPageCount;
 }
 
-void 
-ValueInternalArray::clear()
-{
+void ValueInternalArray::clear() {
   ValueInternalArray dummy;
   swap(dummy);
 }
 
-
-void 
-ValueInternalArray::resize( ArrayIndex newSize )
-{
+void ValueInternalArray::resize(ArrayIndex newSize) {
   if (newSize == 0)
     clear();
-   else if ( newSize < size_ )
-   {
+  else if (newSize < size_) {
     IteratorState it;
     IteratorState itEnd;
     makeIterator(it, newSize);
     makeIterator(itEnd, size_);
-      for ( ; !equals(it,itEnd); increment(it) )
-      {
+    for (; !equals(it, itEnd); increment(it)) {
       Value* value = &dereference(it);
       value->~Value();
     }
@@ -354,29 +277,24 @@ ValueInternalArray::resize( ArrayIndex newSize )
     for (; pageIndex < lastPageIndex; ++pageIndex)
       arrayAllocator()->releaseArrayPage(pages_[pageIndex]);
     size_ = newSize;
-   }
-   else if ( newSize > size_ )
+  } else if (newSize > size_)
     resolveReference(newSize);
 }
 
-
-void 
-ValueInternalArray::makeIndexValid( ArrayIndex index )
-{
+void ValueInternalArray::makeIndexValid(ArrayIndex index) {
   // Need to enlarge page index ?
-   if ( index >= pageCount_ * itemsPerPage )
-   {
+  if (index >= pageCount_ * itemsPerPage) {
     PageIndex minNewPages = (index + 1) / itemsPerPage;
     arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages);
-      JSON_ASSERT_MESSAGE( pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation" );
+    JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages,
+                        "ValueInternalArray::reserve(): bad reallocation");
   }
 
   // Need to allocate new pages ?
-   ArrayIndex nextPageIndex = 
-      (size_ % itemsPerPage) != 0 ? size_ - (size_%itemsPerPage) + itemsPerPage
+  ArrayIndex nextPageIndex = (size_ % itemsPerPage) != 0
+                                 ? size_ - (size_ % itemsPerPage) + itemsPerPage
                                  : size_;
-   if ( nextPageIndex <= index )
-   {
+  if (nextPageIndex <= index) {
     PageIndex pageIndex = nextPageIndex / itemsPerPage;
     PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1;
     for (; pageToAllocate-- > 0; ++pageIndex)
@@ -389,62 +307,48 @@ ValueInternalArray::makeIndexValid( ArrayIndex index )
   makeIterator(it, size_);
   size_ = index + 1;
   makeIterator(itEnd, size_);
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
+  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 )
-{
+Value& ValueInternalArray::resolveReference(ArrayIndex index) {
   if (index >= size_)
     makeIndexValid(index);
   return pages_[index / itemsPerPage][index % itemsPerPage];
 }
 
-Value *
-ValueInternalArray::find( ArrayIndex index ) const
-{
+Value* ValueInternalArray::find(ArrayIndex index) const {
   if (index >= size_)
     return 0;
   return &(pages_[index / itemsPerPage][index % itemsPerPage]);
 }
 
-ValueInternalArray::ArrayIndex 
-ValueInternalArray::size() const
-{
+ValueInternalArray::ArrayIndex ValueInternalArray::size() const {
   return size_;
 }
 
-int 
-ValueInternalArray::distance( const IteratorState &x, const IteratorState &y )
-{
+int ValueInternalArray::distance(const IteratorState& x,
+                                 const IteratorState& y) {
   return indexOf(y) - indexOf(x);
 }
 
-
 ValueInternalArray::ArrayIndex
-ValueInternalArray::indexOf( const IteratorState &iterator )
-{
+ValueInternalArray::indexOf(const IteratorState& iterator) {
   if (!iterator.array_)
     return ArrayIndex(-1);
-   return ArrayIndex(
-      (iterator.currentPageIndex_ - iterator.array_->pages_) * itemsPerPage 
-      + iterator.currentItemIndex_ );
+  return ArrayIndex((iterator.currentPageIndex_ - iterator.array_->pages_) *
+                        itemsPerPage +
+                    iterator.currentItemIndex_);
 }
 
-
-int 
-ValueInternalArray::compare( const ValueInternalArray &other ) const
-{
+int ValueInternalArray::compare(const ValueInternalArray& other) const {
   int sizeDiff(size_ - other.size_);
   if (sizeDiff != 0)
     return sizeDiff;
 
-   for ( ArrayIndex index =0; index < size_; ++index )
-   {
+  for (ArrayIndex index = 0; index < size_; ++index) {
     int diff = pages_[index / itemsPerPage][index % itemsPerPage].compare(
         other.pages_[index / itemsPerPage][index % itemsPerPage]);
     if (diff != 0)

src/lib_json/json_internalmap.inl

@@ -15,146 +15,106 @@ namespace Json {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) );
+/** \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() : previous_(0), next_(0) {}
 
-ValueInternalLink::~ValueInternalLink()
-{ 
-   for ( int index =0; index < itemPerLink; ++index )
-   {
-      if ( !items_[index].isItemAvailable() )
-      {
+ValueInternalLink::~ValueInternalLink() {
+  for (int index = 0; index < itemPerLink; ++index) {
+    if (!items_[index].isItemAvailable()) {
       if (!items_[index].isMemberNameStatic())
         free(keys_[index]);
-      }
-      else
+    } else
       break;
   }
 }
 
-
-
-ValueMapAllocator::~ValueMapAllocator()
-{
-}
+ValueMapAllocator::~ValueMapAllocator() {}
 
 #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueMapAllocator : public ValueMapAllocator
-{
+class DefaultValueMapAllocator : public ValueMapAllocator {
 public: // overridden from ValueMapAllocator
-   virtual ValueInternalMap *newMap()
-   {
-      return new ValueInternalMap();
-   }
+  virtual ValueInternalMap* newMap() { return new ValueInternalMap(); }
 
-   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
-   {
+  virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) {
     return new ValueInternalMap(other);
   }
 
-   virtual void destructMap( ValueInternalMap *map )
-   {
-      delete map;
-   }
+  virtual void destructMap(ValueInternalMap* map) { delete map; }
 
-   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
-   {
+  virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
     return new ValueInternalLink[size];
   }
 
-   virtual void releaseMapBuckets( ValueInternalLink *links )
-   {
-      delete [] links;
-   }
+  virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
 
-   virtual ValueInternalLink *allocateMapLink()
-   {
+  virtual ValueInternalLink* allocateMapLink() {
     return new ValueInternalLink();
   }
 
-   virtual void releaseMapLink( ValueInternalLink *link )
-   {
-      delete link;
-   }
+  virtual void releaseMapLink(ValueInternalLink* link) { delete link; }
 };
 #else
 /// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueMapAllocator : public ValueMapAllocator
-{
+class DefaultValueMapAllocator : public ValueMapAllocator {
 public: // overridden from ValueMapAllocator
-   virtual ValueInternalMap *newMap()
-   {
+  virtual ValueInternalMap* newMap() {
     ValueInternalMap* map = mapsAllocator_.allocate();
     new (map) ValueInternalMap(); // placement new
     return map;
   }
 
-   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
-   {
+  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 )
-      {
+  virtual void destructMap(ValueInternalMap* map) {
+    if (map) {
       map->~ValueInternalMap();
       mapsAllocator_.release(map);
     }
   }
 
-   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
-   {
+  virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
     return new ValueInternalLink[size];
   }
 
-   virtual void releaseMapBuckets( ValueInternalLink *links )
-   {
-      delete [] links;
-   }
+  virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
 
-   virtual ValueInternalLink *allocateMapLink()
-   {
+  virtual ValueInternalLink* allocateMapLink() {
     ValueInternalLink* link = linksAllocator_.allocate();
     memset(link, 0, sizeof(ValueInternalLink));
     return link;
   }
 
-   virtual void releaseMapLink( ValueInternalLink *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 ValueMapAllocator*& mapAllocator() {
   static DefaultValueMapAllocator defaultAllocator;
   static ValueMapAllocator* mapAllocator = &defaultAllocator;
   return mapAllocator;
 }
 
 static struct DummyMapAllocatorInitializer {
-   DummyMapAllocatorInitializer() 
-   {
-      mapAllocator();      // ensure mapAllocator() statics are initialized before main().
+  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.
 
 /*
@@ -164,29 +124,17 @@ 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 )
-{
-}
-
+    : buckets_(0), tailLink_(0), bucketsSize_(0), itemCount_(0) {}
 
 ValueInternalMap::ValueInternalMap(const ValueInternalMap& other)
-   : buckets_( 0 )
-   , tailLink_( 0 )
-   , bucketsSize_( 0 )
-   , itemCount_( 0 )
-{
+    : 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) )
-   {
+  for (; !equals(it, itEnd); increment(it)) {
     bool isStatic;
     const char* memberName = key(it, isStatic);
     const Value& aValue = value(it);
@@ -194,25 +142,17 @@ ValueInternalMap::ValueInternalMap( const ValueInternalMap &other )
   }
 }
 
-
-ValueInternalMap &
-ValueInternalMap::operator =( const ValueInternalMap &other )
-{
-   ValueInternalMap dummy( other );
-   swap( dummy );
+ValueInternalMap& ValueInternalMap::operator=(ValueInternalMap other) {
+  swap(other);
   return *this;
 }
 
-
-ValueInternalMap::~ValueInternalMap()
-{
-   if ( buckets_ )
-   {
-      for ( BucketIndex bucketIndex =0; bucketIndex < bucketsSize_; ++bucketIndex )
-      {
+ValueInternalMap::~ValueInternalMap() {
+  if (buckets_) {
+    for (BucketIndex bucketIndex = 0; bucketIndex < bucketsSize_;
+         ++bucketIndex) {
       ValueInternalLink* link = buckets_[bucketIndex].next_;
-         while ( link )
-         {
+      while (link) {
         ValueInternalLink* linkToRelease = link;
         link = link->next_;
         mapAllocator()->releaseMapLink(linkToRelease);
@@ -222,10 +162,7 @@ ValueInternalMap::~ValueInternalMap()
   }
 }
 
-
-void 
-ValueInternalMap::swap( ValueInternalMap &other )
-{
+void ValueInternalMap::swap(ValueInternalMap& other) {
   ValueInternalLink* tempBuckets = buckets_;
   buckets_ = other.buckets_;
   other.buckets_ = tempBuckets;
@@ -240,54 +177,39 @@ ValueInternalMap::swap( ValueInternalMap &other )
   other.itemCount_ = tempItemCount;
 }
 
-
-void 
-ValueInternalMap::clear()
-{
+void ValueInternalMap::clear() {
   ValueInternalMap dummy;
   swap(dummy);
 }
 
-
-ValueInternalMap::BucketIndex 
-ValueInternalMap::size() const
-{
+ValueInternalMap::BucketIndex ValueInternalMap::size() const {
   return itemCount_;
 }
 
-bool 
-ValueInternalMap::reserveDelta( BucketIndex growth )
-{
+bool ValueInternalMap::reserveDelta(BucketIndex growth) {
   return reserve(itemCount_ + growth);
 }
 
-bool 
-ValueInternalMap::reserve( BucketIndex newItemCount )
-{
-   if ( !buckets_  &&  newItemCount > 0 )
-   {
+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;
+  //   BucketIndex idealBucketCount = (newItemCount +
+  // ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink;
   return true;
 }
 
-
-const Value *
-ValueInternalMap::find( const char *key ) const
-{
+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 )
-      {
+  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)
@@ -297,31 +219,20 @@ ValueInternalMap::find( const char *key ) const
   return 0;
 }
 
-
-Value *
-ValueInternalMap::find( const char *key )
-{
+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 )
-{
+Value& ValueInternalMap::resolveReference(const char* key, bool isStatic) {
   HashKey hashedKey = hash(key);
-   if ( bucketsSize_ )
-   {
+  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 )
-         {
+    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)
@@ -334,25 +245,18 @@ ValueInternalMap::resolveReference( const char *key,
   return unsafeAdd(key, isStatic, hashedKey);
 }
 
-
-void 
-ValueInternalMap::remove( const char *key )
-{
+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_ )
-   {
+  for (ValueInternalLink* link = &buckets_[bucketIndex]; link != 0;
+       link = link->next_) {
     BucketIndex index;
-      for ( index =0; index < ValueInternalLink::itemPerLink; ++index )
-      {
+    for (index = 0; index < ValueInternalLink::itemPerLink; ++index) {
       if (link->items_[index].isItemAvailable())
         return;
-         if ( strcmp( key, link->keys_[index] ) == 0 )
-         {
+      if (strcmp(key, link->keys_[index]) == 0) {
         doActualRemove(link, index, bucketIndex);
         return;
       }
@@ -360,18 +264,16 @@ ValueInternalMap::remove( const char *key )
   }
 }
 
-void 
-ValueInternalMap::doActualRemove( ValueInternalLink *link, 
+void ValueInternalMap::doActualRemove(ValueInternalLink* link,
                                       BucketIndex index,
-                                  BucketIndex bucketIndex )
-{
+                                      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)
+  // 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; 
+  for (; lastItemIndex < ValueInternalLink::itemPerLink;
        ++lastItemIndex) // may be optimized with dicotomic search
   {
     if (lastLink->items_[lastItemIndex].isItemAvailable())
@@ -392,9 +294,7 @@ ValueInternalMap::doActualRemove( ValueInternalLink *link,
       linkPreviousToLast->next_ = 0;
       lastLink = linkPreviousToLast;
     }
-   }
-   else
-   {
+  } else {
     Value dummy;
     valueToPreserve->swap(dummy); // restore deleted to default Value.
     valueToPreserve->setItemUsed(false);
@@ -402,10 +302,8 @@ ValueInternalMap::doActualRemove( ValueInternalLink *link,
   --itemCount_;
 }
 
-
 ValueInternalLink*&
-ValueInternalMap::getLastLinkInBucket( BucketIndex bucketIndex )
-{
+ValueInternalMap::getLastLinkInBucket(BucketIndex bucketIndex) {
   if (bucketIndex == bucketsSize_ - 1)
     return tailLink_;
   ValueInternalLink*& previous = buckets_[bucketIndex + 1].previous_;
@@ -414,13 +312,10 @@ ValueInternalMap::getLastLinkInBucket( BucketIndex bucketIndex )
   return previous;
 }
 
-
-Value &
-ValueInternalMap::setNewItem( const char *key, 
+Value& ValueInternalMap::setNewItem(const char* key,
                                     bool isStatic,
                                     ValueInternalLink* link,
-                              BucketIndex index )
-{
+                                    BucketIndex index) {
   char* duplicatedKey = makeMemberName(key);
   ++itemCount_;
   link->keys_[index] = duplicatedKey;
@@ -429,19 +324,15 @@ ValueInternalMap::setNewItem( const char *key,
   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." );
+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 )
-   {
+  for (index = 0; index < ValueInternalLink::itemPerLink; ++index) {
     if (link->items_[index].isItemAvailable())
       break;
   }
@@ -456,38 +347,31 @@ ValueInternalMap::unsafeAdd( const char *key,
   return setNewItem(key, isStatic, link, index);
 }
 
-
-ValueInternalMap::HashKey 
-ValueInternalMap::hash( const char *key ) const
-{
+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 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.
+  // 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) )
-   {
+  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) )
-   {
+  for (; !equals(it, itEnd); increment(it)) {
     const Value* otherValue = other.find(key(it));
     int valueDiff = value(it).compare(*otherValue);
     if (valueDiff != 0)
@@ -496,42 +380,30 @@ ValueInternalMap::compare( const ValueInternalMap &other ) const
   return 0;
 }
 
-
-void 
-ValueInternalMap::makeBeginIterator( IteratorState &it ) const
-{
+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
-{
+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_;
+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 )
-{
+void ValueInternalMap::incrementBucket(IteratorState& iterator) {
   ++iterator.bucketIndex_;
-   JSON_ASSERT_MESSAGE( iterator.bucketIndex_ <= iterator.map_->bucketsSize_,
+  JSON_ASSERT_MESSAGE(
+      iterator.bucketIndex_ <= iterator.map_->bucketsSize_,
       "ValueInternalMap::increment(): attempting to iterate beyond end.");
   if (iterator.bucketIndex_ == iterator.map_->bucketsSize_)
     iterator.link_ = 0;
@@ -540,36 +412,29 @@ ValueInternalMap::incrementBucket( IteratorState &iterator )
   iterator.itemIndex_ = 0;
 }
 
-
-void 
-ValueInternalMap::increment( IteratorState &iterator )
-{
-   JSON_ASSERT_MESSAGE( iterator.map_, "Attempting to iterator using invalid iterator." );
+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,
+  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() )
-   {
+  } 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." );
+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_;
@@ -577,34 +442,27 @@ ValueInternalMap::decrement( IteratorState &iterator )
   }
 }
 
-
-const char *
-ValueInternalMap::key( const IteratorState &iterator )
-{
-   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+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." );
+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." );
+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 ValueInternalMap::distance(const IteratorState& x, const IteratorState& y) {
   int offset = 0;
   IteratorState it = x;
   while (!equals(it, y))

src/lib_json/json_tool.h

@@ -15,33 +15,24 @@
 namespace Json {
 
 /// Converts a unicode code-point to UTF-8.
-static inline std::string 
-codePointToUTF8(unsigned int cp)
-{
+static inline std::string codePointToUTF8(unsigned int cp) {
   std::string result;
 
   // based on description from http://en.wikipedia.org/wiki/UTF-8
 
-   if (cp <= 0x7f) 
-   {
+  if (cp <= 0x7f) {
     result.resize(1);
     result[0] = static_cast<char>(cp);
-   } 
-   else if (cp <= 0x7FF) 
-   {
+  } else if (cp <= 0x7FF) {
     result.resize(2);
     result[1] = static_cast<char>(0x80 | (0x3f & cp));
     result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
-   } 
-   else if (cp <= 0xFFFF) 
-   {
+  } else if (cp <= 0xFFFF) {
     result.resize(3);
     result[2] = static_cast<char>(0x80 | (0x3f & cp));
     result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
     result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
-   }
-   else if (cp <= 0x10FFFF) 
-   {
+  } else if (cp <= 0x10FFFF) {
     result.resize(4);
     result[3] = static_cast<char>(0x80 | (0x3f & cp));
     result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
@@ -52,40 +43,43 @@ codePointToUTF8(unsigned int cp)
   return result;
 }
 
-
 /// Returns true if ch is a control character (in range [0,32[).
-static inline bool 
-isControlCharacter(char ch)
-{
-   return ch > 0 && ch <= 0x1F;
-}
-
+static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
 
 enum {
-   /// Constant that specify the size of the buffer that must be passed to uintToString.
+  /// Constant that specify the size of the buffer that must be passed to
+  /// uintToString.
   uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
 };
 
 // Defines a char buffer for use with uintToString().
 typedef char UIntToStringBuffer[uintToStringBufferSize];
 
-
 /** Converts an unsigned integer to string.
  * @param value Unsigned interger to convert to string
  * @param current Input/Output string buffer.
  *        Must have at least uintToStringBufferSize chars free.
  */
-static inline void 
-uintToString( LargestUInt value, 
-              char *&current )
-{
+static inline void uintToString(LargestUInt value, char*& current) {
   *--current = 0;
-   do
-   {
+  do {
     *--current = char(value % 10) + '0';
     value /= 10;
+  } while (value != 0);
+}
+
+/** Change ',' to '.' everywhere in buffer.
+ *
+ * We had a sophisticated way, but it did not work in WinCE.
+ * @see https://github.com/open-source-parsers/jsoncpp/pull/9
+ */
+static inline void fixNumericLocale(char* begin, char* end) {
+  while (begin < end) {
+    if (*begin == ',') {
+      *begin = '.';
+    }
+    ++begin;
   }
-   while ( value != 0 );
 }
 
 } // namespace Json {

src/lib_json/json_valueiterator.inl

@@ -17,43 +17,33 @@ namespace Json {
 
 ValueIteratorBase::ValueIteratorBase()
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   : current_()
-   , isNull_( true )
-{
+    : current_(), isNull_(true) {
 }
 #else
-   : isArray_( true )
-   , isNull_( true )
-{
+    : 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 )
-{
-}
+ValueIteratorBase::ValueIteratorBase(
+    const Value::ObjectValues::iterator& current)
+    : current_(current), isNull_(false) {}
 #else
-ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
-   : isArray_( true )
-{
+ValueIteratorBase::ValueIteratorBase(
+    const ValueInternalArray::IteratorState& state)
+    : isArray_(true) {
   iterator_.array_ = state;
 }
 
-
-ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
-   : isArray_( false )
-{
+ValueIteratorBase::ValueIteratorBase(
+    const ValueInternalMap::IteratorState& state)
+    : isArray_(false) {
   iterator_.map_ = state;
 }
 #endif
 
-Value &
-ValueIteratorBase::deref() const
-{
+Value& ValueIteratorBase::deref() const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   return current_->second;
 #else
@@ -63,10 +53,7 @@ ValueIteratorBase::deref() const
 #endif
 }
 
-
-void 
-ValueIteratorBase::increment()
-{
+void ValueIteratorBase::increment() {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   ++current_;
 #else
@@ -76,10 +63,7 @@ ValueIteratorBase::increment()
 #endif
 }
 
-
-void 
-ValueIteratorBase::decrement()
-{
+void ValueIteratorBase::decrement() {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   --current_;
 #else
@@ -89,10 +73,8 @@ ValueIteratorBase::decrement()
 #endif
 }
 
-
 ValueIteratorBase::difference_type
-ValueIteratorBase::computeDistance( const SelfType &other ) const
-{
+ValueIteratorBase::computeDistance(const SelfType& other) const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
 #ifdef JSON_USE_CPPTL_SMALLMAP
   return current_ - other.current_;
@@ -102,37 +84,33 @@ ValueIteratorBase::computeDistance( const SelfType &other ) const
   // std::map::iterator. As begin() and end() are two instance
   // of the default std::map::iterator, they can not be compared.
   // To allow this, we handle this comparison specifically.
-   if ( isNull_  &&  other.isNull_ )
-   {
+  if (isNull_ && other.isNull_) {
     return 0;
   }
 
-
-   // Usage of std::distance is not portable (does not compile with Sun Studio 12 RogueWave STL,
+  // Usage of std::distance is not portable (does not compile with Sun Studio 12
+  // RogueWave STL,
   // which is the one used by default).
   // Using a portable hand-made version for non random iterator instead:
   //   return difference_type( std::distance( current_, other.current_ ) );
   difference_type myDistance = 0;
-   for ( Value::ObjectValues::iterator it = current_; it != other.current_; ++it )
-   {
+  for (Value::ObjectValues::iterator it = current_; it != other.current_;
+       ++it) {
     ++myDistance;
   }
   return myDistance;
 #endif
 #else
   if (isArray_)
-      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
+    return ValueInternalArray::distance(iterator_.array_,
+                                        other.iterator_.array_);
   return ValueInternalMap::distance(iterator_.map_, other.iterator_.map_);
 #endif
 }
 
-
-bool 
-ValueIteratorBase::isEqual( const SelfType &other ) const
-{
+bool ValueIteratorBase::isEqual(const SelfType& other) const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-   if ( isNull_ )
-   {
+  if (isNull_) {
     return other.isNull_;
   }
   return current_ == other.current_;
@@ -143,12 +121,10 @@ ValueIteratorBase::isEqual( const SelfType &other ) const
 #endif
 }
 
-
-void 
-ValueIteratorBase::copy( const SelfType &other )
-{
+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_;
@@ -156,14 +132,10 @@ ValueIteratorBase::copy( const SelfType &other )
 #endif
 }
 
-
-Value 
-ValueIteratorBase::key() const
-{
+Value ValueIteratorBase::key() const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   const Value::CZString czstring = (*current_).first;
-   if ( czstring.c_str() )
-   {
+  if (czstring.c_str()) {
     if (czstring.isStaticString())
       return Value(StaticString(czstring.c_str()));
     return Value(czstring.c_str());
@@ -180,10 +152,7 @@ ValueIteratorBase::key() const
 #endif
 }
 
-
-UInt 
-ValueIteratorBase::index() const
-{
+UInt ValueIteratorBase::index() const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   const Value::CZString czstring = (*current_).first;
   if (!czstring.c_str())
@@ -196,10 +165,7 @@ ValueIteratorBase::index() const
 #endif
 }
 
-
-const char *
-ValueIteratorBase::memberName() const
-{
+const char* ValueIteratorBase::memberName() const {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
   const char* name = (*current_).first.c_str();
   return name ? name : "";
@@ -210,7 +176,6 @@ ValueIteratorBase::memberName() const
 #endif
 }
 
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -219,36 +184,28 @@ ValueIteratorBase::memberName() const
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueConstIterator::ValueConstIterator()
-{
-}
-
+ValueConstIterator::ValueConstIterator() {}
 
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
-   : ValueIteratorBase( current )
-{
-}
+ValueConstIterator::ValueConstIterator(
+    const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
 #else
-ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
+ValueConstIterator::ValueConstIterator(
+    const ValueInternalArray::IteratorState& state)
+    : ValueIteratorBase(state) {}
 
-ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
+ValueConstIterator::ValueConstIterator(
+    const ValueInternalMap::IteratorState& state)
+    : ValueIteratorBase(state) {}
 #endif
 
-ValueConstIterator &
-ValueConstIterator::operator =( const ValueIteratorBase &other )
-{
+ValueConstIterator& ValueConstIterator::
+operator=(const ValueIteratorBase& other) {
   copy(other);
   return *this;
 }
 
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -257,41 +214,26 @@ ValueConstIterator::operator =( const ValueIteratorBase &other )
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueIterator::ValueIterator()
-{
-}
-
+ValueIterator::ValueIterator() {}
 
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
 ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
-   : ValueIteratorBase( current )
-{
-}
+    : ValueIteratorBase(current) {}
 #else
 ValueIterator::ValueIterator(const ValueInternalArray::IteratorState& state)
-   : ValueIteratorBase( state )
-{
-}
+    : ValueIteratorBase(state) {}
 
 ValueIterator::ValueIterator(const ValueInternalMap::IteratorState& state)
-   : ValueIteratorBase( state )
-{
-}
+    : ValueIteratorBase(state) {}
 #endif
 
 ValueIterator::ValueIterator(const ValueConstIterator& other)
-   : ValueIteratorBase( other )
-{
-}
+    : ValueIteratorBase(other) {}
 
 ValueIterator::ValueIterator(const ValueIterator& other)
-   : ValueIteratorBase( other )
-{
-}
+    : ValueIteratorBase(other) {}
 
-ValueIterator &
-ValueIterator::operator =( const SelfType &other )
-{
+ValueIterator& ValueIterator::operator=(const SelfType& other) {
   copy(other);
   return *this;
 }

src/lib_json/json_writer.cpp

@@ -1,4 +1,4 @@
-// Copyright 2007-2010 Baptiste Lepilleur
+// Copyright 2011 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
@@ -11,29 +11,32 @@
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
-#include <iostream>
 #include <sstream>
 #include <iomanip>
+#include <math.h>
 
-#if _MSC_VER >= 1400 // VC++ 8.0
-#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
+#include <float.h>
+#define isfinite _finite
+#define snprintf _snprintf
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+// Disable warning about strdup being deprecated.
+#pragma warning(disable : 4996)
 #endif
 
 namespace Json {
 
-static bool containsControlCharacter( const char* str )
-{
-   while ( *str ) 
-   {
+static bool containsControlCharacter(const char* str) {
+  while (*str) {
     if (isControlCharacter(*(str++)))
       return true;
   }
   return false;
 }
 
-
-std::string valueToString( LargestInt value )
-{
+std::string valueToString(LargestInt value) {
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   bool isNegative = value < 0;
@@ -46,9 +49,7 @@ std::string valueToString( LargestInt value )
   return current;
 }
 
-
-std::string valueToString( LargestUInt value )
-{
+std::string valueToString(LargestUInt value) {
   UIntToStringBuffer buffer;
   char* current = buffer + sizeof(buffer);
   uintToString(value, current);
@@ -58,81 +59,72 @@ std::string valueToString( LargestUInt value )
 
 #if defined(JSON_HAS_INT64)
 
-std::string valueToString( Int value )
-{
+std::string valueToString(Int value) {
   return valueToString(LargestInt(value));
 }
 
-
-std::string valueToString( UInt value )
-{
+std::string valueToString(UInt value) {
   return valueToString(LargestUInt(value));
 }
 
 #endif // # if defined(JSON_HAS_INT64)
 
-
-std::string valueToString( double value )
-{
+std::string valueToString(double value) {
+  // Allocate a buffer that is more than large enough to store the 16 digits of
+  // precision requested below.
   char buffer[32];
-#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning. 
-   sprintf_s(buffer, sizeof(buffer), "%#.16g", value); 
+  int len = -1;
+
+// Print into the buffer. We need not request the alternative representation
+// that always has a decimal point because JSON doesn't distingish the
+// concepts of reals and integers.
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
+                                                      // visual studio 2005 to
+                                                      // avoid warning.
+#if defined(WINCE)
+  len = _snprintf(buffer, sizeof(buffer), "%.16g", value);
 #else
-   sprintf(buffer, "%#.16g", value); 
+  len = sprintf_s(buffer, sizeof(buffer), "%.16g", value);
 #endif
-   char* ch = buffer + strlen(buffer) - 1;
-   if (*ch != '0') return buffer; // nothing to truncate, so save time
-   while(ch > buffer && *ch == '0'){
-     --ch;
-   }
-   char* last_nonzero = ch;
-   while(ch >= buffer){
-     switch(*ch){
-     case '0':
-     case '1':
-     case '2':
-     case '3':
-     case '4':
-     case '5':
-     case '6':
-     case '7':
-     case '8':
-     case '9':
-       --ch;
-       continue;
-     case '.':
-       // Truncate zeroes to save bytes in output, but keep one.
-       *(last_nonzero+2) = '\0';
-       return buffer;
-     default:
-       return buffer;
+#else
+  if (isfinite(value)) {
+    len = snprintf(buffer, sizeof(buffer), "%.16g", value);
+  } else {
+    // IEEE standard states that NaN values will not compare to themselves
+    if (value != value) {
+      len = snprintf(buffer, sizeof(buffer), "null");
+    } else if (value < 0) {
+      len = snprintf(buffer, sizeof(buffer), "-1e+9999");
+    } else {
+      len = snprintf(buffer, sizeof(buffer), "1e+9999");
     }
+    // For those, we do not need to call fixNumLoc, but it is fast.
   }
+#endif
+  assert(len >= 0);
+  fixNumericLocale(buffer, buffer + len);
   return buffer;
 }
 
+std::string valueToString(bool value) { return value ? "true" : "false"; }
 
-std::string valueToString( bool value )
-{
-   return value ? "true" : "false";
-}
-
-std::string valueToQuotedString( const char *value )
-{
+std::string valueToQuotedString(const char* value) {
+  if (value == NULL)
+    return "";
   // Not sure how to handle unicode...
-   if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter( value ))
+  if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL &&
+      !containsControlCharacter(value))
     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 = strlen(value)*2 + 3; // allescaped+quotes+NULL
+  std::string::size_type maxsize =
+      strlen(value) * 2 + 3; // allescaped+quotes+NULL
   std::string result;
   result.reserve(maxsize); // to avoid lots of mallocs
   result += "\"";
-   for (const char* c=value; *c != 0; ++c)
-   {
-      switch(*c)
-      {
+  for (const char* c = value; *c != 0; ++c) {
+    switch (*c) {
     case '\"':
       result += "\\\"";
       break;
@@ -163,14 +155,12 @@ std::string valueToQuotedString( const char *value )
     // Should add a flag to allow this compatibility mode and prevent this
     // sequence from occurring.
     default:
-            if ( isControlCharacter( *c ) )
-            {
+      if (isControlCharacter(*c)) {
         std::ostringstream oss;
-               oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*c);
+        oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+            << std::setw(4) << static_cast<int>(*c);
         result += oss.str();
-            }
-            else
-            {
+      } else {
         result += *c;
       }
       break;
@@ -182,43 +172,33 @@ std::string valueToQuotedString( const char *value )
 
 // Class Writer
 // //////////////////////////////////////////////////////////////////
-Writer::~Writer()
-{
-}
-
+Writer::~Writer() {}
 
 // Class FastWriter
 // //////////////////////////////////////////////////////////////////
 
 FastWriter::FastWriter()
-   : yamlCompatiblityEnabled_( false )
-{
-}
+    : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
+      omitEndingLineFeed_(false) {}
 
+void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
 
-void 
-FastWriter::enableYAMLCompatibility()
-{
-   yamlCompatiblityEnabled_ = true;
-}
+void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
 
+void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
 
-std::string 
-FastWriter::write( const Value &root )
-{
+std::string FastWriter::write(const Value& root) {
   document_ = "";
   writeValue(root);
+  if (!omitEndingLineFeed_)
     document_ += "\n";
   return document_;
 }
 
-
-void 
-FastWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
+void FastWriter::writeValue(const Value& value) {
+  switch (value.type()) {
   case nullValue:
+    if (!dropNullPlaceholders_)
       document_ += "null";
     break;
   case intValue:
@@ -236,55 +216,40 @@ FastWriter::writeValue( const Value &value )
   case booleanValue:
     document_ += valueToString(value.asBool());
     break;
-   case arrayValue:
-      {
+  case arrayValue: {
     document_ += "[";
     int size = value.size();
-         for ( int index =0; index < size; ++index )
-         {
+    for (int index = 0; index < size; ++index) {
       if (index > 0)
         document_ += ",";
       writeValue(value[index]);
     }
     document_ += "]";
-      }
-      break;
-   case objectValue:
-      {
+  } break;
+  case objectValue: {
     Value::Members members(value.getMemberNames());
     document_ += "{";
-         for ( Value::Members::iterator it = members.begin(); 
-               it != members.end(); 
-               ++it )
-         {
+    for (Value::Members::iterator it = members.begin(); it != members.end();
+         ++it) {
       const std::string& name = *it;
       if (it != members.begin())
         document_ += ",";
       document_ += valueToQuotedString(name.c_str());
-            document_ += yamlCompatiblityEnabled_ ? ": " 
-                                                  : ":";
+      document_ += yamlCompatiblityEnabled_ ? ": " : ":";
       writeValue(value[name]);
     }
     document_ += "}";
-      }
-      break;
+  } break;
   }
 }
 
-
 // Class StyledWriter
 // //////////////////////////////////////////////////////////////////
 
 StyledWriter::StyledWriter()
-   : rightMargin_( 74 )
-   , indentSize_( 3 )
-{
-}
+    : rightMargin_(74), indentSize_(3), addChildValues_() {}
 
-
-std::string 
-StyledWriter::write( const Value &root )
-{
+std::string StyledWriter::write(const Value& root) {
   document_ = "";
   addChildValues_ = false;
   indentString_ = "";
@@ -295,12 +260,8 @@ StyledWriter::write( const Value &root )
   return document_;
 }
 
-
-void 
-StyledWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
+void StyledWriter::writeValue(const Value& value) {
+  switch (value.type()) {
   case nullValue:
     pushValue("null");
     break;
@@ -322,26 +283,22 @@ StyledWriter::writeValue( const Value &value )
   case arrayValue:
     writeArrayValue(value);
     break;
-   case objectValue:
-      {
+  case objectValue: {
     Value::Members members(value.getMemberNames());
     if (members.empty())
       pushValue("{}");
-         else
-         {
+    else {
       writeWithIndent("{");
       indent();
       Value::Members::iterator it = members.begin();
-            for (;;)
-            {
+      for (;;) {
         const std::string& name = *it;
         const Value& childValue = value[name];
         writeCommentBeforeValue(childValue);
         writeWithIndent(valueToQuotedString(name.c_str()));
         document_ += " : ";
         writeValue(childValue);
-               if ( ++it == members.end() )
-               {
+        if (++it == members.end()) {
           writeCommentAfterValueOnSameLine(childValue);
           break;
         }
@@ -351,40 +308,31 @@ StyledWriter::writeValue( const Value &value )
       unindent();
       writeWithIndent("}");
     }
-      }
-      break;
+  } break;
   }
 }
 
-
-void 
-StyledWriter::writeArrayValue( const Value &value )
-{
+void StyledWriter::writeArrayValue(const Value& value) {
   unsigned size = value.size();
   if (size == 0)
     pushValue("[]");
-   else
-   {
+  else {
     bool isArrayMultiLine = isMultineArray(value);
-      if ( isArrayMultiLine )
-      {
+    if (isArrayMultiLine) {
       writeWithIndent("[");
       indent();
       bool hasChildValue = !childValues_.empty();
       unsigned index = 0;
-         for (;;)
-         {
+      for (;;) {
         const Value& childValue = value[index];
         writeCommentBeforeValue(childValue);
         if (hasChildValue)
           writeWithIndent(childValues_[index]);
-            else
-            {
+        else {
           writeIndent();
           writeValue(childValue);
         }
-            if ( ++index == size )
-            {
+        if (++index == size) {
           writeCommentAfterValueOnSameLine(childValue);
           break;
         }
@@ -393,13 +341,11 @@ StyledWriter::writeArrayValue( const Value &value )
       }
       unindent();
       writeWithIndent("]");
-      }
-      else // output on a single line
+    } else // output on a single line
     {
       assert(childValues_.size() == size);
       document_ += "[ ";
-         for ( unsigned index =0; index < size; ++index )
-         {
+      for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
           document_ += ", ";
         document_ += childValues_[index];
@@ -409,18 +355,14 @@ StyledWriter::writeArrayValue( const Value &value )
   }
 }
 
-
-bool 
-StyledWriter::isMultineArray( const Value &value )
-{
+bool StyledWriter::isMultineArray(const Value& value) {
   int size = value.size();
   bool isMultiLine = size * 3 >= rightMargin_;
   childValues_.clear();
-   for ( int index =0; index < size  &&  !isMultiLine; ++index )
-   {
+  for (int index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
-      isMultiLine = isMultiLine  ||
-                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+    isMultiLine =
+        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
                         childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
@@ -428,11 +370,9 @@ StyledWriter::isMultineArray( const Value &value )
     childValues_.reserve(size);
     addChildValues_ = true;
     int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
-      for ( int index =0; index < size  &&  !isMultiLine; ++index )
-      {
+    for (int index = 0; index < size; ++index) {
       writeValue(value[index]);
       lineLength += int(childValues_[index].length());
-         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
     }
     addChildValues_ = false;
     isMultiLine = isMultiLine || lineLength >= rightMargin_;
@@ -440,22 +380,15 @@ StyledWriter::isMultineArray( const Value &value )
   return isMultiLine;
 }
 
-
-void 
-StyledWriter::pushValue( const std::string &value )
-{
+void StyledWriter::pushValue(const std::string& value) {
   if (addChildValues_)
     childValues_.push_back(value);
   else
     document_ += value;
 }
 
-
-void 
-StyledWriter::writeIndent()
-{
-   if ( !document_.empty() )
-   {
+void StyledWriter::writeIndent() {
+  if (!document_.empty()) {
     char last = document_[document_.length() - 1];
     if (last == ' ') // already indented
       return;
@@ -465,102 +398,81 @@ StyledWriter::writeIndent()
   document_ += indentString_;
 }
 
-
-void 
-StyledWriter::writeWithIndent( const std::string &value )
-{
+void StyledWriter::writeWithIndent(const std::string& value) {
   writeIndent();
   document_ += value;
 }
 
+void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); }
 
-void 
-StyledWriter::indent()
-{
-   indentString_ += std::string( indentSize_, ' ' );
-}
-
-
-void 
-StyledWriter::unindent()
-{
+void StyledWriter::unindent() {
   assert(int(indentString_.size()) >= indentSize_);
   indentString_.resize(indentString_.size() - indentSize_);
 }
 
-
-void 
-StyledWriter::writeCommentBeforeValue( const Value &root )
-{
+void StyledWriter::writeCommentBeforeValue(const Value& root) {
   if (!root.hasComment(commentBefore))
     return;
-   document_ += normalizeEOL( root.getComment( commentBefore ) );
+
+  document_ += "\n";
+  writeIndent();
+  std::string normalizedComment = normalizeEOL(root.getComment(commentBefore));
+  std::string::const_iterator iter = normalizedComment.begin();
+  while (iter != normalizedComment.end()) {
+    document_ += *iter;
+    if (*iter == '\n' && *(iter + 1) == '/')
+      writeIndent();
+    ++iter;
+  }
+
+  // Comments are stripped of newlines, so add one here
   document_ += "\n";
 }
 
-
-void 
-StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
   if (root.hasComment(commentAfterOnSameLine))
     document_ += " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
 
-   if ( root.hasComment( commentAfter ) )
-   {
+  if (root.hasComment(commentAfter)) {
     document_ += "\n";
     document_ += normalizeEOL(root.getComment(commentAfter));
     document_ += "\n";
   }
 }
 
-
-bool 
-StyledWriter::hasCommentForValue( const Value &value )
-{
-   return value.hasComment( commentBefore )
-          ||  value.hasComment( commentAfterOnSameLine )
-          ||  value.hasComment( commentAfter );
+bool StyledWriter::hasCommentForValue(const Value& value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
-
-std::string 
-StyledWriter::normalizeEOL( const std::string &text )
-{
+std::string StyledWriter::normalizeEOL(const std::string& text) {
   std::string normalized;
   normalized.reserve(text.length());
   const char* begin = text.c_str();
   const char* end = begin + text.length();
   const char* current = begin;
-   while ( current != end )
-   {
+  while (current != end) {
     char c = *current++;
     if (c == '\r') // mac or dos EOL
     {
       if (*current == '\n') // convert dos EOL
         ++current;
       normalized += '\n';
-      }
-      else // handle unix EOL & other char
+    } else // handle unix EOL & other char
       normalized += c;
   }
   return normalized;
 }
 
-
 // Class StyledStreamWriter
 // //////////////////////////////////////////////////////////////////
 
 StyledStreamWriter::StyledStreamWriter(std::string indentation)
-   : document_(NULL)
-   , rightMargin_( 74 )
-   , indentation_( indentation )
-{
-}
+    : document_(NULL), rightMargin_(74), indentation_(indentation),
+      addChildValues_() {}
 
-
-void
-StyledStreamWriter::write( std::ostream &out, const Value &root )
-{
+void StyledStreamWriter::write(std::ostream& out, const Value& root) {
   document_ = &out;
   addChildValues_ = false;
   indentString_ = "";
@@ -571,12 +483,8 @@ StyledStreamWriter::write( std::ostream &out, const Value &root )
   document_ = NULL; // Forget the stream, for safety.
 }
 
-
-void 
-StyledStreamWriter::writeValue( const Value &value )
-{
-   switch ( value.type() )
-   {
+void StyledStreamWriter::writeValue(const Value& value) {
+  switch (value.type()) {
   case nullValue:
     pushValue("null");
     break;
@@ -598,26 +506,22 @@ StyledStreamWriter::writeValue( const Value &value )
   case arrayValue:
     writeArrayValue(value);
     break;
-   case objectValue:
-      {
+  case objectValue: {
     Value::Members members(value.getMemberNames());
     if (members.empty())
       pushValue("{}");
-         else
-         {
+    else {
       writeWithIndent("{");
       indent();
       Value::Members::iterator it = members.begin();
-            for (;;)
-            {
+      for (;;) {
         const std::string& name = *it;
         const Value& childValue = value[name];
         writeCommentBeforeValue(childValue);
         writeWithIndent(valueToQuotedString(name.c_str()));
         *document_ << " : ";
         writeValue(childValue);
-               if ( ++it == members.end() )
-               {
+        if (++it == members.end()) {
           writeCommentAfterValueOnSameLine(childValue);
           break;
         }
@@ -627,40 +531,31 @@ StyledStreamWriter::writeValue( const Value &value )
       unindent();
       writeWithIndent("}");
     }
-      }
-      break;
+  } break;
   }
 }
 
-
-void 
-StyledStreamWriter::writeArrayValue( const Value &value )
-{
+void StyledStreamWriter::writeArrayValue(const Value& value) {
   unsigned size = value.size();
   if (size == 0)
     pushValue("[]");
-   else
-   {
+  else {
     bool isArrayMultiLine = isMultineArray(value);
-      if ( isArrayMultiLine )
-      {
+    if (isArrayMultiLine) {
       writeWithIndent("[");
       indent();
       bool hasChildValue = !childValues_.empty();
       unsigned index = 0;
-         for (;;)
-         {
+      for (;;) {
         const Value& childValue = value[index];
         writeCommentBeforeValue(childValue);
         if (hasChildValue)
           writeWithIndent(childValues_[index]);
-            else
-            {
+        else {
           writeIndent();
           writeValue(childValue);
         }
-            if ( ++index == size )
-            {
+        if (++index == size) {
           writeCommentAfterValueOnSameLine(childValue);
           break;
         }
@@ -669,13 +564,11 @@ StyledStreamWriter::writeArrayValue( const Value &value )
       }
       unindent();
       writeWithIndent("]");
-      }
-      else // output on a single line
+    } else // output on a single line
     {
       assert(childValues_.size() == size);
       *document_ << "[ ";
-         for ( unsigned index =0; index < size; ++index )
-         {
+      for (unsigned index = 0; index < size; ++index) {
         if (index > 0)
           *document_ << ", ";
         *document_ << childValues_[index];
@@ -685,18 +578,14 @@ StyledStreamWriter::writeArrayValue( const Value &value )
   }
 }
 
-
-bool 
-StyledStreamWriter::isMultineArray( const Value &value )
-{
+bool StyledStreamWriter::isMultineArray(const Value& value) {
   int size = value.size();
   bool isMultiLine = size * 3 >= rightMargin_;
   childValues_.clear();
-   for ( int index =0; index < size  &&  !isMultiLine; ++index )
-   {
+  for (int index = 0; index < size && !isMultiLine; ++index) {
     const Value& childValue = value[index];
-      isMultiLine = isMultiLine  ||
-                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+    isMultiLine =
+        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
                         childValue.size() > 0);
   }
   if (!isMultiLine) // check if line length > max line length
@@ -704,11 +593,9 @@ StyledStreamWriter::isMultineArray( const Value &value )
     childValues_.reserve(size);
     addChildValues_ = true;
     int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
-      for ( int index =0; index < size  &&  !isMultiLine; ++index )
-      {
+    for (int index = 0; index < size; ++index) {
       writeValue(value[index]);
       lineLength += int(childValues_[index].length());
-         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
     }
     addChildValues_ = false;
     isMultiLine = isMultiLine || lineLength >= rightMargin_;
@@ -716,20 +603,14 @@ StyledStreamWriter::isMultineArray( const Value &value )
   return isMultiLine;
 }
 
-
-void 
-StyledStreamWriter::pushValue( const std::string &value )
-{
+void StyledStreamWriter::pushValue(const std::string& value) {
   if (addChildValues_)
     childValues_.push_back(value);
   else
     *document_ << value;
 }
 
-
-void 
-StyledStreamWriter::writeIndent()
-{
+void StyledStreamWriter::writeIndent() {
   /*
     Some comments in this method would have been nice. ;-)
 
@@ -745,94 +626,65 @@ StyledStreamWriter::writeIndent()
   *document_ << '\n' << indentString_;
 }
 
-
-void 
-StyledStreamWriter::writeWithIndent( const std::string &value )
-{
+void StyledStreamWriter::writeWithIndent(const std::string& value) {
   writeIndent();
   *document_ << value;
 }
 
+void StyledStreamWriter::indent() { indentString_ += indentation_; }
 
-void 
-StyledStreamWriter::indent()
-{
-   indentString_ += indentation_;
-}
-
-
-void 
-StyledStreamWriter::unindent()
-{
+void StyledStreamWriter::unindent() {
   assert(indentString_.size() >= indentation_.size());
   indentString_.resize(indentString_.size() - indentation_.size());
 }
 
-
-void 
-StyledStreamWriter::writeCommentBeforeValue( const Value &root )
-{
+void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
   if (!root.hasComment(commentBefore))
     return;
   *document_ << normalizeEOL(root.getComment(commentBefore));
   *document_ << "\n";
 }
 
-
-void 
-StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
   if (root.hasComment(commentAfterOnSameLine))
     *document_ << " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
 
-   if ( root.hasComment( commentAfter ) )
-   {
+  if (root.hasComment(commentAfter)) {
     *document_ << "\n";
     *document_ << normalizeEOL(root.getComment(commentAfter));
     *document_ << "\n";
   }
 }
 
-
-bool 
-StyledStreamWriter::hasCommentForValue( const Value &value )
-{
-   return value.hasComment( commentBefore )
-          ||  value.hasComment( commentAfterOnSameLine )
-          ||  value.hasComment( commentAfter );
+bool StyledStreamWriter::hasCommentForValue(const Value& value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
 }
 
-
-std::string 
-StyledStreamWriter::normalizeEOL( const std::string &text )
-{
+std::string StyledStreamWriter::normalizeEOL(const std::string& text) {
   std::string normalized;
   normalized.reserve(text.length());
   const char* begin = text.c_str();
   const char* end = begin + text.length();
   const char* current = begin;
-   while ( current != end )
-   {
+  while (current != end) {
     char c = *current++;
     if (c == '\r') // mac or dos EOL
     {
       if (*current == '\n') // convert dos EOL
         ++current;
       normalized += '\n';
-      }
-      else // handle unix EOL & other char
+    } else // handle unix EOL & other char
       normalized += c;
   }
   return normalized;
 }
 
-
-std::ostream& operator<<( std::ostream &sout, const Value &root )
-{
+std::ostream& operator<<(std::ostream& sout, const Value& root) {
   Json::StyledStreamWriter writer;
   writer.write(sout, root);
   return sout;
 }
 
-
 } // namespace Json

src/lib_json/version.h.in

@@ -0,0 +1,14 @@
+// DO NOT EDIT. This file is generated by CMake from  "version"
+// and "version.h.in" files.
+// Run CMake configure step to update it.
+#ifndef JSON_VERSION_H_INCLUDED
+# define JSON_VERSION_H_INCLUDED
+
+# define JSONCPP_VERSION_STRING "@JSONCPP_VERSION@"
+# define JSONCPP_VERSION_MAJOR @JSONCPP_VERSION_MAJOR@
+# define JSONCPP_VERSION_MINOR @JSONCPP_VERSION_MINOR@
+# define JSONCPP_VERSION_PATCH @JSONCPP_VERSION_PATCH@
+# define JSONCPP_VERSION_QUALIFIER
+# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
+
+#endif // JSON_VERSION_H_INCLUDED

src/test_lib_json/CMakeLists.txt

@@ -0,0 +1,22 @@
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+  ADD_DEFINITIONS( -DJSON_DLL )
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+ADD_EXECUTABLE( jsoncpp_test 
+                jsontest.cpp
+                jsontest.h
+                main.cpp
+                )
+
+TARGET_LINK_LIBRARIES(jsoncpp_test jsoncpp_lib)
+
+# Run unit tests in post-build
+# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
+IF(JSONCPP_WITH_POST_BUILD_UNITTEST)
+    ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
+                        POST_BUILD
+                        COMMAND $<TARGET_FILE:jsoncpp_test>)
+ENDIF(JSONCPP_WITH_POST_BUILD_UNITTEST)
+
+SET_TARGET_PROPERTIES(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test) 

src/test_lib_json/jsontest.cpp

@@ -70,42 +70,31 @@
 
 namespace JsonTest {
 
-
 // class TestResult
 // //////////////////////////////////////////////////////////////////
 
 TestResult::TestResult()
-   : predicateId_( 1 )
-   , lastUsedPredicateId_( 0 )
-   , messageTarget_( 0 )
-{
+    : predicateId_(1), lastUsedPredicateId_(0), messageTarget_(0) {
   // The root predicate has id 0
   rootPredicateNode_.id_ = 0;
   rootPredicateNode_.next_ = 0;
   predicateStackTail_ = &rootPredicateNode_;
 }
 
-
-void 
-TestResult::setTestName( const std::string &name )
-{
-   name_ = name;
-}
+void TestResult::setTestName(const std::string& name) { name_ = name; }
 
 TestResult&
-TestResult::addFailure( const char *file, unsigned int line,
-                        const char *expr )
-{
-   /// Walks the PredicateContext stack adding them to failures_ if not already added.
+TestResult::addFailure(const char* file, unsigned int line, const char* expr) {
+  /// Walks the PredicateContext stack adding them to failures_ if not already
+  /// added.
   unsigned int nestingLevel = 0;
   PredicateContext* lastNode = rootPredicateNode_.next_;
-   for ( ; lastNode != 0; lastNode = lastNode->next_ )
-   {
+  for (; lastNode != 0; lastNode = lastNode->next_) {
     if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
     {
       lastUsedPredicateId_ = lastNode->id_;
-         addFailureInfo( lastNode->file_, lastNode->line_, lastNode->expr_,
-                         nestingLevel );
+      addFailureInfo(
+          lastNode->file_, lastNode->line_, lastNode->expr_, nestingLevel);
       // Link the PredicateContext to the failure for message target when
       // popping the PredicateContext.
       lastNode->failure_ = &(failures_.back());
@@ -119,35 +108,28 @@ TestResult::addFailure( const char *file, unsigned int line,
   return *this;
 }
 
-
-void 
-TestResult::addFailureInfo( const char *file, unsigned int line,
-                            const char *expr, unsigned int nestingLevel )
-{
+void TestResult::addFailureInfo(const char* file,
+                                unsigned int line,
+                                const char* expr,
+                                unsigned int nestingLevel) {
   Failure failure;
   failure.file_ = file;
   failure.line_ = line;
-   if ( expr )
-   {
+  if (expr) {
     failure.expr_ = expr;
   }
   failure.nestingLevel_ = nestingLevel;
   failures_.push_back(failure);
 }
 
-
-TestResult &
-TestResult::popPredicateContext()
-{
+TestResult& TestResult::popPredicateContext() {
   PredicateContext* lastNode = &rootPredicateNode_;
-   while ( lastNode->next_ != 0  &&  lastNode->next_->next_ != 0 )
-   {
+  while (lastNode->next_ != 0 && lastNode->next_->next_ != 0) {
     lastNode = lastNode->next_;
   }
   // Set message target to popped failure
   PredicateContext* tail = lastNode->next_;
-   if ( tail != 0  &&  tail->failure_ != 0 )
-   {
+  if (tail != 0 && tail->failure_ != 0) {
     messageTarget_ = tail->failure_;
   }
   // Remove tail from list
@@ -156,79 +138,54 @@ TestResult::popPredicateContext()
   return *this;
 }
 
+bool TestResult::failed() const { return !failures_.empty(); }
 
-bool 
-TestResult::failed() const
-{
-   return !failures_.empty();
-}
-
-
-unsigned int 
-TestResult::getAssertionNestingLevel() const
-{
+unsigned int TestResult::getAssertionNestingLevel() const {
   unsigned int level = 0;
   const PredicateContext* lastNode = &rootPredicateNode_;
-   while ( lastNode->next_ != 0 )
-   {
+  while (lastNode->next_ != 0) {
     lastNode = lastNode->next_;
     ++level;
   }
   return level;
 }
 
-
-void 
-TestResult::printFailure( bool printTestName ) const
-{
-   if ( failures_.empty() )
-   {
+void TestResult::printFailure(bool printTestName) const {
+  if (failures_.empty()) {
     return;
   }
 
-   if ( printTestName )
-   {
+  if (printTestName) {
     printf("* Detail of %s test failure:\n", name_.c_str());
   }
 
   // Print in reverse to display the callstack in the right order
   Failures::const_iterator itEnd = failures_.end();
-   for ( Failures::const_iterator it = failures_.begin(); it != itEnd; ++it )
-   {
+  for (Failures::const_iterator it = failures_.begin(); it != itEnd; ++it) {
     const Failure& failure = *it;
     std::string indent(failure.nestingLevel_ * 2, ' ');
-      if ( failure.file_ )
-      {
+    if (failure.file_) {
       printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);
     }
-      if ( !failure.expr_.empty() )
-      {
+    if (!failure.expr_.empty()) {
       printf("%s\n", failure.expr_.c_str());
-      }
-      else if ( failure.file_ )
-      {
+    } else if (failure.file_) {
       printf("\n");
     }
-      if ( !failure.message_.empty() )
-      {
+    if (!failure.message_.empty()) {
       std::string reindented = indentText(failure.message_, indent + "  ");
       printf("%s\n", reindented.c_str());
     }
   }
 }
 
-
-std::string 
-TestResult::indentText( const std::string &text, 
-                        const std::string &indent )
-{
+std::string TestResult::indentText(const std::string& text,
+                                   const std::string& indent) {
   std::string reindented;
   std::string::size_type lastIndex = 0;
-   while ( lastIndex < text.size() )
-   {
+  while (lastIndex < text.size()) {
     std::string::size_type nextIndex = text.find('\n', lastIndex);
-      if ( nextIndex == std::string::npos )
-      {
+    if (nextIndex == std::string::npos) {
       nextIndex = text.size() - 1;
     }
     reindented += indent;
@@ -238,203 +195,119 @@ TestResult::indentText( const std::string &text,
   return reindented;
 }
 
-
-TestResult &
-TestResult::addToLastFailure( const std::string &message )
-{
-   if ( messageTarget_ != 0 )
-   {
+TestResult& TestResult::addToLastFailure(const std::string& message) {
+  if (messageTarget_ != 0) {
     messageTarget_->message_ += message;
   }
   return *this;
 }
 
+TestResult& TestResult::operator<<(Json::Int64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
 
-TestResult &
-TestResult::operator << ( bool value )
-{
+TestResult& TestResult::operator<<(Json::UInt64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
+
+TestResult& TestResult::operator<<(bool value) {
   return addToLastFailure(value ? "true" : "false");
 }
 
-
-TestResult &
-TestResult::operator << ( int value )
-{
-   char buffer[32];
-   sprintf( buffer, "%d", value );
-   return addToLastFailure( buffer );
-}
-
-
-TestResult &
-TestResult::operator << ( unsigned int value )
-{
-   char buffer[32];
-   sprintf( buffer, "%u", value );
-   return addToLastFailure( buffer );
-}
-
-
-TestResult &
-TestResult::operator << ( double value )
-{
-   char buffer[32];
-   sprintf( buffer, "%16g", value );
-   return addToLastFailure( buffer );
-}
-
-
-TestResult &
-TestResult::operator << ( const char *value )
-{
-   return addToLastFailure( value ? value 
-                                  : "<NULL>" );
-}
-
-
-TestResult &
-TestResult::operator << ( const std::string &value )
-{
-   return addToLastFailure( value );
-}
-
-
-
 // class TestCase
 // //////////////////////////////////////////////////////////////////
 
-TestCase::TestCase()
-   : result_( 0 )
-{
-}
+TestCase::TestCase() : result_(0) {}
 
+TestCase::~TestCase() {}
 
-TestCase::~TestCase()
-{
-}
-
-
-void 
-TestCase::run( TestResult &result )
-{
+void TestCase::run(TestResult& result) {
   result_ = &result;
   runTestCase();
 }
 
-
-
 // class Runner
 // //////////////////////////////////////////////////////////////////
 
-Runner::Runner()
-{
-}
+Runner::Runner() {}
 
-
-Runner &
-Runner::add( TestCaseFactory factory )
-{
+Runner& Runner::add(TestCaseFactory factory) {
   tests_.push_back(factory);
   return *this;
 }
 
-
-unsigned int 
-Runner::testCount() const
-{
+unsigned int Runner::testCount() const {
   return static_cast<unsigned int>(tests_.size());
 }
 
-
-std::string 
-Runner::testNameAt( unsigned int index ) const
-{
+std::string Runner::testNameAt(unsigned int index) const {
   TestCase* test = tests_[index]();
   std::string name = test->testName();
   delete test;
   return name;
 }
 
-
-void 
-Runner::runTestAt( unsigned int index, TestResult &result ) const
-{
+void Runner::runTestAt(unsigned int index, TestResult& result) const {
   TestCase* test = tests_[index]();
   result.setTestName(test->testName());
   printf("Testing %s: ", test->testName());
   fflush(stdout);
 #if JSON_USE_EXCEPTION
-   try 
-   {
+  try {
 #endif // if JSON_USE_EXCEPTION
     test->run(result);
 #if JSON_USE_EXCEPTION
   }
-   catch ( const std::exception &e ) 
-   {
-      result.addFailure( __FILE__, __LINE__, 
-         "Unexpected exception caugth:" ) << e.what();
+  catch (const std::exception& e) {
+    result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
+        << e.what();
   }
 #endif // if JSON_USE_EXCEPTION
   delete test;
-   const char *status = result.failed() ? "FAILED" 
-                                        : "OK";
+  const char* status = result.failed() ? "FAILED" : "OK";
   printf("%s\n", status);
   fflush(stdout);
 }
 
-
-bool 
-Runner::runAllTest( bool printSummary ) const
-{
+bool Runner::runAllTest(bool printSummary) const {
   unsigned int count = testCount();
   std::deque<TestResult> failures;
-   for ( unsigned int index = 0; index < count; ++index )
-   {
+  for (unsigned int index = 0; index < count; ++index) {
     TestResult result;
     runTestAt(index, result);
-      if ( result.failed() )
-      {
+    if (result.failed()) {
       failures.push_back(result);
     }
   }
 
-   if ( failures.empty() )
-   {
-      if ( printSummary )
-      {
+  if (failures.empty()) {
+    if (printSummary) {
       printf("All %d tests passed\n", count);
     }
     return true;
-   }
-   else
-   {
-      for ( unsigned int index = 0; index < failures.size(); ++index )
-      {
+  } else {
+    for (unsigned int index = 0; index < failures.size(); ++index) {
       TestResult& result = failures[index];
       result.printFailure(count > 1);
     }
 
-      if ( printSummary )
-      {
+    if (printSummary) {
       unsigned int failedCount = static_cast<unsigned int>(failures.size());
       unsigned int passedCount = count - failedCount;
-         printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
+      printf("%d/%d tests passed (%d failure(s))\n",
+             passedCount,
+             count,
+             failedCount);
     }
     return false;
   }
 }
 
-
-bool 
-Runner::testIndex( const std::string &testName, 
-                   unsigned int &indexOut ) const
-{
+bool Runner::testIndex(const std::string& testName,
+                       unsigned int& indexOut) const {
   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      if ( testNameAt(index) == testName )
-      {
+  for (unsigned int index = 0; index < count; ++index) {
+    if (testNameAt(index) == testName) {
       indexOut = index;
       return true;
     }
@@ -442,97 +315,67 @@ Runner::testIndex( const std::string &testName,
   return false;
 }
 
-
-void 
-Runner::listTests() const
-{
+void Runner::listTests() const {
   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
+  for (unsigned int index = 0; index < count; ++index) {
     printf("%s\n", testNameAt(index).c_str());
   }
 }
 
-
-int 
-Runner::runCommandLine( int argc, const char *argv[] ) const
-{
+int Runner::runCommandLine(int argc, const char* argv[]) const {
   typedef std::deque<std::string> TestNames;
   Runner subrunner;
-   for ( int index = 1; index < argc; ++index )
-   {
+  for (int index = 1; index < argc; ++index) {
     std::string opt = argv[index];
-      if ( opt == "--list-tests" )
-      {
+    if (opt == "--list-tests") {
       listTests();
       return 0;
-      }
-      else if ( opt == "--test-auto" )
-      {
+    } else if (opt == "--test-auto") {
       preventDialogOnCrash();
-      }
-      else if ( opt == "--test" )
-      {
+    } else if (opt == "--test") {
       ++index;
-         if ( index < argc )
-         {
+      if (index < argc) {
         unsigned int testNameIndex;
-            if ( testIndex( argv[index], testNameIndex ) )
-            {
+        if (testIndex(argv[index], testNameIndex)) {
           subrunner.add(tests_[testNameIndex]);
-            }
-            else
-            {
+        } else {
           fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
           return 2;
         }
-         }
-         else
-         {
+      } else {
         printUsage(argv[0]);
         return 2;
       }
-      }
-      else
-      {
+    } else {
       printUsage(argv[0]);
       return 2;
     }
   }
   bool succeeded;
-   if ( subrunner.testCount() > 0 )
-   {
+  if (subrunner.testCount() > 0) {
     succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
-   }
-   else
-   {
+  } else {
     succeeded = runAllTest(true);
   }
-   return succeeded ? 0 
-                    : 1;
+  return succeeded ? 0 : 1;
 }
 
-
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && defined(_DEBUG)
 // Hook MSVCRT assertions to prevent dialog from appearing
 static int
-msvcrtSilentReportHook( int reportType, char *message, int *returnValue )
-{
+msvcrtSilentReportHook(int reportType, char* message, int* /*returnValue*/) {
   // The default CRT handling of error and assertion is to display
   // an error dialog to the user.
   // Instead, when an error or an assertion occurs, we force the
   // application to terminate using abort() after display
   // the message on stderr.
-   if ( reportType == _CRT_ERROR  ||  
-        reportType == _CRT_ASSERT )
-   {
+  if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
     // calling abort() cause the ReportHook to be called
     // The following is used to detect this case and let's the
     // error handler fallback on its default behaviour (
     // display a warning message)
     static volatile bool isAborting = false;
-      if ( isAborting ) 
-      {
+    if (isAborting) {
       return TRUE;
     }
     isAborting = true;
@@ -546,13 +389,12 @@ msvcrtSilentReportHook( int reportType, char *message, int *returnValue )
 }
 #endif // if defined(_MSC_VER)
 
-
-void 
-Runner::preventDialogOnCrash()
-{
-#if defined(_MSC_VER)
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
   // Install a hook to prevent MSVCRT error and assertion from
-   // popping a dialog.
+  // popping a dialog
+  // This function a NO-OP in release configuration
+  // (which cause warning since msvcrtSilentReportHook is not referenced)
   _CrtSetReportHook(&msvcrtSilentReportHook);
 #endif // if defined(_MSC_VER)
 
@@ -562,17 +404,13 @@ Runner::preventDialogOnCrash()
 #if defined(_WIN32)
   // Prevents the system from popping a dialog for debugging if the
   // application fails due to invalid memory access.
-   SetErrorMode( SEM_FAILCRITICALERRORS 
-                 | SEM_NOGPFAULTERRORBOX 
-                 | SEM_NOOPENFILEERRORBOX );
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
 #endif // if defined(_WIN32)
 }
 
-void 
-Runner::printUsage( const char *appName )
-{
-   printf( 
-      "Usage: %s [options]\n"
+void Runner::printUsage(const char* appName) {
+  printf("Usage: %s [options]\n"
          "\n"
          "If --test is not specified, then all the test cases be run.\n"
          "\n"
@@ -581,22 +419,20 @@ Runner::printUsage( const char *appName )
          "              output and exit.\n"
          "--test TESTNAME: executes the test case with the specified name.\n"
          "                 May be repeated.\n"
-      "--test-auto: prevent dialog prompting for debugging on crash.\n"
-      , appName );
+         "--test-auto: prevent dialog prompting for debugging on crash.\n",
+         appName);
 }
 
-
-
 // Assertion functions
 // //////////////////////////////////////////////////////////////////
 
-TestResult &
-checkStringEqual( TestResult &result, 
-                  const std::string &expected, const std::string &actual,
-                  const char *file, unsigned int line, const char *expr )
-{
-   if ( expected != actual )
-   {
+TestResult& checkStringEqual(TestResult& result,
+                             const std::string& expected,
+                             const std::string& actual,
+                             const char* file,
+                             unsigned int line,
+                             const char* expr) {
+  if (expected != actual) {
     result.addFailure(file, line, expr);
     result << "Expected: '" << expected << "'\n";
     result << "Actual  : '" << actual << "'";
@@ -604,5 +440,4 @@ checkStringEqual( TestResult &result,
   return result;
 }
 
-
 } // namespace JsonTest

src/test_lib_json/jsontest.h

@@ -7,8 +7,11 @@
 #define JSONTEST_H_INCLUDED
 
 #include <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
 #include <stdio.h>
 #include <deque>
+#include <sstream>
 #include <string>
 
 // //////////////////////////////////////////////////////////////////
@@ -17,8 +20,6 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-
-
 /** \brief Unit testing framework.
  * \warning: all assertions are non-aborting, test case execution will continue
  *           even if an assertion namespace.
@@ -27,9 +28,7 @@
  */
 namespace JsonTest {
 
-
-   class Failure
-   {
+class Failure {
 public:
   const char* file_;
   unsigned int line_;
@@ -38,12 +37,10 @@ namespace JsonTest {
   unsigned int nestingLevel_;
 };
 
-
 /// Context used to create the assertion callstack on failure.
 /// Must be a POD to allow inline initialisation without stepping
 /// into the debugger.
-   struct PredicateContext
-   {
+struct PredicateContext {
   typedef unsigned int Id;
   Id id_;
   const char* file_;
@@ -55,8 +52,7 @@ namespace JsonTest {
   Failure* failure_;
 };
 
-   class TestResult
-   {
+class TestResult {
 public:
   TestResult();
 
@@ -72,8 +68,8 @@ namespace JsonTest {
   void setTestName(const std::string& name);
 
   /// Adds an assertion failure.
-      TestResult &addFailure( const char *file, unsigned int line,
-                              const char *expr = 0 );
+  TestResult&
+  addFailure(const char* file, unsigned int line, const char* expr = 0);
 
   /// Removes the last PredicateContext added to the predicate stack
   /// chained list.
@@ -84,19 +80,29 @@ namespace JsonTest {
 
   void printFailure(bool printTestName) const;
 
+  // Generic operator that will work with anything ostream can deal with.
+  template <typename T> TestResult& operator<<(const T& value) {
+    std::ostringstream oss;
+    oss.precision(16);
+    oss.setf(std::ios_base::floatfield);
+    oss << value;
+    return addToLastFailure(oss.str());
+  }
+
+  // Specialized versions.
   TestResult& operator<<(bool value);
-      TestResult &operator << ( int value );
-      TestResult &operator << ( unsigned int value );
-      TestResult &operator << ( double value );
-      TestResult &operator << ( const char *value );
-      TestResult &operator << ( const std::string &value );
+  // std:ostream does not support 64bits integers on all STL implementation
+  TestResult& operator<<(Json::Int64 value);
+  TestResult& operator<<(Json::UInt64 value);
 
 private:
   TestResult& addToLastFailure(const std::string& message);
   unsigned int getAssertionNestingLevel() const;
   /// Adds a failure or a predicate context
-      void addFailureInfo( const char *file, unsigned int line,
-                           const char *expr, unsigned int nestingLevel  );
+  void addFailureInfo(const char* file,
+                      unsigned int line,
+                      const char* expr,
+                      unsigned int nestingLevel);
   static std::string indentText(const std::string& text,
                                 const std::string& indent);
 
@@ -109,9 +115,7 @@ namespace JsonTest {
   Failure* messageTarget_;
 };
 
-
-   class TestCase
-   {
+class TestCase {
 public:
   TestCase();
 
@@ -131,8 +135,7 @@ namespace JsonTest {
 /// Function pointer type for TestCase factory
 typedef TestCase* (*TestCaseFactory)();
 
-   class Runner
-   {
+class Runner {
 public:
   Runner();
 
@@ -173,78 +176,96 @@ namespace JsonTest {
   Factories tests_;
 };
 
-   template<typename T>
-   TestResult &
-   checkEqual( TestResult &result, const T &expected, const T &actual, 
-               const char *file, unsigned int line, const char *expr )
-   {
-      if ( expected != actual )
-      {
+template <typename T, typename U>
+TestResult& checkEqual(TestResult& result,
+                       const T& expected,
+                       const U& actual,
+                       const char* file,
+                       unsigned int line,
+                       const char* expr) {
+  if (static_cast<U>(expected) != actual) {
     result.addFailure(file, line, expr);
-         result << "Expected: " << expected << "\n";
+    result << "Expected: " << static_cast<U>(expected) << "\n";
     result << "Actual  : " << actual;
   }
   return result;
 }
 
-   TestResult &
-   checkStringEqual( TestResult &result, 
-                     const std::string &expected, const std::string &actual,
-                     const char *file, unsigned int line, const char *expr );
+TestResult& checkStringEqual(TestResult& result,
+                             const std::string& expected,
+                             const std::string& actual,
+                             const char* file,
+                             unsigned int line,
+                             const char* expr);
 
 } // namespace JsonTest
 
-
 /// \brief Asserts that the given expression is true.
 /// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
 /// JSONTEST_ASSERT( x == y );
 #define JSONTEST_ASSERT(expr)                                                  \
-   if ( expr )                                                                \
-   {                                                                          \
-   }                                                                          \
-   else                                                                       \
+  if (expr) {                                                                  \
+  } else                                                                       \
   result_->addFailure(__FILE__, __LINE__, #expr)
 
 /// \brief Asserts that the given predicate is true.
-/// The predicate may do other assertions and be a member function of the fixture.
+/// The predicate may do other assertions and be a member function of the
+/// fixture.
 #define JSONTEST_ASSERT_PRED(expr)                                             \
   {                                                                            \
     JsonTest::PredicateContext _minitest_Context = {                           \
-         result_->predicateId_, __FILE__, __LINE__, #expr };            \
+      result_->predicateId_, __FILE__, __LINE__, #expr                         \
+    };                                                                         \
     result_->predicateStackTail_->next_ = &_minitest_Context;                  \
     result_->predicateId_ += 1;                                                \
     result_->predicateStackTail_ = &_minitest_Context;                         \
     (expr);                                                                    \
     result_->popPredicateContext();                                            \
-   }                                                                    \
-   *result_
+  }
 
 /// \brief Asserts that two values are equals.
 #define JSONTEST_ASSERT_EQUAL(expected, actual)                                \
-   JsonTest::checkEqual( *result_, expected, actual,       \
-                         __FILE__, __LINE__,               \
+  JsonTest::checkEqual(*result_,                                               \
+                       expected,                                               \
+                       actual,                                                 \
+                       __FILE__,                                               \
+                       __LINE__,                                               \
                        #expected " == " #actual)
 
 /// \brief Asserts that two values are equals.
 #define JSONTEST_ASSERT_STRING_EQUAL(expected, actual)                         \
   JsonTest::checkStringEqual(*result_,                                         \
-      std::string(expected), std::string(actual),        \
+                             std::string(expected),                            \
+                             std::string(actual),                              \
+                             __FILE__,                                         \
+                             __LINE__,                                         \
                              #expected " == " #actual)
 
+/// \brief Asserts that a given expression throws an exception
+#define JSONTEST_ASSERT_THROWS(expr)                                           \
+  {                                                                            \
+    bool _threw = false;                                                       \
+    try {                                                                      \
+      expr;                                                                    \
+    }                                                                          \
+    catch (...) {                                                              \
+      _threw = true;                                                           \
+    }                                                                          \
+    if (!_threw)                                                               \
+      result_->addFailure(                                                     \
+          __FILE__, __LINE__, "expected exception thrown: " #expr);            \
+  }
+
 /// \brief Begin a fixture test case.
 #define JSONTEST_FIXTURE(FixtureType, name)                                    \
-   class Test##FixtureType##name : public FixtureType          \
-   {                                                           \
+  class Test##FixtureType##name : public FixtureType {                         \
   public:                                                                      \
-      static JsonTest::TestCase *factory()                     \
-      {                                                        \
+    static JsonTest::TestCase* factory() {                                     \
       return new Test##FixtureType##name();                                    \
     }                                                                          \
+                                                                               \
   public: /* overidden from TestCase */                                        \
-      virtual const char *testName() const                     \
-      {                                                        \
-         return #FixtureType "/" #name;                        \
-      }                                                        \
+    virtual const char* testName() const { return #FixtureType "/" #name; }    \
     virtual void runTestCase();                                                \
   };                                                                           \
                                                                                \

test/data/test_basic_08.expected

@@ -1,2 +1,3 @@
+// C++ style comment
 .=null
 

test/data/test_basic_09.expected

@@ -1,2 +1,4 @@
+/* C style comment
+ */
 .=null
 

test/data/test_comment_02.expected

@@ -0,0 +1,14 @@
+.={}
+/* C-style comment
+
+    C-style-2 comment */
+.c-test={}
+.c-test.a=1
+/* Internal comment c-style */
+.c-test.b=2
+// C++-style comment
+.cpp-test={}
+// Multiline comment cpp-style
+// Second line
+.cpp-test.c=3
+.cpp-test.d=4

test/data/test_comment_02.json

@@ -0,0 +1,17 @@
+{
+   /* C-style comment
+
+    C-style-2 comment */
+   "c-test" : {
+      "a" : 1,
+      /* Internal comment c-style */
+      "b" : 2
+   },
+   // C++-style comment
+   "cpp-test" : {
+      // Multiline comment cpp-style
+      // Second line
+      "c" : 3,
+      "d" : 4
+   }
+}

test/data/test_integer_01.expected

@@ -1 +1,2 @@
+// Max signed integer
 .=2147483647

test/data/test_integer_02.expected

@@ -1 +1,2 @@
+// Min signed integer
 .=-2147483648

test/data/test_integer_03.expected

@@ -1 +1,2 @@
+// Max unsigned integer
 .=4294967295

test/data/test_integer_04.expected

@@ -1,2 +1,3 @@
+// Min unsigned integer
 .=0
 

test/data/test_preserve_comment_01.expected

@@ -1,3 +1,11 @@
+/* A comment
+   at the beginning of the file.
+ */
 .={}
 .first=1
+/* Comment before 'second'
+ */
 .second=2
+/* A comment at 
+   the end of the file.
+ */

test/data/test_real_01.expected

@@ -1,2 +1,3 @@
+// 2^33 => out of integer range, switch to double
 .=8589934592
 

test/data/test_real_02.expected

@@ -1,2 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
 .=-4294967295
 

test/data/test_real_03.expected

@@ -1,2 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
 .=-4294967295
 

test/data/test_real_04.expected

@@ -1,2 +1,3 @@
+// 1.2345678
 .=1.2345678
 

test/data/test_real_05.expected

@@ -1,3 +1,4 @@
+// 1234567.8
 .=1234567.8
 
 

test/data/test_real_06.expected

@@ -1,3 +1,4 @@
+// -1.2345678
 .=-1.2345678
 
 

test/data/test_real_07.expected

@@ -1,3 +1,4 @@
+// -1234567.8
 .=-1234567.8
 
 

test/data/test_real_08.expected

@@ -0,0 +1,4 @@
+// Out of 32-bit integer range, switch to double in 32-bit mode. Length the
+// same as UINT_MAX in base 10 and digit less than UINT_MAX's last digit in
+// order to catch a bug in the parsing code.
+.=4300000001

test/data/test_real_08.json

@@ -0,0 +1,4 @@
+// Out of 32-bit integer range, switch to double in 32-bit mode. Length the
+// same as UINT_MAX in base 10 and digit less than UINT_MAX's last digit in
+// order to catch a bug in the parsing code.
+4300000001

test/data/test_real_09.expected

@@ -0,0 +1,4 @@
+// Out of 64-bit integer range, switch to double in all modes. Length the same
+// as ULONG_MAX in base 10 and digit less than ULONG_MAX's last digit in order
+// to catch a bug in the parsing code.
+.=1.9e+19

test/data/test_real_09.json

@@ -0,0 +1,4 @@
+// Out of 64-bit integer range, switch to double in all modes. Length the same
+// as ULONG_MAX in base 10 and digit less than ULONG_MAX's last digit in order
+// to catch a bug in the parsing code.
+19000000000000000001

test/data/test_real_10.expected

@@ -0,0 +1,4 @@
+// Out of 32-bit signed integer range, switch to double in all modes. Length
+// the same as INT_MIN in base 10 and digit less than INT_MIN's last digit in
+// order to catch a bug in the parsing code.
+.=-2200000001

test/data/test_real_10.json

@@ -0,0 +1,4 @@
+// Out of 32-bit signed integer range, switch to double in all modes. Length
+// the same as INT_MIN in base 10 and digit less than INT_MIN's last digit in
+// order to catch a bug in the parsing code.
+-2200000001

test/data/test_real_11.expected

@@ -0,0 +1,4 @@
+// Out of 64-bit signed integer range, switch to double in all modes. Length
+// the same as LONG_MIN in base 10 and digit less than LONG_MIN's last digit in
+// order to catch a bug in the parsing code.
+.=-9.3e+18

test/data/test_real_11.json

@@ -0,0 +1,4 @@
+// Out of 64-bit signed integer range, switch to double in all modes. Length
+// the same as LONG_MIN in base 10 and digit less than LONG_MIN's last digit in
+// order to catch a bug in the parsing code.
+-9300000000000000001

test/data/test_real_12.expected

@@ -0,0 +1,2 @@
+// 2^64 -> switch to double.
+.=1.844674407370955e+19

test/data/test_real_12.json

@@ -0,0 +1,2 @@
+// 2^64 -> switch to double.
+18446744073709551616

test/data/test_string_04.expected

@@ -0,0 +1,2 @@
+.=""abc\def""
+

test/data/test_string_04.json

@@ -0,0 +1,2 @@
+"\"abc\\def\""
+

test/data/test_string_05.expected

@@ -0,0 +1,2 @@
+.="\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
+

test/data/test_string_05.json

@@ -0,0 +1,2 @@
+"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
+

version

@@ -1 +1 @@
-0.6.0-rc2
+0.7.0