Merge branch 'master' of https://github.com/miloyip/rapidjson

1f4211e2 · Justin Scheiber · 33b7a4ba · f4e357f6 · 1f4211e2 · 1f4211e2
Commit 1f4211e2 authored May 06, 2015 by Justin Scheiber
105 changed files
--- a/.gitignore
+++ b/.gitignore
@@ -2,10 +2,21 @@
 !/bin/data
 !/bin/encodings
 !/bin/jsonchecker
-/build/*.exe
-/build/gmake
-/build/vs*/
+/build
 /doc/html
 /doc/doxygen_*.db
-/thirdparty/lib
-/intermediate
+*.a
+
+# Temporary files created during CMake build
+CMakeCache.txt
+CMakeFiles
+cmake_install.cmake
+CTestTestfile.cmake
+Makefile
+RapidJSON*.cmake
+RapidJSON.pc
+Testing
+/googletest
+install_manifest.txt
+Doxyfile
+DartConfiguration.tcl
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,36 +6,46 @@ compiler:

 env:
  matrix:
-    - CONF=debug   BITS=64
-    - CONF=release BITS=64
-    - CONF=debug   BITS=32
-    - CONF=release BITS=32
+    - CONF=debug   ARCH=x86_64
+    - CONF=release ARCH=x86_64
+    - CONF=debug   ARCH=x86
+    - CONF=release ARCH=x86
  global:
+    - ARCH_FLAGS_x86='-m32'        # #266: don't use SSE on 32-bit
+    - ARCH_FLAGS_x86_64='-msse4.2' #       use SSE4.2 on 64-bit
    - GITHUB_REPO='miloyip/rapidjson'
-    - DEFINES='-DRAPIDJSON_HAS_STDSTRING'
    - secure: "HrsaCb+N66EG1HR+LWH1u51SjaJyRwJEDzqJGYMB7LJ/bfqb9mWKF1fLvZGk46W5t7TVaXRDD5KHFx9DPWvKn4gRUVkwTHEy262ah5ORh8M6n/6VVVajeV/AYt2C0sswdkDBDO4Xq+xy5gdw3G8s1A4Inbm73pUh+6vx+7ltBbk="

 before_install:
-  - sudo add-apt-repository -y ppa:codegear/release
  - sudo apt-get update -qq
-  - sudo apt-get install -qq premake4 valgrind
-  - if [ "$BITS" = 32 ]; then sudo apt-get install -qq g++-multilib libc6-dbg:i386; fi
+  - sudo apt-get install -qq cmake valgrind
+  - sudo apt-get --no-install-recommends install doxygen # Don't install LaTeX stuffs
+  - if [ "$ARCH" = "x86" ]; then sudo apt-get install -qq g++-multilib libc6-dbg:i386; fi
+  - if [ "$CC" = "gcc" ] && [ "$CONF" = "debug" ]; then sudo pip install cpp-coveralls; export GCOV_FLAGS='--coverage'; fi

 install: true

 before_script:
-  - (cd build && premake4 'gmake')
 #   hack to avoid Valgrind bug (https://bugs.kde.org/show_bug.cgi?id=326469),
 #   exposed by merging PR#163 (using -march=native)
-  - (cd build/gmake && sed -i 's/march=native/msse4.2/' *.make)
+    - sed -i "s/-march=native//" CMakeLists.txt
+    - mkdir build 
+    - >
+        eval "ARCH_FLAGS=\${ARCH_FLAGS_${ARCH}}" ;
+        (cd build && cmake 
+        -DRAPIDJSON_HAS_STDSTRING=ON
+        -DCMAKE_VERBOSE_MAKEFILE=ON 
+        -DCMAKE_BUILD_TYPE=$CONF 
+        -DCMAKE_CXX_FLAGS="$ARCH_FLAGS $GCOV_FLAGS"
+        -DCMAKE_EXE_LINKER_FLAGS=$GCOV_FLAGS
+        ..)

 script:
-  - make -C build/gmake -f test.make    config=${CONF}${BITS}
-  - make -C build/gmake -f example.make config=${CONF}${BITS}
-  - if [ "$CONF" = "debug" ] && ( objdump -t -C intermediate/${CONF}/gmake/unittest/x${BITS}/namespacetest.o | grep rapidjson ) ; then echo "Symbol check failed!" ; false; fi
-  - pushd bin
-  -  ./unittest_${CONF}_x${BITS}_gmake
-  - valgrind --leak-check=full --error-exitcode=1 ./unittest_${CONF}_x${BITS}_gmake
-  - if [ "$CONF" = "release" ]; then ./perftest_${CONF}_x${BITS}_gmake; fi
-  - popd
-  - ./build/travis-doxygen.sh;
+  - cd build
+  - make tests
+  - make examples
+  - ctest -V `[ "$CONF" = "release" ] || echo "-E perftest"`
+  - make travis_doc
+
+after_success:
+  - coveralls -r .. --gcov-options '\-lp' -e thirdparty -e example -e test -e build/CMakeFiles -e include/rapidjson/msinttypes -e include/rapidjson/internal/meta.h -e include/rapidjson/error/en.h
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+* Include rapidjson.h for all internal/error headers.
+
+## [1.0.1] - 2015-04-25
+
+### Added
+* Changelog following [Keep a CHANGELOG](https://github.com/olivierlacan/keep-a-changelog) suggestions.
+
+### Fixed
+* Parsing of some numbers (e.g. "1e-00011111111111") causing assertion (#314).
+* Visual C++ 32-bit compilation error in `diyfp.h` (#317).
+
+## [1.0.0] - 2015-04-22
+
+### Added
+* 100% [Coverall](https://coveralls.io/r/miloyip/rapidjson?branch=master) coverage.
+* Version macros (#311)
+
+### Fixed
+* A bug in trimming long number sequence (4824f12efbf01af72b8cb6fc96fae7b097b73015).
+* Double quote in unicode escape (#288).
+* Negative zero roundtrip (double only) (#289).
+* Standardize behavior of `memcpy()` and `malloc()` (0c5c1538dcfc7f160e5a4aa208ddf092c787be5a, #305, 0e8bbe5e3ef375e7f052f556878be0bd79e9062d).
+
+### Removed
+* Remove an invalid `Document::ParseInsitu()` API (e7f1c6dd08b522cfcf9aed58a333bd9a0c0ccbeb).
+
+## 1.0-beta - 2015-04-8
+
+### Added
+* RFC 7159 (#101)
+* Optional Iterative Parser (#76)
+* Deep-copy values (#20)
+* Error code and message (#27)
+* ASCII Encoding (#70)
+* `kParseStopWhenDoneFlag` (#83)
+* `kParseFullPrecisionFlag` (881c91d696f06b7f302af6d04ec14dd08db66ceb)
+* Add `Key()` to handler concept (#134)
+* C++11 compatibility and support (#128)
+* Optimized number-to-string and vice versa conversions (#137, #80)
+* Short-String Optimization (#131)
+* Local stream optimization by traits (#32)
+* Travis & Appveyor Continuous Integration, with Valgrind verification (#24, #242)
+* Redo all documentation (English, Simplified Chinese)
+
+### Changed
+* Copyright ownership transfered to THL A29 Limited (a Tencent company).
+* Migrating from Premake to CMAKE (#192)
+* Resolve all warning reports
+
+### Removed
+* Remove other JSON libraries for performance comparison (#180)
+
+## 0.11 - 2012-11-16
+
+## 0.1 - 2011-11-18
+
+[Unreleased]: https://github.com/miloyip/rapidjson/compare/v1.0.1...HEAD
+[1.0.1]: https://github.com/miloyip/rapidjson/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/miloyip/rapidjson/compare/v1.0-beta...v1.0.0
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules)
+
+PROJECT(RapidJSON CXX)
+
+set(LIB_MAJOR_VERSION "1")
+set(LIB_MINOR_VERSION "0")
+set(LIB_PATCH_VERSION "1")
+set(LIB_VERSION_STRING "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_PATCH_VERSION}")
+
+# compile in release with debug info mode by default
+SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Build Type")
+
+# Build all binaries in a separate directory
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+option(RAPIDJSON_BUILD_DOC "Build rapidjson documentation." ON)
+option(RAPIDJSON_BUILD_EXAMPLES "Build rapidjson examples." ON)
+option(RAPIDJSON_BUILD_TESTS "Build rapidjson perftests and unittests." ON)
+option(RAPIDJSON_BUILD_THIRDPARTY_GTEST 
+    "Use gtest installation in `thirdparty/gtest` by default if available" OFF)
+
+option(RAPIDJSON_HAS_STDSTRING "" OFF)
+if(RAPIDJSON_HAS_STDSTRING)
+    add_definitions(-DRAPIDJSON_HAS_STDSTRING)
+endif()
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wall -Wextra")
+elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wall -Wextra")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
+endif()
+
+#add extra search paths for libraries and includes
+SET(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The directory the headers are installed in")
+SET(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE STRING "Directory where lib will install")
+SET(DOC_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/share/doc/${PROJECT_NAME}" CACHE PATH "Path to the documentation")
+
+IF(UNIX OR CYGWIN)
+    SET(_CMAKE_INSTALL_DIR "${LIB_INSTALL_DIR}/cmake/${PROJECT_NAME}")
+ELSEIF(WIN32)
+    SET(_CMAKE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/cmake")
+ENDIF()
+SET(CMAKE_INSTALL_DIR "${_CMAKE_INSTALL_DIR}" CACHE PATH "The directory cmake fiels are installed in")
+
+include_directories(${CMAKE_SOURCE_DIR}/include)
+
+if(RAPIDJSON_BUILD_DOC)
+    add_subdirectory(doc)
+endif()
+
+add_custom_target(travis_doc)
+add_custom_command(TARGET travis_doc
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/travis-doxygen.sh)
+
+if(RAPIDJSON_BUILD_EXAMPLES)
+    add_subdirectory(example)
+endif()
+
+if(RAPIDJSON_BUILD_TESTS)
+    if(MSVC11)
+        # required for VS2012 due to missing support for variadic templates
+        add_definitions(-D_VARIADIC_MAX=10)
+    endif(MSVC11)
+    add_subdirectory(test)
+    include(CTest)
+endif()
+
+# pkg-config
+IF (UNIX OR CYGWIN)
+  CONFIGURE_FILE (${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.in
+                  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
+                  @ONLY)
+  INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
+      DESTINATION "${LIB_INSTALL_DIR}/pkgconfig"
+      COMPONENT pkgconfig)
+ENDIF()
+
+install(FILES readme.md
+        DESTINATION "${DOC_INSTALL_DIR}"
+        COMPONENT doc)
+
+install(DIRECTORY include/rapidjson
+    DESTINATION "${INCLUDE_INSTALL_DIR}"
+    COMPONENT dev)
+
+install(DIRECTORY example/
+    DESTINATION "${DOC_INSTALL_DIR}/examples"
+    COMPONENT examples
+    # Following patterns are for excluding the intermediate/object files
+    # from an install of in-source CMake build.
+    PATTERN "CMakeFiles" EXCLUDE
+    PATTERN "Makefile" EXCLUDE
+    PATTERN "cmake_install.cmake" EXCLUDE)
+
+# Provide config and version files to be used by other applications
+# ===============================
+
+export(PACKAGE ${PROJECT_NAME})
+
+# cmake-modules
+CONFIGURE_FILE(${PROJECT_NAME}Config.cmake.in
+    ${PROJECT_NAME}Config.cmake
+    @ONLY)
+CONFIGURE_FILE(${PROJECT_NAME}ConfigVersion.cmake.in
+    ${PROJECT_NAME}ConfigVersion.cmake
+    @ONLY)
+INSTALL(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+    DESTINATION "${CMAKE_INSTALL_DIR}"
+    COMPONENT dev)
--- a/CMakeModules/FindGTestSrc.cmake
+++ b/CMakeModules/FindGTestSrc.cmake
+
+SET(GTEST_SEARCH_PATH 
+    "${GTEST_SOURCE_DIR}"
+    "${CMAKE_SOURCE_DIR}/thirdparty/gtest")
+
+IF(UNIX)
+    IF(RAPIDJSON_BUILD_THIRDPARTY_GTEST)
+        LIST(APPEND GTEST_SEARCH_PATH "/usr/src/gtest")
+    ELSE()
+        LIST(INSERT GTEST_SEARCH_PATH 1 "/usr/src/gtest")
+    ENDIF()
+ENDIF()
+
+FIND_PATH(GTEST_SOURCE_DIR
+    NAMES CMakeLists.txt src/gtest_main.cc
+    PATHS ${GTEST_SEARCH_PATH})
+
+# Debian installs gtest include directory in /usr/include, thus need to look
+# for include directory separately from source directory.
+FIND_PATH(GTEST_INCLUDE_DIR
+    NAMES gtest/gtest.h
+    PATH_SUFFIXES include
+    HINTS ${GTEST_SOURCE_DIR}
+    PATHS ${GTEST_SEARCH_PATH})
+
+INCLUDE(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GTestSrc DEFAULT_MSG
+    GTEST_SOURCE_DIR
+    GTEST_INCLUDE_DIR)
--- a/RapidJSON.pc.in
+++ b/RapidJSON.pc.in
+includedir=@INCLUDE_INSTALL_DIR@
+
+Name: @PROJECT_NAME@
+Description: A fast JSON parser/generator for C++ with both SAX/DOM style API
+Version: @LIB_VERSION_STRING@
+URL: https://github.com/miloyip/rapidjson
+Cflags: -I${includedir}
--- a/RapidJSONConfig.cmake.in
+++ b/RapidJSONConfig.cmake.in
+get_filename_component(RAPIDJSON_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(RAPIDJSON_INCLUDE_DIRS "@INCLUDE_INSTALL_DIR@")
+message(STATUS "RapidJSON found. Headers: ${RAPIDJSON_INCLUDE_DIRS}")
--- a/RapidJSONConfigVersion.cmake.in
+++ b/RapidJSONConfigVersion.cmake.in
+SET(PACKAGE_VERSION "@LIB_VERSION_STRING@")
+
+IF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_EXACT "true")
+ENDIF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+IF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_COMPATIBLE "true")
+ELSE (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_UNSUITABLE "true")
+ENDIF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
--- a/appveyor.yml
+++ b/appveyor.yml
+version: 1.0.1.{build}
+
+configuration:
+- Debug
+- Release
+
+environment:
+  matrix:
+  - VS_VERSION: 11
+    VS_PLATFORM: win32
+  - VS_VERSION: 11
+    VS_PLATFORM: x64
+  - VS_VERSION: 12
+    VS_PLATFORM: win32
+  - VS_VERSION: 12
+    VS_PLATFORM: x64
+
+before_build:
+- git submodule update --init --recursive
+- cmake -H. -BBuild/VS -G "Visual Studio %VS_VERSION%" -DCMAKE_GENERATOR_PLATFORM=%VS_PLATFORM% -DBUILD_SHARED_LIBS=true -Wno-dev
+
+build:
+  project: Build\VS\RapidJSON.sln
+  parallel: true
+  verbosity: minimal
+
+test_script:
+- cd Build\VS && if %CONFIGURATION%==Debug (ctest --verbose -E perftest --build-config %CONFIGURATION%) else (ctest --verbose --build-config %CONFIGURATION%)
--- a/build/premake.bat
+++ b/build/premake.bat
-@echo off
-premake4 vs2005
-premake4 vs2008
-premake4 vs2010
-premake4 gmake
\ No newline at end of file
--- a/build/premake.sh
+++ b/build/premake.sh
-#!/bin/sh
-premake4 vs2005
-premake4 vs2008
-premake4 vs2010
-premake4 gmake
--- a/build/premake4.lua
+++ b/build/premake4.lua
-function setTargetObjDir(outDir)
-    for _, cfg in ipairs(configurations()) do
-        for _, plat in ipairs(platforms()) do
-            local action = _ACTION or ""
-            
-            local prj = project()
-            
-            --"_debug_win32_vs2008"
-            local suffix = "_" .. cfg .. "_" .. plat .. "_" .. action
-            
-            targetPath = outDir
-            
-            suffix = string.lower(suffix)
-
-            local obj_path = "../intermediate/" .. cfg .. "/" .. action .. "/" .. prj.name
-            
-            obj_path = string.lower(obj_path)
-            
-            configuration {cfg, plat}
-                targetdir(targetPath)
-                objdir(obj_path)
-                targetsuffix(suffix)
-        end
-    end
-end
-
-function linkLib(libBaseName)
-    for _, cfg in ipairs(configurations()) do
-        for _, plat in ipairs(platforms()) do
-            local action = _ACTION or ""
-            
-            local prj = project()
-            
-            local cfgName = cfg
-            
-            --"_debug_win32_vs2008"
-            local suffix = "_" .. cfgName .. "_" .. plat .. "_" .. action
-            
-            libFullName = libBaseName .. string.lower(suffix)
-            
-            configuration {cfg, plat}
-                links(libFullName)
-        end
-    end
-end
-
-solution "test"
-    configurations { "debug", "release" }
-    platforms { "x32", "x64" }
-
-    location ("./" .. (_ACTION or ""))
-    language "C++"
-    flags { "ExtraWarnings" }
-    
-    configuration "debug"
-        defines { "DEBUG" }
-        flags { "Symbols" }
-
-    configuration "release"
-        defines { "NDEBUG" }
-        flags { "Optimize" }
-
-    configuration "vs*"
-        defines { "_CRT_SECURE_NO_WARNINGS" }
-        
-    configuration "gmake"
-        buildoptions "-march=native -Wall -Wextra"
-
-    project "gtest"
-        kind "StaticLib"
-        
-        defines { "GTEST_HAS_PTHREAD=0" }
-
-        files { 
-            "../thirdparty/gtest/src/gtest-all.cc",
-            "../thirdparty/gtest/src/**.h",
-        }
-
-        includedirs {
-            "../thirdparty/gtest/",
-            "../thirdparty/gtest/include",
-        }
-
-        setTargetObjDir("../thirdparty/lib")
-
-    project "unittest"
-        kind "ConsoleApp"
-        
-        if _ACTION == "gmake" then
-            buildoptions "-Werror -Weffc++ -Wswitch-default"
-        end
-
-        files { 
-            "../include/**.h",
-            "../test/unittest/**.cpp",
-            "../test/unittest/**.h",
-        }
-        
-        includedirs {
-            "../include/",
-            "../thirdparty/gtest/include/",
-        }
-
-        libdirs "../thirdparty/lib"
-
-        setTargetObjDir("../bin")
-
-        linkLib "gtest"
-        links "gtest"
-        
-    project "perftest"
-        kind "ConsoleApp"
-        
-        files { 
-            "../include/**.h",
-            "../test/perftest/**.cpp",
-            "../test/perftest/**.h",
-        }
-        
-        includedirs {
-            "../include/",
-            "../thirdparty/gtest/include/",
-            "../thirdparty/",
-        }
-
-        libdirs "../thirdparty/lib"
-
-        setTargetObjDir("../bin")
-
-        linkLib "gtest"
-        links "gtest"
-
-solution "example"
-    configurations { "debug", "release" }
-    platforms { "x32", "x64" }
-    location ("./" .. (_ACTION or ""))
-    language "C++"
-    flags { "ExtraWarnings" }
-    includedirs "../include/"
-
-    configuration "debug"
-        defines { "DEBUG" }
-        flags { "Symbols" }
-
-    configuration "release"
-        defines { "NDEBUG" }
-        flags { "Optimize", "EnableSSE2" }
-
-    configuration "vs*"
-        defines { "_CRT_SECURE_NO_WARNINGS" }
-
-    configuration "gmake"
-        buildoptions "-Werror -Wall -Wextra -Weffc++ -Wswitch-default"
-
-    local examplepaths = os.matchdirs("../example/*")
-    for _, examplepath in ipairs(examplepaths) do
-        project(path.getname(examplepath))
-            kind "ConsoleApp"
-            files(examplepath .. "/*")
-            setTargetObjDir("../bin")
-    end
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
+find_package(Doxygen)
+
+IF(NOT DOXYGEN_FOUND)
+    MESSAGE(STATUS "No Doxygen found. Documentation won't be built")
+ELSE()
+    file(GLOB SOURCES ${CMAKE_SOURCE_DIR}/include/*)
+    file(GLOB MARKDOWN_DOC ${CMAKE_SOURCE_DIR}/doc/*.md)
+    list(APPEND MARKDOWN_DOC ${CMAKE_SOURCE_DIR}/readme.md)
+
+    CONFIGURE_FILE(Doxyfile.in Doxyfile @ONLY)
+    CONFIGURE_FILE(Doxyfile.zh-cn.in Doxyfile.zh-cn @ONLY)
+
+    add_custom_command(OUTPUT html
+        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile.zh-cn
+        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/html
+        DEPENDS ${MARKDOWN_DOC} ${SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile*
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+
+    add_custom_target(doc ALL DEPENDS html)
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
+        DESTINATION ${DOC_INSTALL_DIR}
+        COMPONENT doc)
+ENDIF()
--- a/build/Doxyfile
+++ b/build/Doxyfile
@@ -58,7 +58,7 @@ PROJECT_LOGO           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.

-OUTPUT_DIRECTORY       = ./doc
+OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@

 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -764,18 +764,19 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.

-INPUT                  = ./include/rapidjson/rapidjson.h \
-                         ./include/ \
-                         ./readme.md \
-                         ./doc/features.md \
-                         ./doc/tutorial.md \
-                         ./doc/stream.md \
-                         ./doc/encoding.md \
-                         ./doc/dom.md \
-                         ./doc/sax.md \
-                         ./doc/performance.md \
-                         ./doc/internals.md \
-                         ./doc/faq.md
+INPUT                  = readme.md \
+                         include/rapidjson/rapidjson.h \
+                         include/ \
+                         doc/features.md \
+                         doc/tutorial.md \
+                         doc/pointer.md \
+                         doc/stream.md \
+                         doc/encoding.md \
+                         doc/dom.md \
+                         doc/sax.md \
+                         doc/performance.md \
+                         doc/internals.md \
+                         doc/faq.md

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -920,7 +921,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.

-USE_MDFILE_AS_MAINPAGE = ./readme.md
+USE_MDFILE_AS_MAINPAGE = readme.md

 #---------------------------------------------------------------------------
 # Configuration options related to source browsing

--- a/doc/Doxyfile.zh-cn.in
+++ b/doc/Doxyfile.zh-cn.in
--- a/doc/diagram/architecture.dot
+++ b/doc/diagram/architecture.dot
+digraph {
+	compound=true
+	fontname="Inconsolata, Consolas"
+	fontsize=10
+	margin="0,0"
+	ranksep=0.2
+	nodesep=0.5
+	penwidth=0.5
+	colorscheme=spectral7
+	
+	node [shape=box, fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5, style=filled, fillcolor=white]
+	edge [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
+
+	subgraph cluster1 {
+		margin="10,10"
+		labeljust="left"
+		label = "SAX"
+		style=filled
+		fillcolor=6
+
+		Reader -> Writer [style=invis]
+	}
+
+	subgraph cluster2 {
+		margin="10,10"
+		labeljust="left"
+		label = "DOM"
+		style=filled
+		fillcolor=7
+
+		Value
+		Document
+	}
+
+	Handler [label="<<concept>>\nHandler"]
+
+	{
+		edge [arrowtail=onormal, dir=back]
+		Value -> Document
+		Handler -> Document
+		Handler -> Writer
+	}
+
+	{
+		edge [arrowhead=vee, style=dashed, constraint=false]
+		Reader -> Handler [label="calls"]
+		Value -> Handler [label="calls"]
+		Document -> Reader [label="uses"]
+	}
+}
\ No newline at end of file
--- a/doc/diagram/architecture.png
+++ b/doc/diagram/architecture.png
--- a/doc/diagram/simpledom.dot
+++ b/doc/diagram/simpledom.dot
@@ -11,8 +11,8 @@ digraph {

 	{
 		node [shape=record, fontsize="8", margin="0.04", height=0.2, color=gray]
-		srcjson [label="\{|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|0|\}"]
-		dstjson [label="\{|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|1|\}"]
+		srcjson [label="\{|\"|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|0|\}"]
+		dstjson [label="\{|\"|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|1|\}"]
 	}

 	{

--- a/doc/diagram/simpledom.png
+++ b/doc/diagram/simpledom.png
--- a/doc/diagram/utilityclass.dot
+++ b/doc/diagram/utilityclass.dot
+digraph {
+	rankdir=LR
+	compound=true
+	fontname="Inconsolata, Consolas"
+	fontsize=10
+	margin="0,0"
+	ranksep=0.3
+	nodesep=0.15
+	penwidth=0.5
+	colorscheme=spectral7
+	
+	node [shape=box, fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5, style=filled, fillcolor=white]
+	edge [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
+
+	subgraph cluster0 {
+		style=filled
+		fillcolor=4
+
+		Encoding [label="<<concept>>\nEncoding"]
+
+		edge [arrowtail=onormal, dir=back]
+		Encoding -> { UTF8; UTF16; UTF32; ASCII; AutoUTF }
+		UTF16 -> { UTF16LE; UTF16BE }
+		UTF32 -> { UTF32LE; UTF32BE }
+	}
+
+	subgraph cluster1 {
+		style=filled
+		fillcolor=5
+
+		Stream [label="<<concept>>\nStream"]
+		InputByteStream [label="<<concept>>\nInputByteStream"]
+		OutputByteStream [label="<<concept>>\nOutputByteStream"]
+
+		edge [arrowtail=onormal, dir=back]
+		Stream -> { 
+			StringStream; InsituStringStream; StringBuffer; 
+			EncodedInputStream; EncodedOutputStream; 
+			AutoUTFInputStream; AutoUTFOutputStream 
+			InputByteStream; OutputByteStream
+		}
+
+		InputByteStream ->	{ MemoryStream; FlieReadStream }
+		OutputByteStream -> { MemoryBuffer; FileWriteStream } 
+	}
+
+	subgraph cluster2 {
+		style=filled
+		fillcolor=3
+
+		Allocator [label="<<concept>>\nAllocator"]
+
+		edge [arrowtail=onormal, dir=back]
+		Allocator -> { CrtAllocator; MemoryPoolAllocator }
+	}
+
+	{
+		edge [arrowtail=odiamond, arrowhead=vee, dir=both]
+		EncodedInputStream -> InputByteStream
+		EncodedOutputStream -> OutputByteStream
+		AutoUTFInputStream -> InputByteStream
+		AutoUTFOutputStream -> OutputByteStream
+		MemoryPoolAllocator -> Allocator [label="base", tailport=s]
+	}
+
+	{
+		edge [arrowhead=vee, style=dashed]
+		AutoUTFInputStream -> AutoUTF
+		AutoUTFOutputStream -> AutoUTF
+	}
+
+	//UTF32LE -> Stream [style=invis]
+}
\ No newline at end of file
--- a/doc/diagram/utilityclass.png
+++ b/doc/diagram/utilityclass.png
--- a/doc/dom.md
+++ b/doc/dom.md
--- a/doc/dom.zh-cn.md
+++ b/doc/dom.zh-cn.md
--- a/doc/encoding.md
+++ b/doc/encoding.md
@@ -73,7 +73,7 @@ typedef GenericDocument<UTF16<> > WDocument;
 typedef GenericValue<UTF16<> > WValue;
 ~~~~~~~~~~

-For a detail example, please check the example in [DOM's Encoding](doc/stream.md#Encoding) section.
+For a detail example, please check the example in [DOM's Encoding](doc/stream.md) section.

 ## Character Type {#CharacterType}


--- a/doc/encoding.zh-cn.md
+++ b/doc/encoding.zh-cn.md
+# 编码
+
+根据[ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf)：
+
+> (in Introduction) JSON text is a sequence of Unicode code points.
+> 
+> 翻译：JSON文本是Unicode码点的序列。
+
+较早的[RFC4627](http://www.ietf.org/rfc/rfc4627.txt)申明：
+
+> (in §3) JSON text SHALL be encoded in Unicode.  The default encoding is UTF-8.
+> 
+> 翻译：JSON文本应该以Unicode编码。缺省的编码为UTF-8。
+
+> (in §6) JSON may be represented using UTF-8, UTF-16, or UTF-32. When JSON is written in UTF-8, JSON is 8bit compatible.  When JSON is written in UTF-16 or UTF-32, the binary content-transfer-encoding must be used.
+> 
+> 翻译：JSON可使用UTF-8、UTF-16或UTF-18表示。当JSON以UTF-8写入，该JSON是8位兼容的。当JSON以UTF-16或UTF-32写入，就必须使用二进制的内容传送编码。
+
+RapidJSON支持多种编码。它也能检查JSON的编码，以及在不同编码中进行转码。所有这些功能都是在内部实现，无需使用外部的程序库（如[ICU](http://site.icu-project.org/)）。
+
+[TOC]
+
+# Unicode {#Unicode}
+根据 [Unicode的官方网站](http://www.unicode.org/standard/translations/t-chinese.html)：
+>Unicode给每个字符提供了一个唯一的数字，
+不论是什么平台、
+不论是什么程序、
+不论是什么语言。
+
+这些唯一数字称为码点（code point），其范围介乎`0x0`至`0x10FFFF`之间。
+
+## Unicode转换格式 {#UTF}
+
+存储Unicode码点有多种编码方式。这些称为Unicode转换格式（Unicode Transformation Format, UTF）。RapidJSON支持最常用的UTF，包括：
+
+* UTF-8：8位可变长度编码。它把一个码点映射至1至4个字节。
+* UTF-16：16位可变长度编码。它把一个码点映射至1至2个16位编码单元（即2至4个字节）。
+* UTF-32：32位固定长度编码。它直接把码点映射至单个32位编码单元（即4字节）。
+
+对于UTF-16及UTF-32来说，字节序（endianness）是有影响的。在内存中，它们通常都是以该计算机的字节序来存储。然而，当要储存在文件中或在网上传输，我们需要指明字节序列的字节序，是小端（little endian, LE）还是大端（big-endian, BE）。 
+
+RapidJSON通过`rapidjson/encodings.h`中的struct去提供各种编码：
+
+~~~~~~~~~~cpp
+namespace rapidjson {
+
+template<typename CharType = char>
+struct UTF8;
+
+template<typename CharType = wchar_t>
+struct UTF16;
+
+template<typename CharType = wchar_t>
+struct UTF16LE;
+
+template<typename CharType = wchar_t>
+struct UTF16BE;
+
+template<typename CharType = unsigned>
+struct UTF32;
+
+template<typename CharType = unsigned>
+struct UTF32LE;
+
+template<typename CharType = unsigned>
+struct UTF32BE;
+
+} // namespace rapidjson
+~~~~~~~~~~
+
+对于在内存中的文本，我们正常会使用`UTF8`、`UTF16`或`UTF32`。对于处理经过I/O的文本，我们可使用`UTF8`、`UTF16LE`、`UTF16BE`、`UTF32LE`或`UTF32BE`。
+
+当使用DOM风格的API，`GenericValue<Encoding>`及`GenericDocument<Encoding>`里的`Encoding`模板参数是用于指明内存中存储的JSON字符串使用哪种编码。因此通常我们会在此参数中使用`UTF8`、`UTF16`或`UTF32`。如何选择，视乎应用软件所使用的操作系统及其他程序库。例如，Windows API使用UTF-16表示Unicode字符，而多数的Linux发行版本及应用软件则更喜欢UTF-8。
+
+使用UTF-16的DOM声明例子：
+
+~~~~~~~~~~cpp
+typedef GenericDocument<UTF16<> > WDocument;
+typedef GenericValue<UTF16<> > WValue;
+~~~~~~~~~~
+
+可以在[DOM's Encoding](doc/stream.md)一节看到更详细的使用例子。
+
+## 字符类型 {#CharacterType}
+
+从之前的声明中可以看到，每个编码都有一个`CharType`模板参数。这可能比较容易混淆，实际上，每个`CharType`存储一个编码单元，而不是一个字符（码点）。如之前所谈及，在UTF-8中一个码点可能会编码成1至4个编码单元。
+
+对于`UTF16(LE|BE)`及`UTF32(LE|BE)`来说，`CharType`必须分别是一个至少2及4字节的整数类型。
+
+注意C++11新添了`char16_t`及`char32_t`类型，也可分别用于`UTF16`及`UTF32`。
+
+## AutoUTF {#AutoUTF}
+
+上述所介绍的编码都是在编译期静态挷定的。换句话说，使用者必须知道内存或流之中使用了哪种编码。然而，有时候我们可能需要读写不同编码的文件，而且这些编码需要在运行时才能决定。
+
+`AutoUTF`是为此而设计的编码。它根据输入或输出流来选择使用哪种编码。目前它应该与`EncodedInputStream`及`EncodedOutputStream`结合使用。
+
+## ASCII {#ASCII}
+
+虽然JSON标准并未提及[ASCII](http://en.wikipedia.org/wiki/ASCII)，有时候我们希望写入7位的ASCII JSON，以供未能处理UTF-8的应用程序使用。由于任JSON都可以把Unicode字符表示为`\uXXXX`转义序列，JSON总是可用ASCII来编码。
+
+以下的例子把UTF-8的DOM写成ASCII的JSON：
+
+~~~~~~~~~~cpp
+using namespace rapidjson;
+Document d; // UTF8<>
+// ...
+StringBuffer buffer;
+Writer<StringBuffer, Document::EncodingType, ASCII<> > writer(buffer);
+d.Accept(writer);
+std::cout << buffer.GetString();
+~~~~~~~~~~
+
+ASCII可用于输入流。当输入流包含大于127的字节，就会导致`kParseErrorStringInvalidEncoding`错误。
+
+ASCII *不能* 用于内存（`Document`的编码，或`Reader`的目标编码)，因为它不能表示Unicode码点。
+
+# 校验及转码 {#ValidationTranscoding}
+
+当RapidJSON解析一个JSON时，它能校验输入JSON，判断它是否所标明编码的合法序列。要开启此选项，请把`kParseValidateEncodingFlag`加入`parseFlags`模板参数。
+
+若输入编码和输出编码并不相同，`Reader`及`Writer`会算把文本转码。在这种情况下，并不需要`kParseValidateEncodingFlag`，因为它必须解码输入序列。若序列不能被解码，它必然是不合法的。
+
+## 转码器 {#Transcoder}
+
+虽然RapidJSON的编码功能是为JSON解析／生成而设计，使用者也可以“滥用”它们来为非JSON字符串转码。
+
+以下的例子把UTF-8字符串转码成UTF-16：
+
+~~~~~~~~~~cpp
+#include "rapidjson/encodings.h"
+
+using namespace rapidjson;
+
+const char* s = "..."; // UTF-8 string
+StringStream source(s);
+GenericStringBuffer<UTF16<> > target;
+
+bool hasError = false;
+while (source.Peak() != '\0')
+    if (!Transcoder::Transcode<UTF8<>, UTF16<> >(source, target)) {
+        hasError = true;
+        break;
+    }
+
+if (!hasError) {
+    const wchar_t* t = target.GetString();
+    // ...
+}
+~~~~~~~~~~
+
+你也可以用`AutoUTF`及对应的流来在运行时设置内源／目的之编码。
--- a/doc/faq.md
+++ b/doc/faq.md
--- a/doc/faq.zh-cn.md
+++ b/doc/faq.zh-cn.md
--- a/doc/features.md
+++ b/doc/features.md
@@ -15,7 +15,7 @@
 * High performance
 * Use template and inline functions to reduce function call overheads.
 * Internal optimized Grisu2 and floating point parsing implementations.
- * Optional SSE2/SSE4.1 support.
+ * Optional SSE2/SSE4.2 support.

 ## Standard compliance


--- a/doc/features.zh-cn.md
+++ b/doc/features.zh-cn.md
+# 特点
+
+## 总体
+
+* 跨平台
+ * 编译器：Visual Studio、gcc、clang等
+ * 架构：x86、x64、ARM等
+ * 操作系统：Windows、Mac OS X、Linux、iOS、Android等
+* 容易安装
+ * 只有头文件的库。只需把头文件复制至你的项目中。
+* 独立、最小依赖
+ * 不需依赖STL、BOOST等。
+ * 只包含`<cstdio>`, `<cstdlib>`, `<cstring>`, `<inttypes.h>`, `<new>`, `<stdint.h>`。 
+* 没使用C++异常、RTTI
+* 高性能
+ * 使用模版及内联函数去降低函数调用开销。
+ * 内部经优化的Grisu2及浮点数解析实现。
+ * 可选的SSE2/SSE4.2支持。
+
+## 符合标准
+
+* RapidJSON应完全符合RFC4627/ECMA-404标准。
+* 支持Unicod代理对（surrogate pair）。
+* 支持空字符（`"\u0000"`）。
+ * 例如，可以优雅地解析及处理`["Hello\u0000World"]`。含读写字符串长度的API。
+
+## Unicode
+
+* 支持UTF-8、UTF-16、UTF-32编码，包括小端序和大端序。
+ * 这些编码用于输入输出流，以及内存中的表示。
+* 支持从输入流自动检测编码。
+* 内部支持编码的转换。
+ * 例如，你可以读取一个UTF-8文件，让RapidJSON把JSON字符串转换至UTF-16的DOM。
+* 内部支持编码校验。
+ * 例如，你可以读取一个UTF-8文件，让RapidJSON检查是否所有JSON字符串是合法的UTF-8字节序列。
+* 支持自定义的字符类型。
+ * 预设的字符类型是：UTF-8为`char`，UTF-16为`wchar_t`，UTF32为`uint32_t`。
+* 支持自定义的编码。
+
+## API风格
+
+* SAX（Simple API for XML）风格API
+ * 类似于[SAX](http://en.wikipedia.org/wiki/Simple_API_for_XML), RapidJSON提供一个事件循序访问的解析器API（`rapidjson::GenericReader`）。RapidJSON也提供一个生成器API（`rapidjson::Writer`），可以处理相同的事件集合。
+* DOM（Document Object Model）风格API
+ * 类似于HTML／XML的[DOM](http://en.wikipedia.org/wiki/Document_Object_Model)，RapidJSON可把JSON解析至一个DOM表示方式（`rapidjson::GenericDocument`），以方便操作。如有需要，可把DOM转换（stringify）回JSON。
+ * DOM风格API（`rapidjson::GenericDocument`）实际上是由SAX风格API（`rapidjson::GenericReader`）实现的。SAX更快，但有时DOM更易用。用户可根据情况作出选择。
+
+## 解析
+
+* 递归式（预设）及迭代式解析器
+ * 递归式解析器较快，但在极端情况下可出现堆栈溢出。
+ * 迭代式解析器使用自定义的堆栈去维持解析状态。
+* 支持原位（*in situ*）解析。
+ * 把JSON字符串的值解析至原JSON之中，然后让DOM指向那些字符串。
+ * 比常规分析更快：不需字符串的内存分配、不需复制（如字符串不含转义符）、缓存友好。
+* 对于JSON数字类型，支持32-bit/64-bit的有号／无号整数，以及`double`。
+* 错误处理
+ * 支持详尽的解析错误代号。
+ * 支持本地化错误信息。
+
+## DOM (Document)
+
+* RapidJSON在类型转换时会检查数值的范围。
+* 字符串字面量的优化
+ * 只储存指针，不作复制
+* 优化“短”字符串
+ * 在`Value`内储存短字符串，无需额外分配。
+ * 对UTF-8字符串来说，32位架构下可存储最多11字符，64位下15字符。
+* 可选地支持`std::string`（定义`RAPIDJSON_HAS_STDSTRING=1`）
+
+## 生成
+
+* 支持`rapidjson::PrettyWriter`去加入换行及缩进。
+
+## 输入输出流
+
+* 支持`rapidjson::GenericStringBuffer`，把输出的JSON储存于字符串内。
+* 支持`rapidjson::FileReadStream`及`rapidjson::FileWriteStream`，使用`FILE`对象作输入输出。
+* 支持自定义输入输出流。
+
+## 内存
+
+* 最小化DOM的内存开销。
+ * 对大部分32／64位机器而言，每个JSON值只占16或20字节（不包含字符串）。
+* 支持快速的预设分配器。
+ * 它是一个堆栈形式的分配器（顺序分配，不容许单独释放，适合解析过程之用）。
+ * 使用者也可提供一个预分配的缓冲区。（有可能达至无需CRT分配就能解析多个JSON）
+* 支持标准CRT（C-runtime）分配器。
+* 支持自定义分配器。
+
+## 其他
+
+* 一些C++11的支持（可选）
+ * 右值引用（rvalue reference）
+ * `noexcept`修饰符
--- a/doc/internals.md
+++ b/doc/internals.md
--- a/doc/misc/doxygenextra.css
+++ b/doc/misc/doxygenextra.css
@@ -74,6 +74,18 @@ div.toc li {
 	margin-top: 0px;
 }

+.summary {
+	float: none !important;
+	width: auto !important;
+	padding-top: 10px;
+	padding-right: 10px !important;
+}
+
+.summary + .headertitle .title {
+	font-size: 1.5em;
+	line-height: 2.0em;
+}
+
 body h1 {
 	font-size: 2em;
 	line-height: 1.7;
@@ -113,6 +125,7 @@ table.doxtable td, table.doxtable th {
 	background-color: #fff;
 	width: 918px;
 	height: auto !important;
+	margin-left: 270px !important;
 }

 div.contents {
@@ -177,7 +190,8 @@ div.fragment {
 	border-top: 60px solid #2980b9;
 	background-color: #343131;
 	width: 250px !important;
-	position: fixed
+	height: 100% !important;
+	position: fixed;
 }

 #nav-tree

--- a/doc/misc/footer.html
+++ b/doc/misc/footer.html
@@ -7,3 +7,21 @@
  </ul>
 </div>
 <!--END GENERATE_TREEVIEW-->
+<script type="text/javascript">
+    /* * * CONFIGURATION VARIABLES * * */
+    var disqus_shortname = 'rapidjson-doc';
+    
+    /* * * DON'T EDIT BELOW THIS LINE * * */
+    (function() {
+	    var dt = document.createElement('div');
+	    dt.id = "disqus_thread";
+	    (document.getElementsByClassName('contents')[0]).appendChild(dt);
+
+        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
+        dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
+        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
+    })();
+</script>
+
+</body>
+</html>
--- a/doc/performance.md
+++ b/doc/performance.md
 # Performance

-The old performance article for RapidJSON 0.1 is provided [here](https://code.google.com/p/rapidjson/wiki/Performance).
-
-The (third-party) performance tests have been removed from this repository
-and are now part of a dedicated [native JSON benchmark collection] [1].
-
-This file will be updated with a summary of benchmarking results based on
-the above benchmark collection in the future.
+There is a [native JSON benchmark collection] [1] which evaluates speed, memory usage and code size of various operations among 20 JSON libaries.

 [1]: https://github.com/miloyip/nativejson-benchmark

+The old performance article for RapidJSON 0.1 is provided [here](https://code.google.com/p/rapidjson/wiki/Performance).
+
 Additionally, you may refer to the following third-party benchmarks.

 ## Third-party benchmarks

--- a/doc/performance.zh-cn.md
+++ b/doc/performance.zh-cn.md
+# 性能
+
+有一个[native JSON benchmark collection][1]项目，能评估20个JSON库在不同操作下的速度、內存用量及代码大小。
+
+[1]: https://github.com/miloyip/nativejson-benchmark
+
+RapidJSON 0.1版本的性能测试文章位于[这里](https://code.google.com/p/rapidjson/wiki/Performance).
+
+此外，你也可以参考以下这些第三方的评测。
+
+## 第三方评测
+
+* [Basic benchmarks for miscellaneous C++ JSON parsers and generators](https://github.com/mloskot/json_benchmark) by Mateusz Loskot (Jun 2013)
+ * [casablanca](https://casablanca.codeplex.com/)
+ * [json_spirit](https://github.com/cierelabs/json_spirit)
+ * [jsoncpp](http://jsoncpp.sourceforge.net/)
+ * [libjson](http://sourceforge.net/projects/libjson/)
+ * [rapidjson](https://github.com/miloyip/rapidjson/)
+ * [QJsonDocument](http://qt-project.org/doc/qt-5.0/qtcore/qjsondocument.html)
+ 
+* [JSON Parser Benchmarking](http://chadaustin.me/2013/01/json-parser-benchmarking/) by Chad Austin (Jan 2013)
+ * [sajson](https://github.com/chadaustin/sajson)
+ * [rapidjson](https://github.com/miloyip/rapidjson/)
+ * [vjson](https://code.google.com/p/vjson/)
+ * [YAJL](http://lloyd.github.com/yajl/)
+ * [Jansson](http://www.digip.org/jansson/)
--- a/doc/pointer.md
+++ b/doc/pointer.md
+# Pointer
+
+## Status: experimental, shall be included in v1.1
+
+JSON Pointer is a standardized ([RFC6901]) way to select a value inside a JSON Document (DOM). This can be analogous to XPath for XML document. However, JSON Pointer is much simpler, and a single JSON Pointer only pointed to a single value.
+
+Using RapidJSON's implementation of JSON Pointer can simplify some manipulations of the DOM.
+
+[TOC]
+
+# JSON Pointer {#JsonPointer}
+
+A JSON Pointer is a list of zero-to-many tokens, each prefixed by `/`. Each token can be a string or a number. For example, given a JSON:
+~~~javascript
+{
+    "foo" : ["bar", "baz"],
+    "pi" : 3.1416
+}
+~~~
+
+The following JSON Pointers resolve this JSON as:
+
+1. `"/foo"` → `[ "bar", "baz" ]`
+2. `"/foo/0"` → `"bar"`
+3. `"/foo/1"` → `"baz"`
+4. `"/pi"` → `3.1416`
+
+Note that, an empty JSON Pointer `""` (zero token) resolves to the whole JSON.
+
+# Basic Usage {#BasicUsage}
+
+The following example code is self-explanatory.
+
+~~~cpp
+#include "rapidjson/pointer.h"
+
+// ...
+Document d;
+
+// Create DOM by Set()
+Pointer("/project").Set(d, "RapidJSON");
+Pointer("/stars").Set(d, 10);
+
+// { "project" : "RapidJSON", "stars" : 10 }
+
+// Access DOM by Get(). It return nullptr if the value does not exist.
+if (Value* stars = Pointer("/stars").Get(d))
+    stars->SetInt(stars->GetInt() + 1);
+
+// { "project" : "RapidJSON", "stars" : 11 }
+
+// Set() and Create() automatically generate parents if not exist.
+Pointer("/a/b/0").Create(d);
+
+// { "project" : "RapidJSON", "stars" : 11, "a" : { "b" : [ null ] } }
+
+// GetWithDefault() returns reference. And it deep clones the default value.
+Value& hello = Pointer("/hello").GetWithDefault(d, "world");
+
+// { "project" : "RapidJSON", "stars" : 11, "a" : { "b" : [ null ] }, "hello" : "world" }
+
+// Swap() is similar to Set()
+Value x("C++");
+Pointer("/hello").Swap(d, x);
+
+// { "project" : "RapidJSON", "stars" : 11, "a" : { "b" : [ null ] }, "hello" : "C++" }
+// x becomes "world"
+
+// Erase a member or element, return true if the value exists
+bool success = Pointer("/a").Erase(d);
+assert(success);
+
+// { "project" : "RapidJSON", "stars" : 10 }
+~~~
+
+# Helper Functions {#HelperFunctions}
+
+Since object-oriented calling convention may be non-intuitive, RapidJSON also provides helper functions, which just wrap the member functions with free-functions.
+
+The following example does exactly the same as the above one.
+
+~~~cpp
+Document d;
+
+SetValueByPointer(d, "/project", "RapidJSON");
+SetValueByPointer(d, "/stars", 10);
+
+if (Value* stars = GetValueByPointer(d, "/stars"))
+    stars->SetInt(stars->GetInt() + 1);
+
+CreateValueByPointer(d, "/a/b/0");
+
+Value& hello = GetValueByPointerWithDefault(d, "/hello", "world");
+
+Value x("C++");
+SwapValueByPointer(d, "/hello", x);
+
+bool success = EraseValueByPointer(d, "/a");
+assert(success);
+~~~
+
+The conventions are shown here for comparison:
+
+1. `Pointer(source).<Method>(root, ...)`
+2. `<Method>ValueByPointer(root, Pointer(source), ...)`
+3. `<Method>ValueByPointer(root, source, ...)`
+
+# Resolving Pointer {#ResolvingPointer}
+
+`Pointer::Get()` or `GetValueByPointer()` function does not modify the DOM. If the tokens cannot match a value in the DOM, it returns `nullptr`. User can use this to check whether a value exists.
+
+Note that, numerical tokens can represent an array index or member name. The resolving process will match the values according to the types of value.
+
+~~~javascript
+{
+    "0" : 123,
+    "1" : [456]
+}
+~~~
+
+1. `"/0"` → `123`
+2. `"/1/0"` → `456`
+
+The token `"0"` is treated as member name in the first pointer. It is treated as an array index in the second pointer.
+
+The other functions, including `Create()`, `GetWithDefault()`, `Set()` and `Swap()`, will change the DOM. These functions will always succeed. They will create the parent values if they do not exist. If the parent values do not match the tokens, they will also be forced to change their type. Changing the type also mean fully removal of that DOM subtree.
+
+Parsing the above JSON into `d`, 
+
+~~~cpp
+SetValueByPointer(d, "1/a", 789); // { "0" : 123, "1" : { "a" : 789 } }
+~~~
+
+## Resolving Minus Sign Token
+
+Besides, [RFC6901] defines a special token `-` (single minus sign), which represents the pass-the-end element of an array. `Get()` only treats this token as a member name '"-"'. Yet the other functions can resolve this for array, equivalent to calling `Value::PushBack()` to the array.
+
+~~~cpp
+Document d;
+d.Parse("{\"foo\":[123]}");
+SetValueByPointer(d, "/foo/-", 456); // { "foo" : [123, 456] }
+SetValueByPointer(d, "/-", 789);    // { "foo" : [123, 456], "-" : 789 }
+~~~
+
+## Resolving Document and Value
+
+When using `p.Get(root)` or `GetValueByPointer(root, p)`, `root` is a (const) `Value&`. That means, it can be a subtree of the DOM.
+
+The other functions have two groups of signature. One group uses `Document& document` as parameter, another one uses `Value& root`. The first group uses `document.GetAllocator()` for creating values. And the second group needs user to supply an allocator, like the functions in DOM.
+
+All examples above do not require an allocator parameter, because the parameter is a `Document&`. But if you want to resolve a pointer to a subtree. You need to supply it as in the following example:
+
+~~~cpp
+class Person {
+public:
+    Person() {
+        document_ = new Document();
+        // CreateValueByPointer() here no need allocator
+        SetLocation(CreateValueByPointer(*document_, "/residence"), ...);
+        SetLocation(CreateValueByPointer(*document_, "/office"), ...);
+    };
+
+private:
+    void SetLocation(Value& location, const char* country, const char* addresses[2]) {
+        Value::Allocator& a = document_->GetAllocator();
+        // SetValueByPointer() here need allocator
+        SetValueByPointer(location, "/country", country, a);
+        SetValueByPointer(location, "/address/0", address[0], a);
+        SetValueByPointer(location, "/address/1", address[1], a);
+    }
+
+    // ...
+
+    Document* document_;
+};
+~~~
+
+`Erase()` or `EraseValueByPointer()` does not need allocator. And they return `true` if the value is erased successfully.
+
+# Error Handling {#ErrorHandling}
+
+A `Pointer` parses a source string in its constructor. If there is parsing error, `Pointer::IsValid()` returns false. And you can use `Pointer::GetParseErrorCode()` and `GetParseErrorOffset()` to retrieve the error information.
+
+Note that, all resolving functions assumes valid pointer. Resolving with an invalid pointer causes assertion failure.
+
+# URI Fragment Representation {#URIFragment}
+
+In addition to the string representation of JSON pointer that we are using till now, [RFC6901] also defines the URI fragment representation of JSON pointer. URI fragment is specified in [RFC3986] "Uniform Resource Identifier (URI): Generic Syntax".
+
+The main differences are that a the URI fragment always has a `#` (pound sign) in the beginning, and some characters are encoded by percent-encoding in UTF-8 sequence. For example, the following table shows different C/C++ string literals of different representations.
+
+String Representation | URI Fragment Representation | Pointer Tokens (UTF-8)
+----------------------|-----------------------------|------------------------
+`"/foo/0"`            | `"#/foo/0"`                 | `{"foo", 0}`
+`"/a~1b"`             | `"#/a~1b"`                  | `{"a/b"}`
+`"/m~0n"`             | `"#/m~0n"`                  | `{"m~n"}`
+`"/ "`                | `"#/%20"`                   | `{" "}`
+`"/\0"`               | `"#/%00"`                   | `{"\0"}`
+`"/€"`                | `"#/%E2%82%AC"`             | `{"€"}`
+
+RapidJSON fully support URI fragment representation. It automatically detects the pound sign during parsing.
+
+# Stringify
+
+You may also stringify a `Pointer` to a string or other output streams. This can be done by:
+
+~~~
+Pointer p(...);
+StringBuffer sb;
+p.Stringify(sb);
+std::cout << sb.GetString() << std::endl;
+~~~
+
+It can also stringify to URI fragment reprsentation by `StringifyUriFragment()`.
+
+# User-Supplied Tokens {#UserSuppliedTokens}
+
+If a pointer will be resolved multiple times, it should be construct once, and then apply it to different DOMs or in different times. This reduce time and memory allocation for constructing `Pointer` multiple times.
+
+We can go one step further, to completely eliminate the parsing process and dynamic memory allocation, we can establish the token array directly:
+
+~~~cpp
+#define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
+#define INDEX(i) { #i, sizeof(#i) - 1, i }
+
+static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
+static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
+// Equivalent to static const Pointer p("/foo/123");
+~~~
+
+This may be useful for memory constrained systems.
+
+[RFC3986]: https://tools.ietf.org/html/rfc3986
+[RFC6901]: https://tools.ietf.org/html/rfc6901
--- a/doc/sax.zh-cn.md
+++ b/doc/sax.zh-cn.md
--- a/doc/stream.zh-cn.md
+++ b/doc/stream.zh-cn.md
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -2,7 +2,7 @@

 This tutorial introduces the basics of the Document Object Model(DOM) API.

-As shown in [Usage at a glance](readme.md), a JSON can be parsed into DOM, and then the DOM can be queried and modified easily, and finally be converted back to JSON.
+As shown in [Usage at a glance](@ref index), a JSON can be parsed into DOM, and then the DOM can be queried and modified easily, and finally be converted back to JSON.

 [TOC]

@@ -192,7 +192,7 @@ Checking          | Obtaining
 `bool IsNumber()` | N/A
 `bool IsUint()`   | `unsigned GetUint()`
 `bool IsInt()`    | `int GetInt()`
-`bool IsUint64()` | `uint64_t GetUint()`
+`bool IsUint64()` | `uint64_t GetUint64()`
 `bool IsInt64()`  | `int64_t GetInt64()`
 `bool IsDouble()` | `double GetDouble()`

@@ -512,4 +512,4 @@ This tutorial shows the basics of DOM tree query and manipulation. There are sev
 5. [Performance](doc/performance.md) shows some in-house and third-party benchmarks.
 6. [Internals](doc/internals.md) describes some internal designs and techniques of RapidJSON.

-You may also refer to the [FAQ](faq.md), API documentation, examples and unit tests.
+You may also refer to the [FAQ](doc/faq.md), API documentation, examples and unit tests.
--- a/doc/tutorial.zh-cn.md
+++ b/doc/tutorial.zh-cn.md
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
+# Copyright (c) 2011 Milo Yip (miloyip@gmail.com)
+# Copyright (c) 2013 Rafal Jeczalik (rjeczalik@gmail.com)
+# Distributed under the MIT License (see license.txt file)
+
+set(EXAMPLES
+    capitalize
+    condense
+    messagereader
+    pretty
+    prettyauto
+    serialize
+    simpledom
+    simplereader
+    simplewriter
+    tutorial)
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Weffc++ -Wswitch-default")
+elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Weffc++ -Wswitch-default")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
+endif()
+
+foreach (example ${EXAMPLES})
+    add_executable(${example} ${example}/${example}.cpp)
+endforeach()
+
+add_custom_target(examples ALL DEPENDS ${EXAMPLES})
--- a/example/capitalize/capitalize.cpp
+++ b/example/capitalize/capitalize.cpp
-// JSON condenser exmaple
+// JSON condenser example

 // This example parses JSON from stdin with validation, 
 // and re-output the JSON content to stdout with all string capitalized, and without whitespace.

--- a/example/condense/condense.cpp
+++ b/example/condense/condense.cpp
-// JSON condenser exmaple
+// JSON condenser example

 // This example parses JSON text from stdin with validation, 
 // and re-output the JSON content to stdout without whitespace.

--- a/example/messagereader/messagereader.cpp
+++ b/example/messagereader/messagereader.cpp
@@ -54,7 +54,7 @@ struct MessageHandler
    enum State {
        kExpectObjectStart,
        kExpectNameOrObjectEnd,
-        kExpectValue,
+        kExpectValue
    }state_;
    std::string name_;
 };

--- a/example/serialize/serialize.cpp
+++ b/example/serialize/serialize.cpp
@@ -2,7 +2,6 @@
 // This example shows writing JSON string with writer directly.

 #include "rapidjson/prettywriter.h" // for stringify JSON
-#include "rapidjson/filestream.h"   // wrapper of C stream for prettywriter as output
 #include <cstdio>
 #include <string>
 #include <vector>
@@ -144,13 +143,15 @@ int main(int, char*[]) {

    employees.push_back(Employee("Percy TSE", 30, false));

-    FileStream s(stdout);
-    PrettyWriter<FileStream> writer(s);     // Can also use Writer for condensed formatting
+    StringBuffer sb;
+    PrettyWriter<StringBuffer> writer(sb);

    writer.StartArray();
    for (std::vector<Employee>::const_iterator employeeItr = employees.begin(); employeeItr != employees.end(); ++employeeItr)
        employeeItr->Serialize(writer);
    writer.EndArray();

+    puts(sb.GetString());
+
    return 0;
 }
--- a/example/tutorial/tutorial.cpp
+++ b/example/tutorial/tutorial.cpp
@@ -3,7 +3,6 @@

 #include "rapidjson/document.h"     // rapidjson's DOM-style API
 #include "rapidjson/prettywriter.h" // for stringify JSON
-#include "rapidjson/filestream.h"   // wrapper of C stream for prettywriter as output
 #include <cstdio>

 using namespace rapidjson;
@@ -24,12 +23,10 @@ int main(int, char*[]) {
        return 1;
 #else
    // In-situ parsing, decode strings directly in the source string. Source must be string.
-    {
-        char buffer[sizeof(json)];
-        memcpy(buffer, json, sizeof(json));
-        if (document.ParseInsitu(buffer).HasParseError())
-            return 1;
-    }
+    char buffer[sizeof(json)];
+    memcpy(buffer, json, sizeof(json));
+    if (document.ParseInsitu(buffer).HasParseError())
+        return 1;
 #endif

    printf("\nParsing to document succeeded.\n");
@@ -145,9 +142,10 @@ int main(int, char*[]) {
    // 4. Stringify JSON

    printf("\nModified JSON with reformatting:\n");
-    FileStream f(stdout);
-    PrettyWriter<FileStream> writer(f);
+    StringBuffer sb;
+    PrettyWriter<StringBuffer> writer(sb);
    document.Accept(writer);    // Accept() traverses the DOM and generates Handler events.
+    puts(sb.GetString());

    return 0;
 }
--- a/include/rapidjson/allocators.h
+++ b/include/rapidjson/allocators.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ALLOCATORS_H_
 #define RAPIDJSON_ALLOCATORS_H_
@@ -68,8 +62,20 @@ concept Allocator {
 class CrtAllocator {
 public:
    static const bool kNeedFree = true;
-    void* Malloc(size_t size) { return std::malloc(size); }
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { (void)originalSize; return std::realloc(originalPtr, newSize); }
+    void* Malloc(size_t size) { 
+        if (size) //  behavior of malloc(0) is implementation defined.
+            return std::malloc(size);
+        else
+            return NULL; // standardize to returning NULL.
+    }
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        (void)originalSize;
+        if (newSize == 0) {
+            std::free(originalPtr);
+            return NULL;
+        }
+        return std::realloc(originalPtr, newSize);
+    }
    static void Free(void *ptr) { std::free(ptr); }
 };

@@ -166,6 +172,9 @@ public:

    //! Allocates a memory block. (concept Allocator)
    void* Malloc(size_t size) {
+        if (!size)
+            return NULL;
+
        size = RAPIDJSON_ALIGN(size);
        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
            AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size);
@@ -180,6 +189,9 @@ public:
        if (originalPtr == 0)
            return Malloc(newSize);

+        if (newSize == 0)
+            return NULL;
+
        // Do not shrink if new size is smaller than original
        if (originalSize >= newSize)
            return originalPtr;
@@ -197,7 +209,9 @@ public:
        // Realloc process: allocate and copy memory, do not free original buffer.
        void* newBuffer = Malloc(newSize);
        RAPIDJSON_ASSERT(newBuffer != 0);   // Do not handle out-of-memory explicitly.
-        return std::memcpy(newBuffer, originalPtr, originalSize);
+        if (originalSize)
+            std::memcpy(newBuffer, originalPtr, originalSize);
+        return newBuffer;
    }

    //! Frees a memory block (concept Allocator)

--- a/include/rapidjson/document.h
+++ b/include/rapidjson/document.h
--- a/include/rapidjson/encodedstream.h
+++ b/include/rapidjson/encodedstream.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ENCODEDSTREAM_H_
 #define RAPIDJSON_ENCODEDSTREAM_H_
@@ -115,6 +109,7 @@ public:
        \param type UTF encoding type if it is not detected from the stream.
    */
    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
        DetectType();
        static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
        takeFunc_ = f[type_];
@@ -183,21 +178,8 @@ private:
        }

        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-        switch (type_) {
-        case kUTF8:
-            // Do nothing
-            break;
-        case kUTF16LE:
-        case kUTF16BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-            break;
-        case kUTF32LE:
-        case kUTF32BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-            break;
-        default:
-            RAPIDJSON_ASSERT(false);    // Invalid type
-        }
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
    }

    typedef Ch (*TakeFunc)(InputByteStream& is);
@@ -226,22 +208,11 @@ public:
        \param putBOM Whether to write BOM at the beginning of the stream.
    */
    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
-        // RUntime check whether the size of character type is sufficient. It only perform checks with assertion.
-        switch (type_) {
-        case kUTF16LE:
-        case kUTF16BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-            break;
-        case kUTF32LE:
-        case kUTF32BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-            break;
-        case kUTF8:
-            // Do nothing
-            break;
-        default:
-            RAPIDJSON_ASSERT(false);    // Invalid UTFType
-        }
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
+
+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

        static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
        putFunc_ = f[type_];

--- a/include/rapidjson/encodings.h
+++ b/include/rapidjson/encodings.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ENCODINGS_H_
 #define RAPIDJSON_ENCODINGS_H_
@@ -30,6 +24,7 @@ RAPIDJSON_DIAG_OFF(4702)  // unreachable code
 #elif defined(__GNUC__)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(overflow)
 #endif

 RAPIDJSON_NAMESPACE_BEGIN

--- a/include/rapidjson/error/en.h
+++ b/include/rapidjson/error/en.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ERROR_EN_H__
 #define RAPIDJSON_ERROR_EN_H__

--- a/include/rapidjson/error/error.h
+++ b/include/rapidjson/error/error.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ERROR_ERROR_H__
 #define RAPIDJSON_ERROR_ERROR_H__

+#include "../rapidjson.h"
+
 /*! \file error.h */

 /*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
@@ -85,7 +81,7 @@ enum ParseErrorCode {
    kParseErrorNumberMissExponent,              //!< Miss exponent in number.

    kParseErrorTermination,                     //!< Parsing was terminated.
-    kParseErrorUnspecificSyntaxError,           //!< Unspecific syntax error.
+    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
 };

 //! Result of parsing (wraps ParseErrorCode)

--- a/include/rapidjson/filereadstream.h
+++ b/include/rapidjson/filereadstream.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_FILEREADSTREAM_H_
 #define RAPIDJSON_FILEREADSTREAM_H_

--- a/include/rapidjson/filestream.h
+++ b/include/rapidjson/filestream.h
-// Copyright (C) 2011 Milo Yip
-//
-// 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.
-
-#ifndef RAPIDJSON_FILESTREAM_H_
-#define RAPIDJSON_FILESTREAM_H_
-
-#include "rapidjson.h"
-#include <cstdio>
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! (Deprecated) Wrapper of C file stream for input or output.
-/*!
-    This simple wrapper does not check the validity of the stream.
-    \note implements Stream concept
-    \note deprecated: This was only for basic testing in version 0.1, it is found that the performance is very low by using fgetc(). Use FileReadStream instead.
-*/
-class FileStream {
-public:
-    typedef char Ch;    //!< Character type. Only support char.
-
-    FileStream(std::FILE* fp) : fp_(fp), current_('\0'), count_(0) { Read(); }
-    char Peek() const { return current_; }
-    char Take() { char c = current_; Read(); return c; }
-    size_t Tell() const { return count_; }
-    void Put(char c) { fputc(c, fp_); }
-    void Flush() { fflush(fp_); }
-
-    // Not implemented
-    char* PutBegin() { return 0; }
-    size_t PutEnd(char*) { return 0; }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    FileStream(const FileStream&);
-    FileStream& operator=(const FileStream&);
-
-    void Read() {
-        RAPIDJSON_ASSERT(fp_ != 0);
-        int c = fgetc(fp_);
-        if (c != EOF) {
-            current_ = (char)c;
-            count_++;
-        }
-        else if (current_ != '\0')
-            current_ = '\0';
-    }
-
-    std::FILE* fp_;
-    char current_;
-    size_t count_;
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_FILESTREAM_H_
--- a/include/rapidjson/filewritestream.h
+++ b/include/rapidjson/filewritestream.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_FILEWRITESTREAM_H_
 #define RAPIDJSON_FILEWRITESTREAM_H_

--- a/include/rapidjson/internal/biginteger.h
+++ b/include/rapidjson/internal/biginteger.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_BIGINTEGER_H_
 #define RAPIDJSON_BIGINTEGER_H_
@@ -103,7 +97,7 @@ public:
        if (u == 1) return *this;
        if (*this == 1) return *this = u;

-        uint32_t k = 0;
+        uint64_t k = 0;
        for (size_t i = 0; i < count_; i++) {
            const uint64_t c = digits_[i] >> 32;
            const uint64_t d = digits_[i] & 0xFFFFFFFF;
@@ -148,7 +142,7 @@ public:
    }

    bool operator==(const BigInteger& rhs) const {
-        return count_ == rhs.count_ && memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
+        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
    }

    bool operator==(const Type rhs) const {
@@ -172,19 +166,16 @@ public:
        };
        if (exp == 0) return *this;
        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
-        for (; exp >= 13; exp -= 13) *this *= 1220703125u; // 5^13
+        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
        if (exp > 0)                 *this *= kPow5[exp - 1];
        return *this;
    }

    // Compute absolute difference of this and rhs.
-    // Return false if this < rhs
+    // Assume this != rhs
    bool Difference(const BigInteger& rhs, BigInteger* out) const {
        int cmp = Compare(rhs);
-        if (cmp == 0) {
-            *out = BigInteger(0);
-            return false;
-        }
+        RAPIDJSON_ASSERT(cmp != 0);
        const BigInteger *a, *b;  // Makes a > b
        bool ret;
        if (cmp < 0) { a = &rhs; b = this; ret = true; }
@@ -252,9 +243,10 @@ private:
            (*outHigh)++;
        return low;
 #elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p = static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b);
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
        p += k;
-        *outHigh = p >> 64;
+        *outHigh = static_cast<uint64_t>(p >> 64);
        return static_cast<uint64_t>(p);
 #else
        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
@@ -274,12 +266,6 @@ private:
 #endif
    }

-    static Type FullAdd(Type a, Type b, bool inCarry, bool* outCarry) {
-        Type c = a + b + (inCarry ? 1 : 0);
-        *outCarry = c < a;
-        return c;
-    }
-
    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
    static const size_t kCapacity = kBitCount / sizeof(Type);
    static const size_t kTypeBit = sizeof(Type) * 8;

--- a/include/rapidjson/internal/diyfp.h
+++ b/include/rapidjson/internal/diyfp.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 // This is a C++ header-only implementation of Grisu2 algorithm from the publication:
 // Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
@@ -25,12 +19,12 @@
 #ifndef RAPIDJSON_DIYFP_H_
 #define RAPIDJSON_DIYFP_H_

-#if defined(_MSC_VER)
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
 #include <intrin.h>
-#if defined(_M_AMD64)
 #pragma intrinsic(_BitScanReverse64)
 #endif
-#endif

 RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {
@@ -51,7 +45,7 @@ struct DiyFp {
            uint64_t u64;
        } u = { d };

-        int biased_e = (u.u64 & kDpExponentMask) >> kDpSignificandSize;
+        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
        uint64_t significand = (u.u64 & kDpSignificandMask);
        if (biased_e != 0) {
            f = significand + kDpHiddenBit;
@@ -75,8 +69,9 @@ struct DiyFp {
            h++;
        return DiyFp(h, e + rhs.e + 64);
 #elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p = static_cast<unsigned __int128>(f) * static_cast<unsigned __int128>(rhs.f);
-        uint64_t h = p >> 64;
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
+        uint64_t h = static_cast<uint64_t>(p >> 64);
        uint64_t l = static_cast<uint64_t>(p);
        if (l & (uint64_t(1) << 63)) // rounding
            h++;
@@ -140,25 +135,9 @@ struct DiyFp {
            double d;
            uint64_t u64;
        }u;
-        uint64_t significand = f;
-        int exponent = e;
-        while (significand > kDpHiddenBit + kDpSignificandMask) {
-            significand >>= 1;
-            exponent++;
-        }
-        while (exponent > kDpDenormalExponent && (significand & kDpHiddenBit) == 0) {
-            significand <<= 1;
-            exponent--;
-        }
-        if (exponent >= kDpMaxExponent) {
-            u.u64 = kDpExponentMask;    // Infinity
-            return u.d;
-        }
-        else if (exponent < kDpDenormalExponent)
-            return 0.0;
-        const uint64_t be = (exponent == kDpDenormalExponent && (significand & kDpHiddenBit) == 0) ? 0 : 
-            static_cast<uint64_t>(exponent + kDpExponentBias);
-        u.u64 = (significand & kDpSignificandMask) | (be << kDpSignificandSize);
+        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
+            static_cast<uint64_t>(e + kDpExponentBias);
+        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
        return u.d;
    }

@@ -243,7 +222,7 @@ inline DiyFp GetCachedPower(int e, int* K) {
    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
    int k = static_cast<int>(dk);
-    if (k != dk)
+    if (dk - k > 0.0)
        k++;

    unsigned index = static_cast<unsigned>((k >> 3) + 1);

--- a/include/rapidjson/internal/dtoa.h
+++ b/include/rapidjson/internal/dtoa.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 // This is a C++ header-only implementation of Grisu2 algorithm from the publication:
 // Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
@@ -27,6 +21,7 @@

 #include "itoa.h" // GetDigitsLut()
 #include "diyfp.h"
+#include "ieee754.h"

 RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {
@@ -55,8 +50,10 @@ inline unsigned CountDecimalDigit32(uint32_t n) {
    if (n < 1000000) return 6;
    if (n < 10000000) return 7;
    if (n < 100000000) return 8;
-    if (n < 1000000000) return 9;
-    return 10;
+    // Will not reach 10 digits in DigitGen()
+    //if (n < 1000000000) return 9;
+    //return 10;
+    return 9;
 }

 inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
@@ -65,13 +62,12 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
    const DiyFp wp_w = Mp - W;
    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
    uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = CountDecimalDigit32(p1);
+    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
    *len = 0;

    while (kappa > 0) {
-        uint32_t d;
+        uint32_t d = 0;
        switch (kappa) {
-            case 10: d = p1 / 1000000000; p1 %= 1000000000; break;
            case  9: d = p1 /  100000000; p1 %=  100000000; break;
            case  8: d = p1 /   10000000; p1 %=   10000000; break;
            case  7: d = p1 /    1000000; p1 %=    1000000; break;
@@ -81,14 +77,7 @@ inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buff
            case  3: d = p1 /        100; p1 %=        100; break;
            case  2: d = p1 /         10; p1 %=         10; break;
            case  1: d = p1;              p1 =           0; break;
-            default: 
-#if defined(_MSC_VER)
-                __assume(0);
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-                __builtin_unreachable();
-#else
-                d = 0;
-#endif
+            default:;
        }
        if (d || *len)
            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
@@ -198,7 +187,10 @@ inline char* Prettify(char* buffer, int length, int k) {
 }

 inline char* dtoa(double value, char* buffer) {
-    if (value == 0) {
+    Double d(value);
+    if (d.IsZero()) {
+        if (d.Sign())
+            *buffer++ = '-';     // -0.0, Issue #289
        buffer[0] = '0';
        buffer[1] = '.';
        buffer[2] = '0';

--- a/include/rapidjson/internal/ieee754.h
+++ b/include/rapidjson/internal/ieee754.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_IEEE754_
 #define RAPIDJSON_IEEE754_
@@ -29,36 +23,29 @@ namespace internal {
 class Double {
 public:
    Double() {}
-    Double(double d) : d(d) {}
-    Double(uint64_t u) : u(u) {}
+    Double(double d) : d_(d) {}
+    Double(uint64_t u) : u_(u) {}

-    double Value() const { return d; }
-    uint64_t Uint64Value() const { return u; }
+    double Value() const { return d_; }
+    uint64_t Uint64Value() const { return u_; }

    double NextPositiveDouble() const {
        RAPIDJSON_ASSERT(!Sign());
-        return Double(u + 1).Value();
+        return Double(u_ + 1).Value();
    }

-    double PreviousPositiveDouble() const {
-        RAPIDJSON_ASSERT(!Sign());
-        if (d == 0.0)
-            return 0.0;
-        else
-            return Double(u - 1).Value();
-    }
-
-    bool Sign() const { return (u & kSignMask) != 0; }
-    uint64_t Significand() const { return u & kSignificandMask; }
-    int Exponent() const { return ((u & kExponentMask) >> kSignificandSize) - kExponentBias; }
+    bool Sign() const { return (u_ & kSignMask) != 0; }
+    uint64_t Significand() const { return u_ & kSignificandMask; }
+    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }

-    bool IsNan() const { return (u & kExponentMask) == kExponentMask && Significand() != 0; }
-    bool IsInf() const { return (u & kExponentMask) == kExponentMask && Significand() == 0; }
-    bool IsNormal() const { return (u & kExponentMask) != 0 || Significand() == 0; }
+    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
+    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
+    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
+    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }

    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
-    uint64_t ToBias() const { return (u & kSignMask) ? ~u + 1 : u | kSignMask; }
+    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }

    static unsigned EffectiveSignificandSize(int order) {
        if (order >= -1021)
@@ -79,8 +66,8 @@ private:
    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);

    union {
-        double d;
-        uint64_t u;
+        double d_;
+        uint64_t u_;
    };
 };


--- a/include/rapidjson/internal/itoa.h
+++ b/include/rapidjson/internal/itoa.h
-// Copyright (C) 2011 Milo Yip
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
 //
-// 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:
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
 //
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
+// http://opensource.org/licenses/MIT
 //
-// 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.
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.

 #ifndef RAPIDJSON_ITOA_
 #define RAPIDJSON_ITOA_

+#include "../rapidjson.h"
+
 RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {

@@ -115,12 +111,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
 }

 inline char* i32toa(int32_t value, char* buffer) {
+    uint32_t u = static_cast<uint32_t>(value);
    if (value < 0) {
        *buffer++ = '-';
-        value = -value;
+        u = ~u + 1;
    }

-    return u32toa(static_cast<uint32_t>(value), buffer);
+    return u32toa(u, buffer);
 }

 inline char* u64toa(uint64_t value, char* buffer) {
@@ -292,12 +289,13 @@ inline char* u64toa(uint64_t value, char* buffer) {
 }

 inline char* i64toa(int64_t value, char* buffer) {
+    uint64_t u = static_cast<uint64_t>(value);
    if (value < 0) {
        *buffer++ = '-';
-        value = -value;
+        u = ~u + 1;
    }

-    return u64toa(static_cast<uint64_t>(value), buffer);
+    return u64toa(u, buffer);
 }

 } // namespace internal

--- a/include/rapidjson/internal/meta.h
+++ b/include/rapidjson/internal/meta.h
--- a/include/rapidjson/internal/pow10.h
+++ b/include/rapidjson/internal/pow10.h
--- a/include/rapidjson/internal/stack.h
+++ b/include/rapidjson/internal/stack.h
--- a/include/rapidjson/internal/strfunc.h
+++ b/include/rapidjson/internal/strfunc.h
--- a/include/rapidjson/internal/strtod.h
+++ b/include/rapidjson/internal/strtod.h
--- a/include/rapidjson/memorybuffer.h
+++ b/include/rapidjson/memorybuffer.h
--- a/include/rapidjson/memorystream.h
+++ b/include/rapidjson/memorystream.h
--- a/include/rapidjson/msinttypes/inttypes.h
+++ b/include/rapidjson/msinttypes/inttypes.h
@@ -30,6 +30,10 @@
 // 
 ///////////////////////////////////////////////////////////////////////////////

+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
 #ifndef _MSC_VER // [
 #error "Use this header only with Microsoft Visual C++ compilers!"
 #endif // _MSC_VER ]

--- a/include/rapidjson/msinttypes/stdint.h
+++ b/include/rapidjson/msinttypes/stdint.h
--- a/include/rapidjson/pointer.h
+++ b/include/rapidjson/pointer.h
--- a/include/rapidjson/prettywriter.h
+++ b/include/rapidjson/prettywriter.h
--- a/include/rapidjson/rapidjson.h
+++ b/include/rapidjson/rapidjson.h
--- a/include/rapidjson/reader.h
+++ b/include/rapidjson/reader.h
--- a/include/rapidjson/stringbuffer.h
+++ b/include/rapidjson/stringbuffer.h
--- a/include/rapidjson/writer.h
+++ b/include/rapidjson/writer.h
--- a/license.txt
+++ b/license.txt
--- a/readme.md
+++ b/readme.md
--- a/readme.zh-cn.md
+++ b/readme.zh-cn.md
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
--- a/test/perftest/CMakeLists.txt
+++ b/test/perftest/CMakeLists.txt
--- a/test/perftest/misctest.cpp
+++ b/test/perftest/misctest.cpp
--- a/test/perftest/perftest.cpp
+++ b/test/perftest/perftest.cpp
--- a/test/perftest/perftest.h
+++ b/test/perftest/perftest.h
--- a/test/perftest/platformtest.cpp
+++ b/test/perftest/platformtest.cpp
--- a/test/perftest/rapidjsontest.cpp
+++ b/test/perftest/rapidjsontest.cpp
--- a/test/unittest/CMakeLists.txt
+++ b/test/unittest/CMakeLists.txt
--- a/test/unittest/allocatorstest.cpp
+++ b/test/unittest/allocatorstest.cpp
--- a/test/unittest/bigintegertest.cpp
+++ b/test/unittest/bigintegertest.cpp
--- a/test/unittest/documenttest.cpp
+++ b/test/unittest/documenttest.cpp
--- a/test/unittest/encodedstreamtest.cpp
+++ b/test/unittest/encodedstreamtest.cpp
--- a/test/unittest/encodingstest.cpp
+++ b/test/unittest/encodingstest.cpp
--- a/test/unittest/filestreamtest.cpp
+++ b/test/unittest/filestreamtest.cpp
--- a/test/unittest/itoatest.cpp
+++ b/test/unittest/itoatest.cpp
--- a/test/unittest/jsoncheckertest.cpp
+++ b/test/unittest/jsoncheckertest.cpp
--- a/test/unittest/namespacetest.cpp
+++ b/test/unittest/namespacetest.cpp
--- a/test/unittest/pointertest.cpp
+++ b/test/unittest/pointertest.cpp
--- a/test/unittest/prettywritertest.cpp
+++ b/test/unittest/prettywritertest.cpp
--- a/test/unittest/readertest.cpp
+++ b/test/unittest/readertest.cpp
--- a/test/unittest/simdtest.cpp
+++ b/test/unittest/simdtest.cpp
--- a/test/unittest/stringbuffertest.cpp
+++ b/test/unittest/stringbuffertest.cpp
--- a/test/unittest/strtodtest.cpp
+++ b/test/unittest/strtodtest.cpp
--- a/test/unittest/unittest.cpp
+++ b/test/unittest/unittest.cpp
--- a/test/unittest/unittest.h
+++ b/test/unittest/unittest.h
--- a/test/unittest/valuetest.cpp
+++ b/test/unittest/valuetest.cpp
--- a/test/unittest/writertest.cpp
+++ b/test/unittest/writertest.cpp
--- a/build/travis-doxygen.sh
+++ b/build/travis-doxygen.sh