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

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

.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,36 @@
+/build/
+*.pyc
+*.swp
+*.actual
+*.actual-rewrite
+*.process-output
+*.rewrite
+/bin/
+/buildscons/
+/libs/
+/doc/doxyfile
+/dist/
+#/version
+#/include/json/version.h
+
+# MSVC project files:
+*.sln
+*.vcxproj
+*.filters
+*.user
+*.sdf
+*.opensdf
+*.suo
+
+# MSVC build files:
+*.lib
+*.obj
+*.tlog/
+*.pdb
+
+# CMake-generated files:
+CMakeFiles/
+CTestTestFile.cmake
+cmake_install.cmake
+pkg-config/jsoncpp.pc
+jsoncpp_lib_static.dir/

.travis.yml

@@ -0,0 +1,17 @@
+# 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_WITH_CMAKE_PACKAGE=$CMAKE_PKG -DJSONCPP_LIB_BUILD_SHARED=$SHARED_LIB -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_VERBOSE_MAKEFILE=$VERBOSE_MAKE . && make && make jsoncpp_check
+env:
+  matrix:
+    - SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false
+    - SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug   VERBOSE_MAKE=true VERBOSE
+notifications:
+  email:
+    - aaronjjacobs@gmail.com

CMakeLists.txt

@@ -0,0 +1,126 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)
+PROJECT(jsoncpp)
+ENABLE_TESTING()
+
+OPTION(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" ON)
+OPTION(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" ON)
+OPTION(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
+OPTION(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
+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(LIB_SUFFIX "" CACHE STRING "Optional arch-dependent suffix for the library installation directory")
+
+SET(RUNTIME_INSTALL_DIR bin
+    CACHE PATH "Install dir for executables and dlls")
+SET(ARCHIVE_INSTALL_DIR lib${LIB_SUFFIX}
+    CACHE PATH "Install dir for static libraries")
+SET(LIBRARY_INSTALL_DIR lib${LIB_SUFFIX}
+    CACHE PATH "Install dir for shared libraries")
+SET(INCLUDE_INSTALL_DIR include
+    CACHE PATH "Install dir for headers")
+SET(PACKAGE_INSTALL_DIR lib${LIB_SUFFIX}/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 )
+
+# 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)
+#SET( JSONCPP_VERSION_MAJOR X )
+#SET( JSONCPP_VERSION_MINOR Y )
+#SET( JSONCPP_VERSION_PATCH Z )
+SET( JSONCPP_VERSION 1.10.0 )
+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"
+                NEWLINE_STYLE UNIX )
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/version.in"
+                "${PROJECT_SOURCE_DIR}/version"
+                NEWLINE_STYLE UNIX )
+
+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 (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  # using regular Clang or AppleClang
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  # using GCC
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
+endif()
+
+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${LIB_SUFFIX}/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 )

LICENSE

@@ -1 +1,55 @@
-The json-cpp library and this documentation are in Public Domain.
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.

NEWS.txt

@@ -0,0 +1,175 @@
+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:
+  ---------------------
+
+* Compilation
+
+  - LD_LIBRARY_PATH and LIBRARY_PATH environment variables are now 
+    propagated to the build environment as this is required for some 
+    compiler installation.
+
+  - Added support for Microsoft Visual Studio 2008 (bug #2930462): 
+    The platform "msvc90" has been added.
+
+    Notes: you need to setup the environment by running vcvars32.bat 
+    (e.g. MSVC 2008 command prompt in start menu) before running scons.
+    
+  - Added support for amalgamated source and header generation (a la sqlite).
+    Refer to README.md section "Generating amalgamated source and header"
+    for detail.
+    
+* Value
+
+  - Removed experimental ValueAllocator, it caused static 
+    initialization/destruction order issues (bug #2934500). 
+    The DefaultValueAllocator has been inlined in code.
+    
+  - Added support for 64 bits integer:
+  
+    Types Json::Int64 and Json::UInt64 have been added. They are aliased
+	to 64 bits integers on system that support them (based on __int64 on 
+	Microsoft Visual Studio platform, and long long on other platforms).
+	
+	Types Json::LargestInt and Json::LargestUInt have been added. They are
+	aliased to the largest integer type supported: 
+	either Json::Int/Json::UInt or Json::Int64/Json::UInt64 respectively.
+	
+	Json::Value::asInt() and Json::Value::asUInt() still returns plain
+	"int" based types, but asserts if an attempt is made to retrieve
+	a 64 bits value that can not represented as the return type.
+	
+	Json::Value::asInt64() and Json::Value::asUInt64() have been added
+	to obtain the 64 bits integer value.
+	
+	Json::Value::asLargestInt() and Json::Value::asLargestUInt() returns
+	the integer as a LargestInt/LargestUInt respectively. Those functions
+	functions are typically used when implementing writer.
+	
+	The reader attempts to read number as 64 bits integer, and fall back
+	to reading a double if the number is not in the range of 64 bits 
+	integer.
+    
+    Warning: Json::Value::asInt() and Json::Value::asUInt() now returns
+    long long. This changes break code that was passing the return value
+    to *printf() function.
+  
+    Support for 64 bits integer can be disabled by defining the macro 
+	JSON_NO_INT64 (uncomment it in json/config.h for example), though
+	it should have no impact on existing usage.
+    
+  - The type Json::ArrayIndex is used for indexes of a JSON value array. It
+    is an unsigned int (typically 32 bits).
+	
+  - Array index can be passed as int to operator[], allowing use of literal:
+    Json::Value array;
+	array.append( 1234 );
+	int value = array[0].asInt();  // did not compile previously
+
+  - Added float Json::Value::asFloat() to obtain a floating point value as a
+    float (avoid lost of precision warning caused by used of asDouble() 
+    to initialize a float).
+
+* Reader
+
+  - Renamed Reader::getFormatedErrorMessages() to getFormattedErrorMessages.
+    Bug #3023708 (Formatted has 2 't'). The old member function is deprecated
+    but still present for backward compatibility.
+    
+* Tests
+
+  - Added test to ensure that the escape sequence "\/" is corrected handled 
+    by the parser.
+
+* Bug fixes
+
+  - Bug #3139677: JSON [1 2 3] was incorrectly parsed as [1, 3]. Error is now 
+    correctly detected.
+    
+  - Bug #3139678: stack buffer overflow when parsing a double with a
+    length of 32 characters.
+	
+  - Fixed Value::operator <= implementation (had the semantic of operator >=).
+    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 
+    MIT license, or public domain if desired and recognized in your jurisdiction.
+    Thanks to Stephan G. Beal [http://wanderinghorse.net/home/stephan/]) who
+	helped figuring out the solution to the public domain issue.

README.md

@@ -0,0 +1,210 @@
+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.
+
+[JsonCpp]: http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html
+
+## A note on backward-compatibility
+* `1.y.z` is built with C++11.
+* `0.y.z` can be used with older compilers.
+* Major versions maintain binary-compatibility.
+
+Using JsonCpp in your project
+-----------------------------
+The recommended approach to integrating JsonCpp in your project is to build
+the amalgamated source (a single `.cpp` file) with your own build system. This
+ensures consistency of compilation flags and ABI compatibility. See the section
+"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 built as a dynamic library on Windows, then your project needs to
+define the macro `JSON_DLL`.
+
+Building and testing with 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_STATIC=ON -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
+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
+
+## Running the tests using scons
+Note that tests can be run using SCons using the `check` target:
+
+    scons platform=$PLATFORM check
+
+Building the documentation
+--------------------------
+Run the Python script `doxybuild.py` from the top directory:
+
+    python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
+
+See `doxybuild.py --help` for options.
+
+Generating amalgamated source and header
+----------------------------------------
+JsonCpp is provided with a script to generate a single header and a single
+source file to ease inclusion into an existing project. The amalgamated source
+can be generated at any time by running the following command from the
+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,117 +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 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/project/showfiles.php?group_id=30337&package_id=67375
-
-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
-	linux-gcc Gnu C++ (linux, also reported to work for Mac OS X)
-	
-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:
-  ==========================
-
-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. 
-
-
-* 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.

SConstruct

@@ -18,7 +18,7 @@ options = Variables()
 options.Add( EnumVariable('platform',
                         'Platform (compiler/stl) used to build the project',
                         'msvc71',
-                        allowed_values='suncc vacpp mingw msvc6 msvc7 msvc71 msvc80 linux-gcc'.split(),
+                        allowed_values='suncc vacpp mingw msvc6 msvc7 msvc71 msvc80 msvc90 linux-gcc'.split(),
                         ignorecase=2) )
 
 try:
@@ -57,8 +57,9 @@ def make_environ_vars():
 	"""Returns a dictionnary with environment variable to use when compiling."""
 	# PATH is required to find the compiler
 	# TEMP is required for at least mingw
+    # LD_LIBRARY_PATH & co is required on some system for the compiler
 	vars = {}
-	for name in ('PATH', 'TEMP', 'TMP'):
+	for name in ('PATH', 'TEMP', 'TMP', 'LD_LIBRARY_PATH', 'LIBRARY_PATH'):
 		if name in os.environ:
 			vars[name] = os.environ[name]
 	return vars
@@ -101,12 +102,24 @@ elif platform == 'msvc80':
     for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
         env.Tool( tool )
     env['CXXFLAGS']='-GR -EHsc /nologo /MT'
+elif platform == 'msvc90':
+    env['MSVS_VERSION']='9.0'
+    # Scons 1.2 fails to detect the correct location of the platform SDK.
+    # So we propagate those from the environment. This requires that the
+    # user run vcvars32.bat before compiling.
+    if 'INCLUDE' in os.environ:
+        env['ENV']['INCLUDE'] = os.environ['INCLUDE']
+    if 'LIB' in os.environ:
+        env['ENV']['LIB'] = os.environ['LIB']
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -EHsc /nologo /MT'
 elif platform == 'mingw':
     env.Tool( '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."
@@ -224,7 +237,7 @@ RunUnitTests = ActionFactory(runUnitTests_action, runUnitTests_string )
 env.Alias( 'check' )
 
 srcdist_cmd = env['SRCDIST_ADD']( source = """
-    AUTHORS README.txt SConstruct
+    AUTHORS README.md SConstruct
     """.split() )
 env.Alias( 'src-dist', srcdist_cmd )
 

amalgamate.py

@@ -0,0 +1,154 @@
+"""Amalgate json-cpp library sources into a single source and header file.
+
+Works with python2.6+ and python3.4+.
+
+Example of invocation (must be invoked from json-cpp top directory):
+python amalgate.py
+"""
+import os
+import os.path
+import sys
+
+class AmalgamationFile:
+    def __init__(self, top_dir):
+        self.top_dir = top_dir
+        self.blocks = []
+
+    def add_text(self, text):
+        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")
+        content = f.read()
+        if wrap_in_comment:
+            content = "/*\n" + content + "\n*/"
+        self.add_text(content)
+        f.close()
+        add_marker("End")
+        self.add_text("\n\n\n\n")
+
+    def get_value(self):
+        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(str.encode(self.get_value(), 'UTF-8'))
+        f.close()
+
+def amalgamate_source(source_top_dir=None,
+                       target_source_path=None,
+                       header_include_path=None):
+    """Produces amalgated source.
+       Parameters:
+           source_top_dir: top-directory
+           target_source_path: output .cpp path
+           header_include_path: generated header path relative to target_source_path.
+    """
+    print("Amalgating header...")
+    header = AmalgamationFile(source_top_dir)
+    header.add_text("/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).")
+    header.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
+    header.add_file("LICENSE", wrap_in_comment=True)
+    header.add_text("#ifndef JSON_AMALGATED_H_INCLUDED")
+    header.add_text("# define JSON_AMALGATED_H_INCLUDED")
+    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)
+    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...")
+    header = AmalgamationFile(source_top_dir)
+    header.add_text("/// Json-cpp amalgated forward header (http://jsoncpp.sourceforge.net/).")
+    header.add_text('/// It is intended to be used with #include "%s"' % forward_header_include_path)
+    header.add_text("/// This header provides forward declaration for all JsonCpp types.")
+    header.add_file("LICENSE", wrap_in_comment=True)
+    header.add_text("#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED")
+    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)
+    header.write_to(target_forward_header_path)
+
+    print("Amalgating source...")
+    source = AmalgamationFile(source_top_dir)
+    source.add_text("/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/).")
+    source.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
+    source.add_file("LICENSE", wrap_in_comment=True)
+    source.add_text("")
+    source.add_text('#include "%s"' % header_include_path)
+    source.add_text("""
+#ifndef JSON_IS_AMALGAMATION
+#error "Compile with -I PATH_TO_JSON_DIRECTORY"
+#endif
+""")
+    source.add_text("")
+    lib_json = "src/lib_json"
+    source.add_file(os.path.join(lib_json, "json_tool.h"))
+    source.add_file(os.path.join(lib_json, "json_reader.cpp"))
+    source.add_file(os.path.join(lib_json, "json_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)
+    source.write_to(target_source_path)
+
+def main():
+    usage = """%prog [options]
+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",
+        help="""Output .cpp source path. [Default: %default]""")
+    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(),
+        help="""Source top-directory. [Default: %default]""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    msg = amalgamate_source(source_top_dir=options.top_dir,
+                             target_source_path=options.target_source_path,
+                             header_include_path=options.header_include_path)
+    if msg:
+        sys.stderr.write(msg + "\n")
+        sys.exit(1)
+    else:
+        print("Source succesfully amalagated")
+
+if __name__ == "__main__":
+    main()

dev.makefile

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

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/antglob.py

@@ -2,6 +2,7 @@
 # encoding: utf-8
 # Baptiste Lepilleur, 2009
 
+from __future__ import print_function
 from dircache import listdir
 import re
 import fnmatch
@@ -53,44 +54,44 @@ LINKS = DIR_LINK | FILE_LINK
 ALL_NO_LINK = DIR | FILE
 ALL = DIR | FILE | LINKS
 
-_ANT_RE = re.compile( r'(/\*\*/)|(\*\*/)|(/\*\*)|(\*)|(/)|([^\*/]*)' )
+_ANT_RE = re.compile(r'(/\*\*/)|(\*\*/)|(/\*\*)|(\*)|(/)|([^\*/]*)')
 
-def ant_pattern_to_re( ant_pattern ):
-    """Generates a regular expression from the ant pattern.
-    Matching convention:
-    **/a: match 'a', 'dir/a', 'dir1/dir2/a'
-    a/**/b: match 'a/b', 'a/c/b', 'a/d/c/b'
-    *.py: match 'script.py' but not 'a/script.py'
+def ant_pattern_to_re(ant_pattern):
+    """Generates a regular expression from the ant pattern.
+    Matching convention:
+    **/a: match 'a', 'dir/a', 'dir1/dir2/a'
+    a/**/b: match 'a/b', 'a/c/b', 'a/d/c/b'
+    *.py: match 'script.py' but not 'a/script.py'
     """
     rex = ['^']
     next_pos = 0
-    sep_rex = r'(?:/|%s)' % re.escape( os.path.sep )
-##    print 'Converting', ant_pattern
-    for match in _ANT_RE.finditer( ant_pattern ):
-##        print 'Matched', match.group()
-##        print match.start(0), next_pos
+    sep_rex = r'(?:/|%s)' % re.escape(os.path.sep)
+##    print 'Converting', ant_pattern
+    for match in _ANT_RE.finditer(ant_pattern):
+##        print 'Matched', match.group()
+##        print match.start(0), next_pos
         if match.start(0) != next_pos:
-            raise ValueError( "Invalid ant pattern" )
+            raise ValueError("Invalid ant pattern")
         if match.group(1): # /**/
-            rex.append( sep_rex + '(?:.*%s)?' % sep_rex )
+            rex.append(sep_rex + '(?:.*%s)?' % sep_rex)
         elif match.group(2): # **/
-            rex.append( '(?:.*%s)?' % sep_rex )
+            rex.append('(?:.*%s)?' % sep_rex)
         elif match.group(3): # /**
-            rex.append( sep_rex + '.*' )
+            rex.append(sep_rex + '.*')
         elif match.group(4): # *
-            rex.append( '[^/%s]*' % re.escape(os.path.sep) )
+            rex.append('[^/%s]*' % re.escape(os.path.sep))
         elif match.group(5): # /
-            rex.append( sep_rex )
+            rex.append(sep_rex)
         else: # somepath
-            rex.append( re.escape(match.group(6)) )
-        next_pos = match.end()
+            rex.append(re.escape(match.group(6)))
+        next_pos = match.end()
     rex.append('$')
-    return re.compile( ''.join( rex ) )
-
-def _as_list( l ):
-    if isinstance(l, basestring):
-        return l.split()
-    return l
+    return re.compile(''.join(rex))
+
+def _as_list(l):
+    if isinstance(l, basestring):
+        return l.split()
+    return l
 
 def glob(dir_path,
          includes = '**/*',
@@ -99,103 +100,103 @@ def glob(dir_path,
          prune_dirs = prune_dirs,
          max_depth = 25):
     include_filter = [ant_pattern_to_re(p) for p in _as_list(includes)]
-    exclude_filter = [ant_pattern_to_re(p) for p in _as_list(excludes)]
-    prune_dirs = [p.replace('/',os.path.sep) for p in _as_list(prune_dirs)]
+    exclude_filter = [ant_pattern_to_re(p) for p in _as_list(excludes)]
+    prune_dirs = [p.replace('/',os.path.sep) for p in _as_list(prune_dirs)]
     dir_path = dir_path.replace('/',os.path.sep)
     entry_type_filter = entry_type
 
-    def is_pruned_dir( dir_name ):
+    def is_pruned_dir(dir_name):
         for pattern in prune_dirs:
-            if fnmatch.fnmatch( dir_name, pattern ):
+            if fnmatch.fnmatch(dir_name, pattern):
                 return True
         return False
 
-    def apply_filter( full_path, filter_rexs ):
+    def apply_filter(full_path, filter_rexs):
         """Return True if at least one of the filter regular expression match full_path."""
         for rex in filter_rexs:
-            if rex.match( full_path ):
+            if rex.match(full_path):
                 return True
         return False
 
-    def glob_impl( root_dir_path ):
-        child_dirs = [root_dir_path]
-        while child_dirs:
+    def glob_impl(root_dir_path):
+        child_dirs = [root_dir_path]
+        while child_dirs:
             dir_path = child_dirs.pop()
-            for entry in listdir( dir_path ):
-                full_path = os.path.join( dir_path, entry )
-##                print 'Testing:', full_path,
-                is_dir = os.path.isdir( full_path )
-                if is_dir and not is_pruned_dir( entry ): # explore child directory ?
-##                    print '===> marked for recursion',
-                    child_dirs.append( full_path )
-                included = apply_filter( full_path, include_filter )
-                rejected = apply_filter( full_path, exclude_filter )
-                if not included or rejected: # do not include entry ?
-##                    print '=> not included or rejected'
-                    continue
-                link = os.path.islink( full_path )
-                is_file = os.path.isfile( full_path )
-                if not is_file and not is_dir:
-##                    print '=> unknown entry type'
-                    continue
-                if link:
-                    entry_type = is_file and FILE_LINK or DIR_LINK
-                else:
-                    entry_type = is_file and FILE or DIR
-##                print '=> type: %d' % entry_type, 
-                if (entry_type & entry_type_filter) != 0:
-##                    print ' => KEEP'
-                    yield os.path.join( dir_path, entry )
-##                else:
-##                    print ' => TYPE REJECTED'
-    return list( glob_impl( dir_path ) )
+            for entry in listdir(dir_path):
+                full_path = os.path.join(dir_path, entry)
+##                print 'Testing:', full_path,
+                is_dir = os.path.isdir(full_path)
+                if is_dir and not is_pruned_dir(entry): # explore child directory ?
+##                    print '===> marked for recursion',
+                    child_dirs.append(full_path)
+                included = apply_filter(full_path, include_filter)
+                rejected = apply_filter(full_path, exclude_filter)
+                if not included or rejected: # do not include entry ?
+##                    print '=> not included or rejected'
+                    continue
+                link = os.path.islink(full_path)
+                is_file = os.path.isfile(full_path)
+                if not is_file and not is_dir:
+##                    print '=> unknown entry type'
+                    continue
+                if link:
+                    entry_type = is_file and FILE_LINK or DIR_LINK
+                else:
+                    entry_type = is_file and FILE or DIR
+##                print '=> type: %d' % entry_type, 
+                if (entry_type & entry_type_filter) != 0:
+##                    print ' => KEEP'
+                    yield os.path.join(dir_path, entry)
+##                else:
+##                    print ' => TYPE REJECTED'
+    return list(glob_impl(dir_path))
 
 
 if __name__ == "__main__":
     import unittest
 
     class AntPatternToRETest(unittest.TestCase):
-##        def test_conversion( self ):
-##            self.assertEqual( '^somepath$', ant_pattern_to_re( 'somepath' ).pattern )
-
-        def test_matching( self ):
-            test_cases = [ ( 'path',
-                             ['path'],
-                             ['somepath', 'pathsuffix', '/path', '/path'] ),
-                           ( '*.py',
-                             ['source.py', 'source.ext.py', '.py'],
-                             ['path/source.py', '/.py', 'dir.py/z', 'z.pyc', 'z.c'] ),
-                           ( '**/path',
-                             ['path', '/path', '/a/path', 'c:/a/path', '/a/b/path', '//a/path', '/a/path/b/path'],
-                             ['path/', 'a/path/b', 'dir.py/z', 'somepath', 'pathsuffix', 'a/somepath'] ),
-                           ( 'path/**',
-                             ['path/a', 'path/path/a', 'path//'],
-                             ['path', 'somepath/a', 'a/path', 'a/path/a', 'pathsuffix/a'] ),
-                           ( '/**/path',
-                             ['/path', '/a/path', '/a/b/path/path', '/path/path'],
-                             ['path', 'path/', 'a/path', '/pathsuffix', '/somepath'] ),
-                           ( 'a/b',
-                             ['a/b'],
-                             ['somea/b', 'a/bsuffix', 'a/b/c'] ),
-                           ( '**/*.py',
-                             ['script.py', 'src/script.py', 'a/b/script.py', '/a/b/script.py'],
-                             ['script.pyc', 'script.pyo', 'a.py/b'] ),
-                           ( 'src/**/*.py',
-                             ['src/a.py', 'src/dir/a.py'],
-                             ['a/src/a.py', '/src/a.py'] ),
-                           ]
-            for ant_pattern, accepted_matches, rejected_matches in list(test_cases):
-                def local_path( paths ):
-                    return [ p.replace('/',os.path.sep) for p in paths ]
-                test_cases.append( (ant_pattern, local_path(accepted_matches), local_path( rejected_matches )) )
-            for ant_pattern, accepted_matches, rejected_matches in test_cases:
-                rex = ant_pattern_to_re( ant_pattern )
-                print 'ant_pattern:', ant_pattern, ' => ', rex.pattern
-                for accepted_match in accepted_matches:
-                    print 'Accepted?:', accepted_match
-                    self.assert_( rex.match( accepted_match ) is not None )
-                for rejected_match in rejected_matches:
-                    print 'Rejected?:', rejected_match
-                    self.assert_( rex.match( rejected_match ) is None )
+##        def test_conversion(self):
+##            self.assertEqual('^somepath$', ant_pattern_to_re('somepath').pattern)
+
+        def test_matching(self):
+            test_cases = [ ('path',
+                             ['path'],
+                             ['somepath', 'pathsuffix', '/path', '/path']),
+                           ('*.py',
+                             ['source.py', 'source.ext.py', '.py'],
+                             ['path/source.py', '/.py', 'dir.py/z', 'z.pyc', 'z.c']),
+                           ('**/path',
+                             ['path', '/path', '/a/path', 'c:/a/path', '/a/b/path', '//a/path', '/a/path/b/path'],
+                             ['path/', 'a/path/b', 'dir.py/z', 'somepath', 'pathsuffix', 'a/somepath']),
+                           ('path/**',
+                             ['path/a', 'path/path/a', 'path//'],
+                             ['path', 'somepath/a', 'a/path', 'a/path/a', 'pathsuffix/a']),
+                           ('/**/path',
+                             ['/path', '/a/path', '/a/b/path/path', '/path/path'],
+                             ['path', 'path/', 'a/path', '/pathsuffix', '/somepath']),
+                           ('a/b',
+                             ['a/b'],
+                             ['somea/b', 'a/bsuffix', 'a/b/c']),
+                           ('**/*.py',
+                             ['script.py', 'src/script.py', 'a/b/script.py', '/a/b/script.py'],
+                             ['script.pyc', 'script.pyo', 'a.py/b']),
+                           ('src/**/*.py',
+                             ['src/a.py', 'src/dir/a.py'],
+                             ['a/src/a.py', '/src/a.py']),
+                           ]
+            for ant_pattern, accepted_matches, rejected_matches in list(test_cases):
+                def local_path(paths):
+                    return [ p.replace('/',os.path.sep) for p in paths ]
+                test_cases.append((ant_pattern, local_path(accepted_matches), local_path(rejected_matches)))
+            for ant_pattern, accepted_matches, rejected_matches in test_cases:
+                rex = ant_pattern_to_re(ant_pattern)
+                print('ant_pattern:', ant_pattern, ' => ', rex.pattern)
+                for accepted_match in accepted_matches:
+                    print('Accepted?:', accepted_match)
+                    self.assertTrue(rex.match(accepted_match) is not None)
+                for rejected_match in rejected_matches:
+                    print('Rejected?:', rejected_match)
+                    self.assertTrue(rex.match(rejected_match) is None)
 
     unittest.main()

devtools/batchbuild.py

@@ -0,0 +1,278 @@
+from __future__ import print_function
+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 list(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: ', end=' ')
+        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:', end=' ')
+        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 = list(build_descs_by_axis.keys())
+    build_descs = []
+    for axis_name, axis_build_descs in list(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()
+

devtools/fixeol.py

@@ -1,63 +1,64 @@
-import os.path
-
-def fix_source_eol( path, is_dry_run = True, verbose = True, eol = '\n' ):
-    """Makes sure that all sources have the specified eol sequence (default: unix)."""
-    if not os.path.isfile( path ):
-        raise ValueError( 'Path "%s" is not a file' % path )
-    try:
-        f = open(path, 'rb')
-    except IOError, msg:
-        print >> sys.stderr, "%s: I/O Error: %s" % (file, str(msg))
-        return False
-    try:
-        raw_lines = f.readlines()
-    finally:
-        f.close()
-    fixed_lines = [line.rstrip('\r\n') + eol for line in raw_lines]
-    if raw_lines != fixed_lines:
-        print '%s =>' % path,
-        if not is_dry_run:
-            f = open(path, "wb")
-            try:
-                f.writelines(fixed_lines)
-            finally:
-                f.close()
-        if verbose:
-            print is_dry_run and ' NEED FIX' or ' FIXED'
-    return True
-##    
-##    
-##
-##def _do_fix( is_dry_run = True ):
-##    from waftools import antglob
-##    python_sources = antglob.glob( '.',
-##        includes = '**/*.py **/wscript **/wscript_build',
-##        excludes = antglob.default_excludes + './waf.py',
-##        prune_dirs = antglob.prune_dirs + 'waf-* ./build' )
-##    for path in python_sources:
-##        _fix_python_source( path, is_dry_run )
-##
-##    cpp_sources = antglob.glob( '.',
-##        includes = '**/*.cpp **/*.h **/*.inl',
-##        prune_dirs = antglob.prune_dirs + 'waf-* ./build' )
-##    for path in cpp_sources:
-##        _fix_source_eol( path, is_dry_run )
-##
-##
-##def dry_fix(context):
-##    _do_fix( is_dry_run = True )
-##
-##def fix(context):
-##    _do_fix( is_dry_run = False )
-##
-##def shutdown():
-##    pass
-##
-##def check(context):
-##    # Unit tests are run when "check" target is used
-##    ut = UnitTest.unit_test()
-##    ut.change_to_testfile_dir = True
-##    ut.want_to_see_test_output = True
-##    ut.want_to_see_test_error = True
-##    ut.run()
-##    ut.print_results()
+from __future__ import print_function
+import os.path
+
+def fix_source_eol(path, is_dry_run = True, verbose = True, eol = '\n'):
+    """Makes sure that all sources have the specified eol sequence (default: unix)."""
+    if not os.path.isfile(path):
+        raise ValueError('Path "%s" is not a file' % path)
+    try:
+        f = open(path, 'rb')
+    except IOError as msg:
+        print("%s: I/O Error: %s" % (file, str(msg)), file=sys.stderr)
+        return False
+    try:
+        raw_lines = f.readlines()
+    finally:
+        f.close()
+    fixed_lines = [line.rstrip('\r\n') + eol for line in raw_lines]
+    if raw_lines != fixed_lines:
+        print('%s =>' % path, end=' ')
+        if not is_dry_run:
+            f = open(path, "wb")
+            try:
+                f.writelines(fixed_lines)
+            finally:
+                f.close()
+        if verbose:
+            print(is_dry_run and ' NEED FIX' or ' FIXED')
+    return True
+##    
+##    
+##
+##def _do_fix(is_dry_run = True):
+##    from waftools import antglob
+##    python_sources = antglob.glob('.',
+##        includes = '**/*.py **/wscript **/wscript_build',
+##        excludes = antglob.default_excludes + './waf.py',
+##        prune_dirs = antglob.prune_dirs + 'waf-* ./build')
+##    for path in python_sources:
+##        _fix_python_source(path, is_dry_run)
+##
+##    cpp_sources = antglob.glob('.',
+##        includes = '**/*.cpp **/*.h **/*.inl',
+##        prune_dirs = antglob.prune_dirs + 'waf-* ./build')
+##    for path in cpp_sources:
+##        _fix_source_eol(path, is_dry_run)
+##
+##
+##def dry_fix(context):
+##    _do_fix(is_dry_run = True)
+##
+##def fix(context):
+##    _do_fix(is_dry_run = False)
+##
+##def shutdown():
+##    pass
+##
+##def check(context):
+##    # Unit tests are run when "check" target is used
+##    ut = UnitTest.unit_test()
+##    ut.change_to_testfile_dir = True
+##    ut.want_to_see_test_output = True
+##    ut.want_to_see_test_error = True
+##    ut.run()
+##    ut.print_results()

devtools/licenseupdater.py

@@ -0,0 +1,94 @@
+"""Updates the license text in source file.
+"""
+from __future__ import print_function
+
+# An existing license is found if the file starts with the string below,
+# and ends with the first blank line.
+LICENSE_BEGIN = "// Copyright "
+
+BRIEF_LICENSE = LICENSE_BEGIN + """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
+
+""".replace('\r\n','\n')
+
+def update_license(path, dry_run, show_diff):
+    """Update the license statement in the specified file.
+    Parameters:
+      path: path of the C++ source file to update.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file. 
+    """
+    with open(path, 'rt') as fin:
+        original_text = fin.read().replace('\r\n','\n')
+        newline = fin.newlines and fin.newlines[0] or '\n'
+    if not original_text.startswith(LICENSE_BEGIN):
+        # No existing license found => prepend it
+        new_text = BRIEF_LICENSE + original_text
+    else:
+        license_end_index = original_text.index('\n\n') # search first blank line
+        new_text = BRIEF_LICENSE + original_text[license_end_index+2:]
+    if original_text != new_text:
+        if not dry_run:
+            with open(path, 'wb') as fout:
+                fout.write(new_text.replace('\n', newline))
+        print('Updated', path)
+        if show_diff:
+            import difflib
+            print('\n'.join(difflib.unified_diff(original_text.split('\n'),
+                                                   new_text.split('\n'))))
+        return True
+    return False
+
+def update_license_in_source_directories(source_dirs, dry_run, show_diff):
+    """Updates license text in C++ source files found in directory source_dirs.
+    Parameters:
+      source_dirs: list of directory to scan for C++ sources. Directories are
+                   scanned recursively.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file. 
+    """
+    from devtools import antglob
+    prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist'
+    for source_dir in source_dirs:
+        cpp_sources = antglob.glob(source_dir,
+            includes = '''**/*.h **/*.cpp **/*.inl''',
+            prune_dirs = prune_dirs)
+        for source in cpp_sources:
+            update_license(source, dry_run, show_diff)
+
+def main():
+    usage = """%prog DIR [DIR2...]
+Updates license text in sources of the project in source files found
+in the directory specified on the command-line.
+
+Example of call:
+python devtools\licenseupdater.py include src -n --diff
+=> Show change that would be made to the sources.
+
+python devtools\licenseupdater.py include src
+=> Update license statement on all sources in directories include/ and src/.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('-n', '--dry-run', dest="dry_run", action='store_true', default=False,
+        help="""Only show what files are updated, do not update the files""")
+    parser.add_option('--diff', dest="show_diff", action='store_true', default=False,
+        help="""On update, show change made to the file.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    update_license_in_source_directories(args, options.dry_run, options.show_diff)
+    print('Done')
+
+if __name__ == '__main__':
+    import sys
+    import os.path
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    main()
+

devtools/tarball.py

@@ -1,53 +1,47 @@
-import os.path
-import gzip
-import tarfile
-
-TARGZ_DEFAULT_COMPRESSION_LEVEL = 9
-
-def make_tarball(tarball_path, sources, base_dir, prefix_dir=''):
-    """Parameters:
-    tarball_path: output path of the .tar.gz file
-    sources: list of sources to include in the tarball, relative to the current directory
-    base_dir: if a source file is in a sub-directory of base_dir, then base_dir is stripped
-        from path in the tarball.
-    prefix_dir: all files stored in the tarball be sub-directory of prefix_dir. Set to ''
-        to make them child of root.
-    """
-    base_dir = os.path.normpath( os.path.abspath( base_dir ) )
-    def archive_name( path ):
-        """Makes path relative to base_dir."""
-        path = os.path.normpath( os.path.abspath( path ) )
-        common_path = os.path.commonprefix( (base_dir, path) )
-        archive_name = path[len(common_path):]
-        if os.path.isabs( archive_name ):
-            archive_name = archive_name[1:]
-        return os.path.join( prefix_dir, archive_name )
-    def visit(tar, dirname, names):
-        for name in names:
-            path = os.path.join(dirname, name)
-            if os.path.isfile(path):
-                path_in_tar = archive_name(path)
-                tar.add(path, path_in_tar )
-    compression = TARGZ_DEFAULT_COMPRESSION_LEVEL
-    tar = tarfile.TarFile.gzopen( tarball_path, 'w', compresslevel=compression )
-    try:
-        for source in sources:
-            source_path = source
-            if os.path.isdir( source ):
-                os.path.walk(source_path, visit, tar)
-            else:
-                path_in_tar = archive_name(source_path)
-                tar.add(source_path, path_in_tar )      # filename, arcname
-    finally:
-        tar.close()
-
-def decompress( tarball_path, base_dir ):
-    """Decompress the gzipped tarball into directory base_dir.
-    """
-    # !!! This class method is not documented in the online doc
-    # nor is bz2open!
-    tar = tarfile.TarFile.gzopen(tarball_path, mode='r')
-    try:
-        tar.extractall( base_dir )
-    finally:
-        tar.close()
+from contextlib import closing
+import os
+import tarfile
+
+TARGZ_DEFAULT_COMPRESSION_LEVEL = 9
+
+def make_tarball(tarball_path, sources, base_dir, prefix_dir=''):
+    """Parameters:
+    tarball_path: output path of the .tar.gz file
+    sources: list of sources to include in the tarball, relative to the current directory
+    base_dir: if a source file is in a sub-directory of base_dir, then base_dir is stripped
+        from path in the tarball.
+    prefix_dir: all files stored in the tarball be sub-directory of prefix_dir. Set to ''
+        to make them child of root.
+    """
+    base_dir = os.path.normpath(os.path.abspath(base_dir))
+    def archive_name(path):
+        """Makes path relative to base_dir."""
+        path = os.path.normpath(os.path.abspath(path))
+        common_path = os.path.commonprefix((base_dir, path))
+        archive_name = path[len(common_path):]
+        if os.path.isabs(archive_name):
+            archive_name = archive_name[1:]
+        return os.path.join(prefix_dir, archive_name)
+    def visit(tar, dirname, names):
+        for name in names:
+            path = os.path.join(dirname, name)
+            if os.path.isfile(path):
+                path_in_tar = archive_name(path)
+                tar.add(path, path_in_tar)
+    compression = TARGZ_DEFAULT_COMPRESSION_LEVEL
+    with closing(tarfile.TarFile.open(tarball_path, 'w:gz',
+            compresslevel=compression)) as tar:
+        for source in sources:
+            source_path = source
+            if os.path.isdir(source):
+                for dirpath, dirnames, filenames in os.walk(source_path):
+                    visit(tar, dirpath, filenames)
+            else:
+                path_in_tar = archive_name(source_path)
+                tar.add(source_path, path_in_tar)      # filename, arcname
+
+def decompress(tarball_path, base_dir):
+    """Decompress the gzipped tarball into directory base_dir.
+    """
+    with closing(tarfile.TarFile.open(tarball_path)) as tar:
+        tar.extractall(base_dir)

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="http://open-source-parsers.github.io/jsoncpp-docs/doxygen/">JsonCpp home page</a>
     </td>
   </tr>
 </table>

doc/jsoncpp.dox

@@ -4,11 +4,21 @@
 
 <a HREF="http://www.json.org/">JSON (JavaScript Object Notation)</a>
  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.
 
 Here is an example of JSON data:
 \verbatim
+{
+    "encoding" : "UTF-8",
+    "plug-ins" : [
+        "python",
+        "c++",
+        "ruby"
+        ],
+    "indent" : { "length" : 3, "use_space": true }
+}
+\endverbatim
+<b>JsonCpp</b> supports comments as <i>meta-data</i>:
+\code
 // Configuration options
 {
     // Default encoding for text
@@ -17,21 +27,22 @@ Here is an example of JSON data:
     // Plug-ins loaded at start-up
     "plug-ins" : [
         "python",
-        "c++",
+        "c++",  // trailing comment
         "ruby"
         ],
         
     // Tab indent size
-    "indent" : { "length" : 3, "use_space" = true }
+    // (multi-line comment)
+    "indent" : { /*embedded comment*/ "length" : 3, "use_space": true }
 }
-\endverbatim
+\endcode
 
 \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 
+Notes: Comments used to be supported in JSON but were removed for
 portability (C like comments are not supported in Python). Since
 comments are useful in configuration/input file, this feature was
 preserved.
@@ -39,78 +50,115 @@ preserved.
 \section _example Code example
 
 \code
-Json::Value root;   // will contains the root value after parsing.
-Json::Reader reader;
-bool parsingSuccessful = reader.parse( config_doc, root );
-if ( !parsingSuccessful )
-{
-    // report to the user the failure and their locations in the document.
-    std::cout  << "Failed to parse configuration\n"
-               << reader.getFormatedErrorMessages();
-    return;
-}
+Json::Value root;   // 'root' will contain the root value after parsing.
+std::cin >> root;
 
-// Get the value of the member of root named 'encoding', return 'UTF-8' if there is no
-// such member.
-std::string encoding = root.get("encoding", "UTF-8" ).asString();
-// Get the value of the member of root named 'encoding', return a 'null' value if
-// there is no such member.
-const Json::Value plugins = root["plug-ins"];
-for ( int index = 0; index < plugins.size(); ++index )  // Iterates over the sequence elements.
-   loadPlugIn( plugins[index].asString() );
-   
-setIndentLength( root["indent"].get("length", 3).asInt() );
-setIndentUseSpace( root["indent"].get("use_space", true).asBool() );
-
-// ...
-// At application shutdown to make the new configuration document:
-// Since Json::Value has implicit constructor for all value types, it is not
-// necessary to explicitly construct the Json::Value object:
-root["encoding"] = getCurrentEncoding();
-root["indent"]["length"] = getCurrentIndentLength();
-root["indent"]["use_space"] = getCurrentIndentUseSpace();
-
-Json::StyledWriter writer;
-// Make a new JSON document for the configuration. Preserve original comments.
-std::string outputConfig = writer.write( root );
-
-// You can also use streams.  This will put the contents of any JSON
-// stream at a particular sub-value, if you'd like.
+// You can also read into a particular sub-value.
 std::cin >> root["subtree"];
 
-// And you can write to a stream, using the StyledWriter automatically.
+// Get the value of the member of root named 'encoding',
+// and return 'UTF-8' if there is no such member.
+std::string encoding = root.get("encoding", "UTF-8" ).asString();
+
+// Get the value of the member of root named 'plug-ins'; return a 'null' value if
+// there is no such member.
+const Json::Value plugins = root["plug-ins"];
+
+// Iterate over the sequence elements.
+for ( int index = 0; index < plugins.size(); ++index )
+   loadPlugIn( plugins[index].asString() );
+   
+// Try other datatypes. Some are auto-convertible to others.
+foo::setIndentLength( root["indent"].get("length", 3).asInt() );
+foo::setIndentUseSpace( root["indent"].get("use_space", true).asBool() );
+
+// Since Json::Value has an implicit constructor for all value types, it is not
+// necessary to explicitly construct the Json::Value object.
+root["encoding"] = foo::getCurrentEncoding();
+root["indent"]["length"] = foo::getCurrentIndentLength();
+root["indent"]["use_space"] = foo::getCurrentIndentUseSpace();
+
+// If you like the defaults, you can insert directly into a stream.
 std::cout << root;
+// Of course, you can write to `std::ostringstream` if you prefer.
+
+// If desired, remember to add a linefeed and flush.
+std::cout << std::endl;
 \endcode
 
-\section _plinks Build instructions
+\section _advanced Advanced usage
+
+Configure *builders* to create *readers* and *writers*. For
+configuration, we use our own `Json::Value` (rather than
+standard setters/getters) so that we can add
+features without losing binary-compatibility.
+
+\code
+// For convenience, use `writeString()` with a specialized builder.
+Json::StreamWriterBuilder wbuilder;
+wbuilder["indentation"] = "\t";
+std::string document = Json::writeString(wbuilder, root);
+
+// Here, using a specialized Builder, we discard comments and
+// record errors as we parse.
+Json::CharReaderBuilder rbuilder;
+rbuilder["collectComments"] = false;
+std::string errs;
+bool ok = Json::parseFromStream(rbuilder, std::cin, &root, &errs);
+\endcode
+
+Yes, compile-time configuration-checking would be helpful,
+but `Json::Value` lets you
+write and read the builder configuration, which is better! In other words,
+you can configure your JSON parser using JSON.
+
+CharReaders and StreamWriters are not thread-safe, but they are re-usable.
+\code
+Json::CharReaderBuilder rbuilder;
+cfg >> rbuilder.settings_;
+std::unique_ptr<Json::CharReader> const reader(rbuilder.newCharReader());
+reader->parse(start, stop, &value1, &errs);
+// ...
+reader->parse(start, stop, &value2, &errs);
+// etc.
+\endcode
+
+\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://svn.sourceforge.net/viewcvs.cgi/jsoncpp/README.txt?view=markup">latest README.txt</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 _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>.
-
-\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>
+\section _news What's New?
+The description of latest changes can be found in 
+<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 _license License
-The json-cpp library and this documentation are in Public Domain.
+\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>
 
-\author Baptiste Lepilleur <blep@users.sourceforge.net>
+\section _license License
+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> (originator)
+\author Christopher Dunn <cdunn2001@gmail.com> (primary maintainer)
+\version \include version
+We make strong guarantees about binary-compatibility, consistent with
+<a href="http://apr.apache.org/versioning.html">the Apache versioning scheme</a>.
+\sa version.h
 */

doc/roadmap.dox

@@ -1,32 +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
-  - Release on sourceforge download
-  \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_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
+  Moved to: https://github.com/open-source-parsers/jsoncpp/wiki/Roadmap
 */

doxybuild.py

@@ -1,12 +1,27 @@
 """Script to generate doxygen documentation.
 """
-
+from __future__ import print_function
+from __future__ import unicode_literals
+from devtools import tarball
+from contextlib import contextmanager
+import subprocess
+import traceback
 import re
 import os
-import os.path
 import sys
 import shutil
-from devtools import tarball
+
+@contextmanager
+def cd(newdir):
+    """
+    http://stackoverflow.com/questions/431684/how-do-i-cd-in-python
+    """
+    prevdir = os.getcwd()
+    os.chdir(newdir)
+    try:
+        yield
+    finally:
+        os.chdir(prevdir)
 
 def find_program(*filenames):
     """find a program in folders path_lst, and sets env[var]
@@ -14,7 +29,7 @@ def find_program(*filenames):
     @return: the full path of the filename if found, or '' if filename could not be found
 """
     paths = os.environ.get('PATH', '').split(os.pathsep)
-    suffixes = ('win32' in sys.platform ) and '.exe .com .bat .cmd' or ''
+    suffixes = ('win32' in sys.platform) and '.exe .com .bat .cmd' or ''
     for filename in filenames:
         for name in [filename+ext for ext in suffixes.split()]:
             for directory in paths:
@@ -28,53 +43,56 @@ def do_subst_in_file(targetfile, sourcefile, dict):
     For example, if dict is {'%VERSION%': '1.2345', '%BASE%': 'MyProg'},
     then all instances of %VERSION% in the file will be replaced with 1.2345 etc.
     """
-    try:
-        f = open(sourcefile, 'rb')
+    with open(sourcefile, 'r') as f:
         contents = f.read()
-        f.close()
-    except:
-        print "Can't read source file %s"%sourcefile
-        raise
-    for (k,v) in dict.items():
+    for (k,v) in list(dict.items()):
         v = v.replace('\\','\\\\') 
         contents = re.sub(k, v, contents)
-    try:
-        f = open(targetfile, 'wb')
+    with open(targetfile, 'w') as f:
         f.write(contents)
-        f.close()
+
+def getstatusoutput(cmd):
+    """cmd is a list.
+    """
+    try:
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        output, _ = process.communicate()
+        status = process.returncode
     except:
-        print "Can't write target file %s"%targetfile
-        raise
+        status = -1
+        output = traceback.format_exc()
+    return status, output
+
+def run_cmd(cmd, silent=False):
+    """Raise exception on failure.
+    """
+    info = 'Running: %r in %r' %(' '.join(cmd), os.getcwd())
+    print(info)
+    sys.stdout.flush()
+    if silent:
+        status, output = getstatusoutput(cmd)
+    else:
+        status, output = os.system(' '.join(cmd)), ''
+    if status:
+        msg = 'Error while %s ...\n\terror=%d, output="""%s"""' %(info, status, output)
+        raise Exception(msg)
+
+def assert_is_exe(path):
+    if not path:
+        raise Exception('path is empty.')
+    if not os.path.isfile(path):
+        raise Exception('%r is not a file.' %path)
+    if not os.access(path, os.X_OK):
+        raise Exception('%r is not executable by this user.' %path)
 
 def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
-    config_file = os.path.abspath( config_file )
-    doxygen_path = doxygen_path
-    old_cwd = os.getcwd()
-    try:
-        os.chdir( working_dir )
+    assert_is_exe(doxygen_path)
+    config_file = os.path.abspath(config_file)
+    with cd(working_dir):
         cmd = [doxygen_path, config_file]
-        print 'Running:', ' '.join( cmd )
-        try:
-            import subprocess
-        except:
-            if os.system( ' '.join( cmd ) ) != 0:
-                print 'Documentation generation failed'
-                return False
-        else:
-            if is_silent:
-                process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT )
-            else:
-                process = subprocess.Popen( cmd )
-            stdout, _ = process.communicate()
-            if process.returncode:
-                print 'Documentation generation failed:'
-                print stdout
-                return False
-        return True
-    finally:
-        os.chdir( old_cwd )
+        run_cmd(cmd, is_silent)
 
-def build_doc( options,  make_release=False ):
+def build_doc(options,  make_release=False):
     if make_release:
         options.make_tarball = True
         options.with_dot = True
@@ -83,54 +101,56 @@ def build_doc( options,  make_release=False ):
         options.open = False
         options.silent = True
 
-    version = open('version','rt').read().strip()
+    version = open('version', 'rt').read().strip()
     output_dir = 'dist/doxygen' # relative to doc/doxyfile location.
-    if not os.path.isdir( output_dir ):
-        os.makedirs( output_dir )
-    top_dir = os.path.abspath( '.' )
+    if not os.path.isdir(output_dir):
+        os.makedirs(output_dir)
+    top_dir = os.path.abspath('.')
     html_output_dirname = 'jsoncpp-api-html-' + version
-    tarball_path = os.path.join( 'dist', html_output_dirname + '.tar.gz' )
-    warning_log_path = os.path.join( output_dir, '../jsoncpp-doxygen-warning.log' )
-    html_output_path = os.path.join( output_dir, html_output_dirname )
-    def yesno( bool ):
+    tarball_path = os.path.join('dist', html_output_dirname + '.tar.gz')
+    warning_log_path = os.path.join(output_dir, '../jsoncpp-doxygen-warning.log')
+    html_output_path = os.path.join(output_dir, html_output_dirname)
+    def yesno(bool):
         return bool and 'YES' or 'NO'
     subst_keys = {
         '%JSONCPP_VERSION%': version,
         '%DOC_TOPDIR%': '',
         '%TOPDIR%': top_dir,
-        '%HTML_OUTPUT%': os.path.join( '..', output_dir, html_output_dirname ),
+        '%HTML_OUTPUT%': os.path.join('..', output_dir, html_output_dirname),
         '%HAVE_DOT%': yesno(options.with_dot),
         '%DOT_PATH%': os.path.split(options.dot_path)[0],
         '%HTML_HELP%': yesno(options.with_html_help),
         '%UML_LOOK%': yesno(options.with_uml_look),
-        '%WARNING_LOG_PATH%': os.path.join( '..', warning_log_path )
+        '%WARNING_LOG_PATH%': os.path.join('..', warning_log_path)
         }
 
-    if os.path.isdir( output_dir ):
-        print 'Deleting directory:', output_dir
-        shutil.rmtree( output_dir )
-    if not os.path.isdir( output_dir ):
-        os.makedirs( output_dir )
+    if os.path.isdir(output_dir):
+        print('Deleting directory:', output_dir)
+        shutil.rmtree(output_dir)
+    if not os.path.isdir(output_dir):
+        os.makedirs(output_dir)
 
-    do_subst_in_file( 'doc/doxyfile', 'doc/doxyfile.in', subst_keys )
-    ok = run_doxygen( options.doxygen_path, 'doc/doxyfile', 'doc', is_silent=options.silent )
+    do_subst_in_file('doc/doxyfile', options.doxyfile_input_path, subst_keys)
+    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'))
-    print 'Generated documentation can be found in:'
-    print index_path
+        print(open(warning_log_path, 'r').read())
+    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:
         import webbrowser
-        webbrowser.open( 'file://' + index_path )
+        webbrowser.open('file://' + index_path)
     if options.make_tarball:
-        print 'Generating doc tarball to', tarball_path
+        print('Generating doc tarball to', tarball_path)
         tarball_sources = [
             output_dir,
-            'README.txt',
+            'README.md',
+            'LICENSE',
+            'NEWS.txt',
             'version'
             ]
-        tarball_basedir = os.path.join( output_dir, html_output_dirname )
-        tarball.make_tarball( tarball_path, tarball_sources, tarball_basedir, html_output_dirname )
+        tarball_basedir = os.path.join(output_dir, html_output_dirname)
+        tarball.make_tarball(tarball_path, tarball_sources, tarball_basedir, html_output_dirname)
     return tarball_path, html_output_dirname
 
 def main():
@@ -149,6 +169,8 @@ def main():
         help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""")
     parser.add_option('--doxygen', dest="doxygen_path", action='store', default=find_program('doxygen'),
         help="""Path to Doxygen tool. [Default: %default]""")
+    parser.add_option('--in', dest="doxyfile_input_path", action='store', default='doc/doxyfile.in',
+        help="""Path to doxygen inputs. [Default: %default]""")
     parser.add_option('--with-html-help', dest="with_html_help", action='store_true', default=False,
         help="""Enable generation of Microsoft HTML HELP""")
     parser.add_option('--no-uml-look', dest="with_uml_look", action='store_false', default=True,
@@ -161,7 +183,7 @@ def main():
         help="""Hides doxygen output""")
     parser.enable_interspersed_args()
     options, args = parser.parse_args()
-    build_doc( options )
+    build_doc(options)
 
 if __name__ == '__main__':
     main()

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

include/json/autolink.h

@@ -1,19 +1,25 @@
+// 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 JSON_AUTOLINK_H_INCLUDED
-# define JSON_AUTOLINK_H_INCLUDED
+#define JSON_AUTOLINK_H_INCLUDED
 
-# include "config.h"
+#include "config.h"
 
-# ifdef JSON_IN_CPPTL
-#  include <cpptl/cpptl_autolink.h>
-# endif
+#ifdef JSON_IN_CPPTL
+#include <cpptl/cpptl_autolink.h>
+#endif
 
-# 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
-#   define CPPTL_AUTOLINK_DLL
-#  endif
-#  include "autolink.h"
-# endif
+#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
+#define CPPTL_AUTOLINK_DLL
+#endif
+#include "autolink.h"
+#endif
 
 #endif // JSON_AUTOLINK_H_INCLUDED

include/json/config.h

@@ -1,43 +1,109 @@
+// 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 JSON_CONFIG_H_INCLUDED
-# define JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
 
 /// If defined, indicates that json library is embedded in CppTL library.
 //# define JSON_IN_CPPTL 1
 
 /// 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!
-//#  define JSON_VALUE_USE_INTERNAL_MAP 1
-/// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
-/// The memory pools allocator used optimization (initializing Value and ValueInternalLink
-/// as if it was a POD) that may cause some validation tool to report errors.
-/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
-//#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
 
-/// If defined, indicates that Json use exception to report invalid type manipulation
-/// instead of C assert macro.
-# define JSON_USE_EXCEPTION 1
+// 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
 
-# ifdef JSON_IN_CPPTL
-#  include <cpptl/config.h>
-#  ifndef JSON_USE_CPPTL
-#   define JSON_USE_CPPTL 1
-#  endif
-# 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
-#  define JSON_API CPPTL_API
-# elif defined(JSON_DLL_BUILD)
-#  define JSON_API __declspec(dllexport)
-# elif defined(JSON_DLL)
-#  define JSON_API __declspec(dllimport)
-# else
-#  define JSON_API
-# endif
+#ifdef JSON_IN_CPPTL
+#include <cpptl/config.h>
+#ifndef JSON_USE_CPPTL
+#define JSON_USE_CPPTL 1
+#endif
+#endif
+
+#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)
+#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
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200 // MSVC 6
+// 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
+/// Indicates that the following function is deprecated.
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__clang__) && defined(__has_feature)
+#if __has_feature(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#endif
+#elif defined(__GNUC__) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#elif defined(__GNUC__) &&  (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message)  __attribute__((__deprecated__))
+#endif
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+namespace Json {
+typedef int Int;
+typedef unsigned int UInt;
+#if defined(JSON_NO_INT64)
+typedef int LargestInt;
+typedef unsigned int LargestUInt;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+typedef __int64 Int64;
+typedef unsigned __int64 UInt64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+typedef long long int Int64;
+typedef unsigned long long int UInt64;
+#endif // if defined(_MSC_VER)
+typedef Int64 LargestInt;
+typedef UInt64 LargestUInt;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+} // end namespace Json
 
 #endif // JSON_CONFIG_H_INCLUDED

include/json/features.h

@@ -1,42 +1,51 @@
-#ifndef CPPTL_JSON_FEATURES_H_INCLUDED
-# define CPPTL_JSON_FEATURES_H_INCLUDED
-
-# include "forwards.h"
-
-namespace Json {
-
-   /** \brief Configuration passed to reader and writer.
-    * This configuration object can be used to force the Reader or Writer
-    * to behave in a standard conforming way.
-    */
-   class JSON_API Features
-   {
-   public:
-      /** \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.
-       * - Comments are forbidden.
-       * - Root object must be either an array or an object value.
-       * - Assumes Value strings are encoded in UTF-8
-       */
-      static Features strictMode();
-
-      /** \brief Initialize the configuration like JsonConfig::allFeatures;
-       */
-      Features();
-
-      /// \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.
-      bool strictRoot_;
-   };
-
-} // namespace Json
-
-#endif // CPPTL_JSON_FEATURES_H_INCLUDED
+// 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_FEATURES_H_INCLUDED
+#define CPPTL_JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+/** \brief Configuration passed to reader and writer.
+ * This configuration object can be used to force the Reader or Writer
+ * to behave in a standard conforming way.
+ */
+class JSON_API Features {
+public:
+  /** \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.
+   * - Comments are forbidden.
+   * - Root object must be either an array or an object value.
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features strictMode();
+
+  /** \brief Initialize the configuration like JsonConfig::allFeatures;
+   */
+  Features();
+
+  /// \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.
+  bool strictRoot_;
+};
+
+} // namespace Json
+
+#endif // CPPTL_JSON_FEATURES_H_INCLUDED

include/json/forwards.h

@@ -1,39 +1,37 @@
-#ifndef JSON_FORWARDS_H_INCLUDED
-# define JSON_FORWARDS_H_INCLUDED
+// 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
 
-# include "config.h"
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
 
 namespace Json {
 
-   // writer.h
-   class FastWriter;
-   class StyledWriter;
+// writer.h
+class FastWriter;
+class StyledWriter;
 
-   // reader.h
-   class Reader;
+// reader.h
+class Reader;
 
-   // features.h
-   class Features;
+// features.h
+class Features;
 
-   // value.h
-   typedef int Int;
-   typedef unsigned int UInt;
-   class StaticString;
-   class Path;
-   class PathArgument;
-   class Value;
-   class ValueIteratorBase;
-   class ValueIterator;
-   class ValueConstIterator;
-#ifdef JSON_VALUE_USE_INTERNAL_MAP
-   class ValueAllocator;
-   class ValueMapAllocator;
-   class ValueInternalLink;
-   class ValueInternalArray;
-   class ValueInternalMap;
-#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+// value.h
+typedef unsigned int ArrayIndex;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
 
 } // namespace Json
 
-
 #endif // JSON_FORWARDS_H_INCLUDED

include/json/json.h

@@ -1,10 +1,15 @@
-#ifndef JSON_JSON_H_INCLUDED
-# define JSON_JSON_H_INCLUDED
+// 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
 
-# include "autolink.h"
-# include "value.h"
-# include "reader.h"
-# include "writer.h"
-# include "features.h"
+#ifndef JSON_JSON_H_INCLUDED
+#define JSON_JSON_H_INCLUDED
+
+#include "autolink.h"
+#include "value.h"
+#include "reader.h"
+#include "writer.h"
+#include "features.h"
 
 #endif // JSON_JSON_H_INCLUDED

include/json/reader.h

@@ -1,196 +1,357 @@
-#ifndef CPPTL_JSON_READER_H_INCLUDED
-# define CPPTL_JSON_READER_H_INCLUDED
+// 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
 
-# include "features.h"
-# include "value.h"
-# include <deque>
-# include <stack>
-# include <string>
-# include <iostream>
+#ifndef CPPTL_JSON_READER_H_INCLUDED
+#define CPPTL_JSON_READER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "features.h"
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <deque>
+#include <iosfwd>
+#include <stack>
+#include <string>
+#include <istream>
+
+// 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.
-    *
-    */
-   class JSON_API Reader
-   {
-   public:
-      typedef char Char;
-      typedef const Char *Location;
+/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
+ *Value.
+ *
+ * \deprecated Use CharReader and CharReaderBuilder.
+ */
+class JSON_API Reader {
+public:
+  typedef char Char;
+  typedef const Char* Location;
 
-      /** \brief Constructs a Reader allowing all features
-       * for parsing.
-       */
-      Reader();
-
-      /** \brief Constructs a Reader allowing the specified feature set
-       * for parsing.
-       */
-      Reader( const Features &features );
-
-      /** \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
-       *                        serialization, \c false to discard comments.
-       *                        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.
-       */
-      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 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
-       *                        serialization, \c false to discard comments.
-       *                        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.
-       */
-      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 );
-
-      /** \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 getFormatedErrorMessages() const;
-
-   private:
-      enum TokenType
-      {
-         tokenEndOfStream = 0,
-         tokenObjectBegin,
-         tokenObjectEnd,
-         tokenArrayBegin,
-         tokenArrayEnd,
-         tokenString,
-         tokenNumber,
-         tokenTrue,
-         tokenFalse,
-         tokenNull,
-         tokenArraySeparator,
-         tokenMemberSeparator,
-         tokenComment,
-         tokenError
-      };
-
-      class Token
-      {
-      public:
-         TokenType type_;
-         Location start_;
-         Location end_;
-      };
-
-      class ErrorInfo
-      {
-      public:
-         Token token_;
-         std::string message_;
-         Location extra_;
-      };
-
-      typedef std::deque<ErrorInfo> Errors;
-
-      bool expectToken( TokenType type, Token &token, const char *message );
-      bool readToken( Token &token );
-      void skipSpaces();
-      bool match( Location pattern, 
-                  int patternLength );
-      bool readComment();
-      bool readCStyleComment();
-      bool readCppStyleComment();
-      bool readString();
-      void readNumber();
-      bool readValue();
-      bool readObject( Token &token );
-      bool readArray( Token &token );
-      bool decodeNumber( Token &token );
-      bool decodeString( Token &token );
-      bool decodeString( Token &token, std::string &decoded );
-      bool decodeDouble( Token &token );
-      bool decodeUnicodeCodePoint( Token &token, 
-                                   Location &current, 
-                                   Location end, 
-                                   unsigned int &unicode );
-      bool decodeUnicodeEscapeSequence( Token &token, 
-                                        Location &current, 
-                                        Location end, 
-                                        unsigned int &unicode );
-      bool addError( const std::string &message, 
-                     Token &token,
-                     Location extra = 0 );
-      bool recoverFromError( TokenType skipUntilToken );
-      bool addErrorAndRecover( const std::string &message, 
-                               Token &token,
-                               TokenType skipUntilToken );
-      void skipUntilSpace();
-      Value &currentValue();
-      Char getNextChar();
-      void getLocationLineAndColumn( Location location,
-                                     int &line,
-                                     int &column ) const;
-      std::string getLocationLineAndColumn( Location location ) const;
-      void addComment( Location begin, 
-                       Location end, 
-                       CommentPlacement placement );
-      void skipCommentTokens( Token &token );
-   
-      typedef std::stack<Value *> Nodes;
-      Nodes nodes_;
-      Errors errors_;
-      std::string document_;
-      Location begin_;
-      Location end_;
-      Location current_;
-      Location lastValueEnd_;
-      Value *lastValue_;
-      std::string commentsBefore_;
-      Features features_;
-      bool collectComments_;
-   };
-
-   /** \brief Read from 'sin' into 'root'.
-
-    Always keep comments from the input JSON.
-
-    This can be used to read a file into a particular sub-object.
-    For example:
-    \code
-    Json::Value root;
-    cin >> root["dir"]["file"];
-    cout << root;
-    \endcode
-    Result:
-    \verbatim
-    {
-	"dir": {
-	    "file": {
-		// The input stream JSON would be nested here.
-	    }
-	}
-    }
-    \endverbatim
-    \throw std::exception on parse error.
-    \see Json::operator<<()
+  /** \brief Constructs a Reader allowing all features
+   * for parsing.
    */
-   std::istream& operator>>( std::istream&, Value& );
+  Reader();
+
+  /** \brief Constructs a Reader allowing the specified feature set
+   * for parsing.
+   */
+  Reader(const Features& features);
+
+  /** \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
+   *                        serialization, \c false to discard comments.
+   *                        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.
+   */
+  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.
+   *               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
+   *                        serialization, \c false to discard comments.
+   *                        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.
+   */
+  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);
+
+  /** \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
+   *         during parsing.
+   */
+  std::string getFormattedErrorMessages() const;
+
+private:
+  enum TokenType {
+    tokenEndOfStream = 0,
+    tokenObjectBegin,
+    tokenObjectEnd,
+    tokenArrayBegin,
+    tokenArrayEnd,
+    tokenString,
+    tokenNumber,
+    tokenTrue,
+    tokenFalse,
+    tokenNull,
+    tokenArraySeparator,
+    tokenMemberSeparator,
+    tokenComment,
+    tokenError
+  };
+
+  class Token {
+  public:
+    TokenType type_;
+    Location start_;
+    Location end_;
+  };
+
+  class ErrorInfo {
+  public:
+    Token token_;
+    std::string message_;
+    Location extra_;
+  };
+
+  typedef std::deque<ErrorInfo> Errors;
+
+  bool readToken(Token& token);
+  void skipSpaces();
+  bool match(Location pattern, int patternLength);
+  bool readComment();
+  bool readCStyleComment();
+  bool readCppStyleComment();
+  bool readString();
+  void readNumber();
+  bool readValue();
+  bool readObject(Token& token);
+  bool readArray(Token& token);
+  bool decodeNumber(Token& token);
+  bool decodeNumber(Token& token, Value& decoded);
+  bool decodeString(Token& token);
+  bool decodeString(Token& token, std::string& decoded);
+  bool decodeDouble(Token& token);
+  bool decodeDouble(Token& token, Value& decoded);
+  bool decodeUnicodeCodePoint(Token& token,
+                              Location& current,
+                              Location end,
+                              unsigned int& unicode);
+  bool decodeUnicodeEscapeSequence(Token& token,
+                                   Location& current,
+                                   Location end,
+                                   unsigned int& unicode);
+  bool addError(const std::string& message, Token& token, Location extra = 0);
+  bool recoverFromError(TokenType skipUntilToken);
+  bool addErrorAndRecover(const std::string& message,
+                          Token& token,
+                          TokenType skipUntilToken);
+  void skipUntilSpace();
+  Value& currentValue();
+  Char getNextChar();
+  void
+  getLocationLineAndColumn(Location location, int& line, int& column) const;
+  std::string getLocationLineAndColumn(Location location) const;
+  void addComment(Location begin, Location end, CommentPlacement placement);
+  void skipCommentTokens(Token& token);
+
+  typedef std::stack<Value*> Nodes;
+  Nodes nodes_;
+  Errors errors_;
+  std::string document_;
+  Location begin_;
+  Location end_;
+  Location current_;
+  Location lastValueEnd_;
+  Value* lastValue_;
+  std::string commentsBefore_;
+  Features features_;
+  bool collectComments_;
+};  // Reader
+
+/** Interface for reading JSON from a char array.
+ */
+class JSON_API CharReader {
+public:
+  virtual ~CharReader() {}
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   document.
+   * The document must be a UTF-8 encoded string containing the document to read.
+   *
+   * \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 errs [out] Formatted error messages (if not NULL)
+   *        a user friendly string that lists errors in the parsed
+   * document.
+   * \return \c true if the document was successfully parsed, \c false if an
+   error occurred.
+   */
+  virtual bool parse(
+      char const* beginDoc, char const* endDoc,
+      Value* root, std::string* errs) = 0;
+
+  class Factory {
+  public:
+    virtual ~Factory() {}
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual CharReader* newCharReader() const = 0;
+  };  // Factory
+};  // CharReader
+
+/** \brief Build a CharReader implementation.
+
+Usage:
+\code
+  using namespace Json;
+  CharReaderBuilder builder;
+  builder["collectComments"] = false;
+  Value value;
+  std::string errs;
+  bool ok = parseFromStream(builder, std::cin, &value, &errs);
+\endcode
+*/
+class JSON_API CharReaderBuilder : public CharReader::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+    These are case-sensitive.
+    Available settings (case-sensitive):
+    - `"collectComments": false or true`
+      - true to collect comment and allow writing them
+        back during serialization, false to discard comments.
+        This parameter is ignored if allowComments is false.
+    - `"allowComments": false or true`
+      - true if comments are allowed.
+    - `"strictRoot": false or true`
+      - true if root must be either an array or an object value
+    - `"allowDroppedNullPlaceholders": false or true`
+      - true if dropped null placeholders are allowed. (See StreamWriterBuilder.)
+    - `"allowNumericKeys": false or true`
+      - true if numeric object keys are allowed.
+    - `"allowSingleQuotes": false or true`
+      - true if '' are allowed for strings (both keys and values)
+    - `"stackLimit": integer`
+      - Exceeding stackLimit (recursive depth of `readValue()`) will
+        cause an exception.
+      - This is a security issue (seg-faults caused by deeply nested JSON),
+        so the default is low.
+    - `"failIfExtra": false or true`
+      - If true, `parse()` returns false when extra non-whitespace trails
+        the JSON value in the input string.
+    - `"rejectDupKeys": false or true`
+      - If true, `parse()` returns false when a key is duplicated within an object.
+
+    You can examine 'settings_` yourself
+    to see the defaults. You can also write and read them just like any
+    JSON Value.
+    \sa setDefaults()
+    */
+  Json::Value settings_;
+
+  CharReaderBuilder();
+  virtual ~CharReaderBuilder();
+
+  virtual CharReader* newCharReader() const;
+
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](std::string key);
+
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
+   */
+  static void setDefaults(Json::Value* settings);
+  /** Same as old Features::strictMode().
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
+   */
+  static void strictMode(Json::Value* settings);
+};
+
+/** Consume entire stream and use its begin/end.
+  * Someday we might have a real StreamReader, but for now this
+  * is convenient.
+  */
+bool JSON_API parseFromStream(
+    CharReader::Factory const&,
+    std::istream&,
+    Value* root, std::string* errs);
+
+/** \brief Read from 'sin' into 'root'.
+
+ Always keep comments from the input JSON.
+
+ This can be used to read a file into a particular sub-object.
+ For example:
+ \code
+ Json::Value root;
+ cin >> root["dir"]["file"];
+ cout << root;
+ \endcode
+ Result:
+ \verbatim
+ {
+ "dir": {
+     "file": {
+     // The input stream JSON would be nested here.
+     }
+ }
+ }
+ \endverbatim
+ \throw std::exception on parse error.
+ \see Json::operator<<()
+*/
+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/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 "1.10.0"
+# define JSONCPP_VERSION_MAJOR 1
+# define JSONCPP_VERSION_MINOR 10
+# 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

@@ -1,174 +1,316 @@
-#ifndef JSON_WRITER_H_INCLUDED
-# define JSON_WRITER_H_INCLUDED
+// 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
 
-# include "value.h"
-# include <vector>
-# include <string>
-# include <iostream>
+#ifndef JSON_WRITER_H_INCLUDED
+#define JSON_WRITER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <vector>
+#include <string>
+#include <ostream>
+
+// 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 {
 
-   class Value;
+class Value;
 
-   /** \brief Abstract class for writers.
+/**
+
+Usage:
+\code
+  using namespace Json;
+  void writeToStdout(StreamWriter::Factory const& factory, Value const& value) {
+    std::unique_ptr<StreamWriter> const writer(
+      factory.newStreamWriter());
+    writer->write(value, &std::cout);
+    std::cout << std::endl;  // add lf and flush
+  }
+\endcode
+*/
+class JSON_API StreamWriter {
+protected:
+  std::ostream* sout_;  // not owned; will not delete
+public:
+  StreamWriter();
+  virtual ~StreamWriter();
+  /** Write Value into document as configured in sub-class.
+      Do not take ownership of sout, but maintain a reference during function.
+      \pre sout != NULL
+      \return zero on success (For now, we always return zero, so check the stream instead.)
+      \throw std::exception possibly, depending on configuration
+   */
+  virtual int write(Value const& root, std::ostream* sout) = 0;
+
+  /** \brief A simple abstract factory.
+   */
+  class JSON_API Factory {
+  public:
+    virtual ~Factory();
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual StreamWriter* newStreamWriter() const = 0;
+  };  // Factory
+};  // StreamWriter
+
+/** \brief Write into stringstream, then return string, for convenience.
+ * A StreamWriter will be created from the factory, used, and then deleted.
+ */
+std::string JSON_API writeString(StreamWriter::Factory const& factory, Value const& root);
+
+
+/** \brief Build a StreamWriter implementation.
+
+Usage:
+\code
+  using namespace Json;
+  Value value = ...;
+  StreamWriterBuilder builder;
+  builder["commentStyle"] = "None";
+  builder["indentation"] = "   ";  // or whatever you like
+  std::unique_ptr<Json::StreamWriter> writer(
+      builder.newStreamWriter());
+  writer->write(value, &std::cout);
+  std::cout << std::endl;  // add lf and flush
+\endcode
+*/
+class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+    Available settings (case-sensitive):
+    - "commentStyle": "None" or "All"
+    - "indentation":  "<anything>"
+    - "enableYAMLCompatibility": false or true
+      - slightly change the whitespace around colons
+    - "dropNullPlaceholders": false or true
+      - 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.
+
+    You can examine 'settings_` yourself
+    to see the defaults. You can also write and read them just like any
+    JSON Value.
+    \sa setDefaults()
     */
-   class JSON_API Writer
-   {
-   public:
-      virtual ~Writer();
+  Json::Value settings_;
 
-      virtual std::string write( const Value &root ) = 0;
-   };
+  StreamWriterBuilder();
+  virtual ~StreamWriterBuilder();
 
-   /** \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,
-    * but may be usefull to support feature such as RPC where bandwith is limited.
-    * \sa Reader, Value
-    */
-   class JSON_API FastWriter : public Writer
-   {
-   public:
-      FastWriter();
-      virtual ~FastWriter(){}
+  /**
+   * \throw std::exception if something goes wrong (e.g. invalid settings)
+   */
+  virtual StreamWriter* newStreamWriter() const;
 
-      void enableYAMLCompatibility();
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](std::string key);
 
-   public: // overridden from Writer
-      virtual std::string write( const Value &root );
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
+   */
+  static void setDefaults(Json::Value* settings);
+};
 
-   private:
-      void writeValue( const Value &value );
+/** \brief Abstract class for writers.
+ * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
+ */
+class JSON_API Writer {
+public:
+  virtual ~Writer();
 
-      std::string document_;
-      bool yamlCompatiblityEnabled_;
-   };
+  virtual std::string write(const Value& root) = 0;
+};
 
-   /** \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
-    *       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.
-    *     - 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.
-    *
-    * \sa Reader, Value, Value::setComment()
-    */
-   class JSON_API StyledWriter: public Writer
-   {
-   public:
-      StyledWriter();
-      virtual ~StyledWriter(){}
+/** \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,
+ * but may be usefull to support feature such as RPC where bandwith is limited.
+ * \sa Reader, Value
+ * \deprecated Use StreamWriterBuilder.
+ */
+class JSON_API FastWriter : public Writer {
 
-   public: // overridden from Writer
-      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
-       * \param root Value to serialize.
-       * \return String containing the JSON document that represents the root value.
-       */
-      virtual std::string write( const Value &root );
+public:
+  FastWriter();
+  virtual ~FastWriter() {}
 
-   private:
-      void writeValue( const Value &value );
-      void writeArrayValue( const Value &value );
-      bool isMultineArray( const Value &value );
-      void pushValue( const std::string &value );
-      void writeIndent();
-      void writeWithIndent( const std::string &value );
-      void indent();
-      void unindent();
-      void writeCommentBeforeValue( const Value &root );
-      void writeCommentAfterValueOnSameLine( const Value &root );
-      bool hasCommentForValue( const Value &value );
-      static std::string normalizeEOL( const std::string &text );
+  void enableYAMLCompatibility();
 
-      typedef std::vector<std::string> ChildValues;
+public: // overridden from Writer
+  virtual std::string write(const Value& root);
 
-      ChildValues childValues_;
-      std::string document_;
-      std::string indentString_;
-      int rightMargin_;
-      int indentSize_;
-      bool addChildValues_;
-   };
+private:
+  void writeValue(const Value& value);
 
-   /** \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
-    *       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.
-    *     - 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.
-    *
-    * \param indentation Each level will be indented by this amount extra.
-    * \sa Reader, Value, Value::setComment()
-    */
-   class JSON_API StyledStreamWriter
-   {
-   public:
-      StyledStreamWriter( std::string indentation="\t" );
-      ~StyledStreamWriter(){}
+  std::string document_;
+  bool yamlCompatiblityEnabled_;
+};
 
-   public:
-      /** \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.
-       */
-      void write( std::ostream &out, const Value &root );
+/** \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
+ *       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.
+ *     - 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.
+ *
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+class JSON_API StyledWriter : public Writer {
+public:
+  StyledWriter();
+  virtual ~StyledWriter() {}
 
-   private:
-      void writeValue( const Value &value );
-      void writeArrayValue( const Value &value );
-      bool isMultineArray( const Value &value );
-      void pushValue( const std::string &value );
-      void writeIndent();
-      void writeWithIndent( const std::string &value );
-      void indent();
-      void unindent();
-      void writeCommentBeforeValue( const Value &root );
-      void writeCommentAfterValueOnSameLine( const Value &root );
-      bool hasCommentForValue( const Value &value );
-      static std::string normalizeEOL( const std::string &text );
+public: // overridden from Writer
+  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+   * \param root Value to serialize.
+   * \return String containing the JSON document that represents the root value.
+   */
+  virtual std::string write(const Value& root);
 
-      typedef std::vector<std::string> ChildValues;
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultineArray(const Value& value);
+  void pushValue(const std::string& value);
+  void writeIndent();
+  void writeWithIndent(const std::string& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  bool hasCommentForValue(const Value& value);
+  static std::string normalizeEOL(const std::string& text);
 
-      ChildValues childValues_;
-      std::ostream* document_;
-      std::string indentString_;
-      int rightMargin_;
-      std::string indentation_;
-      bool addChildValues_;
-   };
+  typedef std::vector<std::string> ChildValues;
 
-   std::string JSON_API valueToString( Int value );
-   std::string JSON_API valueToString( UInt value );
-   std::string JSON_API valueToString( double value );
-   std::string JSON_API valueToString( bool value );
-   std::string JSON_API valueToQuotedString( const char *value );
+  ChildValues childValues_;
+  std::string document_;
+  std::string indentString_;
+  int rightMargin_;
+  int indentSize_;
+  bool addChildValues_;
+};
 
-   /// \brief Output using the StyledStreamWriter.
-   /// \see Json::operator>>()
-   std::ostream& operator<<( std::ostream&, const Value &root );
+/** \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
+ *       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.
+ *     - 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.
+ *
+ * \param indentation Each level will be indented by this amount extra.
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+class JSON_API StyledStreamWriter {
+public:
+  StyledStreamWriter(std::string indentation = "\t");
+  ~StyledStreamWriter() {}
+
+public:
+  /** \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.
+   */
+  void write(std::ostream& out, const Value& root);
+
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultineArray(const Value& value);
+  void pushValue(const std::string& value);
+  void writeIndent();
+  void writeWithIndent(const std::string& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  bool hasCommentForValue(const Value& value);
+  static std::string normalizeEOL(const std::string& text);
+
+  typedef std::vector<std::string> ChildValues;
+
+  ChildValues childValues_;
+  std::ostream* document_;
+  std::string indentString_;
+  int rightMargin_;
+  std::string indentation_;
+  bool addChildValues_ : 1;
+  bool indented_ : 1;
+};
+
+#if defined(JSON_HAS_INT64)
+std::string JSON_API valueToString(Int value);
+std::string JSON_API valueToString(UInt value);
+#endif // if defined(JSON_HAS_INT64)
+std::string JSON_API valueToString(LargestInt value);
+std::string JSON_API valueToString(LargestUInt value);
+std::string JSON_API valueToString(double value);
+std::string JSON_API valueToString(bool value);
+std::string JSON_API valueToQuotedString(const char* value);
+
+/// \brief Output using the StyledStreamWriter.
+/// \see Json::operator>>()
+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>

makefiles/vs71/lib_json.vcproj

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

makerelease.py

@@ -3,11 +3,18 @@
 Requires Python 2.6
 
 Example of invocation (use to test the script):
-python makerelease.py --force --retag --platform=msvc6,msvc71,msvc80,mingw -ublep 0.5.0 0.6.0-dev
+python makerelease.py --platform=msvc6,msvc71,msvc80,msvc90,mingw -ublep 0.6.0 0.7.0-dev
+
+When testing this script:
+python makerelease.py --force --retag --platform=msvc6,msvc71,msvc80,mingw -ublep test-0.6.0 test-0.6.1-dev
 
 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.
 """
+from __future__ import print_function
 import os.path
 import subprocess
 import sys
@@ -20,146 +27,147 @@ import tempfile
 import os
 import time
 from devtools import antglob, fixeol, tarball
+import amalgamate
 
 SVN_ROOT = 'https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/'
 SVN_TAG_ROOT = SVN_ROOT + 'tags/jsoncpp'
 SCONS_LOCAL_URL = 'http://sourceforge.net/projects/scons/files/scons-local/1.2.0/scons-local-1.2.0.tar.gz/download'
 SOURCEFORGE_PROJECT = 'jsoncpp'
 
-def set_version( version ):
+def set_version(version):
     with open('version','wb') as f:
-        f.write( version.strip() )
+        f.write(version.strip())
 
-def rmdir_if_exist( dir_path ):
-    if os.path.isdir( dir_path ):
-        shutil.rmtree( dir_path )
+def rmdir_if_exist(dir_path):
+    if os.path.isdir(dir_path):
+        shutil.rmtree(dir_path)
 
 class SVNError(Exception):
     pass
 
-def svn_command( command, *args ):
+def svn_command(command, *args):
     cmd = ['svn', '--non-interactive', command] + list(args)
-    print 'Running:', ' '.join( cmd )
-    process = subprocess.Popen( cmd,
+    print('Running:', ' '.join(cmd))
+    process = subprocess.Popen(cmd,
                                 stdout=subprocess.PIPE,
-                                stderr=subprocess.STDOUT )
+                                stderr=subprocess.STDOUT)
     stdout = process.communicate()[0]
     if process.returncode:
-        error = SVNError( 'SVN command failed:\n' + stdout )
+        error = SVNError('SVN command failed:\n' + stdout)
         error.returncode = process.returncode
         raise error
     return stdout
 
 def check_no_pending_commit():
     """Checks that there is no pending commit in the sandbox."""
-    stdout = svn_command( 'status', '--xml' )
-    etree = ElementTree.fromstring( stdout )
+    stdout = svn_command('status', '--xml')
+    etree = ElementTree.fromstring(stdout)
     msg = []
-    for entry in etree.getiterator( 'entry' ):
+    for entry in etree.getiterator('entry'):
         path = entry.get('path')
         status = entry.find('wc-status').get('item')
         if status != 'unversioned' and path != 'version':
-            msg.append( 'File "%s" has pending change (status="%s")' % (path, status) )
+            msg.append('File "%s" has pending change (status="%s")' % (path, status))
     if msg:
-        msg.insert(0, 'Pending change to commit found in sandbox. Commit them first!' )
-    return '\n'.join( msg )
+        msg.insert(0, 'Pending change to commit found in sandbox. Commit them first!')
+    return '\n'.join(msg)
 
-def svn_join_url( base_url, suffix ):
+def svn_join_url(base_url, suffix):
     if not base_url.endswith('/'):
         base_url += '/'
     if suffix.startswith('/'):
         suffix = suffix[1:]
     return base_url + suffix
 
-def svn_check_if_tag_exist( tag_url ):
+def svn_check_if_tag_exist(tag_url):
     """Checks if a tag exist.
     Returns: True if the tag exist, False otherwise.
     """
     try:
-        list_stdout = svn_command( 'list', tag_url )
-    except SVNError, e:
+        list_stdout = svn_command('list', tag_url)
+    except SVNError as e:
         if e.returncode != 1 or not str(e).find('tag_url'):
             raise e
         # otherwise ignore error, meaning tag does not exist
         return False
     return True
 
-def svn_commit( message ):
+def svn_commit(message):
     """Commit the sandbox, providing the specified comment.
     """
-    svn_command( 'ci', '-m', message )
+    svn_command('ci', '-m', message)
 
-def svn_tag_sandbox( tag_url, message ):
+def svn_tag_sandbox(tag_url, message):
     """Makes a tag based on the sandbox revisions.
     """
-    svn_command( 'copy', '-m', message, '.', tag_url )
+    svn_command('copy', '-m', message, '.', tag_url)
 
-def svn_remove_tag( tag_url, message ):
+def svn_remove_tag(tag_url, message):
     """Removes an existing tag.
     """
-    svn_command( 'delete', '-m', message, tag_url )
+    svn_command('delete', '-m', message, tag_url)
 
-def svn_export( tag_url, export_dir ):
+def svn_export(tag_url, export_dir):
     """Exports the tag_url revision to export_dir.
        Target directory, including its parent is created if it does not exist.
        If the directory export_dir exist, it is deleted before export proceed.
     """
-    rmdir_if_exist( export_dir )
-    svn_command( 'export', tag_url, export_dir )
+    rmdir_if_exist(export_dir)
+    svn_command('export', tag_url, export_dir)
 
-def fix_sources_eol( dist_dir ):
+def fix_sources_eol(dist_dir):
     """Set file EOL for tarball distribution.
     """
-    print 'Preparing exported source file EOL for distribution...'
+    print('Preparing exported source file EOL for distribution...')
     prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist'
-    win_sources = antglob.glob( dist_dir, 
+    win_sources = antglob.glob(dist_dir, 
         includes = '**/*.sln **/*.vcproj',
-        prune_dirs = prune_dirs )
-    unix_sources = antglob.glob( dist_dir,
+        prune_dirs = prune_dirs)
+    unix_sources = antglob.glob(dist_dir,
         includes = '''**/*.h **/*.cpp **/*.inl **/*.txt **/*.dox **/*.py **/*.html **/*.in
         sconscript *.json *.expected AUTHORS LICENSE''',
         excludes = antglob.default_excludes + 'scons.py sconsign.py scons-*',
-        prune_dirs = prune_dirs )
+        prune_dirs = prune_dirs)
     for path in win_sources:
-        fixeol.fix_source_eol( path, is_dry_run = False, verbose = True, eol = '\r\n' )
+        fixeol.fix_source_eol(path, is_dry_run = False, verbose = True, eol = '\r\n')
     for path in unix_sources:
-        fixeol.fix_source_eol( path, is_dry_run = False, verbose = True, eol = '\n' )
+        fixeol.fix_source_eol(path, is_dry_run = False, verbose = True, eol = '\n')
 
-def download( url, target_path ):
+def download(url, target_path):
     """Download file represented by url to target_path.
     """
-    f = urllib2.urlopen( url )
+    f = urllib2.urlopen(url)
     try:
         data = f.read()
     finally:
         f.close()
-    fout = open( target_path, 'wb' )
+    fout = open(target_path, 'wb')
     try:
-        fout.write( data )
+        fout.write(data)
     finally:
         fout.close()
 
-def check_compile( distcheck_top_dir, platform ):
+def check_compile(distcheck_top_dir, platform):
     cmd = [sys.executable, 'scons.py', 'platform=%s' % platform, 'check']
-    print 'Running:', ' '.join( cmd )
-    log_path = os.path.join( distcheck_top_dir, 'build-%s.log' % platform )
-    flog = open( log_path, 'wb' )
+    print('Running:', ' '.join(cmd))
+    log_path = os.path.join(distcheck_top_dir, 'build-%s.log' % platform)
+    flog = open(log_path, 'wb')
     try:
-        process = subprocess.Popen( cmd,
+        process = subprocess.Popen(cmd,
                                     stdout=flog,
                                     stderr=subprocess.STDOUT,
-                                    cwd=distcheck_top_dir )
+                                    cwd=distcheck_top_dir)
         stdout = process.communicate()[0]
         status = (process.returncode == 0)
     finally:
         flog.close()
     return (status, log_path)
 
-def write_tempfile( content, **kwargs ):
-    fd, path = tempfile.mkstemp( **kwargs )
-    f = os.fdopen( fd, 'wt' )
+def write_tempfile(content, **kwargs):
+    fd, path = tempfile.mkstemp(**kwargs)
+    f = os.fdopen(fd, 'wt')
     try:
-        f.write( content )
+        f.write(content)
     finally:
         f.close()
     return path
@@ -167,34 +175,34 @@ def write_tempfile( content, **kwargs ):
 class SFTPError(Exception):
     pass
 
-def run_sftp_batch( userhost, sftp, batch, retry=0 ):
-    path = write_tempfile( batch, suffix='.sftp', text=True )
+def run_sftp_batch(userhost, sftp, batch, retry=0):
+    path = write_tempfile(batch, suffix='.sftp', text=True)
     # psftp -agent -C blep,jsoncpp@web.sourceforge.net -batch -b batch.sftp -bc
     cmd = [sftp, '-agent', '-C', '-batch', '-b', path, '-bc', userhost]
     error = None
-    for retry_index in xrange(0, max(1,retry)):
+    for retry_index in range(0, max(1,retry)):
         heading = retry_index == 0 and 'Running:' or 'Retrying:'
-        print heading, ' '.join( cmd )
-        process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT )
+        print(heading, ' '.join(cmd))
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
         stdout = process.communicate()[0]
         if process.returncode != 0:
-            error = SFTPError( 'SFTP batch failed:\n' + stdout )
+            error = SFTPError('SFTP batch failed:\n' + stdout)
         else:
             break
     if error:
         raise error
     return stdout
 
-def sourceforge_web_synchro( sourceforge_project, doc_dir,
-                             user=None, sftp='sftp' ):
+def sourceforge_web_synchro(sourceforge_project, doc_dir,
+                             user=None, sftp='sftp'):
     """Notes: does not synchronize sub-directory of doc-dir.
     """
     userhost = '%s,%s@web.sourceforge.net' % (user, sourceforge_project)
-    stdout = run_sftp_batch( userhost, sftp, """
+    stdout = run_sftp_batch(userhost, sftp, """
 cd htdocs
 dir
 exit
-""" )
+""")
     existing_paths = set()
     collect = 0
     for line in stdout.split('\n'):
@@ -208,36 +216,36 @@ exit
         elif collect == 2:
             path = line.strip().split()[-1:]
             if path and path[0] not in ('.', '..'):
-                existing_paths.add( path[0] )
-    upload_paths = set( [os.path.basename(p) for p in antglob.glob( doc_dir )] )
+                existing_paths.add(path[0])
+    upload_paths = set([os.path.basename(p) for p in antglob.glob(doc_dir)])
     paths_to_remove = existing_paths - upload_paths
     if paths_to_remove:
-        print 'Removing the following file from web:'
-        print '\n'.join( paths_to_remove )
-        stdout = run_sftp_batch( userhost, sftp, """cd htdocs
+        print('Removing the following file from web:')
+        print('\n'.join(paths_to_remove))
+        stdout = run_sftp_batch(userhost, sftp, """cd htdocs
 rm %s
-exit""" % ' '.join(paths_to_remove) )
-    print 'Uploading %d files:' % len(upload_paths)
+exit""" % ' '.join(paths_to_remove))
+    print('Uploading %d files:' % len(upload_paths))
     batch_size = 10
     upload_paths = list(upload_paths)
     start_time = time.time()
-    for index in xrange(0,len(upload_paths),batch_size):
+    for index in range(0,len(upload_paths),batch_size):
         paths = upload_paths[index:index+batch_size]
         file_per_sec = (time.time() - start_time) / (index+1)
         remaining_files = len(upload_paths) - index
         remaining_sec = file_per_sec * remaining_files
-        print '%d/%d, ETA=%.1fs' % (index+1, len(upload_paths), remaining_sec)
-        run_sftp_batch( userhost, sftp, """cd htdocs
+        print('%d/%d, ETA=%.1fs' % (index+1, len(upload_paths), remaining_sec))
+        run_sftp_batch(userhost, sftp, """cd htdocs
 lcd %s
 mput %s
-exit""" % (doc_dir, ' '.join(paths) ), retry=3 )
+exit""" % (doc_dir, ' '.join(paths)), retry=3)
 
-def sourceforge_release_tarball( sourceforge_project, paths, user=None, sftp='sftp' ):
+def sourceforge_release_tarball(sourceforge_project, paths, user=None, sftp='sftp'):
     userhost = '%s,%s@frs.sourceforge.net' % (user, sourceforge_project)
-    run_sftp_batch( userhost, sftp, """
+    run_sftp_batch(userhost, sftp, """
 mput %s
 exit
-""" % (' '.join(paths),) )
+""" % (' '.join(paths),))
 
 
 def main():
@@ -278,91 +286,99 @@ Warning: --force should only be used when developping/testing the release script
     options, args = parser.parse_args()
 
     if len(args) != 2:
-        parser.error( 'release_version missing on command-line.' )
+        parser.error('release_version missing on command-line.')
     release_version = args[0]
     next_version = args[1]
 
     if not options.platforms and not options.no_test:
-        parser.error( 'You must specify either --platform or --no-test option.' )
+        parser.error('You must specify either --platform or --no-test option.')
 
     if options.ignore_pending_commit:
         msg = ''
     else:
         msg = check_no_pending_commit()
     if not msg:
-        print 'Setting version to', release_version
-        set_version( release_version )
-        svn_commit( 'Release ' + release_version )
-        tag_url = svn_join_url( SVN_TAG_ROOT, release_version )
-        if svn_check_if_tag_exist( tag_url ):
+        print('Setting version to', release_version)
+        set_version(release_version)
+        svn_commit('Release ' + release_version)
+        tag_url = svn_join_url(SVN_TAG_ROOT, release_version)
+        if svn_check_if_tag_exist(tag_url):
             if options.retag_release:
-                svn_remove_tag( tag_url, 'Overwriting previous tag' )
+                svn_remove_tag(tag_url, 'Overwriting previous tag')
             else:
-                print 'Aborting, tag %s already exist. Use --retag to overwrite it!' % tag_url
-                sys.exit( 1 )
-        svn_tag_sandbox( tag_url, 'Release ' + release_version )
+                print('Aborting, tag %s already exist. Use --retag to overwrite it!' % tag_url)
+                sys.exit(1)
+        svn_tag_sandbox(tag_url, 'Release ' + release_version)
 
-        print 'Generated doxygen document...'
+        print('Generated doxygen document...')
 ##        doc_dirname = r'jsoncpp-api-html-0.5.0'
 ##        doc_tarball_path = r'e:\prg\vc\Lib\jsoncpp-trunk\dist\jsoncpp-api-html-0.5.0.tar.gz'
-        doc_tarball_path, doc_dirname = doxybuild.build_doc( options, make_release=True )
+        doc_tarball_path, doc_dirname = doxybuild.build_doc(options, make_release=True)
         doc_distcheck_dir = 'dist/doccheck'
-        tarball.decompress( doc_tarball_path, doc_distcheck_dir )
-        doc_distcheck_top_dir = os.path.join( doc_distcheck_dir, doc_dirname )
+        tarball.decompress(doc_tarball_path, doc_distcheck_dir)
+        doc_distcheck_top_dir = os.path.join(doc_distcheck_dir, doc_dirname)
         
         export_dir = 'dist/export'
-        svn_export( tag_url, export_dir )
-        fix_sources_eol( export_dir )
+        svn_export(tag_url, export_dir)
+        fix_sources_eol(export_dir)
         
         source_dir = 'jsoncpp-src-' + release_version
         source_tarball_path = 'dist/%s.tar.gz' % source_dir
-        print 'Generating source tarball to', source_tarball_path
-        tarball.make_tarball( source_tarball_path, [export_dir], export_dir, prefix_dir=source_dir )
+        print('Generating source tarball to', source_tarball_path)
+        tarball.make_tarball(source_tarball_path, [export_dir], export_dir, prefix_dir=source_dir)
+
+        amalgamation_tarball_path = 'dist/%s-amalgamation.tar.gz' % source_dir
+        print('Generating amalgamation source tarball to', amalgamation_tarball_path)
+        amalgamation_dir = 'dist/amalgamation'
+        amalgamate.amalgamate_source(export_dir, '%s/jsoncpp.cpp' % amalgamation_dir, 'json/json.h')
+        amalgamation_source_dir = 'jsoncpp-src-amalgamation' + release_version
+        tarball.make_tarball(amalgamation_tarball_path, [amalgamation_dir],
+                              amalgamation_dir, prefix_dir=amalgamation_source_dir)
 
         # Decompress source tarball, download and install scons-local
         distcheck_dir = 'dist/distcheck'
         distcheck_top_dir = distcheck_dir + '/' + source_dir
-        print 'Decompressing source tarball to', distcheck_dir
-        rmdir_if_exist( distcheck_dir )
-        tarball.decompress( source_tarball_path, distcheck_dir )
+        print('Decompressing source tarball to', distcheck_dir)
+        rmdir_if_exist(distcheck_dir)
+        tarball.decompress(source_tarball_path, distcheck_dir)
         scons_local_path = 'dist/scons-local.tar.gz'
-        print 'Downloading scons-local to', scons_local_path
-        download( SCONS_LOCAL_URL, scons_local_path )
-        print 'Decompressing scons-local to', distcheck_top_dir
-        tarball.decompress( scons_local_path, distcheck_top_dir )
+        print('Downloading scons-local to', scons_local_path)
+        download(SCONS_LOCAL_URL, scons_local_path)
+        print('Decompressing scons-local to', distcheck_top_dir)
+        tarball.decompress(scons_local_path, distcheck_top_dir)
 
         # Run compilation
-        print 'Compiling decompressed tarball'
+        print('Compiling decompressed tarball')
         all_build_status = True
         for platform in options.platforms.split(','):
-            print 'Testing platform:', platform
-            build_status, log_path = check_compile( distcheck_top_dir, platform )
-            print 'see build log:', log_path
-            print build_status and '=> ok' or '=> FAILED'
+            print('Testing platform:', platform)
+            build_status, log_path = check_compile(distcheck_top_dir, platform)
+            print('see build log:', log_path)
+            print(build_status and '=> ok' or '=> FAILED')
             all_build_status = all_build_status and build_status
         if not build_status:
-            print 'Testing failed on at least one platform, aborting...'
-            svn_remove_tag( tag_url, 'Removing tag due to failed testing' )
+            print('Testing failed on at least one platform, aborting...')
+            svn_remove_tag(tag_url, 'Removing tag due to failed testing')
             sys.exit(1)
         if options.user:
             if not options.no_web:
-                print 'Uploading documentation using user', options.user
-                sourceforge_web_synchro( SOURCEFORGE_PROJECT, doc_distcheck_top_dir, user=options.user, sftp=options.sftp )
-                print 'Completed documentation upload'
-            print 'Uploading source and documentation tarballs for release using user', options.user
-            sourceforge_release_tarball( SOURCEFORGE_PROJECT,
+                print('Uploading documentation using user', options.user)
+                sourceforge_web_synchro(SOURCEFORGE_PROJECT, doc_distcheck_top_dir, user=options.user, sftp=options.sftp)
+                print('Completed documentation upload')
+            print('Uploading source and documentation tarballs for release using user', options.user)
+            sourceforge_release_tarball(SOURCEFORGE_PROJECT,
                                          [source_tarball_path, doc_tarball_path],
-                                         user=options.user, sftp=options.sftp )
-            print 'Source and doc release tarballs uploaded'
+                                         user=options.user, sftp=options.sftp)
+            print('Source and doc release tarballs uploaded')
         else:
-            print 'No upload user specified. Web site and download tarbal were not uploaded.'
-            print 'Tarball can be found at:', doc_tarball_path
+            print('No upload user specified. Web site and download tarbal were not uploaded.')
+            print('Tarball can be found at:', doc_tarball_path)
 
         # Set next version number and commit            
-        set_version( next_version )
-        svn_commit( 'Released ' + release_version )
+        set_version(next_version)
+        svn_commit('Released ' + release_version)
     else:
-        sys.stderr.write( msg + '\n' )
+        sys.stderr.write(msg + '\n')
  
 if __name__ == '__main__':
     main()

pkg-config/jsoncpp.pc.in

@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/@LIBRARY_INSTALL_DIR@
+includedir=${prefix}/@INCLUDE_INSTALL_DIR@
+
+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}

scons-tools/globtool.py

@@ -1,53 +1,53 @@
-import fnmatch
-import os
-
-def generate( env ): 
-   def Glob( env, includes = None, excludes = None, dir = '.' ):
-      """Adds Glob( includes = Split( '*' ), excludes = None, dir = '.')
-       helper function to environment.
-
-       Glob both the file-system files.
-
-       includes: list of file name pattern included in the return list when matched.
-       excludes: list of file name pattern exluced from the return list.
-
-       Example:
-       sources = env.Glob( ("*.cpp", '*.h'), "~*.cpp", "#src" )
-      """
-      def filterFilename(path):
-         abs_path = os.path.join( dir, path )
-         if not os.path.isfile(abs_path):
-            return 0
-         fn = os.path.basename(path)
-         match = 0
-         for include in includes:
-            if fnmatch.fnmatchcase( fn, include ):
-               match = 1
-               break
-         if match == 1 and not excludes is None:
-            for exclude in excludes:
-               if fnmatch.fnmatchcase( fn, exclude ):
-                  match = 0
-                  break
-         return match
-      if includes is None:
-         includes = ('*',)
-      elif type(includes) in ( type(''), type(u'') ):
-         includes = (includes,)
-      if type(excludes) in ( type(''), type(u'') ):
-         excludes = (excludes,)
-      dir = env.Dir(dir).abspath
-      paths = os.listdir( dir )
-      def makeAbsFileNode( path ):
-         return env.File( os.path.join( dir, path ) )
-      nodes = filter( filterFilename, paths )
-      return map( makeAbsFileNode, nodes )
-
-   from SCons.Script import Environment
+import fnmatch
+import os
+
+def generate(env): 
+   def Glob(env, includes = None, excludes = None, dir = '.'):
+      """Adds Glob(includes = Split('*'), excludes = None, dir = '.')
+       helper function to environment.
+
+       Glob both the file-system files.
+
+       includes: list of file name pattern included in the return list when matched.
+       excludes: list of file name pattern exluced from the return list.
+
+       Example:
+       sources = env.Glob(("*.cpp", '*.h'), "~*.cpp", "#src")
+      """
+      def filterFilename(path):
+         abs_path = os.path.join(dir, path)
+         if not os.path.isfile(abs_path):
+            return 0
+         fn = os.path.basename(path)
+         match = 0
+         for include in includes:
+            if fnmatch.fnmatchcase(fn, include):
+               match = 1
+               break
+         if match == 1 and not excludes is None:
+            for exclude in excludes:
+               if fnmatch.fnmatchcase(fn, exclude):
+                  match = 0
+                  break
+         return match
+      if includes is None:
+         includes = ('*',)
+      elif type(includes) in (type(''), type(u'')):
+         includes = (includes,)
+      if type(excludes) in (type(''), type(u'')):
+         excludes = (excludes,)
+      dir = env.Dir(dir).abspath
+      paths = os.listdir(dir)
+      def makeAbsFileNode(path):
+         return env.File(os.path.join(dir, path))
+      nodes = filter(filterFilename, paths)
+      return map(makeAbsFileNode, nodes)
+
+   from SCons.Script import Environment
    Environment.Glob = Glob
-
-def exists(env):
-    """
-    Tool always exists.
-    """
-    return True
+
+def exists(env):
+    """
+    Tool always exists.
+    """
+    return True

scons-tools/srcdist.py

@@ -47,7 +47,7 @@ import targz
 ##         elif token == "=":
 ##            data[key] = list()
 ##         else:
-##            append_data( data, key, new_data, token )
+##            append_data(data, key, new_data, token)
 ##            new_data = True
 ##
 ##      last_token = token
@@ -55,7 +55,7 @@ import targz
 ##      
 ##      if last_token == '\\' and token != '\n':
 ##         new_data = False
-##         append_data( data, key, new_data, '\\' )
+##         append_data(data, key, new_data, '\\')
 ##
 ##   # compress lists of len 1 into single strings
 ##   for (k, v) in data.items():
@@ -116,7 +116,7 @@ import targz
 ##         else:
 ##            for pattern in file_patterns:
 ##               sources.extend(glob.glob("/".join([node, pattern])))
-##   sources = map( lambda path: env.File(path), sources )
+##   sources = map(lambda path: env.File(path), sources)
 ##   return sources
 ##
 ##
@@ -143,7 +143,7 @@ def srcDistEmitter(source, target, env):
 ##   # add our output locations
 ##   for (k, v) in output_formats.items():
 ##      if data.get("GENERATE_" + k, v[0]) == "YES":
-##         targets.append(env.Dir( os.path.join(out_dir, data.get(k + "_OUTPUT", v[1]))) )
+##         targets.append(env.Dir(os.path.join(out_dir, data.get(k + "_OUTPUT", v[1]))))
 ##
 ##   # don't clobber targets
 ##   for node in targets:
@@ -161,14 +161,13 @@ def generate(env):
    Add builders and construction variables for the
    SrcDist tool.
    """
-##   doxyfile_scanner = env.Scanner(
-##      DoxySourceScan,
+##   doxyfile_scanner = env.Scanner(##      DoxySourceScan,
 ##      "DoxySourceScan",
 ##      scan_check = DoxySourceScanCheck,
-##   )
+##)
 
    if targz.exists(env):
-      srcdist_builder = targz.makeBuilder( srcDistEmitter )
+      srcdist_builder = targz.makeBuilder(srcDistEmitter)
 
       env['BUILDERS']['SrcDist'] = srcdist_builder
 

scons-tools/substinfile.py

@@ -1,5 +1,6 @@
 import re
 from SCons.Script import *  # the usual scons stuff you get in a SConscript
+import collections
 
 def generate(env):
     """
@@ -25,28 +26,28 @@ def generate(env):
             contents = f.read()
             f.close()
         except:
-            raise SCons.Errors.UserError, "Can't read source file %s"%sourcefile
-        for (k,v) in dict.items():
+            raise SCons.Errors.UserError("Can't read source file %s"%sourcefile)
+        for (k,v) in list(dict.items()):
             contents = re.sub(k, v, contents)
         try:
             f = open(targetfile, 'wb')
             f.write(contents)
             f.close()
         except:
-            raise SCons.Errors.UserError, "Can't write target file %s"%targetfile
+            raise SCons.Errors.UserError("Can't write target file %s"%targetfile)
         return 0 # success
 
     def subst_in_file(target, source, env):
-        if not env.has_key('SUBST_DICT'):
-            raise SCons.Errors.UserError, "SubstInFile requires SUBST_DICT to be set."
+        if 'SUBST_DICT' not in env:
+            raise SCons.Errors.UserError("SubstInFile requires SUBST_DICT to be set.")
         d = dict(env['SUBST_DICT']) # copy it
-        for (k,v) in d.items():
-            if callable(v):
+        for (k,v) in list(d.items()):
+            if isinstance(v, collections.Callable):
                 d[k] = env.subst(v()).replace('\\','\\\\')
             elif SCons.Util.is_String(v):
                 d[k] = env.subst(v).replace('\\','\\\\')
             else:
-                raise SCons.Errors.UserError, "SubstInFile: key %s: %s must be a string or callable"%(k, repr(v))
+                raise SCons.Errors.UserError("SubstInFile: key %s: %s must be a string or callable"%(k, repr(v)))
         for (t,s) in zip(target, source):
             return do_subst_in_file(str(t), str(s), d)
 
@@ -60,8 +61,8 @@ def generate(env):
         Returns original target, source tuple unchanged.
         """
         d = env['SUBST_DICT'].copy() # copy it
-        for (k,v) in d.items():
-            if callable(v):
+        for (k,v) in list(d.items()):
+            if isinstance(v, collections.Callable):
                 d[k] = env.subst(v())
             elif SCons.Util.is_String(v):
                 d[k]=env.subst(v)
@@ -69,7 +70,7 @@ def generate(env):
         return target, source
 
 ##    env.Append(TOOLS = 'substinfile')       # this should be automaticaly done by Scons ?!?
-    subst_action = SCons.Action.Action( subst_in_file, subst_in_file_string )
+    subst_action = SCons.Action.Action(subst_in_file, subst_in_file_string)
     env['BUILDERS']['SubstInFile'] = Builder(action=subst_action, emitter=subst_emitter)
 
 def exists(env):

scons-tools/targz.py

@@ -27,9 +27,9 @@ TARGZ_DEFAULT_COMPRESSION_LEVEL = 9
 
 if internal_targz:
     def targz(target, source, env):
-        def archive_name( path ):
-            path = os.path.normpath( os.path.abspath( path ) )
-            common_path = os.path.commonprefix( (base_dir, path) )
+        def archive_name(path):
+            path = os.path.normpath(os.path.abspath(path))
+            common_path = os.path.commonprefix((base_dir, path))
             archive_name = path[len(common_path):]
             return archive_name
             
@@ -37,23 +37,23 @@ if internal_targz:
             for name in names:
                 path = os.path.join(dirname, name)
                 if os.path.isfile(path):
-                    tar.add(path, archive_name(path) )
+                    tar.add(path, archive_name(path))
         compression = env.get('TARGZ_COMPRESSION_LEVEL',TARGZ_DEFAULT_COMPRESSION_LEVEL)
-        base_dir = os.path.normpath( env.get('TARGZ_BASEDIR', env.Dir('.')).abspath )
+        base_dir = os.path.normpath(env.get('TARGZ_BASEDIR', env.Dir('.')).abspath)
         target_path = str(target[0])
-        fileobj = gzip.GzipFile( target_path, 'wb', compression )
+        fileobj = gzip.GzipFile(target_path, 'wb', compression)
         tar = tarfile.TarFile(os.path.splitext(target_path)[0], 'w', fileobj)
         for source in source:
             source_path = str(source)
             if source.isdir():
                 os.path.walk(source_path, visit, tar)
             else:
-                tar.add(source_path, archive_name(source_path) )      # filename, arcname
+                tar.add(source_path, archive_name(source_path))      # filename, arcname
         tar.close()
 
     targzAction = SCons.Action.Action(targz, varlist=['TARGZ_COMPRESSION_LEVEL','TARGZ_BASEDIR'])
 
-    def makeBuilder( emitter = None ):
+    def makeBuilder(emitter = None):
         return SCons.Builder.Builder(action = SCons.Action.Action('$TARGZ_COM', '$TARGZ_COMSTR'),
                                      source_factory = SCons.Node.FS.Entry,
                                      source_scanner = SCons.Defaults.DirScanner,

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,28 @@
+FIND_PACKAGE(PythonInterp 2.6)
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+  ADD_DEFINITIONS( -DJSON_DLL )
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+ADD_EXECUTABLE(jsontestrunner_exe
+               main.cpp
+               )
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+    TARGET_LINK_LIBRARIES(jsontestrunner_exe jsoncpp_lib)
+ELSE(JSONCPP_LIB_BUILD_SHARED)
+    TARGET_LINK_LIBRARIES(jsontestrunner_exe jsoncpp_lib_static)
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+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
+                      "${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

@@ -1,233 +1,325 @@
+// 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
+
+/* This executable is used for testing parser/writer using real JSON files.
+ */
+
 #include <json/json.h>
 #include <algorithm> // sort
+#include <sstream>
 #include <stdio.h>
 
-#if defined(_MSC_VER)  &&  _MSC_VER >= 1310
-# pragma warning( disable: 4996 )     // disable fopen deprecation warning
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+#pragma warning(disable : 4996) // disable fopen deprecation warning
 #endif
 
-static std::string
-readInputTestFile( const char *path )
+struct Options
 {
-   FILE *file = fopen( path, "rb" );
-   if ( !file )
-      return std::string("");
-   fseek( file, 0, SEEK_END );
-   long size = ftell( file );
-   fseek( file, 0, SEEK_SET );
-   std::string text;
-   char *buffer = new char[size+1];
-   buffer[size] = 0;
-   if ( fread( buffer, 1, size, file ) == (unsigned long)size )
-      text = buffer;
-   fclose( file );
-   delete[] buffer;
-   return text;
+  std::string path;
+  Json::Features features;
+  bool parseOnly;
+  typedef std::string (*writeFuncType)(Json::Value const&);
+  writeFuncType write;
+};
+
+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("");
+  fseek(file, 0, SEEK_END);
+  long size = ftell(file);
+  fseek(file, 0, SEEK_SET);
+  std::string text;
+  char* buffer = new char[size + 1];
+  buffer[size] = 0;
+  if (fread(buffer, 1, size, file) == (unsigned long)size)
+    text = buffer;
+  fclose(file);
+  delete[] buffer;
+  return text;
+}
 
 static void
-printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
-{
-   switch ( value.type() )
-   {
-   case Json::nullValue:
-      fprintf( fout, "%s=null\n", path.c_str() );
-      break;
-   case Json::intValue:
-      fprintf( fout, "%s=%d\n", path.c_str(), value.asInt() );
-      break;
-   case Json::uintValue:
-      fprintf( fout, "%s=%u\n", path.c_str(), value.asUInt() );
-      break;
-   case Json::realValue:
-      fprintf( fout, "%s=%.16g\n", path.c_str(), value.asDouble() );
-      break;
-   case Json::stringValue:
-      fprintf( fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str() );
-      break;
-   case Json::booleanValue:
-      fprintf( fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false" );
-      break;
-   case Json::arrayValue:
-      {
-         fprintf( fout, "%s=[]\n", path.c_str() );
-         int size = value.size();
-         for ( int index =0; index < size; ++index )
-         {
-            static char buffer[16];
-            sprintf( buffer, "[%d]", index );
-            printValueTree( fout, value[index], path + buffer );
-         }
-      }
-      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 )
-         {
-            const std::string &name = *it;
-            printValueTree( fout, value[name], path + suffix + name );
-         }
-      }
-      break;
-   default:
-      break;
-   }
+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());
+    break;
+  case Json::uintValue:
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            Json::valueToString(value.asLargestUInt()).c_str());
+    break;
+  case Json::realValue:
+    fprintf(fout,
+            "%s=%s\n",
+            path.c_str(),
+            normalizeFloatingPointStr(value.asDouble()).c_str());
+    break;
+  case Json::stringValue:
+    fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
+    break;
+  case Json::booleanValue:
+    fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
+    break;
+  case Json::arrayValue: {
+    fprintf(fout, "%s=[]\n", path.c_str());
+    int size = value.size();
+    for (int index = 0; index < size; ++index) {
+      static char buffer[16];
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
+      sprintf_s(buffer, sizeof(buffer), "[%d]", index);
+#else
+      snprintf(buffer, sizeof(buffer), "[%d]", index);
+#endif
+      printValueTree(fout, value[index], path + buffer);
+    }
+  } 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) {
+      const std::string& name = *it;
+      printValueTree(fout, value[name], path + suffix + name);
+    }
+  } 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, 
-                       const std::string &actual,
-                       const std::string &kind,
-                       Json::Value &root,
-                       const Json::Features &features,
-                       bool parseOnly )
+static int parseAndSaveValueTree(const std::string& input,
+                                 const std::string& actual,
+                                 const std::string& kind,
+                                 const Json::Features& features,
+                                 bool parseOnly,
+                                 Json::Value* root)
 {
-   Json::Reader reader( features );
-   bool parsingSuccessful = reader.parse( input, root );
-   if ( !parsingSuccessful )
-   {
-      printf( "Failed to parse %s file: \n%s\n", 
-              kind.c_str(),
-              reader.getFormatedErrorMessages().c_str() );
-      return 1;
-   }
-
-   if ( !parseOnly )
-   {
-      FILE *factual = fopen( actual.c_str(), "wt" );
-      if ( !factual )
-      {
-         printf( "Failed to create %s actual file.\n", kind.c_str() );
-         return 2;
-      }
-      printValueTree( factual, root );
-      fclose( factual );
-   }
-   return 0;
-}
-
-
-static int
-rewriteValueTree( const std::string &rewritePath, 
-                  const Json::Value &root, 
-                  std::string &rewrite )
-{
-   //Json::FastWriter writer;
-   //writer.enableYAMLCompatibility();
-   Json::StyledWriter writer;
-   rewrite = writer.write( root );
-   FILE *fout = fopen( rewritePath.c_str(), "wt" );
-   if ( !fout )
-   {
-      printf( "Failed to create rewrite file: %s\n", rewritePath.c_str() );
+  Json::Reader reader(features);
+  bool parsingSuccessful = reader.parse(input, *root);
+  if (!parsingSuccessful) {
+    printf("Failed to parse %s file: \n%s\n",
+           kind.c_str(),
+           reader.getFormattedErrorMessages().c_str());
+    return 1;
+  }
+  if (!parseOnly) {
+    FILE* factual = fopen(actual.c_str(), "wt");
+    if (!factual) {
+      printf("Failed to create %s actual file.\n", kind.c_str());
       return 2;
-   }
-   fprintf( fout, "%s\n", rewrite.c_str() );
-   fclose( fout );
-   return 0;
+    }
+    printValueTree(factual, *root);
+    fclose(factual);
+  }
+  return 0;
 }
-
-
-static std::string
-removeSuffix( const std::string &path, 
-              const std::string &extension )
+// static std::string useFastWriter(Json::Value const& root) {
+//   Json::FastWriter writer;
+//   writer.enableYAMLCompatibility();
+//   return writer.write(root);
+// }
+static std::string useStyledWriter(
+    Json::Value const& root)
 {
-   if ( extension.length() >= path.length() )
-      return std::string("");
-   std::string suffix = path.substr( path.length() - extension.length() );
-   if ( suffix != extension )
-      return std::string("");
-   return path.substr( 0, path.length() - extension.length() );
+  Json::StyledWriter writer;
+  return writer.write(root);
 }
-
-static int 
-printUsage( const char *argv[] )
+static std::string useStyledStreamWriter(
+    Json::Value const& root)
 {
-   printf( "Usage: %s [--strict] input-json-file", argv[0] );
-   return 3;
+  Json::StyledStreamWriter writer;
+  std::ostringstream sout;
+  writer.write(sout, root);
+  return sout.str();
 }
-
-
-int
-parseCommandLine( int argc, const char *argv[], 
-                  Json::Features &features, std::string &path,
-                  bool &parseOnly )
+static std::string useBuiltStyledStreamWriter(
+    Json::Value const& root)
 {
-   parseOnly = false;
-   if ( argc < 2 )
-   {
-      return printUsage( argv );
-   }
-
-   int index = 1;
-   if ( std::string(argv[1]) == "--json-checker" )
-   {
-      features = Json::Features::strictMode();
-      parseOnly = true;
-      ++index;
-   }
-
-   if ( index == argc  ||  index + 1 < argc )
-   {
-      return printUsage( argv );
-   }
-
-   path = argv[index];
-   return 0;
+  Json::StreamWriterBuilder builder;
+  return Json::writeString(builder, root);
 }
-
-
-int main( int argc, const char *argv[] )
+static int rewriteValueTree(
+    const std::string& rewritePath,
+    const Json::Value& root,
+    Options::writeFuncType write,
+    std::string* rewrite)
 {
-   std::string path;
-   Json::Features features;
-   bool parseOnly;
-   int exitCode = parseCommandLine( argc, argv, features, path, parseOnly );
-   if ( exitCode != 0 )
-   {
-      return exitCode;
-   }
-
-   std::string input = readInputTestFile( path.c_str() );
-   if ( input.empty() )
-   {
-      printf( "Failed to read input or empty input: %s\n", path.c_str() );
-      return 3;
-   }
-
-   std::string basePath = removeSuffix( argv[1], ".json" );
-   if ( !parseOnly  &&  basePath.empty() )
-   {
-      printf( "Bad input path. Path does not end with '.expected':\n%s\n", path.c_str() );
-      return 3;
-   }
-
-   std::string actualPath = basePath + ".actual";
-   std::string rewritePath = basePath + ".rewrite";
-   std::string rewriteActualPath = basePath + ".actual-rewrite";
-
-   Json::Value root;
-   exitCode = parseAndSaveValueTree( input, actualPath, "input", root, features, parseOnly );
-   if ( exitCode == 0  &&  !parseOnly )
-   {
-      std::string rewrite;
-      exitCode = rewriteValueTree( rewritePath, root, rewrite );
-      if ( exitCode == 0 )
-      {
-         Json::Value rewriteRoot;
-         exitCode = parseAndSaveValueTree( rewrite, rewriteActualPath, 
-            "rewrite", rewriteRoot, features, parseOnly );
-      }
-   }
-
-   return exitCode;
+  *rewrite = write(root);
+  FILE* fout = fopen(rewritePath.c_str(), "wt");
+  if (!fout) {
+    printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
+    return 2;
+  }
+  fprintf(fout, "%s\n", rewrite->c_str());
+  fclose(fout);
+  return 0;
 }
 
+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());
+  if (suffix != extension)
+    return std::string("");
+  return path.substr(0, path.length() - extension.length());
+}
+
+static void printConfig() {
+// Print the configuration used to compile JsonCpp
+#if defined(JSON_NO_INT64)
+  printf("JSON_NO_INT64=1\n");
+#else
+  printf("JSON_NO_INT64=0\n");
+#endif
+}
+
+static int printUsage(const char* argv[]) {
+  printf("Usage: %s [--strict] input-json-file", argv[0]);
+  return 3;
+}
+
+static int parseCommandLine(
+    int argc, const char* argv[], Options* opts)
+{
+  opts->parseOnly = false;
+  opts->write = &useStyledWriter;
+  if (argc < 2) {
+    return printUsage(argv);
+  }
+  int index = 1;
+  if (std::string(argv[index]) == "--json-checker") {
+    opts->features = Json::Features::strictMode();
+    opts->parseOnly = true;
+    ++index;
+  }
+  if (std::string(argv[index]) == "--json-config") {
+    printConfig();
+    return 3;
+  }
+  if (std::string(argv[index]) == "--json-writer") {
+    ++index;
+    std::string const writerName(argv[index++]);
+    if (writerName == "StyledWriter") {
+      opts->write = &useStyledWriter;
+    } else if (writerName == "StyledStreamWriter") {
+      opts->write = &useStyledStreamWriter;
+    } else if (writerName == "BuiltStyledStreamWriter") {
+      opts->write = &useBuiltStyledStreamWriter;
+    } else {
+      printf("Unknown '--json-writer %s'\n", writerName.c_str());
+      return 4;
+    }
+  }
+  if (index == argc || index + 1 < argc) {
+    return printUsage(argv);
+  }
+  opts->path = argv[index];
+  return 0;
+}
+static int runTest(Options const& opts)
+{
+  int exitCode = 0;
+
+  std::string input = readInputTestFile(opts.path.c_str());
+  if (input.empty()) {
+    printf("Failed to read input or empty input: %s\n", opts.path.c_str());
+    return 3;
+  }
+
+  std::string basePath = removeSuffix(opts.path, ".json");
+  if (!opts.parseOnly && basePath.empty()) {
+    printf("Bad input path. Path does not end with '.expected':\n%s\n",
+            opts.path.c_str());
+    return 3;
+  }
+
+  std::string const actualPath = basePath + ".actual";
+  std::string const rewritePath = basePath + ".rewrite";
+  std::string const rewriteActualPath = basePath + ".actual-rewrite";
+
+  Json::Value root;
+  exitCode = parseAndSaveValueTree(
+      input, actualPath, "input",
+      opts.features, opts.parseOnly, &root);
+  if (exitCode || opts.parseOnly) {
+    return exitCode;
+  }
+  std::string rewrite;
+  exitCode = rewriteValueTree(rewritePath, root, opts.write, &rewrite);
+  if (exitCode) {
+    return exitCode;
+  }
+  Json::Value rewriteRoot;
+  exitCode = parseAndSaveValueTree(
+      rewrite, rewriteActualPath, "rewrite",
+      opts.features, opts.parseOnly, &rewriteRoot);
+  if (exitCode) {
+    return exitCode;
+  }
+  return 0;
+}
+int main(int argc, const char* argv[]) {
+  Options opts;
+  int exitCode = parseCommandLine(argc, argv, &opts);
+  if (exitCode != 0) {
+    printf("Failed to parse command-line.");
+    return exitCode;
+  }
+  try {
+    return runTest(opts);
+  }
+  catch (const std::exception& e) {
+    printf("Unhandled exception:\n%s\n", e.what());
+    return 1;
+  }
+}

src/lib_json/CMakeLists.txt

@@ -0,0 +1,85 @@
+OPTION(JSONCPP_LIB_BUILD_SHARED "Build jsoncpp_lib as a shared library." OFF)
+OPTION(JSONCPP_LIB_BUILD_STATIC "Build jsoncpp_lib static library." ON)
+
+IF(BUILD_SHARED_LIBS)
+  SET(JSONCPP_LIB_BUILD_SHARED ON)
+ENDIF(BUILD_SHARED_LIBS)
+
+if( CMAKE_COMPILER_IS_GNUCXX )
+  #Get compiler version.
+  execute_process( COMMAND ${CMAKE_CXX_COMPILER} -dumpversion
+                   OUTPUT_VARIABLE GNUCXX_VERSION )
+ 
+  #-Werror=* was introduced -after- GCC 4.1.2
+  if( GNUCXX_VERSION VERSION_GREATER 4.1.2 )
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=strict-aliasing")
+  endif()
+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} )
+
+SET(jsoncpp_sources
+                json_tool.h
+                json_reader.cpp
+                json_valueiterator.inl
+                json_value.cpp
+                json_writer.cpp
+                version.h.in)
+
+# Install instructions for this target
+IF(JSONCPP_WITH_CMAKE_PACKAGE)
+    SET(INSTALL_EXPORT EXPORT jsoncpp)
+ELSE(JSONCPP_WITH_CMAKE_PACKAGE)
+    SET(INSTALL_EXPORT)
+ENDIF(JSONCPP_WITH_CMAKE_PACKAGE)
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+    ADD_DEFINITIONS( -DJSON_DLL_BUILD )
+    ADD_LIBRARY(jsoncpp_lib SHARED ${PUBLIC_HEADERS} ${jsoncpp_sources})
+    SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES VERSION ${JSONCPP_VERSION} SOVERSION ${JSONCPP_VERSION_MAJOR})
+    SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES OUTPUT_NAME jsoncpp )
+
+    INSTALL( TARGETS jsoncpp_lib ${INSTALL_EXPORT}
+         RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
+         LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
+         ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR})
+
+    IF(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+        TARGET_INCLUDE_DIRECTORIES( jsoncpp_lib PUBLIC
+                                   $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
+                                   $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>)
+    ENDIF(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+
+ENDIF()
+
+IF(JSONCPP_LIB_BUILD_STATIC)
+    ADD_LIBRARY(jsoncpp_lib_static STATIC ${PUBLIC_HEADERS} ${jsoncpp_sources})
+    SET_TARGET_PROPERTIES( jsoncpp_lib_static PROPERTIES VERSION ${JSONCPP_VERSION} SOVERSION ${JSONCPP_VERSION_MAJOR})
+    SET_TARGET_PROPERTIES( jsoncpp_lib_static PROPERTIES OUTPUT_NAME jsoncpp )
+
+    INSTALL( TARGETS jsoncpp_lib_static ${INSTALL_EXPORT}
+         RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
+         LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
+             ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR})
+
+    IF(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+        TARGET_INCLUDE_DIRECTORIES( jsoncpp_lib_static PUBLIC
+                                $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
+                                $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+                                )
+     ENDIF(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
+
+ENDIF()

src/lib_json/json_batchallocator.h

@@ -1,125 +0,0 @@
-#ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
-# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
-
-# include <stdlib.h>
-# include <assert.h>
-
-# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-namespace Json {
-
-/* Fast memory allocator.
- *
- * This memory allocator allocates memory for a batch of object (specified by
- * the page size, the number of object in each page).
- *
- * It does not allow the destruction of a single object. All the allocated objects
- * can be destroyed at once. The memory can be either released or reused for future
- * allocation.
- * 
- * The in-place new operator must be used to construct the object using the pointer
- * returned by allocate.
- */
-template<typename AllocatedType
-        ,const unsigned int objectPerAllocation>
-class BatchAllocator
-{
-public:
-   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.
-      assert( objectsPerPage >= 16 );
-      batches_ = allocateBatch( 0 );   // allocated a dummy page
-      currentBatch_ = batches_;
-   }
-
-   ~BatchAllocator()
-   {
-      for ( BatchInfo *batch = batches_; batch;  )
-      {
-         BatchInfo *nextBatch = batch->next_;
-         free( batch );
-         batch = nextBatch;
-      }
-   }
-
-   /// allocate space for an array of objectPerAllocation object.
-   /// @warning it is the responsability of the caller to call objects constructors.
-   AllocatedType *allocate()
-   {
-      if ( freeHead_ ) // returns node from free list.
-      {
-         AllocatedType *object = freeHead_;
-         freeHead_ = *(AllocatedType **)object;
-         return object;
-      }
-      if ( currentBatch_->used_ == currentBatch_->end_ )
-      {
-         currentBatch_ = currentBatch_->next_;
-         while ( currentBatch_  &&  currentBatch_->used_ == currentBatch_->end_ )
-            currentBatch_ = currentBatch_->next_;
-
-         if ( !currentBatch_  ) // no free batch found, allocate a new one
-         { 
-            currentBatch_ = allocateBatch( objectsPerPage_ );
-            currentBatch_->next_ = batches_; // insert at the head of the list
-            batches_ = currentBatch_;
-         }
-      }
-      AllocatedType *allocated = currentBatch_->used_;
-      currentBatch_->used_ += objectPerAllocation;
-      return allocated;
-   }
-
-   /// Release the object.
-   /// @warning it is the responsability of the caller to actually destruct the object.
-   void release( AllocatedType *object )
-   {
-      assert( object != 0 );
-      *(AllocatedType **)object = freeHead_;
-      freeHead_ = object;
-   }
-
-private:
-   struct BatchInfo
-   {
-      BatchInfo *next_;
-      AllocatedType *used_;
-      AllocatedType *end_;
-      AllocatedType buffer_[objectPerAllocation];
-   };
-
-   // disabled copy constructor and assignement operator.
-   BatchAllocator( const BatchAllocator & );
-   void operator =( const BatchAllocator &);
-
-   static BatchInfo *allocateBatch( unsigned int objectsPerPage )
-   {
-      const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
-                                + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
-      BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
-      batch->next_ = 0;
-      batch->used_ = batch->buffer_;
-      batch->end_ = batch->buffer_ + objectsPerPage;
-      return batch;
-   }
-
-   BatchInfo *batches_;
-   BatchInfo *currentBatch_;
-   /// Head of a single linked list within the allocated space of freeed object
-   AllocatedType *freeHead_;
-   unsigned int objectsPerPage_;
-};
-
-
-} // namespace Json
-
-# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
-
-#endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
-

src/lib_json/json_internalarray.inl

@@ -1,448 +0,0 @@
-// included by json_value.cpp
-// everything is within Json namespace
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalArray
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueArrayAllocator::~ValueArrayAllocator()
-{
-}
-
-// //////////////////////////////////////////////////////////////////
-// class DefaultValueArrayAllocator
-// //////////////////////////////////////////////////////////////////
-#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueArrayAllocator : public ValueArrayAllocator
-{
-public: // overridden from ValueArrayAllocator
-   virtual ~DefaultValueArrayAllocator()
-   {
-   }
-
-   virtual ValueInternalArray *newArray()
-   {
-      return new ValueInternalArray();
-   }
-
-   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
-   {
-      return new ValueInternalArray( other );
-   }
-
-   virtual void destructArray( ValueInternalArray *array )
-   {
-      delete array;
-   }
-
-   virtual void reallocateArrayPageIndex( Value **&indexes, 
-                                          ValueInternalArray::PageIndex &indexCount,
-                                          ValueInternalArray::PageIndex minNewIndexCount )
-   {
-      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
-      if ( minNewIndexCount > newIndexCount )
-         newIndexCount = minNewIndexCount;
-      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
-      if ( !newIndexes )
-         throw std::bad_alloc();
-      indexCount = newIndexCount;
-      indexes = static_cast<Value **>( newIndexes );
-   }
-   virtual void releaseArrayPageIndex( Value **indexes, 
-                                       ValueInternalArray::PageIndex indexCount )
-   {
-      if ( indexes )
-         free( indexes );
-   }
-
-   virtual Value *allocateArrayPage()
-   {
-      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
-   }
-
-   virtual void releaseArrayPage( Value *value )
-   {
-      if ( value )
-         free( value );
-   }
-};
-
-#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-/// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueArrayAllocator : public ValueArrayAllocator
-{
-public: // overridden from ValueArrayAllocator
-   virtual ~DefaultValueArrayAllocator()
-   {
-   }
-
-   virtual ValueInternalArray *newArray()
-   {
-      ValueInternalArray *array = arraysAllocator_.allocate();
-      new (array) ValueInternalArray(); // placement new
-      return array;
-   }
-
-   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
-   {
-      ValueInternalArray *array = arraysAllocator_.allocate();
-      new (array) ValueInternalArray( other ); // placement new
-      return array;
-   }
-
-   virtual void destructArray( ValueInternalArray *array )
-   {
-      if ( array )
-      {
-         array->~ValueInternalArray();
-         arraysAllocator_.release( array );
-      }
-   }
-
-   virtual void reallocateArrayPageIndex( Value **&indexes, 
-                                          ValueInternalArray::PageIndex &indexCount,
-                                          ValueInternalArray::PageIndex minNewIndexCount )
-   {
-      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
-      if ( minNewIndexCount > newIndexCount )
-         newIndexCount = minNewIndexCount;
-      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
-      if ( !newIndexes )
-         throw std::bad_alloc();
-      indexCount = newIndexCount;
-      indexes = static_cast<Value **>( newIndexes );
-   }
-   virtual void releaseArrayPageIndex( Value **indexes, 
-                                       ValueInternalArray::PageIndex indexCount )
-   {
-      if ( indexes )
-         free( indexes );
-   }
-
-   virtual Value *allocateArrayPage()
-   {
-      return static_cast<Value *>( pagesAllocator_.allocate() );
-   }
-
-   virtual void releaseArrayPage( Value *value )
-   {
-      if ( value )
-         pagesAllocator_.release( value );
-   }
-private:
-   BatchAllocator<ValueInternalArray,1> arraysAllocator_;
-   BatchAllocator<Value,ValueInternalArray::itemsPerPage> pagesAllocator_;
-};
-#endif // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-
-static ValueArrayAllocator *&arrayAllocator()
-{
-   static DefaultValueArrayAllocator defaultAllocator;
-   static ValueArrayAllocator *arrayAllocator = &defaultAllocator;
-   return arrayAllocator;
-}
-
-static struct DummyArrayAllocatorInitializer {
-   DummyArrayAllocatorInitializer() 
-   {
-      arrayAllocator();      // ensure arrayAllocator() statics are initialized before main().
-   }
-} dummyArrayAllocatorInitializer;
-
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalArray
-// //////////////////////////////////////////////////////////////////
-bool 
-ValueInternalArray::equals( const IteratorState &x, 
-                            const IteratorState &other )
-{
-   return x.array_ == other.array_  
-          &&  x.currentItemIndex_ == other.currentItemIndex_  
-          &&  x.currentPageIndex_ == other.currentPageIndex_;
-}
-
-
-void 
-ValueInternalArray::increment( IteratorState &it )
-{
-   JSON_ASSERT_MESSAGE( it.array_  &&
-      (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_
-      != it.array_->size_,
-      "ValueInternalArray::increment(): moving iterator beyond end" );
-   ++(it.currentItemIndex_);
-   if ( it.currentItemIndex_ == itemsPerPage )
-   {
-      it.currentItemIndex_ = 0;
-      ++(it.currentPageIndex_);
-   }
-}
-
-
-void 
-ValueInternalArray::decrement( IteratorState &it )
-{
-   JSON_ASSERT_MESSAGE( it.array_  &&  it.currentPageIndex_ == it.array_->pages_ 
-                        &&  it.currentItemIndex_ == 0,
-      "ValueInternalArray::decrement(): moving iterator beyond end" );
-   if ( it.currentItemIndex_ == 0 )
-   {
-      it.currentItemIndex_ = itemsPerPage-1;
-      --(it.currentPageIndex_);
-   }
-   else
-   {
-      --(it.currentItemIndex_);
-   }
-}
-
-
-Value &
-ValueInternalArray::unsafeDereference( const IteratorState &it )
-{
-   return (*(it.currentPageIndex_))[it.currentItemIndex_];
-}
-
-
-Value &
-ValueInternalArray::dereference( const IteratorState &it )
-{
-   JSON_ASSERT_MESSAGE( it.array_  &&
-      (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_
-      < it.array_->size_,
-      "ValueInternalArray::dereference(): dereferencing invalid iterator" );
-   return unsafeDereference( it );
-}
-
-void 
-ValueInternalArray::makeBeginIterator( IteratorState &it ) const
-{
-   it.array_ = const_cast<ValueInternalArray *>( this );
-   it.currentItemIndex_ = 0;
-   it.currentPageIndex_ = pages_;
-}
-
-
-void 
-ValueInternalArray::makeIterator( IteratorState &it, ArrayIndex index ) const
-{
-   it.array_ = const_cast<ValueInternalArray *>( this );
-   it.currentItemIndex_ = index % itemsPerPage;
-   it.currentPageIndex_ = pages_ + index / itemsPerPage;
-}
-
-
-void 
-ValueInternalArray::makeEndIterator( IteratorState &it ) const
-{
-   makeIterator( it, size_ );
-}
-
-
-ValueInternalArray::ValueInternalArray()
-   : pages_( 0 )
-   , size_( 0 )
-   , pageCount_( 0 )
-{
-}
-
-
-ValueInternalArray::ValueInternalArray( const ValueInternalArray &other )
-   : pages_( 0 )
-   , pageCount_( 0 )
-   , size_( other.size_ )
-{
-   PageIndex minNewPages = other.size_ / itemsPerPage;
-   arrayAllocator()->reallocateArrayPageIndex( pages_, pageCount_, minNewPages );
-   JSON_ASSERT_MESSAGE( pageCount_ >= minNewPages, 
-                        "ValueInternalArray::reserve(): bad reallocation" );
-   IteratorState itOther;
-   other.makeBeginIterator( itOther );
-   Value *value;
-   for ( ArrayIndex index = 0; index < size_; ++index, increment(itOther) )
-   {
-      if ( index % itemsPerPage == 0 )
-      {
-         PageIndex pageIndex = index / itemsPerPage;
-         value = arrayAllocator()->allocateArrayPage();
-         pages_[pageIndex] = value;
-      }
-      new (value) Value( dereference( itOther ) );
-   }
-}
-
-
-ValueInternalArray &
-ValueInternalArray::operator =( const ValueInternalArray &other )
-{
-   ValueInternalArray temp( other );
-   swap( temp );
-   return *this;
-}
-
-
-ValueInternalArray::~ValueInternalArray()
-{
-   // destroy all constructed items
-   IteratorState it;
-   IteratorState itEnd;
-   makeBeginIterator( it);
-   makeEndIterator( itEnd );
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
-      Value *value = &dereference(it);
-      value->~Value();
-   }
-   // release all pages
-   PageIndex lastPageIndex = size_ / itemsPerPage;
-   for ( PageIndex pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex )
-      arrayAllocator()->releaseArrayPage( pages_[pageIndex] );
-   // release pages index
-   arrayAllocator()->releaseArrayPageIndex( pages_, pageCount_ );
-}
-
-
-void 
-ValueInternalArray::swap( ValueInternalArray &other )
-{
-   Value **tempPages = pages_;
-   pages_ = other.pages_;
-   other.pages_ = tempPages;
-   ArrayIndex tempSize = size_;
-   size_ = other.size_;
-   other.size_ = tempSize;
-   PageIndex tempPageCount = pageCount_;
-   pageCount_ = other.pageCount_;
-   other.pageCount_ = tempPageCount;
-}
-
-void 
-ValueInternalArray::clear()
-{
-   ValueInternalArray dummy;
-   swap( dummy );
-}
-
-
-void 
-ValueInternalArray::resize( ArrayIndex newSize )
-{
-   if ( newSize == 0 )
-      clear();
-   else if ( newSize < size_ )
-   {
-      IteratorState it;
-      IteratorState itEnd;
-      makeIterator( it, newSize );
-      makeIterator( itEnd, size_ );
-      for ( ; !equals(it,itEnd); increment(it) )
-      {
-         Value *value = &dereference(it);
-         value->~Value();
-      }
-      PageIndex pageIndex = (newSize + itemsPerPage - 1) / itemsPerPage;
-      PageIndex lastPageIndex = size_ / itemsPerPage;
-      for ( ; pageIndex < lastPageIndex; ++pageIndex )
-         arrayAllocator()->releaseArrayPage( pages_[pageIndex] );
-      size_ = newSize;
-   }
-   else if ( newSize > size_ )
-      resolveReference( newSize );
-}
-
-
-void 
-ValueInternalArray::makeIndexValid( ArrayIndex index )
-{
-   // Need to enlarge page index ?
-   if ( index >= pageCount_ * itemsPerPage )
-   {
-      PageIndex minNewPages = (index + 1) / itemsPerPage;
-      arrayAllocator()->reallocateArrayPageIndex( pages_, pageCount_, minNewPages );
-      JSON_ASSERT_MESSAGE( pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation" );
-   }
-
-   // Need to allocate new pages ?
-   ArrayIndex nextPageIndex = 
-      (size_ % itemsPerPage) != 0 ? size_ - (size_%itemsPerPage) + itemsPerPage
-                                  : size_;
-   if ( nextPageIndex <= index )
-   {
-      PageIndex pageIndex = nextPageIndex / itemsPerPage;
-      PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1;
-      for ( ; pageToAllocate-- > 0; ++pageIndex )
-         pages_[pageIndex] = arrayAllocator()->allocateArrayPage();
-   }
-
-   // Initialize all new entries
-   IteratorState it;
-   IteratorState itEnd;
-   makeIterator( it, size_ );
-   size_ = index + 1;
-   makeIterator( itEnd, size_ );
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
-      Value *value = &dereference(it);
-      new (value) Value(); // Construct a default value using placement new
-   }
-}
-
-Value &
-ValueInternalArray::resolveReference( ArrayIndex index )
-{
-   if ( index >= size_ )
-      makeIndexValid( index );
-   return pages_[index/itemsPerPage][index%itemsPerPage];
-}
-
-Value *
-ValueInternalArray::find( ArrayIndex index ) const
-{
-   if ( index >= size_ )
-      return 0;
-   return &(pages_[index/itemsPerPage][index%itemsPerPage]);
-}
-
-ValueInternalArray::ArrayIndex 
-ValueInternalArray::size() const
-{
-   return size_;
-}
-
-int 
-ValueInternalArray::distance( const IteratorState &x, const IteratorState &y )
-{
-   return indexOf(y) - indexOf(x);
-}
-
-
-ValueInternalArray::ArrayIndex 
-ValueInternalArray::indexOf( const IteratorState &iterator )
-{
-   if ( !iterator.array_ )
-      return ArrayIndex(-1);
-   return ArrayIndex(
-      (iterator.currentPageIndex_ - iterator.array_->pages_) * itemsPerPage 
-      + iterator.currentItemIndex_ );
-}
-
-
-int 
-ValueInternalArray::compare( const ValueInternalArray &other ) const
-{
-   int sizeDiff( size_ - other.size_ );
-   if ( sizeDiff != 0 )
-      return sizeDiff;
-   
-   for ( ArrayIndex index =0; index < size_; ++index )
-   {
-      int diff = pages_[index/itemsPerPage][index%itemsPerPage].compare( 
-         other.pages_[index/itemsPerPage][index%itemsPerPage] );
-      if ( diff != 0 )
-         return diff;
-   }
-   return 0;
-}

src/lib_json/json_internalmap.inl

@@ -1,607 +0,0 @@
-// included by json_value.cpp
-// everything is within Json namespace
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueInternalMap
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) );
-   * This optimization is used by the fast allocator.
-   */
-ValueInternalLink::ValueInternalLink()
-   : previous_( 0 )
-   , next_( 0 )
-{
-}
-
-ValueInternalLink::~ValueInternalLink()
-{ 
-   for ( int index =0; index < itemPerLink; ++index )
-   {
-      if ( !items_[index].isItemAvailable() )
-      {
-         if ( !items_[index].isMemberNameStatic() )
-            free( keys_[index] );
-      }
-      else
-         break;
-   }
-}
-
-
-
-ValueMapAllocator::~ValueMapAllocator()
-{
-}
-
-#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueMapAllocator : public ValueMapAllocator
-{
-public: // overridden from ValueMapAllocator
-   virtual ValueInternalMap *newMap()
-   {
-      return new ValueInternalMap();
-   }
-
-   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
-   {
-      return new ValueInternalMap( other );
-   }
-
-   virtual void destructMap( ValueInternalMap *map )
-   {
-      delete map;
-   }
-
-   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
-   {
-      return new ValueInternalLink[size];
-   }
-
-   virtual void releaseMapBuckets( ValueInternalLink *links )
-   {
-      delete [] links;
-   }
-
-   virtual ValueInternalLink *allocateMapLink()
-   {
-      return new ValueInternalLink();
-   }
-
-   virtual void releaseMapLink( ValueInternalLink *link )
-   {
-      delete link;
-   }
-};
-#else
-/// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueMapAllocator : public ValueMapAllocator
-{
-public: // overridden from ValueMapAllocator
-   virtual ValueInternalMap *newMap()
-   {
-      ValueInternalMap *map = mapsAllocator_.allocate();
-      new (map) ValueInternalMap(); // placement new
-      return map;
-   }
-
-   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
-   {
-      ValueInternalMap *map = mapsAllocator_.allocate();
-      new (map) ValueInternalMap( other ); // placement new
-      return map;
-   }
-
-   virtual void destructMap( ValueInternalMap *map )
-   {
-      if ( map )
-      {
-         map->~ValueInternalMap();
-         mapsAllocator_.release( map );
-      }
-   }
-
-   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
-   {
-      return new ValueInternalLink[size];
-   }
-
-   virtual void releaseMapBuckets( ValueInternalLink *links )
-   {
-      delete [] links;
-   }
-
-   virtual ValueInternalLink *allocateMapLink()
-   {
-      ValueInternalLink *link = linksAllocator_.allocate();
-      memset( link, 0, sizeof(ValueInternalLink) );
-      return link;
-   }
-
-   virtual void releaseMapLink( ValueInternalLink *link )
-   {
-      link->~ValueInternalLink();
-      linksAllocator_.release( link );
-   }
-private:
-   BatchAllocator<ValueInternalMap,1> mapsAllocator_;
-   BatchAllocator<ValueInternalLink,1> linksAllocator_;
-};
-#endif
-
-static ValueMapAllocator *&mapAllocator()
-{
-   static DefaultValueMapAllocator defaultAllocator;
-   static ValueMapAllocator *mapAllocator = &defaultAllocator;
-   return mapAllocator;
-}
-
-static struct DummyMapAllocatorInitializer {
-   DummyMapAllocatorInitializer() 
-   {
-      mapAllocator();      // ensure mapAllocator() statics are initialized before main().
-   }
-} dummyMapAllocatorInitializer;
-
-
-
-// h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32.
-
-/*
-use linked list hash map. 
-buckets array is a container.
-linked list element contains 6 key/values. (memory = (16+4) * 6 + 4 = 124)
-value have extra state: valid, available, deleted
-*/
-
-
-ValueInternalMap::ValueInternalMap()
-   : buckets_( 0 )
-   , tailLink_( 0 )
-   , bucketsSize_( 0 )
-   , itemCount_( 0 )
-{
-}
-
-
-ValueInternalMap::ValueInternalMap( const ValueInternalMap &other )
-   : buckets_( 0 )
-   , tailLink_( 0 )
-   , bucketsSize_( 0 )
-   , itemCount_( 0 )
-{
-   reserve( other.itemCount_ );
-   IteratorState it;
-   IteratorState itEnd;
-   other.makeBeginIterator( it );
-   other.makeEndIterator( itEnd );
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
-      bool isStatic;
-      const char *memberName = key( it, isStatic );
-      const Value &aValue = value( it );
-      resolveReference(memberName, isStatic) = aValue;
-   }
-}
-
-
-ValueInternalMap &
-ValueInternalMap::operator =( const ValueInternalMap &other )
-{
-   ValueInternalMap dummy( other );
-   swap( dummy );
-   return *this;
-}
-
-
-ValueInternalMap::~ValueInternalMap()
-{
-   if ( buckets_ )
-   {
-      for ( BucketIndex bucketIndex =0; bucketIndex < bucketsSize_; ++bucketIndex )
-      {
-         ValueInternalLink *link = buckets_[bucketIndex].next_;
-         while ( link )
-         {
-            ValueInternalLink *linkToRelease = link;
-            link = link->next_;
-            mapAllocator()->releaseMapLink( linkToRelease );
-         }
-      }
-      mapAllocator()->releaseMapBuckets( buckets_ );
-   }
-}
-
-
-void 
-ValueInternalMap::swap( ValueInternalMap &other )
-{
-   ValueInternalLink *tempBuckets = buckets_;
-   buckets_ = other.buckets_;
-   other.buckets_ = tempBuckets;
-   ValueInternalLink *tempTailLink = tailLink_;
-   tailLink_ = other.tailLink_;
-   other.tailLink_ = tempTailLink;
-   BucketIndex tempBucketsSize = bucketsSize_;
-   bucketsSize_ = other.bucketsSize_;
-   other.bucketsSize_ = tempBucketsSize;
-   BucketIndex tempItemCount = itemCount_;
-   itemCount_ = other.itemCount_;
-   other.itemCount_ = tempItemCount;
-}
-
-
-void 
-ValueInternalMap::clear()
-{
-   ValueInternalMap dummy;
-   swap( dummy );
-}
-
-
-ValueInternalMap::BucketIndex 
-ValueInternalMap::size() const
-{
-   return itemCount_;
-}
-
-bool 
-ValueInternalMap::reserveDelta( BucketIndex growth )
-{
-   return reserve( itemCount_ + growth );
-}
-
-bool 
-ValueInternalMap::reserve( BucketIndex newItemCount )
-{
-   if ( !buckets_  &&  newItemCount > 0 )
-   {
-      buckets_ = mapAllocator()->allocateMapBuckets( 1 );
-      bucketsSize_ = 1;
-      tailLink_ = &buckets_[0];
-   }
-//   BucketIndex idealBucketCount = (newItemCount + ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink;
-   return true;
-}
-
-
-const Value *
-ValueInternalMap::find( const char *key ) const
-{
-   if ( !bucketsSize_ )
-      return 0;
-   HashKey hashedKey = hash( key );
-   BucketIndex bucketIndex = hashedKey % bucketsSize_;
-   for ( const ValueInternalLink *current = &buckets_[bucketIndex]; 
-         current != 0; 
-         current = current->next_ )
-   {
-      for ( BucketIndex index=0; index < ValueInternalLink::itemPerLink; ++index )
-      {
-         if ( current->items_[index].isItemAvailable() )
-            return 0;
-         if ( strcmp( key, current->keys_[index] ) == 0 )
-            return &current->items_[index];
-      }
-   }
-   return 0;
-}
-
-
-Value *
-ValueInternalMap::find( const char *key )
-{
-   const ValueInternalMap *constThis = this;
-   return const_cast<Value *>( constThis->find( key ) );
-}
-
-
-Value &
-ValueInternalMap::resolveReference( const char *key,
-                                    bool isStatic )
-{
-   HashKey hashedKey = hash( key );
-   if ( bucketsSize_ )
-   {
-      BucketIndex bucketIndex = hashedKey % bucketsSize_;
-      ValueInternalLink **previous = 0;
-      BucketIndex index;
-      for ( ValueInternalLink *current = &buckets_[bucketIndex]; 
-            current != 0; 
-            previous = &current->next_, current = current->next_ )
-      {
-         for ( index=0; index < ValueInternalLink::itemPerLink; ++index )
-         {
-            if ( current->items_[index].isItemAvailable() )
-               return setNewItem( key, isStatic, current, index );
-            if ( strcmp( key, current->keys_[index] ) == 0 )
-               return current->items_[index];
-         }
-      }
-   }
-
-   reserveDelta( 1 );
-   return unsafeAdd( key, isStatic, hashedKey );
-}
-
-
-void 
-ValueInternalMap::remove( const char *key )
-{
-   HashKey hashedKey = hash( key );
-   if ( !bucketsSize_ )
-      return;
-   BucketIndex bucketIndex = hashedKey % bucketsSize_;
-   for ( ValueInternalLink *link = &buckets_[bucketIndex]; 
-         link != 0; 
-         link = link->next_ )
-   {
-      BucketIndex index;
-      for ( index =0; index < ValueInternalLink::itemPerLink; ++index )
-      {
-         if ( link->items_[index].isItemAvailable() )
-            return;
-         if ( strcmp( key, link->keys_[index] ) == 0 )
-         {
-            doActualRemove( link, index, bucketIndex );
-            return;
-         }
-      }
-   }
-}
-
-void 
-ValueInternalMap::doActualRemove( ValueInternalLink *link, 
-                                  BucketIndex index,
-                                  BucketIndex bucketIndex )
-{
-   // find last item of the bucket and swap it with the 'removed' one.
-   // set removed items flags to 'available'.
-   // if last page only contains 'available' items, then desallocate it (it's empty)
-   ValueInternalLink *&lastLink = getLastLinkInBucket( index );
-   BucketIndex lastItemIndex = 1; // a link can never be empty, so start at 1
-   for ( ;   
-         lastItemIndex < ValueInternalLink::itemPerLink; 
-         ++lastItemIndex ) // may be optimized with dicotomic search
-   {
-      if ( lastLink->items_[lastItemIndex].isItemAvailable() )
-         break;
-   }
-   
-   BucketIndex lastUsedIndex = lastItemIndex - 1;
-   Value *valueToDelete = &link->items_[index];
-   Value *valueToPreserve = &lastLink->items_[lastUsedIndex];
-   if ( valueToDelete != valueToPreserve )
-      valueToDelete->swap( *valueToPreserve );
-   if ( lastUsedIndex == 0 )  // page is now empty
-   {  // remove it from bucket linked list and delete it.
-      ValueInternalLink *linkPreviousToLast = lastLink->previous_;
-      if ( linkPreviousToLast != 0 )   // can not deleted bucket link.
-      {
-         mapAllocator()->releaseMapLink( lastLink );
-         linkPreviousToLast->next_ = 0;
-         lastLink = linkPreviousToLast;
-      }
-   }
-   else
-   {
-      Value dummy;
-      valueToPreserve->swap( dummy ); // restore deleted to default Value.
-      valueToPreserve->setItemUsed( false );
-   }
-   --itemCount_;
-}
-
-
-ValueInternalLink *&
-ValueInternalMap::getLastLinkInBucket( BucketIndex bucketIndex )
-{
-   if ( bucketIndex == bucketsSize_ - 1 )
-      return tailLink_;
-   ValueInternalLink *&previous = buckets_[bucketIndex+1].previous_;
-   if ( !previous )
-      previous = &buckets_[bucketIndex];
-   return previous;
-}
-
-
-Value &
-ValueInternalMap::setNewItem( const char *key, 
-                              bool isStatic,
-                              ValueInternalLink *link, 
-                              BucketIndex index )
-{
-   char *duplicatedKey = valueAllocator()->makeMemberName( key );
-   ++itemCount_;
-   link->keys_[index] = duplicatedKey;
-   link->items_[index].setItemUsed();
-   link->items_[index].setMemberNameIsStatic( isStatic );
-   return link->items_[index]; // items already default constructed.
-}
-
-
-Value &
-ValueInternalMap::unsafeAdd( const char *key, 
-                             bool isStatic, 
-                             HashKey hashedKey )
-{
-   JSON_ASSERT_MESSAGE( bucketsSize_ > 0, "ValueInternalMap::unsafeAdd(): internal logic error." );
-   BucketIndex bucketIndex = hashedKey % bucketsSize_;
-   ValueInternalLink *&previousLink = getLastLinkInBucket( bucketIndex );
-   ValueInternalLink *link = previousLink;
-   BucketIndex index;
-   for ( index =0; index < ValueInternalLink::itemPerLink; ++index )
-   {
-      if ( link->items_[index].isItemAvailable() )
-         break;
-   }
-   if ( index == ValueInternalLink::itemPerLink ) // need to add a new page
-   {
-      ValueInternalLink *newLink = mapAllocator()->allocateMapLink();
-      index = 0;
-      link->next_ = newLink;
-      previousLink = newLink;
-      link = newLink;
-   }
-   return setNewItem( key, isStatic, link, index );
-}
-
-
-ValueInternalMap::HashKey 
-ValueInternalMap::hash( const char *key ) const
-{
-   HashKey hash = 0;
-   while ( *key )
-      hash += *key++ * 37;
-   return hash;
-}
-
-
-int 
-ValueInternalMap::compare( const ValueInternalMap &other ) const
-{
-   int sizeDiff( itemCount_ - other.itemCount_ );
-   if ( sizeDiff != 0 )
-      return sizeDiff;
-   // Strict order guaranty is required. Compare all keys FIRST, then compare values.
-   IteratorState it;
-   IteratorState itEnd;
-   makeBeginIterator( it );
-   makeEndIterator( itEnd );
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
-      if ( !other.find( key( it ) ) )
-         return 1;
-   }
-
-   // All keys are equals, let's compare values
-   makeBeginIterator( it );
-   for ( ; !equals(it,itEnd); increment(it) )
-   {
-      const Value *otherValue = other.find( key( it ) );
-      int valueDiff = value(it).compare( *otherValue );
-      if ( valueDiff != 0 )
-         return valueDiff;
-   }
-   return 0;
-}
-
-
-void 
-ValueInternalMap::makeBeginIterator( IteratorState &it ) const
-{
-   it.map_ = const_cast<ValueInternalMap *>( this );
-   it.bucketIndex_ = 0;
-   it.itemIndex_ = 0;
-   it.link_ = buckets_;
-}
-
-
-void 
-ValueInternalMap::makeEndIterator( IteratorState &it ) const
-{
-   it.map_ = const_cast<ValueInternalMap *>( this );
-   it.bucketIndex_ = bucketsSize_;
-   it.itemIndex_ = 0;
-   it.link_ = 0;
-}
-
-
-bool 
-ValueInternalMap::equals( const IteratorState &x, const IteratorState &other )
-{
-   return x.map_ == other.map_  
-          &&  x.bucketIndex_ == other.bucketIndex_  
-          &&  x.link_ == other.link_
-          &&  x.itemIndex_ == other.itemIndex_;
-}
-
-
-void 
-ValueInternalMap::incrementBucket( IteratorState &iterator )
-{
-   ++iterator.bucketIndex_;
-   JSON_ASSERT_MESSAGE( iterator.bucketIndex_ <= iterator.map_->bucketsSize_,
-      "ValueInternalMap::increment(): attempting to iterate beyond end." );
-   if ( iterator.bucketIndex_ == iterator.map_->bucketsSize_ )
-      iterator.link_ = 0;
-   else
-      iterator.link_ = &(iterator.map_->buckets_[iterator.bucketIndex_]);
-   iterator.itemIndex_ = 0;
-}
-
-
-void 
-ValueInternalMap::increment( IteratorState &iterator )
-{
-   JSON_ASSERT_MESSAGE( iterator.map_, "Attempting to iterator using invalid iterator." );
-   ++iterator.itemIndex_;
-   if ( iterator.itemIndex_ == ValueInternalLink::itemPerLink )
-   {
-      JSON_ASSERT_MESSAGE( iterator.link_ != 0,
-         "ValueInternalMap::increment(): attempting to iterate beyond end." );
-      iterator.link_ = iterator.link_->next_;
-      if ( iterator.link_ == 0 )
-         incrementBucket( iterator );
-   }
-   else if ( iterator.link_->items_[iterator.itemIndex_].isItemAvailable() )
-   {
-      incrementBucket( iterator );
-   }
-}
-
-
-void 
-ValueInternalMap::decrement( IteratorState &iterator )
-{
-   if ( iterator.itemIndex_ == 0 )
-   {
-      JSON_ASSERT_MESSAGE( iterator.map_, "Attempting to iterate using invalid iterator." );
-      if ( iterator.link_ == &iterator.map_->buckets_[iterator.bucketIndex_] )
-      {
-         JSON_ASSERT_MESSAGE( iterator.bucketIndex_ > 0, "Attempting to iterate beyond beginning." );
-         --(iterator.bucketIndex_);
-      }
-      iterator.link_ = iterator.link_->previous_;
-      iterator.itemIndex_ = ValueInternalLink::itemPerLink - 1;
-   }
-}
-
-
-const char *
-ValueInternalMap::key( const IteratorState &iterator )
-{
-   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
-   return iterator.link_->keys_[iterator.itemIndex_];
-}
-
-const char *
-ValueInternalMap::key( const IteratorState &iterator, bool &isStatic )
-{
-   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
-   isStatic = iterator.link_->items_[iterator.itemIndex_].isMemberNameStatic();
-   return iterator.link_->keys_[iterator.itemIndex_];
-}
-
-
-Value &
-ValueInternalMap::value( const IteratorState &iterator )
-{
-   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
-   return iterator.link_->items_[iterator.itemIndex_];
-}
-
-
-int 
-ValueInternalMap::distance( const IteratorState &x, const IteratorState &y )
-{
-   int offset = 0;
-   IteratorState it = x;
-   while ( !equals( it, y ) )
-      increment( it );
-   return offset;
-}

src/lib_json/json_tool.h

@@ -0,0 +1,87 @@
+// 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 LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+/* This header provides common string manipulation support, such as UTF-8,
+ * portable conversion from/to string...
+ *
+ * It is an internal header that must not be exposed.
+ */
+
+namespace Json {
+
+/// Converts a unicode code-point to UTF-8.
+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) {
+    result.resize(1);
+    result[0] = static_cast<char>(cp);
+  } 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) {
+    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) {
+    result.resize(4);
+    result[3] = static_cast<char>(0x80 | (0x3f & cp));
+    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+  }
+
+  return result;
+}
+
+/// Returns true if ch is a control character (in range [0,32[).
+static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
+
+enum {
+  /// Constant that specify the size of the buffer that must be passed to
+  /// uintToString.
+  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) {
+  *--current = 0;
+  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;
+  }
+}
+
+} // namespace Json {
+
+#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED

src/lib_json/json_valueiterator.inl

@@ -1,6 +1,11 @@
-// included by json_value.cpp
-// everything is within Json namespace
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
+// included by json_value.cpp
+
+namespace Json {
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -11,201 +16,105 @@
 // //////////////////////////////////////////////////////////////////
 
 ValueIteratorBase::ValueIteratorBase()
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   : current_()
-   , isNull_( true )
-{
+    : current_(), isNull_(true) {
 }
+
+ValueIteratorBase::ValueIteratorBase(
+    const Value::ObjectValues::iterator& current)
+    : current_(current), isNull_(false) {}
+
+Value& ValueIteratorBase::deref() const {
+  return current_->second;
+}
+
+void ValueIteratorBase::increment() {
+  ++current_;
+}
+
+void ValueIteratorBase::decrement() {
+  --current_;
+}
+
+ValueIteratorBase::difference_type
+ValueIteratorBase::computeDistance(const SelfType& other) const {
+#ifdef JSON_USE_CPPTL_SMALLMAP
+  return other.current_ - current_;
 #else
-   : isArray_( true )
-   , isNull_( true )
-{
-   iterator_.array_ = ValueInternalArray::IteratorState();
-}
-#endif
+  // Iterator for null value are initialized using the default
+  // constructor, which initialize current_ to the default
+  // std::map::iterator. As begin() and end() are two instance
+  // of the default std::map::iterator, they can not be compared.
+  // To allow this, we handle this comparison specifically.
+  if (isNull_ && other.isNull_) {
+    return 0;
+  }
 
-
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )
-   : current_( current )
-   , isNull_( false )
-{
-}
-#else
-ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
-   : isArray_( true )
-{
-   iterator_.array_ = state;
-}
-
-
-ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
-   : isArray_( false )
-{
-   iterator_.map_ = state;
-}
-#endif
-
-Value &
-ValueIteratorBase::deref() const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   return current_->second;
-#else
-   if ( isArray_ )
-      return ValueInternalArray::dereference( iterator_.array_ );
-   return ValueInternalMap::value( iterator_.map_ );
+  // 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) {
+    ++myDistance;
+  }
+  return myDistance;
 #endif
 }
 
-
-void 
-ValueIteratorBase::increment()
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   ++current_;
-#else
-   if ( isArray_ )
-      ValueInternalArray::increment( iterator_.array_ );
-   ValueInternalMap::increment( iterator_.map_ );
-#endif
+bool ValueIteratorBase::isEqual(const SelfType& other) const {
+  if (isNull_) {
+    return other.isNull_;
+  }
+  return current_ == other.current_;
 }
 
-
-void 
-ValueIteratorBase::decrement()
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   --current_;
-#else
-   if ( isArray_ )
-      ValueInternalArray::decrement( iterator_.array_ );
-   ValueInternalMap::decrement( iterator_.map_ );
-#endif
+void ValueIteratorBase::copy(const SelfType& other) {
+  current_ = other.current_;
+  isNull_ = other.isNull_;
 }
 
-
-ValueIteratorBase::difference_type 
-ValueIteratorBase::computeDistance( const SelfType &other ) const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-# ifdef JSON_USE_CPPTL_SMALLMAP
-   return current_ - other.current_;
-# else
-   // Iterator for null value are initialized using the default
-   // constructor, which initialize current_ to the default
-   // std::map::iterator. As begin() and end() are two instance 
-   // of the default std::map::iterator, they can not be compared.
-   // To allow this, we handle this comparison specifically.
-   if ( isNull_  &&  other.isNull_ )
-   {
-      return 0;
-   }
-
-
-   // 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 )
-   {
-      ++myDistance;
-   }
-   return myDistance;
-# endif
-#else
-   if ( isArray_ )
-      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
-   return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );
-#endif
+Value ValueIteratorBase::key() const {
+  const Value::CZString czstring = (*current_).first;
+  if (czstring.data()) {
+    if (czstring.isStaticString())
+      return Value(StaticString(czstring.data()));
+    return Value(czstring.data(), czstring.data() + czstring.length());
+  }
+  return Value(czstring.index());
 }
 
-
-bool 
-ValueIteratorBase::isEqual( const SelfType &other ) const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   if ( isNull_ )
-   {
-      return other.isNull_;
-   }
-   return current_ == other.current_;
-#else
-   if ( isArray_ )
-      return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );
-   return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );
-#endif
+UInt ValueIteratorBase::index() const {
+  const Value::CZString czstring = (*current_).first;
+  if (!czstring.data())
+    return czstring.index();
+  return Value::UInt(-1);
 }
 
-
-void 
-ValueIteratorBase::copy( const SelfType &other )
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   current_ = other.current_;
-#else
-   if ( isArray_ )
-      iterator_.array_ = other.iterator_.array_;
-   iterator_.map_ = other.iterator_.map_;
-#endif
+std::string ValueIteratorBase::name() const {
+  char const* key;
+  char const* end;
+  key = memberName(&end);
+  if (!key) return std::string();
+  return std::string(key, end);
 }
 
-
-Value 
-ValueIteratorBase::key() const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   const Value::CZString czstring = (*current_).first;
-   if ( czstring.c_str() )
-   {
-      if ( czstring.isStaticString() )
-         return Value( StaticString( czstring.c_str() ) );
-      return Value( czstring.c_str() );
-   }
-   return Value( czstring.index() );
-#else
-   if ( isArray_ )
-      return Value( ValueInternalArray::indexOf( iterator_.array_ ) );
-   bool isStatic;
-   const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );
-   if ( isStatic )
-      return Value( StaticString( memberName ) );
-   return Value( memberName );
-#endif
+char const* ValueIteratorBase::memberName() const {
+  const char* name = (*current_).first.data();
+  return name ? name : "";
 }
 
-
-UInt 
-ValueIteratorBase::index() const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   const Value::CZString czstring = (*current_).first;
-   if ( !czstring.c_str() )
-      return czstring.index();
-   return Value::UInt( -1 );
-#else
-   if ( isArray_ )
-      return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );
-   return Value::UInt( -1 );
-#endif
+char const* ValueIteratorBase::memberName(char const** end) const {
+  const char* name = (*current_).first.data();
+  if (!name) {
+    *end = NULL;
+    return NULL;
+  }
+  *end = name + (*current_).first.length();
+  return name;
 }
 
-
-const char *
-ValueIteratorBase::memberName() const
-{
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-   const char *name = (*current_).first.c_str();
-   return name ? name : "";
-#else
-   if ( !isArray_ )
-      return ValueInternalMap::key( iterator_.map_ );
-   return "";
-#endif
-}
-
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -214,35 +123,17 @@ ValueIteratorBase::memberName() const
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueConstIterator::ValueConstIterator()
-{
-}
+ValueConstIterator::ValueConstIterator() {}
 
+ValueConstIterator::ValueConstIterator(
+    const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
 
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
-   : ValueIteratorBase( current )
-{
+ValueConstIterator& ValueConstIterator::
+operator=(const ValueIteratorBase& other) {
+  copy(other);
+  return *this;
 }
-#else
-ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
-
-ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
-#endif
-
-ValueConstIterator &
-ValueConstIterator::operator =( const ValueIteratorBase &other )
-{
-   copy( other );
-   return *this;
-}
-
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -252,41 +143,20 @@ ValueConstIterator::operator =( const ValueIteratorBase &other )
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueIterator::ValueIterator()
-{
+ValueIterator::ValueIterator() {}
+
+ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
+
+ValueIterator::ValueIterator(const ValueConstIterator& other)
+    : ValueIteratorBase(other) {}
+
+ValueIterator::ValueIterator(const ValueIterator& other)
+    : ValueIteratorBase(other) {}
+
+ValueIterator& ValueIterator::operator=(const SelfType& other) {
+  copy(other);
+  return *this;
 }
 
-
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueIterator::ValueIterator( const Value::ObjectValues::iterator &current )
-   : ValueIteratorBase( current )
-{
-}
-#else
-ValueIterator::ValueIterator( const ValueInternalArray::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
-
-ValueIterator::ValueIterator( const ValueInternalMap::IteratorState &state )
-   : ValueIteratorBase( state )
-{
-}
-#endif
-
-ValueIterator::ValueIterator( const ValueConstIterator &other )
-   : ValueIteratorBase( other )
-{
-}
-
-ValueIterator::ValueIterator( const ValueIterator &other )
-   : ValueIteratorBase( other )
-{
-}
-
-ValueIterator &
-ValueIterator::operator =( const SelfType &other )
-{
-   copy( other );
-   return *this;
-}
+} // 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,41 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+  ADD_DEFINITIONS( -DJSON_DLL )
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+ADD_EXECUTABLE( jsoncpp_test 
+                jsontest.cpp
+                jsontest.h
+                main.cpp
+                )
+
+
+IF(JSONCPP_LIB_BUILD_SHARED)
+    TARGET_LINK_LIBRARIES(jsoncpp_test jsoncpp_lib)
+ELSE(JSONCPP_LIB_BUILD_SHARED)
+    TARGET_LINK_LIBRARIES(jsoncpp_test jsoncpp_lib_static)
+ENDIF(JSONCPP_LIB_BUILD_SHARED)
+
+# another way to solve issue #90
+#set_target_properties(jsoncpp_test PROPERTIES COMPILE_FLAGS -ffloat-store)
+
+# 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)
+    IF(JSONCPP_LIB_BUILD_SHARED)
+        # First, copy the shared lib, for Microsoft.
+        # Then, run the test executable.
+        ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
+                            POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:jsoncpp_lib> $<TARGET_FILE_DIR:jsoncpp_test>
+                            COMMAND $<TARGET_FILE:jsoncpp_test>)
+    ELSE(JSONCPP_LIB_BUILD_SHARED)
+        # Just run the test executable.
+        ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
+                            POST_BUILD
+                            COMMAND $<TARGET_FILE:jsoncpp_test>)
+    ENDIF(JSONCPP_LIB_BUILD_SHARED)
+ENDIF(JSONCPP_WITH_POST_BUILD_UNITTEST)
+
+SET_TARGET_PROPERTIES(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test) 

src/test_lib_json/jsontest.cpp

@@ -1,3 +1,8 @@
+// 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
+
 #define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
 #include "jsontest.h"
 #include <stdio.h>
@@ -5,599 +10,434 @@
 
 #if defined(_MSC_VER)
 // Used to install a report hook that prevent dialog on assertion and error.
-# include <crtdbg.h>
+#include <crtdbg.h>
 #endif // if defined(_MSC_VER)
 
 #if defined(_WIN32)
 // Used to prevent dialog on memory fault.
 // Limits headers included by Windows.h
-# define WIN32_LEAN_AND_MEAN
-# define NOSERVICE
-# define NOMCX
-# define NOIME
-# define NOSOUND
-# define NOCOMM
-# define NORPC
-# define NOGDI
-# define NOUSER
-# define NODRIVERS
-# define NOLOGERROR
-# define NOPROFILER
-# define NOMEMMGR
-# define NOLFILEIO
-# define NOOPENFILE
-# define NORESOURCE
-# define NOATOM
-# define NOLANGUAGE
-# define NOLSTRING
-# define NODBCS
-# define NOKEYBOARDINFO
-# define NOGDICAPMASKS
-# define NOCOLOR
-# define NOGDIOBJ
-# define NODRAWTEXT
-# define NOTEXTMETRIC
-# define NOSCALABLEFONT
-# define NOBITMAP
-# define NORASTEROPS
-# define NOMETAFILE
-# define NOSYSMETRICS
-# define NOSYSTEMPARAMSINFO
-# define NOMSG
-# define NOWINSTYLES
-# define NOWINOFFSETS
-# define NOSHOWWINDOW
-# define NODEFERWINDOWPOS
-# define NOVIRTUALKEYCODES
-# define NOKEYSTATES
-# define NOWH
-# define NOMENUS
-# define NOSCROLL
-# define NOCLIPBOARD
-# define NOICONS
-# define NOMB
-# define NOSYSCOMMANDS
-# define NOMDI
-# define NOCTLMGR
-# define NOWINMESSAGES
-# include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#define NOSOUND
+#define NOCOMM
+#define NORPC
+#define NOGDI
+#define NOUSER
+#define NODRIVERS
+#define NOLOGERROR
+#define NOPROFILER
+#define NOMEMMGR
+#define NOLFILEIO
+#define NOOPENFILE
+#define NORESOURCE
+#define NOATOM
+#define NOLANGUAGE
+#define NOLSTRING
+#define NODBCS
+#define NOKEYBOARDINFO
+#define NOGDICAPMASKS
+#define NOCOLOR
+#define NOGDIOBJ
+#define NODRAWTEXT
+#define NOTEXTMETRIC
+#define NOSCALABLEFONT
+#define NOBITMAP
+#define NORASTEROPS
+#define NOMETAFILE
+#define NOSYSMETRICS
+#define NOSYSTEMPARAMSINFO
+#define NOMSG
+#define NOWINSTYLES
+#define NOWINOFFSETS
+#define NOSHOWWINDOW
+#define NODEFERWINDOWPOS
+#define NOVIRTUALKEYCODES
+#define NOKEYSTATES
+#define NOWH
+#define NOMENUS
+#define NOSCROLL
+#define NOCLIPBOARD
+#define NOICONS
+#define NOMB
+#define NOSYSCOMMANDS
+#define NOMDI
+#define NOCTLMGR
+#define NOWINMESSAGES
+#include <windows.h>
 #endif // if defined(_WIN32)
 
 namespace JsonTest {
 
-
 // class TestResult
 // //////////////////////////////////////////////////////////////////
 
 TestResult::TestResult()
-   : predicateId_( 1 )
-   , lastUsedPredicateId_( 0 )
-   , messageTarget_( 0 )
-{
-   // The root predicate has id 0
-   rootPredicateNode_.id_ = 0;
-   rootPredicateNode_.next_ = 0;
-   predicateStackTail_ = &rootPredicateNode_;
+    : 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.
+  unsigned int nestingLevel = 0;
+  PredicateContext* lastNode = rootPredicateNode_.next_;
+  for (; lastNode != 0; lastNode = lastNode->next_) {
+    if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
+    {
+      lastUsedPredicateId_ = lastNode->id_;
+      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());
+    }
+    ++nestingLevel;
+  }
+
+  // Adds the failed assertion
+  addFailureInfo(file, line, expr, nestingLevel);
+  messageTarget_ = &(failures_.back());
+  return *this;
 }
 
-TestResult &
-TestResult::addFailure( const char *file, unsigned int line,
-                        const char *expr )
-{
-   /// Walks the PredicateContext stack adding them to failures_ if not already added.
-   unsigned int nestingLevel = 0;
-   PredicateContext *lastNode = rootPredicateNode_.next_;
-   for ( ; lastNode != 0; lastNode = lastNode->next_ )
-   {
-      if ( lastNode->id_ > lastUsedPredicateId_ ) // new PredicateContext
-      {
-         lastUsedPredicateId_ = lastNode->id_;
-         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() );
-      }
-      ++nestingLevel;
-   }
-
-   // Adds the failed assertion
-   addFailureInfo( file, line, expr, nestingLevel );
-   messageTarget_ = &( failures_.back() );
-   return *this;
+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) {
+    failure.expr_ = expr;
+  }
+  failure.nestingLevel_ = nestingLevel;
+  failures_.push_back(failure);
 }
 
-
-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 )
-   {
-      failure.expr_ = expr;
-   }
-   failure.nestingLevel_ = nestingLevel;
-   failures_.push_back( failure );
+TestResult& TestResult::popPredicateContext() {
+  PredicateContext* lastNode = &rootPredicateNode_;
+  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) {
+    messageTarget_ = tail->failure_;
+  }
+  // Remove tail from list
+  predicateStackTail_ = lastNode;
+  lastNode->next_ = 0;
+  return *this;
 }
 
+bool TestResult::failed() const { return !failures_.empty(); }
 
-TestResult &
-TestResult::popPredicateContext()
-{
-   PredicateContext *lastNode = &rootPredicateNode_;
-   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 )
-   {
-      messageTarget_ = tail->failure_;
-   }
-   // Remove tail from list
-   predicateStackTail_ = lastNode;
-   lastNode->next_ = 0;
-   return *this;
+unsigned int TestResult::getAssertionNestingLevel() const {
+  unsigned int level = 0;
+  const PredicateContext* lastNode = &rootPredicateNode_;
+  while (lastNode->next_ != 0) {
+    lastNode = lastNode->next_;
+    ++level;
+  }
+  return level;
 }
 
+void TestResult::printFailure(bool printTestName) const {
+  if (failures_.empty()) {
+    return;
+  }
 
-bool 
-TestResult::failed() const
-{
-   return !failures_.empty();
+  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) {
+    const Failure& failure = *it;
+    std::string indent(failure.nestingLevel_ * 2, ' ');
+    if (failure.file_) {
+      printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);
+    }
+    if (!failure.expr_.empty()) {
+      printf("%s\n", failure.expr_.c_str());
+    } else if (failure.file_) {
+      printf("\n");
+    }
+    if (!failure.message_.empty()) {
+      std::string reindented = indentText(failure.message_, indent + "  ");
+      printf("%s\n", reindented.c_str());
+    }
+  }
 }
 
-
-unsigned int 
-TestResult::getAssertionNestingLevel() const
-{
-   unsigned int level = 0;
-   const PredicateContext *lastNode = &rootPredicateNode_;
-   while ( lastNode->next_ != 0 )
-   {
-      lastNode = lastNode->next_;
-      ++level;
-   }
-   return level;
+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()) {
+    std::string::size_type nextIndex = text.find('\n', lastIndex);
+    if (nextIndex == std::string::npos) {
+      nextIndex = text.size() - 1;
+    }
+    reindented += indent;
+    reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
+    lastIndex = nextIndex + 1;
+  }
+  return reindented;
 }
 
-
-void 
-TestResult::printFailure( bool printTestName ) const
-{
-   if ( failures_.empty() )
-   {
-      return;
-   }
-
-   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 )
-   {
-      const Failure &failure = *it;
-      std::string indent( failure.nestingLevel_ * 2, ' ' );
-      if ( failure.file_ )
-      {
-         printf( "%s%s(%d): ", indent.c_str(), failure.file_, failure.line_ );
-      }
-      if ( !failure.expr_.empty() )
-      {
-         printf( "%s\n", failure.expr_.c_str() );
-      }
-      else if ( failure.file_ )
-      {
-         printf( "\n" );
-      }
-      if ( !failure.message_.empty() )
-      {
-         std::string reindented = indentText( failure.message_, indent + "  " );
-         printf( "%s\n", reindented.c_str() );
-      }
-   }
+TestResult& TestResult::addToLastFailure(const std::string& message) {
+  if (messageTarget_ != 0) {
+    messageTarget_->message_ += message;
+  }
+  return *this;
 }
 
-
-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() )
-   {
-      std::string::size_type nextIndex = text.find( '\n', lastIndex );
-      if ( nextIndex == std::string::npos )
-      {
-         nextIndex = text.size() - 1;
-      }
-      reindented += indent;
-      reindented += text.substr( lastIndex, nextIndex - lastIndex + 1 );
-      lastIndex = nextIndex + 1;
-   }
-   return reindented;
+TestResult& TestResult::operator<<(Json::Int64 value) {
+  return addToLastFailure(Json::valueToString(value));
 }
 
-
-TestResult &
-TestResult::addToLastFailure( const std::string &message )
-{
-   if ( messageTarget_ != 0 )
-   {
-      messageTarget_->message_ += message;
-   }
-   return *this;
+TestResult& TestResult::operator<<(Json::UInt64 value) {
+  return addToLastFailure(Json::valueToString(value));
 }
 
-
-TestResult &
-TestResult::operator << ( bool value )
-{
-   return addToLastFailure( value ? "true" : "false" );
+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() {}
+
+void TestCase::run(TestResult& result) {
+  result_ = &result;
+  runTestCase();
 }
 
-
-TestCase::~TestCase()
-{
-}
-
-
-void 
-TestCase::run( TestResult &result )
-{
-   result_ = &result;
-   runTestCase();
-}
-
-
-
 // class Runner
 // //////////////////////////////////////////////////////////////////
 
-Runner::Runner()
-{
+Runner::Runner() {}
+
+Runner& Runner::add(TestCaseFactory factory) {
+  tests_.push_back(factory);
+  return *this;
 }
 
-
-Runner &
-Runner::add( TestCaseFactory factory )
-{
-   tests_.push_back( factory );
-   return *this;
+unsigned int Runner::testCount() const {
+  return static_cast<unsigned int>(tests_.size());
 }
 
-
-unsigned int 
-Runner::testCount() const
-{
-   return static_cast<unsigned int>( tests_.size() );
+std::string Runner::testNameAt(unsigned int index) const {
+  TestCase* test = tests_[index]();
+  std::string name = test->testName();
+  delete test;
+  return name;
 }
 
-
-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
-{
-   TestCase *test = tests_[index]();
-   result.setTestName( test->testName() );
-   printf( "Testing %s: ", test->testName() );
-   fflush( stdout );
+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 );
+    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";
-   printf( "%s\n", status );
-   fflush( stdout );
+  delete test;
+  const char* status = result.failed() ? "FAILED" : "OK";
+  printf("%s\n", status);
+  fflush(stdout);
 }
 
+bool Runner::runAllTest(bool printSummary) const {
+  unsigned int count = testCount();
+  std::deque<TestResult> failures;
+  for (unsigned int index = 0; index < count; ++index) {
+    TestResult result;
+    runTestAt(index, result);
+    if (result.failed()) {
+      failures.push_back(result);
+    }
+  }
 
-bool 
-Runner::runAllTest( bool printSummary ) const
-{
-   unsigned int count = testCount();
-   std::deque<TestResult> failures;
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      TestResult result;
-      runTestAt( index, result );
-      if ( result.failed() )
-      {
-         failures.push_back( result );
-      }
-   }
+  if (failures.empty()) {
+    if (printSummary) {
+      printf("All %d tests passed\n", count);
+    }
+    return true;
+  } else {
+    for (unsigned int index = 0; index < failures.size(); ++index) {
+      TestResult& result = failures[index];
+      result.printFailure(count > 1);
+    }
 
-   if ( failures.empty() )
-   {
-      if ( printSummary )
-      {
-         printf( "All %d tests passed\n", count );
-      }
+    if (printSummary) {
+      unsigned int failedCount = static_cast<unsigned int>(failures.size());
+      unsigned int passedCount = count - failedCount;
+      printf("%d/%d tests passed (%d failure(s))\n",
+             passedCount,
+             count,
+             failedCount);
+    }
+    return false;
+  }
+}
+
+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) {
+      indexOut = index;
       return true;
-   }
-   else
-   {
-      for ( unsigned int index = 0; index < failures.size(); ++index )
-      {
-         TestResult &result = failures[index];
-         result.printFailure( count > 1 );
-      }
-
-      if ( printSummary )
-      {
-         unsigned int failedCount = static_cast<unsigned int>( failures.size() );
-         unsigned int passedCount = count - failedCount;
-         printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
-      }
-      return false;
-   }
+    }
+  }
+  return false;
 }
 
-
-bool 
-Runner::testIndex( const std::string &testName, 
-                   unsigned int &indexOut ) const
-{
-   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      if ( testNameAt(index) == testName )
-      {
-         indexOut = index;
-         return true;
-      }
-   }
-   return false;
+void Runner::listTests() const {
+  unsigned int count = testCount();
+  for (unsigned int index = 0; index < count; ++index) {
+    printf("%s\n", testNameAt(index).c_str());
+  }
 }
 
-
-void 
-Runner::listTests() const
-{
-   unsigned int count = testCount();
-   for ( unsigned int index = 0; index < count; ++index )
-   {
-      printf( "%s\n", testNameAt( index ).c_str() );
-   }
+int Runner::runCommandLine(int argc, const char* argv[]) const {
+  // typedef std::deque<std::string> TestNames;
+  Runner subrunner;
+  for (int index = 1; index < argc; ++index) {
+    std::string opt = argv[index];
+    if (opt == "--list-tests") {
+      listTests();
+      return 0;
+    } else if (opt == "--test-auto") {
+      preventDialogOnCrash();
+    } else if (opt == "--test") {
+      ++index;
+      if (index < argc) {
+        unsigned int testNameIndex;
+        if (testIndex(argv[index], testNameIndex)) {
+          subrunner.add(tests_[testNameIndex]);
+        } else {
+          fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
+          return 2;
+        }
+      } else {
+        printUsage(argv[0]);
+        return 2;
+      }
+    } else {
+      printUsage(argv[0]);
+      return 2;
+    }
+  }
+  bool succeeded;
+  if (subrunner.testCount() > 0) {
+    succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
+  } else {
+    succeeded = runAllTest(true);
+  }
+  return succeeded ? 0 : 1;
 }
 
-
-int 
-Runner::runCommandLine( int argc, const char *argv[] ) const
-{
-   typedef std::deque<std::string> TestNames;
-   Runner subrunner;
-   for ( int index = 1; index < argc; ++index )
-   {
-      std::string opt = argv[index];
-      if ( opt == "--list-tests" )
-      {
-         listTests();
-         return 0;
-      }
-      else if ( opt == "--test-auto" )
-      {
-         preventDialogOnCrash();
-      }
-      else if ( opt == "--test" )
-      {
-         ++index;
-         if ( index < argc )
-         {
-            unsigned int testNameIndex;
-            if ( testIndex( argv[index], testNameIndex ) )
-            {
-               subrunner.add( tests_[testNameIndex] );
-            }
-            else
-            {
-               fprintf( stderr, "Test '%s' does not exist!\n", argv[index] );
-               return 2;
-            }
-         }
-         else
-         {
-            printUsage( argv[0] );
-            return 2;
-         }
-      }
-      else
-      {
-         printUsage( argv[0] );
-         return 2;
-      }
-   }
-   bool succeeded;
-   if ( subrunner.testCount() > 0 )
-   {
-      succeeded = subrunner.runAllTest( subrunner.testCount() > 1 );
-   }
-   else
-   {
-      succeeded = runAllTest( true );
-   }
-   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 )
-{
-   // 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 )
-   {
-      // 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 ) 
-      {
-         return TRUE;
-      }
-      isAborting = true;
+static int
+msvcrtSilentReportHook(int reportType, char* message, int* /*returnValue*/) {
+  // The default CRT handling of error and assertion is to display
+  // an error dialog to the user.
+  // Instead, when an error or an assertion occurs, we force the
+  // application to terminate using abort() after display
+  // the message on stderr.
+  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) {
+      return TRUE;
+    }
+    isAborting = true;
 
-      fprintf( stderr, "CRT Error/Assert:\n%s\n", message );
-      fflush( stderr );
-      abort();
-   }
-   // Let's other reportType (_CRT_WARNING) be handled as they would by default
-   return FALSE;
+    fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
+    fflush(stderr);
+    abort();
+  }
+  // Let's other reportType (_CRT_WARNING) be handled as they would by default
+  return FALSE;
 }
 #endif // if defined(_MSC_VER)
 
-
-void 
-Runner::preventDialogOnCrash()
-{
-#if defined(_MSC_VER)
-   // Install a hook to prevent MSVCRT error and assertion from
-   // popping a dialog.
-   _CrtSetReportHook( &msvcrtSilentReportHook );
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
+  // Install a hook to prevent MSVCRT error and assertion from
+  // 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)
 
-   // @todo investiguate this handler (for buffer overflow)
-   // _set_security_error_handler
+// @todo investiguate this handler (for buffer overflow)
+// _set_security_error_handler
 
 #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 );
+  // 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);
 #endif // if defined(_WIN32)
 }
 
-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"
-      "Valid options:\n"
-      "--list-tests: print the name of all test cases on the standard\n"
-      "              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 );
+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"
+         "Valid options:\n"
+         "--list-tests: print the name of all test cases on the standard\n"
+         "              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);
 }
 
-
-
 // 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 )
-   {
-      result.addFailure( file, line, expr );
-      result << "Expected: '" << 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) {
+  if (expected != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: '" << expected << "'\n";
+    result << "Actual  : '" << actual << "'";
+  }
+  return result;
 }
 
-
 } // namespace JsonTest

src/test_lib_json/jsontest.h

@@ -1,10 +1,18 @@
-#ifndef JSONTEST_H_INCLUDED
-# define JSONTEST_H_INCLUDED
+// 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
 
-# include <json/config.h>
-# include <stdio.h>
-# include <deque>
-# include <string>
+#ifndef JSONTEST_H_INCLUDED
+#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>
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -12,8 +20,6 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-
-
 /** \brief Unit testing framework.
  * \warning: all assertions are non-aborting, test case execution will continue
  *           even if an assertion namespace.
@@ -22,233 +28,253 @@
  */
 namespace JsonTest {
 
+class Failure {
+public:
+  const char* file_;
+  unsigned int line_;
+  std::string expr_;
+  std::string message_;
+  unsigned int nestingLevel_;
+};
 
-   class Failure
-   {
-   public:
-      const char *file_;
-      unsigned int line_;
-      std::string expr_;
-      std::string message_;
-      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 {
+  typedef unsigned int Id;
+  Id id_;
+  const char* file_;
+  unsigned int line_;
+  const char* expr_;
+  PredicateContext* next_;
+  /// Related Failure, set when the PredicateContext is converted
+  /// into a Failure.
+  Failure* failure_;
+};
 
+class TestResult {
+public:
+  TestResult();
 
-   /// Context used to create the assertion callstack on failure.
-   /// Must be a POD to allow inline initialisation without stepping 
-   /// into the debugger.
-   struct PredicateContext
-   {
-      typedef unsigned int Id;
-      Id id_;
-      const char *file_;
-      unsigned int line_;
-      const char *expr_;
-      PredicateContext *next_;
-      /// Related Failure, set when the PredicateContext is converted
-      /// into a Failure.
-      Failure *failure_;
-   };
+  /// \internal Implementation detail for assertion macros
+  /// Not encapsulated to prevent step into when debugging failed assertions
+  /// Incremented by one on assertion predicate entry, decreased by one
+  /// by addPredicateContext().
+  PredicateContext::Id predicateId_;
 
-   class TestResult
-   {
-   public:
-      TestResult();
+  /// \internal Implementation detail for predicate macros
+  PredicateContext* predicateStackTail_;
 
-      /// \internal Implementation detail for assertion macros
-      /// Not encapsulated to prevent step into when debugging failed assertions
-      /// Incremented by one on assertion predicate entry, decreased by one
-      /// by addPredicateContext().
-      PredicateContext::Id predicateId_;
+  void setTestName(const std::string& name);
 
-      /// \internal Implementation detail for predicate macros
-      PredicateContext *predicateStackTail_;
+  /// Adds an assertion failure.
+  TestResult&
+  addFailure(const char* file, unsigned int line, const char* expr = 0);
 
-      void setTestName( const std::string &name );
+  /// Removes the last PredicateContext added to the predicate stack
+  /// chained list.
+  /// Next messages will be targed at the PredicateContext that was removed.
+  TestResult& popPredicateContext();
 
-      /// Adds an assertion failure.
-      TestResult &addFailure( const char *file, unsigned int line,
-                              const char *expr = 0 );
+  bool failed() const;
 
-      /// Removes the last PredicateContext added to the predicate stack
-      /// chained list.
-      /// Next messages will be targed at the PredicateContext that was removed.
-      TestResult &popPredicateContext();
+  void printFailure(bool printTestName) const;
 
-      bool failed() 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());
+  }
 
-      void printFailure( bool printTestName ) const;
+  // Specialized versions.
+  TestResult& operator<<(bool value);
+  // std:ostream does not support 64bits integers on all STL implementation
+  TestResult& operator<<(Json::Int64 value);
+  TestResult& operator<<(Json::UInt64 value);
 
-      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 );
+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);
+  static std::string indentText(const std::string& text,
+                                const std::string& indent);
 
-   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  );
-      static std::string indentText( const std::string &text, 
-                                     const std::string &indent );
+  typedef std::deque<Failure> Failures;
+  Failures failures_;
+  std::string name_;
+  PredicateContext rootPredicateNode_;
+  PredicateContext::Id lastUsedPredicateId_;
+  /// Failure which is the target of the messages added using operator <<
+  Failure* messageTarget_;
+};
 
-      typedef std::deque<Failure> Failures;
-      Failures failures_;
-      std::string name_;
-      PredicateContext rootPredicateNode_;
-      PredicateContext::Id lastUsedPredicateId_;
-      /// Failure which is the target of the messages added using operator <<
-      Failure *messageTarget_;
-   };
+class TestCase {
+public:
+  TestCase();
 
+  virtual ~TestCase();
 
-   class TestCase
-   {
-   public:
-      TestCase();
+  void run(TestResult& result);
 
-      virtual ~TestCase();
+  virtual const char* testName() const = 0;
 
-      void run( TestResult &result );
+protected:
+  TestResult* result_;
 
-      virtual const char *testName() const = 0;
+private:
+  virtual void runTestCase() = 0;
+};
 
-   protected:
-      TestResult *result_;
+/// Function pointer type for TestCase factory
+typedef TestCase* (*TestCaseFactory)();
 
-   private:
-      virtual void runTestCase() = 0;
-   };
+class Runner {
+public:
+  Runner();
 
-   /// Function pointer type for TestCase factory
-   typedef TestCase *(*TestCaseFactory)();
+  /// Adds a test to the suite
+  Runner& add(TestCaseFactory factory);
 
-   class Runner
-   {
-   public:
-      Runner();
+  /// Runs test as specified on the command-line
+  /// If no command-line arguments are provided, run all tests.
+  /// If --list-tests is provided, then print the list of all test cases
+  /// If --test <testname> is provided, then run test testname.
+  int runCommandLine(int argc, const char* argv[]) const;
 
-      /// Adds a test to the suite
-      Runner &add( TestCaseFactory factory );
+  /// Runs all the test cases
+  bool runAllTest(bool printSummary) const;
 
-      /// Runs test as specified on the command-line
-      /// If no command-line arguments are provided, run all tests.
-      /// If --list-tests is provided, then print the list of all test cases
-      /// If --test <testname> is provided, then run test testname.
-      int runCommandLine( int argc, const char *argv[] ) const;
+  /// Returns the number of test case in the suite
+  unsigned int testCount() const;
 
-      /// Runs all the test cases
-      bool runAllTest( bool printSummary ) const;
+  /// Returns the name of the test case at the specified index
+  std::string testNameAt(unsigned int index) const;
 
-      /// Returns the number of test case in the suite
-      unsigned int testCount() const;
+  /// Runs the test case at the specified index using the specified TestResult
+  void runTestAt(unsigned int index, TestResult& result) const;
 
-      /// Returns the name of the test case at the specified index
-      std::string testNameAt( unsigned int index ) const;
+  static void printUsage(const char* appName);
 
-      /// Runs the test case at the specified index using the specified TestResult
-      void runTestAt( unsigned int index, TestResult &result ) const;
+private: // prevents copy construction and assignment
+  Runner(const Runner& other);
+  Runner& operator=(const Runner& other);
 
-      static void printUsage( const char *appName );
+private:
+  void listTests() const;
+  bool testIndex(const std::string& testName, unsigned int& index) const;
+  static void preventDialogOnCrash();
 
-   private: // prevents copy construction and assignment
-      Runner( const Runner &other );
-      Runner &operator =( const Runner &other );
+private:
+  typedef std::deque<TestCaseFactory> Factories;
+  Factories tests_;
+};
 
-   private:
-      void listTests() const;
-      bool testIndex( const std::string &testName, unsigned int &index ) const;
-      static void preventDialogOnCrash();
+template <typename T, typename U>
+TestResult& checkEqual(TestResult& result,
+                       T expected,
+                       U actual,
+                       const char* file,
+                       unsigned int line,
+                       const char* expr) {
+  if (static_cast<U>(expected) != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: " << static_cast<U>(expected) << "\n";
+    result << "Actual  : " << actual;
+  }
+  return result;
+}
 
-   private:
-      typedef std::deque<TestCaseFactory> Factories;
-      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 )
-      {
-         result.addFailure( file, line, expr );
-         result << "Expected: " << 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 ( condition )                                                           \
-   {                                                                          \
-   }                                                                          \
-   else                                                                       \
-      result_->addFailure( __FILE__, __LINE__, #expr )
+#define JSONTEST_ASSERT(expr)                                                  \
+  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.
-#define JSONTEST_ASSERT_PRED( expr )                                    \
-   {                                                                    \
-      JsonTest::PredicateContext _minitest_Context = {                  \
-         result_->predicateId_, __FILE__, __LINE__, #expr };            \
-      result_->predicateStackTail_->next_ = &_minitest_Context;         \
-      result_->predicateId_ += 1;                                       \
-      result_->predicateStackTail_ = &_minitest_Context;                \
-      (expr);                                                           \
-      result_->popPredicateContext();                                   \
-   }                                                                    \
-   *result_
+/// 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, NULL, NULL             \
+    };                                                                         \
+    result_->predicateStackTail_->next_ = &_minitest_Context;                  \
+    result_->predicateId_ += 1;                                                \
+    result_->predicateStackTail_ = &_minitest_Context;                         \
+    (expr);                                                                    \
+    result_->popPredicateContext();                                            \
+  }
 
 /// \brief Asserts that two values are equals.
-#define JSONTEST_ASSERT_EQUAL( expected, actual )          \
-   JsonTest::checkEqual( *result_, expected, actual,       \
-                         __FILE__, __LINE__,               \
-                         #expected " == " #actual )
+#define JSONTEST_ASSERT_EQUAL(expected, actual)                                \
+  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),        \
-      #expected " == " #actual )
+#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual)                         \
+  JsonTest::checkStringEqual(*result_,                                         \
+                             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          \
-   {                                                           \
-   public:                                                     \
-      static JsonTest::TestCase *factory()                     \
-      {                                                        \
-         return new Test##FixtureType##name();                 \
-      }                                                        \
-   public: /* overidden from TestCase */                       \
-      virtual const char *testName() const                     \
-      {                                                        \
-         return #FixtureType "/" #name;                        \
-      }                                                        \
-      virtual void runTestCase();                              \
-   };                                                          \
-                                                               \
-   void Test##FixtureType##name::runTestCase()
+#define JSONTEST_FIXTURE(FixtureType, name)                                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase* factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+                                                                               \
+  public: /* overidden from TestCase */                                        \
+    virtual const char* testName() const { return #FixtureType "/" #name; }    \
+    virtual void runTestCase();                                                \
+  };                                                                           \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
 
-#define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \
-   &Test##FixtureType##name::factory
+#define JSONTEST_FIXTURE_FACTORY(FixtureType, name)                            \
+  &Test##FixtureType##name::factory
 
-#define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \
-   (runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) )
+#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name)                   \
+  (runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
 
 #endif // ifndef JSONTEST_H_INCLUDED

test/cleantests.py

@@ -4,7 +4,7 @@ import os
 
 paths = []
 for pattern in [ '*.actual', '*.actual-rewrite', '*.rewrite', '*.process-output' ]:
-    paths += glob.glob( 'data/' + pattern )
+    paths += glob.glob('data/' + pattern)
 
 for path in paths:
-    os.unlink( path )
+    os.unlink(path)

test/data/fail_test_array_01.json

@@ -0,0 +1 @@
+[ 1 2 3]

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_00.expected

@@ -0,0 +1,4 @@
+// Comment for array
+.=[]
+// Comment within array
+.[0]="one-element"

test/data/test_comment_00.json

@@ -0,0 +1,5 @@
+// Comment for array
+[
+   // Comment within array
+   "one-element"
+]

test/data/test_comment_01.expected

@@ -1,8 +1,10 @@
-.={}
-.test=[]
-.test[0]={}
-.test[0].a="aaa"
-.test[1]={}
-.test[1].b="bbb"
-.test[2]={}
-.test[2].c="ccc"
+.={}
+// Comment for array
+.test=[]
+// Comment within array
+.test[0]={}
+.test[0].a="aaa"
+.test[1]={}
+.test[1].b="bbb"
+.test[2]={}
+.test[2].c="ccc"

test/data/test_comment_01.json

@@ -1,8 +1,10 @@
-{
-    "test":
-    [
-       { "a" : "aaa" }, // Comment for a
-       { "b" : "bbb" }, // Comment for b
-       { "c" : "ccc" } // Comment for c
-    ]
-}
+{
+    "test":
+    // Comment for array
+    [
+       // Comment within array
+       { "a" : "aaa" }, // Comment for a
+       { "b" : "bbb" }, // Comment for b
+       { "c" : "ccc" } // Comment for c
+    ]
+}

test/data/test_comment_02.expected

@@ -0,0 +1,23 @@
+.={}
+/* 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
+// Comment before double
+.cpp-test.d=4.1
+// Comment before string
+.cpp-test.e="e-string"
+// Comment before true
+.cpp-test.f=true
+// Comment before false
+.cpp-test.g=false
+// Comment before null
+.cpp-test.h=null

test/data/test_comment_02.json

@@ -0,0 +1,26 @@
+{
+   /* 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,
+      // Comment before double
+      "d" : 4.1,
+      // Comment before string
+      "e" : "e-string",
+      // Comment before true
+      "f" : true,
+      // Comment before false
+      "g" : false,
+      // Comment before null
+      "h" : null
+   }
+}

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_integer_06_64bits.expected

@@ -0,0 +1 @@
+.=9223372036854775808

test/data/test_integer_06_64bits.json

@@ -0,0 +1,2 @@
+9223372036854775808
+

test/data/test_integer_07_64bits.expected

@@ -0,0 +1 @@
+.=-9223372036854775808

test/data/test_integer_07_64bits.json

@@ -0,0 +1,2 @@
+-9223372036854775808
+

test/data/test_integer_08_64bits.expected

@@ -0,0 +1 @@
+.=18446744073709551615

test/data/test_integer_08_64bits.json

@@ -0,0 +1,2 @@
+18446744073709551615
+

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