Release 0.5.0

.clang-format

@@ -1,47 +0,0 @@
----
-# 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

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

.travis.yml

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

CMakeLists.txt

@@ -1,109 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)
-PROJECT(jsoncpp)
-ENABLE_TESTING()
-
-OPTION(JSONCPP_WITH_TESTS "Compile and run JsonCpp test executables" ON)
-OPTION(JSONCPP_WITH_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)
-
-jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
-IF(NOT JSONCPP_VERSION_FOUND)
-    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
-ENDIF(NOT JSONCPP_VERSION_FOUND)
-
-MESSAGE(STATUS "JsonCpp Version: ${JSONCPP_VERSION_MAJOR}.${JSONCPP_VERSION_MINOR}.${JSONCPP_VERSION_PATCH}")
-# File version.h is only regenerated on CMake configure step
-CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/src/lib_json/version.h.in"
-                "${PROJECT_SOURCE_DIR}/include/json/version.h" )
-
-macro(UseCompilationWarningAsError)
-	if ( MSVC )
-        # Only enabled in debug because some old versions of VS STL generate
-        # warnings when compiled in release configuration.
-		set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /WX ")
-	endif( MSVC )
-endmacro()
-
-# Include our configuration header
-INCLUDE_DIRECTORIES( ${jsoncpp_SOURCE_DIR}/include )
-
-if ( MSVC )
-    # Only enabled in debug because some old versions of VS STL generate
-    # unreachable code warning when compiled in release configuration.
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /W4 ")
-endif( MSVC )
-
-IF(JSONCPP_WITH_WARNING_AS_ERROR)
-    UseCompilationWarningAsError()
-ENDIF(JSONCPP_WITH_WARNING_AS_ERROR)
-
-IF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
-	CONFIGURE_FILE(
-		"pkg-config/jsoncpp.pc.in"
-		"pkg-config/jsoncpp.pc"
-		@ONLY)
-	INSTALL(FILES "${CMAKE_BINARY_DIR}/pkg-config/jsoncpp.pc"
-		DESTINATION "${CMAKE_INSTALL_PREFIX}/lib${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,55 +1 @@
-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.
+The json-cpp library and this documentation are in Public Domain.

NEWS.txt

@@ -1,175 +0,0 @@
-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.txt 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

@@ -1,224 +0,0 @@
-Introduction
-------------
-
-[JSON][json-org] is a lightweight data-interchange format. It can represent
-numbers, strings, ordered sequences of values, and collections of name/value
-pairs.
-
-[json-org]: http://json.org/
-
-JsonCpp is a C++ library that allows manipulating JSON values, including
-serialization and deserialization to and from strings. It can also preserve
-existing comment in unserialization/serialization steps, making it a convenient
-format to store user input files.
-
-## A note on backward-compatibility
-Very soon, we are switching to C++11 only. For older compilers, try the `pre-C++11` branch.
-
-Using JsonCpp in your project
------------------------------
-
-The recommended approach to integrating JsonCpp in your project is to build
-the amalgamated source (a single `.cpp` file) with your own build system. This
-ensures consistency of compilation flags and ABI compatibility. See the section
-"Generating amalgamated source and header" for instructions.
-  
-The `include/` should be added to your compiler include path. Jsoncpp headers
-should be included as follow:
-
-    #include <json/json.h>
-
-If JsonCpp was build as a dynamic library on Windows, then your project needs to
-define the macro `JSON_DLL`.
-
-
-Building and testing with new CMake
------------------------------------
-
-[CMake][] is a C++ Makefiles/Solution generator. It is usually available on most
-Linux system as package. On Ubuntu:
-
-    sudo apt-get install cmake
-
-[CMake]: http://www.cmake.org
-
-Note that Python is also required to run the JSON reader/writer tests. If
-missing, the build will skip running those tests.
-
-When running CMake, a few parameters are required:
-
-* a build directory where the makefiles/solution are generated. It is also used
-  to store objects, libraries and executables files.
-* the generator to use: makefiles or Visual Studio solution? What version or
-  Visual Studio, 32 or 64 bits solution? 
-
-Steps for generating solution/makefiles using `cmake-gui`:
-
-* Make "source code" point to the source directory.
-* Make "where to build the binary" point to the directory to use for the build.
-* Click on the "Grouped" check box.
-* Review JsonCpp build options (tick `JSONCPP_LIB_BUILD_SHARED` to build as a
-  dynamic library).
-* Click the configure button at the bottom, then the generate button.
-* The generated solution/makefiles can be found in the binary directory.
-
-Alternatively, from the command-line on Unix in the source directory:
-
-    mkdir -p build/debug
-    cd build/debug
-    cmake -DCMAKE_BUILD_TYPE=debug -DJSONCPP_LIB_BUILD_SHARED=OFF -G "Unix Makefiles" ../..
-    make
-
-Running `cmake -`" will display the list of available generators (passed using
-the `-G` option).
-
-By default CMake hides compilation commands. This can be modified by specifying
-`-DCMAKE_VERBOSE_MAKEFILE=true` when generating makefiles.
-
-
-Building and testing with SCons
--------------------------------
-
-**Note:** The SCons-based build system is deprecated. Please use CMake; see the
-section above.
-
-JsonCpp can use [Scons][] as a build system. Note that SCons requires Python to
-be installed.
-
-[SCons]: http://www.scons.org/
-
-Invoke SCons as follows:
-
-    scons platform=$PLATFORM [TARGET]
-
-where `$PLATFORM` may be one of:
-
-* `suncc`: Sun C++ (Solaris)
-* `vacpp`: Visual Age C++ (AIX)
-* `mingw`
-* `msvc6`: Microsoft Visual Studio 6 service pack 5-6
-* `msvc70`: Microsoft Visual Studio 2002
-* `msvc71`: Microsoft Visual Studio 2003
-* `msvc80`: Microsoft Visual Studio 2005
-* `msvc90`: Microsoft Visual Studio 2008
-* `linux-gcc`: Gnu C++ (linux, also reported to work for Mac OS X)
-
-If you are building with Microsoft Visual Studio 2008, you need to set up the
-environment by running `vcvars32.bat` (e.g. MSVC 2008 command prompt) before
-running SCons.
-
-
-Running the tests manually
---------------------------
-
-Note that test can be run using SCons using the `check` target:
-
-    scons platform=$PLATFORM check
-
-You need to run tests manually only if you are troubleshooting an issue.
-
-In the instructions below, replace `path/to/jsontest` with the path of the
-`jsontest` executable that was compiled on your platform.
-
-    cd test
-    # This will run the Reader/Writer tests
-    python runjsontests.py path/to/jsontest
-    
-    # This will run the Reader/Writer tests, using JSONChecker test suite
-    # (http://www.json.org/JSON_checker/).
-    # Notes: not all tests pass: JsonCpp is too lenient (for example,
-    # it allows an integer to start with '0'). The goal is to improve
-    # strict mode parsing to get all tests to pass.
-    python runjsontests.py --with-json-checker path/to/jsontest
-    
-    # This will run the unit tests (mostly Value)
-    python rununittests.py path/to/test_lib_json
-    
-    # You can run the tests using valgrind:
-    python rununittests.py --valgrind path/to/test_lib_json
-
-
-Building the documentation
---------------------------
-
-Run the Python script `doxybuild.py` from the top directory:
-
-    python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
-
-See `doxybuild.py --help` for options.
-
-
-Generating amalgamated source and header
-----------------------------------------
-
-JsonCpp is provided with a script to generate a single header and a single
-source file to ease inclusion into an existing project. The amalgamated source
-can be generated at any time by running the following command from the
-top-directory (this requires Python 2.6):
-
-    python amalgamate.py
-
-It is possible to specify header name. See the `-h` option for detail.
-
-By default, the following files are generated:
-* `dist/jsoncpp.cpp`: source file that needs to be added to your project.
-* `dist/json/json.h`: corresponding header file for use in your project. It is
-  equivalent to including `json/json.h` in non-amalgamated source. This header
-  only depends on standard headers.
-* `dist/json/json-forwards.h`: header that provides forward declaration of all
-  JsonCpp types.
-
-The amalgamated sources are generated by concatenating JsonCpp source in the
-correct order and defining the macro `JSON_IS_AMALGAMATION` to prevent inclusion
-of other headers.
-
-
-Adding a reader/writer test
----------------------------
-
-To add a test, you need to create two files in test/data:
-
-* a `TESTNAME.json` file, that contains the input document in JSON format.
-* a `TESTNAME.expected` file, that contains a flatened representation of the
-  input document.
-
-The `TESTNAME.expected` file format is as follows:
-
-* each line represents a JSON element of the element tree represented by the
-  input document.
-* each line has two parts: the path to access the element separated from the
-  element value by `=`. Array and object values are always empty (i.e.
-  represented by either `[]` or `{}`).
-* element path: `.` represents the root element, and is used to separate object
-  members. `[N]` is used to specify the value of an array element at index `N`.
-
-See the examples `test_complex_01.json` and `test_complex_01.expected` to better
-understand element paths.
-
-
-Understanding reader/writer test output
----------------------------------------
-
-When a test is run, output files are generated beside the input test files.
-Below is a short description of the content of each file:
-
-* `test_complex_01.json`: input JSON document.
-* `test_complex_01.expected`: flattened JSON element tree used to check if
-  parsing was corrected.
-* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest`
-  from reading `test_complex_01.json`.
-* `test_complex_01.rewrite`: JSON document written by `jsontest` using the
-  `Json::Value` parsed from `test_complex_01.json` and serialized using
-  `Json::StyledWritter`.
-* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by
-  `jsontest` from reading `test_complex_01.rewrite`.
-* `test_complex_01.process-output`: `jsontest` output, typically useful for
-  understanding parsing errors.
-
-
-License
--------
-
-See the `LICENSE` file for details. In summary, JsonCpp is licensed under the
-MIT license, or public domain if desired and recognized in your jurisdiction.
-

README.txt

@@ -0,0 +1,117 @@
+* 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 msvc90 linux-gcc'.split(),
+                        allowed_values='suncc vacpp mingw msvc6 msvc7 msvc71 msvc80 linux-gcc'.split(),
                         ignorecase=2) )
 
 try:
@@ -57,9 +57,8 @@ 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', 'LD_LIBRARY_PATH', 'LIBRARY_PATH'):
+	for name in ('PATH', 'TEMP', 'TMP'):
 		if name in os.environ:
 			vars[name] = os.environ[name]
 	return vars
@@ -102,24 +101,12 @@ 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 = os.environ.get("CXXFLAGS", "-Wall"), LINKFLAGS=os.environ.get("LDFLAGS", "") )
+    env.Append( LIBS = ['pthread'], CCFLAGS = "-Wall" )
     env['SHARED_LIB_ENABLED'] = True
 else:
     print "UNSUPPORTED PLATFORM."

amalgamate.py

@@ -1,150 +0,0 @@
-"""Amalgate json-cpp library sources into a single source and header file.
-
-Requires Python 2.6
-
-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 intented to be used with #include <%s>" % header_include_path )
-    header.add_file( "LICENSE", wrap_in_comment=True )
-    header.add_text( "#ifndef JSON_AMALGATED_H_INCLUDED" )
-    header.add_text( "# define JSON_AMALGATED_H_INCLUDED" )
-    header.add_text( "/// If defined, indicates that the source file is amalgated" )
-    header.add_text( "/// to prevent private header inclusion." )
-    header.add_text( "#define JSON_IS_AMALGAMATION" )
-    header.add_file( "include/json/version.h" )
-    header.add_file( "include/json/config.h" )
-    header.add_file( "include/json/forwards.h" )
-    header.add_file( "include/json/features.h" )
-    header.add_file( "include/json/value.h" )
-    header.add_file( "include/json/reader.h" )
-    header.add_file( "include/json/writer.h" )
-    header.add_file( "include/json/assertions.h" )
-    header.add_text( "#endif //ifndef JSON_AMALGATED_H_INCLUDED" )
-
-    target_header_path = os.path.join( os.path.dirname(target_source_path), header_include_path )
-    print("Writing amalgated header to %r" % target_header_path)
-    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 intented to be used with #include <%s>" % forward_header_include_path )
-    header.add_text( "/// This header provides forward declaration for all JsonCpp types." )
-    header.add_file( "LICENSE", wrap_in_comment=True )
-    header.add_text( "#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED" )
-    header.add_text( "# define JSON_FORWARD_AMALGATED_H_INCLUDED" )
-    header.add_text( "/// If defined, indicates that the source file is amalgated" )
-    header.add_text( "/// to prevent private header inclusion." )
-    header.add_text( "#define JSON_IS_AMALGAMATION" )
-    header.add_file( "include/json/config.h" )
-    header.add_file( "include/json/forwards.h" )
-    header.add_text( "#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED" )
-
-    target_forward_header_path = os.path.join( os.path.dirname(target_source_path),
-                                               forward_header_include_path )
-    print("Writing amalgated forward header to %r" % target_forward_header_path)
-    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 intented to be used with #include <%s>" % header_include_path )
-    source.add_file( "LICENSE", wrap_in_comment=True )
-    source.add_text( "" )
-    source.add_text( "#include <%s>" % header_include_path )
-    source.add_text( "" )
-    lib_json = "src/lib_json"
-    source.add_file( os.path.join(lib_json, "json_tool.h") )
-    source.add_file( os.path.join(lib_json, "json_reader.cpp") )
-    source.add_file( os.path.join(lib_json, "json_batchallocator.h") )
-    source.add_file( os.path.join(lib_json, "json_valueiterator.inl") )
-    source.add_file( os.path.join(lib_json, "json_value.cpp") )
-    source.add_file( os.path.join(lib_json, "json_writer.cpp") )
-
-    print("Writing amalgated source to %r" % target_source_path)
-    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

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

devtools/agent_vmw7.json

@@ -1,33 +0,0 @@
-{
-    "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

@@ -1,26 +0,0 @@
-{
-    "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,7 +2,6 @@
 # encoding: utf-8
 # Baptiste Lepilleur, 2009
 
-from __future__ import print_function
 from dircache import listdir
 import re
 import fnmatch
@@ -56,20 +55,20 @@ ALL = DIR | FILE | LINKS
 
 _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" )
         if match.group(1): # /**/
@@ -84,14 +83,14 @@ def ant_pattern_to_re( ant_pattern ):
             rex.append( sep_rex )
         else: # somepath
             rex.append( re.escape(match.group(6)) )
-        next_pos = match.end()
+        next_pos = match.end()
     rex.append('$')
     return re.compile( ''.join( rex ) )
-
-def _as_list( l ):
-    if isinstance(l, basestring):
-        return l.split()
-    return l
+
+def _as_list( l ):
+    if isinstance(l, basestring):
+        return l.split()
+    return l
 
 def glob(dir_path,
          includes = '**/*',
@@ -100,8 +99,8 @@ 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
 
@@ -118,37 +117,37 @@ def glob(dir_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'
+            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 ) )
 
 
@@ -156,47 +155,47 @@ 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.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 )
+##        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 )
 
     unittest.main()

devtools/batchbuild.py

@@ -1,281 +0,0 @@
-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,64 +1,63 @@
-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()
+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()

devtools/licenseupdater.py

@@ -1,94 +0,0 @@
-"""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,53 @@
-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()
+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()

doc/footer.html

@@ -1,3 +1,23 @@
 <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="https://github.com/open-source-parsers/jsoncpp">
+      <a href="http://sourceforge.net/projects/jsoncpp">
       JsonCpp project page
       </a>
     </td>
     <td width="40%" align="right" valign="center">
-      <a href="https://github.com/open-source-parsers/jsoncpp">JsonCpp home page</a>
+      <a href="http://jsoncpp.sourceforge.net">JsonCpp home page</a>
     </td>
   </tr>
 </table>

doc/jsoncpp.dox

@@ -22,14 +22,13 @@ Here is an example of JSON data:
         ],
         
     // Tab indent size
-    "indent" : { "length" : 3, "use_space": true }
+    "indent" : { "length" : 3, "use_space" = true }
 }
 \endverbatim
-<code>jsoncpp</code> supports comments as <i>meta-data</i>.
 
 \section _features Features
 - read and write JSON document
-- attach C++ style comments to element during parsing
+- attach C and 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 
@@ -47,7 +46,7 @@ if ( !parsingSuccessful )
 {
     // report to the user the failure and their locations in the document.
     std::cout  << "Failed to parse configuration\n"
-               << reader.getFormattedErrorMessages();
+               << reader.getFormatedErrorMessages();
     return;
 }
 
@@ -83,37 +82,35 @@ std::cin >> root["subtree"];
 std::cout << root;
 \endcode
 
-\section _pbuild Build instructions
+\section _plinks Build instructions
 The build instructions are located in the file 
-<a HREF="https://github.com/open-source-parsers/jsoncpp/blob/master/README.md">README.md</a> in the top-directory of the project.
+<a HREF="README.txt">README.txt</a> in the top-directory of the project.
 
-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>
+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>
 
-\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 _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 _rlinks Related links
 - <a HREF="http://www.json.org/">JSON</a> Specification and alternate language implementations.
 - <a HREF="http://www.yaml.org/">YAML</a> A data format designed for human readability.
 - <a HREF="http://www.cl.cam.ac.uk/~mgk25/unicode.html">UTF-8 and Unicode FAQ</a>.
 
-\section _plinks Old project links
-- <a href="https://sourceforge.net/projects/jsoncpp/">https://sourceforge.net/projects/jsoncpp/</a>
-- <a href="http://jsoncpp.sourceforge.net">http://jsoncpp.sourceforge.net</a>
-- <a href="http://sourceforge.net/projects/jsoncpp/files/">http://sourceforge.net/projects/jsoncpp/files/</a>
-- <a href="http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/">http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/</a>
-- <a href="http://jsoncpp.sourceforge.net/old.html">http://jsoncpp.sourceforge.net/old.html</a>
-
 \section _license License
-See file <a href="https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE"><code>LICENSE</code></a> in the top-directory of the project.
+The json-cpp library and this documentation are in Public Domain.
 
-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 Baptiste Lepilleur <blep@users.sourceforge.net>
 */

doc/roadmap.dox

@@ -1,3 +1,32 @@
 /*! \page roadmap JsonCpp roadmap
-  Moved to: https://github.com/open-source-parsers/jsoncpp/wiki/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
 */

doxybuild.py

@@ -1,12 +1,12 @@
 """Script to generate doxygen documentation.
 """
-from __future__ import print_function
-from devtools import tarball
+
 import re
 import os
 import os.path
 import sys
 import shutil
+from devtools import tarball
 
 def find_program(*filenames):
     """find a program in folders path_lst, and sets env[var]
@@ -33,9 +33,9 @@ def do_subst_in_file(targetfile, sourcefile, dict):
         contents = f.read()
         f.close()
     except:
-        print("Can't read source file %s"%sourcefile)
+        print "Can't read source file %s"%sourcefile
         raise
-    for (k,v) in list(dict.items()):
+    for (k,v) in dict.items():
         v = v.replace('\\','\\\\') 
         contents = re.sub(k, v, contents)
     try:
@@ -43,7 +43,7 @@ def do_subst_in_file(targetfile, sourcefile, dict):
         f.write(contents)
         f.close()
     except:
-        print("Can't write target file %s"%targetfile)
+        print "Can't write target file %s"%targetfile
         raise
 
 def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
@@ -53,12 +53,12 @@ def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
     try:
         os.chdir( working_dir )
         cmd = [doxygen_path, config_file]
-        print('Running:', ' '.join( cmd ))
+        print 'Running:', ' '.join( cmd )
         try:
             import subprocess
         except:
             if os.system( ' '.join( cmd ) ) != 0:
-                print('Documentation generation failed')
+                print 'Documentation generation failed'
                 return False
         else:
             if is_silent:
@@ -67,8 +67,8 @@ def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
                 process = subprocess.Popen( cmd )
             stdout, _ = process.communicate()
             if process.returncode:
-                print('Documentation generation failed:')
-                print(stdout)
+                print 'Documentation generation failed:'
+                print stdout
                 return False
         return True
     finally:
@@ -107,7 +107,7 @@ def build_doc( options,  make_release=False ):
         }
 
     if os.path.isdir( output_dir ):
-        print('Deleting directory:', output_dir)
+        print 'Deleting directory:', output_dir
         shutil.rmtree( output_dir )
     if not os.path.isdir( output_dir ):
         os.makedirs( output_dir )
@@ -115,20 +115,18 @@ def build_doc( options,  make_release=False ):
     do_subst_in_file( 'doc/doxyfile', 'doc/doxyfile.in', subst_keys )
     ok = run_doxygen( options.doxygen_path, 'doc/doxyfile', 'doc', is_silent=options.silent )
     if not options.silent:
-        print(open(warning_log_path, 'rb').read())
-    index_path = os.path.abspath(os.path.join('doc', subst_keys['%HTML_OUTPUT%'], 'index.html'))
-    print('Generated documentation can be found in:')
-    print(index_path)
+        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
     if options.open:
         import webbrowser
         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',
-            'LICENSE',
-            'NEWS.txt',
             'version'
             ]
         tarball_basedir = os.path.join( output_dir, html_output_dirname )

include/CMakeLists.txt

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

include/json/assertions.h

@@ -1,41 +0,0 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
-#define CPPTL_JSON_ASSERTIONS_H_INCLUDED
-
-#include <stdlib.h>
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-#if JSON_USE_EXCEPTION
-#include <stdexcept>
-#define JSON_ASSERT(condition)                                                 \
-  assert(condition); // @todo <= change this into an exception throw
-#define JSON_FAIL_MESSAGE(message) throw std::runtime_error(message);
-#else // JSON_USE_EXCEPTION
-#define JSON_ASSERT(condition) assert(condition);
-
-// The call to assert() will show the failure message in debug builds. In
-// release bugs we write to invalid memory in order to crash hard, so that a
-// debugger or crash reporter gets the chance to take over. We still call exit()
-// afterward in order to tell the compiler that this macro doesn't return.
-#define JSON_FAIL_MESSAGE(message)                                             \
-  {                                                                            \
-    assert(false&& message);                                                   \
-    strcpy(reinterpret_cast<char*>(666), message);                             \
-    exit(123);                                                                 \
-  }
-
-#endif
-
-#define JSON_ASSERT_MESSAGE(condition, message)                                \
-  if (!(condition)) {                                                          \
-    JSON_FAIL_MESSAGE(message)                                                 \
-  }
-
-#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED

include/json/autolink.h

@@ -1,25 +1,19 @@
-// 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,112 +1,43 @@
-// 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! There is know bugs: See #3177332
+/// 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
+/// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
+/// The memory pools allocator used optimization (initializing Value and ValueInternalLink
 /// as if it was a POD) that may cause some validation tool to report errors.
 /// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
 //#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
 
-// If non-zero, the library uses exceptions to report bad input instead of C
-// assertion macros. The default is to use exceptions.
-#ifndef JSON_USE_EXCEPTION
-#define JSON_USE_EXCEPTION 1
-#endif
+/// If defined, indicates that Json use exception to report invalid type manipulation
+/// instead of C assert macro.
+# define JSON_USE_EXCEPTION 1
 
-/// If defined, indicates that the source file is amalgated
-/// to prevent private header inclusion.
-/// Remarks: it is automatically defined in the generated amalgated header.
-// #define JSON_IS_AMALGAMATION
+# ifdef JSON_IN_CPPTL
+#  include <cpptl/config.h>
+#  ifndef JSON_USE_CPPTL
+#   define JSON_USE_CPPTL 1
+#  endif
+# 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))
-#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
+# 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
 
 #endif // JSON_CONFIG_H_INCLUDED

include/json/features.h

@@ -1,57 +1,42 @@
-// 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_;
-
-  /// \c true if dropped null placeholders are allowed. Default: \c false.
-  bool allowDroppedNullPlaceholders_;
-
-  /// \c true if numeric object key are allowed. Default: \c false.
-  bool allowNumericKeys_;
-};
-
-} // namespace Json
-
-#endif // CPPTL_JSON_FEATURES_H_INCLUDED
+#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

include/json/forwards.h

@@ -1,43 +1,39 @@
-// 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_FORWARDS_H_INCLUDED
-#define JSON_FORWARDS_H_INCLUDED
+# define JSON_FORWARDS_H_INCLUDED
 
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
+# include "config.h"
 
 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 unsigned int ArrayIndex;
-class StaticString;
-class Path;
-class PathArgument;
-class Value;
-class ValueIteratorBase;
-class ValueIterator;
-class ValueConstIterator;
+   // 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 ValueMapAllocator;
-class ValueInternalLink;
-class ValueInternalArray;
-class ValueInternalMap;
+   class ValueAllocator;
+   class ValueMapAllocator;
+   class ValueInternalLink;
+   class ValueInternalArray;
+   class ValueInternalMap;
 #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
 
 } // namespace Json
 
+
 #endif // JSON_FORWARDS_H_INCLUDED

include/json/json.h

@@ -1,15 +1,10 @@
-// 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_JSON_H_INCLUDED
-#define JSON_JSON_H_INCLUDED
+# define JSON_JSON_H_INCLUDED
 
-#include "autolink.h"
-#include "value.h"
-#include "reader.h"
-#include "writer.h"
-#include "features.h"
+# 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,275 +1,196 @@
-// 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_READER_H_INCLUDED
-#define 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>
-
-// 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)
+# include "features.h"
+# include "value.h"
+# include <deque>
+# include <stack>
+# include <string>
+# include <iostream>
 
 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.
+    *
+    */
+   class JSON_API Reader
+   {
+   public:
+      typedef char Char;
+      typedef const Char *Location;
 
-  /** \brief An error tagged with where in the JSON text it was encountered.
-   *
-   * The offsets give the [start, limit) range of bytes within the text. Note
-   * that this is bytes, not codepoints.
-   *
+      /** \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<<()
    */
-  struct StructuredError {
-    size_t offset_start;
-    size_t offset_limit;
-    std::string message;
-  };
-
-  /** \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 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;
-
-  /** \brief Returns a vector of structured erros encounted while parsing.
-   * \return A (possibly empty) vector of StructuredError objects. Currently
-   *         only one error can be returned, but the caller should tolerate
-   * multiple
-   *         errors.  This can occur if the parser recovers from a non-fatal
-   *         parse error and then encounters additional errors.
-   */
-  std::vector<StructuredError> getStructuredErrors() const;
-
-  /** \brief Add a semantic error message.
-   * \param value JSON Value location associated with the error
-   * \param message The error message.
-   * \return \c true if the error was successfully added, \c false if the
-   * Value offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const std::string& message);
-
-  /** \brief Add a semantic error message with extra context.
-   * \param value JSON Value location associated with the error
-   * \param message The error message.
-   * \param extra Additional JSON Value location to contextualize the error
-   * \return \c true if the error was successfully added, \c false if either
-   * Value offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const std::string& message, const Value& extra);
-
-  /** \brief Return whether there are any errors.
-   * \return \c true if there are no errors to report \c false if
-   * errors have occurred.
-   */
-  bool good() const;
-
-private:
-  enum TokenType {
-    tokenEndOfStream = 0,
-    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_;
-};
-
-/** \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&);
+   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

@@ -1,14 +0,0 @@
-// DO NOT EDIT. This file is generated by CMake from  "version"
-// and "version.h.in" files.
-// Run CMake configure step to update it.
-#ifndef JSON_VERSION_H_INCLUDED
-# define JSON_VERSION_H_INCLUDED
-
-# define JSONCPP_VERSION_STRING "1.2.0"
-# define JSONCPP_VERSION_MAJOR 1
-# define JSONCPP_VERSION_MINOR 2
-# 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,213 +1,174 @@
-// 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_WRITER_H_INCLUDED
-#define 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>
-
-// 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)
+# include "value.h"
+# include <vector>
+# include <string>
+# include <iostream>
 
 namespace Json {
 
-class Value;
+   class Value;
 
-/** \brief Abstract class for writers.
- */
-class JSON_API Writer {
-public:
-  virtual ~Writer();
+   /** \brief Abstract class for writers.
+    */
+   class JSON_API Writer
+   {
+   public:
+      virtual ~Writer();
 
-  virtual std::string write(const Value& root) = 0;
-};
+      virtual std::string write( const Value &root ) = 0;
+   };
 
-/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
- *without formatting (not human friendly).
- *
- * 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() {}
+   /** \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(){}
 
-  void enableYAMLCompatibility();
+      void enableYAMLCompatibility();
 
-  /** \brief Drop the "null" string from the writer's output for nullValues.
-   * Strictly speaking, this is not valid JSON. But when the output is being
-   * fed to a browser's Javascript, it makes for smaller output and the
-   * browser can handle the output just fine.
-   */
-  void dropNullPlaceholders();
+   public: // overridden from Writer
+      virtual std::string write( const Value &root );
 
-  void omitEndingLineFeed();
+   private:
+      void writeValue( const Value &value );
 
-public: // overridden from Writer
-  virtual std::string write(const Value& root);
+      std::string document_;
+      bool yamlCompatiblityEnabled_;
+   };
 
-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.
+    *
+    * 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(){}
 
-  std::string document_;
-  bool yamlCompatiblityEnabled_;
-  bool dropNullPlaceholders_;
-  bool omitEndingLineFeed_;
-};
+   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 );
 
-/** \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() {}
+   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::string document_;
+      std::string indentString_;
+      int rightMargin_;
+      int indentSize_;
+      bool addChildValues_;
+   };
 
-  typedef std::vector<std::string> ChildValues;
+   /** \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(){}
 
-  ChildValues childValues_;
-  std::string document_;
-  std::string indentString_;
-  int rightMargin_;
-  int indentSize_;
-  bool addChildValues_;
-};
+   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,
-     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() {}
+   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:
-  /** \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);
+      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::ostream* document_;
-  std::string indentString_;
-  int rightMargin_;
-  std::string indentation_;
-  bool addChildValues_;
-};
-
-#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);
+   /// \brief Output using the StyledStreamWriter.
+   /// \see Json::operator>>()
+   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

@@ -1,42 +0,0 @@
-
-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

@@ -1,96 +0,0 @@
-<?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

@@ -1,13 +0,0 @@
-<?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

@@ -1,143 +0,0 @@
-<?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

@@ -1,33 +0,0 @@
-<?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

@@ -1,109 +0,0 @@
-<?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

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

makerelease.py

@@ -3,18 +3,11 @@
 Requires Python 2.6
 
 Example of invocation (use to test the script):
-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
+python makerelease.py --force --retag --platform=msvc6,msvc71,msvc80,mingw -ublep 0.5.0 0.6.0-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
@@ -27,7 +20,6 @@ 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'
@@ -47,7 +39,7 @@ class SVNError(Exception):
 
 def svn_command( command, *args ):
     cmd = ['svn', '--non-interactive', command] + list(args)
-    print('Running:', ' '.join( cmd ))
+    print 'Running:', ' '.join( cmd )
     process = subprocess.Popen( cmd,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT )
@@ -85,7 +77,7 @@ def svn_check_if_tag_exist( tag_url ):
     """
     try:
         list_stdout = svn_command( 'list', tag_url )
-    except SVNError as e:
+    except SVNError, e:
         if e.returncode != 1 or not str(e).find('tag_url'):
             raise e
         # otherwise ignore error, meaning tag does not exist
@@ -118,7 +110,7 @@ def svn_export( tag_url, export_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, 
         includes = '**/*.sln **/*.vcproj',
@@ -149,7 +141,7 @@ def download( url, target_path ):
 
 def check_compile( distcheck_top_dir, platform ):
     cmd = [sys.executable, 'scons.py', 'platform=%s' % platform, 'check']
-    print('Running:', ' '.join( cmd ))
+    print 'Running:', ' '.join( cmd )
     log_path = os.path.join( distcheck_top_dir, 'build-%s.log' % platform )
     flog = open( log_path, 'wb' )
     try:
@@ -180,9 +172,9 @@ def run_sftp_batch( userhost, sftp, batch, retry=0 ):
     # 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 range(0, max(1,retry)):
+    for retry_index in xrange(0, max(1,retry)):
         heading = retry_index == 0 and 'Running:' or 'Retrying:'
-        print(heading, ' '.join( cmd ))
+        print heading, ' '.join( cmd )
         process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT )
         stdout = process.communicate()[0]
         if process.returncode != 0:
@@ -220,21 +212,21 @@ exit
     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 ))
+        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))
+    print 'Uploading %d files:' % len(upload_paths)
     batch_size = 10
     upload_paths = list(upload_paths)
     start_time = time.time()
-    for index in range(0,len(upload_paths),batch_size):
+    for index in xrange(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))
+        print '%d/%d, ETA=%.1fs' % (index+1, len(upload_paths), remaining_sec)
         run_sftp_batch( userhost, sftp, """cd htdocs
 lcd %s
 mput %s
@@ -298,7 +290,7 @@ Warning: --force should only be used when developping/testing the release script
     else:
         msg = check_no_pending_commit()
     if not msg:
-        print('Setting version to', release_version)
+        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 )
@@ -306,11 +298,11 @@ Warning: --force should only be used when developping/testing the release script
             if options.retag_release:
                 svn_remove_tag( tag_url, 'Overwriting previous tag' )
             else:
-                print('Aborting, tag %s already exist. Use --retag to overwrite it!' % tag_url)
+                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 )
@@ -324,55 +316,47 @@ Warning: --force should only be used when developping/testing the release script
         
         source_dir = 'jsoncpp-src-' + release_version
         source_tarball_path = 'dist/%s.tar.gz' % source_dir
-        print('Generating source tarball to', source_tarball_path)
+        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)
+        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)
+        print 'Downloading scons-local to', scons_local_path
         download( SCONS_LOCAL_URL, scons_local_path )
-        print('Decompressing scons-local to', distcheck_top_dir)
+        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)
+            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 '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...')
+            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)
+                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)
+                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')
+            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 )

pkg-config/jsoncpp.pc.in

@@ -1,11 +0,0 @@
-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/substinfile.py

@@ -1,6 +1,5 @@
 import re
 from SCons.Script import *  # the usual scons stuff you get in a SConscript
-import collections
 
 def generate(env):
     """
@@ -26,28 +25,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 list(dict.items()):
+            raise SCons.Errors.UserError, "Can't read source file %s"%sourcefile
+        for (k,v) in 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 'SUBST_DICT' not in env:
-            raise SCons.Errors.UserError("SubstInFile requires SUBST_DICT to be set.")
+        if not env.has_key('SUBST_DICT'):
+            raise SCons.Errors.UserError, "SubstInFile requires SUBST_DICT to be set."
         d = dict(env['SUBST_DICT']) # copy it
-        for (k,v) in list(d.items()):
-            if isinstance(v, collections.Callable):
+        for (k,v) in d.items():
+            if callable(v):
                 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)
 
@@ -61,8 +60,8 @@ def generate(env):
         Returns original target, source tuple unchanged.
         """
         d = env['SUBST_DICT'].copy() # copy it
-        for (k,v) in list(d.items()):
-            if isinstance(v, collections.Callable):
+        for (k,v) in d.items():
+            if callable(v):
                 d[k] = env.subst(v())
             elif SCons.Util.is_String(v):
                 d[k]=env.subst(v)

src/CMakeLists.txt

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

src/jsontestrunner/CMakeLists.txt

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

src/jsontestrunner/main.cpp

@@ -1,277 +1,233 @@
-// 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 <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 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 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 = ".") {
-  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) {
-  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;
-    }
-    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());
-    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;
-}
-
-int parseCommandLine(int argc,
-                     const char* argv[],
-                     Json::Features& features,
-                     std::string& path,
-                     bool& parseOnly) {
-  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 (std::string(argv[1]) == "--json-config") {
-    printConfig();
-    return 3;
-  }
-
-  if (index == argc || index + 1 < argc) {
-    return printUsage(argv);
-  }
-
-  path = argv[index];
-  return 0;
-}
-
-int main(int argc, const char* argv[]) {
-  std::string path;
-  Json::Features features;
-  bool parseOnly;
-  int exitCode = parseCommandLine(argc, argv, features, path, parseOnly);
-  if (exitCode != 0) {
-    return exitCode;
-  }
-
-  try {
-    std::string input = readInputTestFile(path.c_str());
-    if (input.empty()) {
-      printf("Failed to read input or empty input: %s\n", path.c_str());
-      return 3;
-    }
-
-    std::string basePath = removeSuffix(argv[1], ".json");
-    if (!parseOnly && basePath.empty()) {
-      printf("Bad input path. Path does not end with '.expected':\n%s\n",
-             path.c_str());
-      return 3;
-    }
-
-    std::string actualPath = basePath + ".actual";
-    std::string rewritePath = basePath + ".rewrite";
-    std::string rewriteActualPath = basePath + ".actual-rewrite";
-
-    Json::Value root;
-    exitCode = parseAndSaveValueTree(
-        input, actualPath, "input", root, features, parseOnly);
-    if (exitCode == 0 && !parseOnly) {
-      std::string rewrite;
-      exitCode = rewriteValueTree(rewritePath, root, rewrite);
-      if (exitCode == 0) {
-        Json::Value rewriteRoot;
-        exitCode = parseAndSaveValueTree(rewrite,
-                                         rewriteActualPath,
-                                         "rewrite",
-                                         rewriteRoot,
-                                         features,
-                                         parseOnly);
+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 );
+         }
       }
-    }
-  }
-  catch (const std::exception& e) {
-    printf("Unhandled exception:\n%s\n", e.what());
-    exitCode = 1;
-  }
-
-  return exitCode;
+      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;
+   }
 }
+
+
+static int
+parseAndSaveValueTree( const std::string &input, 
+                       const std::string &actual,
+                       const std::string &kind,
+                       Json::Value &root,
+                       const Json::Features &features,
+                       bool parseOnly )
+{
+   Json::Reader reader( features );
+   bool parsingSuccessful = reader.parse( input, root );
+   if ( !parsingSuccessful )
+   {
+      printf( "Failed to parse %s file: \n%s\n", 
+              kind.c_str(),
+              reader.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() );
+      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 int 
+printUsage( const char *argv[] )
+{
+   printf( "Usage: %s [--strict] input-json-file", argv[0] );
+   return 3;
+}
+
+
+int
+parseCommandLine( int argc, const char *argv[], 
+                  Json::Features &features, std::string &path,
+                  bool &parseOnly )
+{
+   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;
+}
+
+
+int main( int argc, const char *argv[] )
+{
+   std::string path;
+   Json::Features features;
+   bool parseOnly;
+   int exitCode = parseCommandLine( argc, argv, features, path, parseOnly );
+   if ( exitCode != 0 )
+   {
+      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;
+}
+

src/lib_json/CMakeLists.txt

@@ -1,70 +0,0 @@
-OPTION(JSONCPP_LIB_BUILD_SHARED "Build jsoncpp_lib as a shared library." OFF)
-IF(BUILD_SHARED_LIBS)
-  SET(JSONCPP_LIB_BUILD_SHARED ON)
-ENDIF(BUILD_SHARED_LIBS)
-
-IF(JSONCPP_LIB_BUILD_SHARED)
-  SET(JSONCPP_LIB_TYPE SHARED)
-  ADD_DEFINITIONS( -DJSON_DLL_BUILD )
-ELSE(JSONCPP_LIB_BUILD_SHARED)
-  SET(JSONCPP_LIB_TYPE STATIC)
-ENDIF(JSONCPP_LIB_BUILD_SHARED)
-
-if( CMAKE_COMPILER_IS_GNUCXX )
-  #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} )
-
-ADD_LIBRARY( jsoncpp_lib ${JSONCPP_LIB_TYPE}
-             ${PUBLIC_HEADERS} 
-             json_tool.h
-             json_reader.cpp
-             json_batchallocator.h
-             json_valueiterator.inl
-             json_value.cpp
-             json_writer.cpp
-             version.h.in
-             )
-SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES OUTPUT_NAME jsoncpp )
-SET_TARGET_PROPERTIES( jsoncpp_lib PROPERTIES VERSION ${JSONCPP_VERSION} SOVERSION ${JSONCPP_VERSION_MAJOR} )
-
-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)
-
-# 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)
-
-INSTALL( TARGETS jsoncpp_lib ${INSTALL_EXPORT}
-         RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
-         LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
-         ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR}
-)

src/lib_json/json_batchallocator.h

@@ -1,15 +1,10 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
 #ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
-#define JSONCPP_BATCHALLOCATOR_H_INCLUDED
+# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
 
-#include <stdlib.h>
-#include <assert.h>
+# include <stdlib.h>
+# include <assert.h>
 
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
 
 namespace Json {
 
@@ -18,104 +13,113 @@ namespace Json {
  * This memory allocator allocates memory for a batch of object (specified by
  * the page size, the number of object in each page).
  *
- * It does not allow the destruction of a single object. All the allocated
- * objects can be destroyed at once. The memory can be either released or reused
- * for future allocation.
- *
- * The in-place new operator must be used to construct the object using the
- * pointer returned by allocate.
+ * 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 {
+template<typename AllocatedType
+        ,const unsigned int objectPerAllocation>
+class BatchAllocator
+{
 public:
-  BatchAllocator(unsigned int objectsPerPage = 255)
-      : freeHead_(0), objectsPerPage_(objectsPerPage) {
-    //      printf( "Size: %d => %s\n", sizeof(AllocatedType),
-    // typeid(AllocatedType).name() );
-    assert(sizeof(AllocatedType) * objectPerAllocation >=
-           sizeof(AllocatedType*)); // We must be able to store a slist in the
-                                    // object free space.
-    assert(objectsPerPage >= 16);
-    batches_ = allocateBatch(0); // allocated a dummy page
-    currentBatch_ = batches_;
-  }
+   typedef AllocatedType Type;
 
-  ~BatchAllocator() {
-    for (BatchInfo* batch = batches_; batch;) {
-      BatchInfo* nextBatch = batch->next_;
-      free(batch);
-      batch = nextBatch;
-    }
-  }
+   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_;
+   }
 
-  /// 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
+   ~BatchAllocator()
+   {
+      for ( BatchInfo *batch = batches_; batch;  )
       {
-        currentBatch_ = allocateBatch(objectsPerPage_);
-        currentBatch_->next_ = batches_; // insert at the head of the list
-        batches_ = currentBatch_;
+         BatchInfo *nextBatch = batch->next_;
+         free( batch );
+         batch = nextBatch;
       }
-    }
-    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;
-  }
+   /// 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];
-  };
+   struct BatchInfo
+   {
+      BatchInfo *next_;
+      AllocatedType *used_;
+      AllocatedType *end_;
+      AllocatedType buffer_[objectPerAllocation];
+   };
 
-  // disabled copy constructor and assignement operator.
-  BatchAllocator(const BatchAllocator&);
-  void operator=(const BatchAllocator&);
+   // 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;
-  }
+   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_;
+   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 // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
 
 #endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
+

src/lib_json/json_internalarray.inl

@@ -1,11 +1,5 @@
-// 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 {
+// everything is within Json namespace
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -15,346 +9,440 @@ namespace Json {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueArrayAllocator::~ValueArrayAllocator() {}
+ValueArrayAllocator::~ValueArrayAllocator()
+{
+}
 
 // //////////////////////////////////////////////////////////////////
 // class DefaultValueArrayAllocator
 // //////////////////////////////////////////////////////////////////
 #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-class DefaultValueArrayAllocator : public ValueArrayAllocator {
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
 public: // overridden from ValueArrayAllocator
-  virtual ~DefaultValueArrayAllocator() {}
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
 
-  virtual ValueInternalArray* newArray() { return new ValueInternalArray(); }
+   virtual ValueInternalArray *newArray()
+   {
+      return new ValueInternalArray();
+   }
 
-  virtual ValueInternalArray* newArrayCopy(const ValueInternalArray& other) {
-    return new ValueInternalArray(other);
-  }
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      return new ValueInternalArray( other );
+   }
 
-  virtual void destructArray(ValueInternalArray* array) { delete array; }
+   virtual void destructArray( ValueInternalArray *array )
+   {
+      delete array;
+   }
 
-  virtual void
-  reallocateArrayPageIndex(Value**& indexes,
-                           ValueInternalArray::PageIndex& indexCount,
-                           ValueInternalArray::PageIndex minNewIndexCount) {
-    ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1;
-    if (minNewIndexCount > newIndexCount)
-      newIndexCount = minNewIndexCount;
-    void* newIndexes = realloc(indexes, sizeof(Value*) * newIndexCount);
-    JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
-    indexCount = newIndexCount;
-    indexes = static_cast<Value**>(newIndexes);
-  }
-  virtual void releaseArrayPageIndex(Value** indexes,
-                                     ValueInternalArray::PageIndex indexCount) {
-    if (indexes)
-      free(indexes);
-  }
+   virtual 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 Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   }
 
-  virtual void releaseArrayPage(Value* value) {
-    if (value)
-      free(value);
-  }
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         free( value );
+   }
 };
 
-#else  // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
 /// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueArrayAllocator : public ValueArrayAllocator {
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
 public: // overridden from ValueArrayAllocator
-  virtual ~DefaultValueArrayAllocator() {}
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
 
-  virtual ValueInternalArray* newArray() {
-    ValueInternalArray* array = arraysAllocator_.allocate();
-    new (array) ValueInternalArray(); // placement new
-    return array;
-  }
+   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 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 destructArray( ValueInternalArray *array )
+   {
+      if ( array )
+      {
+         array->~ValueInternalArray();
+         arraysAllocator_.release( array );
+      }
+   }
 
-  virtual void
-  reallocateArrayPageIndex(Value**& indexes,
-                           ValueInternalArray::PageIndex& indexCount,
-                           ValueInternalArray::PageIndex minNewIndexCount) {
-    ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1;
-    if (minNewIndexCount > newIndexCount)
-      newIndexCount = minNewIndexCount;
-    void* newIndexes = realloc(indexes, sizeof(Value*) * newIndexCount);
-    JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
-    indexCount = newIndexCount;
-    indexes = static_cast<Value**>(newIndexes);
-  }
-  virtual void releaseArrayPageIndex(Value** indexes,
-                                     ValueInternalArray::PageIndex indexCount) {
-    if (indexes)
-      free(indexes);
-  }
+   virtual 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);
-  }
+   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_;
+   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 ValueArrayAllocator *&arrayAllocator()
+{
+   static DefaultValueArrayAllocator defaultAllocator;
+   static ValueArrayAllocator *arrayAllocator = &defaultAllocator;
+   return arrayAllocator;
 }
 
 static struct DummyArrayAllocatorInitializer {
-  DummyArrayAllocatorInitializer() {
-    arrayAllocator(); // ensure arrayAllocator() statics are initialized before
-                      // main().
-  }
+   DummyArrayAllocatorInitializer() 
+   {
+      arrayAllocator();      // ensure arrayAllocator() statics are initialized before main().
+   }
 } dummyArrayAllocatorInitializer;
 
 // //////////////////////////////////////////////////////////////////
 // class ValueInternalArray
 // //////////////////////////////////////////////////////////////////
-bool ValueInternalArray::equals(const IteratorState& x,
-                                const IteratorState& other) {
-  return x.array_ == other.array_ &&
-         x.currentItemIndex_ == other.currentItemIndex_ &&
-         x.currentPageIndex_ == other.currentPageIndex_;
+bool 
+ValueInternalArray::equals( const IteratorState &x, 
+                            const IteratorState &other )
+{
+   return x.array_ == other.array_  
+          &&  x.currentItemIndex_ == other.currentItemIndex_  
+          &&  x.currentPageIndex_ == other.currentPageIndex_;
 }
 
-void ValueInternalArray::increment(IteratorState& it) {
-  JSON_ASSERT_MESSAGE(
-      it.array_ && (it.currentPageIndex_ - it.array_->pages_) * itemsPerPage +
-                           it.currentItemIndex_ !=
-                       it.array_->size_,
-      "ValueInternalArray::increment(): moving iterator beyond end");
-  ++(it.currentItemIndex_);
-  if (it.currentItemIndex_ == itemsPerPage) {
-    it.currentItemIndex_ = 0;
-    ++(it.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_);
-  }
+
+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::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);
+
+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::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::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_);
+
+void 
+ValueInternalArray::makeEndIterator( IteratorState &it ) const
+{
+   makeIterator( it, size_ );
 }
 
-ValueInternalArray::ValueInternalArray() : pages_(0), size_(0), pageCount_(0) {}
 
-ValueInternalArray::ValueInternalArray(const ValueInternalArray& other)
-    : pages_(0), size_(other.size_), pageCount_(0) {
-  PageIndex minNewPages = other.size_ / itemsPerPage;
-  arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages);
-  JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages,
-                      "ValueInternalArray::reserve(): bad reallocation");
-  IteratorState itOther;
-  other.makeBeginIterator(itOther);
-  Value* value;
-  for (ArrayIndex index = 0; index < size_; ++index, increment(itOther)) {
-    if (index % itemsPerPage == 0) {
-      PageIndex pageIndex = index / itemsPerPage;
-      value = arrayAllocator()->allocateArrayPage();
-      pages_[pageIndex] = value;
-    }
-    new (value) Value(dereference(itOther));
-  }
+ValueInternalArray::ValueInternalArray()
+   : pages_( 0 )
+   , size_( 0 )
+   , pageCount_( 0 )
+{
 }
 
-ValueInternalArray& ValueInternalArray::operator=(ValueInternalArray other) {
-  swap(other);
-  return *this;
+
+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() {
-  // 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_);
+
+ValueInternalArray &
+ValueInternalArray::operator =( const ValueInternalArray &other )
+{
+   ValueInternalArray temp( other );
+   swap( temp );
+   return *this;
 }
 
-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);
+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();
-    }
-    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);
+   }
+   // 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::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
-  }
+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;
 }
 
-Value& ValueInternalArray::resolveReference(ArrayIndex index) {
-  if (index >= size_)
-    makeIndexValid(index);
-  return pages_[index / itemsPerPage][index % itemsPerPage];
+void 
+ValueInternalArray::clear()
+{
+   ValueInternalArray dummy;
+   swap( dummy );
 }
 
-Value* ValueInternalArray::find(ArrayIndex index) const {
-  if (index >= size_)
-    return 0;
-  return &(pages_[index / itemsPerPage][index % itemsPerPage]);
+
+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 );
 }
 
-ValueInternalArray::ArrayIndex ValueInternalArray::size() const {
-  return size_;
+
+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
+   }
 }
 
-int ValueInternalArray::distance(const IteratorState& x,
-                                 const IteratorState& y) {
-  return indexOf(y) - indexOf(x);
+Value &
+ValueInternalArray::resolveReference( ArrayIndex index )
+{
+   if ( index >= size_ )
+      makeIndexValid( index );
+   return pages_[index/itemsPerPage][index%itemsPerPage];
 }
 
-ValueInternalArray::ArrayIndex
-ValueInternalArray::indexOf(const IteratorState& iterator) {
-  if (!iterator.array_)
-    return ArrayIndex(-1);
-  return ArrayIndex((iterator.currentPageIndex_ - iterator.array_->pages_) *
-                        itemsPerPage +
-                    iterator.currentItemIndex_);
+Value *
+ValueInternalArray::find( ArrayIndex index ) const
+{
+   if ( index >= size_ )
+      return 0;
+   return &(pages_[index/itemsPerPage][index%itemsPerPage]);
 }
 
-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;
+ValueInternalArray::ArrayIndex 
+ValueInternalArray::size() const
+{
+   return size_;
 }
 
-} // namespace Json
+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,11 +1,5 @@
-// 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 {
+// everything is within Json namespace
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -15,459 +9,599 @@ namespace Json {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-/** \internal MUST be safely initialized using memset( this, 0,
- * sizeof(ValueInternalLink) );
+/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) );
    * This optimization is used by the fast allocator.
    */
-ValueInternalLink::ValueInternalLink() : previous_(0), next_(0) {}
-
-ValueInternalLink::~ValueInternalLink() {
-  for (int index = 0; index < itemPerLink; ++index) {
-    if (!items_[index].isItemAvailable()) {
-      if (!items_[index].isMemberNameStatic())
-        free(keys_[index]);
-    } else
-      break;
-  }
+ValueInternalLink::ValueInternalLink()
+   : previous_( 0 )
+   , next_( 0 )
+{
 }
 
-ValueMapAllocator::~ValueMapAllocator() {}
+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 {
+class DefaultValueMapAllocator : public ValueMapAllocator
+{
 public: // overridden from ValueMapAllocator
-  virtual ValueInternalMap* newMap() { return new ValueInternalMap(); }
+   virtual ValueInternalMap *newMap()
+   {
+      return new ValueInternalMap();
+   }
 
-  virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) {
-    return new ValueInternalMap(other);
-  }
+   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+   {
+      return new ValueInternalMap( other );
+   }
 
-  virtual void destructMap(ValueInternalMap* map) { delete map; }
+   virtual void destructMap( ValueInternalMap *map )
+   {
+      delete map;
+   }
 
-  virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
-    return new ValueInternalLink[size];
-  }
+   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+   {
+      return new ValueInternalLink[size];
+   }
 
-  virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
+   virtual void releaseMapBuckets( ValueInternalLink *links )
+   {
+      delete [] links;
+   }
 
-  virtual ValueInternalLink* allocateMapLink() {
-    return new ValueInternalLink();
-  }
+   virtual ValueInternalLink *allocateMapLink()
+   {
+      return new ValueInternalLink();
+   }
 
-  virtual void releaseMapLink(ValueInternalLink* link) { delete link; }
+   virtual void releaseMapLink( ValueInternalLink *link )
+   {
+      delete link;
+   }
 };
 #else
 /// @todo make this thread-safe (lock when accessign batch allocator)
-class DefaultValueMapAllocator : public ValueMapAllocator {
+class DefaultValueMapAllocator : public ValueMapAllocator
+{
 public: // overridden from ValueMapAllocator
-  virtual ValueInternalMap* newMap() {
-    ValueInternalMap* map = mapsAllocator_.allocate();
-    new (map) ValueInternalMap(); // placement new
-    return map;
-  }
+   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 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 void destructMap( ValueInternalMap *map )
+   {
+      if ( map )
+      {
+         map->~ValueInternalMap();
+         mapsAllocator_.release( map );
+      }
+   }
 
-  virtual ValueInternalLink* allocateMapBuckets(unsigned int size) {
-    return new ValueInternalLink[size];
-  }
+   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+   {
+      return new ValueInternalLink[size];
+   }
 
-  virtual void releaseMapBuckets(ValueInternalLink* links) { delete[] links; }
+   virtual void releaseMapBuckets( ValueInternalLink *links )
+   {
+      delete [] links;
+   }
 
-  virtual ValueInternalLink* allocateMapLink() {
-    ValueInternalLink* link = linksAllocator_.allocate();
-    memset(link, 0, sizeof(ValueInternalLink));
-    return link;
-  }
-
-  virtual void releaseMapLink(ValueInternalLink* link) {
-    link->~ValueInternalLink();
-    linksAllocator_.release(link);
-  }
+   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_;
+   BatchAllocator<ValueInternalMap,1> mapsAllocator_;
+   BatchAllocator<ValueInternalLink,1> linksAllocator_;
 };
 #endif
 
-static ValueMapAllocator*& mapAllocator() {
-  static DefaultValueMapAllocator defaultAllocator;
-  static ValueMapAllocator* mapAllocator = &defaultAllocator;
-  return mapAllocator;
+static ValueMapAllocator *&mapAllocator()
+{
+   static DefaultValueMapAllocator defaultAllocator;
+   static ValueMapAllocator *mapAllocator = &defaultAllocator;
+   return mapAllocator;
 }
 
 static struct DummyMapAllocatorInitializer {
-  DummyMapAllocatorInitializer() {
-    mapAllocator(); // ensure mapAllocator() statics are initialized before
-                    // main().
-  }
+   DummyMapAllocatorInitializer() 
+   {
+      mapAllocator();      // ensure mapAllocator() statics are initialized before main().
+   }
 } dummyMapAllocatorInitializer;
 
+
+
 // h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32.
 
 /*
-use linked list hash map.
+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;
-  }
+   : buckets_( 0 )
+   , tailLink_( 0 )
+   , bucketsSize_( 0 )
+   , itemCount_( 0 )
+{
 }
 
-ValueInternalMap& ValueInternalMap::operator=(ValueInternalMap other) {
-  swap(other);
-  return *this;
+
+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() {
-  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);
+
+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_);
-  }
+      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::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);
+
+void 
+ValueInternalMap::clear()
+{
+   ValueInternalMap dummy;
+   swap( dummy );
 }
 
-ValueInternalMap::BucketIndex ValueInternalMap::size() const {
-  return itemCount_;
+
+ValueInternalMap::BucketIndex 
+ValueInternalMap::size() const
+{
+   return itemCount_;
 }
 
-bool ValueInternalMap::reserveDelta(BucketIndex growth) {
-  return reserve(itemCount_ + growth);
+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;
+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];
+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];
       }
-    }
-  }
-
-  reserveDelta(1);
-  return unsafeAdd(key, isStatic, hashedKey);
+   }
+   return 0;
 }
 
-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;
+
+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::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_;
+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;
+         }
+      }
+   }
 }
 
-ValueInternalLink*&
-ValueInternalMap::getLastLinkInBucket(BucketIndex bucketIndex) {
-  if (bucketIndex == bucketsSize_ - 1)
-    return tailLink_;
-  ValueInternalLink*& previous = buckets_[bucketIndex + 1].previous_;
-  if (!previous)
-    previous = &buckets_[bucketIndex];
-  return previous;
+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_;
 }
 
-Value& ValueInternalMap::setNewItem(const char* key,
-                                    bool isStatic,
-                                    ValueInternalLink* link,
-                                    BucketIndex index) {
-  char* duplicatedKey = makeMemberName(key);
-  ++itemCount_;
-  link->keys_[index] = duplicatedKey;
-  link->items_[index].setItemUsed();
-  link->items_[index].setMemberNameIsStatic(isStatic);
-  return link->items_[index]; // items already default constructed.
+
+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::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);
+
+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.
 }
 
-ValueInternalMap::HashKey ValueInternalMap::hash(const char* key) const {
-  HashKey hash = 0;
-  while (*key)
-    hash += *key++ * 37;
-  return hash;
+
+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 );
 }
 
-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;
+ValueInternalMap::HashKey 
+ValueInternalMap::hash( const char *key ) const
+{
+   HashKey hash = 0;
+   while ( *key )
+      hash += *key++ * 37;
+   return hash;
 }
 
-void ValueInternalMap::makeBeginIterator(IteratorState& it) const {
-  it.map_ = const_cast<ValueInternalMap*>(this);
-  it.bucketIndex_ = 0;
-  it.itemIndex_ = 0;
-  it.link_ = buckets_;
+
+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::makeEndIterator(IteratorState& it) const {
-  it.map_ = const_cast<ValueInternalMap*>(this);
-  it.bucketIndex_ = bucketsSize_;
-  it.itemIndex_ = 0;
-  it.link_ = 0;
+
+void 
+ValueInternalMap::makeBeginIterator( IteratorState &it ) const
+{
+   it.map_ = const_cast<ValueInternalMap *>( this );
+   it.bucketIndex_ = 0;
+   it.itemIndex_ = 0;
+   it.link_ = buckets_;
 }
 
-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::makeEndIterator( IteratorState &it ) const
+{
+   it.map_ = const_cast<ValueInternalMap *>( this );
+   it.bucketIndex_ = bucketsSize_;
+   it.itemIndex_ = 0;
+   it.link_ = 0;
 }
 
-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;
+
+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::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::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::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;
-  }
+
+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 );
+   }
 }
 
-const char* ValueInternalMap::key(const IteratorState& iterator) {
-  JSON_ASSERT_MESSAGE(iterator.link_,
-                      "Attempting to iterate using invalid iterator.");
-  return iterator.link_->keys_[iterator.itemIndex_];
+
+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,
-                                  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_];
+
+const char *
+ValueInternalMap::key( const IteratorState &iterator )
+{
+   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+   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_];
+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_];
 }
 
-int ValueInternalMap::distance(const IteratorState& x, const IteratorState& y) {
-  int offset = 0;
-  IteratorState it = x;
-  while (!equals(it, y))
-    increment(it);
-  return offset;
+
+Value &
+ValueInternalMap::value( const IteratorState &iterator )
+{
+   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+   return iterator.link_->items_[iterator.itemIndex_];
 }
 
-} // namespace Json
+
+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

@@ -1,87 +0,0 @@
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef 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,11 +1,6 @@
-// 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
+// everything is within Json namespace
 
-namespace Json {
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -17,165 +12,200 @@ namespace Json {
 
 ValueIteratorBase::ValueIteratorBase()
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-    : current_(), isNull_(true) {
+   : current_()
+   , isNull_( true )
+{
 }
 #else
-    : isArray_(true), isNull_(true) {
-  iterator_.array_ = ValueInternalArray::IteratorState();
+   : isArray_( true )
+   , isNull_( true )
+{
+   iterator_.array_ = ValueInternalArray::IteratorState();
 }
 #endif
 
+
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueIteratorBase::ValueIteratorBase(
-    const Value::ObjectValues::iterator& current)
-    : current_(current), isNull_(false) {}
+ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )
+   : current_( current )
+   , isNull_( false )
+{
+}
 #else
-ValueIteratorBase::ValueIteratorBase(
-    const ValueInternalArray::IteratorState& state)
-    : isArray_(true) {
-  iterator_.array_ = state;
+ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
+   : isArray_( true )
+{
+   iterator_.array_ = state;
 }
 
-ValueIteratorBase::ValueIteratorBase(
-    const ValueInternalMap::IteratorState& state)
-    : isArray_(false) {
-  iterator_.map_ = state;
+
+ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
+   : isArray_( false )
+{
+   iterator_.map_ = state;
 }
 #endif
 
-Value& ValueIteratorBase::deref() const {
+Value &
+ValueIteratorBase::deref() const
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  return current_->second;
+   return current_->second;
 #else
-  if (isArray_)
-    return ValueInternalArray::dereference(iterator_.array_);
-  return ValueInternalMap::value(iterator_.map_);
+   if ( isArray_ )
+      return ValueInternalArray::dereference( iterator_.array_ );
+   return ValueInternalMap::value( iterator_.map_ );
 #endif
 }
 
-void ValueIteratorBase::increment() {
+
+void 
+ValueIteratorBase::increment()
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  ++current_;
+   ++current_;
 #else
-  if (isArray_)
-    ValueInternalArray::increment(iterator_.array_);
-  ValueInternalMap::increment(iterator_.map_);
+   if ( isArray_ )
+      ValueInternalArray::increment( iterator_.array_ );
+   ValueInternalMap::increment( iterator_.map_ );
 #endif
 }
 
-void ValueIteratorBase::decrement() {
+
+void 
+ValueIteratorBase::decrement()
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  --current_;
+   --current_;
 #else
-  if (isArray_)
-    ValueInternalArray::decrement(iterator_.array_);
-  ValueInternalMap::decrement(iterator_.map_);
+   if ( isArray_ )
+      ValueInternalArray::decrement( iterator_.array_ );
+   ValueInternalMap::decrement( iterator_.map_ );
 #endif
 }
 
-ValueIteratorBase::difference_type
-ValueIteratorBase::computeDistance(const SelfType& other) const {
+
+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;
-  }
+# 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
+
+   // 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_);
+   if ( isArray_ )
+      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );
 #endif
 }
 
-bool ValueIteratorBase::isEqual(const SelfType& other) const {
+
+bool 
+ValueIteratorBase::isEqual( const SelfType &other ) const
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  if (isNull_) {
-    return other.isNull_;
-  }
-  return current_ == other.current_;
+   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_);
+   if ( isArray_ )
+      return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );
 #endif
 }
 
-void ValueIteratorBase::copy(const SelfType& other) {
+
+void 
+ValueIteratorBase::copy( const SelfType &other )
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  current_ = other.current_;
-  isNull_ = other.isNull_;
+   current_ = other.current_;
 #else
-  if (isArray_)
-    iterator_.array_ = other.iterator_.array_;
-  iterator_.map_ = other.iterator_.map_;
+   if ( isArray_ )
+      iterator_.array_ = other.iterator_.array_;
+   iterator_.map_ = other.iterator_.map_;
 #endif
 }
 
-Value ValueIteratorBase::key() const {
+
+Value 
+ValueIteratorBase::key() const
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  const Value::CZString czstring = (*current_).first;
-  if (czstring.c_str()) {
-    if (czstring.isStaticString())
-      return Value(StaticString(czstring.c_str()));
-    return Value(czstring.c_str());
-  }
-  return Value(czstring.index());
+   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);
+   if ( isArray_ )
+      return Value( ValueInternalArray::indexOf( iterator_.array_ ) );
+   bool isStatic;
+   const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );
+   if ( isStatic )
+      return Value( StaticString( memberName ) );
+   return Value( memberName );
 #endif
 }
 
-UInt ValueIteratorBase::index() const {
+
+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);
+   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);
+   if ( isArray_ )
+      return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );
+   return Value::UInt( -1 );
 #endif
 }
 
-const char* ValueIteratorBase::memberName() const {
+
+const char *
+ValueIteratorBase::memberName() const
+{
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-  const char* name = (*current_).first.c_str();
-  return name ? name : "";
+   const char *name = (*current_).first.c_str();
+   return name ? name : "";
 #else
-  if (!isArray_)
-    return ValueInternalMap::key(iterator_.map_);
-  return "";
+   if ( !isArray_ )
+      return ValueInternalMap::key( iterator_.map_ );
+   return "";
 #endif
 }
 
+
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -184,28 +214,36 @@ const char* ValueIteratorBase::memberName() const {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueConstIterator::ValueConstIterator() {}
+ValueConstIterator::ValueConstIterator()
+{
+}
+
 
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueConstIterator::ValueConstIterator(
-    const Value::ObjectValues::iterator& current)
-    : ValueIteratorBase(current) {}
+ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
+   : ValueIteratorBase( current )
+{
+}
 #else
-ValueConstIterator::ValueConstIterator(
-    const ValueInternalArray::IteratorState& state)
-    : ValueIteratorBase(state) {}
+ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
 
-ValueConstIterator::ValueConstIterator(
-    const ValueInternalMap::IteratorState& state)
-    : ValueIteratorBase(state) {}
+ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
 #endif
 
-ValueConstIterator& ValueConstIterator::
-operator=(const ValueIteratorBase& other) {
-  copy(other);
-  return *this;
+ValueConstIterator &
+ValueConstIterator::operator =( const ValueIteratorBase &other )
+{
+   copy( other );
+   return *this;
 }
 
+
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -214,28 +252,41 @@ operator=(const ValueIteratorBase& other) {
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueIterator::ValueIterator() {}
-
-#ifndef JSON_VALUE_USE_INTERNAL_MAP
-ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
-    : ValueIteratorBase(current) {}
-#else
-ValueIterator::ValueIterator(const ValueInternalArray::IteratorState& state)
-    : ValueIteratorBase(state) {}
-
-ValueIterator::ValueIterator(const ValueInternalMap::IteratorState& state)
-    : ValueIteratorBase(state) {}
-#endif
-
-ValueIterator::ValueIterator(const ValueConstIterator& other)
-    : ValueIteratorBase(other) {}
-
-ValueIterator::ValueIterator(const ValueIterator& other)
-    : ValueIteratorBase(other) {}
-
-ValueIterator& ValueIterator::operator=(const SelfType& other) {
-  copy(other);
-  return *this;
+ValueIterator::ValueIterator()
+{
 }
 
-} // namespace Json
+
+#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;
+}

src/lib_json/version.h.in

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

src/test_lib_json/CMakeLists.txt

@@ -1,22 +0,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
-                )
-
-TARGET_LINK_LIBRARIES(jsoncpp_test jsoncpp_lib)
-
-# Run unit tests in post-build
-# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
-IF(JSONCPP_WITH_POST_BUILD_UNITTEST)
-    ADD_CUSTOM_COMMAND( TARGET jsoncpp_test
-                        POST_BUILD
-                        COMMAND $<TARGET_FILE:jsoncpp_test>)
-ENDIF(JSONCPP_WITH_POST_BUILD_UNITTEST)
-
-SET_TARGET_PROPERTIES(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test) 

src/test_lib_json/jsontest.cpp

@@ -1,8 +1,3 @@
-// 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>
@@ -10,434 +5,599 @@
 
 #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; }
 
-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::setTestName( const std::string &name )
+{
+   name_ = name;
 }
 
-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::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::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;
+
+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 );
 }
 
-bool TestResult::failed() const { return !failures_.empty(); }
 
-unsigned int TestResult::getAssertionNestingLevel() const {
-  unsigned int level = 0;
-  const PredicateContext* lastNode = &rootPredicateNode_;
-  while (lastNode->next_ != 0) {
-    lastNode = lastNode->next_;
-    ++level;
-  }
-  return level;
+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;
 }
 
-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());
-    }
-  }
+bool 
+TestResult::failed() const
+{
+   return !failures_.empty();
 }
 
-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;
+
+unsigned int 
+TestResult::getAssertionNestingLevel() const
+{
+   unsigned int level = 0;
+   const PredicateContext *lastNode = &rootPredicateNode_;
+   while ( lastNode->next_ != 0 )
+   {
+      lastNode = lastNode->next_;
+      ++level;
+   }
+   return level;
 }
 
-TestResult& TestResult::addToLastFailure(const std::string& message) {
-  if (messageTarget_ != 0) {
-    messageTarget_->message_ += message;
-  }
-  return *this;
+
+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::operator<<(Json::Int64 value) {
-  return addToLastFailure(Json::valueToString(value));
+
+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::UInt64 value) {
-  return addToLastFailure(Json::valueToString(value));
+
+TestResult &
+TestResult::addToLastFailure( const std::string &message )
+{
+   if ( messageTarget_ != 0 )
+   {
+      messageTarget_->message_ += message;
+   }
+   return *this;
 }
 
-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() {}
-
-void TestCase::run(TestResult& result) {
-  result_ = &result;
-  runTestCase();
+TestCase::TestCase()
+   : result_( 0 )
+{
 }
 
+
+TestCase::~TestCase()
+{
+}
+
+
+void 
+TestCase::run( TestResult &result )
+{
+   result_ = &result;
+   runTestCase();
+}
+
+
+
 // class Runner
 // //////////////////////////////////////////////////////////////////
 
-Runner::Runner() {}
-
-Runner& Runner::add(TestCaseFactory factory) {
-  tests_.push_back(factory);
-  return *this;
+Runner::Runner()
+{
 }
 
-unsigned int Runner::testCount() const {
-  return static_cast<unsigned int>(tests_.size());
+
+Runner &
+Runner::add( TestCaseFactory factory )
+{
+   tests_.push_back( factory );
+   return *this;
 }
 
-std::string Runner::testNameAt(unsigned int index) const {
-  TestCase* test = tests_[index]();
-  std::string name = test->testName();
-  delete test;
-  return name;
+
+unsigned int 
+Runner::testCount() const
+{
+   return static_cast<unsigned int>( tests_.size() );
 }
 
-void Runner::runTestAt(unsigned int index, TestResult& result) const {
-  TestCase* test = tests_[index]();
-  result.setTestName(test->testName());
-  printf("Testing %s: ", test->testName());
-  fflush(stdout);
+
+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 );
 #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 caught:")
-        << e.what();
-  }
+   } 
+   catch ( const std::exception &e ) 
+   {
+      result.addFailure( __FILE__, __LINE__, 
+         "Unexpected exception caugth:" ) << 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);
-    }
-  }
 
-  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 (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;
-    }
-  }
-  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());
-  }
-}
-
-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;
+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 );
       }
-    } 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 ( 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 ( 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;
+   }
 }
 
-#if defined(_MSC_VER) && defined(_DEBUG)
+
+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() );
+   }
+}
+
+
+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)
 // 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) && 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);
+
+void 
+Runner::preventDialogOnCrash()
+{
+#if defined(_MSC_VER)
+   // Install a hook to prevent MSVCRT error and assertion from
+   // popping a dialog.
+   _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,18 +1,10 @@
-// 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 JSONTEST_H_INCLUDED
-#define 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>
+# include <json/config.h>
+# include <stdio.h>
+# include <deque>
+# include <string>
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
@@ -20,6 +12,8 @@
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
+
+
 /** \brief Unit testing framework.
  * \warning: all assertions are non-aborting, test case execution will continue
  *           even if an assertion namespace.
@@ -28,253 +22,233 @@
  */
 namespace JsonTest {
 
-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 Failure
+   {
+   public:
+      const char *file_;
+      unsigned int line_;
+      std::string expr_;
+      std::string message_;
+      unsigned int nestingLevel_;
+   };
 
-class TestResult {
-public:
-  TestResult();
 
-  /// \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_;
+   /// 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 predicate macros
-  PredicateContext* predicateStackTail_;
+   class TestResult
+   {
+   public:
+      TestResult();
 
-  void setTestName(const std::string& name);
+      /// \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_;
 
-  /// Adds an assertion failure.
-  TestResult&
-  addFailure(const char* file, unsigned int line, const char* expr = 0);
+      /// \internal Implementation detail for predicate macros
+      PredicateContext *predicateStackTail_;
 
-  /// 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 setTestName( const std::string &name );
 
-  bool failed() const;
+      /// Adds an assertion failure.
+      TestResult &addFailure( const char *file, unsigned int line,
+                              const char *expr = 0 );
 
-  void printFailure(bool printTestName) 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();
 
-  // 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());
-  }
+      bool failed() 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);
+      void printFailure( bool printTestName ) const;
 
-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);
+      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 );
 
-  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_;
-};
+   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 );
 
-class TestCase {
-public:
-  TestCase();
+      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_;
+   };
 
-  virtual ~TestCase();
 
-  void run(TestResult& result);
+   class TestCase
+   {
+   public:
+      TestCase();
 
-  virtual const char* testName() const = 0;
+      virtual ~TestCase();
 
-protected:
-  TestResult* result_;
+      void run( TestResult &result );
 
-private:
-  virtual void runTestCase() = 0;
-};
+      virtual const char *testName() const = 0;
 
-/// Function pointer type for TestCase factory
-typedef TestCase* (*TestCaseFactory)();
+   protected:
+      TestResult *result_;
 
-class Runner {
-public:
-  Runner();
+   private:
+      virtual void runTestCase() = 0;
+   };
 
-  /// Adds a test to the suite
-  Runner& add(TestCaseFactory factory);
+   /// Function pointer type for TestCase factory
+   typedef TestCase *(*TestCaseFactory)();
 
-  /// 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;
+   class Runner
+   {
+   public:
+      Runner();
 
-  /// Runs all the test cases
-  bool runAllTest(bool printSummary) const;
+      /// Adds a test to the suite
+      Runner &add( TestCaseFactory factory );
 
-  /// Returns the number of test case in the suite
-  unsigned int testCount() 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 name of the test case at the specified index
-  std::string testNameAt(unsigned int index) const;
+      /// Runs all the test cases
+      bool runAllTest( bool printSummary ) const;
 
-  /// Runs the test case at the specified index using the specified TestResult
-  void runTestAt(unsigned int index, TestResult& result) const;
+      /// Returns the number of test case in the suite
+      unsigned int testCount() const;
 
-  static void printUsage(const char* appName);
+      /// Returns the name of the test case at the specified index
+      std::string testNameAt( unsigned int index ) const;
 
-private: // prevents copy construction and assignment
-  Runner(const Runner& other);
-  Runner& operator=(const Runner& other);
+      /// Runs the test case at the specified index using the specified TestResult
+      void runTestAt( unsigned int index, TestResult &result ) const;
 
-private:
-  void listTests() const;
-  bool testIndex(const std::string& testName, unsigned int& index) const;
-  static void preventDialogOnCrash();
+      static void printUsage( const char *appName );
 
-private:
-  typedef std::deque<TestCaseFactory> Factories;
-  Factories tests_;
-};
+   private: // prevents copy construction and assignment
+      Runner( const Runner &other );
+      Runner &operator =( const Runner &other );
 
-template <typename T, typename U>
-TestResult& checkEqual(TestResult& result,
-                       const T& expected,
-                       const U& actual,
-                       const char* file,
-                       unsigned int line,
-                       const char* expr) {
-  if (static_cast<U>(expected) != actual) {
-    result.addFailure(file, line, expr);
-    result << "Expected: " << static_cast<U>(expected) << "\n";
-    result << "Actual  : " << actual;
-  }
-  return result;
-}
+   private:
+      void listTests() const;
+      bool testIndex( const std::string &testName, unsigned int &index ) const;
+      static void preventDialogOnCrash();
 
-TestResult& checkStringEqual(TestResult& result,
-                             const std::string& expected,
-                             const std::string& actual,
-                             const char* file,
-                             unsigned int line,
-                             const char* expr);
+   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 );
 
 } // namespace JsonTest
 
+
 /// \brief Asserts that the given expression is true.
 /// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
 /// JSONTEST_ASSERT( x == y );
-#define JSONTEST_ASSERT(expr)                                                  \
-  if (expr) {                                                                  \
-  } else                                                                       \
-  result_->addFailure(__FILE__, __LINE__, #expr)
+#define JSONTEST_ASSERT( expr )                                               \
+   if ( condition )                                                           \
+   {                                                                          \
+   }                                                                          \
+   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();                                            \
-  }
+/// 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_
 
 /// \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),                              \
-                             __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);            \
-  }
+#define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \
+   JsonTest::checkStringEqual( *result_,                 \
+      std::string(expected), std::string(actual),        \
+      #expected " == " #actual )
 
 /// \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/data/fail_test_array_01.json

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

test/data/test_basic_08.expected

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

test/data/test_basic_09.expected

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

test/data/test_comment_01.expected

@@ -1,9 +1,8 @@
-.={}
-// Comment for array
-.test=[]
-.test[0]={}
-.test[0].a="aaa"
-.test[1]={}
-.test[1].b="bbb"
-.test[2]={}
-.test[2].c="ccc"
+.={}
+.test=[]
+.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,9 +1,8 @@
-{
-    "test":
-    // Comment for array
-    [
-       { "a" : "aaa" }, // Comment for a
-       { "b" : "bbb" }, // Comment for b
-       { "c" : "ccc" } // Comment for c
-    ]
-}
+{
+    "test":
+    [
+       { "a" : "aaa" }, // Comment for a
+       { "b" : "bbb" }, // Comment for b
+       { "c" : "ccc" } // Comment for c
+    ]
+}

test/data/test_comment_02.expected

@@ -1,23 +0,0 @@
-.={}
-/* 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

@@ -1,26 +0,0 @@
-{
-   /* 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,2 +1 @@
-// Max signed integer
 .=2147483647

test/data/test_integer_02.expected

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

test/data/test_integer_03.expected

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

test/data/test_integer_04.expected

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

test/data/test_integer_06_64bits.expected

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

test/data/test_integer_06_64bits.json

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

test/data/test_integer_07_64bits.expected

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

test/data/test_integer_07_64bits.json

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

test/data/test_integer_08_64bits.expected

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

test/data/test_integer_08_64bits.json

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

test/data/test_preserve_comment_01.expected

@@ -1,11 +1,3 @@
-/* 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,3 +1,2 @@
-// 2^33 => out of integer range, switch to double
 .=8589934592
 

test/data/test_real_02.expected

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

test/data/test_real_03.expected

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

test/data/test_real_04.expected

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

test/data/test_real_05.expected

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

test/data/test_real_06.expected

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

test/data/test_real_07.expected

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

test/data/test_real_08.expected

@@ -1,4 +0,0 @@
-// 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

@@ -1,4 +0,0 @@
-// 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

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

test/data/test_real_09.json

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

test/data/test_real_10.expected

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

test/data/test_real_10.json

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

test/data/test_real_11.expected

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

test/data/test_real_11.json

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

test/data/test_real_12.expected

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

test/data/test_real_12.json

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