From c7102cfe254439e5b0eeadf38973c9bb1d034532 Mon Sep 17 00:00:00 2001 From: DESKTOP-8BA9KEAgjm Date: Mon, 28 Sep 2026 15:38:57 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=BE=9D=E8=B5=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dep_inc/modernGlue/mg_cgal_export.h | 150 + .../dep_inc/modernGlue/mg_curl_export.h | 55 + .../dep_inc/modernGlue/mg_random_export.h | 21 + SourceCode/dep_inc/rapidjson/allocators.h | 284 ++ .../dep_inc/rapidjson/cursorstreamwrapper.h | 78 + SourceCode/dep_inc/rapidjson/document.h | 2646 +++++++++++++++++ SourceCode/dep_inc/rapidjson/encodedstream.h | 299 ++ SourceCode/dep_inc/rapidjson/encodings.h | 716 +++++ SourceCode/dep_inc/rapidjson/error/en.h | 74 + SourceCode/dep_inc/rapidjson/error/error.h | 161 + SourceCode/dep_inc/rapidjson/filereadstream.h | 99 + .../dep_inc/rapidjson/filewritestream.h | 104 + SourceCode/dep_inc/rapidjson/fwd.h | 151 + .../dep_inc/rapidjson/internal/biginteger.h | 290 ++ SourceCode/dep_inc/rapidjson/internal/diyfp.h | 271 ++ SourceCode/dep_inc/rapidjson/internal/dtoa.h | 245 ++ .../dep_inc/rapidjson/internal/ieee754.h | 78 + SourceCode/dep_inc/rapidjson/internal/itoa.h | 308 ++ SourceCode/dep_inc/rapidjson/internal/meta.h | 186 ++ SourceCode/dep_inc/rapidjson/internal/pow10.h | 55 + SourceCode/dep_inc/rapidjson/internal/regex.h | 732 +++++ SourceCode/dep_inc/rapidjson/internal/stack.h | 231 ++ .../dep_inc/rapidjson/internal/strfunc.h | 69 + .../dep_inc/rapidjson/internal/strtod.h | 290 ++ SourceCode/dep_inc/rapidjson/internal/swap.h | 46 + SourceCode/dep_inc/rapidjson/istreamwrapper.h | 113 + SourceCode/dep_inc/rapidjson/memorybuffer.h | 70 + SourceCode/dep_inc/rapidjson/memorystream.h | 71 + .../dep_inc/rapidjson/msinttypes/inttypes.h | 316 ++ .../dep_inc/rapidjson/msinttypes/stdint.h | 300 ++ SourceCode/dep_inc/rapidjson/ostreamwrapper.h | 81 + SourceCode/dep_inc/rapidjson/pointer.h | 1357 +++++++++ SourceCode/dep_inc/rapidjson/prettywriter.h | 277 ++ SourceCode/dep_inc/rapidjson/rapidjson.h | 654 ++++ SourceCode/dep_inc/rapidjson/reader.h | 2230 ++++++++++++++ SourceCode/dep_inc/rapidjson/schema.h | 2494 ++++++++++++++++ SourceCode/dep_inc/rapidjson/stream.h | 223 ++ SourceCode/dep_inc/rapidjson/stringbuffer.h | 121 + SourceCode/dep_inc/rapidjson/writer.h | 710 +++++ .../dep_lib/modernGlue/debug/ModernGlue.lib | Bin 0 -> 9818 bytes .../dep_lib/modernGlue/release/ModernGlue.lib | Bin 0 -> 9818 bytes .../dep_lib/pub/00003564_000029CA_md.lib | Bin 0 -> 898790 bytes .../dep_lib/pub/00003564_000029CA_md_x64.lib | Bin 0 -> 1433788 bytes SourceCode/dep_lib/pub/Dongle_s_win32.lib | Bin 0 -> 278924 bytes SourceCode/dep_lib/pub/Dongle_s_x64.lib | Bin 0 -> 352066 bytes SourceCode/dep_lib/pub/sqlite3_win32.lib | Bin 0 -> 49320 bytes SourceCode/dep_lib/pub/sqlite3_x64.lib | Bin 0 -> 49152 bytes 47 files changed, 16656 insertions(+) create mode 100644 SourceCode/dep_inc/modernGlue/mg_cgal_export.h create mode 100644 SourceCode/dep_inc/modernGlue/mg_curl_export.h create mode 100644 SourceCode/dep_inc/modernGlue/mg_random_export.h create mode 100644 SourceCode/dep_inc/rapidjson/allocators.h create mode 100644 SourceCode/dep_inc/rapidjson/cursorstreamwrapper.h create mode 100644 SourceCode/dep_inc/rapidjson/document.h create mode 100644 SourceCode/dep_inc/rapidjson/encodedstream.h create mode 100644 SourceCode/dep_inc/rapidjson/encodings.h create mode 100644 SourceCode/dep_inc/rapidjson/error/en.h create mode 100644 SourceCode/dep_inc/rapidjson/error/error.h create mode 100644 SourceCode/dep_inc/rapidjson/filereadstream.h create mode 100644 SourceCode/dep_inc/rapidjson/filewritestream.h create mode 100644 SourceCode/dep_inc/rapidjson/fwd.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/biginteger.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/diyfp.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/dtoa.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/ieee754.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/itoa.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/meta.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/pow10.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/regex.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/stack.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/strfunc.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/strtod.h create mode 100644 SourceCode/dep_inc/rapidjson/internal/swap.h create mode 100644 SourceCode/dep_inc/rapidjson/istreamwrapper.h create mode 100644 SourceCode/dep_inc/rapidjson/memorybuffer.h create mode 100644 SourceCode/dep_inc/rapidjson/memorystream.h create mode 100644 SourceCode/dep_inc/rapidjson/msinttypes/inttypes.h create mode 100644 SourceCode/dep_inc/rapidjson/msinttypes/stdint.h create mode 100644 SourceCode/dep_inc/rapidjson/ostreamwrapper.h create mode 100644 SourceCode/dep_inc/rapidjson/pointer.h create mode 100644 SourceCode/dep_inc/rapidjson/prettywriter.h create mode 100644 SourceCode/dep_inc/rapidjson/rapidjson.h create mode 100644 SourceCode/dep_inc/rapidjson/reader.h create mode 100644 SourceCode/dep_inc/rapidjson/schema.h create mode 100644 SourceCode/dep_inc/rapidjson/stream.h create mode 100644 SourceCode/dep_inc/rapidjson/stringbuffer.h create mode 100644 SourceCode/dep_inc/rapidjson/writer.h create mode 100644 SourceCode/dep_lib/modernGlue/debug/ModernGlue.lib create mode 100644 SourceCode/dep_lib/modernGlue/release/ModernGlue.lib create mode 100644 SourceCode/dep_lib/pub/00003564_000029CA_md.lib create mode 100644 SourceCode/dep_lib/pub/00003564_000029CA_md_x64.lib create mode 100644 SourceCode/dep_lib/pub/Dongle_s_win32.lib create mode 100644 SourceCode/dep_lib/pub/Dongle_s_x64.lib create mode 100644 SourceCode/dep_lib/pub/sqlite3_win32.lib create mode 100644 SourceCode/dep_lib/pub/sqlite3_x64.lib diff --git a/SourceCode/dep_inc/modernGlue/mg_cgal_export.h b/SourceCode/dep_inc/modernGlue/mg_cgal_export.h new file mode 100644 index 0000000..b5f9c24 --- /dev/null +++ b/SourceCode/dep_inc/modernGlue/mg_cgal_export.h @@ -0,0 +1,150 @@ +#pragma once + +#if defined(_WIN32) +#if defined(MODERNGLUE_EXPORTS) +#define GLUE_API __declspec(dllexport) +#else +#define GLUE_API __declspec(dllimport) +#endif +#else +#define GLUE_API +#endif + +namespace _cgal +{ + struct Pt2d + { + double x, y; + }; + + struct Pt3d + { + double x, y, z; + }; + + template + struct CgalArray + { + T *pData; + int count; + }; + + typedef CgalArray Pt2dArr; + typedef CgalArray Pt3dArr; + + // 多边形 + struct Polygon2d + { + Pt2dArr vertices; + }; + + struct Polygon3d + { + Pt3dArr vertices; + }; + + typedef CgalArray Polygon2dList; + typedef CgalArray Polygon3dList; + + // 多边形带泂 polygon with holes + struct Pwh2d + { + Polygon2d outer_boundary; + Polygon2dList inner_holes; + }; + + // 带洞多边形数组 + typedef CgalArray Pwh2dList; + + typedef CgalArray IntArray; + + enum Bounded_side + { + eOutside = -1, + eIsPoint, + eOnside, + eInside, + SIDE_ERROR, + }; +} + +#ifdef __cplusplus +extern "C" +#endif +{ + // 哪个dll申请内存,就在哪个dll内部释放. + // 当 这里的函数以参数的e形式传出了 Pt2dArr 等数据块时,需要调用下面的free函数来释放 + // 当 向这里的接口传入 Pt2dArr 等数据块时, 千万不要调用下面的free函数来释放. + GLUE_API void mg_cgal_free_Pt2dArray(_cgal::Pt2dArr &arr); + GLUE_API void mg_cgal_free_Pt3dArray(_cgal::Pt3dArr &arr); + + GLUE_API void mg_cgal_free_Polygon2d(_cgal::Polygon2d &poly); + GLUE_API void mg_cgal_free_Polygon3d(_cgal::Polygon3d &POly); + + GLUE_API void mg_cgal_free_Polygon2dList(_cgal::Polygon2dList &arr); + GLUE_API void mg_cgal_free_Polygon3dList(_cgal::Polygon3dList &arr); + + GLUE_API void mg_cgal_free_Pwh2d(_cgal::Pwh2d &pwh); + GLUE_API void mg_cgal_free_Pwh2dList(_cgal::Pwh2dList &arr); + + GLUE_API void mg_cgal_free_IntArray(_cgal::IntArray &arr); + + GLUE_API bool mg_cgal_less_xy(const _cgal::Pt2d &pt1, const _cgal::Pt2d &pt2); + GLUE_API bool mg_cgal_less_xyz(const _cgal::Pt3d &pt1, const _cgal::Pt3d &pt2); + /////////////////////////////////////////////////////////////////////////// + + // 对pts做delaunary三角化，并保存成GePolyFaceMesh结构 + GLUE_API void mg_cgal_delaunayTriangulationMesh(const _cgal::Pt3dArr &arPts + , _cgal::Pt3dArr &vertexArray + , _cgal::IntArray &faceArray); + + GLUE_API void mg_cgal_delaunayTriangulationMeshWithHolds(const _cgal::Pt3dArr &arPts + , const _cgal::Polygon3dList &holds + , _cgal::Pt3dArr &vertexArray + , _cgal::IntArray &faceArray); + + // 计算一堆点的凸包曲线 + // 传出是一个point数组，按顺序组成一条polygon + GLUE_API void mg_cgal_calcConvexHull2D_2d_2d(const _cgal::Pt2dArr &arPts, _cgal::Pt2dArr &poly); + + GLUE_API void mg_cgal_calcConvexHull2D_3d_2d(const _cgal::Pt3dArr &arPts, _cgal::Pt2dArr &poly); + + GLUE_API void mg_cgal_calcConvexHull2D_3d_3d(const _cgal::Pt3dArr &arPts, _cgal::Pt3dArr &poly); + + GLUE_API _cgal::Bounded_side mg_cgal_boundary_check(const _cgal::Pt2d &pt, const _cgal::Pwh2d &gepwh); + + GLUE_API bool mg_cgal_is_vaild_polygon_with_hole(const _cgal::Pwh2d &geP); + GLUE_API bool mg_cgal_is_vaild_polygon(const _cgal::Polygon2d &geP); + + GLUE_API bool mg_cgal_is_counterclockwise_with_hole(const _cgal::Pwh2d &geP); + GLUE_API bool mg_cgal_is_counterclockwise(const _cgal::Pt2d &ptS + , const _cgal::Pt2d &ptM + , const _cgal::Pt2d &ptE ); + + GLUE_API bool mg_cgal_is_intersect(const _cgal::Pwh2d &geP, const _cgal::Pwh2d &geQ); + + GLUE_API void mg_cgal_intersect(const _cgal::Pwh2d &geP + , const _cgal::Pwh2d &geQ + , _cgal::Pwh2dList &gepwhlst); + + GLUE_API bool mg_cgal_join(const _cgal::Pwh2d &geP + , const _cgal::Pwh2d &geQ + , _cgal::Pwh2d &gepwh); + + GLUE_API void mg_cgal_difference( const _cgal::Pwh2d &geP + , const _cgal::Pwh2d &geQ + , _cgal::Pwh2dList &gepwhlst); + + GLUE_API void mg_cgal_symmetric_difference( const _cgal::Pwh2d &geP + , const _cgal::Pwh2d &geQ + , _cgal::Pwh2dList &gepwhlst); + + GLUE_API void mg_cgal_sort_xy(const _cgal::Polygon2d &ge, _cgal::Polygon2d &out); + + GLUE_API void mg_cgal_sort_yx(const _cgal::Polygon2d &ge, _cgal::Polygon2d &out); + + GLUE_API void mg_cgal_convexHull2d(const _cgal::Pt2dArr &input, _cgal::Pt2dArr &output); + +#ifdef __cplusplus +} +#endif diff --git a/SourceCode/dep_inc/modernGlue/mg_curl_export.h b/SourceCode/dep_inc/modernGlue/mg_curl_export.h new file mode 100644 index 0000000..8f6406a --- /dev/null +++ b/SourceCode/dep_inc/modernGlue/mg_curl_export.h @@ -0,0 +1,55 @@ +#pragma once + +#if defined(_WIN32) +#if defined(MODERNGLUE_EXPORTS) +#define GLUE_API __declspec(dllexport) +#else +#define GLUE_API __declspec(dllimport) +#endif +#else +#define GLUE_API +#endif + +// 当 DLL 收到网络数据时，通过这个指针回调 ARX +// pData: 接收到的原始字节流（注意：可能不是以 \0 结尾的！） +// length: 字节流的长度 +// pUserData: 用户透传指针（ARX 传什么进来，这里就原样送回去） +typedef size_t(*mg_curl_httpWriteCallback)(const char *pData, size_t length, void *pUserData); + +#ifdef __cplusplus +extern "C" { +#endif + + // 全局初始化（在 ARX 插件加载 acrxEntryPoint 的 Init 阶段调用） + GLUE_API void mg_curl_httpGlobalInit(); + + // 全局清理（在 ARX 插件卸载阶段调用） + GLUE_API void mg_curl_httpGlobalCleanup(); + + // 纯粹的 HTTP POST 接口 + // url: 请求地址 + // headers: 字符串数组，存放请求头 (例如 "Content-Type: application/json") + // headerCount: 请求头的数量 + // body: 准备好的 JSON 字符串 + // cb: ARX 提供的接收数据的回调函数 + // pUserData: ARX 透传的上下文（比如 &response） + // 返回值: CURLcode 对应的整数（0 表示成功） + GLUE_API int mg_curl_httpPost( + const char *url, + const char **headers, + int headerCount, + const char *body, + mg_curl_httpWriteCallback cb, + void *pUserData); + + // 纯粹的 HTTP GET 接口 (用于获取模型列表) + GLUE_API int mg_curl_httpGet( + const char *url, + const char **headers, + int headerCount, + mg_curl_httpWriteCallback cb, + void *pUserData); + +#ifdef __cplusplus +} +#endif diff --git a/SourceCode/dep_inc/modernGlue/mg_random_export.h b/SourceCode/dep_inc/modernGlue/mg_random_export.h new file mode 100644 index 0000000..6dfad09 --- /dev/null +++ b/SourceCode/dep_inc/modernGlue/mg_random_export.h @@ -0,0 +1,21 @@ +#pragma once + +#if defined(_WIN32) +#if defined(MODERNGLUE_EXPORTS) +#define GLUE_API __declspec(dllexport) +#else +#define GLUE_API __declspec(dllimport) +#endif +#else +#define GLUE_API +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + GLUE_API int mg_random_int(const int &min, const int &max); + +#ifdef __cplusplus +} +#endif diff --git a/SourceCode/dep_inc/rapidjson/allocators.h b/SourceCode/dep_inc/rapidjson/allocators.h new file mode 100644 index 0000000..06b3420 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/allocators.h @@ -0,0 +1,284 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Allocator + +/*! \class rapidjson::Allocator + \brief Concept for allocating, resizing and freeing memory block. + + Note that Malloc() and Realloc() are non-static but Free() is static. + + So if an allocator need to support Free(), it needs to put its pointer in + the header of memory block. + +\code +concept Allocator { + static const bool kNeedFree; //!< Whether this allocator needs to call Free(). + + // Allocate a memory block. + // \param size of the memory block in bytes. + // \returns pointer to the memory block. + void* Malloc(size_t size); + + // Resize a memory block. + // \param originalPtr The pointer to current memory block. Null pointer is permitted. + // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.) + // \param newSize the new size in bytes. + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize); + + // Free a memory block. + // \param pointer to the memory block. Null pointer is permitted. + static void Free(void *ptr); +}; +\endcode +*/ + + +/*! \def RAPIDJSON_ALLOCATOR_DEFUALT_CHUNK_CAPACITY + \ingroup RAPIDJSON_CONFIG + \brief User-defined kDefaultChunkCapacity definition. + + User can define this as any \c size that is a power of 2. +*/ + +#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY +#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024) +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// CrtAllocator + +//! C-runtime library allocator. +/*! This class is just wrapper for standard C library memory routines. + \note implements Allocator concept +*/ +class CrtAllocator { +public: + static const bool kNeedFree = true; + 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); } +}; + +/////////////////////////////////////////////////////////////////////////////// +// MemoryPoolAllocator + +//! Default memory allocator used by the parser and DOM. +/*! This allocator allocate memory blocks from pre-allocated memory chunks. + + It does not free memory blocks. And Realloc() only allocate new memory. + + The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default. + + User may also supply a buffer as the first chunk. + + If the user-buffer is full then additional chunks are allocated by BaseAllocator. + + The user-buffer is not deallocated by this allocator. + + \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator. + \note implements Allocator concept +*/ +template +class MemoryPoolAllocator { +public: + static const bool kNeedFree = false; //!< Tell users that no need to call Free() with this allocator. (concept Allocator) + + //! Constructor with chunkSize. + /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. + \param baseAllocator The allocator for allocating memory chunks. + */ + MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : + chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0) + { + } + + //! Constructor with user-supplied buffer. + /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size. + + The user buffer will not be deallocated when this allocator is destructed. + + \param buffer User supplied buffer. + \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader). + \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. + \param baseAllocator The allocator for allocating memory chunks. + */ + MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : + chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0) + { + RAPIDJSON_ASSERT(buffer != 0); + RAPIDJSON_ASSERT(size > sizeof(ChunkHeader)); + chunkHead_ = reinterpret_cast(buffer); + chunkHead_->capacity = size - sizeof(ChunkHeader); + chunkHead_->size = 0; + chunkHead_->next = 0; + } + + //! Destructor. + /*! This deallocates all memory chunks, excluding the user-supplied buffer. + */ + ~MemoryPoolAllocator() { + Clear(); + RAPIDJSON_DELETE(ownBaseAllocator_); + } + + //! Deallocates all memory chunks, excluding the user-supplied buffer. + void Clear() { + while (chunkHead_ && chunkHead_ != userBuffer_) { + ChunkHeader* next = chunkHead_->next; + baseAllocator_->Free(chunkHead_); + chunkHead_ = next; + } + if (chunkHead_ && chunkHead_ == userBuffer_) + chunkHead_->size = 0; // Clear user buffer + } + + //! Computes the total capacity of allocated memory chunks. + /*! \return total capacity in bytes. + */ + size_t Capacity() const { + size_t capacity = 0; + for (ChunkHeader* c = chunkHead_; c != 0; c = c->next) + capacity += c->capacity; + return capacity; + } + + //! Computes the memory blocks allocated. + /*! \return total used bytes. + */ + size_t Size() const { + size_t size = 0; + for (ChunkHeader* c = chunkHead_; c != 0; c = c->next) + size += c->size; + return size; + } + + //! 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) + if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size)) + return NULL; + + void *buffer = reinterpret_cast(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size; + chunkHead_->size += size; + return buffer; + } + + //! Resizes a memory block (concept Allocator) + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { + if (originalPtr == 0) + return Malloc(newSize); + + if (newSize == 0) + return NULL; + + originalSize = RAPIDJSON_ALIGN(originalSize); + newSize = RAPIDJSON_ALIGN(newSize); + + // Do not shrink if new size is smaller than original + if (originalSize >= newSize) + return originalPtr; + + // Simply expand it if it is the last allocation and there is sufficient space + if (originalPtr == reinterpret_cast(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) { + size_t increment = static_cast(newSize - originalSize); + if (chunkHead_->size + increment <= chunkHead_->capacity) { + chunkHead_->size += increment; + return originalPtr; + } + } + + // Realloc process: allocate and copy memory, do not free original buffer. + if (void* newBuffer = Malloc(newSize)) { + if (originalSize) + std::memcpy(newBuffer, originalPtr, originalSize); + return newBuffer; + } + else + return NULL; + } + + //! Frees a memory block (concept Allocator) + static void Free(void *ptr) { (void)ptr; } // Do nothing + +private: + //! Copy constructor is not permitted. + MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */; + //! Copy assignment operator is not permitted. + MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */; + + //! Creates a new chunk. + /*! \param capacity Capacity of the chunk in bytes. + \return true if success. + */ + bool AddChunk(size_t capacity) { + if (!baseAllocator_) + ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)(); + if (ChunkHeader* chunk = reinterpret_cast(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) { + chunk->capacity = capacity; + chunk->size = 0; + chunk->next = chunkHead_; + chunkHead_ = chunk; + return true; + } + else + return false; + } + + static const int kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity. + + //! Chunk header for perpending to each chunk. + /*! Chunks are stored as a singly linked list. + */ + struct ChunkHeader { + size_t capacity; //!< Capacity of the chunk in bytes (excluding the header itself). + size_t size; //!< Current size of allocated memory in bytes. + ChunkHeader *next; //!< Next chunk in the linked list. + }; + + ChunkHeader *chunkHead_; //!< Head of the chunk linked-list. Only the head chunk serves allocation. + size_t chunk_capacity_; //!< The minimum capacity of chunk when they are allocated. + void *userBuffer_; //!< User supplied buffer. + BaseAllocator* baseAllocator_; //!< base allocator for allocating memory chunks. + BaseAllocator* ownBaseAllocator_; //!< base allocator created by this object. +}; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ENCODINGS_H_ diff --git a/SourceCode/dep_inc/rapidjson/cursorstreamwrapper.h b/SourceCode/dep_inc/rapidjson/cursorstreamwrapper.h new file mode 100644 index 0000000..52c11a7 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/cursorstreamwrapper.h @@ -0,0 +1,78 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_CURSORSTREAMWRAPPER_H_ +#define RAPIDJSON_CURSORSTREAMWRAPPER_H_ + +#include "stream.h" + +#if defined(__GNUC__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4702) // unreachable code +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + + +//! Cursor stream wrapper for counting line and column number if error exists. +/*! + \tparam InputStream Any stream that implements Stream Concept +*/ +template > +class CursorStreamWrapper : public GenericStreamWrapper { +public: + typedef typename Encoding::Ch Ch; + + CursorStreamWrapper(InputStream& is): + GenericStreamWrapper(is), line_(1), col_(0) {} + + // counting line and column number + Ch Take() { + Ch ch = this->is_.Take(); + if(ch == '\n') { + line_ ++; + col_ = 0; + } else { + col_ ++; + } + return ch; + } + + //! Get the error line number, if error exists. + size_t GetLine() const { return line_; } + //! Get the error column number, if error exists. + size_t GetColumn() const { return col_; } + +private: + size_t line_; //!< Current Line + size_t col_; //!< Current Column +}; + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_POP +#endif + +#if defined(__GNUC__) +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_ diff --git a/SourceCode/dep_inc/rapidjson/document.h b/SourceCode/dep_inc/rapidjson/document.h new file mode 100644 index 0000000..5e83803 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/document.h @@ -0,0 +1,2646 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_DOCUMENT_H_ +#define RAPIDJSON_DOCUMENT_H_ + +/*! \file document.h */ + +#include "reader.h" +#include "internal/meta.h" +#include "internal/strfunc.h" +#include "memorystream.h" +#include "encodedstream.h" +#include // placement new +#include + +RAPIDJSON_DIAG_PUSH +#ifdef __clang__ +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +RAPIDJSON_DIAG_OFF(c++98-compat) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_OFF(effc++) +#endif // __GNUC__ + +#ifndef RAPIDJSON_NOMEMBERITERATORCLASS +#include // std::random_access_iterator_tag +#endif + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS +#include // std::move +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +// Forward declaration. +template +class GenericValue; + +template +class GenericDocument; + +//! Name-value pair in a JSON object value. +/*! + This class was internal to GenericValue. It used to be a inner struct. + But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct. + https://code.google.com/p/rapidjson/issues/detail?id=64 +*/ +template +struct GenericMember { + GenericValue name; //!< name of member (must be a string) + GenericValue value; //!< value of member. +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericMemberIterator + +#ifndef RAPIDJSON_NOMEMBERITERATORCLASS + +//! (Constant) member iterator for a JSON object value +/*! + \tparam Const Is this a constant iterator? + \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) + \tparam Allocator Allocator type for allocating memory of object, array and string. + + This class implements a Random Access Iterator for GenericMember elements + of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements]. + + \note This iterator implementation is mainly intended to avoid implicit + conversions from iterator values to \c NULL, + e.g. from GenericValue::FindMember. + + \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a + pointer-based implementation, if your platform doesn't provide + the C++ header. + + \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator + */ +template +class GenericMemberIterator { + + friend class GenericValue; + template friend class GenericMemberIterator; + + typedef GenericMember PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + +public: + //! Iterator type itself + typedef GenericMemberIterator Iterator; + //! Constant iterator type + typedef GenericMemberIterator ConstIterator; + //! Non-constant iterator type + typedef GenericMemberIterator NonConstIterator; + + /** \name std::iterator_traits support */ + //@{ + typedef ValueType value_type; + typedef ValueType * pointer; + typedef ValueType & reference; + typedef std::ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + //@} + + //! Pointer to (const) GenericMember + typedef pointer Pointer; + //! Reference to (const) GenericMember + typedef reference Reference; + //! Signed integer type (e.g. \c ptrdiff_t) + typedef difference_type DifferenceType; + + //! Default constructor (singular value) + /*! Creates an iterator pointing to no element. + \note All operations, except for comparisons, are undefined on such values. + */ + GenericMemberIterator() : ptr_() {} + + //! Iterator conversions to more const + /*! + \param it (Non-const) iterator to copy from + + Allows the creation of an iterator from another GenericMemberIterator + that is "less const". Especially, creating a non-constant iterator + from a constant iterator are disabled: + \li const -> non-const (not ok) + \li const -> const (ok) + \li non-const -> const (ok) + \li non-const -> non-const (ok) + + \note If the \c Const template parameter is already \c false, this + constructor effectively defines a regular copy-constructor. + Otherwise, the copy constructor is implicitly defined. + */ + GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {} + Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; } + + //! @name stepping + //@{ + Iterator& operator++(){ ++ptr_; return *this; } + Iterator& operator--(){ --ptr_; return *this; } + Iterator operator++(int){ Iterator old(*this); ++ptr_; return old; } + Iterator operator--(int){ Iterator old(*this); --ptr_; return old; } + //@} + + //! @name increment/decrement + //@{ + Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); } + Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); } + + Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; } + Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; } + //@} + + //! @name relations + //@{ + bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; } + bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; } + bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; } + bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; } + bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; } + bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; } + //@} + + //! @name dereference + //@{ + Reference operator*() const { return *ptr_; } + Pointer operator->() const { return ptr_; } + Reference operator[](DifferenceType n) const { return ptr_[n]; } + //@} + + //! Distance + DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; } + +private: + //! Internal constructor from plain pointer + explicit GenericMemberIterator(Pointer p) : ptr_(p) {} + + Pointer ptr_; //!< raw pointer +}; + +#else // RAPIDJSON_NOMEMBERITERATORCLASS + +// class-based member iterator implementation disabled, use plain pointers + +template +struct GenericMemberIterator; + +//! non-const GenericMemberIterator +template +struct GenericMemberIterator { + //! use plain pointer as iterator type + typedef GenericMember* Iterator; +}; +//! const GenericMemberIterator +template +struct GenericMemberIterator { + //! use plain const pointer as iterator type + typedef const GenericMember* Iterator; +}; + +#endif // RAPIDJSON_NOMEMBERITERATORCLASS + +/////////////////////////////////////////////////////////////////////////////// +// GenericStringRef + +//! Reference to a constant string (not taking a copy) +/*! + \tparam CharType character type of the string + + This helper class is used to automatically infer constant string + references for string literals, especially from \c const \b (!) + character arrays. + + The main use is for creating JSON string values without copying the + source string via an \ref Allocator. This requires that the referenced + string pointers have a sufficient lifetime, which exceeds the lifetime + of the associated GenericValue. + + \b Example + \code + Value v("foo"); // ok, no need to copy & calculate length + const char foo[] = "foo"; + v.SetString(foo); // ok + + const char* bar = foo; + // Value x(bar); // not ok, can't rely on bar's lifetime + Value x(StringRef(bar)); // lifetime explicitly guaranteed by user + Value y(StringRef(bar, 3)); // ok, explicitly pass length + \endcode + + \see StringRef, GenericValue::SetString +*/ +template +struct GenericStringRef { + typedef CharType Ch; //!< character type of the string + + //! Create string reference from \c const character array +#ifndef __clang__ // -Wdocumentation + /*! + This constructor implicitly creates a constant string reference from + a \c const character array. It has better performance than + \ref StringRef(const CharType*) by inferring the string \ref length + from the array length, and also supports strings containing null + characters. + + \tparam N length of the string, automatically inferred + + \param str Constant character array, lifetime assumed to be longer + than the use of the string in e.g. a GenericValue + + \post \ref s == str + + \note Constant complexity. + \note There is a hidden, private overload to disallow references to + non-const character arrays to be created via this constructor. + By this, e.g. function-scope arrays used to be filled via + \c snprintf are excluded from consideration. + In such cases, the referenced string should be \b copied to the + GenericValue instead. + */ +#endif + template + GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT + : s(str), length(N-1) {} + + //! Explicitly create string reference from \c const character pointer +#ifndef __clang__ // -Wdocumentation + /*! + This constructor can be used to \b explicitly create a reference to + a constant string pointer. + + \see StringRef(const CharType*) + + \param str Constant character pointer, lifetime assumed to be longer + than the use of the string in e.g. a GenericValue + + \post \ref s == str + + \note There is a hidden, private overload to disallow references to + non-const character arrays to be created via this constructor. + By this, e.g. function-scope arrays used to be filled via + \c snprintf are excluded from consideration. + In such cases, the referenced string should be \b copied to the + GenericValue instead. + */ +#endif + explicit GenericStringRef(const CharType* str) + : s(str), length(NotNullStrLen(str)) {} + + //! Create constant string reference from pointer and length +#ifndef __clang__ // -Wdocumentation + /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \param len length of the string, excluding the trailing NULL terminator + + \post \ref s == str && \ref length == len + \note Constant complexity. + */ +#endif + GenericStringRef(const CharType* str, SizeType len) + : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { RAPIDJSON_ASSERT(str != 0 || len == 0u); } + + GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {} + + //! implicit conversion to plain CharType pointer + operator const Ch *() const { return s; } + + const Ch* const s; //!< plain CharType pointer + const SizeType length; //!< length of the string (excluding the trailing NULL terminator) + +private: + SizeType NotNullStrLen(const CharType* str) { + RAPIDJSON_ASSERT(str != 0); + return internal::StrLen(str); + } + + /// Empty string - used when passing in a NULL pointer + static const Ch emptyString[]; + + //! Disallow construction from non-const array + template + GenericStringRef(CharType (&str)[N]) /* = delete */; + //! Copy assignment operator not permitted - immutable type + GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */; +}; + +template +const CharType GenericStringRef::emptyString[] = { CharType() }; + +//! Mark a character pointer as constant string +/*! Mark a plain character pointer as a "string literal". This function + can be used to avoid copying a character string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + \tparam CharType Character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \return GenericStringRef string reference object + \relatesalso GenericStringRef + + \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember +*/ +template +inline GenericStringRef StringRef(const CharType* str) { + return GenericStringRef(str); +} + +//! Mark a character pointer as constant string +/*! Mark a plain character pointer as a "string literal". This function + can be used to avoid copying a character string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + + This version has better performance with supplied length, and also + supports string containing null characters. + + \tparam CharType character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \param length The length of source string. + \return GenericStringRef string reference object + \relatesalso GenericStringRef +*/ +template +inline GenericStringRef StringRef(const CharType* str, size_t length) { + return GenericStringRef(str, SizeType(length)); +} + +#if RAPIDJSON_HAS_STDSTRING +//! Mark a string object as constant string +/*! Mark a string object (e.g. \c std::string) as a "string literal". + This function can be used to avoid copying a string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + + \tparam CharType character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \return GenericStringRef string reference object + \relatesalso GenericStringRef + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. +*/ +template +inline GenericStringRef StringRef(const std::basic_string& str) { + return GenericStringRef(str.data(), SizeType(str.size())); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// GenericValue type traits +namespace internal { + +template +struct IsGenericValueImpl : FalseType {}; + +// select candidates according to nested encoding and allocator types +template struct IsGenericValueImpl::Type, typename Void::Type> + : IsBaseOf, T>::Type {}; + +// helper to match arbitrary GenericValue instantiations, including derived classes +template struct IsGenericValue : IsGenericValueImpl::Type {}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// TypeHelper + +namespace internal { + +template +struct TypeHelper {}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsBool(); } + static bool Get(const ValueType& v) { return v.GetBool(); } + static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); } + static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt(); } + static int Get(const ValueType& v) { return v.GetInt(); } + static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); } + static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint(); } + static unsigned Get(const ValueType& v) { return v.GetUint(); } + static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); } + static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); } +}; + +#ifdef _MSC_VER +RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int)); +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt(); } + static long Get(const ValueType& v) { return v.GetInt(); } + static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); } + static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); } +}; + +RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned)); +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint(); } + static unsigned long Get(const ValueType& v) { return v.GetUint(); } + static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); } + static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); } +}; +#endif + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt64(); } + static int64_t Get(const ValueType& v) { return v.GetInt64(); } + static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); } + static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint64(); } + static uint64_t Get(const ValueType& v) { return v.GetUint64(); } + static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); } + static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsDouble(); } + static double Get(const ValueType& v) { return v.GetDouble(); } + static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); } + static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsFloat(); } + static float Get(const ValueType& v) { return v.GetFloat(); } + static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); } + static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); } +}; + +template +struct TypeHelper { + typedef const typename ValueType::Ch* StringType; + static bool Is(const ValueType& v) { return v.IsString(); } + static StringType Get(const ValueType& v) { return v.GetString(); } + static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); } + static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); } +}; + +#if RAPIDJSON_HAS_STDSTRING +template +struct TypeHelper > { + typedef std::basic_string StringType; + static bool Is(const ValueType& v) { return v.IsString(); } + static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); } + static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); } +}; +#endif + +template +struct TypeHelper { + typedef typename ValueType::Array ArrayType; + static bool Is(const ValueType& v) { return v.IsArray(); } + static ArrayType Get(ValueType& v) { return v.GetArray(); } + static ValueType& Set(ValueType& v, ArrayType data) { return v = data; } + static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; } +}; + +template +struct TypeHelper { + typedef typename ValueType::ConstArray ArrayType; + static bool Is(const ValueType& v) { return v.IsArray(); } + static ArrayType Get(const ValueType& v) { return v.GetArray(); } +}; + +template +struct TypeHelper { + typedef typename ValueType::Object ObjectType; + static bool Is(const ValueType& v) { return v.IsObject(); } + static ObjectType Get(ValueType& v) { return v.GetObject(); } + static ValueType& Set(ValueType& v, ObjectType data) { return v = data; } + static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; } +}; + +template +struct TypeHelper { + typedef typename ValueType::ConstObject ObjectType; + static bool Is(const ValueType& v) { return v.IsObject(); } + static ObjectType Get(const ValueType& v) { return v.GetObject(); } +}; + +} // namespace internal + +// Forward declarations +template class GenericArray; +template class GenericObject; + +/////////////////////////////////////////////////////////////////////////////// +// GenericValue + +//! Represents a JSON value. Use Value for UTF8 encoding and default allocator. +/*! + A JSON value can be one of 7 types. This class is a variant type supporting + these types. + + Use the Value if UTF8 and default allocator + + \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) + \tparam Allocator Allocator type for allocating memory of object, array and string. +*/ +template > +class GenericValue { +public: + //! Name-value pair in an object. + typedef GenericMember Member; + typedef Encoding EncodingType; //!< Encoding type from template parameter. + typedef Allocator AllocatorType; //!< Allocator type from template parameter. + typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. + typedef GenericStringRef StringRefType; //!< Reference to a constant string + typedef typename GenericMemberIterator::Iterator MemberIterator; //!< Member iterator for iterating in object. + typedef typename GenericMemberIterator::Iterator ConstMemberIterator; //!< Constant member iterator for iterating in object. + typedef GenericValue* ValueIterator; //!< Value iterator for iterating in array. + typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array. + typedef GenericValue ValueType; //!< Value type of itself. + typedef GenericArray Array; + typedef GenericArray ConstArray; + typedef GenericObject Object; + typedef GenericObject ConstObject; + + //!@name Constructors and destructor. + //@{ + + //! Default constructor creates a null value. + GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) { + rhs.data_.f.flags = kNullFlag; // give up contents + } +#endif + +private: + //! Copy constructor is not permitted. + GenericValue(const GenericValue& rhs); + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Moving from a GenericDocument is not permitted. + template + GenericValue(GenericDocument&& rhs); + + //! Move assignment from a GenericDocument is not permitted. + template + GenericValue& operator=(GenericDocument&& rhs); +#endif + +public: + + //! Constructor with JSON value type. + /*! This creates a Value of specified type with default content. + \param type Type of the value. + \note Default content for number is zero. + */ + explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() { + static const uint16_t defaultFlags[] = { + kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag, + kNumberAnyFlag + }; + RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType); + data_.f.flags = defaultFlags[type]; + + // Use ShortString to store empty string. + if (type == kStringType) + data_.ss.SetLength(0); + } + + //! Explicit copy constructor (with allocator) + /*! Creates a copy of a Value by using the given Allocator + \tparam SourceAllocator allocator of \c rhs + \param rhs Value to copy from (read-only) + \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator(). + \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer) + \see CopyFrom() + */ + template + GenericValue(const GenericValue& rhs, Allocator& allocator, bool copyConstStrings = false) { + switch (rhs.GetType()) { + case kObjectType: { + SizeType count = rhs.data_.o.size; + Member* lm = reinterpret_cast(allocator.Malloc(count * sizeof(Member))); + const typename GenericValue::Member* rm = rhs.GetMembersPointer(); + for (SizeType i = 0; i < count; i++) { + new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings); + new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings); + } + data_.f.flags = kObjectFlag; + data_.o.size = data_.o.capacity = count; + SetMembersPointer(lm); + } + break; + case kArrayType: { + SizeType count = rhs.data_.a.size; + GenericValue* le = reinterpret_cast(allocator.Malloc(count * sizeof(GenericValue))); + const GenericValue* re = rhs.GetElementsPointer(); + for (SizeType i = 0; i < count; i++) + new (&le[i]) GenericValue(re[i], allocator, copyConstStrings); + data_.f.flags = kArrayFlag; + data_.a.size = data_.a.capacity = count; + SetElementsPointer(le); + } + break; + case kStringType: + if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) { + data_.f.flags = rhs.data_.f.flags; + data_ = *reinterpret_cast(&rhs.data_); + } + else + SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator); + break; + default: + data_.f.flags = rhs.data_.f.flags; + data_ = *reinterpret_cast(&rhs.data_); + break; + } + } + + //! Constructor for boolean value. + /*! \param b Boolean value + \note This constructor is limited to \em real boolean values and rejects + implicitly converted types like arbitrary pointers. Use an explicit cast + to \c bool, if you want to construct a boolean JSON value in such cases. + */ +#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen + template + explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame))) RAPIDJSON_NOEXCEPT // See #472 +#else + explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT +#endif + : data_() { + // safe-guard against failing SFINAE + RAPIDJSON_STATIC_ASSERT((internal::IsSame::Value)); + data_.f.flags = b ? kTrueFlag : kFalseFlag; + } + + //! Constructor for int value. + explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() { + data_.n.i64 = i; + data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag; + } + + //! Constructor for unsigned value. + explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() { + data_.n.u64 = u; + data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag); + } + + //! Constructor for int64_t value. + explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() { + data_.n.i64 = i64; + data_.f.flags = kNumberInt64Flag; + if (i64 >= 0) { + data_.f.flags |= kNumberUint64Flag; + if (!(static_cast(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) + data_.f.flags |= kUintFlag; + if (!(static_cast(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + else if (i64 >= static_cast(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + + //! Constructor for uint64_t value. + explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() { + data_.n.u64 = u64; + data_.f.flags = kNumberUint64Flag; + if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000))) + data_.f.flags |= kInt64Flag; + if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) + data_.f.flags |= kUintFlag; + if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + + //! Constructor for double value. + explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; } + + //! Constructor for float value. + explicit GenericValue(float f) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast(f); data_.f.flags = kNumberDoubleFlag; } + + //! Constructor for constant string (i.e. do not make a copy of string) + GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); } + + //! Constructor for constant string (i.e. do not make a copy of string) + explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); } + + //! Constructor for copy-string (i.e. do make a copy of string) + GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); } + + //! Constructor for copy-string (i.e. do make a copy of string) + GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); } + +#if RAPIDJSON_HAS_STDSTRING + //! Constructor for copy-string from a string object (i.e. do make a copy of string) + /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + GenericValue(const std::basic_string& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); } +#endif + + //! Constructor for Array. + /*! + \param a An array obtained by \c GetArray(). + \note \c Array is always pass-by-value. + \note the source array is moved into this value and the sourec array becomes empty. + */ + GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) { + a.value_.data_ = Data(); + a.value_.data_.f.flags = kArrayFlag; + } + + //! Constructor for Object. + /*! + \param o An object obtained by \c GetObject(). + \note \c Object is always pass-by-value. + \note the source object is moved into this value and the sourec object becomes empty. + */ + GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) { + o.value_.data_ = Data(); + o.value_.data_.f.flags = kObjectFlag; + } + + //! Destructor. + /*! Need to destruct elements of array, members of object, or copy-string. + */ + ~GenericValue() { + if (Allocator::kNeedFree) { // Shortcut by Allocator's trait + switch(data_.f.flags) { + case kArrayFlag: + { + GenericValue* e = GetElementsPointer(); + for (GenericValue* v = e; v != e + data_.a.size; ++v) + v->~GenericValue(); + Allocator::Free(e); + } + break; + + case kObjectFlag: + for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) + m->~Member(); + Allocator::Free(GetMembersPointer()); + break; + + case kCopyStringFlag: + Allocator::Free(const_cast(GetStringPointer())); + break; + + default: + break; // Do nothing for other types. + } + } + } + + //@} + + //!@name Assignment operators + //@{ + + //! Assignment with move semantics. + /*! \param rhs Source of the assignment. It will become a null value after assignment. + */ + GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT { + if (RAPIDJSON_LIKELY(this != &rhs)) { + this->~GenericValue(); + RawAssign(rhs); + } + return *this; + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move assignment in C++11 + GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT { + return *this = rhs.Move(); + } +#endif + + //! Assignment of constant string reference (no copy) + /*! \param str Constant string reference to be assigned + \note This overload is needed to avoid clashes with the generic primitive type assignment overload below. + \see GenericStringRef, operator=(T) + */ + GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT { + GenericValue s(str); + return *this = s; + } + + //! Assignment with primitive types. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param value The value to be assigned. + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref SetString(const Ch*, Allocator&) (for copying) or + \ref StringRef() (to explicitly mark the pointer as constant) instead. + All other pointer types would implicitly convert to \c bool, + use \ref SetBool() instead. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer), (GenericValue&)) + operator=(T value) { + GenericValue v(value); + return *this = v; + } + + //! Deep-copy assignment from Value + /*! Assigns a \b copy of the Value to the current Value object + \tparam SourceAllocator Allocator type of \c rhs + \param rhs Value to copy from (read-only) + \param allocator Allocator to use for copying + \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer) + */ + template + GenericValue& CopyFrom(const GenericValue& rhs, Allocator& allocator, bool copyConstStrings = false) { + RAPIDJSON_ASSERT(static_cast(this) != static_cast(&rhs)); + this->~GenericValue(); + new (this) GenericValue(rhs, allocator, copyConstStrings); + return *this; + } + + //! Exchange the contents of this value with those of other. + /*! + \param other Another value. + \note Constant complexity. + */ + GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT { + GenericValue temp; + temp.RawAssign(*this); + RawAssign(other); + other.RawAssign(temp); + return *this; + } + + //! free-standing swap function helper + /*! + Helper function to enable support for common swap implementation pattern based on \c std::swap: + \code + void swap(MyClass& a, MyClass& b) { + using std::swap; + swap(a.value, b.value); + // ... + } + \endcode + \see Swap() + */ + friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } + + //! Prepare Value for move semantics + /*! \return *this */ + GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; } + //@} + + //!@name Equal-to and not-equal-to operators + //@{ + //! Equal-to operator + /*! + \note If an object contains duplicated named member, comparing equality with any object is always \c false. + \note Linear time complexity (number of all values in the subtree and total lengths of all strings). + */ + template + bool operator==(const GenericValue& rhs) const { + typedef GenericValue RhsType; + if (GetType() != rhs.GetType()) + return false; + + switch (GetType()) { + case kObjectType: // Warning: O(n^2) inner-loop + if (data_.o.size != rhs.data_.o.size) + return false; + for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) { + typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name); + if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value) + return false; + } + return true; + + case kArrayType: + if (data_.a.size != rhs.data_.a.size) + return false; + for (SizeType i = 0; i < data_.a.size; i++) + if ((*this)[i] != rhs[i]) + return false; + return true; + + case kStringType: + return StringEqual(rhs); + + case kNumberType: + if (IsDouble() || rhs.IsDouble()) { + double a = GetDouble(); // May convert from integer to double. + double b = rhs.GetDouble(); // Ditto + return a >= b && a <= b; // Prevent -Wfloat-equal + } + else + return data_.n.u64 == rhs.data_.n.u64; + + default: + return true; + } + } + + //! Equal-to operator with const C-string pointer + bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); } + +#if RAPIDJSON_HAS_STDSTRING + //! Equal-to operator with string object + /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + bool operator==(const std::basic_string& rhs) const { return *this == GenericValue(StringRef(rhs)); } +#endif + + //! Equal-to operator with primitive types + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false + */ + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr,internal::IsGenericValue >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); } + + //! Not-equal-to operator + /*! \return !(*this == rhs) + */ + template + bool operator!=(const GenericValue& rhs) const { return !(*this == rhs); } + + //! Not-equal-to operator with const C-string pointer + bool operator!=(const Ch* rhs) const { return !(*this == rhs); } + + //! Not-equal-to operator with arbitrary types + /*! \return !(*this == rhs) + */ + template RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); } + + //! Equal-to operator with arbitrary types (symmetric version) + /*! \return (rhs == lhs) + */ + template friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; } + + //! Not-Equal-to operator with arbitrary types (symmetric version) + /*! \return !(rhs == lhs) + */ + template friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); } + //@} + + //!@name Type + //@{ + + Type GetType() const { return static_cast(data_.f.flags & kTypeMask); } + bool IsNull() const { return data_.f.flags == kNullFlag; } + bool IsFalse() const { return data_.f.flags == kFalseFlag; } + bool IsTrue() const { return data_.f.flags == kTrueFlag; } + bool IsBool() const { return (data_.f.flags & kBoolFlag) != 0; } + bool IsObject() const { return data_.f.flags == kObjectFlag; } + bool IsArray() const { return data_.f.flags == kArrayFlag; } + bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; } + bool IsInt() const { return (data_.f.flags & kIntFlag) != 0; } + bool IsUint() const { return (data_.f.flags & kUintFlag) != 0; } + bool IsInt64() const { return (data_.f.flags & kInt64Flag) != 0; } + bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; } + bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; } + bool IsString() const { return (data_.f.flags & kStringFlag) != 0; } + + // Checks whether a number can be losslessly converted to a double. + bool IsLosslessDouble() const { + if (!IsNumber()) return false; + if (IsUint64()) { + uint64_t u = GetUint64(); + volatile double d = static_cast(u); + return (d >= 0.0) + && (d < static_cast((std::numeric_limits::max)())) + && (u == static_cast(d)); + } + if (IsInt64()) { + int64_t i = GetInt64(); + volatile double d = static_cast(i); + return (d >= static_cast((std::numeric_limits::min)())) + && (d < static_cast((std::numeric_limits::max)())) + && (i == static_cast(d)); + } + return true; // double, int, uint are always lossless + } + + // Checks whether a number is a float (possible lossy). + bool IsFloat() const { + if ((data_.f.flags & kDoubleFlag) == 0) + return false; + double d = GetDouble(); + return d >= -3.4028234e38 && d <= 3.4028234e38; + } + // Checks whether a number can be losslessly converted to a float. + bool IsLosslessFloat() const { + if (!IsNumber()) return false; + double a = GetDouble(); + if (a < static_cast(-(std::numeric_limits::max)()) + || a > static_cast((std::numeric_limits::max)())) + return false; + double b = static_cast(static_cast(a)); + return a >= b && a <= b; // Prevent -Wfloat-equal + } + + //@} + + //!@name Null + //@{ + + GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; } + + //@} + + //!@name Bool + //@{ + + bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; } + //!< Set boolean value + /*! \post IsBool() == true */ + GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; } + + //@} + + //!@name Object + //@{ + + //! Set this value as an empty object. + /*! \post IsObject() == true */ + GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; } + + //! Get the number of members in the object. + SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; } + + //! Get the capacity of object. + SizeType MemberCapacity() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; } + + //! Check whether the object is empty. + bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; } + + //! Get a value from an object associated with the name. + /*! \pre IsObject() == true + \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType)) + \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7. + Since 0.2, if the name is not correct, it will assert. + If user is unsure whether a member exists, user should use HasMember() first. + A better approach is to use FindMember(). + \note Linear time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >),(GenericValue&)) operator[](T* name) { + GenericValue n(StringRef(name)); + return (*this)[n]; + } + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast(*this)[name]; } + + //! Get a value from an object associated with the name. + /*! \pre IsObject() == true + \tparam SourceAllocator Allocator of the \c name value + + \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen(). + And it can also handle strings with embedded null characters. + + \note Linear time complexity. + */ + template + GenericValue& operator[](const GenericValue& name) { + MemberIterator member = FindMember(name); + if (member != MemberEnd()) + return member->value; + else { + RAPIDJSON_ASSERT(false); // see above note + + // This will generate -Wexit-time-destructors in clang + // static GenericValue NullValue; + // return NullValue; + + // Use static buffer and placement-new to prevent destruction + static char buffer[sizeof(GenericValue)]; + return *new (buffer) GenericValue(); + } + } + template + const GenericValue& operator[](const GenericValue& name) const { return const_cast(*this)[name]; } + +#if RAPIDJSON_HAS_STDSTRING + //! Get a value from an object associated with name (string object). + GenericValue& operator[](const std::basic_string& name) { return (*this)[GenericValue(StringRef(name))]; } + const GenericValue& operator[](const std::basic_string& name) const { return (*this)[GenericValue(StringRef(name))]; } +#endif + + //! Const member iterator + /*! \pre IsObject() == true */ + ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); } + //! Const \em past-the-end member iterator + /*! \pre IsObject() == true */ + ConstMemberIterator MemberEnd() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); } + //! Member iterator + /*! \pre IsObject() == true */ + MemberIterator MemberBegin() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); } + //! \em Past-the-end member iterator + /*! \pre IsObject() == true */ + MemberIterator MemberEnd() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); } + + //! Request the object to have enough capacity to store members. + /*! \param newCapacity The capacity that the object at least need to have. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note Linear time complexity. + */ + GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) { + RAPIDJSON_ASSERT(IsObject()); + if (newCapacity > data_.o.capacity) { + SetMembersPointer(reinterpret_cast(allocator.Realloc(GetMembersPointer(), data_.o.capacity * sizeof(Member), newCapacity * sizeof(Member)))); + data_.o.capacity = newCapacity; + } + return *this; + } + + //! Check whether a member exists in the object. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); } + +#if RAPIDJSON_HAS_STDSTRING + //! Check whether a member exists in the object with string object. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + bool HasMember(const std::basic_string& name) const { return FindMember(name) != MemberEnd(); } +#endif + + //! Check whether a member exists in the object with GenericValue name. + /*! + This version is faster because it does not need a StrLen(). It can also handle string with null character. + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + template + bool HasMember(const GenericValue& name) const { return FindMember(name) != MemberEnd(); } + + //! Find member by name. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + + \note Earlier versions of Rapidjson returned a \c NULL pointer, in case + the requested member doesn't exist. For consistency with e.g. + \c std::map, this has been changed to MemberEnd() now. + \note Linear time complexity. + */ + MemberIterator FindMember(const Ch* name) { + GenericValue n(StringRef(name)); + return FindMember(n); + } + + ConstMemberIterator FindMember(const Ch* name) const { return const_cast(*this).FindMember(name); } + + //! Find member by name. + /*! + This version is faster because it does not need a StrLen(). It can also handle string with null character. + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + + \note Earlier versions of Rapidjson returned a \c NULL pointer, in case + the requested member doesn't exist. For consistency with e.g. + \c std::map, this has been changed to MemberEnd() now. + \note Linear time complexity. + */ + template + MemberIterator FindMember(const GenericValue& name) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(name.IsString()); + MemberIterator member = MemberBegin(); + for ( ; member != MemberEnd(); ++member) + if (name.StringEqual(member->name)) + break; + return member; + } + template ConstMemberIterator FindMember(const GenericValue& name) const { return const_cast(*this).FindMember(name); } + +#if RAPIDJSON_HAS_STDSTRING + //! Find member by string object name. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + */ + MemberIterator FindMember(const std::basic_string& name) { return FindMember(GenericValue(StringRef(name))); } + ConstMemberIterator FindMember(const std::basic_string& name) const { return FindMember(GenericValue(StringRef(name))); } +#endif + + //! Add a member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value Value of any type. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note The ownership of \c name and \c value will be transferred to this object on success. + \pre IsObject() && name.IsString() + \post name.IsNull() && value.IsNull() + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(name.IsString()); + + ObjectData& o = data_.o; + if (o.size >= o.capacity) + MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator); + Member* members = GetMembersPointer(); + members[o.size].name.RawAssign(name); + members[o.size].value.RawAssign(value); + o.size++; + return *this; + } + + //! Add a constant string value as member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Add a string object as member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, std::basic_string& value, Allocator& allocator) { + GenericValue v(value, allocator); + return AddMember(name, v, allocator); + } +#endif + + //! Add any primitive value as member (name-value pair) to the object. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param name A string value as name of member. + \param value Value of primitive type \c T as value of member + \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref + AddMember(StringRefType, StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized Constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + AddMember(GenericValue& name, T value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + + + //! Add a member (name-value pair) to the object. + /*! \param name A constant string reference as name of member. + \param value Value of any type. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note The ownership of \c value will be transferred to this object on success. + \pre IsObject() + \post value.IsNull() + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } + + //! Add a constant string value as member (name-value pair) to the object. + /*! \param name A constant string reference as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + + //! Add any primitive value as member (name-value pair) to the object. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param name A constant string reference as name of member. + \param value Value of primitive type \c T as value of member + \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref + AddMember(StringRefType, StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized Constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + AddMember(StringRefType name, T value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } + + //! Remove all members in the object. + /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged. + \note Linear time complexity. + */ + void RemoveAllMembers() { + RAPIDJSON_ASSERT(IsObject()); + for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) + m->~Member(); + data_.o.size = 0; + } + + //! Remove a member in object by its name. + /*! \param name Name of member to be removed. + \return Whether the member existed. + \note This function may reorder the object members. Use \ref + EraseMember(ConstMemberIterator) if you need to preserve the + relative order of the remaining members. + \note Linear time complexity. + */ + bool RemoveMember(const Ch* name) { + GenericValue n(StringRef(name)); + return RemoveMember(n); + } + +#if RAPIDJSON_HAS_STDSTRING + bool RemoveMember(const std::basic_string& name) { return RemoveMember(GenericValue(StringRef(name))); } +#endif + + template + bool RemoveMember(const GenericValue& name) { + MemberIterator m = FindMember(name); + if (m != MemberEnd()) { + RemoveMember(m); + return true; + } + else + return false; + } + + //! Remove a member in object by iterator. + /*! \param m member iterator (obtained by FindMember() or MemberBegin()). + \return the new iterator after removal. + \note This function may reorder the object members. Use \ref + EraseMember(ConstMemberIterator) if you need to preserve the + relative order of the remaining members. + \note Constant time complexity. + */ + MemberIterator RemoveMember(MemberIterator m) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(data_.o.size > 0); + RAPIDJSON_ASSERT(GetMembersPointer() != 0); + RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd()); + + MemberIterator last(GetMembersPointer() + (data_.o.size - 1)); + if (data_.o.size > 1 && m != last) + *m = *last; // Move the last one to this place + else + m->~Member(); // Only one left, just destroy + --data_.o.size; + return m; + } + + //! Remove a member from an object by iterator. + /*! \param pos iterator to the member to remove + \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd() + \return Iterator following the removed element. + If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned. + \note This function preserves the relative order of the remaining object + members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator). + \note Linear time complexity. + */ + MemberIterator EraseMember(ConstMemberIterator pos) { + return EraseMember(pos, pos +1); + } + + //! Remove members in the range [first, last) from an object. + /*! \param first iterator to the first member to remove + \param last iterator following the last member to remove + \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd() + \return Iterator following the last removed element. + \note This function preserves the relative order of the remaining object + members. + \note Linear time complexity. + */ + MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(data_.o.size > 0); + RAPIDJSON_ASSERT(GetMembersPointer() != 0); + RAPIDJSON_ASSERT(first >= MemberBegin()); + RAPIDJSON_ASSERT(first <= last); + RAPIDJSON_ASSERT(last <= MemberEnd()); + + MemberIterator pos = MemberBegin() + (first - MemberBegin()); + for (MemberIterator itr = pos; itr != last; ++itr) + itr->~Member(); + std::memmove(static_cast(&*pos), &*last, static_cast(MemberEnd() - last) * sizeof(Member)); + data_.o.size -= static_cast(last - first); + return pos; + } + + //! Erase a member in object by its name. + /*! \param name Name of member to be removed. + \return Whether the member existed. + \note Linear time complexity. + */ + bool EraseMember(const Ch* name) { + GenericValue n(StringRef(name)); + return EraseMember(n); + } + +#if RAPIDJSON_HAS_STDSTRING + bool EraseMember(const std::basic_string& name) { return EraseMember(GenericValue(StringRef(name))); } +#endif + + template + bool EraseMember(const GenericValue& name) { + MemberIterator m = FindMember(name); + if (m != MemberEnd()) { + EraseMember(m); + return true; + } + else + return false; + } + + Object GetObject() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); } + ConstObject GetObject() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); } + + //@} + + //!@name Array + //@{ + + //! Set this value as an empty array. + /*! \post IsArray == true */ + GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; } + + //! Get the number of elements in array. + SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; } + + //! Get the capacity of array. + SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; } + + //! Check whether the array is empty. + bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; } + + //! Remove all elements in the array. + /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged. + \note Linear time complexity. + */ + void Clear() { + RAPIDJSON_ASSERT(IsArray()); + GenericValue* e = GetElementsPointer(); + for (GenericValue* v = e; v != e + data_.a.size; ++v) + v->~GenericValue(); + data_.a.size = 0; + } + + //! Get an element from array by index. + /*! \pre IsArray() == true + \param index Zero-based index of element. + \see operator[](T*) + */ + GenericValue& operator[](SizeType index) { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(index < data_.a.size); + return GetElementsPointer()[index]; + } + const GenericValue& operator[](SizeType index) const { return const_cast(*this)[index]; } + + //! Element iterator + /*! \pre IsArray() == true */ + ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); } + //! \em Past-the-end element iterator + /*! \pre IsArray() == true */ + ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; } + //! Constant element iterator + /*! \pre IsArray() == true */ + ConstValueIterator Begin() const { return const_cast(*this).Begin(); } + //! Constant \em past-the-end element iterator + /*! \pre IsArray() == true */ + ConstValueIterator End() const { return const_cast(*this).End(); } + + //! Request the array to have enough capacity to store elements. + /*! \param newCapacity The capacity that the array at least need to have. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note Linear time complexity. + */ + GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) { + RAPIDJSON_ASSERT(IsArray()); + if (newCapacity > data_.a.capacity) { + SetElementsPointer(reinterpret_cast(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue)))); + data_.a.capacity = newCapacity; + } + return *this; + } + + //! Append a GenericValue at the end of the array. + /*! \param value Value to be appended. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \post value.IsNull() == true + \return The value itself for fluent API. + \note The ownership of \c value will be transferred to this array on success. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + \note Amortized constant time complexity. + */ + GenericValue& PushBack(GenericValue& value, Allocator& allocator) { + RAPIDJSON_ASSERT(IsArray()); + if (data_.a.size >= data_.a.capacity) + Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator); + GetElementsPointer()[data_.a.size++].RawAssign(value); + return *this; + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericValue& PushBack(GenericValue&& value, Allocator& allocator) { + return PushBack(value, allocator); + } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + + //! Append a constant string reference at the end of the array. + /*! \param value Constant string reference to be appended. + \param allocator Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \return The value itself for fluent API. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + \note Amortized constant time complexity. + \see GenericStringRef + */ + GenericValue& PushBack(StringRefType value, Allocator& allocator) { + return (*this).template PushBack(value, allocator); + } + + //! Append a primitive value at the end of the array. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param value Value of primitive type T to be appended. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \return The value itself for fluent API. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref PushBack(GenericValue&, Allocator&) or \ref + PushBack(StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + PushBack(T value, Allocator& allocator) { + GenericValue v(value); + return PushBack(v, allocator); + } + + //! Remove the last element in the array. + /*! + \note Constant time complexity. + */ + GenericValue& PopBack() { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(!Empty()); + GetElementsPointer()[--data_.a.size].~GenericValue(); + return *this; + } + + //! Remove an element of array by iterator. + /*! + \param pos iterator to the element to remove + \pre IsArray() == true && \ref Begin() <= \c pos < \ref End() + \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned. + \note Linear time complexity. + */ + ValueIterator Erase(ConstValueIterator pos) { + return Erase(pos, pos + 1); + } + + //! Remove elements in the range [first, last) of the array. + /*! + \param first iterator to the first element to remove + \param last iterator following the last element to remove + \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End() + \return Iterator following the last removed element. + \note Linear time complexity. + */ + ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(data_.a.size > 0); + RAPIDJSON_ASSERT(GetElementsPointer() != 0); + RAPIDJSON_ASSERT(first >= Begin()); + RAPIDJSON_ASSERT(first <= last); + RAPIDJSON_ASSERT(last <= End()); + ValueIterator pos = Begin() + (first - Begin()); + for (ValueIterator itr = pos; itr != last; ++itr) + itr->~GenericValue(); + std::memmove(static_cast(pos), last, static_cast(End() - last) * sizeof(GenericValue)); + data_.a.size -= static_cast(last - first); + return pos; + } + + Array GetArray() { RAPIDJSON_ASSERT(IsArray()); return Array(*this); } + ConstArray GetArray() const { RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); } + + //@} + + //!@name Number + //@{ + + int GetInt() const { RAPIDJSON_ASSERT(data_.f.flags & kIntFlag); return data_.n.i.i; } + unsigned GetUint() const { RAPIDJSON_ASSERT(data_.f.flags & kUintFlag); return data_.n.u.u; } + int64_t GetInt64() const { RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; } + uint64_t GetUint64() const { RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; } + + //! Get the value as double type. + /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessDouble() to check whether the converison is lossless. + */ + double GetDouble() const { + RAPIDJSON_ASSERT(IsNumber()); + if ((data_.f.flags & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion. + if ((data_.f.flags & kIntFlag) != 0) return data_.n.i.i; // int -> double + if ((data_.f.flags & kUintFlag) != 0) return data_.n.u.u; // unsigned -> double + if ((data_.f.flags & kInt64Flag) != 0) return static_cast(data_.n.i64); // int64_t -> double (may lose precision) + RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0); return static_cast(data_.n.u64); // uint64_t -> double (may lose precision) + } + + //! Get the value as float type. + /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless. + */ + float GetFloat() const { + return static_cast(GetDouble()); + } + + GenericValue& SetInt(int i) { this->~GenericValue(); new (this) GenericValue(i); return *this; } + GenericValue& SetUint(unsigned u) { this->~GenericValue(); new (this) GenericValue(u); return *this; } + GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; } + GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; } + GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; } + GenericValue& SetFloat(float f) { this->~GenericValue(); new (this) GenericValue(static_cast(f)); return *this; } + + //@} + + //!@name String + //@{ + + const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); } + + //! Get the length of string. + /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength(). + */ + SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); } + + //! Set this value as a string without copying source string. + /*! This version has better performance with supplied length, and also support string containing null character. + \param s source string pointer. + \param length The length of source string, excluding the trailing null terminator. + \return The value itself for fluent API. + \post IsString() == true && GetString() == s && GetStringLength() == length + \see SetString(StringRefType) + */ + GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); } + + //! Set this value as a string without copying source string. + /*! \param s source string reference + \return The value itself for fluent API. + \post IsString() == true && GetString() == s && GetStringLength() == s.length + */ + GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; } + + //! Set this value as a string by copying from source string. + /*! This version has better performance with supplied length, and also support string containing null character. + \param s source string. + \param length The length of source string, excluding the trailing null terminator. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { return SetString(StringRef(s, length), allocator); } + + //! Set this value as a string by copying from source string. + /*! \param s source string. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(StringRef(s), allocator); } + + //! Set this value as a string by copying from source string. + /*! \param s source string reference + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(StringRefType s, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, allocator); return *this; } + +#if RAPIDJSON_HAS_STDSTRING + //! Set this value as a string by copying from source string. + /*! \param s source string. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size() + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + GenericValue& SetString(const std::basic_string& s, Allocator& allocator) { return SetString(StringRef(s), allocator); } +#endif + + //@} + + //!@name Array + //@{ + + //! Templated version for checking whether this value is type T. + /*! + \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c const \c char*, \c std::basic_string + */ + template + bool Is() const { return internal::TypeHelper::Is(*this); } + + template + T Get() const { return internal::TypeHelper::Get(*this); } + + template + T Get() { return internal::TypeHelper::Get(*this); } + + template + ValueType& Set(const T& data) { return internal::TypeHelper::Set(*this, data); } + + template + ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper::Set(*this, data, allocator); } + + //@} + + //! Generate events of this value to a Handler. + /*! This function adopts the GoF visitor pattern. + Typical usage is to output this JSON value as JSON text via Writer, which is a Handler. + It can also be used to deep clone this value via GenericDocument, which is also a Handler. + \tparam Handler type of handler. + \param handler An object implementing concept Handler. + */ + template + bool Accept(Handler& handler) const { + switch(GetType()) { + case kNullType: return handler.Null(); + case kFalseType: return handler.Bool(false); + case kTrueType: return handler.Bool(true); + + case kObjectType: + if (RAPIDJSON_UNLIKELY(!handler.StartObject())) + return false; + for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) { + RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator. + if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0))) + return false; + if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler))) + return false; + } + return handler.EndObject(data_.o.size); + + case kArrayType: + if (RAPIDJSON_UNLIKELY(!handler.StartArray())) + return false; + for (const GenericValue* v = Begin(); v != End(); ++v) + if (RAPIDJSON_UNLIKELY(!v->Accept(handler))) + return false; + return handler.EndArray(data_.a.size); + + case kStringType: + return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0); + + default: + RAPIDJSON_ASSERT(GetType() == kNumberType); + if (IsDouble()) return handler.Double(data_.n.d); + else if (IsInt()) return handler.Int(data_.n.i.i); + else if (IsUint()) return handler.Uint(data_.n.u.u); + else if (IsInt64()) return handler.Int64(data_.n.i64); + else return handler.Uint64(data_.n.u64); + } + } + +private: + template friend class GenericValue; + template friend class GenericDocument; + + enum { + kBoolFlag = 0x0008, + kNumberFlag = 0x0010, + kIntFlag = 0x0020, + kUintFlag = 0x0040, + kInt64Flag = 0x0080, + kUint64Flag = 0x0100, + kDoubleFlag = 0x0200, + kStringFlag = 0x0400, + kCopyFlag = 0x0800, + kInlineStrFlag = 0x1000, + + // Initial flags of different types. + kNullFlag = kNullType, + kTrueFlag = kTrueType | kBoolFlag, + kFalseFlag = kFalseType | kBoolFlag, + kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag, + kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag, + kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag, + kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag, + kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag, + kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag, + kConstStringFlag = kStringType | kStringFlag, + kCopyStringFlag = kStringType | kStringFlag | kCopyFlag, + kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag, + kObjectFlag = kObjectType, + kArrayFlag = kArrayType, + + kTypeMask = 0x07 + }; + + static const SizeType kDefaultArrayCapacity = 16; + static const SizeType kDefaultObjectCapacity = 16; + + struct Flag { +#if RAPIDJSON_48BITPOINTER_OPTIMIZATION + char payload[sizeof(SizeType) * 2 + 6]; // 2 x SizeType + lower 48-bit pointer +#elif RAPIDJSON_64BIT + char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes +#else + char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes +#endif + uint16_t flags; + }; + + struct String { + SizeType length; + SizeType hashcode; //!< reserved + const Ch* str; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars + // (excluding the terminating zero) and store a value to determine the length of the contained + // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string + // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as + // the string terminator as well. For getting the string length back from that value just use + // "MaxSize - str[LenPos]". + // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode, + // 13-chars strings for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings). + struct ShortString { + enum { MaxChars = sizeof(static_cast(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize }; + Ch str[MaxChars]; + + inline static bool Usable(SizeType len) { return (MaxSize >= len); } + inline void SetLength(SizeType len) { str[LenPos] = static_cast(MaxSize - len); } + inline SizeType GetLength() const { return static_cast(MaxSize - str[LenPos]); } + }; // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + // By using proper binary layout, retrieval of different integer types do not need conversions. + union Number { +#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN + struct I { + int i; + char padding[4]; + }i; + struct U { + unsigned u; + char padding2[4]; + }u; +#else + struct I { + char padding[4]; + int i; + }i; + struct U { + char padding2[4]; + unsigned u; + }u; +#endif + int64_t i64; + uint64_t u64; + double d; + }; // 8 bytes + + struct ObjectData { + SizeType size; + SizeType capacity; + Member* members; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + struct ArrayData { + SizeType size; + SizeType capacity; + GenericValue* elements; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + union Data { + String s; + ShortString ss; + Number n; + ObjectData o; + ArrayData a; + Flag f; + }; // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with RAPIDJSON_48BITPOINTER_OPTIMIZATION + + RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return RAPIDJSON_GETPOINTER(Ch, data_.s.str); } + RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); } + RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); } + RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); } + RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); } + RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); } + + // Initialize this value as array with initial data, without calling destructor. + void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) { + data_.f.flags = kArrayFlag; + if (count) { + GenericValue* e = static_cast(allocator.Malloc(count * sizeof(GenericValue))); + SetElementsPointer(e); + std::memcpy(static_cast(e), values, count * sizeof(GenericValue)); + } + else + SetElementsPointer(0); + data_.a.size = data_.a.capacity = count; + } + + //! Initialize this value as object with initial data, without calling destructor. + void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) { + data_.f.flags = kObjectFlag; + if (count) { + Member* m = static_cast(allocator.Malloc(count * sizeof(Member))); + SetMembersPointer(m); + std::memcpy(static_cast(m), members, count * sizeof(Member)); + } + else + SetMembersPointer(0); + data_.o.size = data_.o.capacity = count; + } + + //! Initialize this value as constant string, without calling destructor. + void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT { + data_.f.flags = kConstStringFlag; + SetStringPointer(s); + data_.s.length = s.length; + } + + //! Initialize this value as copy string with initial data, without calling destructor. + void SetStringRaw(StringRefType s, Allocator& allocator) { + Ch* str = 0; + if (ShortString::Usable(s.length)) { + data_.f.flags = kShortStringFlag; + data_.ss.SetLength(s.length); + str = data_.ss.str; + } else { + data_.f.flags = kCopyStringFlag; + data_.s.length = s.length; + str = static_cast(allocator.Malloc((s.length + 1) * sizeof(Ch))); + SetStringPointer(str); + } + std::memcpy(str, s, s.length * sizeof(Ch)); + str[s.length] = '\0'; + } + + //! Assignment without calling destructor + void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT { + data_ = rhs.data_; + // data_.f.flags = rhs.data_.f.flags; + rhs.data_.f.flags = kNullFlag; + } + + template + bool StringEqual(const GenericValue& rhs) const { + RAPIDJSON_ASSERT(IsString()); + RAPIDJSON_ASSERT(rhs.IsString()); + + const SizeType len1 = GetStringLength(); + const SizeType len2 = rhs.GetStringLength(); + if(len1 != len2) { return false; } + + const Ch* const str1 = GetString(); + const Ch* const str2 = rhs.GetString(); + if(str1 == str2) { return true; } // fast path for constant string + + return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0); + } + + Data data_; +}; + +//! GenericValue with UTF8 encoding +typedef GenericValue > Value; + +/////////////////////////////////////////////////////////////////////////////// +// GenericDocument + +//! A document for parsing JSON text as DOM. +/*! + \note implements Handler concept + \tparam Encoding Encoding for both parsing and string storage. + \tparam Allocator Allocator for allocating memory for the DOM + \tparam StackAllocator Allocator for allocating memory for stack during parsing. + \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor. To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue. +*/ +template , typename StackAllocator = CrtAllocator> +class GenericDocument : public GenericValue { +public: + typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. + typedef GenericValue ValueType; //!< Value type of the document. + typedef Allocator AllocatorType; //!< Allocator type from template parameter. + + //! Constructor + /*! Creates an empty document of specified type. + \param type Mandatory type of object to create. + \param allocator Optional allocator for allocating memory. + \param stackCapacity Optional initial capacity of stack in bytes. + \param stackAllocator Optional allocator for allocating memory for stack. + */ + explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : + GenericValue(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_() + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + } + + //! Constructor + /*! Creates an empty document which type is Null. + \param allocator Optional allocator for allocating memory. + \param stackCapacity Optional initial capacity of stack in bytes. + \param stackAllocator Optional allocator for allocating memory for stack. + */ + GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : + allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_() + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT + : ValueType(std::forward(rhs)), // explicit cast to avoid prohibited move from Document + allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + stack_(std::move(rhs.stack_)), + parseResult_(rhs.parseResult_) + { + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.parseResult_ = ParseResult(); + } +#endif + + ~GenericDocument() { + Destroy(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move assignment in C++11 + GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT + { + // The cast to ValueType is necessary here, because otherwise it would + // attempt to call GenericValue's templated assignment operator. + ValueType::operator=(std::forward(rhs)); + + // Calling the destructor here would prematurely call stack_'s destructor + Destroy(); + + allocator_ = rhs.allocator_; + ownAllocator_ = rhs.ownAllocator_; + stack_ = std::move(rhs.stack_); + parseResult_ = rhs.parseResult_; + + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.parseResult_ = ParseResult(); + + return *this; + } +#endif + + //! Exchange the contents of this document with those of another. + /*! + \param rhs Another document. + \note Constant complexity. + \see GenericValue::Swap + */ + GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT { + ValueType::Swap(rhs); + stack_.Swap(rhs.stack_); + internal::Swap(allocator_, rhs.allocator_); + internal::Swap(ownAllocator_, rhs.ownAllocator_); + internal::Swap(parseResult_, rhs.parseResult_); + return *this; + } + + // Allow Swap with ValueType. + // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names. + using ValueType::Swap; + + //! free-standing swap function helper + /*! + Helper function to enable support for common swap implementation pattern based on \c std::swap: + \code + void swap(MyClass& a, MyClass& b) { + using std::swap; + swap(a.doc, b.doc); + // ... + } + \endcode + \see Swap() + */ + friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } + + //! Populate this document by a generator which produces SAX events. + /*! \tparam Generator A functor with bool f(Handler) prototype. + \param g Generator functor which sends SAX events to the parameter. + \return The document itself for fluent API. + */ + template + GenericDocument& Populate(Generator& g) { + ClearStackOnExit scope(*this); + if (g(*this)) { + RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object + ValueType::operator=(*stack_.template Pop(1));// Move value from stack to document + } + return *this; + } + + //!@name Parse from stream + //!@{ + + //! Parse JSON text from an input stream (with Encoding conversion) + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam SourceEncoding Encoding of input stream + \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + GenericReader reader( + stack_.HasAllocator() ? &stack_.GetAllocator() : 0); + ClearStackOnExit scope(*this); + parseResult_ = reader.template Parse(is, *this); + if (parseResult_) { + RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object + ValueType::operator=(*stack_.template Pop(1));// Move value from stack to document + } + return *this; + } + + //! Parse JSON text from an input stream + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + return ParseStream(is); + } + + //! Parse JSON text from an input stream (with \ref kParseDefaultFlags) + /*! \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + return ParseStream(is); + } + //!@} + + //!@name Parse in-place from mutable string + //!@{ + + //! Parse JSON text from a mutable string + /*! \tparam parseFlags Combination of \ref ParseFlag. + \param str Mutable zero-terminated string to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseInsitu(Ch* str) { + GenericInsituStringStream s(str); + return ParseStream(s); + } + + //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags) + /*! \param str Mutable zero-terminated string to be parsed. + \return The document itself for fluent API. + */ + GenericDocument& ParseInsitu(Ch* str) { + return ParseInsitu(str); + } + //!@} + + //!@name Parse from read-only string + //!@{ + + //! Parse JSON text from a read-only string (with Encoding conversion) + /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). + \tparam SourceEncoding Transcoding from input Encoding + \param str Read-only zero-terminated string to be parsed. + */ + template + GenericDocument& Parse(const typename SourceEncoding::Ch* str) { + RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); + GenericStringStream s(str); + return ParseStream(s); + } + + //! Parse JSON text from a read-only string + /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). + \param str Read-only zero-terminated string to be parsed. + */ + template + GenericDocument& Parse(const Ch* str) { + return Parse(str); + } + + //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags) + /*! \param str Read-only zero-terminated string to be parsed. + */ + GenericDocument& Parse(const Ch* str) { + return Parse(str); + } + + template + GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) { + RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); + MemoryStream ms(reinterpret_cast(str), length * sizeof(typename SourceEncoding::Ch)); + EncodedInputStream is(ms); + ParseStream(is); + return *this; + } + + template + GenericDocument& Parse(const Ch* str, size_t length) { + return Parse(str, length); + } + + GenericDocument& Parse(const Ch* str, size_t length) { + return Parse(str, length); + } + +#if RAPIDJSON_HAS_STDSTRING + template + GenericDocument& Parse(const std::basic_string& str) { + // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t) + return Parse(str.c_str()); + } + + template + GenericDocument& Parse(const std::basic_string& str) { + return Parse(str.c_str()); + } + + GenericDocument& Parse(const std::basic_string& str) { + return Parse(str); + } +#endif // RAPIDJSON_HAS_STDSTRING + + //!@} + + //!@name Handling parse errors + //!@{ + + //! Whether a parse error has occurred in the last parsing. + bool HasParseError() const { return parseResult_.IsError(); } + + //! Get the \ref ParseErrorCode of last parsing. + ParseErrorCode GetParseError() const { return parseResult_.Code(); } + + //! Get the position of last parsing error in input, 0 otherwise. + size_t GetErrorOffset() const { return parseResult_.Offset(); } + + //! Implicit conversion to get the last parse result +#ifndef __clang // -Wdocumentation + /*! \return \ref ParseResult of the last parse operation + + \code + Document doc; + ParseResult ok = doc.Parse(json); + if (!ok) + printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset()); + \endcode + */ +#endif + operator ParseResult() const { return parseResult_; } + //!@} + + //! Get the allocator of this document. + Allocator& GetAllocator() { + RAPIDJSON_ASSERT(allocator_); + return *allocator_; + } + + //! Get the capacity of stack in bytes. + size_t GetStackCapacity() const { return stack_.GetCapacity(); } + +private: + // clear stack on any exit from ParseStream, e.g. due to exception + struct ClearStackOnExit { + explicit ClearStackOnExit(GenericDocument& d) : d_(d) {} + ~ClearStackOnExit() { d_.ClearStack(); } + private: + ClearStackOnExit(const ClearStackOnExit&); + ClearStackOnExit& operator=(const ClearStackOnExit&); + GenericDocument& d_; + }; + + // callers of the following private Handler functions + // template friend class GenericReader; // for parsing + template friend class GenericValue; // for deep copying + +public: + // Implementation of Handler + bool Null() { new (stack_.template Push()) ValueType(); return true; } + bool Bool(bool b) { new (stack_.template Push()) ValueType(b); return true; } + bool Int(int i) { new (stack_.template Push()) ValueType(i); return true; } + bool Uint(unsigned i) { new (stack_.template Push()) ValueType(i); return true; } + bool Int64(int64_t i) { new (stack_.template Push()) ValueType(i); return true; } + bool Uint64(uint64_t i) { new (stack_.template Push()) ValueType(i); return true; } + bool Double(double d) { new (stack_.template Push()) ValueType(d); return true; } + + bool RawNumber(const Ch* str, SizeType length, bool copy) { + if (copy) + new (stack_.template Push()) ValueType(str, length, GetAllocator()); + else + new (stack_.template Push()) ValueType(str, length); + return true; + } + + bool String(const Ch* str, SizeType length, bool copy) { + if (copy) + new (stack_.template Push()) ValueType(str, length, GetAllocator()); + else + new (stack_.template Push()) ValueType(str, length); + return true; + } + + bool StartObject() { new (stack_.template Push()) ValueType(kObjectType); return true; } + + bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); } + + bool EndObject(SizeType memberCount) { + typename ValueType::Member* members = stack_.template Pop(memberCount); + stack_.template Top()->SetObjectRaw(members, memberCount, GetAllocator()); + return true; + } + + bool StartArray() { new (stack_.template Push()) ValueType(kArrayType); return true; } + + bool EndArray(SizeType elementCount) { + ValueType* elements = stack_.template Pop(elementCount); + stack_.template Top()->SetArrayRaw(elements, elementCount, GetAllocator()); + return true; + } + +private: + //! Prohibit copying + GenericDocument(const GenericDocument&); + //! Prohibit assignment + GenericDocument& operator=(const GenericDocument&); + + void ClearStack() { + if (Allocator::kNeedFree) + while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects) + (stack_.template Pop(1))->~ValueType(); + else + stack_.Clear(); + stack_.ShrinkToFit(); + } + + void Destroy() { + RAPIDJSON_DELETE(ownAllocator_); + } + + static const size_t kDefaultStackCapacity = 1024; + Allocator* allocator_; + Allocator* ownAllocator_; + internal::Stack stack_; + ParseResult parseResult_; +}; + +//! GenericDocument with UTF8 encoding +typedef GenericDocument > Document; + +//! Helper class for accessing Value of array type. +/*! + Instance of this helper class is obtained by \c GenericValue::GetArray(). + In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1. +*/ +template +class GenericArray { +public: + typedef GenericArray ConstArray; + typedef GenericArray Array; + typedef ValueT PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + typedef ValueType* ValueIterator; // This may be const or non-const iterator + typedef const ValueT* ConstValueIterator; + typedef typename ValueType::AllocatorType AllocatorType; + typedef typename ValueType::StringRefType StringRefType; + + template + friend class GenericValue; + + GenericArray(const GenericArray& rhs) : value_(rhs.value_) {} + GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; } + ~GenericArray() {} + + SizeType Size() const { return value_.Size(); } + SizeType Capacity() const { return value_.Capacity(); } + bool Empty() const { return value_.Empty(); } + void Clear() const { value_.Clear(); } + ValueType& operator[](SizeType index) const { return value_[index]; } + ValueIterator Begin() const { return value_.Begin(); } + ValueIterator End() const { return value_.End(); } + GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; } + GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (const GenericArray&)) PushBack(T value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } + GenericArray PopBack() const { value_.PopBack(); return *this; } + ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); } + ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); } + +#if RAPIDJSON_HAS_CXX11_RANGE_FOR + ValueIterator begin() const { return value_.Begin(); } + ValueIterator end() const { return value_.End(); } +#endif + +private: + GenericArray(); + GenericArray(ValueType& value) : value_(value) {} + ValueType& value_; +}; + +//! Helper class for accessing Value of object type. +/*! + Instance of this helper class is obtained by \c GenericValue::GetObject(). + In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1. +*/ +template +class GenericObject { +public: + typedef GenericObject ConstObject; + typedef GenericObject Object; + typedef ValueT PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + typedef GenericMemberIterator MemberIterator; // This may be const or non-const iterator + typedef GenericMemberIterator ConstMemberIterator; + typedef typename ValueType::AllocatorType AllocatorType; + typedef typename ValueType::StringRefType StringRefType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename ValueType::Ch Ch; + + template + friend class GenericValue; + + GenericObject(const GenericObject& rhs) : value_(rhs.value_) {} + GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; } + ~GenericObject() {} + + SizeType MemberCount() const { return value_.MemberCount(); } + SizeType MemberCapacity() const { return value_.MemberCapacity(); } + bool ObjectEmpty() const { return value_.ObjectEmpty(); } + template ValueType& operator[](T* name) const { return value_[name]; } + template ValueType& operator[](const GenericValue& name) const { return value_[name]; } +#if RAPIDJSON_HAS_STDSTRING + ValueType& operator[](const std::basic_string& name) const { return value_[name]; } +#endif + MemberIterator MemberBegin() const { return value_.MemberBegin(); } + MemberIterator MemberEnd() const { return value_.MemberEnd(); } + GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; } + bool HasMember(const Ch* name) const { return value_.HasMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool HasMember(const std::basic_string& name) const { return value_.HasMember(name); } +#endif + template bool HasMember(const GenericValue& name) const { return value_.HasMember(name); } + MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); } + template MemberIterator FindMember(const GenericValue& name) const { return value_.FindMember(name); } +#if RAPIDJSON_HAS_STDSTRING + MemberIterator FindMember(const std::basic_string& name) const { return value_.FindMember(name); } +#endif + GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#if RAPIDJSON_HAS_STDSTRING + GenericObject AddMember(ValueType& name, std::basic_string& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#endif + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + void RemoveAllMembers() { value_.RemoveAllMembers(); } + bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool RemoveMember(const std::basic_string& name) const { return value_.RemoveMember(name); } +#endif + template bool RemoveMember(const GenericValue& name) const { return value_.RemoveMember(name); } + MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); } + MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); } + MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); } + bool EraseMember(const Ch* name) const { return value_.EraseMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool EraseMember(const std::basic_string& name) const { return EraseMember(ValueType(StringRef(name))); } +#endif + template bool EraseMember(const GenericValue& name) const { return value_.EraseMember(name); } + +#if RAPIDJSON_HAS_CXX11_RANGE_FOR + MemberIterator begin() const { return value_.MemberBegin(); } + MemberIterator end() const { return value_.MemberEnd(); } +#endif + +private: + GenericObject(); + GenericObject(ValueType& value) : value_(value) {} + ValueType& value_; +}; + +RAPIDJSON_NAMESPACE_END +RAPIDJSON_DIAG_POP + +#endif // RAPIDJSON_DOCUMENT_H_ diff --git a/SourceCode/dep_inc/rapidjson/encodedstream.h b/SourceCode/dep_inc/rapidjson/encodedstream.h new file mode 100644 index 0000000..223601c --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/encodedstream.h @@ -0,0 +1,299 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "stream.h" +#include "memorystream.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Input byte stream wrapper with a statically bound encoding. +/*! + \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE. + \tparam InputByteStream Type of input byte stream. For example, FileReadStream. +*/ +template +class EncodedInputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); +public: + typedef typename Encoding::Ch Ch; + + EncodedInputStream(InputByteStream& is) : is_(is) { + current_ = Encoding::TakeBOM(is_); + } + + Ch Peek() const { return current_; } + Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; } + size_t Tell() const { return is_.Tell(); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + EncodedInputStream(const EncodedInputStream&); + EncodedInputStream& operator=(const EncodedInputStream&); + + InputByteStream& is_; + Ch current_; +}; + +//! Specialized for UTF8 MemoryStream. +template <> +class EncodedInputStream, MemoryStream> { +public: + typedef UTF8<>::Ch Ch; + + EncodedInputStream(MemoryStream& is) : is_(is) { + if (static_cast(is_.Peek()) == 0xEFu) is_.Take(); + if (static_cast(is_.Peek()) == 0xBBu) is_.Take(); + if (static_cast(is_.Peek()) == 0xBFu) is_.Take(); + } + Ch Peek() const { return is_.Peek(); } + Ch Take() { return is_.Take(); } + size_t Tell() const { return is_.Tell(); } + + // Not implemented + void Put(Ch) {} + void Flush() {} + Ch* PutBegin() { return 0; } + size_t PutEnd(Ch*) { return 0; } + + MemoryStream& is_; + +private: + EncodedInputStream(const EncodedInputStream&); + EncodedInputStream& operator=(const EncodedInputStream&); +}; + +//! Output byte stream wrapper with statically bound encoding. +/*! + \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE. + \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream. +*/ +template +class EncodedOutputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); +public: + typedef typename Encoding::Ch Ch; + + EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { + if (putBOM) + Encoding::PutBOM(os_); + } + + void Put(Ch c) { Encoding::Put(os_, c); } + void Flush() { os_.Flush(); } + + // Not implemented + Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;} + Ch Take() { RAPIDJSON_ASSERT(false); return 0;} + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + EncodedOutputStream(const EncodedOutputStream&); + EncodedOutputStream& operator=(const EncodedOutputStream&); + + OutputByteStream& os_; +}; + +#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8::x, UTF16LE::x, UTF16BE::x, UTF32LE::x, UTF32BE::x + +//! Input stream wrapper with dynamically bound encoding and automatic encoding detection. +/*! + \tparam CharType Type of character for reading. + \tparam InputByteStream type of input byte stream to be wrapped. +*/ +template +class AutoUTFInputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); +public: + typedef CharType Ch; + + //! Constructor. + /*! + \param is input stream to be wrapped. + \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_]; + current_ = takeFunc_(*is_); + } + + UTFType GetType() const { return type_; } + bool HasBOM() const { return hasBOM_; } + + Ch Peek() const { return current_; } + Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; } + size_t Tell() const { return is_->Tell(); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + AutoUTFInputStream(const AutoUTFInputStream&); + AutoUTFInputStream& operator=(const AutoUTFInputStream&); + + // Detect encoding type with BOM or RFC 4627 + void DetectType() { + // BOM (Byte Order Mark): + // 00 00 FE FF UTF-32BE + // FF FE 00 00 UTF-32LE + // FE FF UTF-16BE + // FF FE UTF-16LE + // EF BB BF UTF-8 + + const unsigned char* c = reinterpret_cast(is_->Peek4()); + if (!c) + return; + + unsigned bom = static_cast(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24)); + hasBOM_ = false; + if (bom == 0xFFFE0000) { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); } + else if (bom == 0x0000FEFF) { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); } + else if ((bom & 0xFFFF) == 0xFFFE) { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take(); } + else if ((bom & 0xFFFF) == 0xFEFF) { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take(); } + else if ((bom & 0xFFFFFF) == 0xBFBBEF) { type_ = kUTF8; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); } + + // RFC 4627: Section 3 + // "Since the first two characters of a JSON text will always be ASCII + // characters [RFC0020], it is possible to determine whether an octet + // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking + // at the pattern of nulls in the first four octets." + // 00 00 00 xx UTF-32BE + // 00 xx 00 xx UTF-16BE + // xx 00 00 00 UTF-32LE + // xx 00 xx 00 UTF-16LE + // xx xx xx xx UTF-8 + + if (!hasBOM_) { + int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0); + switch (pattern) { + case 0x08: type_ = kUTF32BE; break; + case 0x0A: type_ = kUTF16BE; break; + case 0x01: type_ = kUTF32LE; break; + case 0x05: type_ = kUTF16LE; break; + case 0x0F: type_ = kUTF8; break; + default: break; // Use type defined by user. + } + } + + // 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); + } + + typedef Ch (*TakeFunc)(InputByteStream& is); + InputByteStream* is_; + UTFType type_; + Ch current_; + TakeFunc takeFunc_; + bool hasBOM_; +}; + +//! Output stream wrapper with dynamically bound encoding and automatic encoding detection. +/*! + \tparam CharType Type of character for writing. + \tparam OutputByteStream type of output byte stream to be wrapped. +*/ +template +class AutoUTFOutputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); +public: + typedef CharType Ch; + + //! Constructor. + /*! + \param os output stream to be wrapped. + \param type UTF encoding type. + \param putBOM Whether to write BOM at the beginning of the stream. + */ + AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) { + 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_]; + + if (putBOM) + PutBOM(); + } + + UTFType GetType() const { return type_; } + + void Put(Ch c) { putFunc_(*os_, c); } + void Flush() { os_->Flush(); } + + // Not implemented + Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;} + Ch Take() { RAPIDJSON_ASSERT(false); return 0;} + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + AutoUTFOutputStream(const AutoUTFOutputStream&); + AutoUTFOutputStream& operator=(const AutoUTFOutputStream&); + + void PutBOM() { + typedef void (*PutBOMFunc)(OutputByteStream&); + static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) }; + f[type_](*os_); + } + + typedef void (*PutFunc)(OutputByteStream&, Ch); + + OutputByteStream* os_; + UTFType type_; + PutFunc putFunc_; +}; + +#undef RAPIDJSON_ENCODINGS_FUNC + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/SourceCode/dep_inc/rapidjson/encodings.h b/SourceCode/dep_inc/rapidjson/encodings.h new file mode 100644 index 0000000..0b24467 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/encodings.h @@ -0,0 +1,716 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "rapidjson.h" + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data +RAPIDJSON_DIAG_OFF(4702) // unreachable code +#elif defined(__GNUC__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +RAPIDJSON_DIAG_OFF(overflow) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Encoding + +/*! \class rapidjson::Encoding + \brief Concept for encoding of Unicode characters. + +\code +concept Encoding { + typename Ch; //! Type of character. A "character" is actually a code unit in unicode's definition. + + enum { supportUnicode = 1 }; // or 0 if not supporting unicode + + //! \brief Encode a Unicode codepoint to an output stream. + //! \param os Output stream. + //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively. + template + static void Encode(OutputStream& os, unsigned codepoint); + + //! \brief Decode a Unicode codepoint from an input stream. + //! \param is Input stream. + //! \param codepoint Output of the unicode codepoint. + //! \return true if a valid codepoint can be decoded from the stream. + template + static bool Decode(InputStream& is, unsigned* codepoint); + + //! \brief Validate one Unicode codepoint from an encoded stream. + //! \param is Input stream to obtain codepoint. + //! \param os Output for copying one codepoint. + //! \return true if it is valid. + //! \note This function just validating and copying the codepoint without actually decode it. + template + static bool Validate(InputStream& is, OutputStream& os); + + // The following functions are deal with byte streams. + + //! Take a character from input byte stream, skip BOM if exist. + template + static CharType TakeBOM(InputByteStream& is); + + //! Take a character from input byte stream. + template + static Ch Take(InputByteStream& is); + + //! Put BOM to output byte stream. + template + static void PutBOM(OutputByteStream& os); + + //! Put a character to output byte stream. + template + static void Put(OutputByteStream& os, Ch c); +}; +\endcode +*/ + +/////////////////////////////////////////////////////////////////////////////// +// UTF8 + +//! UTF-8 encoding. +/*! http://en.wikipedia.org/wiki/UTF-8 + http://tools.ietf.org/html/rfc3629 + \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char. + \note implements Encoding concept +*/ +template +struct UTF8 { + typedef CharType Ch; + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + if (codepoint <= 0x7F) + os.Put(static_cast(codepoint & 0xFF)); + else if (codepoint <= 0x7FF) { + os.Put(static_cast(0xC0 | ((codepoint >> 6) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint & 0x3F)))); + } + else if (codepoint <= 0xFFFF) { + os.Put(static_cast(0xE0 | ((codepoint >> 12) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + os.Put(static_cast(0x80 | (codepoint & 0x3F))); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + os.Put(static_cast(0xF0 | ((codepoint >> 18) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint >> 12) & 0x3F))); + os.Put(static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + os.Put(static_cast(0x80 | (codepoint & 0x3F))); + } + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + if (codepoint <= 0x7F) + PutUnsafe(os, static_cast(codepoint & 0xFF)); + else if (codepoint <= 0x7FF) { + PutUnsafe(os, static_cast(0xC0 | ((codepoint >> 6) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint & 0x3F)))); + } + else if (codepoint <= 0xFFFF) { + PutUnsafe(os, static_cast(0xE0 | ((codepoint >> 12) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | (codepoint & 0x3F))); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + PutUnsafe(os, static_cast(0xF0 | ((codepoint >> 18) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 12) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | (codepoint & 0x3F))); + } + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { +#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast(c) & 0x3Fu) +#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast(c)) & mask) != 0) +#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70) + typename InputStream::Ch c = is.Take(); + if (!(c & 0x80)) { + *codepoint = static_cast(c); + return true; + } + + unsigned char type = GetRange(static_cast(c)); + if (type >= 32) { + *codepoint = 0; + } else { + *codepoint = (0xFFu >> type) & static_cast(c); + } + bool result = true; + switch (type) { + case 2: RAPIDJSON_TAIL(); return result; + case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result; + case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result; + case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + default: return false; + } +#undef RAPIDJSON_COPY +#undef RAPIDJSON_TRANS +#undef RAPIDJSON_TAIL + } + + template + static bool Validate(InputStream& is, OutputStream& os) { +#define RAPIDJSON_COPY() os.Put(c = is.Take()) +#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast(c)) & mask) != 0) +#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70) + Ch c; + RAPIDJSON_COPY(); + if (!(c & 0x80)) + return true; + + bool result = true; + switch (GetRange(static_cast(c))) { + case 2: RAPIDJSON_TAIL(); return result; + case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result; + case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result; + case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + default: return false; + } +#undef RAPIDJSON_COPY +#undef RAPIDJSON_TRANS +#undef RAPIDJSON_TAIL + } + + static unsigned char GetRange(unsigned char c) { + // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ + // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types. + static const unsigned char type[] = { + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, + 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8, + }; + return type[c]; + } + + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + typename InputByteStream::Ch c = Take(is); + if (static_cast(c) != 0xEFu) return c; + c = is.Take(); + if (static_cast(c) != 0xBBu) return c; + c = is.Take(); + if (static_cast(c) != 0xBFu) return c; + c = is.Take(); + return c; + } + + template + static Ch Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + return static_cast(is.Take()); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xEFu)); + os.Put(static_cast(0xBBu)); + os.Put(static_cast(0xBFu)); + } + + template + static void Put(OutputByteStream& os, Ch c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// UTF16 + +//! UTF-16 encoding. +/*! http://en.wikipedia.org/wiki/UTF-16 + http://tools.ietf.org/html/rfc2781 + \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead. + \note implements Encoding concept + + \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness. + For streaming, use UTF16LE and UTF16BE, which handle endianness. +*/ +template +struct UTF16 { + typedef CharType Ch; + RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2); + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + if (codepoint <= 0xFFFF) { + RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair + os.Put(static_cast(codepoint)); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + unsigned v = codepoint - 0x10000; + os.Put(static_cast((v >> 10) | 0xD800)); + os.Put(static_cast((v & 0x3FF) | 0xDC00)); + } + } + + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + if (codepoint <= 0xFFFF) { + RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair + PutUnsafe(os, static_cast(codepoint)); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + unsigned v = codepoint - 0x10000; + PutUnsafe(os, static_cast((v >> 10) | 0xD800)); + PutUnsafe(os, static_cast((v & 0x3FF) | 0xDC00)); + } + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2); + typename InputStream::Ch c = is.Take(); + if (c < 0xD800 || c > 0xDFFF) { + *codepoint = static_cast(c); + return true; + } + else if (c <= 0xDBFF) { + *codepoint = (static_cast(c) & 0x3FF) << 10; + c = is.Take(); + *codepoint |= (static_cast(c) & 0x3FF); + *codepoint += 0x10000; + return c >= 0xDC00 && c <= 0xDFFF; + } + return false; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2); + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + typename InputStream::Ch c; + os.Put(static_cast(c = is.Take())); + if (c < 0xD800 || c > 0xDFFF) + return true; + else if (c <= 0xDBFF) { + os.Put(c = is.Take()); + return c >= 0xDC00 && c <= 0xDFFF; + } + return false; + } +}; + +//! UTF-16 little endian encoding. +template +struct UTF16LE : UTF16 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0xFEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(is.Take()); + c |= static_cast(static_cast(is.Take())) << 8; + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFFu)); + os.Put(static_cast(0xFEu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(static_cast(c) & 0xFFu)); + os.Put(static_cast((static_cast(c) >> 8) & 0xFFu)); + } +}; + +//! UTF-16 big endian encoding. +template +struct UTF16BE : UTF16 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0xFEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())); + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0xFFu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast((static_cast(c) >> 8) & 0xFFu)); + os.Put(static_cast(static_cast(c) & 0xFFu)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// UTF32 + +//! UTF-32 encoding. +/*! http://en.wikipedia.org/wiki/UTF-32 + \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead. + \note implements Encoding concept + + \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness. + For streaming, use UTF32LE and UTF32BE, which handle endianness. +*/ +template +struct UTF32 { + typedef CharType Ch; + RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4); + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4); + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + os.Put(codepoint); + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4); + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + PutUnsafe(os, codepoint); + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4); + Ch c = is.Take(); + *codepoint = c; + return c <= 0x10FFFF; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4); + Ch c; + os.Put(c = is.Take()); + return c <= 0x10FFFF; + } +}; + +//! UTF-32 little endian enocoding. +template +struct UTF32LE : UTF32 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0x0000FEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(is.Take()); + c |= static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())) << 16; + c |= static_cast(static_cast(is.Take())) << 24; + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFFu)); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0x00u)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c & 0xFFu)); + os.Put(static_cast((c >> 8) & 0xFFu)); + os.Put(static_cast((c >> 16) & 0xFFu)); + os.Put(static_cast((c >> 24) & 0xFFu)); + } +}; + +//! UTF-32 big endian encoding. +template +struct UTF32BE : UTF32 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0x0000FEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(static_cast(is.Take())) << 24; + c |= static_cast(static_cast(is.Take())) << 16; + c |= static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())); + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0xFFu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast((c >> 24) & 0xFFu)); + os.Put(static_cast((c >> 16) & 0xFFu)); + os.Put(static_cast((c >> 8) & 0xFFu)); + os.Put(static_cast(c & 0xFFu)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// ASCII + +//! ASCII encoding. +/*! http://en.wikipedia.org/wiki/ASCII + \tparam CharType Code unit for storing 7-bit ASCII data. Default is char. + \note implements Encoding concept +*/ +template +struct ASCII { + typedef CharType Ch; + + enum { supportUnicode = 0 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_ASSERT(codepoint <= 0x7F); + os.Put(static_cast(codepoint & 0xFF)); + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_ASSERT(codepoint <= 0x7F); + PutUnsafe(os, static_cast(codepoint & 0xFF)); + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + uint8_t c = static_cast(is.Take()); + *codepoint = c; + return c <= 0X7F; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + uint8_t c = static_cast(is.Take()); + os.Put(static_cast(c)); + return c <= 0x7F; + } + + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + uint8_t c = static_cast(Take(is)); + return static_cast(c); + } + + template + static Ch Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + return static_cast(is.Take()); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + (void)os; + } + + template + static void Put(OutputByteStream& os, Ch c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// AutoUTF + +//! Runtime-specified UTF encoding type of a stream. +enum UTFType { + kUTF8 = 0, //!< UTF-8. + kUTF16LE = 1, //!< UTF-16 little endian. + kUTF16BE = 2, //!< UTF-16 big endian. + kUTF32LE = 3, //!< UTF-32 little endian. + kUTF32BE = 4 //!< UTF-32 big endian. +}; + +//! Dynamically select encoding according to stream's runtime-specified UTF encoding type. +/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType(). +*/ +template +struct AutoUTF { + typedef CharType Ch; + + enum { supportUnicode = 1 }; + +#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8::x, UTF16LE::x, UTF16BE::x, UTF32LE::x, UTF32BE::x + + template + static RAPIDJSON_FORCEINLINE void Encode(OutputStream& os, unsigned codepoint) { + typedef void (*EncodeFunc)(OutputStream&, unsigned); + static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) }; + (*f[os.GetType()])(os, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + typedef void (*EncodeFunc)(OutputStream&, unsigned); + static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) }; + (*f[os.GetType()])(os, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE bool Decode(InputStream& is, unsigned* codepoint) { + typedef bool (*DecodeFunc)(InputStream&, unsigned*); + static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) }; + return (*f[is.GetType()])(is, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + typedef bool (*ValidateFunc)(InputStream&, OutputStream&); + static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) }; + return (*f[is.GetType()])(is, os); + } + +#undef RAPIDJSON_ENCODINGS_FUNC +}; + +/////////////////////////////////////////////////////////////////////////////// +// Transcoder + +//! Encoding conversion. +template +struct Transcoder { + //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream. + template + static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) { + unsigned codepoint; + if (!SourceEncoding::Decode(is, &codepoint)) + return false; + TargetEncoding::Encode(os, codepoint); + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) { + unsigned codepoint; + if (!SourceEncoding::Decode(is, &codepoint)) + return false; + TargetEncoding::EncodeUnsafe(os, codepoint); + return true; + } + + //! Validate one Unicode codepoint from an encoded stream. + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + return Transcode(is, os); // Since source/target encoding is different, must transcode. + } +}; + +// Forward declaration. +template +inline void PutUnsafe(Stream& stream, typename Stream::Ch c); + +//! Specialization of Transcoder with same source and target encoding. +template +struct Transcoder { + template + static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) { + os.Put(is.Take()); // Just copy one code unit. This semantic is different from primary template class. + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) { + PutUnsafe(os, is.Take()); // Just copy one code unit. This semantic is different from primary template class. + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + return Encoding::Validate(is, os); // source/target encoding are the same + } +}; + +RAPIDJSON_NAMESPACE_END + +#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__)) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ENCODINGS_H_ diff --git a/SourceCode/dep_inc/rapidjson/error/en.h b/SourceCode/dep_inc/rapidjson/error/en.h new file mode 100644 index 0000000..2db838b --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/error/en.h @@ -0,0 +1,74 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "error.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(switch-enum) +RAPIDJSON_DIAG_OFF(covered-switch-default) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Maps error code of parsing into error message. +/*! + \ingroup RAPIDJSON_ERRORS + \param parseErrorCode Error code obtained in parsing. + \return the error message. + \note User can make a copy of this function for localization. + Using switch-case is safer for future modification of error codes. +*/ +inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) { + switch (parseErrorCode) { + case kParseErrorNone: return RAPIDJSON_ERROR_STRING("No error."); + + case kParseErrorDocumentEmpty: return RAPIDJSON_ERROR_STRING("The document is empty."); + case kParseErrorDocumentRootNotSingular: return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values."); + + case kParseErrorValueInvalid: return RAPIDJSON_ERROR_STRING("Invalid value."); + + case kParseErrorObjectMissName: return RAPIDJSON_ERROR_STRING("Missing a name for object member."); + case kParseErrorObjectMissColon: return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member."); + case kParseErrorObjectMissCommaOrCurlyBracket: return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member."); + + case kParseErrorArrayMissCommaOrSquareBracket: return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element."); + + case kParseErrorStringUnicodeEscapeInvalidHex: return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string."); + case kParseErrorStringUnicodeSurrogateInvalid: return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid."); + case kParseErrorStringEscapeInvalid: return RAPIDJSON_ERROR_STRING("Invalid escape character in string."); + case kParseErrorStringMissQuotationMark: return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string."); + case kParseErrorStringInvalidEncoding: return RAPIDJSON_ERROR_STRING("Invalid encoding in string."); + + case kParseErrorNumberTooBig: return RAPIDJSON_ERROR_STRING("Number too big to be stored in double."); + case kParseErrorNumberMissFraction: return RAPIDJSON_ERROR_STRING("Miss fraction part in number."); + case kParseErrorNumberMissExponent: return RAPIDJSON_ERROR_STRING("Miss exponent in number."); + + case kParseErrorTermination: return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error."); + case kParseErrorUnspecificSyntaxError: return RAPIDJSON_ERROR_STRING("Unspecific syntax error."); + + default: return RAPIDJSON_ERROR_STRING("Unknown error."); + } +} + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ERROR_EN_H_ diff --git a/SourceCode/dep_inc/rapidjson/error/error.h b/SourceCode/dep_inc/rapidjson/error/error.h new file mode 100644 index 0000000..9311d2f --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/error/error.h @@ -0,0 +1,161 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +/*! \file error.h */ + +/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */ + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ERROR_CHARTYPE + +//! Character type of error messages. +/*! \ingroup RAPIDJSON_ERRORS + The default character type is \c char. + On Windows, user can define this macro as \c TCHAR for supporting both + unicode/non-unicode settings. +*/ +#ifndef RAPIDJSON_ERROR_CHARTYPE +#define RAPIDJSON_ERROR_CHARTYPE char +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ERROR_STRING + +//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[]. +/*! \ingroup RAPIDJSON_ERRORS + By default this conversion macro does nothing. + On Windows, user can define this macro as \c _T(x) for supporting both + unicode/non-unicode settings. +*/ +#ifndef RAPIDJSON_ERROR_STRING +#define RAPIDJSON_ERROR_STRING(x) x +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// ParseErrorCode + +//! Error code of parsing. +/*! \ingroup RAPIDJSON_ERRORS + \see GenericReader::Parse, GenericReader::GetParseErrorCode +*/ +enum ParseErrorCode { + kParseErrorNone = 0, //!< No error. + + kParseErrorDocumentEmpty, //!< The document is empty. + kParseErrorDocumentRootNotSingular, //!< The document root must not follow by other values. + + kParseErrorValueInvalid, //!< Invalid value. + + kParseErrorObjectMissName, //!< Missing a name for object member. + kParseErrorObjectMissColon, //!< Missing a colon after a name of object member. + kParseErrorObjectMissCommaOrCurlyBracket, //!< Missing a comma or '}' after an object member. + + kParseErrorArrayMissCommaOrSquareBracket, //!< Missing a comma or ']' after an array element. + + kParseErrorStringUnicodeEscapeInvalidHex, //!< Incorrect hex digit after \\u escape in string. + kParseErrorStringUnicodeSurrogateInvalid, //!< The surrogate pair in string is invalid. + kParseErrorStringEscapeInvalid, //!< Invalid escape character in string. + kParseErrorStringMissQuotationMark, //!< Missing a closing quotation mark in string. + kParseErrorStringInvalidEncoding, //!< Invalid encoding in string. + + kParseErrorNumberTooBig, //!< Number too big to be stored in double. + kParseErrorNumberMissFraction, //!< Miss fraction part in number. + kParseErrorNumberMissExponent, //!< Miss exponent in number. + + kParseErrorTermination, //!< Parsing was terminated. + kParseErrorUnspecificSyntaxError //!< Unspecific syntax error. +}; + +//! Result of parsing (wraps ParseErrorCode) +/*! + \ingroup RAPIDJSON_ERRORS + \code + Document doc; + ParseResult ok = doc.Parse("[42]"); + if (!ok) { + fprintf(stderr, "JSON parse error: %s (%u)", + GetParseError_En(ok.Code()), ok.Offset()); + exit(EXIT_FAILURE); + } + \endcode + \see GenericReader::Parse, GenericDocument::Parse +*/ +struct ParseResult { + //!! Unspecified boolean type + typedef bool (ParseResult::*BooleanType)() const; +public: + //! Default constructor, no error. + ParseResult() : code_(kParseErrorNone), offset_(0) {} + //! Constructor to set an error. + ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {} + + //! Get the error code. + ParseErrorCode Code() const { return code_; } + //! Get the error offset, if \ref IsError(), 0 otherwise. + size_t Offset() const { return offset_; } + + //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError(). + operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; } + //! Whether the result is an error. + bool IsError() const { return code_ != kParseErrorNone; } + + bool operator==(const ParseResult& that) const { return code_ == that.code_; } + bool operator==(ParseErrorCode code) const { return code_ == code; } + friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; } + + bool operator!=(const ParseResult& that) const { return !(*this == that); } + bool operator!=(ParseErrorCode code) const { return !(*this == code); } + friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; } + + //! Reset error code. + void Clear() { Set(kParseErrorNone); } + //! Update error code and offset. + void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; } + +private: + ParseErrorCode code_; + size_t offset_; +}; + +//! Function pointer type of GetParseError(). +/*! \ingroup RAPIDJSON_ERRORS + + This is the prototype for \c GetParseError_X(), where \c X is a locale. + User can dynamically change locale in runtime, e.g.: +\code + GetParseErrorFunc GetParseError = GetParseError_En; // or whatever + const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode()); +\endcode +*/ +typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode); + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ERROR_ERROR_H_ diff --git a/SourceCode/dep_inc/rapidjson/filereadstream.h b/SourceCode/dep_inc/rapidjson/filereadstream.h new file mode 100644 index 0000000..f1bfb7d --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/filereadstream.h @@ -0,0 +1,99 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(missing-noreturn) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! File byte stream for input using fread(). +/*! + \note implements Stream concept +*/ +class FileReadStream { +public: + typedef char Ch; //!< Character type (byte). + + //! Constructor. + /*! + \param fp File pointer opened for read. + \param buffer user-supplied buffer. + \param bufferSize size of buffer in bytes. Must >=4 bytes. + */ + FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { + RAPIDJSON_ASSERT(fp_ != 0); + RAPIDJSON_ASSERT(bufferSize >= 4); + Read(); + } + + Ch Peek() const { return *current_; } + Ch Take() { Ch c = *current_; Read(); return c; } + size_t Tell() const { return count_ + static_cast(current_ - buffer_); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + return (current_ + 4 <= bufferLast_) ? current_ : 0; + } + +private: + void Read() { + if (current_ < bufferLast_) + ++current_; + else if (!eof_) { + count_ += readCount_; + readCount_ = std::fread(buffer_, 1, bufferSize_, fp_); + bufferLast_ = buffer_ + readCount_ - 1; + current_ = buffer_; + + if (readCount_ < bufferSize_) { + buffer_[readCount_] = '\0'; + ++bufferLast_; + eof_ = true; + } + } + } + + std::FILE* fp_; + Ch *buffer_; + size_t bufferSize_; + Ch *bufferLast_; + Ch *current_; + size_t readCount_; + size_t count_; //!< Number of characters read + bool eof_; +}; + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/SourceCode/dep_inc/rapidjson/filewritestream.h b/SourceCode/dep_inc/rapidjson/filewritestream.h new file mode 100644 index 0000000..8b48fee --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/filewritestream.h @@ -0,0 +1,104 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(unreachable-code) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of C file stream for output using fwrite(). +/*! + \note implements Stream concept +*/ +class FileWriteStream { +public: + typedef char Ch; //!< Character type. Only support char. + + FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { + RAPIDJSON_ASSERT(fp_ != 0); + } + + void Put(char c) { + if (current_ >= bufferEnd_) + Flush(); + + *current_++ = c; + } + + void PutN(char c, size_t n) { + size_t avail = static_cast(bufferEnd_ - current_); + while (n > avail) { + std::memset(current_, c, avail); + current_ += avail; + Flush(); + n -= avail; + avail = static_cast(bufferEnd_ - current_); + } + + if (n > 0) { + std::memset(current_, c, n); + current_ += n; + } + } + + void Flush() { + if (current_ != buffer_) { + size_t result = std::fwrite(buffer_, 1, static_cast(current_ - buffer_), fp_); + if (result < static_cast(current_ - buffer_)) { + // failure deliberately ignored at this time + // added to avoid warn_unused_result build errors + } + current_ = buffer_; + } + } + + // Not implemented + char Peek() const { RAPIDJSON_ASSERT(false); return 0; } + char Take() { RAPIDJSON_ASSERT(false); return 0; } + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + // Prohibit copy constructor & assignment operator. + FileWriteStream(const FileWriteStream&); + FileWriteStream& operator=(const FileWriteStream&); + + std::FILE* fp_; + char *buffer_; + char *bufferEnd_; + char *current_; +}; + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(FileWriteStream& stream, char c, size_t n) { + stream.PutN(c, n); +} + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/SourceCode/dep_inc/rapidjson/fwd.h b/SourceCode/dep_inc/rapidjson/fwd.h new file mode 100644 index 0000000..e8104e8 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/fwd.h @@ -0,0 +1,151 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_FWD_H_ +#define RAPIDJSON_FWD_H_ + +#include "rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN + +// encodings.h + +template struct UTF8; +template struct UTF16; +template struct UTF16BE; +template struct UTF16LE; +template struct UTF32; +template struct UTF32BE; +template struct UTF32LE; +template struct ASCII; +template struct AutoUTF; + +template +struct Transcoder; + +// allocators.h + +class CrtAllocator; + +template +class MemoryPoolAllocator; + +// stream.h + +template +struct GenericStringStream; + +typedef GenericStringStream > StringStream; + +template +struct GenericInsituStringStream; + +typedef GenericInsituStringStream > InsituStringStream; + +// stringbuffer.h + +template +class GenericStringBuffer; + +typedef GenericStringBuffer, CrtAllocator> StringBuffer; + +// filereadstream.h + +class FileReadStream; + +// filewritestream.h + +class FileWriteStream; + +// memorybuffer.h + +template +struct GenericMemoryBuffer; + +typedef GenericMemoryBuffer MemoryBuffer; + +// memorystream.h + +struct MemoryStream; + +// reader.h + +template +struct BaseReaderHandler; + +template +class GenericReader; + +typedef GenericReader, UTF8, CrtAllocator> Reader; + +// writer.h + +template +class Writer; + +// prettywriter.h + +template +class PrettyWriter; + +// document.h + +template +struct GenericMember; + +template +class GenericMemberIterator; + +template +struct GenericStringRef; + +template +class GenericValue; + +typedef GenericValue, MemoryPoolAllocator > Value; + +template +class GenericDocument; + +typedef GenericDocument, MemoryPoolAllocator, CrtAllocator> Document; + +// pointer.h + +template +class GenericPointer; + +typedef GenericPointer Pointer; + +// schema.h + +template +class IGenericRemoteSchemaDocumentProvider; + +template +class GenericSchemaDocument; + +typedef GenericSchemaDocument SchemaDocument; +typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProvider; + +template < + typename SchemaDocumentType, + typename OutputHandler, + typename StateAllocator> +class GenericSchemaValidator; + +typedef GenericSchemaValidator, void>, CrtAllocator> SchemaValidator; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_RAPIDJSONFWD_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/biginteger.h b/SourceCode/dep_inc/rapidjson/internal/biginteger.h new file mode 100644 index 0000000..a31c8a8 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/biginteger.h @@ -0,0 +1,290 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "../rapidjson.h" + +#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64) +#include // for _umul128 +#pragma intrinsic(_umul128) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +class BigInteger { +public: + typedef uint64_t Type; + + BigInteger(const BigInteger& rhs) : count_(rhs.count_) { + std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type)); + } + + explicit BigInteger(uint64_t u) : count_(1) { + digits_[0] = u; + } + + BigInteger(const char* decimals, size_t length) : count_(1) { + RAPIDJSON_ASSERT(length > 0); + digits_[0] = 0; + size_t i = 0; + const size_t kMaxDigitPerIteration = 19; // 2^64 = 18446744073709551616 > 10^19 + while (length >= kMaxDigitPerIteration) { + AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration); + length -= kMaxDigitPerIteration; + i += kMaxDigitPerIteration; + } + + if (length > 0) + AppendDecimal64(decimals + i, decimals + i + length); + } + + BigInteger& operator=(const BigInteger &rhs) + { + if (this != &rhs) { + count_ = rhs.count_; + std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type)); + } + return *this; + } + + BigInteger& operator=(uint64_t u) { + digits_[0] = u; + count_ = 1; + return *this; + } + + BigInteger& operator+=(uint64_t u) { + Type backup = digits_[0]; + digits_[0] += u; + for (size_t i = 0; i < count_ - 1; i++) { + if (digits_[i] >= backup) + return *this; // no carry + backup = digits_[i + 1]; + digits_[i + 1] += 1; + } + + // Last carry + if (digits_[count_ - 1] < backup) + PushBack(1); + + return *this; + } + + BigInteger& operator*=(uint64_t u) { + if (u == 0) return *this = 0; + if (u == 1) return *this; + if (*this == 1) return *this = u; + + uint64_t k = 0; + for (size_t i = 0; i < count_; i++) { + uint64_t hi; + digits_[i] = MulAdd64(digits_[i], u, k, &hi); + k = hi; + } + + if (k > 0) + PushBack(k); + + return *this; + } + + BigInteger& operator*=(uint32_t u) { + if (u == 0) return *this = 0; + if (u == 1) return *this; + if (*this == 1) return *this = u; + + 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; + const uint64_t uc = u * c; + const uint64_t ud = u * d; + const uint64_t p0 = ud + k; + const uint64_t p1 = uc + (p0 >> 32); + digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32); + k = p1 >> 32; + } + + if (k > 0) + PushBack(k); + + return *this; + } + + BigInteger& operator<<=(size_t shift) { + if (IsZero() || shift == 0) return *this; + + size_t offset = shift / kTypeBit; + size_t interShift = shift % kTypeBit; + RAPIDJSON_ASSERT(count_ + offset <= kCapacity); + + if (interShift == 0) { + std::memmove(digits_ + offset, digits_, count_ * sizeof(Type)); + count_ += offset; + } + else { + digits_[count_] = 0; + for (size_t i = count_; i > 0; i--) + digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift)); + digits_[offset] = digits_[0] << interShift; + count_ += offset; + if (digits_[count_]) + count_++; + } + + std::memset(digits_, 0, offset * sizeof(Type)); + + return *this; + } + + bool operator==(const BigInteger& rhs) const { + return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0; + } + + bool operator==(const Type rhs) const { + return count_ == 1 && digits_[0] == rhs; + } + + BigInteger& MultiplyPow5(unsigned exp) { + static const uint32_t kPow5[12] = { + 5, + 5 * 5, + 5 * 5 * 5, + 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 + }; + if (exp == 0) return *this; + for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27 + for (; exp >= 13; exp -= 13) *this *= static_cast(1220703125u); // 5^13 + if (exp > 0) *this *= kPow5[exp - 1]; + return *this; + } + + // Compute absolute difference of this and rhs. + // Assume this != rhs + bool Difference(const BigInteger& rhs, BigInteger* out) const { + int cmp = Compare(rhs); + RAPIDJSON_ASSERT(cmp != 0); + const BigInteger *a, *b; // Makes a > b + bool ret; + if (cmp < 0) { a = &rhs; b = this; ret = true; } + else { a = this; b = &rhs; ret = false; } + + Type borrow = 0; + for (size_t i = 0; i < a->count_; i++) { + Type d = a->digits_[i] - borrow; + if (i < b->count_) + d -= b->digits_[i]; + borrow = (d > a->digits_[i]) ? 1 : 0; + out->digits_[i] = d; + if (d != 0) + out->count_ = i + 1; + } + + return ret; + } + + int Compare(const BigInteger& rhs) const { + if (count_ != rhs.count_) + return count_ < rhs.count_ ? -1 : 1; + + for (size_t i = count_; i-- > 0;) + if (digits_[i] != rhs.digits_[i]) + return digits_[i] < rhs.digits_[i] ? -1 : 1; + + return 0; + } + + size_t GetCount() const { return count_; } + Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; } + bool IsZero() const { return count_ == 1 && digits_[0] == 0; } + +private: + void AppendDecimal64(const char* begin, const char* end) { + uint64_t u = ParseUint64(begin, end); + if (IsZero()) + *this = u; + else { + unsigned exp = static_cast(end - begin); + (MultiplyPow5(exp) <<= exp) += u; // *this = *this * 10^exp + u + } + } + + void PushBack(Type digit) { + RAPIDJSON_ASSERT(count_ < kCapacity); + digits_[count_++] = digit; + } + + static uint64_t ParseUint64(const char* begin, const char* end) { + uint64_t r = 0; + for (const char* p = begin; p != end; ++p) { + RAPIDJSON_ASSERT(*p >= '0' && *p <= '9'); + r = r * 10u + static_cast(*p - '0'); + } + return r; + } + + // Assume a * b + k < 2^128 + static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) { +#if defined(_MSC_VER) && defined(_M_AMD64) + uint64_t low = _umul128(a, b, outHigh) + k; + if (low < k) + (*outHigh)++; + return low; +#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__) + __extension__ typedef unsigned __int128 uint128; + uint128 p = static_cast(a) * static_cast(b); + p += k; + *outHigh = static_cast(p >> 64); + return static_cast(p); +#else + const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32; + uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1; + x1 += (x0 >> 32); // can't give carry + x1 += x2; + if (x1 < x2) + x3 += (static_cast(1) << 32); + uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF); + uint64_t hi = x3 + (x1 >> 32); + + lo += k; + if (lo < k) + hi++; + *outHigh = hi; + return lo; +#endif + } + + 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; + + Type digits_[kCapacity]; + size_t count_; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_BIGINTEGER_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/diyfp.h b/SourceCode/dep_inc/rapidjson/internal/diyfp.h new file mode 100644 index 0000000..b6c2cf5 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/diyfp.h @@ -0,0 +1,271 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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 +// integers." ACM Sigplan Notices 45.6 (2010): 233-243. + +#ifndef RAPIDJSON_DIYFP_H_ +#define RAPIDJSON_DIYFP_H_ + +#include "../rapidjson.h" +#include + +#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER) +#include +#pragma intrinsic(_BitScanReverse64) +#pragma intrinsic(_umul128) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +struct DiyFp { + DiyFp() : f(), e() {} + + DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {} + + explicit DiyFp(double d) { + union { + double d; + uint64_t u64; + } u = { d }; + + int biased_e = static_cast((u.u64 & kDpExponentMask) >> kDpSignificandSize); + uint64_t significand = (u.u64 & kDpSignificandMask); + if (biased_e != 0) { + f = significand + kDpHiddenBit; + e = biased_e - kDpExponentBias; + } + else { + f = significand; + e = kDpMinExponent + 1; + } + } + + DiyFp operator-(const DiyFp& rhs) const { + return DiyFp(f - rhs.f, e); + } + + DiyFp operator*(const DiyFp& rhs) const { +#if defined(_MSC_VER) && defined(_M_AMD64) + uint64_t h; + uint64_t l = _umul128(f, rhs.f, &h); + if (l & (uint64_t(1) << 63)) // rounding + h++; + return DiyFp(h, e + rhs.e + 64); +#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__) + __extension__ typedef unsigned __int128 uint128; + uint128 p = static_cast(f) * static_cast(rhs.f); + uint64_t h = static_cast(p >> 64); + uint64_t l = static_cast(p); + if (l & (uint64_t(1) << 63)) // rounding + h++; + return DiyFp(h, e + rhs.e + 64); +#else + const uint64_t M32 = 0xFFFFFFFF; + const uint64_t a = f >> 32; + const uint64_t b = f & M32; + const uint64_t c = rhs.f >> 32; + const uint64_t d = rhs.f & M32; + const uint64_t ac = a * c; + const uint64_t bc = b * c; + const uint64_t ad = a * d; + const uint64_t bd = b * d; + uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32); + tmp += 1U << 31; /// mult_round + return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64); +#endif + } + + DiyFp Normalize() const { + RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737 +#if defined(_MSC_VER) && defined(_M_AMD64) + unsigned long index; + _BitScanReverse64(&index, f); + return DiyFp(f << (63 - index), e - (63 - index)); +#elif defined(__GNUC__) && __GNUC__ >= 4 + int s = __builtin_clzll(f); + return DiyFp(f << s, e - s); +#else + DiyFp res = *this; + while (!(res.f & (static_cast(1) << 63))) { + res.f <<= 1; + res.e--; + } + return res; +#endif + } + + DiyFp NormalizeBoundary() const { + DiyFp res = *this; + while (!(res.f & (kDpHiddenBit << 1))) { + res.f <<= 1; + res.e--; + } + res.f <<= (kDiySignificandSize - kDpSignificandSize - 2); + res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2); + return res; + } + + void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const { + DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary(); + DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1); + mi.f <<= mi.e - pl.e; + mi.e = pl.e; + *plus = pl; + *minus = mi; + } + + double ToDouble() const { + union { + double d; + uint64_t u64; + }u; + RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask); + if (e < kDpDenormalExponent) { + // Underflow. + return 0.0; + } + if (e >= kDpMaxExponent) { + // Overflow. + return std::numeric_limits::infinity(); + } + const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : + static_cast(e + kDpExponentBias); + u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize); + return u.d; + } + + static const int kDiySignificandSize = 64; + static const int kDpSignificandSize = 52; + static const int kDpExponentBias = 0x3FF + kDpSignificandSize; + static const int kDpMaxExponent = 0x7FF - kDpExponentBias; + static const int kDpMinExponent = -kDpExponentBias; + static const int kDpDenormalExponent = -kDpExponentBias + 1; + static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000); + static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF); + static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000); + + uint64_t f; + int e; +}; + +inline DiyFp GetCachedPowerByIndex(size_t index) { + // 10^-348, 10^-340, ..., 10^340 + static const uint64_t kCachedPowers_F[] = { + RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76), + RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea), + RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df), + RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f), + RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c), + RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5), + RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d), + RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637), + RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7), + RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5), + RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b), + RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996), + RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6), + RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8), + RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053), + RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd), + RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94), + RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b), + RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac), + RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3), + RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb), + RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c), + RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000), + RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984), + RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70), + RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245), + RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8), + RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a), + RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea), + RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85), + RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2), + RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3), + RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25), + RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece), + RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5), + RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a), + RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c), + RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a), + RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129), + RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429), + RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d), + RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841), + RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9), + RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b) + }; + static const int16_t kCachedPowers_E[] = { + -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, + -954, -927, -901, -874, -847, -821, -794, -768, -741, -715, + -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, + -422, -396, -369, -343, -316, -289, -263, -236, -210, -183, + -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, + 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, + 375, 402, 428, 455, 481, 508, 534, 561, 588, 614, + 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, + 907, 933, 960, 986, 1013, 1039, 1066 + }; + RAPIDJSON_ASSERT(index < 87); + return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]); +} + +inline DiyFp GetCachedPower(int e, int* K) { + + //int k = static_cast(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(dk); + if (dk - k > 0.0) + k++; + + unsigned index = static_cast((k >> 3) + 1); + *K = -(-348 + static_cast(index << 3)); // decimal exponent no need lookup table + + return GetCachedPowerByIndex(index); +} + +inline DiyFp GetCachedPower10(int exp, int *outExp) { + RAPIDJSON_ASSERT(exp >= -348); + unsigned index = static_cast(exp + 348) / 8u; + *outExp = -348 + static_cast(index) * 8; + return GetCachedPowerByIndex(index); +} + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +RAPIDJSON_DIAG_OFF(padded) +#endif + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_DIYFP_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/dtoa.h b/SourceCode/dep_inc/rapidjson/internal/dtoa.h new file mode 100644 index 0000000..bf2e9b2 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/dtoa.h @@ -0,0 +1,245 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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 +// integers." ACM Sigplan Notices 45.6 (2010): 233-243. + +#ifndef RAPIDJSON_DTOA_ +#define RAPIDJSON_DTOA_ + +#include "itoa.h" // GetDigitsLut() +#include "diyfp.h" +#include "ieee754.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124 +#endif + +inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) { + while (rest < wp_w && delta - rest >= ten_kappa && + (rest + ten_kappa < wp_w || /// closer + wp_w - rest > rest + ten_kappa - wp_w)) { + buffer[len - 1]--; + rest += ten_kappa; + } +} + +inline int CountDecimalDigit32(uint32_t n) { + // Simple pure C++ implementation was faster than __builtin_clz version in this situation. + if (n < 10) return 1; + if (n < 100) return 2; + if (n < 1000) return 3; + if (n < 10000) return 4; + if (n < 100000) return 5; + if (n < 1000000) return 6; + if (n < 10000000) return 7; + if (n < 100000000) return 8; + // 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) { + static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; + const DiyFp one(uint64_t(1) << -Mp.e, Mp.e); + const DiyFp wp_w = Mp - W; + uint32_t p1 = static_cast(Mp.f >> -one.e); + uint64_t p2 = Mp.f & (one.f - 1); + int kappa = CountDecimalDigit32(p1); // kappa in [0, 9] + *len = 0; + + while (kappa > 0) { + uint32_t d = 0; + switch (kappa) { + case 9: d = p1 / 100000000; p1 %= 100000000; break; + case 8: d = p1 / 10000000; p1 %= 10000000; break; + case 7: d = p1 / 1000000; p1 %= 1000000; break; + case 6: d = p1 / 100000; p1 %= 100000; break; + case 5: d = p1 / 10000; p1 %= 10000; break; + case 4: d = p1 / 1000; p1 %= 1000; break; + 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 (d || *len) + buffer[(*len)++] = static_cast('0' + static_cast(d)); + kappa--; + uint64_t tmp = (static_cast(p1) << -one.e) + p2; + if (tmp <= delta) { + *K += kappa; + GrisuRound(buffer, *len, delta, tmp, static_cast(kPow10[kappa]) << -one.e, wp_w.f); + return; + } + } + + // kappa = 0 + for (;;) { + p2 *= 10; + delta *= 10; + char d = static_cast(p2 >> -one.e); + if (d || *len) + buffer[(*len)++] = static_cast('0' + d); + p2 &= one.f - 1; + kappa--; + if (p2 < delta) { + *K += kappa; + int index = -kappa; + GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0)); + return; + } + } +} + +inline void Grisu2(double value, char* buffer, int* length, int* K) { + const DiyFp v(value); + DiyFp w_m, w_p; + v.NormalizedBoundaries(&w_m, &w_p); + + const DiyFp c_mk = GetCachedPower(w_p.e, K); + const DiyFp W = v.Normalize() * c_mk; + DiyFp Wp = w_p * c_mk; + DiyFp Wm = w_m * c_mk; + Wm.f++; + Wp.f--; + DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K); +} + +inline char* WriteExponent(int K, char* buffer) { + if (K < 0) { + *buffer++ = '-'; + K = -K; + } + + if (K >= 100) { + *buffer++ = static_cast('0' + static_cast(K / 100)); + K %= 100; + const char* d = GetDigitsLut() + K * 2; + *buffer++ = d[0]; + *buffer++ = d[1]; + } + else if (K >= 10) { + const char* d = GetDigitsLut() + K * 2; + *buffer++ = d[0]; + *buffer++ = d[1]; + } + else + *buffer++ = static_cast('0' + static_cast(K)); + + return buffer; +} + +inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) { + const int kk = length + k; // 10^(kk-1) <= v < 10^kk + + if (0 <= k && kk <= 21) { + // 1234e7 -> 12340000000 + for (int i = length; i < kk; i++) + buffer[i] = '0'; + buffer[kk] = '.'; + buffer[kk + 1] = '0'; + return &buffer[kk + 2]; + } + else if (0 < kk && kk <= 21) { + // 1234e-2 -> 12.34 + std::memmove(&buffer[kk + 1], &buffer[kk], static_cast(length - kk)); + buffer[kk] = '.'; + if (0 > k + maxDecimalPlaces) { + // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1 + // Remove extra trailing zeros (at least one) after truncation. + for (int i = kk + maxDecimalPlaces; i > kk + 1; i--) + if (buffer[i] != '0') + return &buffer[i + 1]; + return &buffer[kk + 2]; // Reserve one zero + } + else + return &buffer[length + 1]; + } + else if (-6 < kk && kk <= 0) { + // 1234e-6 -> 0.001234 + const int offset = 2 - kk; + std::memmove(&buffer[offset], &buffer[0], static_cast(length)); + buffer[0] = '0'; + buffer[1] = '.'; + for (int i = 2; i < offset; i++) + buffer[i] = '0'; + if (length - kk > maxDecimalPlaces) { + // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1 + // Remove extra trailing zeros (at least one) after truncation. + for (int i = maxDecimalPlaces + 1; i > 2; i--) + if (buffer[i] != '0') + return &buffer[i + 1]; + return &buffer[3]; // Reserve one zero + } + else + return &buffer[length + offset]; + } + else if (kk < -maxDecimalPlaces) { + // Truncate to zero + buffer[0] = '0'; + buffer[1] = '.'; + buffer[2] = '0'; + return &buffer[3]; + } + else if (length == 1) { + // 1e30 + buffer[1] = 'e'; + return WriteExponent(kk - 1, &buffer[2]); + } + else { + // 1234e30 -> 1.234e33 + std::memmove(&buffer[2], &buffer[1], static_cast(length - 1)); + buffer[1] = '.'; + buffer[length + 1] = 'e'; + return WriteExponent(kk - 1, &buffer[0 + length + 2]); + } +} + +inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) { + RAPIDJSON_ASSERT(maxDecimalPlaces >= 1); + Double d(value); + if (d.IsZero()) { + if (d.Sign()) + *buffer++ = '-'; // -0.0, Issue #289 + buffer[0] = '0'; + buffer[1] = '.'; + buffer[2] = '0'; + return &buffer[3]; + } + else { + if (value < 0) { + *buffer++ = '-'; + value = -value; + } + int length, K; + Grisu2(value, buffer, &length, &K); + return Prettify(buffer, length, K, maxDecimalPlaces); + } +} + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_DTOA_ diff --git a/SourceCode/dep_inc/rapidjson/internal/ieee754.h b/SourceCode/dep_inc/rapidjson/internal/ieee754.h new file mode 100644 index 0000000..c2684ba --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/ieee754.h @@ -0,0 +1,78 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ + +#include "../rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +class Double { +public: + Double() {} + Double(double d) : d_(d) {} + Double(uint64_t u) : u_(u) {} + + double Value() const { return d_; } + uint64_t Uint64Value() const { return u_; } + + double NextPositiveDouble() const { + RAPIDJSON_ASSERT(!Sign()); + return Double(u_ + 1).Value(); + } + + bool Sign() const { return (u_ & kSignMask) != 0; } + uint64_t Significand() const { return u_ & kSignificandMask; } + int Exponent() const { return static_cast(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); } + + bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; } + bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; } + bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; } + 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; } + + static int EffectiveSignificandSize(int order) { + if (order >= -1021) + return 53; + else if (order <= -1074) + return 0; + else + return order + 1074; + } + +private: + static const int kSignificandSize = 52; + static const int kExponentBias = 0x3FF; + static const int kDenormalExponent = 1 - kExponentBias; + static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000); + static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000); + static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF); + static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000); + + union { + double d_; + uint64_t u_; + }; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_IEEE754_ diff --git a/SourceCode/dep_inc/rapidjson/internal/itoa.h b/SourceCode/dep_inc/rapidjson/internal/itoa.h new file mode 100644 index 0000000..9b1c45c --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/itoa.h @@ -0,0 +1,308 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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 { + +inline const char* GetDigitsLut() { + static const char cDigitsLut[200] = { + '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9', + '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9', + '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9', + '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9', + '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9', + '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9', + '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9', + '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9', + '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9', + '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9' + }; + return cDigitsLut; +} + +inline char* u32toa(uint32_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + + const char* cDigitsLut = GetDigitsLut(); + + if (value < 10000) { + const uint32_t d1 = (value / 100) << 1; + const uint32_t d2 = (value % 100) << 1; + + if (value >= 1000) + *buffer++ = cDigitsLut[d1]; + if (value >= 100) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 10) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + } + else if (value < 100000000) { + // value = bbbbcccc + const uint32_t b = value / 10000; + const uint32_t c = value % 10000; + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + if (value >= 10000000) + *buffer++ = cDigitsLut[d1]; + if (value >= 1000000) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 100000) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + else { + // value = aabbbbcccc in decimal + + const uint32_t a = value / 100000000; // 1 to 42 + value %= 100000000; + + if (a >= 10) { + const unsigned i = a << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else + *buffer++ = static_cast('0' + static_cast(a)); + + const uint32_t b = value / 10000; // 0 to 9999 + const uint32_t c = value % 10000; // 0 to 9999 + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + *buffer++ = cDigitsLut[d1]; + *buffer++ = cDigitsLut[d1 + 1]; + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + return buffer; +} + +inline char* i32toa(int32_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + uint32_t u = static_cast(value); + if (value < 0) { + *buffer++ = '-'; + u = ~u + 1; + } + + return u32toa(u, buffer); +} + +inline char* u64toa(uint64_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + const char* cDigitsLut = GetDigitsLut(); + const uint64_t kTen8 = 100000000; + const uint64_t kTen9 = kTen8 * 10; + const uint64_t kTen10 = kTen8 * 100; + const uint64_t kTen11 = kTen8 * 1000; + const uint64_t kTen12 = kTen8 * 10000; + const uint64_t kTen13 = kTen8 * 100000; + const uint64_t kTen14 = kTen8 * 1000000; + const uint64_t kTen15 = kTen8 * 10000000; + const uint64_t kTen16 = kTen8 * kTen8; + + if (value < kTen8) { + uint32_t v = static_cast(value); + if (v < 10000) { + const uint32_t d1 = (v / 100) << 1; + const uint32_t d2 = (v % 100) << 1; + + if (v >= 1000) + *buffer++ = cDigitsLut[d1]; + if (v >= 100) + *buffer++ = cDigitsLut[d1 + 1]; + if (v >= 10) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + } + else { + // value = bbbbcccc + const uint32_t b = v / 10000; + const uint32_t c = v % 10000; + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + if (value >= 10000000) + *buffer++ = cDigitsLut[d1]; + if (value >= 1000000) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 100000) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + } + else if (value < kTen16) { + const uint32_t v0 = static_cast(value / kTen8); + const uint32_t v1 = static_cast(value % kTen8); + + const uint32_t b0 = v0 / 10000; + const uint32_t c0 = v0 % 10000; + + const uint32_t d1 = (b0 / 100) << 1; + const uint32_t d2 = (b0 % 100) << 1; + + const uint32_t d3 = (c0 / 100) << 1; + const uint32_t d4 = (c0 % 100) << 1; + + const uint32_t b1 = v1 / 10000; + const uint32_t c1 = v1 % 10000; + + const uint32_t d5 = (b1 / 100) << 1; + const uint32_t d6 = (b1 % 100) << 1; + + const uint32_t d7 = (c1 / 100) << 1; + const uint32_t d8 = (c1 % 100) << 1; + + if (value >= kTen15) + *buffer++ = cDigitsLut[d1]; + if (value >= kTen14) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= kTen13) + *buffer++ = cDigitsLut[d2]; + if (value >= kTen12) + *buffer++ = cDigitsLut[d2 + 1]; + if (value >= kTen11) + *buffer++ = cDigitsLut[d3]; + if (value >= kTen10) + *buffer++ = cDigitsLut[d3 + 1]; + if (value >= kTen9) + *buffer++ = cDigitsLut[d4]; + + *buffer++ = cDigitsLut[d4 + 1]; + *buffer++ = cDigitsLut[d5]; + *buffer++ = cDigitsLut[d5 + 1]; + *buffer++ = cDigitsLut[d6]; + *buffer++ = cDigitsLut[d6 + 1]; + *buffer++ = cDigitsLut[d7]; + *buffer++ = cDigitsLut[d7 + 1]; + *buffer++ = cDigitsLut[d8]; + *buffer++ = cDigitsLut[d8 + 1]; + } + else { + const uint32_t a = static_cast(value / kTen16); // 1 to 1844 + value %= kTen16; + + if (a < 10) + *buffer++ = static_cast('0' + static_cast(a)); + else if (a < 100) { + const uint32_t i = a << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else if (a < 1000) { + *buffer++ = static_cast('0' + static_cast(a / 100)); + + const uint32_t i = (a % 100) << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else { + const uint32_t i = (a / 100) << 1; + const uint32_t j = (a % 100) << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + *buffer++ = cDigitsLut[j]; + *buffer++ = cDigitsLut[j + 1]; + } + + const uint32_t v0 = static_cast(value / kTen8); + const uint32_t v1 = static_cast(value % kTen8); + + const uint32_t b0 = v0 / 10000; + const uint32_t c0 = v0 % 10000; + + const uint32_t d1 = (b0 / 100) << 1; + const uint32_t d2 = (b0 % 100) << 1; + + const uint32_t d3 = (c0 / 100) << 1; + const uint32_t d4 = (c0 % 100) << 1; + + const uint32_t b1 = v1 / 10000; + const uint32_t c1 = v1 % 10000; + + const uint32_t d5 = (b1 / 100) << 1; + const uint32_t d6 = (b1 % 100) << 1; + + const uint32_t d7 = (c1 / 100) << 1; + const uint32_t d8 = (c1 % 100) << 1; + + *buffer++ = cDigitsLut[d1]; + *buffer++ = cDigitsLut[d1 + 1]; + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + *buffer++ = cDigitsLut[d5]; + *buffer++ = cDigitsLut[d5 + 1]; + *buffer++ = cDigitsLut[d6]; + *buffer++ = cDigitsLut[d6 + 1]; + *buffer++ = cDigitsLut[d7]; + *buffer++ = cDigitsLut[d7 + 1]; + *buffer++ = cDigitsLut[d8]; + *buffer++ = cDigitsLut[d8 + 1]; + } + + return buffer; +} + +inline char* i64toa(int64_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + uint64_t u = static_cast(value); + if (value < 0) { + *buffer++ = '-'; + u = ~u + 1; + } + + return u64toa(u, buffer); +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ITOA_ diff --git a/SourceCode/dep_inc/rapidjson/internal/meta.h b/SourceCode/dep_inc/rapidjson/internal/meta.h new file mode 100644 index 0000000..d401edf --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/meta.h @@ -0,0 +1,186 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_INTERNAL_META_H_ +#define RAPIDJSON_INTERNAL_META_H_ + +#include "../rapidjson.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(6334) +#endif + +#if RAPIDJSON_HAS_CXX11_TYPETRAITS +#include +#endif + +//@cond RAPIDJSON_INTERNAL +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching +template struct Void { typedef void Type; }; + +/////////////////////////////////////////////////////////////////////////////// +// BoolType, TrueType, FalseType +// +template struct BoolType { + static const bool Value = Cond; + typedef BoolType Type; +}; +typedef BoolType TrueType; +typedef BoolType FalseType; + + +/////////////////////////////////////////////////////////////////////////////// +// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr +// + +template struct SelectIfImpl { template struct Apply { typedef T1 Type; }; }; +template <> struct SelectIfImpl { template struct Apply { typedef T2 Type; }; }; +template struct SelectIfCond : SelectIfImpl::template Apply {}; +template struct SelectIf : SelectIfCond {}; + +template struct AndExprCond : FalseType {}; +template <> struct AndExprCond : TrueType {}; +template struct OrExprCond : TrueType {}; +template <> struct OrExprCond : FalseType {}; + +template struct BoolExpr : SelectIf::Type {}; +template struct NotExpr : SelectIf::Type {}; +template struct AndExpr : AndExprCond::Type {}; +template struct OrExpr : OrExprCond::Type {}; + + +/////////////////////////////////////////////////////////////////////////////// +// AddConst, MaybeAddConst, RemoveConst +template struct AddConst { typedef const T Type; }; +template struct MaybeAddConst : SelectIfCond {}; +template struct RemoveConst { typedef T Type; }; +template struct RemoveConst { typedef T Type; }; + + +/////////////////////////////////////////////////////////////////////////////// +// IsSame, IsConst, IsMoreConst, IsPointer +// +template struct IsSame : FalseType {}; +template struct IsSame : TrueType {}; + +template struct IsConst : FalseType {}; +template struct IsConst : TrueType {}; + +template +struct IsMoreConst + : AndExpr::Type, typename RemoveConst::Type>, + BoolType::Value >= IsConst::Value> >::Type {}; + +template struct IsPointer : FalseType {}; +template struct IsPointer : TrueType {}; + +/////////////////////////////////////////////////////////////////////////////// +// IsBaseOf +// +#if RAPIDJSON_HAS_CXX11_TYPETRAITS + +template struct IsBaseOf + : BoolType< ::std::is_base_of::value> {}; + +#else // simplified version adopted from Boost + +template struct IsBaseOfImpl { + RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0); + RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0); + + typedef char (&Yes)[1]; + typedef char (&No) [2]; + + template + static Yes Check(const D*, T); + static No Check(const B*, int); + + struct Host { + operator const B*() const; + operator const D*(); + }; + + enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) }; +}; + +template struct IsBaseOf + : OrExpr, BoolExpr > >::Type {}; + +#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS + + +////////////////////////////////////////////////////////////////////////// +// EnableIf / DisableIf +// +template struct EnableIfCond { typedef T Type; }; +template struct EnableIfCond { /* empty */ }; + +template struct DisableIfCond { typedef T Type; }; +template struct DisableIfCond { /* empty */ }; + +template +struct EnableIf : EnableIfCond {}; + +template +struct DisableIf : DisableIfCond {}; + +// SFINAE helpers +struct SfinaeTag {}; +template struct RemoveSfinaeTag; +template struct RemoveSfinaeTag { typedef T Type; }; + +#define RAPIDJSON_REMOVEFPTR_(type) \ + typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \ + < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type + +#define RAPIDJSON_ENABLEIF(cond) \ + typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \ + ::Type * = NULL + +#define RAPIDJSON_DISABLEIF(cond) \ + typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \ + ::Type * = NULL + +#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \ + typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \ + ::Type + +#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \ + typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \ + ::Type + +} // namespace internal +RAPIDJSON_NAMESPACE_END +//@endcond + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_META_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/pow10.h b/SourceCode/dep_inc/rapidjson/internal/pow10.h new file mode 100644 index 0000000..02f475d --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/pow10.h @@ -0,0 +1,55 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_POW10_ +#define RAPIDJSON_POW10_ + +#include "../rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Computes integer powers of 10 in double (10.0^n). +/*! This function uses lookup table for fast and accurate results. + \param n non-negative exponent. Must <= 308. + \return 10.0^n +*/ +inline double Pow10(int n) { + static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes + 1e+0, + 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, 1e+8, 1e+9, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, + 1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40, + 1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60, + 1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80, + 1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100, + 1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120, + 1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140, + 1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160, + 1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180, + 1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200, + 1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220, + 1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240, + 1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260, + 1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280, + 1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300, + 1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308 + }; + RAPIDJSON_ASSERT(n >= 0 && n <= 308); + return e[n]; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_POW10_ diff --git a/SourceCode/dep_inc/rapidjson/internal/regex.h b/SourceCode/dep_inc/rapidjson/internal/regex.h new file mode 100644 index 0000000..de06718 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/regex.h @@ -0,0 +1,732 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_INTERNAL_REGEX_H_ +#define RAPIDJSON_INTERNAL_REGEX_H_ + +#include "../allocators.h" +#include "../stream.h" +#include "stack.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +RAPIDJSON_DIAG_OFF(implicit-fallthrough) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#if __GNUC__ >= 7 +RAPIDJSON_DIAG_OFF(implicit-fallthrough) +#endif +#endif + +#ifndef RAPIDJSON_REGEX_VERBOSE +#define RAPIDJSON_REGEX_VERBOSE 0 +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +/////////////////////////////////////////////////////////////////////////////// +// DecodedStream + +template +class DecodedStream { +public: + DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); } + unsigned Peek() { return codepoint_; } + unsigned Take() { + unsigned c = codepoint_; + if (c) // No further decoding when '\0' + Decode(); + return c; + } + +private: + void Decode() { + if (!Encoding::Decode(ss_, &codepoint_)) + codepoint_ = 0; + } + + SourceStream& ss_; + unsigned codepoint_; +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericRegex + +static const SizeType kRegexInvalidState = ~SizeType(0); //!< Represents an invalid index in GenericRegex::State::out, out1 +static const SizeType kRegexInvalidRange = ~SizeType(0); + +template +class GenericRegexSearch; + +//! Regular expression engine with subset of ECMAscript grammar. +/*! + Supported regular expression syntax: + - \c ab Concatenation + - \c a|b Alternation + - \c a? Zero or one + - \c a* Zero or more + - \c a+ One or more + - \c a{3} Exactly 3 times + - \c a{3,} At least 3 times + - \c a{3,5} 3 to 5 times + - \c (ab) Grouping + - \c ^a At the beginning + - \c a$ At the end + - \c . Any character + - \c [abc] Character classes + - \c [a-c] Character class range + - \c [a-z0-9_] Character class combination + - \c [^abc] Negated character classes + - \c [^a-c] Negated character class range + - \c [\b] Backspace (U+0008) + - \c \\| \\\\ ... Escape characters + - \c \\f Form feed (U+000C) + - \c \\n Line feed (U+000A) + - \c \\r Carriage return (U+000D) + - \c \\t Tab (U+0009) + - \c \\v Vertical tab (U+000B) + + \note This is a Thompson NFA engine, implemented with reference to + Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", + https://swtch.com/~rsc/regexp/regexp1.html +*/ +template +class GenericRegex { +public: + typedef Encoding EncodingType; + typedef typename Encoding::Ch Ch; + template friend class GenericRegexSearch; + + GenericRegex(const Ch* source, Allocator* allocator = 0) : + states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), + anchorBegin_(), anchorEnd_() + { + GenericStringStream ss(source); + DecodedStream, Encoding> ds(ss); + Parse(ds); + } + + ~GenericRegex() {} + + bool IsValid() const { + return root_ != kRegexInvalidState; + } + +private: + enum Operator { + kZeroOrOne, + kZeroOrMore, + kOneOrMore, + kConcatenation, + kAlternation, + kLeftParenthesis + }; + + static const unsigned kAnyCharacterClass = 0xFFFFFFFF; //!< For '.' + static const unsigned kRangeCharacterClass = 0xFFFFFFFE; + static const unsigned kRangeNegationFlag = 0x80000000; + + struct Range { + unsigned start; // + unsigned end; + SizeType next; + }; + + struct State { + SizeType out; //!< Equals to kInvalid for matching state + SizeType out1; //!< Equals to non-kInvalid for split + SizeType rangeStart; + unsigned codepoint; + }; + + struct Frag { + Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {} + SizeType start; + SizeType out; //!< link-list of all output states + SizeType minIndex; + }; + + State& GetState(SizeType index) { + RAPIDJSON_ASSERT(index < stateCount_); + return states_.template Bottom()[index]; + } + + const State& GetState(SizeType index) const { + RAPIDJSON_ASSERT(index < stateCount_); + return states_.template Bottom()[index]; + } + + Range& GetRange(SizeType index) { + RAPIDJSON_ASSERT(index < rangeCount_); + return ranges_.template Bottom()[index]; + } + + const Range& GetRange(SizeType index) const { + RAPIDJSON_ASSERT(index < rangeCount_); + return ranges_.template Bottom()[index]; + } + + template + void Parse(DecodedStream& ds) { + Allocator allocator; + Stack operandStack(&allocator, 256); // Frag + Stack operatorStack(&allocator, 256); // Operator + Stack atomCountStack(&allocator, 256); // unsigned (Atom per parenthesis) + + *atomCountStack.template Push() = 0; + + unsigned codepoint; + while (ds.Peek() != 0) { + switch (codepoint = ds.Take()) { + case '^': + anchorBegin_ = true; + break; + + case '$': + anchorEnd_ = true; + break; + + case '|': + while (!operatorStack.Empty() && *operatorStack.template Top() < kAlternation) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + *operatorStack.template Push() = kAlternation; + *atomCountStack.template Top() = 0; + break; + + case '(': + *operatorStack.template Push() = kLeftParenthesis; + *atomCountStack.template Push() = 0; + break; + + case ')': + while (!operatorStack.Empty() && *operatorStack.template Top() != kLeftParenthesis) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + if (operatorStack.Empty()) + return; + operatorStack.template Pop(1); + atomCountStack.template Pop(1); + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '?': + if (!Eval(operandStack, kZeroOrOne)) + return; + break; + + case '*': + if (!Eval(operandStack, kZeroOrMore)) + return; + break; + + case '+': + if (!Eval(operandStack, kOneOrMore)) + return; + break; + + case '{': + { + unsigned n, m; + if (!ParseUnsigned(ds, &n)) + return; + + if (ds.Peek() == ',') { + ds.Take(); + if (ds.Peek() == '}') + m = kInfinityQuantifier; + else if (!ParseUnsigned(ds, &m) || m < n) + return; + } + else + m = n; + + if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}') + return; + ds.Take(); + } + break; + + case '.': + PushOperand(operandStack, kAnyCharacterClass); + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '[': + { + SizeType range; + if (!ParseRange(ds, &range)) + return; + SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass); + GetState(s).rangeStart = range; + *operandStack.template Push() = Frag(s, s, s); + } + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '\\': // Escape character + if (!CharacterEscape(ds, &codepoint)) + return; // Unsupported escape character + // fall through to default + + default: // Pattern character + PushOperand(operandStack, codepoint); + ImplicitConcatenation(atomCountStack, operatorStack); + } + } + + while (!operatorStack.Empty()) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + + // Link the operand to matching state. + if (operandStack.GetSize() == sizeof(Frag)) { + Frag* e = operandStack.template Pop(1); + Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0)); + root_ = e->start; + +#if RAPIDJSON_REGEX_VERBOSE + printf("root: %d\n", root_); + for (SizeType i = 0; i < stateCount_ ; i++) { + State& s = GetState(i); + printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint); + } + printf("\n"); +#endif + } + } + + SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) { + State* s = states_.template Push(); + s->out = out; + s->out1 = out1; + s->codepoint = codepoint; + s->rangeStart = kRegexInvalidRange; + return stateCount_++; + } + + void PushOperand(Stack& operandStack, unsigned codepoint) { + SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint); + *operandStack.template Push() = Frag(s, s, s); + } + + void ImplicitConcatenation(Stack& atomCountStack, Stack& operatorStack) { + if (*atomCountStack.template Top()) + *operatorStack.template Push() = kConcatenation; + (*atomCountStack.template Top())++; + } + + SizeType Append(SizeType l1, SizeType l2) { + SizeType old = l1; + while (GetState(l1).out != kRegexInvalidState) + l1 = GetState(l1).out; + GetState(l1).out = l2; + return old; + } + + void Patch(SizeType l, SizeType s) { + for (SizeType next; l != kRegexInvalidState; l = next) { + next = GetState(l).out; + GetState(l).out = s; + } + } + + bool Eval(Stack& operandStack, Operator op) { + switch (op) { + case kConcatenation: + RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2); + { + Frag e2 = *operandStack.template Pop(1); + Frag e1 = *operandStack.template Pop(1); + Patch(e1.out, e2.start); + *operandStack.template Push() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex)); + } + return true; + + case kAlternation: + if (operandStack.GetSize() >= sizeof(Frag) * 2) { + Frag e2 = *operandStack.template Pop(1); + Frag e1 = *operandStack.template Pop(1); + SizeType s = NewState(e1.start, e2.start, 0); + *operandStack.template Push() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex)); + return true; + } + return false; + + case kZeroOrOne: + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + *operandStack.template Push() = Frag(s, Append(e.out, s), e.minIndex); + return true; + } + return false; + + case kZeroOrMore: + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + Patch(e.out, s); + *operandStack.template Push() = Frag(s, s, e.minIndex); + return true; + } + return false; + + default: + RAPIDJSON_ASSERT(op == kOneOrMore); + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + Patch(e.out, s); + *operandStack.template Push() = Frag(e.start, s, e.minIndex); + return true; + } + return false; + } + } + + bool EvalQuantifier(Stack& operandStack, unsigned n, unsigned m) { + RAPIDJSON_ASSERT(n <= m); + RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag)); + + if (n == 0) { + if (m == 0) // a{0} not support + return false; + else if (m == kInfinityQuantifier) + Eval(operandStack, kZeroOrMore); // a{0,} -> a* + else { + Eval(operandStack, kZeroOrOne); // a{0,5} -> a? + for (unsigned i = 0; i < m - 1; i++) + CloneTopOperand(operandStack); // a{0,5} -> a? a? a? a? a? + for (unsigned i = 0; i < m - 1; i++) + Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a? + } + return true; + } + + for (unsigned i = 0; i < n - 1; i++) // a{3} -> a a a + CloneTopOperand(operandStack); + + if (m == kInfinityQuantifier) + Eval(operandStack, kOneOrMore); // a{3,} -> a a a+ + else if (m > n) { + CloneTopOperand(operandStack); // a{3,5} -> a a a a + Eval(operandStack, kZeroOrOne); // a{3,5} -> a a a a? + for (unsigned i = n; i < m - 1; i++) + CloneTopOperand(operandStack); // a{3,5} -> a a a a? a? + for (unsigned i = n; i < m; i++) + Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a? + } + + for (unsigned i = 0; i < n - 1; i++) + Eval(operandStack, kConcatenation); // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a? + + return true; + } + + static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; } + + void CloneTopOperand(Stack& operandStack) { + const Frag src = *operandStack.template Top(); // Copy constructor to prevent invalidation + SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_) + State* s = states_.template Push(count); + memcpy(s, &GetState(src.minIndex), count * sizeof(State)); + for (SizeType j = 0; j < count; j++) { + if (s[j].out != kRegexInvalidState) + s[j].out += count; + if (s[j].out1 != kRegexInvalidState) + s[j].out1 += count; + } + *operandStack.template Push() = Frag(src.start + count, src.out + count, src.minIndex + count); + stateCount_ += count; + } + + template + bool ParseUnsigned(DecodedStream& ds, unsigned* u) { + unsigned r = 0; + if (ds.Peek() < '0' || ds.Peek() > '9') + return false; + while (ds.Peek() >= '0' && ds.Peek() <= '9') { + if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295 + return false; // overflow + r = r * 10 + (ds.Take() - '0'); + } + *u = r; + return true; + } + + template + bool ParseRange(DecodedStream& ds, SizeType* range) { + bool isBegin = true; + bool negate = false; + int step = 0; + SizeType start = kRegexInvalidRange; + SizeType current = kRegexInvalidRange; + unsigned codepoint; + while ((codepoint = ds.Take()) != 0) { + if (isBegin) { + isBegin = false; + if (codepoint == '^') { + negate = true; + continue; + } + } + + switch (codepoint) { + case ']': + if (start == kRegexInvalidRange) + return false; // Error: nothing inside [] + if (step == 2) { // Add trailing '-' + SizeType r = NewRange('-'); + RAPIDJSON_ASSERT(current != kRegexInvalidRange); + GetRange(current).next = r; + } + if (negate) + GetRange(start).start |= kRangeNegationFlag; + *range = start; + return true; + + case '\\': + if (ds.Peek() == 'b') { + ds.Take(); + codepoint = 0x0008; // Escape backspace character + } + else if (!CharacterEscape(ds, &codepoint)) + return false; + // fall through to default + + default: + switch (step) { + case 1: + if (codepoint == '-') { + step++; + break; + } + // fall through to step 0 for other characters + + case 0: + { + SizeType r = NewRange(codepoint); + if (current != kRegexInvalidRange) + GetRange(current).next = r; + if (start == kRegexInvalidRange) + start = r; + current = r; + } + step = 1; + break; + + default: + RAPIDJSON_ASSERT(step == 2); + GetRange(current).end = codepoint; + step = 0; + } + } + } + return false; + } + + SizeType NewRange(unsigned codepoint) { + Range* r = ranges_.template Push(); + r->start = r->end = codepoint; + r->next = kRegexInvalidRange; + return rangeCount_++; + } + + template + bool CharacterEscape(DecodedStream& ds, unsigned* escapedCodepoint) { + unsigned codepoint; + switch (codepoint = ds.Take()) { + case '^': + case '$': + case '|': + case '(': + case ')': + case '?': + case '*': + case '+': + case '.': + case '[': + case ']': + case '{': + case '}': + case '\\': + *escapedCodepoint = codepoint; return true; + case 'f': *escapedCodepoint = 0x000C; return true; + case 'n': *escapedCodepoint = 0x000A; return true; + case 'r': *escapedCodepoint = 0x000D; return true; + case 't': *escapedCodepoint = 0x0009; return true; + case 'v': *escapedCodepoint = 0x000B; return true; + default: + return false; // Unsupported escape character + } + } + + Stack states_; + Stack ranges_; + SizeType root_; + SizeType stateCount_; + SizeType rangeCount_; + + static const unsigned kInfinityQuantifier = ~0u; + + // For SearchWithAnchoring() + bool anchorBegin_; + bool anchorEnd_; +}; + +template +class GenericRegexSearch { +public: + typedef typename RegexType::EncodingType Encoding; + typedef typename Encoding::Ch Ch; + + GenericRegexSearch(const RegexType& regex, Allocator* allocator = 0) : + regex_(regex), allocator_(allocator), ownAllocator_(0), + state0_(allocator, 0), state1_(allocator, 0), stateSet_() + { + RAPIDJSON_ASSERT(regex_.IsValid()); + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + stateSet_ = static_cast(allocator_->Malloc(GetStateSetSize())); + state0_.template Reserve(regex_.stateCount_); + state1_.template Reserve(regex_.stateCount_); + } + + ~GenericRegexSearch() { + Allocator::Free(stateSet_); + RAPIDJSON_DELETE(ownAllocator_); + } + + template + bool Match(InputStream& is) { + return SearchWithAnchoring(is, true, true); + } + + bool Match(const Ch* s) { + GenericStringStream is(s); + return Match(is); + } + + template + bool Search(InputStream& is) { + return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_); + } + + bool Search(const Ch* s) { + GenericStringStream is(s); + return Search(is); + } + +private: + typedef typename RegexType::State State; + typedef typename RegexType::Range Range; + + template + bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) { + DecodedStream ds(is); + + state0_.Clear(); + Stack *current = &state0_, *next = &state1_; + const size_t stateSetSize = GetStateSetSize(); + std::memset(stateSet_, 0, stateSetSize); + + bool matched = AddState(*current, regex_.root_); + unsigned codepoint; + while (!current->Empty() && (codepoint = ds.Take()) != 0) { + std::memset(stateSet_, 0, stateSetSize); + next->Clear(); + matched = false; + for (const SizeType* s = current->template Bottom(); s != current->template End(); ++s) { + const State& sr = regex_.GetState(*s); + if (sr.codepoint == codepoint || + sr.codepoint == RegexType::kAnyCharacterClass || + (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint))) + { + matched = AddState(*next, sr.out) || matched; + if (!anchorEnd && matched) + return true; + } + if (!anchorBegin) + AddState(*next, regex_.root_); + } + internal::Swap(current, next); + } + + return matched; + } + + size_t GetStateSetSize() const { + return (regex_.stateCount_ + 31) / 32 * 4; + } + + // Return whether the added states is a match state + bool AddState(Stack& l, SizeType index) { + RAPIDJSON_ASSERT(index != kRegexInvalidState); + + const State& s = regex_.GetState(index); + if (s.out1 != kRegexInvalidState) { // Split + bool matched = AddState(l, s.out); + return AddState(l, s.out1) || matched; + } + else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) { + stateSet_[index >> 5] |= (1u << (index & 31)); + *l.template PushUnsafe() = index; + } + return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation. + } + + bool MatchRange(SizeType rangeIndex, unsigned codepoint) const { + bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0; + while (rangeIndex != kRegexInvalidRange) { + const Range& r = regex_.GetRange(rangeIndex); + if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end) + return yes; + rangeIndex = r.next; + } + return !yes; + } + + const RegexType& regex_; + Allocator* allocator_; + Allocator* ownAllocator_; + Stack state0_; + Stack state1_; + uint32_t* stateSet_; +}; + +typedef GenericRegex > Regex; +typedef GenericRegexSearch RegexSearch; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_REGEX_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/stack.h b/SourceCode/dep_inc/rapidjson/internal/stack.h new file mode 100644 index 0000000..89558d0 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/stack.h @@ -0,0 +1,231 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_INTERNAL_STACK_H_ +#define RAPIDJSON_INTERNAL_STACK_H_ + +#include "../allocators.h" +#include "swap.h" + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +/////////////////////////////////////////////////////////////////////////////// +// Stack + +//! A type-unsafe stack for storing different types of data. +/*! \tparam Allocator Allocator for allocating stack memory. +*/ +template +class Stack { +public: + // Optimization note: Do not allocate memory for stack_ in constructor. + // Do it lazily when first Push() -> Expand() -> Resize(). + Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) { + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Stack(Stack&& rhs) + : allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + stack_(rhs.stack_), + stackTop_(rhs.stackTop_), + stackEnd_(rhs.stackEnd_), + initialCapacity_(rhs.initialCapacity_) + { + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.stack_ = 0; + rhs.stackTop_ = 0; + rhs.stackEnd_ = 0; + rhs.initialCapacity_ = 0; + } +#endif + + ~Stack() { + Destroy(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Stack& operator=(Stack&& rhs) { + if (&rhs != this) + { + Destroy(); + + allocator_ = rhs.allocator_; + ownAllocator_ = rhs.ownAllocator_; + stack_ = rhs.stack_; + stackTop_ = rhs.stackTop_; + stackEnd_ = rhs.stackEnd_; + initialCapacity_ = rhs.initialCapacity_; + + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.stack_ = 0; + rhs.stackTop_ = 0; + rhs.stackEnd_ = 0; + rhs.initialCapacity_ = 0; + } + return *this; + } +#endif + + void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT { + internal::Swap(allocator_, rhs.allocator_); + internal::Swap(ownAllocator_, rhs.ownAllocator_); + internal::Swap(stack_, rhs.stack_); + internal::Swap(stackTop_, rhs.stackTop_); + internal::Swap(stackEnd_, rhs.stackEnd_); + internal::Swap(initialCapacity_, rhs.initialCapacity_); + } + + void Clear() { stackTop_ = stack_; } + + void ShrinkToFit() { + if (Empty()) { + // If the stack is empty, completely deallocate the memory. + Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc) + stack_ = 0; + stackTop_ = 0; + stackEnd_ = 0; + } + else + Resize(GetSize()); + } + + // Optimization note: try to minimize the size of this function for force inline. + // Expansion is run very infrequently, so it is moved to another (probably non-inline) function. + template + RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) { + // Expand the stack if needed + if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_)) + Expand(count); + } + + template + RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) { + Reserve(count); + return PushUnsafe(count); + } + + template + RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) { + RAPIDJSON_ASSERT(stackTop_); + RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_); + T* ret = reinterpret_cast(stackTop_); + stackTop_ += sizeof(T) * count; + return ret; + } + + template + T* Pop(size_t count) { + RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T)); + stackTop_ -= count * sizeof(T); + return reinterpret_cast(stackTop_); + } + + template + T* Top() { + RAPIDJSON_ASSERT(GetSize() >= sizeof(T)); + return reinterpret_cast(stackTop_ - sizeof(T)); + } + + template + const T* Top() const { + RAPIDJSON_ASSERT(GetSize() >= sizeof(T)); + return reinterpret_cast(stackTop_ - sizeof(T)); + } + + template + T* End() { return reinterpret_cast(stackTop_); } + + template + const T* End() const { return reinterpret_cast(stackTop_); } + + template + T* Bottom() { return reinterpret_cast(stack_); } + + template + const T* Bottom() const { return reinterpret_cast(stack_); } + + bool HasAllocator() const { + return allocator_ != 0; + } + + Allocator& GetAllocator() { + RAPIDJSON_ASSERT(allocator_); + return *allocator_; + } + + bool Empty() const { return stackTop_ == stack_; } + size_t GetSize() const { return static_cast(stackTop_ - stack_); } + size_t GetCapacity() const { return static_cast(stackEnd_ - stack_); } + +private: + template + void Expand(size_t count) { + // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity. + size_t newCapacity; + if (stack_ == 0) { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + newCapacity = initialCapacity_; + } else { + newCapacity = GetCapacity(); + newCapacity += (newCapacity + 1) / 2; + } + size_t newSize = GetSize() + sizeof(T) * count; + if (newCapacity < newSize) + newCapacity = newSize; + + Resize(newCapacity); + } + + void Resize(size_t newCapacity) { + const size_t size = GetSize(); // Backup the current size + stack_ = static_cast(allocator_->Realloc(stack_, GetCapacity(), newCapacity)); + stackTop_ = stack_ + size; + stackEnd_ = stack_ + newCapacity; + } + + void Destroy() { + Allocator::Free(stack_); + RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack + } + + // Prohibit copy constructor & assignment operator. + Stack(const Stack&); + Stack& operator=(const Stack&); + + Allocator* allocator_; + Allocator* ownAllocator_; + char *stack_; + char *stackTop_; + char *stackEnd_; + size_t initialCapacity_; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_STACK_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/strfunc.h b/SourceCode/dep_inc/rapidjson/internal/strfunc.h new file mode 100644 index 0000000..226439a --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/strfunc.h @@ -0,0 +1,69 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_INTERNAL_STRFUNC_H_ +#define RAPIDJSON_INTERNAL_STRFUNC_H_ + +#include "../stream.h" +#include + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Custom strlen() which works on different character types. +/*! \tparam Ch Character type (e.g. char, wchar_t, short) + \param s Null-terminated input string. + \return Number of characters in the string. + \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints. +*/ +template +inline SizeType StrLen(const Ch* s) { + RAPIDJSON_ASSERT(s != 0); + const Ch* p = s; + while (*p) ++p; + return SizeType(p - s); +} + +template <> +inline SizeType StrLen(const char* s) { + return SizeType(std::strlen(s)); +} + +template <> +inline SizeType StrLen(const wchar_t* s) { + return SizeType(std::wcslen(s)); +} + +//! Returns number of code points in a encoded string. +template +bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) { + RAPIDJSON_ASSERT(s != 0); + RAPIDJSON_ASSERT(outCount != 0); + GenericStringStream is(s); + const typename Encoding::Ch* end = s + length; + SizeType count = 0; + while (is.src_ < end) { + unsigned codepoint; + if (!Encoding::Decode(is, &codepoint)) + return false; + count++; + } + *outCount = count; + return true; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_INTERNAL_STRFUNC_H_ diff --git a/SourceCode/dep_inc/rapidjson/internal/strtod.h b/SourceCode/dep_inc/rapidjson/internal/strtod.h new file mode 100644 index 0000000..dfca22b --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/strtod.h @@ -0,0 +1,290 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_STRTOD_ +#define RAPIDJSON_STRTOD_ + +#include "ieee754.h" +#include "biginteger.h" +#include "diyfp.h" +#include "pow10.h" +#include +#include + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +inline double FastPath(double significand, int exp) { + if (exp < -308) + return 0.0; + else if (exp >= 0) + return significand * internal::Pow10(exp); + else + return significand / internal::Pow10(-exp); +} + +inline double StrtodNormalPrecision(double d, int p) { + if (p < -308) { + // Prevent expSum < -308, making Pow10(p) = 0 + d = FastPath(d, -308); + d = FastPath(d, p + 308); + } + else + d = FastPath(d, p); + return d; +} + +template +inline T Min3(T a, T b, T c) { + T m = a; + if (m > b) m = b; + if (m > c) m = c; + return m; +} + +inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) { + const Double db(b); + const uint64_t bInt = db.IntegerSignificand(); + const int bExp = db.IntegerExponent(); + const int hExp = bExp - 1; + + int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0; + + // Adjust for decimal exponent + if (dExp >= 0) { + dS_Exp2 += dExp; + dS_Exp5 += dExp; + } + else { + bS_Exp2 -= dExp; + bS_Exp5 -= dExp; + hS_Exp2 -= dExp; + hS_Exp5 -= dExp; + } + + // Adjust for binary exponent + if (bExp >= 0) + bS_Exp2 += bExp; + else { + dS_Exp2 -= bExp; + hS_Exp2 -= bExp; + } + + // Adjust for half ulp exponent + if (hExp >= 0) + hS_Exp2 += hExp; + else { + dS_Exp2 -= hExp; + bS_Exp2 -= hExp; + } + + // Remove common power of two factor from all three scaled values + int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2); + dS_Exp2 -= common_Exp2; + bS_Exp2 -= common_Exp2; + hS_Exp2 -= common_Exp2; + + BigInteger dS = d; + dS.MultiplyPow5(static_cast(dS_Exp5)) <<= static_cast(dS_Exp2); + + BigInteger bS(bInt); + bS.MultiplyPow5(static_cast(bS_Exp5)) <<= static_cast(bS_Exp2); + + BigInteger hS(1); + hS.MultiplyPow5(static_cast(hS_Exp5)) <<= static_cast(hS_Exp2); + + BigInteger delta(0); + dS.Difference(bS, &delta); + + return delta.Compare(hS); +} + +inline bool StrtodFast(double d, int p, double* result) { + // Use fast path for string-to-double conversion if possible + // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/ + if (p > 22 && p < 22 + 16) { + // Fast Path Cases In Disguise + d *= internal::Pow10(p - 22); + p = 22; + } + + if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1 + *result = FastPath(d, p); + return true; + } + else + return false; +} + +// Compute an approximation and see if it is within 1/2 ULP +inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) { + uint64_t significand = 0; + int i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999 + for (; i < dLen; i++) { + if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || + (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5')) + break; + significand = significand * 10u + static_cast(decimals[i] - '0'); + } + + if (i < dLen && decimals[i] >= '5') // Rounding + significand++; + + int remaining = dLen - i; + const int kUlpShift = 3; + const int kUlp = 1 << kUlpShift; + int64_t error = (remaining == 0) ? 0 : kUlp / 2; + + DiyFp v(significand, 0); + v = v.Normalize(); + error <<= -v.e; + + dExp += remaining; + + int actualExp; + DiyFp cachedPower = GetCachedPower10(dExp, &actualExp); + if (actualExp != dExp) { + static const DiyFp kPow10[] = { + DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60), // 10^1 + DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57), // 10^2 + DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54), // 10^3 + DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50), // 10^4 + DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47), // 10^5 + DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44), // 10^6 + DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40) // 10^7 + }; + int adjustment = dExp - actualExp; + RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8); + v = v * kPow10[adjustment - 1]; + if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit + error += kUlp / 2; + } + + v = v * cachedPower; + + error += kUlp + (error == 0 ? 0 : 1); + + const int oldExp = v.e; + v = v.Normalize(); + error <<= oldExp - v.e; + + const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e); + int precisionSize = 64 - effectiveSignificandSize; + if (precisionSize + kUlpShift >= 64) { + int scaleExp = (precisionSize + kUlpShift) - 63; + v.f >>= scaleExp; + v.e += scaleExp; + error = (error >> scaleExp) + 1 + kUlp; + precisionSize -= scaleExp; + } + + DiyFp rounded(v.f >> precisionSize, v.e + precisionSize); + const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp; + const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp; + if (precisionBits >= halfWay + static_cast(error)) { + rounded.f++; + if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340) + rounded.f >>= 1; + rounded.e++; + } + } + + *result = rounded.ToDouble(); + + return halfWay - static_cast(error) >= precisionBits || precisionBits >= halfWay + static_cast(error); +} + +inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) { + RAPIDJSON_ASSERT(dLen >= 0); + const BigInteger dInt(decimals, static_cast(dLen)); + Double a(approx); + int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp); + if (cmp < 0) + return a.Value(); // within half ULP + else if (cmp == 0) { + // Round towards even + if (a.Significand() & 1) + return a.NextPositiveDouble(); + else + return a.Value(); + } + else // adjustment + return a.NextPositiveDouble(); +} + +inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) { + RAPIDJSON_ASSERT(d >= 0.0); + RAPIDJSON_ASSERT(length >= 1); + + double result = 0.0; + if (StrtodFast(d, p, &result)) + return result; + + RAPIDJSON_ASSERT(length <= INT_MAX); + int dLen = static_cast(length); + + RAPIDJSON_ASSERT(length >= decimalPosition); + RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX); + int dExpAdjust = static_cast(length - decimalPosition); + + RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust); + int dExp = exp - dExpAdjust; + + // Make sure length+dExp does not overflow + RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen); + + // Trim leading zeros + while (dLen > 0 && *decimals == '0') { + dLen--; + decimals++; + } + + // Trim trailing zeros + while (dLen > 0 && decimals[dLen - 1] == '0') { + dLen--; + dExp++; + } + + if (dLen == 0) { // Buffer only contains zeros. + return 0.0; + } + + // Trim right-most digits + const int kMaxDecimalDigit = 767 + 1; + if (dLen > kMaxDecimalDigit) { + dExp += dLen - kMaxDecimalDigit; + dLen = kMaxDecimalDigit; + } + + // If too small, underflow to zero. + // Any x <= 10^-324 is interpreted as zero. + if (dLen + dExp <= -324) + return 0.0; + + // If too large, overflow to infinity. + // Any x >= 10^309 is interpreted as +infinity. + if (dLen + dExp > 309) + return std::numeric_limits::infinity(); + + if (StrtodDiyFp(decimals, dLen, dExp, &result)) + return result; + + // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison + return StrtodBigInteger(result, decimals, dLen, dExp); +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_STRTOD_ diff --git a/SourceCode/dep_inc/rapidjson/internal/swap.h b/SourceCode/dep_inc/rapidjson/internal/swap.h new file mode 100644 index 0000000..666e49f --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/internal/swap.h @@ -0,0 +1,46 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_INTERNAL_SWAP_H_ +#define RAPIDJSON_INTERNAL_SWAP_H_ + +#include "../rapidjson.h" + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Custom swap() to avoid dependency on C++ header +/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only. + \note This has the same semantics as std::swap(). +*/ +template +inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT { + T tmp = a; + a = b; + b = tmp; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_SWAP_H_ diff --git a/SourceCode/dep_inc/rapidjson/istreamwrapper.h b/SourceCode/dep_inc/rapidjson/istreamwrapper.h new file mode 100644 index 0000000..5f81698 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/istreamwrapper.h @@ -0,0 +1,113 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_ISTREAMWRAPPER_H_ +#define RAPIDJSON_ISTREAMWRAPPER_H_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept. +/*! + The classes can be wrapped including but not limited to: + + - \c std::istringstream + - \c std::stringstream + - \c std::wistringstream + - \c std::wstringstream + - \c std::ifstream + - \c std::fstream + - \c std::wifstream + - \c std::wfstream + + \tparam StreamType Class derived from \c std::basic_istream. +*/ + +template +class BasicIStreamWrapper { +public: + typedef typename StreamType::char_type Ch; + BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {} + + Ch Peek() const { + typename StreamType::int_type c = stream_.peek(); + return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast(c) : static_cast('\0'); + } + + Ch Take() { + typename StreamType::int_type c = stream_.get(); + if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) { + count_++; + return static_cast(c); + } + else + return '\0'; + } + + // tellg() may return -1 when failed. So we count by ourself. + size_t Tell() const { return count_; } + + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream. + int i; + bool hasError = false; + for (i = 0; i < 4; ++i) { + typename StreamType::int_type c = stream_.get(); + if (c == StreamType::traits_type::eof()) { + hasError = true; + stream_.clear(); + break; + } + peekBuffer_[i] = static_cast(c); + } + for (--i; i >= 0; --i) + stream_.putback(peekBuffer_[i]); + return !hasError ? peekBuffer_ : 0; + } + +private: + BasicIStreamWrapper(const BasicIStreamWrapper&); + BasicIStreamWrapper& operator=(const BasicIStreamWrapper&); + + StreamType& stream_; + size_t count_; //!< Number of characters read. Note: + mutable Ch peekBuffer_[4]; +}; + +typedef BasicIStreamWrapper IStreamWrapper; +typedef BasicIStreamWrapper WIStreamWrapper; + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ISTREAMWRAPPER_H_ diff --git a/SourceCode/dep_inc/rapidjson/memorybuffer.h b/SourceCode/dep_inc/rapidjson/memorybuffer.h new file mode 100644 index 0000000..39bee1d --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/memorybuffer.h @@ -0,0 +1,70 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_MEMORYBUFFER_H_ +#define RAPIDJSON_MEMORYBUFFER_H_ + +#include "stream.h" +#include "internal/stack.h" + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory output byte stream. +/*! + This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream. + + It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file. + + Differences between MemoryBuffer and StringBuffer: + 1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. + 2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator. + + \tparam Allocator type for allocating memory buffer. + \note implements Stream concept +*/ +template +struct GenericMemoryBuffer { + typedef char Ch; // byte + + GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {} + + void Put(Ch c) { *stack_.template Push() = c; } + void Flush() {} + + void Clear() { stack_.Clear(); } + void ShrinkToFit() { stack_.ShrinkToFit(); } + Ch* Push(size_t count) { return stack_.template Push(count); } + void Pop(size_t count) { stack_.template Pop(count); } + + const Ch* GetBuffer() const { + return stack_.template Bottom(); + } + + size_t GetSize() const { return stack_.GetSize(); } + + static const size_t kDefaultCapacity = 256; + mutable internal::Stack stack_; +}; + +typedef GenericMemoryBuffer<> MemoryBuffer; + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) { + std::memset(memoryBuffer.stack_.Push(n), c, n * sizeof(c)); +} + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_MEMORYBUFFER_H_ diff --git a/SourceCode/dep_inc/rapidjson/memorystream.h b/SourceCode/dep_inc/rapidjson/memorystream.h new file mode 100644 index 0000000..1d71d8a --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/memorystream.h @@ -0,0 +1,71 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_MEMORYSTREAM_H_ +#define RAPIDJSON_MEMORYSTREAM_H_ + +#include "stream.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(missing-noreturn) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory input byte stream. +/*! + This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream. + + It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file. + + Differences between MemoryStream and StringStream: + 1. StringStream has encoding but MemoryStream is a byte stream. + 2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source. + 3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4(). + \note implements Stream concept +*/ +struct MemoryStream { + typedef char Ch; // byte + + MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {} + + Ch Peek() const { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; } + Ch Take() { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; } + size_t Tell() const { return static_cast(src_ - begin_); } + + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + return Tell() + 4 <= size_ ? src_ : 0; + } + + const Ch* src_; //!< Current read position. + const Ch* begin_; //!< Original head of the string. + const Ch* end_; //!< End of stream. + size_t size_; //!< Size of the stream. +}; + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_MEMORYBUFFER_H_ diff --git a/SourceCode/dep_inc/rapidjson/msinttypes/inttypes.h b/SourceCode/dep_inc/rapidjson/msinttypes/inttypes.h new file mode 100644 index 0000000..1811128 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/msinttypes/inttypes.h @@ -0,0 +1,316 @@ +// ISO C9x compliant inttypes.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2013 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the product nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +// 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 ] + +#ifndef _MSC_INTTYPES_H_ // [ +#define _MSC_INTTYPES_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include "stdint.h" + +// miloyip: VC supports inttypes.h since VC2013 +#if _MSC_VER >= 1800 +#include +#else + +// 7.8 Format conversion of integer types + +typedef struct { + intmax_t quot; + intmax_t rem; +} imaxdiv_t; + +// 7.8.1 Macros for format specifiers + +#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198 + +// The fprintf macros for signed integers are: +#define PRId8 "d" +#define PRIi8 "i" +#define PRIdLEAST8 "d" +#define PRIiLEAST8 "i" +#define PRIdFAST8 "d" +#define PRIiFAST8 "i" + +#define PRId16 "hd" +#define PRIi16 "hi" +#define PRIdLEAST16 "hd" +#define PRIiLEAST16 "hi" +#define PRIdFAST16 "hd" +#define PRIiFAST16 "hi" + +#define PRId32 "I32d" +#define PRIi32 "I32i" +#define PRIdLEAST32 "I32d" +#define PRIiLEAST32 "I32i" +#define PRIdFAST32 "I32d" +#define PRIiFAST32 "I32i" + +#define PRId64 "I64d" +#define PRIi64 "I64i" +#define PRIdLEAST64 "I64d" +#define PRIiLEAST64 "I64i" +#define PRIdFAST64 "I64d" +#define PRIiFAST64 "I64i" + +#define PRIdMAX "I64d" +#define PRIiMAX "I64i" + +#define PRIdPTR "Id" +#define PRIiPTR "Ii" + +// The fprintf macros for unsigned integers are: +#define PRIo8 "o" +#define PRIu8 "u" +#define PRIx8 "x" +#define PRIX8 "X" +#define PRIoLEAST8 "o" +#define PRIuLEAST8 "u" +#define PRIxLEAST8 "x" +#define PRIXLEAST8 "X" +#define PRIoFAST8 "o" +#define PRIuFAST8 "u" +#define PRIxFAST8 "x" +#define PRIXFAST8 "X" + +#define PRIo16 "ho" +#define PRIu16 "hu" +#define PRIx16 "hx" +#define PRIX16 "hX" +#define PRIoLEAST16 "ho" +#define PRIuLEAST16 "hu" +#define PRIxLEAST16 "hx" +#define PRIXLEAST16 "hX" +#define PRIoFAST16 "ho" +#define PRIuFAST16 "hu" +#define PRIxFAST16 "hx" +#define PRIXFAST16 "hX" + +#define PRIo32 "I32o" +#define PRIu32 "I32u" +#define PRIx32 "I32x" +#define PRIX32 "I32X" +#define PRIoLEAST32 "I32o" +#define PRIuLEAST32 "I32u" +#define PRIxLEAST32 "I32x" +#define PRIXLEAST32 "I32X" +#define PRIoFAST32 "I32o" +#define PRIuFAST32 "I32u" +#define PRIxFAST32 "I32x" +#define PRIXFAST32 "I32X" + +#define PRIo64 "I64o" +#define PRIu64 "I64u" +#define PRIx64 "I64x" +#define PRIX64 "I64X" +#define PRIoLEAST64 "I64o" +#define PRIuLEAST64 "I64u" +#define PRIxLEAST64 "I64x" +#define PRIXLEAST64 "I64X" +#define PRIoFAST64 "I64o" +#define PRIuFAST64 "I64u" +#define PRIxFAST64 "I64x" +#define PRIXFAST64 "I64X" + +#define PRIoMAX "I64o" +#define PRIuMAX "I64u" +#define PRIxMAX "I64x" +#define PRIXMAX "I64X" + +#define PRIoPTR "Io" +#define PRIuPTR "Iu" +#define PRIxPTR "Ix" +#define PRIXPTR "IX" + +// The fscanf macros for signed integers are: +#define SCNd8 "d" +#define SCNi8 "i" +#define SCNdLEAST8 "d" +#define SCNiLEAST8 "i" +#define SCNdFAST8 "d" +#define SCNiFAST8 "i" + +#define SCNd16 "hd" +#define SCNi16 "hi" +#define SCNdLEAST16 "hd" +#define SCNiLEAST16 "hi" +#define SCNdFAST16 "hd" +#define SCNiFAST16 "hi" + +#define SCNd32 "ld" +#define SCNi32 "li" +#define SCNdLEAST32 "ld" +#define SCNiLEAST32 "li" +#define SCNdFAST32 "ld" +#define SCNiFAST32 "li" + +#define SCNd64 "I64d" +#define SCNi64 "I64i" +#define SCNdLEAST64 "I64d" +#define SCNiLEAST64 "I64i" +#define SCNdFAST64 "I64d" +#define SCNiFAST64 "I64i" + +#define SCNdMAX "I64d" +#define SCNiMAX "I64i" + +#ifdef _WIN64 // [ +# define SCNdPTR "I64d" +# define SCNiPTR "I64i" +#else // _WIN64 ][ +# define SCNdPTR "ld" +# define SCNiPTR "li" +#endif // _WIN64 ] + +// The fscanf macros for unsigned integers are: +#define SCNo8 "o" +#define SCNu8 "u" +#define SCNx8 "x" +#define SCNX8 "X" +#define SCNoLEAST8 "o" +#define SCNuLEAST8 "u" +#define SCNxLEAST8 "x" +#define SCNXLEAST8 "X" +#define SCNoFAST8 "o" +#define SCNuFAST8 "u" +#define SCNxFAST8 "x" +#define SCNXFAST8 "X" + +#define SCNo16 "ho" +#define SCNu16 "hu" +#define SCNx16 "hx" +#define SCNX16 "hX" +#define SCNoLEAST16 "ho" +#define SCNuLEAST16 "hu" +#define SCNxLEAST16 "hx" +#define SCNXLEAST16 "hX" +#define SCNoFAST16 "ho" +#define SCNuFAST16 "hu" +#define SCNxFAST16 "hx" +#define SCNXFAST16 "hX" + +#define SCNo32 "lo" +#define SCNu32 "lu" +#define SCNx32 "lx" +#define SCNX32 "lX" +#define SCNoLEAST32 "lo" +#define SCNuLEAST32 "lu" +#define SCNxLEAST32 "lx" +#define SCNXLEAST32 "lX" +#define SCNoFAST32 "lo" +#define SCNuFAST32 "lu" +#define SCNxFAST32 "lx" +#define SCNXFAST32 "lX" + +#define SCNo64 "I64o" +#define SCNu64 "I64u" +#define SCNx64 "I64x" +#define SCNX64 "I64X" +#define SCNoLEAST64 "I64o" +#define SCNuLEAST64 "I64u" +#define SCNxLEAST64 "I64x" +#define SCNXLEAST64 "I64X" +#define SCNoFAST64 "I64o" +#define SCNuFAST64 "I64u" +#define SCNxFAST64 "I64x" +#define SCNXFAST64 "I64X" + +#define SCNoMAX "I64o" +#define SCNuMAX "I64u" +#define SCNxMAX "I64x" +#define SCNXMAX "I64X" + +#ifdef _WIN64 // [ +# define SCNoPTR "I64o" +# define SCNuPTR "I64u" +# define SCNxPTR "I64x" +# define SCNXPTR "I64X" +#else // _WIN64 ][ +# define SCNoPTR "lo" +# define SCNuPTR "lu" +# define SCNxPTR "lx" +# define SCNXPTR "lX" +#endif // _WIN64 ] + +#endif // __STDC_FORMAT_MACROS ] + +// 7.8.2 Functions for greatest-width integer types + +// 7.8.2.1 The imaxabs function +#define imaxabs _abs64 + +// 7.8.2.2 The imaxdiv function + +// This is modified version of div() function from Microsoft's div.c found +// in %MSVC.NET%\crt\src\div.c +#ifdef STATIC_IMAXDIV // [ +static +#else // STATIC_IMAXDIV ][ +_inline +#endif // STATIC_IMAXDIV ] +imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom) +{ + imaxdiv_t result; + + result.quot = numer / denom; + result.rem = numer % denom; + + if (numer < 0 && result.rem > 0) { + // did division wrong; must fix up + ++result.quot; + result.rem -= denom; + } + + return result; +} + +// 7.8.2.3 The strtoimax and strtoumax functions +#define strtoimax _strtoi64 +#define strtoumax _strtoui64 + +// 7.8.2.4 The wcstoimax and wcstoumax functions +#define wcstoimax _wcstoi64 +#define wcstoumax _wcstoui64 + +#endif // _MSC_VER >= 1800 + +#endif // _MSC_INTTYPES_H_ ] diff --git a/SourceCode/dep_inc/rapidjson/msinttypes/stdint.h b/SourceCode/dep_inc/rapidjson/msinttypes/stdint.h new file mode 100644 index 0000000..3d4477b --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/msinttypes/stdint.h @@ -0,0 +1,300 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2013 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the product nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +// 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 ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010. +#if _MSC_VER >= 1600 // [ +#include + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +#undef INT8_C +#undef INT16_C +#undef INT32_C +#undef INT64_C +#undef UINT8_C +#undef UINT16_C +#undef UINT32_C +#undef UINT64_C + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +// These #ifndef's are needed to prevent collisions with . +// Check out Issue 9 for the details. +#ifndef INTMAX_C // [ +# define INTMAX_C INT64_C +#endif // INTMAX_C ] +#ifndef UINTMAX_C // [ +# define UINTMAX_C UINT64_C +#endif // UINTMAX_C ] + +#endif // __STDC_CONSTANT_MACROS ] + +#else // ] _MSC_VER >= 1700 [ + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we have to wrap include with 'extern "C++" {}' +// or compiler would give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#if defined(__cplusplus) && !defined(_M_ARM) +extern "C" { +#endif +# include +#if defined(__cplusplus) && !defined(_M_ARM) +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +// These #ifndef's are needed to prevent collisions with . +// Check out Issue 9 for the details. +#ifndef INTMAX_C // [ +# define INTMAX_C INT64_C +#endif // INTMAX_C ] +#ifndef UINTMAX_C // [ +# define UINTMAX_C UINT64_C +#endif // UINTMAX_C ] + +#endif // __STDC_CONSTANT_MACROS ] + +#endif // _MSC_VER >= 1600 ] + +#endif // _MSC_STDINT_H_ ] diff --git a/SourceCode/dep_inc/rapidjson/ostreamwrapper.h b/SourceCode/dep_inc/rapidjson/ostreamwrapper.h new file mode 100644 index 0000000..6f4667c --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/ostreamwrapper.h @@ -0,0 +1,81 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_OSTREAMWRAPPER_H_ +#define RAPIDJSON_OSTREAMWRAPPER_H_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept. +/*! + The classes can be wrapped including but not limited to: + + - \c std::ostringstream + - \c std::stringstream + - \c std::wpstringstream + - \c std::wstringstream + - \c std::ifstream + - \c std::fstream + - \c std::wofstream + - \c std::wfstream + + \tparam StreamType Class derived from \c std::basic_ostream. +*/ + +template +class BasicOStreamWrapper { +public: + typedef typename StreamType::char_type Ch; + BasicOStreamWrapper(StreamType& stream) : stream_(stream) {} + + void Put(Ch c) { + stream_.put(c); + } + + void Flush() { + stream_.flush(); + } + + // Not implemented + char Peek() const { RAPIDJSON_ASSERT(false); return 0; } + char Take() { RAPIDJSON_ASSERT(false); return 0; } + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + BasicOStreamWrapper(const BasicOStreamWrapper&); + BasicOStreamWrapper& operator=(const BasicOStreamWrapper&); + + StreamType& stream_; +}; + +typedef BasicOStreamWrapper OStreamWrapper; +typedef BasicOStreamWrapper WOStreamWrapper; + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_OSTREAMWRAPPER_H_ diff --git a/SourceCode/dep_inc/rapidjson/pointer.h b/SourceCode/dep_inc/rapidjson/pointer.h new file mode 100644 index 0000000..3d339f2 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/pointer.h @@ -0,0 +1,1357 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_POINTER_H_ +#define RAPIDJSON_POINTER_H_ + +#include "document.h" +#include "internal/itoa.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(switch-enum) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +static const SizeType kPointerInvalidIndex = ~SizeType(0); //!< Represents an invalid index in GenericPointer::Token + +//! Error code of parsing. +/*! \ingroup RAPIDJSON_ERRORS + \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode +*/ +enum PointerParseErrorCode { + kPointerParseErrorNone = 0, //!< The parse is successful + + kPointerParseErrorTokenMustBeginWithSolidus, //!< A token must begin with a '/' + kPointerParseErrorInvalidEscape, //!< Invalid escape + kPointerParseErrorInvalidPercentEncoding, //!< Invalid percent encoding in URI fragment + kPointerParseErrorCharacterMustPercentEncode //!< A character must percent encoded in URI fragment +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericPointer + +//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator. +/*! + This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" + (https://tools.ietf.org/html/rfc6901). + + A JSON pointer is for identifying a specific value in a JSON document + (GenericDocument). It can simplify coding of DOM tree manipulation, because it + can access multiple-level depth of DOM tree with single API call. + + After it parses a string representation (e.g. "/foo/0" or URI fragment + representation (e.g. "#/foo/0") into its internal representation (tokens), + it can be used to resolve a specific value in multiple documents, or sub-tree + of documents. + + Contrary to GenericValue, Pointer can be copy constructed and copy assigned. + Apart from assignment, a Pointer cannot be modified after construction. + + Although Pointer is very convenient, please aware that constructing Pointer + involves parsing and dynamic memory allocation. A special constructor with user- + supplied tokens eliminates these. + + GenericPointer depends on GenericDocument and GenericValue. + + \tparam ValueType The value type of the DOM tree. E.g. GenericValue > + \tparam Allocator The allocator type for allocating memory for internal representation. + + \note GenericPointer uses same encoding of ValueType. + However, Allocator of GenericPointer is independent of Allocator of Value. +*/ +template +class GenericPointer { +public: + typedef typename ValueType::EncodingType EncodingType; //!< Encoding type from Value + typedef typename ValueType::Ch Ch; //!< Character type from Value + + //! A token is the basic units of internal representation. + /*! + A JSON pointer string representation "/foo/123" is parsed to two tokens: + "foo" and 123. 123 will be represented in both numeric form and string form. + They are resolved according to the actual value type (object or array). + + For token that are not numbers, or the numeric value is out of bound + (greater than limits of SizeType), they are only treated as string form + (i.e. the token's index will be equal to kPointerInvalidIndex). + + This struct is public so that user can create a Pointer without parsing and + allocation, using a special constructor. + */ + struct Token { + const Ch* name; //!< Name of the token. It has null character at the end but it can contain null character. + SizeType length; //!< Length of the name. + SizeType index; //!< A valid array index, if it is not equal to kPointerInvalidIndex. + }; + + //!@name Constructors and destructor. + //@{ + + //! Default constructor. + GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {} + + //! Constructor that parses a string or URI fragment representation. + /*! + \param source A null-terminated, string or URI fragment representation of JSON pointer. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + */ + explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source, internal::StrLen(source)); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Constructor that parses a string or URI fragment representation. + /*! + \param source A string or URI fragment representation of JSON pointer. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + explicit GenericPointer(const std::basic_string& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source.c_str(), source.size()); + } +#endif + + //! Constructor that parses a string or URI fragment representation, with length of the source string. + /*! + \param source A string or URI fragment representation of JSON pointer. + \param length Length of source. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + \note Slightly faster than the overload without length. + */ + GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source, length); + } + + //! Constructor with user-supplied tokens. + /*! + This constructor let user supplies const array of tokens. + This prevents the parsing process and eliminates allocation. + This is preferred for memory constrained environments. + + \param tokens An constant array of tokens representing the JSON pointer. + \param tokenCount Number of tokens. + + \b Example + \code + #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"); + + #undef NAME + #undef INDEX + \endcode + */ + GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {} + + //! Copy constructor. + GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + *this = rhs; + } + + //! Copy constructor. + GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + *this = rhs; + } + + //! Destructor. + ~GenericPointer() { + if (nameBuffer_) // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated. + Allocator::Free(tokens_); + RAPIDJSON_DELETE(ownAllocator_); + } + + //! Assignment operator. + GenericPointer& operator=(const GenericPointer& rhs) { + if (this != &rhs) { + // Do not delete ownAllcator + if (nameBuffer_) + Allocator::Free(tokens_); + + tokenCount_ = rhs.tokenCount_; + parseErrorOffset_ = rhs.parseErrorOffset_; + parseErrorCode_ = rhs.parseErrorCode_; + + if (rhs.nameBuffer_) + CopyFromRaw(rhs); // Normally parsed tokens. + else { + tokens_ = rhs.tokens_; // User supplied const tokens. + nameBuffer_ = 0; + } + } + return *this; + } + + //@} + + //!@name Append token + //@{ + + //! Append a token and return a new Pointer + /*! + \param token Token to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const Token& token, Allocator* allocator = 0) const { + GenericPointer r; + r.allocator_ = allocator; + Ch *p = r.CopyFromRaw(*this, 1, token.length + 1); + std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch)); + r.tokens_[tokenCount_].name = p; + r.tokens_[tokenCount_].length = token.length; + r.tokens_[tokenCount_].index = token.index; + return r; + } + + //! Append a name token with length, and return a new Pointer + /*! + \param name Name to be appended. + \param length Length of name. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const { + Token token = { name, length, kPointerInvalidIndex }; + return Append(token, allocator); + } + + //! Append a name token without length, and return a new Pointer + /*! + \param name Name (const Ch*) to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >), (GenericPointer)) + Append(T* name, Allocator* allocator = 0) const { + return Append(name, internal::StrLen(name), allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Append a name token, and return a new Pointer + /*! + \param name Name to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const std::basic_string& name, Allocator* allocator = 0) const { + return Append(name.c_str(), static_cast(name.size()), allocator); + } +#endif + + //! Append a index token, and return a new Pointer + /*! + \param index Index to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(SizeType index, Allocator* allocator = 0) const { + char buffer[21]; + char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer); + SizeType length = static_cast(end - buffer); + buffer[length] = '\0'; + + if (sizeof(Ch) == 1) { + Token token = { reinterpret_cast(buffer), length, index }; + return Append(token, allocator); + } + else { + Ch name[21]; + for (size_t i = 0; i <= length; i++) + name[i] = static_cast(buffer[i]); + Token token = { name, length, index }; + return Append(token, allocator); + } + } + + //! Append a token by value, and return a new Pointer + /*! + \param token token to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const { + if (token.IsString()) + return Append(token.GetString(), token.GetStringLength(), allocator); + else { + RAPIDJSON_ASSERT(token.IsUint64()); + RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0)); + return Append(static_cast(token.GetUint64()), allocator); + } + } + + //!@name Handling Parse Error + //@{ + + //! Check whether this is a valid pointer. + bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; } + + //! Get the parsing error offset in code unit. + size_t GetParseErrorOffset() const { return parseErrorOffset_; } + + //! Get the parsing error code. + PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; } + + //@} + + //! Get the allocator of this pointer. + Allocator& GetAllocator() { return *allocator_; } + + //!@name Tokens + //@{ + + //! Get the token array (const version only). + const Token* GetTokens() const { return tokens_; } + + //! Get the number of tokens. + size_t GetTokenCount() const { return tokenCount_; } + + //@} + + //!@name Equality/inequality operators + //@{ + + //! Equality operator. + /*! + \note When any pointers are invalid, always returns false. + */ + bool operator==(const GenericPointer& rhs) const { + if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_) + return false; + + for (size_t i = 0; i < tokenCount_; i++) { + if (tokens_[i].index != rhs.tokens_[i].index || + tokens_[i].length != rhs.tokens_[i].length || + (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0)) + { + return false; + } + } + + return true; + } + + //! Inequality operator. + /*! + \note When any pointers are invalid, always returns true. + */ + bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); } + + //@} + + //!@name Stringify + //@{ + + //! Stringify the pointer into string representation. + /*! + \tparam OutputStream Type of output stream. + \param os The output stream. + */ + template + bool Stringify(OutputStream& os) const { + return Stringify(os); + } + + //! Stringify the pointer into URI fragment representation. + /*! + \tparam OutputStream Type of output stream. + \param os The output stream. + */ + template + bool StringifyUriFragment(OutputStream& os) const { + return Stringify(os); + } + + //@} + + //!@name Create value + //@{ + + //! Create a value in a subtree. + /*! + If the value is not exist, it creates all parent values and a JSON Null value. + So it always succeed and return the newly created or existing value. + + Remind that it may change types of parents according to tokens, so it + potentially removes previously stored values. For example, if a document + was an array, and "/foo" is used to create a value, then the document + will be changed to an object, and all existing array elements are lost. + + \param root Root value of a DOM subtree to be resolved. It can be any value other than document root. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \param alreadyExist If non-null, it stores whether the resolved value is already exist. + \return The resolved newly created (a JSON Null value), or already exists value. + */ + ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const { + RAPIDJSON_ASSERT(IsValid()); + ValueType* v = &root; + bool exist = true; + for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + if (v->IsArray() && t->name[0] == '-' && t->length == 1) { + v->PushBack(ValueType().Move(), allocator); + v = &((*v)[v->Size() - 1]); + exist = false; + } + else { + if (t->index == kPointerInvalidIndex) { // must be object name + if (!v->IsObject()) + v->SetObject(); // Change to Object + } + else { // object name or array index + if (!v->IsArray() && !v->IsObject()) + v->SetArray(); // Change to Array + } + + if (v->IsArray()) { + if (t->index >= v->Size()) { + v->Reserve(t->index + 1, allocator); + while (t->index >= v->Size()) + v->PushBack(ValueType().Move(), allocator); + exist = false; + } + v = &((*v)[t->index]); + } + else { + typename ValueType::MemberIterator m = v->FindMember(GenericStringRef(t->name, t->length)); + if (m == v->MemberEnd()) { + v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator); + v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end + exist = false; + } + else + v = &m->value; + } + } + } + + if (alreadyExist) + *alreadyExist = exist; + + return *v; + } + + //! Creates a value in a document. + /*! + \param document A document to be resolved. + \param alreadyExist If non-null, it stores whether the resolved value is already exist. + \return The resolved newly created, or already exists value. + */ + template + ValueType& Create(GenericDocument& document, bool* alreadyExist = 0) const { + return Create(document, document.GetAllocator(), alreadyExist); + } + + //@} + + //!@name Query value + //@{ + + //! Query a value in a subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token. + \return Pointer to the value if it can be resolved. Otherwise null. + + \note + There are only 3 situations when a value cannot be resolved: + 1. A value in the path is not an array nor object. + 2. An object value does not contain the token. + 3. A token is out of range of an array value. + + Use unresolvedTokenIndex to retrieve the token index. + */ + ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const { + RAPIDJSON_ASSERT(IsValid()); + ValueType* v = &root; + for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + switch (v->GetType()) { + case kObjectType: + { + typename ValueType::MemberIterator m = v->FindMember(GenericStringRef(t->name, t->length)); + if (m == v->MemberEnd()) + break; + v = &m->value; + } + continue; + case kArrayType: + if (t->index == kPointerInvalidIndex || t->index >= v->Size()) + break; + v = &((*v)[t->index]); + continue; + default: + break; + } + + // Error: unresolved token + if (unresolvedTokenIndex) + *unresolvedTokenIndex = static_cast(t - tokens_); + return 0; + } + return v; + } + + //! Query a const value in a const subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \return Pointer to the value if it can be resolved. Otherwise null. + */ + const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { + return Get(const_cast(root), unresolvedTokenIndex); + } + + //@} + + //!@name Query a value with default + //@{ + + //! Query a value in a subtree with default value. + /*! + Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value. + So that this function always succeed. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param defaultValue Default value to be cloned if the value was not exists. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.CopyFrom(defaultValue, allocator); + } + + //! Query a value in a subtree with default null-terminated string. + ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.SetString(defaultValue, allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Query a value in a subtree with default std::basic_string. + ValueType& GetWithDefault(ValueType& root, const std::basic_string& defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.SetString(defaultValue, allocator); + } +#endif + + //! Query a value in a subtree with default primitive value. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const { + return GetWithDefault(root, ValueType(defaultValue).Move(), allocator); + } + + //! Query a value in a document with default value. + template + ValueType& GetWithDefault(GenericDocument& document, const ValueType& defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + + //! Query a value in a document with default null-terminated string. + template + ValueType& GetWithDefault(GenericDocument& document, const Ch* defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Query a value in a document with default std::basic_string. + template + ValueType& GetWithDefault(GenericDocument& document, const std::basic_string& defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } +#endif + + //! Query a value in a document with default primitive value. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + GetWithDefault(GenericDocument& document, T defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + + //@} + + //!@name Set a value + //@{ + + //! Set a value in a subtree, with move semantics. + /*! + It creates all parents if they are not exist or types are different to the tokens. + So this function always succeeds but potentially remove existing values. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param value Value to be set. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = value; + } + + //! Set a value in a subtree, with copy semantics. + ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator).CopyFrom(value, allocator); + } + + //! Set a null-terminated string in a subtree. + ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value, allocator).Move(); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Set a std::basic_string in a subtree. + ValueType& Set(ValueType& root, const std::basic_string& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value, allocator).Move(); + } +#endif + + //! Set a primitive value in a subtree. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value).Move(); + } + + //! Set a value in a document, with move semantics. + template + ValueType& Set(GenericDocument& document, ValueType& value) const { + return Create(document) = value; + } + + //! Set a value in a document, with copy semantics. + template + ValueType& Set(GenericDocument& document, const ValueType& value) const { + return Create(document).CopyFrom(value, document.GetAllocator()); + } + + //! Set a null-terminated string in a document. + template + ValueType& Set(GenericDocument& document, const Ch* value) const { + return Create(document) = ValueType(value, document.GetAllocator()).Move(); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Sets a std::basic_string in a document. + template + ValueType& Set(GenericDocument& document, const std::basic_string& value) const { + return Create(document) = ValueType(value, document.GetAllocator()).Move(); + } +#endif + + //! Set a primitive value in a document. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + Set(GenericDocument& document, T value) const { + return Create(document) = value; + } + + //@} + + //!@name Swap a value + //@{ + + //! Swap a value with a value in a subtree. + /*! + It creates all parents if they are not exist or types are different to the tokens. + So this function always succeeds but potentially remove existing values. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param value Value to be swapped. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator).Swap(value); + } + + //! Swap a value with a value in a document. + template + ValueType& Swap(GenericDocument& document, ValueType& value) const { + return Create(document).Swap(value); + } + + //@} + + //! Erase a value in a subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \return Whether the resolved value is found and erased. + + \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false. + */ + bool Erase(ValueType& root) const { + RAPIDJSON_ASSERT(IsValid()); + if (tokenCount_ == 0) // Cannot erase the root + return false; + + ValueType* v = &root; + const Token* last = tokens_ + (tokenCount_ - 1); + for (const Token *t = tokens_; t != last; ++t) { + switch (v->GetType()) { + case kObjectType: + { + typename ValueType::MemberIterator m = v->FindMember(GenericStringRef(t->name, t->length)); + if (m == v->MemberEnd()) + return false; + v = &m->value; + } + break; + case kArrayType: + if (t->index == kPointerInvalidIndex || t->index >= v->Size()) + return false; + v = &((*v)[t->index]); + break; + default: + return false; + } + } + + switch (v->GetType()) { + case kObjectType: + return v->EraseMember(GenericStringRef(last->name, last->length)); + case kArrayType: + if (last->index == kPointerInvalidIndex || last->index >= v->Size()) + return false; + v->Erase(v->Begin() + last->index); + return true; + default: + return false; + } + } + +private: + //! Clone the content from rhs to this. + /*! + \param rhs Source pointer. + \param extraToken Extra tokens to be allocated. + \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated. + \return Start of non-occupied name buffer, for storing extra names. + */ + Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) { + if (!allocator_) // allocator is independently owned. + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens + for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t) + nameBufferSize += t->length; + + tokenCount_ = rhs.tokenCount_ + extraToken; + tokens_ = static_cast(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch))); + nameBuffer_ = reinterpret_cast(tokens_ + tokenCount_); + if (rhs.tokenCount_ > 0) { + std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token)); + } + if (nameBufferSize > 0) { + std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch)); + } + + // Adjust pointers to name buffer + std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_; + for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t) + t->name += diff; + + return nameBuffer_ + nameBufferSize; + } + + //! Check whether a character should be percent-encoded. + /*! + According to RFC 3986 2.3 Unreserved Characters. + \param c The character (code unit) to be tested. + */ + bool NeedPercentEncode(Ch c) const { + return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~'); + } + + //! Parse a JSON String or its URI fragment representation into tokens. +#ifndef __clang__ // -Wdocumentation + /*! + \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated. + \param length Length of the source string. + \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped. + */ +#endif + void Parse(const Ch* source, size_t length) { + RAPIDJSON_ASSERT(source != NULL); + RAPIDJSON_ASSERT(nameBuffer_ == 0); + RAPIDJSON_ASSERT(tokens_ == 0); + + // Create own allocator if user did not supply. + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + // Count number of '/' as tokenCount + tokenCount_ = 0; + for (const Ch* s = source; s != source + length; s++) + if (*s == '/') + tokenCount_++; + + Token* token = tokens_ = static_cast(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch))); + Ch* name = nameBuffer_ = reinterpret_cast(tokens_ + tokenCount_); + size_t i = 0; + + // Detect if it is a URI fragment + bool uriFragment = false; + if (source[i] == '#') { + uriFragment = true; + i++; + } + + if (i != length && source[i] != '/') { + parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus; + goto error; + } + + while (i < length) { + RAPIDJSON_ASSERT(source[i] == '/'); + i++; // consumes '/' + + token->name = name; + bool isNumber = true; + + while (i < length && source[i] != '/') { + Ch c = source[i]; + if (uriFragment) { + // Decoding percent-encoding for URI fragment + if (c == '%') { + PercentDecodeStream is(&source[i], source + length); + GenericInsituStringStream os(name); + Ch* begin = os.PutBegin(); + if (!Transcoder, EncodingType>().Validate(is, os) || !is.IsValid()) { + parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding; + goto error; + } + size_t len = os.PutEnd(begin); + i += is.Tell() - 1; + if (len == 1) + c = *name; + else { + name += len; + isNumber = false; + i++; + continue; + } + } + else if (NeedPercentEncode(c)) { + parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode; + goto error; + } + } + + i++; + + // Escaping "~0" -> '~', "~1" -> '/' + if (c == '~') { + if (i < length) { + c = source[i]; + if (c == '0') c = '~'; + else if (c == '1') c = '/'; + else { + parseErrorCode_ = kPointerParseErrorInvalidEscape; + goto error; + } + i++; + } + else { + parseErrorCode_ = kPointerParseErrorInvalidEscape; + goto error; + } + } + + // First check for index: all of characters are digit + if (c < '0' || c > '9') + isNumber = false; + + *name++ = c; + } + token->length = static_cast(name - token->name); + if (token->length == 0) + isNumber = false; + *name++ = '\0'; // Null terminator + + // Second check for index: more than one digit cannot have leading zero + if (isNumber && token->length > 1 && token->name[0] == '0') + isNumber = false; + + // String to SizeType conversion + SizeType n = 0; + if (isNumber) { + for (size_t j = 0; j < token->length; j++) { + SizeType m = n * 10 + static_cast(token->name[j] - '0'); + if (m < n) { // overflow detection + isNumber = false; + break; + } + n = m; + } + } + + token->index = isNumber ? n : kPointerInvalidIndex; + token++; + } + + RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer + parseErrorCode_ = kPointerParseErrorNone; + return; + + error: + Allocator::Free(tokens_); + nameBuffer_ = 0; + tokens_ = 0; + tokenCount_ = 0; + parseErrorOffset_ = i; + return; + } + + //! Stringify to string or URI fragment representation. + /*! + \tparam uriFragment True for stringifying to URI fragment representation. False for string representation. + \tparam OutputStream type of output stream. + \param os The output stream. + */ + template + bool Stringify(OutputStream& os) const { + RAPIDJSON_ASSERT(IsValid()); + + if (uriFragment) + os.Put('#'); + + for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + os.Put('/'); + for (size_t j = 0; j < t->length; j++) { + Ch c = t->name[j]; + if (c == '~') { + os.Put('~'); + os.Put('0'); + } + else if (c == '/') { + os.Put('~'); + os.Put('1'); + } + else if (uriFragment && NeedPercentEncode(c)) { + // Transcode to UTF8 sequence + GenericStringStream source(&t->name[j]); + PercentEncodeStream target(os); + if (!Transcoder >().Validate(source, target)) + return false; + j += source.Tell() - 1; + } + else + os.Put(c); + } + } + return true; + } + + //! A helper stream for decoding a percent-encoded sequence into code unit. + /*! + This stream decodes %XY triplet into code unit (0-255). + If it encounters invalid characters, it sets output code unit as 0 and + mark invalid, and to be checked by IsValid(). + */ + class PercentDecodeStream { + public: + typedef typename ValueType::Ch Ch; + + //! Constructor + /*! + \param source Start of the stream + \param end Past-the-end of the stream. + */ + PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {} + + Ch Take() { + if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet + valid_ = false; + return 0; + } + src_++; + Ch c = 0; + for (int j = 0; j < 2; j++) { + c = static_cast(c << 4); + Ch h = *src_; + if (h >= '0' && h <= '9') c = static_cast(c + h - '0'); + else if (h >= 'A' && h <= 'F') c = static_cast(c + h - 'A' + 10); + else if (h >= 'a' && h <= 'f') c = static_cast(c + h - 'a' + 10); + else { + valid_ = false; + return 0; + } + src_++; + } + return c; + } + + size_t Tell() const { return static_cast(src_ - head_); } + bool IsValid() const { return valid_; } + + private: + const Ch* src_; //!< Current read position. + const Ch* head_; //!< Original head of the string. + const Ch* end_; //!< Past-the-end position. + bool valid_; //!< Whether the parsing is valid. + }; + + //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence. + template + class PercentEncodeStream { + public: + PercentEncodeStream(OutputStream& os) : os_(os) {} + void Put(char c) { // UTF-8 must be byte + unsigned char u = static_cast(c); + static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + os_.Put('%'); + os_.Put(static_cast(hexDigits[u >> 4])); + os_.Put(static_cast(hexDigits[u & 15])); + } + private: + OutputStream& os_; + }; + + Allocator* allocator_; //!< The current allocator. It is either user-supplied or equal to ownAllocator_. + Allocator* ownAllocator_; //!< Allocator owned by this Pointer. + Ch* nameBuffer_; //!< A buffer containing all names in tokens. + Token* tokens_; //!< A list of tokens. + size_t tokenCount_; //!< Number of tokens in tokens_. + size_t parseErrorOffset_; //!< Offset in code unit when parsing fail. + PointerParseErrorCode parseErrorCode_; //!< Parsing error code. +}; + +//! GenericPointer for Value (UTF-8, default allocator). +typedef GenericPointer Pointer; + +//!@name Helper functions for GenericPointer +//@{ + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer& pointer, typename T::AllocatorType& a) { + return pointer.Create(root, a); +} + +template +typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Create(root, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer& pointer) { + return pointer.Create(document); +} + +template +typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) { + return GenericPointer(source, N - 1).Create(document); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType* GetValueByPointer(T& root, const GenericPointer& pointer, size_t* unresolvedTokenIndex = 0) { + return pointer.Get(root, unresolvedTokenIndex); +} + +template +const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer& pointer, size_t* unresolvedTokenIndex = 0) { + return pointer.Get(root, unresolvedTokenIndex); +} + +template +typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) { + return GenericPointer(source, N - 1).Get(root, unresolvedTokenIndex); +} + +template +const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) { + return GenericPointer(source, N - 1).Get(root, unresolvedTokenIndex); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const std::basic_string& defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, T2 defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string& defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::ValueType& defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::Ch* defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const std::basic_string& defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, T2 defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string& defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const typename T::Ch* value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const std::basic_string& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +SetValueByPointer(T& root, const GenericPointer& pointer, T2 value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, typename DocumentType::ValueType& value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::ValueType& value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::Ch* value) { + return pointer.Set(document, value); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const std::basic_string& value) { + return pointer.Set(document, value); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +SetValueByPointer(DocumentType& document, const GenericPointer& pointer, T2 value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string& value) { + return GenericPointer(source, N - 1).Set(document, value); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer& pointer, typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Swap(root, value, a); +} + +template +typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Swap(root, value, a); +} + +template +typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer& pointer, typename DocumentType::ValueType& value) { + return pointer.Swap(document, value); +} + +template +typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Swap(document, value); +} + +////////////////////////////////////////////////////////////////////////////// + +template +bool EraseValueByPointer(T& root, const GenericPointer& pointer) { + return pointer.Erase(root); +} + +template +bool EraseValueByPointer(T& root, const CharType(&source)[N]) { + return GenericPointer(source, N - 1).Erase(root); +} + +//@} + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_POINTER_H_ diff --git a/SourceCode/dep_inc/rapidjson/prettywriter.h b/SourceCode/dep_inc/rapidjson/prettywriter.h new file mode 100644 index 0000000..45afb69 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/prettywriter.h @@ -0,0 +1,277 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_PRETTYWRITER_H_ +#define RAPIDJSON_PRETTYWRITER_H_ + +#include "writer.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Combination of PrettyWriter format flags. +/*! \see PrettyWriter::SetFormatOptions + */ +enum PrettyFormatOptions { + kFormatDefault = 0, //!< Default pretty formatting. + kFormatSingleLineArray = 1 //!< Format arrays on a single line. +}; + +//! Writer with indentation and spacing. +/*! + \tparam OutputStream Type of output os. + \tparam SourceEncoding Encoding of source string. + \tparam TargetEncoding Encoding of output stream. + \tparam StackAllocator Type of allocator for allocating memory of stack. +*/ +template, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags> +class PrettyWriter : public Writer { +public: + typedef Writer Base; + typedef typename Base::Ch Ch; + + //! Constructor + /*! \param os Output stream. + \param allocator User supplied allocator. If it is null, it will create a private one. + \param levelDepth Initial capacity of stack. + */ + explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : + Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {} + + + explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : + Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + PrettyWriter(PrettyWriter&& rhs) : + Base(std::forward(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {} +#endif + + //! Set custom indentation. + /*! \param indentChar Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r'). + \param indentCharCount Number of indent characters for each indentation level. + \note The default indentation is 4 spaces. + */ + PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) { + RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r'); + indentChar_ = indentChar; + indentCharCount_ = indentCharCount; + return *this; + } + + //! Set pretty writer formatting options. + /*! \param options Formatting options. + */ + PrettyWriter& SetFormatOptions(PrettyFormatOptions options) { + formatOptions_ = options; + return *this; + } + + /*! @name Implementation of Handler + \see Handler + */ + //@{ + + bool Null() { PrettyPrefix(kNullType); return Base::EndValue(Base::WriteNull()); } + bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); } + bool Int(int i) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); } + bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); } + bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); } + bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64)); } + bool Double(double d) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); } + + bool RawNumber(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + PrettyPrefix(kNumberType); + return Base::EndValue(Base::WriteString(str, length)); + } + + bool String(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + PrettyPrefix(kStringType); + return Base::EndValue(Base::WriteString(str, length)); + } + +#if RAPIDJSON_HAS_STDSTRING + bool String(const std::basic_string& str) { + return String(str.data(), SizeType(str.size())); + } +#endif + + bool StartObject() { + PrettyPrefix(kObjectType); + new (Base::level_stack_.template Push()) typename Base::Level(false); + return Base::WriteStartObject(); + } + + bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); } + +#if RAPIDJSON_HAS_STDSTRING + bool Key(const std::basic_string& str) { + return Key(str.data(), SizeType(str.size())); + } +#endif + + bool EndObject(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object + RAPIDJSON_ASSERT(!Base::level_stack_.template Top()->inArray); // currently inside an Array, not Object + RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top()->valueCount % 2); // Object has a Key without a Value + + bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; + + if (!empty) { + Base::os_->Put('\n'); + WriteIndent(); + } + bool ret = Base::EndValue(Base::WriteEndObject()); + (void)ret; + RAPIDJSON_ASSERT(ret == true); + if (Base::level_stack_.Empty()) // end of json text + Base::Flush(); + return true; + } + + bool StartArray() { + PrettyPrefix(kArrayType); + new (Base::level_stack_.template Push()) typename Base::Level(true); + return Base::WriteStartArray(); + } + + bool EndArray(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); + RAPIDJSON_ASSERT(Base::level_stack_.template Top()->inArray); + bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; + + if (!empty && !(formatOptions_ & kFormatSingleLineArray)) { + Base::os_->Put('\n'); + WriteIndent(); + } + bool ret = Base::EndValue(Base::WriteEndArray()); + (void)ret; + RAPIDJSON_ASSERT(ret == true); + if (Base::level_stack_.Empty()) // end of json text + Base::Flush(); + return true; + } + + //@} + + /*! @name Convenience extensions */ + //@{ + + //! Simpler but slower overload. + bool String(const Ch* str) { return String(str, internal::StrLen(str)); } + bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); } + + //@} + + //! Write a raw JSON value. + /*! + For user to write a stringified JSON as a value. + + \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range. + \param length Length of the json. + \param type Type of the root of json. + \note When using PrettyWriter::RawValue(), the result json may not be indented correctly. + */ + bool RawValue(const Ch* json, size_t length, Type type) { + RAPIDJSON_ASSERT(json != 0); + PrettyPrefix(type); + return Base::EndValue(Base::WriteRawValue(json, length)); + } + +protected: + void PrettyPrefix(Type type) { + (void)type; + if (Base::level_stack_.GetSize() != 0) { // this value is not at root + typename Base::Level* level = Base::level_stack_.template Top(); + + if (level->inArray) { + if (level->valueCount > 0) { + Base::os_->Put(','); // add comma if it is not the first element in array + if (formatOptions_ & kFormatSingleLineArray) + Base::os_->Put(' '); + } + + if (!(formatOptions_ & kFormatSingleLineArray)) { + Base::os_->Put('\n'); + WriteIndent(); + } + } + else { // in object + if (level->valueCount > 0) { + if (level->valueCount % 2 == 0) { + Base::os_->Put(','); + Base::os_->Put('\n'); + } + else { + Base::os_->Put(':'); + Base::os_->Put(' '); + } + } + else + Base::os_->Put('\n'); + + if (level->valueCount % 2 == 0) + WriteIndent(); + } + if (!level->inArray && level->valueCount % 2 == 0) + RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name + level->valueCount++; + } + else { + RAPIDJSON_ASSERT(!Base::hasRoot_); // Should only has one and only one root. + Base::hasRoot_ = true; + } + } + + void WriteIndent() { + size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_; + PutN(*Base::os_, static_cast(indentChar_), count); + } + + Ch indentChar_; + unsigned indentCharCount_; + PrettyFormatOptions formatOptions_; + +private: + // Prohibit copy constructor & assignment operator. + PrettyWriter(const PrettyWriter&); + PrettyWriter& operator=(const PrettyWriter&); +}; + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/SourceCode/dep_inc/rapidjson/rapidjson.h b/SourceCode/dep_inc/rapidjson/rapidjson.h new file mode 100644 index 0000000..065c8bb --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/rapidjson.h @@ -0,0 +1,654 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_RAPIDJSON_H_ +#define RAPIDJSON_RAPIDJSON_H_ + +/*!\file rapidjson.h + \brief common definitions and configuration + + \see RAPIDJSON_CONFIG + */ + +/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration + \brief Configuration macros for library features + + Some RapidJSON features are configurable to adapt the library to a wide + variety of platforms, environments and usage scenarios. Most of the + features can be configured in terms of overridden or predefined + preprocessor macros at compile-time. + + Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs. + + \note These macros should be given on the compiler command-line + (where applicable) to avoid inconsistent values when compiling + different translation units of a single application. + */ + +#include // malloc(), realloc(), free(), size_t +#include // memset(), memcpy(), memmove(), memcmp() + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_VERSION_STRING +// +// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt. +// + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +// token stringification +#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x) +#define RAPIDJSON_DO_STRINGIFY(x) #x + +// token concatenation +#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y) +#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y) +#define RAPIDJSON_DO_JOIN2(X, Y) X##Y +//!@endcond + +/*! \def RAPIDJSON_MAJOR_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Major version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_MINOR_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Minor version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_PATCH_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Patch version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_VERSION_STRING + \ingroup RAPIDJSON_CONFIG + \brief Version of RapidJSON in ".." string format. +*/ +#define RAPIDJSON_MAJOR_VERSION 1 +#define RAPIDJSON_MINOR_VERSION 1 +#define RAPIDJSON_PATCH_VERSION 0 +#define RAPIDJSON_VERSION_STRING \ + RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION) + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NAMESPACE_(BEGIN|END) +/*! \def RAPIDJSON_NAMESPACE + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace + + In order to avoid symbol clashes and/or "One Definition Rule" errors + between multiple inclusions of (different versions of) RapidJSON in + a single binary, users can customize the name of the main RapidJSON + namespace. + + In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE + to a custom name (e.g. \c MyRapidJSON) is sufficient. If multiple + levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref + RAPIDJSON_NAMESPACE_END need to be defined as well: + + \code + // in some .cpp file + #define RAPIDJSON_NAMESPACE my::rapidjson + #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson { + #define RAPIDJSON_NAMESPACE_END } } + #include "rapidjson/..." + \endcode + + \see rapidjson + */ +/*! \def RAPIDJSON_NAMESPACE_BEGIN + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace (opening expression) + \see RAPIDJSON_NAMESPACE +*/ +/*! \def RAPIDJSON_NAMESPACE_END + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace (closing expression) + \see RAPIDJSON_NAMESPACE +*/ +#ifndef RAPIDJSON_NAMESPACE +#define RAPIDJSON_NAMESPACE rapidjson +#endif +#ifndef RAPIDJSON_NAMESPACE_BEGIN +#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE { +#endif +#ifndef RAPIDJSON_NAMESPACE_END +#define RAPIDJSON_NAMESPACE_END } +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_HAS_STDSTRING + +#ifndef RAPIDJSON_HAS_STDSTRING +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation +#else +#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default +#endif +/*! \def RAPIDJSON_HAS_STDSTRING + \ingroup RAPIDJSON_CONFIG + \brief Enable RapidJSON support for \c std::string + + By defining this preprocessor symbol to \c 1, several convenience functions for using + \ref rapidjson::GenericValue with \c std::string are enabled, especially + for construction and comparison. + + \hideinitializer +*/ +#endif // !defined(RAPIDJSON_HAS_STDSTRING) + +#if RAPIDJSON_HAS_STDSTRING +#include +#endif // RAPIDJSON_HAS_STDSTRING + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NO_INT64DEFINE + +/*! \def RAPIDJSON_NO_INT64DEFINE + \ingroup RAPIDJSON_CONFIG + \brief Use external 64-bit integer types. + + RapidJSON requires the 64-bit integer types \c int64_t and \c uint64_t types + to be available at global scope. + + If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to + prevent RapidJSON from defining its own types. +*/ +#ifndef RAPIDJSON_NO_INT64DEFINE +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#if defined(_MSC_VER) && (_MSC_VER < 1800) // Visual Studio 2013 +#include "msinttypes/stdint.h" +#include "msinttypes/inttypes.h" +#else +// Other compilers should have this. +#include +#include +#endif +//!@endcond +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_NO_INT64DEFINE +#endif +#endif // RAPIDJSON_NO_INT64TYPEDEF + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_FORCEINLINE + +#ifndef RAPIDJSON_FORCEINLINE +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#if defined(_MSC_VER) && defined(NDEBUG) +#define RAPIDJSON_FORCEINLINE __forceinline +#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG) +#define RAPIDJSON_FORCEINLINE __attribute__((always_inline)) +#else +#define RAPIDJSON_FORCEINLINE +#endif +//!@endcond +#endif // RAPIDJSON_FORCEINLINE + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ENDIAN +#define RAPIDJSON_LITTLEENDIAN 0 //!< Little endian machine +#define RAPIDJSON_BIGENDIAN 1 //!< Big endian machine + +//! Endianness of the machine. +/*! + \def RAPIDJSON_ENDIAN + \ingroup RAPIDJSON_CONFIG + + GCC 4.6 provided macro for detecting endianness of the target machine. But other + compilers may not have this. User can define RAPIDJSON_ENDIAN to either + \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN. + + Default detection implemented with reference to + \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html + \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp +*/ +#ifndef RAPIDJSON_ENDIAN +// Detect with GCC 4.6's macro +# ifdef __BYTE_ORDER__ +# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif // __BYTE_ORDER__ +// Detect with GLIBC's endian.h +# elif defined(__GLIBC__) +# include +# if (__BYTE_ORDER == __LITTLE_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif (__BYTE_ORDER == __BIG_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif // __GLIBC__ +// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro +# elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +// Detect with architecture macros +# elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64)) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(RAPIDJSON_DOXYGEN_RUNNING) +# define RAPIDJSON_ENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif +#endif // RAPIDJSON_ENDIAN + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_64BIT + +//! Whether using 64-bit architecture +#ifndef RAPIDJSON_64BIT +#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__) +#define RAPIDJSON_64BIT 1 +#else +#define RAPIDJSON_64BIT 0 +#endif +#endif // RAPIDJSON_64BIT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ALIGN + +//! Data alignment of the machine. +/*! \ingroup RAPIDJSON_CONFIG + \param x pointer to align + + Some machines require strict data alignment. The default is 8 bytes. + User can customize by defining the RAPIDJSON_ALIGN function macro. +*/ +#ifndef RAPIDJSON_ALIGN +#define RAPIDJSON_ALIGN(x) (((x) + static_cast(7u)) & ~static_cast(7u)) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_UINT64_C2 + +//! Construct a 64-bit literal by a pair of 32-bit integer. +/*! + 64-bit literal with or without ULL suffix is prone to compiler warnings. + UINT64_C() is C macro which cause compilation problems. + Use this macro to define 64-bit constants by a pair of 32-bit integer. +*/ +#ifndef RAPIDJSON_UINT64_C2 +#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast(high32) << 32) | static_cast(low32)) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_48BITPOINTER_OPTIMIZATION + +//! Use only lower 48-bit address for some pointers. +/*! + \ingroup RAPIDJSON_CONFIG + + This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address. + The higher 16-bit can be used for storing other data. + \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture. +*/ +#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION +#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64) +#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1 +#else +#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0 +#endif +#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION + +#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1 +#if RAPIDJSON_64BIT != 1 +#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1 +#endif +#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast((reinterpret_cast(p) & static_cast(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast(reinterpret_cast(x)))) +#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast(reinterpret_cast(p) & static_cast(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF)))) +#else +#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x)) +#define RAPIDJSON_GETPOINTER(type, p) (p) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD + +/*! \def RAPIDJSON_SIMD + \ingroup RAPIDJSON_CONFIG + \brief Enable SSE2/SSE4.2/Neon optimization. + + RapidJSON supports optimized implementations for some parsing operations + based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel + or ARM compatible processors. + + To enable these optimizations, three different symbols can be defined; + \code + // Enable SSE2 optimization. + #define RAPIDJSON_SSE2 + + // Enable SSE4.2 optimization. + #define RAPIDJSON_SSE42 + \endcode + + // Enable ARM Neon optimization. + #define RAPIDJSON_NEON + \endcode + + \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined. + + If any of these symbols is defined, RapidJSON defines the macro + \c RAPIDJSON_SIMD to indicate the availability of the optimized code. +*/ +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \ + || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING) +#define RAPIDJSON_SIMD +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NO_SIZETYPEDEFINE + +#ifndef RAPIDJSON_NO_SIZETYPEDEFINE +/*! \def RAPIDJSON_NO_SIZETYPEDEFINE + \ingroup RAPIDJSON_CONFIG + \brief User-provided \c SizeType definition. + + In order to avoid using 32-bit size types for indexing strings and arrays, + define this preprocessor symbol and provide the type rapidjson::SizeType + before including RapidJSON: + \code + #define RAPIDJSON_NO_SIZETYPEDEFINE + namespace rapidjson { typedef ::std::size_t SizeType; } + #include "rapidjson/..." + \endcode + + \see rapidjson::SizeType +*/ +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_NO_SIZETYPEDEFINE +#endif +RAPIDJSON_NAMESPACE_BEGIN +//! Size type (for string lengths, array sizes, etc.) +/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms, + instead of using \c size_t. Users may override the SizeType by defining + \ref RAPIDJSON_NO_SIZETYPEDEFINE. +*/ +typedef unsigned SizeType; +RAPIDJSON_NAMESPACE_END +#endif + +// always import std::size_t to rapidjson namespace +RAPIDJSON_NAMESPACE_BEGIN +using std::size_t; +RAPIDJSON_NAMESPACE_END + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ASSERT + +//! Assertion. +/*! \ingroup RAPIDJSON_CONFIG + By default, rapidjson uses C \c assert() for internal assertions. + User can override it by defining RAPIDJSON_ASSERT(x) macro. + + \note Parsing errors are handled and can be customized by the + \ref RAPIDJSON_ERRORS APIs. +*/ +#ifndef RAPIDJSON_ASSERT +#include +#define RAPIDJSON_ASSERT(x) assert(x) +#endif // RAPIDJSON_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_STATIC_ASSERT + +// Prefer C++11 static_assert, if available +#ifndef RAPIDJSON_STATIC_ASSERT +#if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 ) +#define RAPIDJSON_STATIC_ASSERT(x) \ + static_assert(x, RAPIDJSON_STRINGIFY(x)) +#endif // C++11 +#endif // RAPIDJSON_STATIC_ASSERT + +// Adopt C++03 implementation from boost +#ifndef RAPIDJSON_STATIC_ASSERT +#ifndef __clang__ +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#endif +RAPIDJSON_NAMESPACE_BEGIN +template struct STATIC_ASSERTION_FAILURE; +template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; +template struct StaticAssertTest {}; +RAPIDJSON_NAMESPACE_END + +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused)) +#else +#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE +#endif +#ifndef __clang__ +//!@endcond +#endif + +/*! \def RAPIDJSON_STATIC_ASSERT + \brief (Internal) macro to check for conditions at compile-time + \param x compile-time condition + \hideinitializer + */ +#define RAPIDJSON_STATIC_ASSERT(x) \ + typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \ + sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE)> \ + RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE +#endif // RAPIDJSON_STATIC_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY + +//! Compiler branching hint for expression with high probability to be true. +/*! + \ingroup RAPIDJSON_CONFIG + \param x Boolean expression likely to be true. +*/ +#ifndef RAPIDJSON_LIKELY +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1) +#else +#define RAPIDJSON_LIKELY(x) (x) +#endif +#endif + +//! Compiler branching hint for expression with low probability to be true. +/*! + \ingroup RAPIDJSON_CONFIG + \param x Boolean expression unlikely to be true. +*/ +#ifndef RAPIDJSON_UNLIKELY +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0) +#else +#define RAPIDJSON_UNLIKELY(x) (x) +#endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Helpers + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN + +#define RAPIDJSON_MULTILINEMACRO_BEGIN do { +#define RAPIDJSON_MULTILINEMACRO_END \ +} while((void)0, 0) + +// adopted from Boost +#define RAPIDJSON_VERSION_CODE(x,y,z) \ + (((x)*100000) + ((y)*100) + (z)) + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF + +#if defined(__GNUC__) +#define RAPIDJSON_GNUC \ + RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__) +#endif + +#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0)) + +#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x)) +#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x) +#define RAPIDJSON_DIAG_OFF(x) \ + RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x))) + +// push/pop support in Clang and GCC>=4.6 +#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) +#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) +#define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) +#else // GCC >= 4.2, < 4.6 +#define RAPIDJSON_DIAG_PUSH /* ignored */ +#define RAPIDJSON_DIAG_POP /* ignored */ +#endif + +#elif defined(_MSC_VER) + +// pragma (MSVC specific) +#define RAPIDJSON_PRAGMA(x) __pragma(x) +#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x)) + +#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x) +#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) +#define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) + +#else + +#define RAPIDJSON_DIAG_OFF(x) /* ignored */ +#define RAPIDJSON_DIAG_PUSH /* ignored */ +#define RAPIDJSON_DIAG_POP /* ignored */ + +#endif // RAPIDJSON_DIAG_* + +/////////////////////////////////////////////////////////////////////////////// +// C++11 features + +#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS +#if defined(__clang__) +#if __has_feature(cxx_rvalue_references) && \ + (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306) +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 +#else +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 +#endif +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1600) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) + +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 +#else +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 +#endif +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + +#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT +#if defined(__clang__) +#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept) +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1900) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1 +#else +#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0 +#endif +#endif +#if RAPIDJSON_HAS_CXX11_NOEXCEPT +#define RAPIDJSON_NOEXCEPT noexcept +#else +#define RAPIDJSON_NOEXCEPT /* noexcept */ +#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT + +// no automatic detection, yet +#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS +#if (defined(_MSC_VER) && _MSC_VER >= 1700) +#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1 +#else +#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0 +#endif +#endif + +#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR +#if defined(__clang__) +#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for) +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1700) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1 +#else +#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0 +#endif +#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR + +//!@endcond + +//! Assertion (in non-throwing contexts). + /*! \ingroup RAPIDJSON_CONFIG + Some functions provide a \c noexcept guarantee, if the compiler supports it. + In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to + throw an exception. This macro adds a separate customization point for + such cases. + + Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is + supported, and to \ref RAPIDJSON_ASSERT otherwise. + */ + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NOEXCEPT_ASSERT + +#ifdef RAPIDJSON_ASSERT_THROWS +#if RAPIDJSON_HAS_CXX11_NOEXCEPT +#define RAPIDJSON_NOEXCEPT_ASSERT(x) +#else +#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x) +#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT +#else +#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x) +#endif // RAPIDJSON_ASSERT_THROWS + +/////////////////////////////////////////////////////////////////////////////// +// new/delete + +#ifndef RAPIDJSON_NEW +///! customization point for global \c new +#define RAPIDJSON_NEW(TypeName) new TypeName +#endif +#ifndef RAPIDJSON_DELETE +///! customization point for global \c delete +#define RAPIDJSON_DELETE(x) delete x +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Type + +/*! \namespace rapidjson + \brief main RapidJSON namespace + \see RAPIDJSON_NAMESPACE +*/ +RAPIDJSON_NAMESPACE_BEGIN + +//! Type of JSON value +enum Type { + kNullType = 0, //!< null + kFalseType = 1, //!< false + kTrueType = 2, //!< true + kObjectType = 3, //!< object + kArrayType = 4, //!< array + kStringType = 5, //!< string + kNumberType = 6 //!< number +}; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/SourceCode/dep_inc/rapidjson/reader.h b/SourceCode/dep_inc/rapidjson/reader.h new file mode 100644 index 0000000..44a6bcd --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/reader.h @@ -0,0 +1,2230 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_READER_H_ +#define RAPIDJSON_READER_H_ + +/*! \file reader.h */ + +#include "allocators.h" +#include "stream.h" +#include "encodedstream.h" +#include "internal/meta.h" +#include "internal/stack.h" +#include "internal/strtod.h" +#include + +#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER) +#include +#pragma intrinsic(_BitScanForward) +#endif +#ifdef RAPIDJSON_SSE42 +#include +#elif defined(RAPIDJSON_SSE2) +#include +#elif defined(RAPIDJSON_NEON) +#include +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(old-style-cast) +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +RAPIDJSON_DIAG_OFF(4702) // unreachable code +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define RAPIDJSON_NOTHING /* deliberately empty */ +#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN +#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \ + RAPIDJSON_MULTILINEMACRO_END +#endif +#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \ + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING) +//!@endcond + +/*! \def RAPIDJSON_PARSE_ERROR_NORETURN + \ingroup RAPIDJSON_ERRORS + \brief Macro to indicate a parse error. + \param parseErrorCode \ref rapidjson::ParseErrorCode of the error + \param offset position of the error in JSON input (\c size_t) + + This macros can be used as a customization point for the internal + error handling mechanism of RapidJSON. + + A common usage model is to throw an exception instead of requiring the + caller to explicitly check the \ref rapidjson::GenericReader::Parse's + return value: + + \code + #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \ + throw ParseException(parseErrorCode, #parseErrorCode, offset) + + #include // std::runtime_error + #include "rapidjson/error/error.h" // rapidjson::ParseResult + + struct ParseException : std::runtime_error, rapidjson::ParseResult { + ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset) + : std::runtime_error(msg), ParseResult(code, offset) {} + }; + + #include "rapidjson/reader.h" + \endcode + + \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse + */ +#ifndef RAPIDJSON_PARSE_ERROR_NORETURN +#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \ + SetParseError(parseErrorCode, offset); \ + RAPIDJSON_MULTILINEMACRO_END +#endif + +/*! \def RAPIDJSON_PARSE_ERROR + \ingroup RAPIDJSON_ERRORS + \brief (Internal) macro to indicate and handle a parse error. + \param parseErrorCode \ref rapidjson::ParseErrorCode of the error + \param offset position of the error in JSON input (\c size_t) + + Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing. + + \see RAPIDJSON_PARSE_ERROR_NORETURN + \hideinitializer + */ +#ifndef RAPIDJSON_PARSE_ERROR +#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \ + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \ + RAPIDJSON_MULTILINEMACRO_END +#endif + +#include "error/error.h" // ParseErrorCode, ParseResult + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// ParseFlag + +/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS + \ingroup RAPIDJSON_CONFIG + \brief User-defined kParseDefaultFlags definition. + + User can define this as any \c ParseFlag combinations. +*/ +#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS +#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags +#endif + +//! Combination of parseFlags +/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream + */ +enum ParseFlag { + kParseNoFlags = 0, //!< No flags are set. + kParseInsituFlag = 1, //!< In-situ(destructive) parsing. + kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings. + kParseIterativeFlag = 4, //!< Iterative(constant complexity in terms of function call stack size) parsing. + kParseStopWhenDoneFlag = 8, //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error. + kParseFullPrecisionFlag = 16, //!< Parse number in full precision (but slower). + kParseCommentsFlag = 32, //!< Allow one-line (//) and multi-line (/**/) comments. + kParseNumbersAsStringsFlag = 64, //!< Parse all numbers (ints/doubles) as strings. + kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays. + kParseNanAndInfFlag = 256, //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles. + kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS +}; + +/////////////////////////////////////////////////////////////////////////////// +// Handler + +/*! \class rapidjson::Handler + \brief Concept for receiving events from GenericReader upon parsing. + The functions return true if no error occurs. If they return false, + the event publisher should terminate the process. +\code +concept Handler { + typename Ch; + + bool Null(); + bool Bool(bool b); + bool Int(int i); + bool Uint(unsigned i); + bool Int64(int64_t i); + bool Uint64(uint64_t i); + bool Double(double d); + /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length) + bool RawNumber(const Ch* str, SizeType length, bool copy); + bool String(const Ch* str, SizeType length, bool copy); + bool StartObject(); + bool Key(const Ch* str, SizeType length, bool copy); + bool EndObject(SizeType memberCount); + bool StartArray(); + bool EndArray(SizeType elementCount); +}; +\endcode +*/ +/////////////////////////////////////////////////////////////////////////////// +// BaseReaderHandler + +//! Default implementation of Handler. +/*! This can be used as base class of any reader handler. + \note implements Handler concept +*/ +template, typename Derived = void> +struct BaseReaderHandler { + typedef typename Encoding::Ch Ch; + + typedef typename internal::SelectIf, BaseReaderHandler, Derived>::Type Override; + + bool Default() { return true; } + bool Null() { return static_cast(*this).Default(); } + bool Bool(bool) { return static_cast(*this).Default(); } + bool Int(int) { return static_cast(*this).Default(); } + bool Uint(unsigned) { return static_cast(*this).Default(); } + bool Int64(int64_t) { return static_cast(*this).Default(); } + bool Uint64(uint64_t) { return static_cast(*this).Default(); } + bool Double(double) { return static_cast(*this).Default(); } + /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length) + bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast(*this).String(str, len, copy); } + bool String(const Ch*, SizeType, bool) { return static_cast(*this).Default(); } + bool StartObject() { return static_cast(*this).Default(); } + bool Key(const Ch* str, SizeType len, bool copy) { return static_cast(*this).String(str, len, copy); } + bool EndObject(SizeType) { return static_cast(*this).Default(); } + bool StartArray() { return static_cast(*this).Default(); } + bool EndArray(SizeType) { return static_cast(*this).Default(); } +}; + +/////////////////////////////////////////////////////////////////////////////// +// StreamLocalCopy + +namespace internal { + +template::copyOptimization> +class StreamLocalCopy; + +//! Do copy optimization. +template +class StreamLocalCopy { +public: + StreamLocalCopy(Stream& original) : s(original), original_(original) {} + ~StreamLocalCopy() { original_ = s; } + + Stream s; + +private: + StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */; + + Stream& original_; +}; + +//! Keep reference. +template +class StreamLocalCopy { +public: + StreamLocalCopy(Stream& original) : s(original) {} + + Stream& s; + +private: + StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */; +}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// SkipWhitespace + +//! Skip the JSON white spaces in a stream. +/*! \param is A input stream for skipping white spaces. + \note This function has SSE2/SSE4.2 specialization. +*/ +template +void SkipWhitespace(InputStream& is) { + internal::StreamLocalCopy copy(is); + InputStream& s(copy.s); + + typename InputStream::Ch c; + while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t') + s.Take(); +} + +inline const char* SkipWhitespace(const char* p, const char* end) { + while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + return p; +} + +#ifdef RAPIDJSON_SSE42 +//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // The rest of string using SIMD + static const char whitespace[16] = " \n\r\t"; + const __m128i w = _mm_loadu_si128(reinterpret_cast(&whitespace[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY); + if (r != 16) // some of characters is non-whitespace + return p + r; + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + // The middle of string using SIMD + static const char whitespace[16] = " \n\r\t"; + const __m128i w = _mm_loadu_si128(reinterpret_cast(&whitespace[0])); + + for (; p <= end - 16; p += 16) { + const __m128i s = _mm_loadu_si128(reinterpret_cast(p)); + const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY); + if (r != 16) // some of characters is non-whitespace + return p + r; + } + + return SkipWhitespace(p, end); +} + +#elif defined(RAPIDJSON_SSE2) + +//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // The rest of string + #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c } + static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') }; + #undef C16 + + const __m128i w0 = _mm_loadu_si128(reinterpret_cast(&whitespaces[0][0])); + const __m128i w1 = _mm_loadu_si128(reinterpret_cast(&whitespaces[1][0])); + const __m128i w2 = _mm_loadu_si128(reinterpret_cast(&whitespaces[2][0])); + const __m128i w3 = _mm_loadu_si128(reinterpret_cast(&whitespaces[3][0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + __m128i x = _mm_cmpeq_epi8(s, w0); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3)); + unsigned short r = static_cast(~_mm_movemask_epi8(x)); + if (r != 0) { // some of characters may be non-whitespace +#ifdef _MSC_VER // Find the index of first non-whitespace + unsigned long offset; + _BitScanForward(&offset, r); + return p + offset; +#else + return p + __builtin_ffs(r) - 1; +#endif + } + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + // The rest of string + #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c } + static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') }; + #undef C16 + + const __m128i w0 = _mm_loadu_si128(reinterpret_cast(&whitespaces[0][0])); + const __m128i w1 = _mm_loadu_si128(reinterpret_cast(&whitespaces[1][0])); + const __m128i w2 = _mm_loadu_si128(reinterpret_cast(&whitespaces[2][0])); + const __m128i w3 = _mm_loadu_si128(reinterpret_cast(&whitespaces[3][0])); + + for (; p <= end - 16; p += 16) { + const __m128i s = _mm_loadu_si128(reinterpret_cast(p)); + __m128i x = _mm_cmpeq_epi8(s, w0); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3)); + unsigned short r = static_cast(~_mm_movemask_epi8(x)); + if (r != 0) { // some of characters may be non-whitespace +#ifdef _MSC_VER // Find the index of first non-whitespace + unsigned long offset; + _BitScanForward(&offset, r); + return p + offset; +#else + return p + __builtin_ffs(r) - 1; +#endif + } + } + + return SkipWhitespace(p, end); +} + +#elif defined(RAPIDJSON_NEON) + +//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + const uint8x16_t w0 = vmovq_n_u8(' '); + const uint8x16_t w1 = vmovq_n_u8('\n'); + const uint8x16_t w2 = vmovq_n_u8('\r'); + const uint8x16_t w3 = vmovq_n_u8('\t'); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, w0); + x = vorrq_u8(x, vceqq_u8(s, w1)); + x = vorrq_u8(x, vceqq_u8(s, w2)); + x = vorrq_u8(x, vceqq_u8(s, w3)); + + x = vmvnq_u8(x); // Negate + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + if (low == 0) { + if (high != 0) { + int lz =__builtin_clzll(high);; + return p + 8 + (lz >> 3); + } + } else { + int lz = __builtin_clzll(low);; + return p + (lz >> 3); + } + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + const uint8x16_t w0 = vmovq_n_u8(' '); + const uint8x16_t w1 = vmovq_n_u8('\n'); + const uint8x16_t w2 = vmovq_n_u8('\r'); + const uint8x16_t w3 = vmovq_n_u8('\t'); + + for (; p <= end - 16; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, w0); + x = vorrq_u8(x, vceqq_u8(s, w1)); + x = vorrq_u8(x, vceqq_u8(s, w2)); + x = vorrq_u8(x, vceqq_u8(s, w3)); + + x = vmvnq_u8(x); // Negate + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + if (low == 0) { + if (high != 0) { + int lz = __builtin_clzll(high); + return p + 8 + (lz >> 3); + } + } else { + int lz = __builtin_clzll(low); + return p + (lz >> 3); + } + } + + return SkipWhitespace(p, end); +} + +#endif // RAPIDJSON_NEON + +#ifdef RAPIDJSON_SIMD +//! Template function specialization for InsituStringStream +template<> inline void SkipWhitespace(InsituStringStream& is) { + is.src_ = const_cast(SkipWhitespace_SIMD(is.src_)); +} + +//! Template function specialization for StringStream +template<> inline void SkipWhitespace(StringStream& is) { + is.src_ = SkipWhitespace_SIMD(is.src_); +} + +template<> inline void SkipWhitespace(EncodedInputStream, MemoryStream>& is) { + is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_); +} +#endif // RAPIDJSON_SIMD + +/////////////////////////////////////////////////////////////////////////////// +// GenericReader + +//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator. +/*! GenericReader parses JSON text from a stream, and send events synchronously to an + object implementing Handler concept. + + It needs to allocate a stack for storing a single decoded string during + non-destructive parsing. + + For in-situ parsing, the decoded string is directly written to the source + text string, no temporary buffer is required. + + A GenericReader object can be reused for parsing multiple JSON text. + + \tparam SourceEncoding Encoding of the input stream. + \tparam TargetEncoding Encoding of the parse output. + \tparam StackAllocator Allocator type for stack. +*/ +template +class GenericReader { +public: + typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type + + //! Constructor. + /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing) + \param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing) + */ + GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : + stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {} + + //! Parse JSON text. + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept. + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + ParseResult Parse(InputStream& is, Handler& handler) { + if (parseFlags & kParseIterativeFlag) + return IterativeParse(is, handler); + + parseResult_.Clear(); + + ClearStackOnExit scope(*this); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell()); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + else { + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (!(parseFlags & kParseStopWhenDoneFlag)) { + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell()); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + } + } + + return parseResult_; + } + + //! Parse JSON text (with \ref kParseDefaultFlags) + /*! \tparam InputStream Type of input stream, implementing Stream concept + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + ParseResult Parse(InputStream& is, Handler& handler) { + return Parse(is, handler); + } + + //! Initialize JSON text token-by-token parsing + /*! + */ + void IterativeParseInit() { + parseResult_.Clear(); + state_ = IterativeParsingStartState; + } + + //! Parse one token from JSON text + /*! \tparam InputStream Type of input stream, implementing Stream concept + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + bool IterativeParseNext(InputStream& is, Handler& handler) { + while (RAPIDJSON_LIKELY(is.Peek() != '\0')) { + SkipWhitespaceAndComments(is); + + Token t = Tokenize(is.Peek()); + IterativeParsingState n = Predict(state_, t); + IterativeParsingState d = Transit(state_, t, n, is, handler); + + // If we've finished or hit an error... + if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) { + // Report errors. + if (d == IterativeParsingErrorState) { + HandleError(state_, is); + return false; + } + + // Transition to the finish state. + RAPIDJSON_ASSERT(d == IterativeParsingFinishState); + state_ = d; + + // If StopWhenDone is not set... + if (!(parseFlags & kParseStopWhenDoneFlag)) { + // ... and extra non-whitespace data is found... + SkipWhitespaceAndComments(is); + if (is.Peek() != '\0') { + // ... this is considered an error. + HandleError(state_, is); + return false; + } + } + + // Success! We are done! + return true; + } + + // Transition to the new state. + state_ = d; + + // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now. + if (!IsIterativeParsingDelimiterState(n)) + return true; + } + + // We reached the end of file. + stack_.Clear(); + + if (state_ != IterativeParsingFinishState) { + HandleError(state_, is); + return false; + } + + return true; + } + + //! Check if token-by-token parsing JSON text is complete + /*! \return Whether the JSON has been fully decoded. + */ + RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const { + return IsIterativeParsingCompleteState(state_); + } + + //! Whether a parse error has occurred in the last parsing. + bool HasParseError() const { return parseResult_.IsError(); } + + //! Get the \ref ParseErrorCode of last parsing. + ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); } + + //! Get the position of last parsing error in input, 0 otherwise. + size_t GetErrorOffset() const { return parseResult_.Offset(); } + +protected: + void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); } + +private: + // Prohibit copy constructor & assignment operator. + GenericReader(const GenericReader&); + GenericReader& operator=(const GenericReader&); + + void ClearStack() { stack_.Clear(); } + + // clear stack on any exit from ParseStream, e.g. due to exception + struct ClearStackOnExit { + explicit ClearStackOnExit(GenericReader& r) : r_(r) {} + ~ClearStackOnExit() { r_.ClearStack(); } + private: + GenericReader& r_; + ClearStackOnExit(const ClearStackOnExit&); + ClearStackOnExit& operator=(const ClearStackOnExit&); + }; + + template + void SkipWhitespaceAndComments(InputStream& is) { + SkipWhitespace(is); + + if (parseFlags & kParseCommentsFlag) { + while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) { + if (Consume(is, '*')) { + while (true) { + if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) + RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell()); + else if (Consume(is, '*')) { + if (Consume(is, '/')) + break; + } + else + is.Take(); + } + } + else if (RAPIDJSON_LIKELY(Consume(is, '/'))) + while (is.Peek() != '\0' && is.Take() != '\n') {} + else + RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell()); + + SkipWhitespace(is); + } + } + } + + // Parse object: { string : value, ... } + template + void ParseObject(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == '{'); + is.Take(); // Skip '{' + + if (RAPIDJSON_UNLIKELY(!handler.StartObject())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, '}')) { + if (RAPIDJSON_UNLIKELY(!handler.EndObject(0))) // empty object + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + + for (SizeType memberCount = 0;;) { + if (RAPIDJSON_UNLIKELY(is.Peek() != '"')) + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); + + ParseString(is, handler, true); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (RAPIDJSON_UNLIKELY(!Consume(is, ':'))) + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ++memberCount; + + switch (is.Peek()) { + case ',': + is.Take(); + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + break; + case '}': + is.Take(); + if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + default: + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy + } + + if (parseFlags & kParseTrailingCommasFlag) { + if (is.Peek() == '}') { + if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + is.Take(); + return; + } + } + } + } + + // Parse array: [ value, ... ] + template + void ParseArray(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == '['); + is.Take(); // Skip '[' + + if (RAPIDJSON_UNLIKELY(!handler.StartArray())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, ']')) { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + + for (SizeType elementCount = 0;;) { + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ++elementCount; + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, ',')) { + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + } + else if (Consume(is, ']')) { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); + + if (parseFlags & kParseTrailingCommasFlag) { + if (is.Peek() == ']') { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + is.Take(); + return; + } + } + } + } + + template + void ParseNull(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 'n'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) { + if (RAPIDJSON_UNLIKELY(!handler.Null())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + void ParseTrue(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 't'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) { + if (RAPIDJSON_UNLIKELY(!handler.Bool(true))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + void ParseFalse(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 'f'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) { + if (RAPIDJSON_UNLIKELY(!handler.Bool(false))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) { + if (RAPIDJSON_LIKELY(is.Peek() == expect)) { + is.Take(); + return true; + } + else + return false; + } + + // Helper function to parse four hexadecimal digits in \uXXXX in ParseString(). + template + unsigned ParseHex4(InputStream& is, size_t escapeOffset) { + unsigned codepoint = 0; + for (int i = 0; i < 4; i++) { + Ch c = is.Peek(); + codepoint <<= 4; + codepoint += static_cast(c); + if (c >= '0' && c <= '9') + codepoint -= '0'; + else if (c >= 'A' && c <= 'F') + codepoint -= 'A' - 10; + else if (c >= 'a' && c <= 'f') + codepoint -= 'a' - 10; + else { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0); + } + is.Take(); + } + return codepoint; + } + + template + class StackStream { + public: + typedef CharType Ch; + + StackStream(internal::Stack& stack) : stack_(stack), length_(0) {} + RAPIDJSON_FORCEINLINE void Put(Ch c) { + *stack_.template Push() = c; + ++length_; + } + + RAPIDJSON_FORCEINLINE void* Push(SizeType count) { + length_ += count; + return stack_.template Push(count); + } + + size_t Length() const { return length_; } + + Ch* Pop() { + return stack_.template Pop(length_); + } + + private: + StackStream(const StackStream&); + StackStream& operator=(const StackStream&); + + internal::Stack& stack_; + SizeType length_; + }; + + // Parse string and generate String event. Different code paths for kParseInsituFlag. + template + void ParseString(InputStream& is, Handler& handler, bool isKey = false) { + internal::StreamLocalCopy copy(is); + InputStream& s(copy.s); + + RAPIDJSON_ASSERT(s.Peek() == '\"'); + s.Take(); // Skip '\"' + + bool success = false; + if (parseFlags & kParseInsituFlag) { + typename InputStream::Ch *head = s.PutBegin(); + ParseStringToStream(s, s); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + size_t length = s.PutEnd(head) - 1; + RAPIDJSON_ASSERT(length <= 0xFFFFFFFF); + const typename TargetEncoding::Ch* const str = reinterpret_cast(head); + success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false)); + } + else { + StackStream stackStream(stack_); + ParseStringToStream(s, stackStream); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + SizeType length = static_cast(stackStream.Length()) - 1; + const typename TargetEncoding::Ch* const str = stackStream.Pop(); + success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true)); + } + if (RAPIDJSON_UNLIKELY(!success)) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell()); + } + + // Parse string to an output is + // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation. + template + RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) { +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + static const char escape[256] = { + Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/', + Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, + 0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0, + 0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 + }; +#undef Z16 +//!@endcond + + for (;;) { + // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation. + if (!(parseFlags & kParseValidateEncodingFlag)) + ScanCopyUnescapedString(is, os); + + Ch c = is.Peek(); + if (RAPIDJSON_UNLIKELY(c == '\\')) { // Escape + size_t escapeOffset = is.Tell(); // For invalid escaping, report the initial '\\' as error offset + is.Take(); + Ch e = is.Peek(); + if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast(e)])) { + is.Take(); + os.Put(static_cast(escape[static_cast(e)])); + } + else if (RAPIDJSON_LIKELY(e == 'u')) { // Unicode + is.Take(); + unsigned codepoint = ParseHex4(is, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF)) { + // Handle UTF-16 surrogate pair + if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u'))) + RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset); + unsigned codepoint2 = ParseHex4(is, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF)) + RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset); + codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000; + } + TEncoding::Encode(os, codepoint); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset); + } + else if (RAPIDJSON_UNLIKELY(c == '"')) { // Closing double quote + is.Take(); + os.Put('\0'); // null-terminate the string + return; + } + else if (RAPIDJSON_UNLIKELY(static_cast(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF + if (c == '\0') + RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell()); + else + RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell()); + } + else { + size_t offset = is.Tell(); + if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ? + !Transcoder::Validate(is, os) : + !Transcoder::Transcode(is, os)))) + RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset); + } + } + } + + template + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) { + // Do nothing for generic version + } + +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) + // StringStream -> StackStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream& os) { + const char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + return; + } + else + os.Put(*p++); + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + SizeType length; + #ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; + #else + length = static_cast(__builtin_ffs(r) - 1); + #endif + if (length != 0) { + char* q = reinterpret_cast(os.Push(length)); + for (size_t i = 0; i < length; i++) + q[i] = p[i]; + + p += length; + } + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s); + } + + is.src_ = p; + } + + // InsituStringStream -> InsituStringStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) { + RAPIDJSON_ASSERT(&is == &os); + (void)os; + + if (is.src_ == is.dst_) { + SkipUnescapedString(is); + return; + } + + char* p = is.src_; + char *q = is.dst_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + is.dst_ = q; + return; + } + else + *q++ = *p++; + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16, q += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + size_t length; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; +#else + length = static_cast(__builtin_ffs(r) - 1); +#endif + for (const char* pend = p + length; p != pend; ) + *q++ = *p++; + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s); + } + + is.src_ = p; + is.dst_ = q; + } + + // When read/write pointers are the same for insitu stream, just skip unescaped characters + static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) { + RAPIDJSON_ASSERT(is.src_ == is.dst_); + char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + for (; p != nextAligned; p++) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = is.dst_ = p; + return; + } + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + size_t length; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; +#else + length = static_cast(__builtin_ffs(r) - 1); +#endif + p += length; + break; + } + } + + is.src_ = is.dst_ = p; + } +#elif defined(RAPIDJSON_NEON) + // StringStream -> StackStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream& os) { + const char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + return; + } + else + os.Put(*p++); + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + SizeType length = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + unsigned lz = (unsigned)__builtin_clzll(high);; + length = 8 + (lz >> 3); + escaped = true; + } + } else { + unsigned lz = (unsigned)__builtin_clzll(low);; + length = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + if (length != 0) { + char* q = reinterpret_cast(os.Push(length)); + for (size_t i = 0; i < length; i++) + q[i] = p[i]; + + p += length; + } + break; + } + vst1q_u8(reinterpret_cast(os.Push(16)), s); + } + + is.src_ = p; + } + + // InsituStringStream -> InsituStringStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) { + RAPIDJSON_ASSERT(&is == &os); + (void)os; + + if (is.src_ == is.dst_) { + SkipUnescapedString(is); + return; + } + + char* p = is.src_; + char *q = is.dst_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + is.dst_ = q; + return; + } + else + *q++ = *p++; + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16, q += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + SizeType length = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + unsigned lz = (unsigned)__builtin_clzll(high); + length = 8 + (lz >> 3); + escaped = true; + } + } else { + unsigned lz = (unsigned)__builtin_clzll(low); + length = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + for (const char* pend = p + length; p != pend; ) { + *q++ = *p++; + } + break; + } + vst1q_u8(reinterpret_cast(q), s); + } + + is.src_ = p; + is.dst_ = q; + } + + // When read/write pointers are the same for insitu stream, just skip unescaped characters + static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) { + RAPIDJSON_ASSERT(is.src_ == is.dst_); + char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + for (; p != nextAligned; p++) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = is.dst_ = p; + return; + } + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + if (low == 0) { + if (high != 0) { + int lz = __builtin_clzll(high); + p += 8 + (lz >> 3); + break; + } + } else { + int lz = __builtin_clzll(low); + p += lz >> 3; + break; + } + } + + is.src_ = is.dst_ = p; + } +#endif // RAPIDJSON_NEON + + template + class NumberStream; + + template + class NumberStream { + public: + typedef typename InputStream::Ch Ch; + + NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader; } + + RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); } + RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); } + RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); } + RAPIDJSON_FORCEINLINE void Push(char) {} + + size_t Tell() { return is.Tell(); } + size_t Length() { return 0; } + const char* Pop() { return 0; } + + protected: + NumberStream& operator=(const NumberStream&); + + InputStream& is; + }; + + template + class NumberStream : public NumberStream { + typedef NumberStream Base; + public: + NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {} + + RAPIDJSON_FORCEINLINE Ch TakePush() { + stackStream.Put(static_cast(Base::is.Peek())); + return Base::is.Take(); + } + + RAPIDJSON_FORCEINLINE void Push(char c) { + stackStream.Put(c); + } + + size_t Length() { return stackStream.Length(); } + + const char* Pop() { + stackStream.Put('\0'); + return stackStream.Pop(); + } + + private: + StackStream stackStream; + }; + + template + class NumberStream : public NumberStream { + typedef NumberStream Base; + public: + NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {} + + RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); } + }; + + template + void ParseNumber(InputStream& is, Handler& handler) { + internal::StreamLocalCopy copy(is); + NumberStream s(*this, copy.s); + + size_t startOffset = s.Tell(); + double d = 0.0; + bool useNanOrInf = false; + + // Parse minus + bool minus = Consume(s, '-'); + + // Parse int: zero / ( digit1-9 *DIGIT ) + unsigned i = 0; + uint64_t i64 = 0; + bool use64bit = false; + int significandDigit = 0; + if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) { + i = 0; + s.TakePush(); + } + else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) { + i = static_cast(s.TakePush() - '0'); + + if (minus) + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648 + if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) { + i64 = i; + use64bit = true; + break; + } + } + i = i * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + else + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295 + if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) { + i64 = i; + use64bit = true; + break; + } + } + i = i * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + } + // Parse NaN or Infinity here + else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) { + if (Consume(s, 'N')) { + if (Consume(s, 'a') && Consume(s, 'N')) { + d = std::numeric_limits::quiet_NaN(); + useNanOrInf = true; + } + } + else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) { + if (Consume(s, 'n') && Consume(s, 'f')) { + d = (minus ? -std::numeric_limits::infinity() : std::numeric_limits::infinity()); + useNanOrInf = true; + + if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n') + && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) { + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + } + } + } + + if (RAPIDJSON_UNLIKELY(!useNanOrInf)) { + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + } + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + + // Parse 64bit int + bool useDouble = false; + if (use64bit) { + if (minus) + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808 + if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) { + d = static_cast(i64); + useDouble = true; + break; + } + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + else + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615 + if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) { + d = static_cast(i64); + useDouble = true; + break; + } + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + } + + // Force double for big integer + if (useDouble) { + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + d = d * 10 + (s.TakePush() - '0'); + } + } + + // Parse frac = decimal-point 1*DIGIT + int expFrac = 0; + size_t decimalPosition; + if (Consume(s, '.')) { + decimalPosition = s.Length(); + + if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9'))) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell()); + + if (!useDouble) { +#if RAPIDJSON_64BIT + // Use i64 to store significand in 64-bit architecture + if (!use64bit) + i64 = i; + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path + break; + else { + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + --expFrac; + if (i64 != 0) + significandDigit++; + } + } + + d = static_cast(i64); +#else + // Use double to store significand in 32-bit architecture + d = static_cast(use64bit ? i64 : i); +#endif + useDouble = true; + } + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (significandDigit < 17) { + d = d * 10.0 + (s.TakePush() - '0'); + --expFrac; + if (RAPIDJSON_LIKELY(d > 0.0)) + significandDigit++; + } + else + s.TakePush(); + } + } + else + decimalPosition = s.Length(); // decimal position at the end of integer. + + // Parse exp = e [ minus / plus ] 1*DIGIT + int exp = 0; + if (Consume(s, 'e') || Consume(s, 'E')) { + if (!useDouble) { + d = static_cast(use64bit ? i64 : i); + useDouble = true; + } + + bool expMinus = false; + if (Consume(s, '+')) + ; + else if (Consume(s, '-')) + expMinus = true; + + if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = static_cast(s.Take() - '0'); + if (expMinus) { + // (exp + expFrac) must not underflow int => we're detecting when -exp gets + // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into + // underflow territory): + // + // -(exp * 10 + 9) + expFrac >= INT_MIN + // <=> exp <= (expFrac - INT_MIN - 9) / 10 + RAPIDJSON_ASSERT(expFrac <= 0); + int maxExp = (expFrac + 2147483639) / 10; + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = exp * 10 + static_cast(s.Take() - '0'); + if (RAPIDJSON_UNLIKELY(exp > maxExp)) { + while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9')) // Consume the rest of exponent + s.Take(); + } + } + } + else { // positive exp + int maxExp = 308 - expFrac; + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = exp * 10 + static_cast(s.Take() - '0'); + if (RAPIDJSON_UNLIKELY(exp > maxExp)) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset); + } + } + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell()); + + if (expMinus) + exp = -exp; + } + + // Finish parsing, call event according to the type of number. + bool cont = true; + + if (parseFlags & kParseNumbersAsStringsFlag) { + if (parseFlags & kParseInsituFlag) { + s.Pop(); // Pop stack no matter if it will be used or not. + typename InputStream::Ch* head = is.PutBegin(); + const size_t length = s.Tell() - startOffset; + RAPIDJSON_ASSERT(length <= 0xFFFFFFFF); + // unable to insert the \0 character here, it will erase the comma after this number + const typename TargetEncoding::Ch* const str = reinterpret_cast(head); + cont = handler.RawNumber(str, SizeType(length), false); + } + else { + SizeType numCharsToCopy = static_cast(s.Length()); + StringStream srcStream(s.Pop()); + StackStream dstStream(stack_); + while (numCharsToCopy--) { + Transcoder, TargetEncoding>::Transcode(srcStream, dstStream); + } + dstStream.Put('\0'); + const typename TargetEncoding::Ch* str = dstStream.Pop(); + const SizeType length = static_cast(dstStream.Length()) - 1; + cont = handler.RawNumber(str, SizeType(length), true); + } + } + else { + size_t length = s.Length(); + const char* decimal = s.Pop(); // Pop stack no matter if it will be used or not. + + if (useDouble) { + int p = exp + expFrac; + if (parseFlags & kParseFullPrecisionFlag) + d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp); + else + d = internal::StrtodNormalPrecision(d, p); + + // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal + if (d > (std::numeric_limits::max)()) { + // Overflow + // TODO: internal::StrtodX should report overflow (or underflow) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset); + } + + cont = handler.Double(minus ? -d : d); + } + else if (useNanOrInf) { + cont = handler.Double(d); + } + else { + if (use64bit) { + if (minus) + cont = handler.Int64(static_cast(~i64 + 1)); + else + cont = handler.Uint64(i64); + } + else { + if (minus) + cont = handler.Int(static_cast(~i + 1)); + else + cont = handler.Uint(i); + } + } + } + if (RAPIDJSON_UNLIKELY(!cont)) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset); + } + + // Parse any JSON value + template + void ParseValue(InputStream& is, Handler& handler) { + switch (is.Peek()) { + case 'n': ParseNull (is, handler); break; + case 't': ParseTrue (is, handler); break; + case 'f': ParseFalse (is, handler); break; + case '"': ParseString(is, handler); break; + case '{': ParseObject(is, handler); break; + case '[': ParseArray (is, handler); break; + default : + ParseNumber(is, handler); + break; + + } + } + + // Iterative Parsing + + // States + enum IterativeParsingState { + IterativeParsingFinishState = 0, // sink states at top + IterativeParsingErrorState, // sink states at top + IterativeParsingStartState, + + // Object states + IterativeParsingObjectInitialState, + IterativeParsingMemberKeyState, + IterativeParsingMemberValueState, + IterativeParsingObjectFinishState, + + // Array states + IterativeParsingArrayInitialState, + IterativeParsingElementState, + IterativeParsingArrayFinishState, + + // Single value state + IterativeParsingValueState, + + // Delimiter states (at bottom) + IterativeParsingElementDelimiterState, + IterativeParsingMemberDelimiterState, + IterativeParsingKeyValueDelimiterState, + + cIterativeParsingStateCount + }; + + // Tokens + enum Token { + LeftBracketToken = 0, + RightBracketToken, + + LeftCurlyBracketToken, + RightCurlyBracketToken, + + CommaToken, + ColonToken, + + StringToken, + FalseToken, + TrueToken, + NullToken, + NumberToken, + + kTokenCount + }; + + RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const { + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define N NumberToken +#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N + // Maps from ASCII to Token + static const unsigned char tokenMap[256] = { + N16, // 00~0F + N16, // 10~1F + N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F + N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F + N16, // 40~4F + N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F + N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F + N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F + N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF + }; +#undef N +#undef N16 +//!@endcond + + if (sizeof(Ch) == 1 || static_cast(c) < 256) + return static_cast(tokenMap[static_cast(c)]); + else + return NumberToken; + } + + RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const { + // current state x one lookahead token -> new state + static const char G[cIterativeParsingStateCount][kTokenCount] = { + // Finish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Error(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Start + { + IterativeParsingArrayInitialState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingValueState, // String + IterativeParsingValueState, // False + IterativeParsingValueState, // True + IterativeParsingValueState, // Null + IterativeParsingValueState // Number + }, + // ObjectInitial + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberKeyState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // MemberKey + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingKeyValueDelimiterState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // MemberValue + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingMemberDelimiterState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // ObjectFinish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // ArrayInitial + { + IterativeParsingArrayInitialState, // Left bracket(push Element state) + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push Element state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingElementState, // String + IterativeParsingElementState, // False + IterativeParsingElementState, // True + IterativeParsingElementState, // Null + IterativeParsingElementState // Number + }, + // Element + { + IterativeParsingErrorState, // Left bracket + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingElementDelimiterState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // ArrayFinish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Single Value (sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // ElementDelimiter + { + IterativeParsingArrayInitialState, // Left bracket(push Element state) + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push Element state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingElementState, // String + IterativeParsingElementState, // False + IterativeParsingElementState, // True + IterativeParsingElementState, // Null + IterativeParsingElementState // Number + }, + // MemberDelimiter + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberKeyState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // KeyValueDelimiter + { + IterativeParsingArrayInitialState, // Left bracket(push MemberValue state) + IterativeParsingErrorState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberValueState, // String + IterativeParsingMemberValueState, // False + IterativeParsingMemberValueState, // True + IterativeParsingMemberValueState, // Null + IterativeParsingMemberValueState // Number + }, + }; // End of G + + return static_cast(G[state][token]); + } + + // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit(). + // May return a new state on state pop. + template + RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) { + (void)token; + + switch (dst) { + case IterativeParsingErrorState: + return dst; + + case IterativeParsingObjectInitialState: + case IterativeParsingArrayInitialState: + { + // Push the state(Element or MemeberValue) if we are nested in another array or value of member. + // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop. + IterativeParsingState n = src; + if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState) + n = IterativeParsingElementState; + else if (src == IterativeParsingKeyValueDelimiterState) + n = IterativeParsingMemberValueState; + // Push current state. + *stack_.template Push(1) = n; + // Initialize and push the member/element count. + *stack_.template Push(1) = 0; + // Call handler + bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray(); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return dst; + } + } + + case IterativeParsingMemberKeyState: + ParseString(is, handler, true); + if (HasParseError()) + return IterativeParsingErrorState; + else + return dst; + + case IterativeParsingKeyValueDelimiterState: + RAPIDJSON_ASSERT(token == ColonToken); + is.Take(); + return dst; + + case IterativeParsingMemberValueState: + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return dst; + + case IterativeParsingElementState: + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return dst; + + case IterativeParsingMemberDelimiterState: + case IterativeParsingElementDelimiterState: + is.Take(); + // Update member/element count. + *stack_.template Top() = *stack_.template Top() + 1; + return dst; + + case IterativeParsingObjectFinishState: + { + // Transit from delimiter is only allowed when trailing commas are enabled + if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell()); + return IterativeParsingErrorState; + } + // Get member count. + SizeType c = *stack_.template Pop(1); + // If the object is not empty, count the last member. + if (src == IterativeParsingMemberValueState) + ++c; + // Restore the state. + IterativeParsingState n = static_cast(*stack_.template Pop(1)); + // Transit to Finish state if this is the topmost scope. + if (n == IterativeParsingStartState) + n = IterativeParsingFinishState; + // Call handler + bool hr = handler.EndObject(c); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return n; + } + } + + case IterativeParsingArrayFinishState: + { + // Transit from delimiter is only allowed when trailing commas are enabled + if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell()); + return IterativeParsingErrorState; + } + // Get element count. + SizeType c = *stack_.template Pop(1); + // If the array is not empty, count the last element. + if (src == IterativeParsingElementState) + ++c; + // Restore the state. + IterativeParsingState n = static_cast(*stack_.template Pop(1)); + // Transit to Finish state if this is the topmost scope. + if (n == IterativeParsingStartState) + n = IterativeParsingFinishState; + // Call handler + bool hr = handler.EndArray(c); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return n; + } + } + + default: + // This branch is for IterativeParsingValueState actually. + // Use `default:` rather than + // `case IterativeParsingValueState:` is for code coverage. + + // The IterativeParsingStartState is not enumerated in this switch-case. + // It is impossible for that case. And it can be caught by following assertion. + + // The IterativeParsingFinishState is not enumerated in this switch-case either. + // It is a "derivative" state which cannot triggered from Predict() directly. + // Therefore it cannot happen here. And it can be caught by following assertion. + RAPIDJSON_ASSERT(dst == IterativeParsingValueState); + + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return IterativeParsingFinishState; + } + } + + template + void HandleError(IterativeParsingState src, InputStream& is) { + if (HasParseError()) { + // Error flag has been set. + return; + } + + switch (src) { + case IterativeParsingStartState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return; + case IterativeParsingFinishState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return; + case IterativeParsingObjectInitialState: + case IterativeParsingMemberDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return; + case IterativeParsingMemberKeyState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return; + case IterativeParsingMemberValueState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return; + case IterativeParsingKeyValueDelimiterState: + case IterativeParsingArrayInitialState: + case IterativeParsingElementDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return; + default: RAPIDJSON_ASSERT(src == IterativeParsingElementState); RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return; + } + } + + RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const { + return s >= IterativeParsingElementDelimiterState; + } + + RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const { + return s <= IterativeParsingErrorState; + } + + template + ParseResult IterativeParse(InputStream& is, Handler& handler) { + parseResult_.Clear(); + ClearStackOnExit scope(*this); + IterativeParsingState state = IterativeParsingStartState; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + while (is.Peek() != '\0') { + Token t = Tokenize(is.Peek()); + IterativeParsingState n = Predict(state, t); + IterativeParsingState d = Transit(state, t, n, is, handler); + + if (d == IterativeParsingErrorState) { + HandleError(state, is); + break; + } + + state = d; + + // Do not further consume streams if a root JSON has been parsed. + if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState) + break; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + + // Handle the end of file. + if (state != IterativeParsingFinishState) + HandleError(state, is); + + return parseResult_; + } + + static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string. + internal::Stack stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing. + ParseResult parseResult_; + IterativeParsingState state_; +}; // class GenericReader + +//! Reader with UTF8 encoding and default allocator. +typedef GenericReader, UTF8<> > Reader; + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_READER_H_ diff --git a/SourceCode/dep_inc/rapidjson/schema.h b/SourceCode/dep_inc/rapidjson/schema.h new file mode 100644 index 0000000..fa0d696 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/schema.h @@ -0,0 +1,2494 @@ +// 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-> +// +// 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 +// +// http://opensource->org/licenses/MIT +// +// 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_SCHEMA_H_ +#define RAPIDJSON_SCHEMA_H_ + +#include "document.h" +#include "pointer.h" +#include "stringbuffer.h" +#include // abs, floor + +#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX) +#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1 +#else +#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0 +#endif + +#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)) +#define RAPIDJSON_SCHEMA_USE_STDREGEX 1 +#else +#define RAPIDJSON_SCHEMA_USE_STDREGEX 0 +#endif + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX +#include "internal/regex.h" +#elif RAPIDJSON_SCHEMA_USE_STDREGEX +#include +#endif + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX +#define RAPIDJSON_SCHEMA_HAS_REGEX 1 +#else +#define RAPIDJSON_SCHEMA_HAS_REGEX 0 +#endif + +#ifndef RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_SCHEMA_VERBOSE 0 +#endif + +#if RAPIDJSON_SCHEMA_VERBOSE +#include "stringbuffer.h" +#endif + +RAPIDJSON_DIAG_PUSH + +#if defined(__GNUC__) +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_OFF(weak-vtables) +RAPIDJSON_DIAG_OFF(exit-time-destructors) +RAPIDJSON_DIAG_OFF(c++98-compat-pedantic) +RAPIDJSON_DIAG_OFF(variadic-macros) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Verbose Utilities + +#if RAPIDJSON_SCHEMA_VERBOSE + +namespace internal { + +inline void PrintInvalidKeyword(const char* keyword) { + printf("Fail keyword: %s\n", keyword); +} + +inline void PrintInvalidKeyword(const wchar_t* keyword) { + wprintf(L"Fail keyword: %ls\n", keyword); +} + +inline void PrintInvalidDocument(const char* document) { + printf("Fail document: %s\n\n", document); +} + +inline void PrintInvalidDocument(const wchar_t* document) { + wprintf(L"Fail document: %ls\n\n", document); +} + +inline void PrintValidatorPointers(unsigned depth, const char* s, const char* d) { + printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d); +} + +inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar_t* d) { + wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d); +} + +} // namespace internal + +#endif // RAPIDJSON_SCHEMA_VERBOSE + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_INVALID_KEYWORD_RETURN + +#if RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword) +#else +#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) +#endif + +#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\ +RAPIDJSON_MULTILINEMACRO_BEGIN\ + context.invalidKeyword = keyword.GetString();\ + RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\ + return false;\ +RAPIDJSON_MULTILINEMACRO_END + +/////////////////////////////////////////////////////////////////////////////// +// Forward declarations + +template +class GenericSchemaDocument; + +namespace internal { + +template +class Schema; + +/////////////////////////////////////////////////////////////////////////////// +// ISchemaValidator + +class ISchemaValidator { +public: + virtual ~ISchemaValidator() {} + virtual bool IsValid() const = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// ISchemaStateFactory + +template +class ISchemaStateFactory { +public: + virtual ~ISchemaStateFactory() {} + virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&) = 0; + virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0; + virtual void* CreateHasher() = 0; + virtual uint64_t GetHashCode(void* hasher) = 0; + virtual void DestroryHasher(void* hasher) = 0; + virtual void* MallocState(size_t size) = 0; + virtual void FreeState(void* p) = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// IValidationErrorHandler + +template +class IValidationErrorHandler { +public: + typedef typename SchemaType::Ch Ch; + typedef typename SchemaType::SValue SValue; + + virtual ~IValidationErrorHandler() {} + + virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0; + virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0; + virtual void NotMultipleOf(double actual, const SValue& expected) = 0; + virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0; + + virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0; + virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0; + virtual void DoesNotMatch(const Ch* str, SizeType length) = 0; + + virtual void DisallowedItem(SizeType index) = 0; + virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0; + virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0; + virtual void DuplicateItems(SizeType index1, SizeType index2) = 0; + + virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0; + virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0; + virtual void StartMissingProperties() = 0; + virtual void AddMissingProperty(const SValue& name) = 0; + virtual bool EndMissingProperties() = 0; + virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void DisallowedProperty(const Ch* name, SizeType length) = 0; + + virtual void StartDependencyErrors() = 0; + virtual void StartMissingDependentProperties() = 0; + virtual void AddMissingDependentProperty(const SValue& targetName) = 0; + virtual void EndMissingDependentProperties(const SValue& sourceName) = 0; + virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0; + virtual bool EndDependencyErrors() = 0; + + virtual void DisallowedValue() = 0; + virtual void StartDisallowedType() = 0; + virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0; + virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0; + virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void Disallowed() = 0; +}; + + +/////////////////////////////////////////////////////////////////////////////// +// Hasher + +// For comparison of compound value +template +class Hasher { +public: + typedef typename Encoding::Ch Ch; + + Hasher(Allocator* allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {} + + bool Null() { return WriteType(kNullType); } + bool Bool(bool b) { return WriteType(b ? kTrueType : kFalseType); } + bool Int(int i) { Number n; n.u.i = i; n.d = static_cast(i); return WriteNumber(n); } + bool Uint(unsigned u) { Number n; n.u.u = u; n.d = static_cast(u); return WriteNumber(n); } + bool Int64(int64_t i) { Number n; n.u.i = i; n.d = static_cast(i); return WriteNumber(n); } + bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d = static_cast(u); return WriteNumber(n); } + bool Double(double d) { + Number n; + if (d < 0) n.u.i = static_cast(d); + else n.u.u = static_cast(d); + n.d = d; + return WriteNumber(n); + } + + bool RawNumber(const Ch* str, SizeType len, bool) { + WriteBuffer(kNumberType, str, len * sizeof(Ch)); + return true; + } + + bool String(const Ch* str, SizeType len, bool) { + WriteBuffer(kStringType, str, len * sizeof(Ch)); + return true; + } + + bool StartObject() { return true; } + bool Key(const Ch* str, SizeType len, bool copy) { return String(str, len, copy); } + bool EndObject(SizeType memberCount) { + uint64_t h = Hash(0, kObjectType); + uint64_t* kv = stack_.template Pop(memberCount * 2); + for (SizeType i = 0; i < memberCount; i++) + h ^= Hash(kv[i * 2], kv[i * 2 + 1]); // Use xor to achieve member order insensitive + *stack_.template Push() = h; + return true; + } + + bool StartArray() { return true; } + bool EndArray(SizeType elementCount) { + uint64_t h = Hash(0, kArrayType); + uint64_t* e = stack_.template Pop(elementCount); + for (SizeType i = 0; i < elementCount; i++) + h = Hash(h, e[i]); // Use hash to achieve element order sensitive + *stack_.template Push() = h; + return true; + } + + bool IsValid() const { return stack_.GetSize() == sizeof(uint64_t); } + + uint64_t GetHashCode() const { + RAPIDJSON_ASSERT(IsValid()); + return *stack_.template Top(); + } + +private: + static const size_t kDefaultSize = 256; + struct Number { + union U { + uint64_t u; + int64_t i; + }u; + double d; + }; + + bool WriteType(Type type) { return WriteBuffer(type, 0, 0); } + + bool WriteNumber(const Number& n) { return WriteBuffer(kNumberType, &n, sizeof(n)); } + + bool WriteBuffer(Type type, const void* data, size_t len) { + // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/ + uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type); + const unsigned char* d = static_cast(data); + for (size_t i = 0; i < len; i++) + h = Hash(h, d[i]); + *stack_.template Push() = h; + return true; + } + + static uint64_t Hash(uint64_t h, uint64_t d) { + static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3); + h ^= d; + h *= kPrime; + return h; + } + + Stack stack_; +}; + +/////////////////////////////////////////////////////////////////////////////// +// SchemaValidationContext + +template +struct SchemaValidationContext { + typedef Schema SchemaType; + typedef ISchemaStateFactory SchemaValidatorFactoryType; + typedef IValidationErrorHandler ErrorHandlerType; + typedef typename SchemaType::ValueType ValueType; + typedef typename ValueType::Ch Ch; + + enum PatternValidatorType { + kPatternValidatorOnly, + kPatternValidatorWithProperty, + kPatternValidatorWithAdditionalProperty + }; + + SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) : + factory(f), + error_handler(eh), + schema(s), + valueSchema(), + invalidKeyword(), + hasher(), + arrayElementHashCodes(), + validators(), + validatorCount(), + patternPropertiesValidators(), + patternPropertiesValidatorCount(), + patternPropertiesSchemas(), + patternPropertiesSchemaCount(), + valuePatternValidatorType(kPatternValidatorOnly), + propertyExist(), + inArray(false), + valueUniqueness(false), + arrayUniqueness(false) + { + } + + ~SchemaValidationContext() { + if (hasher) + factory.DestroryHasher(hasher); + if (validators) { + for (SizeType i = 0; i < validatorCount; i++) + factory.DestroySchemaValidator(validators[i]); + factory.FreeState(validators); + } + if (patternPropertiesValidators) { + for (SizeType i = 0; i < patternPropertiesValidatorCount; i++) + factory.DestroySchemaValidator(patternPropertiesValidators[i]); + factory.FreeState(patternPropertiesValidators); + } + if (patternPropertiesSchemas) + factory.FreeState(patternPropertiesSchemas); + if (propertyExist) + factory.FreeState(propertyExist); + } + + SchemaValidatorFactoryType& factory; + ErrorHandlerType& error_handler; + const SchemaType* schema; + const SchemaType* valueSchema; + const Ch* invalidKeyword; + void* hasher; // Only validator access + void* arrayElementHashCodes; // Only validator access this + ISchemaValidator** validators; + SizeType validatorCount; + ISchemaValidator** patternPropertiesValidators; + SizeType patternPropertiesValidatorCount; + const SchemaType** patternPropertiesSchemas; + SizeType patternPropertiesSchemaCount; + PatternValidatorType valuePatternValidatorType; + PatternValidatorType objectPatternValidatorType; + SizeType arrayElementIndex; + bool* propertyExist; + bool inArray; + bool valueUniqueness; + bool arrayUniqueness; +}; + +/////////////////////////////////////////////////////////////////////////////// +// Schema + +template +class Schema { +public: + typedef typename SchemaDocumentType::ValueType ValueType; + typedef typename SchemaDocumentType::AllocatorType AllocatorType; + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename EncodingType::Ch Ch; + typedef SchemaValidationContext Context; + typedef Schema SchemaType; + typedef GenericValue SValue; + typedef IValidationErrorHandler ErrorHandler; + friend class GenericSchemaDocument; + + Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) : + allocator_(allocator), + uri_(schemaDocument->GetURI(), *allocator), + pointer_(p), + typeless_(schemaDocument->GetTypeless()), + enum_(), + enumCount_(), + not_(), + type_((1 << kTotalSchemaType) - 1), // typeless + validatorCount_(), + notValidatorIndex_(), + properties_(), + additionalPropertiesSchema_(), + patternProperties_(), + patternPropertyCount_(), + propertyCount_(), + minProperties_(), + maxProperties_(SizeType(~0)), + additionalProperties_(true), + hasDependencies_(), + hasRequired_(), + hasSchemaDependencies_(), + additionalItemsSchema_(), + itemsList_(), + itemsTuple_(), + itemsTupleCount_(), + minItems_(), + maxItems_(SizeType(~0)), + additionalItems_(true), + uniqueItems_(false), + pattern_(), + minLength_(0), + maxLength_(~SizeType(0)), + exclusiveMinimum_(false), + exclusiveMaximum_(false), + defaultValueLength_(0) + { + typedef typename SchemaDocumentType::ValueType ValueType; + typedef typename ValueType::ConstValueIterator ConstValueIterator; + typedef typename ValueType::ConstMemberIterator ConstMemberIterator; + + if (!value.IsObject()) + return; + + if (const ValueType* v = GetMember(value, GetTypeString())) { + type_ = 0; + if (v->IsString()) + AddType(*v); + else if (v->IsArray()) + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) + AddType(*itr); + } + + if (const ValueType* v = GetMember(value, GetEnumString())) + if (v->IsArray() && v->Size() > 0) { + enum_ = static_cast(allocator_->Malloc(sizeof(uint64_t) * v->Size())); + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) { + typedef Hasher > EnumHasherType; + char buffer[256u + 24]; + MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer)); + EnumHasherType h(&hasherAllocator, 256); + itr->Accept(h); + enum_[enumCount_++] = h.GetHashCode(); + } + } + + if (schemaDocument) { + AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document); + AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document); + AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document); + } + + if (const ValueType* v = GetMember(value, GetNotString())) { + schemaDocument->CreateSchema(¬_, p.Append(GetNotString(), allocator_), *v, document); + notValidatorIndex_ = validatorCount_; + validatorCount_++; + } + + // Object + + const ValueType* properties = GetMember(value, GetPropertiesString()); + const ValueType* required = GetMember(value, GetRequiredString()); + const ValueType* dependencies = GetMember(value, GetDependenciesString()); + { + // Gather properties from properties/required/dependencies + SValue allProperties(kArrayType); + + if (properties && properties->IsObject()) + for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) + AddUniqueElement(allProperties, itr->name); + + if (required && required->IsArray()) + for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr) + if (itr->IsString()) + AddUniqueElement(allProperties, *itr); + + if (dependencies && dependencies->IsObject()) + for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) { + AddUniqueElement(allProperties, itr->name); + if (itr->value.IsArray()) + for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i) + if (i->IsString()) + AddUniqueElement(allProperties, *i); + } + + if (allProperties.Size() > 0) { + propertyCount_ = allProperties.Size(); + properties_ = static_cast(allocator_->Malloc(sizeof(Property) * propertyCount_)); + for (SizeType i = 0; i < propertyCount_; i++) { + new (&properties_[i]) Property(); + properties_[i].name = allProperties[i]; + properties_[i].schema = typeless_; + } + } + } + + if (properties && properties->IsObject()) { + PointerType q = p.Append(GetPropertiesString(), allocator_); + for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) { + SizeType index; + if (FindPropertyIndex(itr->name, &index)) + schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document); + } + } + + if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) { + PointerType q = p.Append(GetPatternPropertiesString(), allocator_); + patternProperties_ = static_cast(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount())); + patternPropertyCount_ = 0; + + for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) { + new (&patternProperties_[patternPropertyCount_]) PatternProperty(); + patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name); + schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document); + patternPropertyCount_++; + } + } + + if (required && required->IsArray()) + for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr) + if (itr->IsString()) { + SizeType index; + if (FindPropertyIndex(*itr, &index)) { + properties_[index].required = true; + hasRequired_ = true; + } + } + + if (dependencies && dependencies->IsObject()) { + PointerType q = p.Append(GetDependenciesString(), allocator_); + hasDependencies_ = true; + for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) { + SizeType sourceIndex; + if (FindPropertyIndex(itr->name, &sourceIndex)) { + if (itr->value.IsArray()) { + properties_[sourceIndex].dependencies = static_cast(allocator_->Malloc(sizeof(bool) * propertyCount_)); + std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_); + for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) { + SizeType targetIndex; + if (FindPropertyIndex(*targetItr, &targetIndex)) + properties_[sourceIndex].dependencies[targetIndex] = true; + } + } + else if (itr->value.IsObject()) { + hasSchemaDependencies_ = true; + schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document); + properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_; + validatorCount_++; + } + } + } + } + + if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) { + if (v->IsBool()) + additionalProperties_ = v->GetBool(); + else if (v->IsObject()) + schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document); + } + + AssignIfExist(minProperties_, value, GetMinPropertiesString()); + AssignIfExist(maxProperties_, value, GetMaxPropertiesString()); + + // Array + if (const ValueType* v = GetMember(value, GetItemsString())) { + PointerType q = p.Append(GetItemsString(), allocator_); + if (v->IsObject()) // List validation + schemaDocument->CreateSchema(&itemsList_, q, *v, document); + else if (v->IsArray()) { // Tuple validation + itemsTuple_ = static_cast(allocator_->Malloc(sizeof(const Schema*) * v->Size())); + SizeType index = 0; + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++) + schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document); + } + } + + AssignIfExist(minItems_, value, GetMinItemsString()); + AssignIfExist(maxItems_, value, GetMaxItemsString()); + + if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) { + if (v->IsBool()) + additionalItems_ = v->GetBool(); + else if (v->IsObject()) + schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document); + } + + AssignIfExist(uniqueItems_, value, GetUniqueItemsString()); + + // String + AssignIfExist(minLength_, value, GetMinLengthString()); + AssignIfExist(maxLength_, value, GetMaxLengthString()); + + if (const ValueType* v = GetMember(value, GetPatternString())) + pattern_ = CreatePattern(*v); + + // Number + if (const ValueType* v = GetMember(value, GetMinimumString())) + if (v->IsNumber()) + minimum_.CopyFrom(*v, *allocator_); + + if (const ValueType* v = GetMember(value, GetMaximumString())) + if (v->IsNumber()) + maximum_.CopyFrom(*v, *allocator_); + + AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString()); + AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString()); + + if (const ValueType* v = GetMember(value, GetMultipleOfString())) + if (v->IsNumber() && v->GetDouble() > 0.0) + multipleOf_.CopyFrom(*v, *allocator_); + + // Default + if (const ValueType* v = GetMember(value, GetDefaultValueString())) + if (v->IsString()) + defaultValueLength_ = v->GetStringLength(); + + } + + ~Schema() { + AllocatorType::Free(enum_); + if (properties_) { + for (SizeType i = 0; i < propertyCount_; i++) + properties_[i].~Property(); + AllocatorType::Free(properties_); + } + if (patternProperties_) { + for (SizeType i = 0; i < patternPropertyCount_; i++) + patternProperties_[i].~PatternProperty(); + AllocatorType::Free(patternProperties_); + } + AllocatorType::Free(itemsTuple_); +#if RAPIDJSON_SCHEMA_HAS_REGEX + if (pattern_) { + pattern_->~RegexType(); + AllocatorType::Free(pattern_); + } +#endif + } + + const SValue& GetURI() const { + return uri_; + } + + const PointerType& GetPointer() const { + return pointer_; + } + + bool BeginValue(Context& context) const { + if (context.inArray) { + if (uniqueItems_) + context.valueUniqueness = true; + + if (itemsList_) + context.valueSchema = itemsList_; + else if (itemsTuple_) { + if (context.arrayElementIndex < itemsTupleCount_) + context.valueSchema = itemsTuple_[context.arrayElementIndex]; + else if (additionalItemsSchema_) + context.valueSchema = additionalItemsSchema_; + else if (additionalItems_) + context.valueSchema = typeless_; + else { + context.error_handler.DisallowedItem(context.arrayElementIndex); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString()); + } + } + else + context.valueSchema = typeless_; + + context.arrayElementIndex++; + } + return true; + } + + RAPIDJSON_FORCEINLINE bool EndValue(Context& context) const { + if (context.patternPropertiesValidatorCount > 0) { + bool otherValid = false; + SizeType count = context.patternPropertiesValidatorCount; + if (context.objectPatternValidatorType != Context::kPatternValidatorOnly) + otherValid = context.patternPropertiesValidators[--count]->IsValid(); + + bool patternValid = true; + for (SizeType i = 0; i < count; i++) + if (!context.patternPropertiesValidators[i]->IsValid()) { + patternValid = false; + break; + } + + if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) { + if (!patternValid) { + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString()); + } + } + else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) { + if (!patternValid || !otherValid) { + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString()); + } + } + else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty) + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString()); + } + } + + if (enum_) { + const uint64_t h = context.factory.GetHashCode(context.hasher); + for (SizeType i = 0; i < enumCount_; i++) + if (enum_[i] == h) + goto foundEnum; + context.error_handler.DisallowedValue(); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString()); + foundEnum:; + } + + if (allOf_.schemas) + for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++) + if (!context.validators[i]->IsValid()) { + context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString()); + } + + if (anyOf_.schemas) { + for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++) + if (context.validators[i]->IsValid()) + goto foundAny; + context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString()); + foundAny:; + } + + if (oneOf_.schemas) { + bool oneValid = false; + for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++) + if (context.validators[i]->IsValid()) { + if (oneValid) { + context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString()); + } else + oneValid = true; + } + if (!oneValid) { + context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString()); + } + } + + if (not_ && context.validators[notValidatorIndex_]->IsValid()) { + context.error_handler.Disallowed(); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString()); + } + + return true; + } + + bool Null(Context& context) const { + if (!(type_ & (1 << kNullSchemaType))) { + DisallowedType(context, GetNullString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + return CreateParallelValidator(context); + } + + bool Bool(Context& context, bool) const { + if (!(type_ & (1 << kBooleanSchemaType))) { + DisallowedType(context, GetBooleanString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + return CreateParallelValidator(context); + } + + bool Int(Context& context, int i) const { + if (!CheckInt(context, i)) + return false; + return CreateParallelValidator(context); + } + + bool Uint(Context& context, unsigned u) const { + if (!CheckUint(context, u)) + return false; + return CreateParallelValidator(context); + } + + bool Int64(Context& context, int64_t i) const { + if (!CheckInt(context, i)) + return false; + return CreateParallelValidator(context); + } + + bool Uint64(Context& context, uint64_t u) const { + if (!CheckUint(context, u)) + return false; + return CreateParallelValidator(context); + } + + bool Double(Context& context, double d) const { + if (!(type_ & (1 << kNumberSchemaType))) { + DisallowedType(context, GetNumberString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d)) + return false; + + if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d)) + return false; + + if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d)) + return false; + + return CreateParallelValidator(context); + } + + bool String(Context& context, const Ch* str, SizeType length, bool) const { + if (!(type_ & (1 << kStringSchemaType))) { + DisallowedType(context, GetStringString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + if (minLength_ != 0 || maxLength_ != SizeType(~0)) { + SizeType count; + if (internal::CountStringCodePoint(str, length, &count)) { + if (count < minLength_) { + context.error_handler.TooShort(str, length, minLength_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString()); + } + if (count > maxLength_) { + context.error_handler.TooLong(str, length, maxLength_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString()); + } + } + } + + if (pattern_ && !IsPatternMatch(pattern_, str, length)) { + context.error_handler.DoesNotMatch(str, length); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString()); + } + + return CreateParallelValidator(context); + } + + bool StartObject(Context& context) const { + if (!(type_ & (1 << kObjectSchemaType))) { + DisallowedType(context, GetObjectString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + if (hasDependencies_ || hasRequired_) { + context.propertyExist = static_cast(context.factory.MallocState(sizeof(bool) * propertyCount_)); + std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_); + } + + if (patternProperties_) { // pre-allocate schema array + SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType + context.patternPropertiesSchemas = static_cast(context.factory.MallocState(sizeof(const SchemaType*) * count)); + context.patternPropertiesSchemaCount = 0; + std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count); + } + + return CreateParallelValidator(context); + } + + bool Key(Context& context, const Ch* str, SizeType len, bool) const { + if (patternProperties_) { + context.patternPropertiesSchemaCount = 0; + for (SizeType i = 0; i < patternPropertyCount_; i++) + if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema; + context.valueSchema = typeless_; + } + } + + SizeType index; + if (FindPropertyIndex(ValueType(str, len).Move(), &index)) { + if (context.patternPropertiesSchemaCount > 0) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema; + context.valueSchema = typeless_; + context.valuePatternValidatorType = Context::kPatternValidatorWithProperty; + } + else + context.valueSchema = properties_[index].schema; + + if (context.propertyExist) + context.propertyExist[index] = true; + + return true; + } + + if (additionalPropertiesSchema_) { + if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_; + context.valueSchema = typeless_; + context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty; + } + else + context.valueSchema = additionalPropertiesSchema_; + return true; + } + else if (additionalProperties_) { + context.valueSchema = typeless_; + return true; + } + + if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties + context.error_handler.DisallowedProperty(str, len); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString()); + } + + return true; + } + + bool EndObject(Context& context, SizeType memberCount) const { + if (hasRequired_) { + context.error_handler.StartMissingProperties(); + for (SizeType index = 0; index < propertyCount_; index++) + if (properties_[index].required && !context.propertyExist[index]) + if (properties_[index].schema->defaultValueLength_ == 0 ) + context.error_handler.AddMissingProperty(properties_[index].name); + if (context.error_handler.EndMissingProperties()) + RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString()); + } + + if (memberCount < minProperties_) { + context.error_handler.TooFewProperties(memberCount, minProperties_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString()); + } + + if (memberCount > maxProperties_) { + context.error_handler.TooManyProperties(memberCount, maxProperties_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString()); + } + + if (hasDependencies_) { + context.error_handler.StartDependencyErrors(); + for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) { + const Property& source = properties_[sourceIndex]; + if (context.propertyExist[sourceIndex]) { + if (source.dependencies) { + context.error_handler.StartMissingDependentProperties(); + for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++) + if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex]) + context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name); + context.error_handler.EndMissingDependentProperties(source.name); + } + else if (source.dependenciesSchema) { + ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex]; + if (!dependenciesValidator->IsValid()) + context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator); + } + } + } + if (context.error_handler.EndDependencyErrors()) + RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString()); + } + + return true; + } + + bool StartArray(Context& context) const { + if (!(type_ & (1 << kArraySchemaType))) { + DisallowedType(context, GetArrayString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + context.arrayElementIndex = 0; + context.inArray = true; + + return CreateParallelValidator(context); + } + + bool EndArray(Context& context, SizeType elementCount) const { + context.inArray = false; + + if (elementCount < minItems_) { + context.error_handler.TooFewItems(elementCount, minItems_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString()); + } + + if (elementCount > maxItems_) { + context.error_handler.TooManyItems(elementCount, maxItems_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString()); + } + + return true; + } + + // Generate functions for string literal according to Ch +#define RAPIDJSON_STRING_(name, ...) \ + static const ValueType& Get##name##String() {\ + static const Ch s[] = { __VA_ARGS__, '\0' };\ + static const ValueType v(s, static_cast(sizeof(s) / sizeof(Ch) - 1));\ + return v;\ + } + + RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l') + RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n') + RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't') + RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y') + RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g') + RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r') + RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r') + RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e') + RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm') + RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f') + RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f') + RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f') + RAPIDJSON_STRING_(Not, 'n', 'o', 't') + RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd') + RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's') + RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h') + RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h') + RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n') + RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f') + RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't') + +#undef RAPIDJSON_STRING_ + +private: + enum SchemaValueType { + kNullSchemaType, + kBooleanSchemaType, + kObjectSchemaType, + kArraySchemaType, + kStringSchemaType, + kNumberSchemaType, + kIntegerSchemaType, + kTotalSchemaType + }; + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX + typedef internal::GenericRegex RegexType; +#elif RAPIDJSON_SCHEMA_USE_STDREGEX + typedef std::basic_regex RegexType; +#else + typedef char RegexType; +#endif + + struct SchemaArray { + SchemaArray() : schemas(), count() {} + ~SchemaArray() { AllocatorType::Free(schemas); } + const SchemaType** schemas; + SizeType begin; // begin index of context.validators + SizeType count; + }; + + template + void AddUniqueElement(V1& a, const V2& v) { + for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr) + if (*itr == v) + return; + V1 c(v, *allocator_); + a.PushBack(c, *allocator_); + } + + static const ValueType* GetMember(const ValueType& value, const ValueType& name) { + typename ValueType::ConstMemberIterator itr = value.FindMember(name); + return itr != value.MemberEnd() ? &(itr->value) : 0; + } + + static void AssignIfExist(bool& out, const ValueType& value, const ValueType& name) { + if (const ValueType* v = GetMember(value, name)) + if (v->IsBool()) + out = v->GetBool(); + } + + static void AssignIfExist(SizeType& out, const ValueType& value, const ValueType& name) { + if (const ValueType* v = GetMember(value, name)) + if (v->IsUint64() && v->GetUint64() <= SizeType(~0)) + out = static_cast(v->GetUint64()); + } + + void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument, const PointerType& p, const ValueType& value, const ValueType& name, const ValueType& document) { + if (const ValueType* v = GetMember(value, name)) { + if (v->IsArray() && v->Size() > 0) { + PointerType q = p.Append(name, allocator_); + out.count = v->Size(); + out.schemas = static_cast(allocator_->Malloc(out.count * sizeof(const Schema*))); + memset(out.schemas, 0, sizeof(Schema*)* out.count); + for (SizeType i = 0; i < out.count; i++) + schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document); + out.begin = validatorCount_; + validatorCount_ += out.count; + } + } + } + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX + template + RegexType* CreatePattern(const ValueType& value) { + if (value.IsString()) { + RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_); + if (!r->IsValid()) { + r->~RegexType(); + AllocatorType::Free(r); + r = 0; + } + return r; + } + return 0; + } + + static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) { + GenericRegexSearch rs(*pattern); + return rs.Search(str); + } +#elif RAPIDJSON_SCHEMA_USE_STDREGEX + template + RegexType* CreatePattern(const ValueType& value) { + if (value.IsString()) + try { + return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript); + } + catch (const std::regex_error&) { + } + return 0; + } + + static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType length) { + std::match_results r; + return std::regex_search(str, str + length, r, *pattern); + } +#else + template + RegexType* CreatePattern(const ValueType&) { return 0; } + + static bool IsPatternMatch(const RegexType*, const Ch *, SizeType) { return true; } +#endif // RAPIDJSON_SCHEMA_USE_STDREGEX + + void AddType(const ValueType& type) { + if (type == GetNullString() ) type_ |= 1 << kNullSchemaType; + else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType; + else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType; + else if (type == GetArrayString() ) type_ |= 1 << kArraySchemaType; + else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType; + else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType; + else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType); + } + + bool CreateParallelValidator(Context& context) const { + if (enum_ || context.arrayUniqueness) + context.hasher = context.factory.CreateHasher(); + + if (validatorCount_) { + RAPIDJSON_ASSERT(context.validators == 0); + context.validators = static_cast(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_)); + context.validatorCount = validatorCount_; + + if (allOf_.schemas) + CreateSchemaValidators(context, allOf_); + + if (anyOf_.schemas) + CreateSchemaValidators(context, anyOf_); + + if (oneOf_.schemas) + CreateSchemaValidators(context, oneOf_); + + if (not_) + context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_); + + if (hasSchemaDependencies_) { + for (SizeType i = 0; i < propertyCount_; i++) + if (properties_[i].dependenciesSchema) + context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema); + } + } + + return true; + } + + void CreateSchemaValidators(Context& context, const SchemaArray& schemas) const { + for (SizeType i = 0; i < schemas.count; i++) + context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]); + } + + // O(n) + bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const { + SizeType len = name.GetStringLength(); + const Ch* str = name.GetString(); + for (SizeType index = 0; index < propertyCount_; index++) + if (properties_[index].name.GetStringLength() == len && + (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0)) + { + *outIndex = index; + return true; + } + return false; + } + + bool CheckInt(Context& context, int64_t i) const { + if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) { + DisallowedType(context, GetIntegerString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + if (!minimum_.IsNull()) { + if (minimum_.IsInt64()) { + if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); + } + } + else if (minimum_.IsUint64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64() + } + else if (!CheckDoubleMinimum(context, static_cast(i))) + return false; + } + + if (!maximum_.IsNull()) { + if (maximum_.IsInt64()) { + if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); + } + } + else if (maximum_.IsUint64()) { } + /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64() + else if (!CheckDoubleMaximum(context, static_cast(i))) + return false; + } + + if (!multipleOf_.IsNull()) { + if (multipleOf_.IsUint64()) { + if (static_cast(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) { + context.error_handler.NotMultipleOf(i, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString()); + } + } + else if (!CheckDoubleMultipleOf(context, static_cast(i))) + return false; + } + + return true; + } + + bool CheckUint(Context& context, uint64_t i) const { + if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) { + DisallowedType(context, GetIntegerString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString()); + } + + if (!minimum_.IsNull()) { + if (minimum_.IsUint64()) { + if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); + } + } + else if (minimum_.IsInt64()) + /* do nothing */; // i >= 0 > minimum.Getint64() + else if (!CheckDoubleMinimum(context, static_cast(i))) + return false; + } + + if (!maximum_.IsNull()) { + if (maximum_.IsUint64()) { + if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); + } + } + else if (maximum_.IsInt64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_ + } + else if (!CheckDoubleMaximum(context, static_cast(i))) + return false; + } + + if (!multipleOf_.IsNull()) { + if (multipleOf_.IsUint64()) { + if (i % multipleOf_.GetUint64() != 0) { + context.error_handler.NotMultipleOf(i, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString()); + } + } + else if (!CheckDoubleMultipleOf(context, static_cast(i))) + return false; + } + + return true; + } + + bool CheckDoubleMinimum(Context& context, double d) const { + if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) { + context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); + } + return true; + } + + bool CheckDoubleMaximum(Context& context, double d) const { + if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) { + context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); + } + return true; + } + + bool CheckDoubleMultipleOf(Context& context, double d) const { + double a = std::abs(d), b = std::abs(multipleOf_.GetDouble()); + double q = std::floor(a / b); + double r = a - q * b; + if (r > 0.0) { + context.error_handler.NotMultipleOf(d, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString()); + } + return true; + } + + void DisallowedType(Context& context, const ValueType& actualType) const { + ErrorHandler& eh = context.error_handler; + eh.StartDisallowedType(); + + if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString()); + if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString()); + if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString()); + if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString()); + if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString()); + + if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString()); + else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString()); + + eh.EndDisallowedType(actualType); + } + + struct Property { + Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {} + ~Property() { AllocatorType::Free(dependencies); } + SValue name; + const SchemaType* schema; + const SchemaType* dependenciesSchema; + SizeType dependenciesValidatorIndex; + bool* dependencies; + bool required; + }; + + struct PatternProperty { + PatternProperty() : schema(), pattern() {} + ~PatternProperty() { + if (pattern) { + pattern->~RegexType(); + AllocatorType::Free(pattern); + } + } + const SchemaType* schema; + RegexType* pattern; + }; + + AllocatorType* allocator_; + SValue uri_; + PointerType pointer_; + const SchemaType* typeless_; + uint64_t* enum_; + SizeType enumCount_; + SchemaArray allOf_; + SchemaArray anyOf_; + SchemaArray oneOf_; + const SchemaType* not_; + unsigned type_; // bitmask of kSchemaType + SizeType validatorCount_; + SizeType notValidatorIndex_; + + Property* properties_; + const SchemaType* additionalPropertiesSchema_; + PatternProperty* patternProperties_; + SizeType patternPropertyCount_; + SizeType propertyCount_; + SizeType minProperties_; + SizeType maxProperties_; + bool additionalProperties_; + bool hasDependencies_; + bool hasRequired_; + bool hasSchemaDependencies_; + + const SchemaType* additionalItemsSchema_; + const SchemaType* itemsList_; + const SchemaType** itemsTuple_; + SizeType itemsTupleCount_; + SizeType minItems_; + SizeType maxItems_; + bool additionalItems_; + bool uniqueItems_; + + RegexType* pattern_; + SizeType minLength_; + SizeType maxLength_; + + SValue minimum_; + SValue maximum_; + SValue multipleOf_; + bool exclusiveMinimum_; + bool exclusiveMaximum_; + + SizeType defaultValueLength_; +}; + +template +struct TokenHelper { + RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) { + *documentStack.template Push() = '/'; + char buffer[21]; + size_t length = static_cast((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer); + for (size_t i = 0; i < length; i++) + *documentStack.template Push() = static_cast(buffer[i]); + } +}; + +// Partial specialized version for char to prevent buffer copying. +template +struct TokenHelper { + RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) { + if (sizeof(SizeType) == 4) { + char *buffer = documentStack.template Push(1 + 10); // '/' + uint + *buffer++ = '/'; + const char* end = internal::u32toa(index, buffer); + documentStack.template Pop(static_cast(10 - (end - buffer))); + } + else { + char *buffer = documentStack.template Push(1 + 20); // '/' + uint64 + *buffer++ = '/'; + const char* end = internal::u64toa(index, buffer); + documentStack.template Pop(static_cast(20 - (end - buffer))); + } + } +}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// IGenericRemoteSchemaDocumentProvider + +template +class IGenericRemoteSchemaDocumentProvider { +public: + typedef typename SchemaDocumentType::Ch Ch; + + virtual ~IGenericRemoteSchemaDocumentProvider() {} + virtual const SchemaDocumentType* GetRemoteDocument(const Ch* uri, SizeType length) = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericSchemaDocument + +//! JSON schema document. +/*! + A JSON schema document is a compiled version of a JSON schema. + It is basically a tree of internal::Schema. + + \note This is an immutable class (i.e. its instance cannot be modified after construction). + \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding. + \tparam Allocator Allocator type for allocating memory of this document. +*/ +template +class GenericSchemaDocument { +public: + typedef ValueT ValueType; + typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProviderType; + typedef Allocator AllocatorType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename EncodingType::Ch Ch; + typedef internal::Schema SchemaType; + typedef GenericPointer PointerType; + typedef GenericValue URIType; + friend class internal::Schema; + template + friend class GenericSchemaValidator; + + //! Constructor. + /*! + Compile a JSON document into schema document. + + \param document A JSON document as source. + \param uri The base URI of this schema document for purposes of violation reporting. + \param uriLength Length of \c name, in code points. + \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null. + \param allocator An optional allocator instance for allocating memory. Can be null. + */ + explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0, + IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) : + remoteProvider_(remoteProvider), + allocator_(allocator), + ownAllocator_(), + root_(), + typeless_(), + schemaMap_(allocator, kInitialSchemaMapSize), + schemaRef_(allocator, kInitialSchemaRefSize) + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + Ch noUri[1] = {0}; + uri_.SetString(uri ? uri : noUri, uriLength, *allocator_); + + typeless_ = static_cast(allocator_->Malloc(sizeof(SchemaType))); + new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_); + + // Generate root schema, it will call CreateSchema() to create sub-schemas, + // And call AddRefSchema() if there are $ref. + CreateSchemaRecursive(&root_, PointerType(), document, document); + + // Resolve $ref + while (!schemaRef_.Empty()) { + SchemaRefEntry* refEntry = schemaRef_.template Pop(1); + if (const SchemaType* s = GetSchema(refEntry->target)) { + if (refEntry->schema) + *refEntry->schema = s; + + // Create entry in map if not exist + if (!GetSchema(refEntry->source)) { + new (schemaMap_.template Push()) SchemaEntry(refEntry->source, const_cast(s), false, allocator_); + } + } + else if (refEntry->schema) + *refEntry->schema = typeless_; + + refEntry->~SchemaRefEntry(); + } + + RAPIDJSON_ASSERT(root_ != 0); + + schemaRef_.ShrinkToFit(); // Deallocate all memory for ref + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericSchemaDocument(GenericSchemaDocument&& rhs) RAPIDJSON_NOEXCEPT : + remoteProvider_(rhs.remoteProvider_), + allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + root_(rhs.root_), + typeless_(rhs.typeless_), + schemaMap_(std::move(rhs.schemaMap_)), + schemaRef_(std::move(rhs.schemaRef_)), + uri_(std::move(rhs.uri_)) + { + rhs.remoteProvider_ = 0; + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.typeless_ = 0; + } +#endif + + //! Destructor + ~GenericSchemaDocument() { + while (!schemaMap_.Empty()) + schemaMap_.template Pop(1)->~SchemaEntry(); + + if (typeless_) { + typeless_->~SchemaType(); + Allocator::Free(typeless_); + } + + RAPIDJSON_DELETE(ownAllocator_); + } + + const URIType& GetURI() const { return uri_; } + + //! Get the root schema. + const SchemaType& GetRoot() const { return *root_; } + +private: + //! Prohibit copying + GenericSchemaDocument(const GenericSchemaDocument&); + //! Prohibit assignment + GenericSchemaDocument& operator=(const GenericSchemaDocument&); + + struct SchemaRefEntry { + SchemaRefEntry(const PointerType& s, const PointerType& t, const SchemaType** outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {} + PointerType source; + PointerType target; + const SchemaType** schema; + }; + + struct SchemaEntry { + SchemaEntry(const PointerType& p, SchemaType* s, bool o, Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {} + ~SchemaEntry() { + if (owned) { + schema->~SchemaType(); + Allocator::Free(schema); + } + } + PointerType pointer; + SchemaType* schema; + bool owned; + }; + + void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) { + if (schema) + *schema = typeless_; + + if (v.GetType() == kObjectType) { + const SchemaType* s = GetSchema(pointer); + if (!s) + CreateSchema(schema, pointer, v, document); + + for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr) + CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document); + } + else if (v.GetType() == kArrayType) + for (SizeType i = 0; i < v.Size(); i++) + CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document); + } + + void CreateSchema(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) { + RAPIDJSON_ASSERT(pointer.IsValid()); + if (v.IsObject()) { + if (!HandleRefSchema(pointer, schema, v, document)) { + SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_); + new (schemaMap_.template Push()) SchemaEntry(pointer, s, true, allocator_); + if (schema) + *schema = s; + } + } + } + + bool HandleRefSchema(const PointerType& source, const SchemaType** schema, const ValueType& v, const ValueType& document) { + static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' }; + static const ValueType kRefValue(kRefString, 4); + + typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue); + if (itr == v.MemberEnd()) + return false; + + if (itr->value.IsString()) { + SizeType len = itr->value.GetStringLength(); + if (len > 0) { + const Ch* s = itr->value.GetString(); + SizeType i = 0; + while (i < len && s[i] != '#') // Find the first # + i++; + + if (i > 0) { // Remote reference, resolve immediately + if (remoteProvider_) { + if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) { + PointerType pointer(&s[i], len - i, allocator_); + if (pointer.IsValid()) { + if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) { + if (schema) + *schema = sc; + new (schemaMap_.template Push()) SchemaEntry(source, const_cast(sc), false, allocator_); + return true; + } + } + } + } + } + else if (s[i] == '#') { // Local reference, defer resolution + PointerType pointer(&s[i], len - i, allocator_); + if (pointer.IsValid()) { + if (const ValueType* nv = pointer.Get(document)) + if (HandleRefSchema(source, schema, *nv, document)) + return true; + + new (schemaRef_.template Push()) SchemaRefEntry(source, pointer, schema, allocator_); + return true; + } + } + } + } + return false; + } + + const SchemaType* GetSchema(const PointerType& pointer) const { + for (const SchemaEntry* target = schemaMap_.template Bottom(); target != schemaMap_.template End(); ++target) + if (pointer == target->pointer) + return target->schema; + return 0; + } + + PointerType GetPointer(const SchemaType* schema) const { + for (const SchemaEntry* target = schemaMap_.template Bottom(); target != schemaMap_.template End(); ++target) + if (schema == target->schema) + return target->pointer; + return PointerType(); + } + + const SchemaType* GetTypeless() const { return typeless_; } + + static const size_t kInitialSchemaMapSize = 64; + static const size_t kInitialSchemaRefSize = 64; + + IRemoteSchemaDocumentProviderType* remoteProvider_; + Allocator *allocator_; + Allocator *ownAllocator_; + const SchemaType* root_; //!< Root schema. + SchemaType* typeless_; + internal::Stack schemaMap_; // Stores created Pointer -> Schemas + internal::Stack schemaRef_; // Stores Pointer from $ref and schema which holds the $ref + URIType uri_; +}; + +//! GenericSchemaDocument using Value type. +typedef GenericSchemaDocument SchemaDocument; +//! IGenericRemoteSchemaDocumentProvider using SchemaDocument. +typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProvider; + +/////////////////////////////////////////////////////////////////////////////// +// GenericSchemaValidator + +//! JSON Schema Validator. +/*! + A SAX style JSON schema validator. + It uses a \c GenericSchemaDocument to validate SAX events. + It delegates the incoming SAX events to an output handler. + The default output handler does nothing. + It can be reused multiple times by calling \c Reset(). + + \tparam SchemaDocumentType Type of schema document. + \tparam OutputHandler Type of output handler. Default handler does nothing. + \tparam StateAllocator Allocator for storing the internal validation states. +*/ +template < + typename SchemaDocumentType, + typename OutputHandler = BaseReaderHandler, + typename StateAllocator = CrtAllocator> +class GenericSchemaValidator : + public internal::ISchemaStateFactory, + public internal::ISchemaValidator, + public internal::IValidationErrorHandler +{ +public: + typedef typename SchemaDocumentType::SchemaType SchemaType; + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename SchemaType::EncodingType EncodingType; + typedef typename SchemaType::SValue SValue; + typedef typename EncodingType::Ch Ch; + typedef GenericStringRef StringRefType; + typedef GenericValue ValueType; + + //! Constructor without output handler. + /*! + \param schemaDocument The schema document to conform to. + \param allocator Optional allocator for storing internal validation states. + \param schemaStackCapacity Optional initial capacity of schema path stack. + \param documentStackCapacity Optional initial capacity of document path stack. + */ + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(schemaDocument.GetRoot()), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(0), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(0) +#endif + { + } + + //! Constructor with output handler. + /*! + \param schemaDocument The schema document to conform to. + \param allocator Optional allocator for storing internal validation states. + \param schemaStackCapacity Optional initial capacity of schema path stack. + \param documentStackCapacity Optional initial capacity of document path stack. + */ + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + OutputHandler& outputHandler, + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(schemaDocument.GetRoot()), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(&outputHandler), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(0) +#endif + { + } + + //! Destructor. + ~GenericSchemaValidator() { + Reset(); + RAPIDJSON_DELETE(ownStateAllocator_); + } + + //! Reset the internal states. + void Reset() { + while (!schemaStack_.Empty()) + PopSchema(); + documentStack_.Clear(); + error_.SetObject(); + currentError_.SetNull(); + missingDependents_.SetNull(); + valid_ = true; + } + + //! Checks whether the current state is valid. + // Implementation of ISchemaValidator + virtual bool IsValid() const { return valid_; } + + //! Gets the error object. + ValueType& GetError() { return error_; } + const ValueType& GetError() const { return error_; } + + //! Gets the JSON pointer pointed to the invalid schema. + PointerType GetInvalidSchemaPointer() const { + return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer(); + } + + //! Gets the keyword of invalid schema. + const Ch* GetInvalidSchemaKeyword() const { + return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword; + } + + //! Gets the JSON pointer pointed to the invalid value. + PointerType GetInvalidDocumentPointer() const { + if (documentStack_.Empty()) { + return PointerType(); + } + else { + return PointerType(documentStack_.template Bottom(), documentStack_.GetSize() / sizeof(Ch)); + } + } + + void NotMultipleOf(int64_t actual, const SValue& expected) { + AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected); + } + void NotMultipleOf(uint64_t actual, const SValue& expected) { + AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected); + } + void NotMultipleOf(double actual, const SValue& expected) { + AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected); + } + void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void AboveMaximum(double actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + void BelowMinimum(double actual, const SValue& expected, bool exclusive) { + AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + + void TooLong(const Ch* str, SizeType length, SizeType expected) { + AddNumberError(SchemaType::GetMaxLengthString(), + ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move()); + } + void TooShort(const Ch* str, SizeType length, SizeType expected) { + AddNumberError(SchemaType::GetMinLengthString(), + ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move()); + } + void DoesNotMatch(const Ch* str, SizeType length) { + currentError_.SetObject(); + currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator()); + AddCurrentError(SchemaType::GetPatternString()); + } + + void DisallowedItem(SizeType index) { + currentError_.SetObject(); + currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator()); + AddCurrentError(SchemaType::GetAdditionalItemsString(), true); + } + void TooFewItems(SizeType actualCount, SizeType expectedCount) { + AddNumberError(SchemaType::GetMinItemsString(), + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void TooManyItems(SizeType actualCount, SizeType expectedCount) { + AddNumberError(SchemaType::GetMaxItemsString(), + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void DuplicateItems(SizeType index1, SizeType index2) { + ValueType duplicates(kArrayType); + duplicates.PushBack(index1, GetStateAllocator()); + duplicates.PushBack(index2, GetStateAllocator()); + currentError_.SetObject(); + currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator()); + AddCurrentError(SchemaType::GetUniqueItemsString(), true); + } + + void TooManyProperties(SizeType actualCount, SizeType expectedCount) { + AddNumberError(SchemaType::GetMaxPropertiesString(), + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void TooFewProperties(SizeType actualCount, SizeType expectedCount) { + AddNumberError(SchemaType::GetMinPropertiesString(), + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void StartMissingProperties() { + currentError_.SetArray(); + } + void AddMissingProperty(const SValue& name) { + currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator()); + } + bool EndMissingProperties() { + if (currentError_.Empty()) + return false; + ValueType error(kObjectType); + error.AddMember(GetMissingString(), currentError_, GetStateAllocator()); + currentError_ = error; + AddCurrentError(SchemaType::GetRequiredString()); + return true; + } + void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) { + for (SizeType i = 0; i < count; ++i) + MergeError(static_cast(subvalidators[i])->GetError()); + } + void DisallowedProperty(const Ch* name, SizeType length) { + currentError_.SetObject(); + currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator()); + AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true); + } + + void StartDependencyErrors() { + currentError_.SetObject(); + } + void StartMissingDependentProperties() { + missingDependents_.SetArray(); + } + void AddMissingDependentProperty(const SValue& targetName) { + missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator()); + } + void EndMissingDependentProperties(const SValue& sourceName) { + if (!missingDependents_.Empty()) + currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), + missingDependents_, GetStateAllocator()); + } + void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) { + currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), + static_cast(subvalidator)->GetError(), GetStateAllocator()); + } + bool EndDependencyErrors() { + if (currentError_.ObjectEmpty()) + return false; + ValueType error(kObjectType); + error.AddMember(GetErrorsString(), currentError_, GetStateAllocator()); + currentError_ = error; + AddCurrentError(SchemaType::GetDependenciesString()); + return true; + } + + void DisallowedValue() { + currentError_.SetObject(); + AddCurrentError(SchemaType::GetEnumString()); + } + void StartDisallowedType() { + currentError_.SetArray(); + } + void AddExpectedType(const typename SchemaType::ValueType& expectedType) { + currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator()); + } + void EndDisallowedType(const typename SchemaType::ValueType& actualType) { + ValueType error(kObjectType); + error.AddMember(GetExpectedString(), currentError_, GetStateAllocator()); + error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator()); + currentError_ = error; + AddCurrentError(SchemaType::GetTypeString()); + } + void NotAllOf(ISchemaValidator** subvalidators, SizeType count) { + for (SizeType i = 0; i < count; ++i) { + MergeError(static_cast(subvalidators[i])->GetError()); + } + } + void NoneOf(ISchemaValidator** subvalidators, SizeType count) { + AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count); + } + void NotOneOf(ISchemaValidator** subvalidators, SizeType count) { + AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count); + } + void Disallowed() { + currentError_.SetObject(); + AddCurrentError(SchemaType::GetNotString()); + } + +#define RAPIDJSON_STRING_(name, ...) \ + static const StringRefType& Get##name##String() {\ + static const Ch s[] = { __VA_ARGS__, '\0' };\ + static const StringRefType v(s, static_cast(sizeof(s) / sizeof(Ch) - 1)); \ + return v;\ + } + + RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f') + RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f') + RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd') + RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l') + RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd') + RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g') + RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's') + RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's') + +#undef RAPIDJSON_STRING_ + +#if RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \ +RAPIDJSON_MULTILINEMACRO_BEGIN\ + *documentStack_.template Push() = '\0';\ + documentStack_.template Pop(1);\ + internal::PrintInvalidDocument(documentStack_.template Bottom());\ +RAPIDJSON_MULTILINEMACRO_END +#else +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() +#endif + +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\ + if (!valid_) return false; \ + if (!BeginValue() || !CurrentSchema().method arg1) {\ + RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\ + return valid_ = false;\ + } + +#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\ + for (Context* context = schemaStack_.template Bottom(); context != schemaStack_.template End(); context++) {\ + if (context->hasher)\ + static_cast(context->hasher)->method arg2;\ + if (context->validators)\ + for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\ + static_cast(context->validators[i_])->method arg2;\ + if (context->patternPropertiesValidators)\ + for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\ + static_cast(context->patternPropertiesValidators[i_])->method arg2;\ + } + +#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\ + return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2) + +#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \ + RAPIDJSON_SCHEMA_HANDLE_BEGIN_ (method, arg1);\ + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\ + RAPIDJSON_SCHEMA_HANDLE_END_ (method, arg2) + + bool Null() { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext()), ( )); } + bool Bool(bool b) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, (CurrentContext(), b), (b)); } + bool Int(int i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, (CurrentContext(), i), (i)); } + bool Uint(unsigned u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, (CurrentContext(), u), (u)); } + bool Int64(int64_t i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64, (CurrentContext(), i), (i)); } + bool Uint64(uint64_t u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); } + bool Double(double d) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); } + bool RawNumber(const Ch* str, SizeType length, bool copy) + { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); } + bool String(const Ch* str, SizeType length, bool copy) + { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); } + + bool StartObject() { + RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext())); + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ()); + return valid_ = !outputHandler_ || outputHandler_->StartObject(); + } + + bool Key(const Ch* str, SizeType len, bool copy) { + if (!valid_) return false; + AppendToken(str, len); + if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy)); + return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy); + } + + bool EndObject(SizeType memberCount) { + if (!valid_) return false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount)); + if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount)); + } + + bool StartArray() { + RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext())); + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ()); + return valid_ = !outputHandler_ || outputHandler_->StartArray(); + } + + bool EndArray(SizeType elementCount) { + if (!valid_) return false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount)); + if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount)); + } + +#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_ +#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_ +#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_ +#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_ + + // Implementation of ISchemaStateFactory + virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) { + return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom(), documentStack_.GetSize(), +#if RAPIDJSON_SCHEMA_VERBOSE + depth_ + 1, +#endif + &GetStateAllocator()); + } + + virtual void DestroySchemaValidator(ISchemaValidator* validator) { + GenericSchemaValidator* v = static_cast(validator); + v->~GenericSchemaValidator(); + StateAllocator::Free(v); + } + + virtual void* CreateHasher() { + return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator()); + } + + virtual uint64_t GetHashCode(void* hasher) { + return static_cast(hasher)->GetHashCode(); + } + + virtual void DestroryHasher(void* hasher) { + HasherType* h = static_cast(hasher); + h->~HasherType(); + StateAllocator::Free(h); + } + + virtual void* MallocState(size_t size) { + return GetStateAllocator().Malloc(size); + } + + virtual void FreeState(void* p) { + StateAllocator::Free(p); + } + +private: + typedef typename SchemaType::Context Context; + typedef GenericValue, StateAllocator> HashCodeArray; + typedef internal::Hasher HasherType; + + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + const SchemaType& root, + const char* basePath, size_t basePathSize, +#if RAPIDJSON_SCHEMA_VERBOSE + unsigned depth, +#endif + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(root), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(0), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(depth) +#endif + { + if (basePath && basePathSize) + memcpy(documentStack_.template Push(basePathSize), basePath, basePathSize); + } + + StateAllocator& GetStateAllocator() { + if (!stateAllocator_) + stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator)(); + return *stateAllocator_; + } + + bool BeginValue() { + if (schemaStack_.Empty()) + PushSchema(root_); + else { + if (CurrentContext().inArray) + internal::TokenHelper, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex); + + if (!CurrentSchema().BeginValue(CurrentContext())) + return false; + + SizeType count = CurrentContext().patternPropertiesSchemaCount; + const SchemaType** sa = CurrentContext().patternPropertiesSchemas; + typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType; + bool valueUniqueness = CurrentContext().valueUniqueness; + RAPIDJSON_ASSERT(CurrentContext().valueSchema); + PushSchema(*CurrentContext().valueSchema); + + if (count > 0) { + CurrentContext().objectPatternValidatorType = patternValidatorType; + ISchemaValidator**& va = CurrentContext().patternPropertiesValidators; + SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount; + va = static_cast(MallocState(sizeof(ISchemaValidator*) * count)); + for (SizeType i = 0; i < count; i++) + va[validatorCount++] = CreateSchemaValidator(*sa[i]); + } + + CurrentContext().arrayUniqueness = valueUniqueness; + } + return true; + } + + bool EndValue() { + if (!CurrentSchema().EndValue(CurrentContext())) + return false; + +#if RAPIDJSON_SCHEMA_VERBOSE + GenericStringBuffer sb; + schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb); + + *documentStack_.template Push() = '\0'; + documentStack_.template Pop(1); + internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom()); +#endif + + uint64_t h = CurrentContext().arrayUniqueness ? static_cast(CurrentContext().hasher)->GetHashCode() : 0; + + PopSchema(); + + if (!schemaStack_.Empty()) { + Context& context = CurrentContext(); + if (context.valueUniqueness) { + HashCodeArray* a = static_cast(context.arrayElementHashCodes); + if (!a) + CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType); + for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr) + if (itr->GetUint64() == h) { + DuplicateItems(static_cast(itr - a->Begin()), a->Size()); + RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString()); + } + a->PushBack(h, GetStateAllocator()); + } + } + + // Remove the last token of document pointer + while (!documentStack_.Empty() && *documentStack_.template Pop(1) != '/') + ; + + return true; + } + + void AppendToken(const Ch* str, SizeType len) { + documentStack_.template Reserve(1 + len * 2); // worst case all characters are escaped as two characters + *documentStack_.template PushUnsafe() = '/'; + for (SizeType i = 0; i < len; i++) { + if (str[i] == '~') { + *documentStack_.template PushUnsafe() = '~'; + *documentStack_.template PushUnsafe() = '0'; + } + else if (str[i] == '/') { + *documentStack_.template PushUnsafe() = '~'; + *documentStack_.template PushUnsafe() = '1'; + } + else + *documentStack_.template PushUnsafe() = str[i]; + } + } + + RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push()) Context(*this, *this, &schema); } + + RAPIDJSON_FORCEINLINE void PopSchema() { + Context* c = schemaStack_.template Pop(1); + if (HashCodeArray* a = static_cast(c->arrayElementHashCodes)) { + a->~HashCodeArray(); + StateAllocator::Free(a); + } + c->~Context(); + } + + void AddErrorLocation(ValueType& result, bool parent) { + GenericStringBuffer sb; + PointerType instancePointer = GetInvalidDocumentPointer(); + ((parent && instancePointer.GetTokenCount() > 0) + ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1) + : instancePointer).StringifyUriFragment(sb); + ValueType instanceRef(sb.GetString(), static_cast(sb.GetSize() / sizeof(Ch)), + GetStateAllocator()); + result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator()); + sb.Clear(); + memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()), + CurrentSchema().GetURI().GetString(), + CurrentSchema().GetURI().GetStringLength() * sizeof(Ch)); + GetInvalidSchemaPointer().StringifyUriFragment(sb); + ValueType schemaRef(sb.GetString(), static_cast(sb.GetSize() / sizeof(Ch)), + GetStateAllocator()); + result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator()); + } + + void AddError(ValueType& keyword, ValueType& error) { + typename ValueType::MemberIterator member = error_.FindMember(keyword); + if (member == error_.MemberEnd()) + error_.AddMember(keyword, error, GetStateAllocator()); + else { + if (member->value.IsObject()) { + ValueType errors(kArrayType); + errors.PushBack(member->value, GetStateAllocator()); + member->value = errors; + } + member->value.PushBack(error, GetStateAllocator()); + } + } + + void AddCurrentError(const typename SchemaType::ValueType& keyword, bool parent = false) { + AddErrorLocation(currentError_, parent); + AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_); + } + + void MergeError(ValueType& other) { + for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) { + AddError(it->name, it->value); + } + } + + void AddNumberError(const typename SchemaType::ValueType& keyword, ValueType& actual, const SValue& expected, + const typename SchemaType::ValueType& (*exclusive)() = 0) { + currentError_.SetObject(); + currentError_.AddMember(GetActualString(), actual, GetStateAllocator()); + currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator()); + if (exclusive) + currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator()); + AddCurrentError(keyword); + } + + void AddErrorArray(const typename SchemaType::ValueType& keyword, + ISchemaValidator** subvalidators, SizeType count) { + ValueType errors(kArrayType); + for (SizeType i = 0; i < count; ++i) + errors.PushBack(static_cast(subvalidators[i])->GetError(), GetStateAllocator()); + currentError_.SetObject(); + currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator()); + AddCurrentError(keyword); + } + + const SchemaType& CurrentSchema() const { return *schemaStack_.template Top()->schema; } + Context& CurrentContext() { return *schemaStack_.template Top(); } + const Context& CurrentContext() const { return *schemaStack_.template Top(); } + + static const size_t kDefaultSchemaStackCapacity = 1024; + static const size_t kDefaultDocumentStackCapacity = 256; + const SchemaDocumentType* schemaDocument_; + const SchemaType& root_; + StateAllocator* stateAllocator_; + StateAllocator* ownStateAllocator_; + internal::Stack schemaStack_; //!< stack to store the current path of schema (BaseSchemaType *) + internal::Stack documentStack_; //!< stack to store the current path of validating document (Ch) + OutputHandler* outputHandler_; + ValueType error_; + ValueType currentError_; + ValueType missingDependents_; + bool valid_; +#if RAPIDJSON_SCHEMA_VERBOSE + unsigned depth_; +#endif +}; + +typedef GenericSchemaValidator SchemaValidator; + +/////////////////////////////////////////////////////////////////////////////// +// SchemaValidatingReader + +//! A helper class for parsing with validation. +/*! + This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate(). + + \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept. + \tparam SourceEncoding Encoding of the input stream. + \tparam SchemaDocumentType Type of schema document. + \tparam StackAllocator Allocator type for stack. +*/ +template < + unsigned parseFlags, + typename InputStream, + typename SourceEncoding, + typename SchemaDocumentType = SchemaDocument, + typename StackAllocator = CrtAllocator> +class SchemaValidatingReader { +public: + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename InputStream::Ch Ch; + typedef GenericValue ValueType; + + //! Constructor + /*! + \param is Input stream. + \param sd Schema document. + */ + SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {} + + template + bool operator()(Handler& handler) { + GenericReader reader; + GenericSchemaValidator validator(sd_, handler); + parseResult_ = reader.template Parse(is_, validator); + + isValid_ = validator.IsValid(); + if (isValid_) { + invalidSchemaPointer_ = PointerType(); + invalidSchemaKeyword_ = 0; + invalidDocumentPointer_ = PointerType(); + error_.SetObject(); + } + else { + invalidSchemaPointer_ = validator.GetInvalidSchemaPointer(); + invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword(); + invalidDocumentPointer_ = validator.GetInvalidDocumentPointer(); + error_.CopyFrom(validator.GetError(), allocator_); + } + + return parseResult_; + } + + const ParseResult& GetParseResult() const { return parseResult_; } + bool IsValid() const { return isValid_; } + const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; } + const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; } + const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; } + const ValueType& GetError() const { return error_; } + +private: + InputStream& is_; + const SchemaDocumentType& sd_; + + ParseResult parseResult_; + PointerType invalidSchemaPointer_; + const Ch* invalidSchemaKeyword_; + PointerType invalidDocumentPointer_; + StackAllocator allocator_; + ValueType error_; + bool isValid_; +}; + +RAPIDJSON_NAMESPACE_END +RAPIDJSON_DIAG_POP + +#endif // RAPIDJSON_SCHEMA_H_ diff --git a/SourceCode/dep_inc/rapidjson/stream.h b/SourceCode/dep_inc/rapidjson/stream.h new file mode 100644 index 0000000..7f2643e --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/stream.h @@ -0,0 +1,223 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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. + +#include "rapidjson.h" + +#ifndef RAPIDJSON_STREAM_H_ +#define RAPIDJSON_STREAM_H_ + +#include "encodings.h" + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Stream + +/*! \class rapidjson::Stream + \brief Concept for reading and writing characters. + + For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd(). + + For write-only stream, only need to implement Put() and Flush(). + +\code +concept Stream { + typename Ch; //!< Character type of the stream. + + //! Read the current character from stream without moving the read cursor. + Ch Peek() const; + + //! Read the current character from stream and moving the read cursor to next character. + Ch Take(); + + //! Get the current read cursor. + //! \return Number of characters read from start. + size_t Tell(); + + //! Begin writing operation at the current read pointer. + //! \return The begin writer pointer. + Ch* PutBegin(); + + //! Write a character. + void Put(Ch c); + + //! Flush the buffer. + void Flush(); + + //! End the writing operation. + //! \param begin The begin write pointer returned by PutBegin(). + //! \return Number of characters written. + size_t PutEnd(Ch* begin); +} +\endcode +*/ + +//! Provides additional information for stream. +/*! + By using traits pattern, this type provides a default configuration for stream. + For custom stream, this type can be specialized for other configuration. + See TEST(Reader, CustomStringStream) in readertest.cpp for example. +*/ +template +struct StreamTraits { + //! Whether to make local copy of stream for optimization during parsing. + /*! + By default, for safety, streams do not use local copy optimization. + Stream that can be copied fast should specialize this, like StreamTraits. + */ + enum { copyOptimization = 0 }; +}; + +//! Reserve n characters for writing to a stream. +template +inline void PutReserve(Stream& stream, size_t count) { + (void)stream; + (void)count; +} + +//! Write character to a stream, presuming buffer is reserved. +template +inline void PutUnsafe(Stream& stream, typename Stream::Ch c) { + stream.Put(c); +} + +//! Put N copies of a character to a stream. +template +inline void PutN(Stream& stream, Ch c, size_t n) { + PutReserve(stream, n); + for (size_t i = 0; i < n; i++) + PutUnsafe(stream, c); +} + +/////////////////////////////////////////////////////////////////////////////// +// GenericStreamWrapper + +//! A Stream Wrapper +/*! \tThis string stream is a wrapper for any stream by just forwarding any + \treceived message to the origin stream. + \note implements Stream concept +*/ + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4702) // unreachable code +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +template > +class GenericStreamWrapper { +public: + typedef typename Encoding::Ch Ch; + GenericStreamWrapper(InputStream& is): is_(is) {} + + Ch Peek() const { return is_.Peek(); } + Ch Take() { return is_.Take(); } + size_t Tell() { return is_.Tell(); } + Ch* PutBegin() { return is_.PutBegin(); } + void Put(Ch ch) { is_.Put(ch); } + void Flush() { is_.Flush(); } + size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); } + + // wrapper for MemoryStream + const Ch* Peek4() const { return is_.Peek4(); } + + // wrapper for AutoUTFInputStream + UTFType GetType() const { return is_.GetType(); } + bool HasBOM() const { return is_.HasBOM(); } + +protected: + InputStream& is_; +}; + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_POP +#endif + +/////////////////////////////////////////////////////////////////////////////// +// StringStream + +//! Read-only string stream. +/*! \note implements Stream concept +*/ +template +struct GenericStringStream { + typedef typename Encoding::Ch Ch; + + GenericStringStream(const Ch *src) : src_(src), head_(src) {} + + Ch Peek() const { return *src_; } + Ch Take() { return *src_++; } + size_t Tell() const { return static_cast(src_ - head_); } + + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + const Ch* src_; //!< Current read position. + const Ch* head_; //!< Original head of the string. +}; + +template +struct StreamTraits > { + enum { copyOptimization = 1 }; +}; + +//! String stream with UTF8 encoding. +typedef GenericStringStream > StringStream; + +/////////////////////////////////////////////////////////////////////////////// +// InsituStringStream + +//! A read-write string stream. +/*! This string stream is particularly designed for in-situ parsing. + \note implements Stream concept +*/ +template +struct GenericInsituStringStream { + typedef typename Encoding::Ch Ch; + + GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {} + + // Read + Ch Peek() { return *src_; } + Ch Take() { return *src_++; } + size_t Tell() { return static_cast(src_ - head_); } + + // Write + void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; } + + Ch* PutBegin() { return dst_ = src_; } + size_t PutEnd(Ch* begin) { return static_cast(dst_ - begin); } + void Flush() {} + + Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; } + void Pop(size_t count) { dst_ -= count; } + + Ch* src_; + Ch* dst_; + Ch* head_; +}; + +template +struct StreamTraits > { + enum { copyOptimization = 1 }; +}; + +//! Insitu string stream with UTF8 encoding. +typedef GenericInsituStringStream > InsituStringStream; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_STREAM_H_ diff --git a/SourceCode/dep_inc/rapidjson/stringbuffer.h b/SourceCode/dep_inc/rapidjson/stringbuffer.h new file mode 100644 index 0000000..4e38b82 --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/stringbuffer.h @@ -0,0 +1,121 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_STRINGBUFFER_H_ +#define RAPIDJSON_STRINGBUFFER_H_ + +#include "stream.h" +#include "internal/stack.h" + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS +#include // std::move +#endif + +#include "internal/stack.h" + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory output stream. +/*! + \tparam Encoding Encoding of the stream. + \tparam Allocator type for allocating memory buffer. + \note implements Stream concept +*/ +template +class GenericStringBuffer { +public: + typedef typename Encoding::Ch Ch; + + GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {} + GenericStringBuffer& operator=(GenericStringBuffer&& rhs) { + if (&rhs != this) + stack_ = std::move(rhs.stack_); + return *this; + } +#endif + + void Put(Ch c) { *stack_.template Push() = c; } + void PutUnsafe(Ch c) { *stack_.template PushUnsafe() = c; } + void Flush() {} + + void Clear() { stack_.Clear(); } + void ShrinkToFit() { + // Push and pop a null terminator. This is safe. + *stack_.template Push() = '\0'; + stack_.ShrinkToFit(); + stack_.template Pop(1); + } + + void Reserve(size_t count) { stack_.template Reserve(count); } + Ch* Push(size_t count) { return stack_.template Push(count); } + Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe(count); } + void Pop(size_t count) { stack_.template Pop(count); } + + const Ch* GetString() const { + // Push and pop a null terminator. This is safe. + *stack_.template Push() = '\0'; + stack_.template Pop(1); + + return stack_.template Bottom(); + } + + //! Get the size of string in bytes in the string buffer. + size_t GetSize() const { return stack_.GetSize(); } + + //! Get the length of string in Ch in the string buffer. + size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); } + + static const size_t kDefaultCapacity = 256; + mutable internal::Stack stack_; + +private: + // Prohibit copy constructor & assignment operator. + GenericStringBuffer(const GenericStringBuffer&); + GenericStringBuffer& operator=(const GenericStringBuffer&); +}; + +//! String buffer with UTF8 encoding +typedef GenericStringBuffer > StringBuffer; + +template +inline void PutReserve(GenericStringBuffer& stream, size_t count) { + stream.Reserve(count); +} + +template +inline void PutUnsafe(GenericStringBuffer& stream, typename Encoding::Ch c) { + stream.PutUnsafe(c); +} + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(GenericStringBuffer >& stream, char c, size_t n) { + std::memset(stream.stack_.Push(n), c, n * sizeof(c)); +} + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_STRINGBUFFER_H_ diff --git a/SourceCode/dep_inc/rapidjson/writer.h b/SourceCode/dep_inc/rapidjson/writer.h new file mode 100644 index 0000000..49cc0fb --- /dev/null +++ b/SourceCode/dep_inc/rapidjson/writer.h @@ -0,0 +1,710 @@ +// 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. +// +// 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 +// +// http://opensource.org/licenses/MIT +// +// 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_WRITER_H_ +#define RAPIDJSON_WRITER_H_ + +#include "stream.h" +#include "internal/meta.h" +#include "internal/stack.h" +#include "internal/strfunc.h" +#include "internal/dtoa.h" +#include "internal/itoa.h" +#include "stringbuffer.h" +#include // placement new + +#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER) +#include +#pragma intrinsic(_BitScanForward) +#endif +#ifdef RAPIDJSON_SSE42 +#include +#elif defined(RAPIDJSON_SSE2) +#include +#elif defined(RAPIDJSON_NEON) +#include +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(c++98-compat) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// WriteFlag + +/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS + \ingroup RAPIDJSON_CONFIG + \brief User-defined kWriteDefaultFlags definition. + + User can define this as any \c WriteFlag combinations. +*/ +#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS +#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags +#endif + +//! Combination of writeFlags +enum WriteFlag { + kWriteNoFlags = 0, //!< No flags are set. + kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings. + kWriteNanAndInfFlag = 2, //!< Allow writing of Infinity, -Infinity and NaN. + kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS +}; + +//! JSON writer +/*! Writer implements the concept Handler. + It generates JSON text by events to an output os. + + User may programmatically calls the functions of a writer to generate JSON text. + + On the other side, a writer can also be passed to objects that generates events, + + for example Reader::Parse() and Document::Accept(). + + \tparam OutputStream Type of output stream. + \tparam SourceEncoding Encoding of source string. + \tparam TargetEncoding Encoding of output stream. + \tparam StackAllocator Type of allocator for allocating memory of stack. + \note implements Handler concept +*/ +template, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags> +class Writer { +public: + typedef typename SourceEncoding::Ch Ch; + + static const int kDefaultMaxDecimalPlaces = 324; + + //! Constructor + /*! \param os Output stream. + \param stackAllocator User supplied allocator. If it is null, it will create a private one. + \param levelDepth Initial capacity of stack. + */ + explicit + Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : + os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {} + + explicit + Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) : + os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Writer(Writer&& rhs) : + os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) { + rhs.os_ = 0; + } +#endif + + //! Reset the writer with a new stream. + /*! + This function reset the writer with a new stream and default settings, + in order to make a Writer object reusable for output multiple JSONs. + + \param os New output stream. + \code + Writer writer(os1); + writer.StartObject(); + // ... + writer.EndObject(); + + writer.Reset(os2); + writer.StartObject(); + // ... + writer.EndObject(); + \endcode + */ + void Reset(OutputStream& os) { + os_ = &os; + hasRoot_ = false; + level_stack_.Clear(); + } + + //! Checks whether the output is a complete JSON. + /*! + A complete JSON has a complete root object or array. + */ + bool IsComplete() const { + return hasRoot_ && level_stack_.Empty(); + } + + int GetMaxDecimalPlaces() const { + return maxDecimalPlaces_; + } + + //! Sets the maximum number of decimal places for double output. + /*! + This setting truncates the output with specified number of decimal places. + + For example, + + \code + writer.SetMaxDecimalPlaces(3); + writer.StartArray(); + writer.Double(0.12345); // "0.123" + writer.Double(0.0001); // "0.0" + writer.Double(1.234567890123456e30); // "1.234567890123456e30" (do not truncate significand for positive exponent) + writer.Double(1.23e-4); // "0.0" (do truncate significand for negative exponent) + writer.EndArray(); + \endcode + + The default setting does not truncate any decimal places. You can restore to this setting by calling + \code + writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces); + \endcode + */ + void SetMaxDecimalPlaces(int maxDecimalPlaces) { + maxDecimalPlaces_ = maxDecimalPlaces; + } + + /*!@name Implementation of Handler + \see Handler + */ + //@{ + + bool Null() { Prefix(kNullType); return EndValue(WriteNull()); } + bool Bool(bool b) { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); } + bool Int(int i) { Prefix(kNumberType); return EndValue(WriteInt(i)); } + bool Uint(unsigned u) { Prefix(kNumberType); return EndValue(WriteUint(u)); } + bool Int64(int64_t i64) { Prefix(kNumberType); return EndValue(WriteInt64(i64)); } + bool Uint64(uint64_t u64) { Prefix(kNumberType); return EndValue(WriteUint64(u64)); } + + //! Writes the given \c double value to the stream + /*! + \param d The value to be written. + \return Whether it is succeed. + */ + bool Double(double d) { Prefix(kNumberType); return EndValue(WriteDouble(d)); } + + bool RawNumber(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + Prefix(kNumberType); + return EndValue(WriteString(str, length)); + } + + bool String(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + Prefix(kStringType); + return EndValue(WriteString(str, length)); + } + +#if RAPIDJSON_HAS_STDSTRING + bool String(const std::basic_string& str) { + return String(str.data(), SizeType(str.size())); + } +#endif + + bool StartObject() { + Prefix(kObjectType); + new (level_stack_.template Push()) Level(false); + return WriteStartObject(); + } + + bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); } + +#if RAPIDJSON_HAS_STDSTRING + bool Key(const std::basic_string& str) + { + return Key(str.data(), SizeType(str.size())); + } +#endif + + bool EndObject(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object + RAPIDJSON_ASSERT(!level_stack_.template Top()->inArray); // currently inside an Array, not Object + RAPIDJSON_ASSERT(0 == level_stack_.template Top()->valueCount % 2); // Object has a Key without a Value + level_stack_.template Pop(1); + return EndValue(WriteEndObject()); + } + + bool StartArray() { + Prefix(kArrayType); + new (level_stack_.template Push()) Level(true); + return WriteStartArray(); + } + + bool EndArray(SizeType elementCount = 0) { + (void)elementCount; + RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); + RAPIDJSON_ASSERT(level_stack_.template Top()->inArray); + level_stack_.template Pop(1); + return EndValue(WriteEndArray()); + } + //@} + + /*! @name Convenience extensions */ + //@{ + + //! Simpler but slower overload. + bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); } + bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); } + + //@} + + //! Write a raw JSON value. + /*! + For user to write a stringified JSON as a value. + + \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range. + \param length Length of the json. + \param type Type of the root of json. + */ + bool RawValue(const Ch* json, size_t length, Type type) { + RAPIDJSON_ASSERT(json != 0); + Prefix(type); + return EndValue(WriteRawValue(json, length)); + } + + //! Flush the output stream. + /*! + Allows the user to flush the output stream immediately. + */ + void Flush() { + os_->Flush(); + } + +protected: + //! Information for each nested level + struct Level { + Level(bool inArray_) : valueCount(0), inArray(inArray_) {} + size_t valueCount; //!< number of values in this level + bool inArray; //!< true if in array, otherwise in object + }; + + static const size_t kDefaultLevelDepth = 32; + + bool WriteNull() { + PutReserve(*os_, 4); + PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true; + } + + bool WriteBool(bool b) { + if (b) { + PutReserve(*os_, 4); + PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e'); + } + else { + PutReserve(*os_, 5); + PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e'); + } + return true; + } + + bool WriteInt(int i) { + char buffer[11]; + const char* end = internal::i32toa(i, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteUint(unsigned u) { + char buffer[10]; + const char* end = internal::u32toa(u, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteInt64(int64_t i64) { + char buffer[21]; + const char* end = internal::i64toa(i64, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteUint64(uint64_t u64) { + char buffer[20]; + char* end = internal::u64toa(u64, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteDouble(double d) { + if (internal::Double(d).IsNanOrInf()) { + if (!(writeFlags & kWriteNanAndInfFlag)) + return false; + if (internal::Double(d).IsNan()) { + PutReserve(*os_, 3); + PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N'); + return true; + } + if (internal::Double(d).Sign()) { + PutReserve(*os_, 9); + PutUnsafe(*os_, '-'); + } + else + PutReserve(*os_, 8); + PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f'); + PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y'); + return true; + } + + char buffer[25]; + char* end = internal::dtoa(d, buffer, maxDecimalPlaces_); + PutReserve(*os_, static_cast(end - buffer)); + for (char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteString(const Ch* str, SizeType length) { + static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + static const char escape[256] = { +#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + //0 1 2 3 4 5 6 7 8 9 A B C D E F + 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00 + 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10 + 0, 0, '"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20 + Z16, Z16, // 30~4F + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, // 50 + Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 // 60~FF +#undef Z16 + }; + + if (TargetEncoding::supportUnicode) + PutReserve(*os_, 2 + length * 6); // "\uxxxx..." + else + PutReserve(*os_, 2 + length * 12); // "\uxxxx\uyyyy..." + + PutUnsafe(*os_, '\"'); + GenericStringStream is(str); + while (ScanWriteUnescapedString(is, length)) { + const Ch c = is.Peek(); + if (!TargetEncoding::supportUnicode && static_cast(c) >= 0x80) { + // Unicode escaping + unsigned codepoint; + if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint))) + return false; + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, 'u'); + if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) { + PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint ) & 15]); + } + else { + RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF); + // Surrogate pair + unsigned s = codepoint - 0x010000; + unsigned lead = (s >> 10) + 0xD800; + unsigned trail = (s & 0x3FF) + 0xDC00; + PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(lead >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(lead >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(lead ) & 15]); + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, 'u'); + PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(trail >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(trail >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(trail ) & 15]); + } + } + else if ((sizeof(Ch) == 1 || static_cast(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast(c)])) { + is.Take(); + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, static_cast(escape[static_cast(c)])); + if (escape[static_cast(c)] == 'u') { + PutUnsafe(*os_, '0'); + PutUnsafe(*os_, '0'); + PutUnsafe(*os_, hexDigits[static_cast(c) >> 4]); + PutUnsafe(*os_, hexDigits[static_cast(c) & 0xF]); + } + } + else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? + Transcoder::Validate(is, *os_) : + Transcoder::TranscodeUnsafe(is, *os_)))) + return false; + } + PutUnsafe(*os_, '\"'); + return true; + } + + bool ScanWriteUnescapedString(GenericStringStream& is, size_t length) { + return RAPIDJSON_LIKELY(is.Tell() < length); + } + + bool WriteStartObject() { os_->Put('{'); return true; } + bool WriteEndObject() { os_->Put('}'); return true; } + bool WriteStartArray() { os_->Put('['); return true; } + bool WriteEndArray() { os_->Put(']'); return true; } + + bool WriteRawValue(const Ch* json, size_t length) { + PutReserve(*os_, length); + GenericStringStream is(json); + while (RAPIDJSON_LIKELY(is.Tell() < length)) { + const Ch c = is.Peek(); + RAPIDJSON_ASSERT(c != '\0'); + if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? + Transcoder::Validate(is, *os_) : + Transcoder::TranscodeUnsafe(is, *os_)))) + return false; + } + return true; + } + + void Prefix(Type type) { + (void)type; + if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root + Level* level = level_stack_.template Top(); + if (level->valueCount > 0) { + if (level->inArray) + os_->Put(','); // add comma if it is not the first element in array + else // in object + os_->Put((level->valueCount % 2 == 0) ? ',' : ':'); + } + if (!level->inArray && level->valueCount % 2 == 0) + RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name + level->valueCount++; + } + else { + RAPIDJSON_ASSERT(!hasRoot_); // Should only has one and only one root. + hasRoot_ = true; + } + } + + // Flush the value if it is the top level one. + bool EndValue(bool ret) { + if (RAPIDJSON_UNLIKELY(level_stack_.Empty())) // end of json text + Flush(); + return ret; + } + + OutputStream* os_; + internal::Stack level_stack_; + int maxDecimalPlaces_; + bool hasRoot_; + +private: + // Prohibit copy constructor & assignment operator. + Writer(const Writer&); + Writer& operator=(const Writer&); +}; + +// Full specialization for StringStream to prevent memory copying + +template<> +inline bool Writer::WriteInt(int i) { + char *buffer = os_->Push(11); + const char* end = internal::i32toa(i, buffer); + os_->Pop(static_cast(11 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteUint(unsigned u) { + char *buffer = os_->Push(10); + const char* end = internal::u32toa(u, buffer); + os_->Pop(static_cast(10 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteInt64(int64_t i64) { + char *buffer = os_->Push(21); + const char* end = internal::i64toa(i64, buffer); + os_->Pop(static_cast(21 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteUint64(uint64_t u) { + char *buffer = os_->Push(20); + const char* end = internal::u64toa(u, buffer); + os_->Pop(static_cast(20 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteDouble(double d) { + if (internal::Double(d).IsNanOrInf()) { + // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag). + if (!(kWriteDefaultFlags & kWriteNanAndInfFlag)) + return false; + if (internal::Double(d).IsNan()) { + PutReserve(*os_, 3); + PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N'); + return true; + } + if (internal::Double(d).Sign()) { + PutReserve(*os_, 9); + PutUnsafe(*os_, '-'); + } + else + PutReserve(*os_, 8); + PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f'); + PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y'); + return true; + } + + char *buffer = os_->Push(25); + char* end = internal::dtoa(d, buffer, maxDecimalPlaces_); + os_->Pop(static_cast(25 - (end - buffer))); + return true; +} + +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) +template<> +inline bool Writer::ScanWriteUnescapedString(StringStream& is, size_t length) { + if (length < 16) + return RAPIDJSON_LIKELY(is.Tell() < length); + + if (!RAPIDJSON_LIKELY(is.Tell() < length)) + return false; + + const char* p = is.src_; + const char* end = is.head_ + length; + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + const char* endAligned = reinterpret_cast(reinterpret_cast(end) & static_cast(~15)); + if (nextAligned > end) + return true; + + while (p != nextAligned) + if (*p < 0x20 || *p == '\"' || *p == '\\') { + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); + } + else + os_->PutUnsafe(*p++); + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (; p != endAligned; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + SizeType len; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + len = offset; +#else + len = static_cast(__builtin_ffs(r) - 1); +#endif + char* q = reinterpret_cast(os_->PushUnsafe(len)); + for (size_t i = 0; i < len; i++) + q[i] = p[i]; + + p += len; + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s); + } + + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); +} +#elif defined(RAPIDJSON_NEON) +template<> +inline bool Writer::ScanWriteUnescapedString(StringStream& is, size_t length) { + if (length < 16) + return RAPIDJSON_LIKELY(is.Tell() < length); + + if (!RAPIDJSON_LIKELY(is.Tell() < length)) + return false; + + const char* p = is.src_; + const char* end = is.head_ + length; + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + const char* endAligned = reinterpret_cast(reinterpret_cast(end) & static_cast(~15)); + if (nextAligned > end) + return true; + + while (p != nextAligned) + if (*p < 0x20 || *p == '\"' || *p == '\\') { + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); + } + else + os_->PutUnsafe(*p++); + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (; p != endAligned; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(reinterpret_cast(x), 0); // extract + uint64_t high = vgetq_lane_u64(reinterpret_cast(x), 1); // extract + + SizeType len = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + unsigned lz = (unsigned)__builtin_clzll(high); + len = 8 + (lz >> 3); + escaped = true; + } + } else { + unsigned lz = (unsigned)__builtin_clzll(low); + len = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + char* q = reinterpret_cast(os_->PushUnsafe(len)); + for (size_t i = 0; i < len; i++) + q[i] = p[i]; + + p += len; + break; + } + vst1q_u8(reinterpret_cast(os_->PushUnsafe(16)), s); + } + + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); +} +#endif // RAPIDJSON_NEON + +RAPIDJSON_NAMESPACE_END + +#if defined(_MSC_VER) || defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/SourceCode/dep_lib/modernGlue/debug/ModernGlue.lib b/SourceCode/dep_lib/modernGlue/debug/ModernGlue.lib new file mode 100644 index 0000000000000000000000000000000000000000..6f4a41efa66be90ef42f02630b08efce13d96b37 GIT binary patch literal 9818 zcmcIqU2GIp6h8f-XaxjHOI!N0{o}_UEZgo@1Wb`CG}7AO5`8hlvNLp7raR5<7HDIH zsA)7nOn5Lp7=;&u#s{BjG-|5RhpMT@_#XuxFho)kQjOxQCu}OkCsLryqJ}ewi`0~{sAdk^M`}51QS&6?Bek?! zRDA^PKx#vMLanDPYI_FDNUhipLTxx6Z8M6}+c)sozKGKE@Z-Do^$tWH+o$vys+LOb z)<-l@l>YsD_j+aExGQ9dME30Oe^lw&8QFuE3zfOl-2ig8QL3M8;o$Vb9Em1$RT;KiN;!&Ss>BUl zbM&)_WN*v21!1KiKnzXKXsMWP#10=#q&2x2S)@Fch_b9Po;r_qf>@K*V(wmmM!HNv z-Ye{Ic*&=YMA9+DEb#Se;?N;2r6ptT=rb%{Ha$8tq-9cxn8JwA-B?;F=o_gF>+NZ~ zERh;L<``{CVVReTxgNy$4$E}qM^d^H&t!&o>&C&T-kVHVV=Q6&>FmlBI|%)Go`#Enqa#V(X;`;#43Q93V`*M03YL7 z-dPWDp%!3z9Y6%B2YGKJudV?gj{Hka00YecSE~W^8h{&B0Ap(bt|N`(`)mNqNGBQr zN|DO&{S4}6P;U<9&$a+eqJBF*k6;^RXvC>jfM@VohtC;&VweR*Pz-Be6|9B|2*91N z66#6}tc4n=f=XBi%V7mHKqJ&cD>OqBv_RW}v{8cdaBH!R zGk<3Ml65=u?6cN!z_;KL%40(pT9Ug63A20;J$E^p-SL(4JMoy^f;Ywt?0iB4E9jd? z)a4(F3|QKpQ;TgnOQ7TgoD!o4GTB1N-0>9Or0+KGJ*I@Y$bOIsC|S-E;Y{|T_#N3i zgyew95z_Jc*-r#PR(2Y>B6Qa!+pC0Y9tHlJH*-{YmHCaF*_7#7C^$T2d%QSDajt2(EvuY~K&PGjCsfp=gk$odx(+45}3wZd^%Swqsxj^m=dhU1((+vn!P zS>n1P)s?uIGkTIbc^oNimh&mLO|C-HAQ#k82cz~nmm|ucPQ{hk088dbM3{9UuFN@) zx5g7;(NKtSm29_vH!-kT)%E)Vxw18(_OP9|IZ&>Sm%#hY%coWs0mcm0XS1pu92snV z+%7^7zF0^8E1(0;onGCSh^36QaVQhmxNlQnZ*TvjRyF^<42#4T zLKtnCZ^VWr<{J-$mc)#qVKn*N>7t^WH(4zd2V!F}(4Kc=kVZIh$}#(BVc9aBL?4#5m(NynB4vr+!|y?t^~$YA52|B1Z%eCBbUYB zLiQk;{z@H!^17j$`dcUE5x@S47VIaHTZ|E&&*%owhJ{?2A^WBl2$1YE@mX~|^4_*j z)|-7TbxsN)%;2XH_+su^4bx4OLH)eD?D}RzEy7)f9v?nY3=g*;=>PtAZH}N9XG6Dw zq(wmAaCXN{f?kpX9b>Qp(L<7vfAy)^i>-)W%A&I&UV)h5t+op@vwiIH_kV0b%q0w_ zZ+s|rI`3ViOR~z}Ejl^#09sHs9}CfjH=`v>SxejixKP9{FXFa$ zCTB4Tg1eyWYkYhyfaX2ovVG-^ivF+2zCv;<)Wi8eU7Tp%ih1lS^sr!7+KCrNC+|Yk za$i(4DCeOBLvka_`ulp*#0=^09X`l~dvjRQ-+P|_^)u4nWxlA3)!)O~#aYtdGH5AvfdGjk2QLqCe^GF;Xii0d%iEVilCxlT!)r4E#H;b*jR_qRin(V~*1ycT>d#64Y8gD55-PZV zlJR`*+3_C<-Z~KvQ%;5Ag(bWG^o6gd??Jpe7EhMa62ST5t&QzRQ(b?PzSi5=Y{ral zAM##1VaeFeezaq56XG?9cw9!VP-I!$^wN#K@5o8lC`C3iegZ6CoX7Y|eC5lD$hQGR k4G5@aLXig$)>dx3PRR}Ezs6sFAi0tz3y;ZH3Si~`10RhYS^xk5 literal 0 HcmV?d00001 diff --git a/SourceCode/dep_lib/modernGlue/release/ModernGlue.lib b/SourceCode/dep_lib/modernGlue/release/ModernGlue.lib new file mode 100644 index 0000000000000000000000000000000000000000..6f4a41efa66be90ef42f02630b08efce13d96b37 GIT binary patch literal 9818 zcmcIqU2GIp6h8f-XaxjHOI!N0{o}_UEZgo@1Wb`CG}7AO5`8hlvNLp7raR5<7HDIH zsA)7nOn5Lp7=;&u#s{BjG-|5RhpMT@_#XuxFho)kQjOxQCu}OkCsLryqJ}ewi`0~{sAdk^M`}51QS&6?Bek?! zRDA^PKx#vMLanDPYI_FDNUhipLTxx6Z8M6}+c)sozKGKE@Z-Do^$tWH+o$vys+LOb z)<-l@l>YsD_j+aExGQ9dME30Oe^lw&8QFuE3zfOl-2ig8QL3M8;o$Vb9Em1$RT;KiN;!&Ss>BUl zbM&)_WN*v21!1KiKnzXKXsMWP#10=#q&2x2S)@Fch_b9Po;r_qf>@K*V(wmmM!HNv z-Ye{Ic*&=YMA9+DEb#Se;?N;2r6ptT=rb%{Ha$8tq-9cxn8JwA-B?;F=o_gF>+NZ~ zERh;L<``{CVVReTxgNy$4$E}qM^d^H&t!&o>&C&T-kVHVV=Q6&>FmlBI|%)Go`#Enqa#V(X;`;#43Q93V`*M03YL7 z-dPWDp%!3z9Y6%B2YGKJudV?gj{Hka00YecSE~W^8h{&B0Ap(bt|N`(`)mNqNGBQr zN|DO&{S4}6P;U<9&$a+eqJBF*k6;^RXvC>jfM@VohtC;&VweR*Pz-Be6|9B|2*91N z66#6}tc4n=f=XBi%V7mHKqJ&cD>OqBv_RW}v{8cdaBH!R zGk<3Ml65=u?6cN!z_;KL%40(pT9Ug63A20;J$E^p-SL(4JMoy^f;Ywt?0iB4E9jd? z)a4(F3|QKpQ;TgnOQ7TgoD!o4GTB1N-0>9Or0+KGJ*I@Y$bOIsC|S-E;Y{|T_#N3i zgyew95z_Jc*-r#PR(2Y>B6Qa!+pC0Y9tHlJH*-{YmHCaF*_7#7C^$T2d%QSDajt2(EvuY~K&PGjCsfp=gk$odx(+45}3wZd^%Swqsxj^m=dhU1((+vn!P zS>n1P)s?uIGkTIbc^oNimh&mLO|C-HAQ#k82cz~nmm|ucPQ{hk088dbM3{9UuFN@) zx5g7;(NKtSm29_vH!-kT)%E)Vxw18(_OP9|IZ&>Sm%#hY%coWs0mcm0XS1pu92snV z+%7^7zF0^8E1(0;onGCSh^36QaVQhmxNlQnZ*TvjRyF^<42#4T zLKtnCZ^VWr<{J-$mc)#qVKn*N>7t^WH(4zd2V!F}(4Kc=kVZIh$}#(BVc9aBL?4#5m(NynB4vr+!|y?t^~$YA52|B1Z%eCBbUYB zLiQk;{z@H!^17j$`dcUE5x@S47VIaHTZ|E&&*%owhJ{?2A^WBl2$1YE@mX~|^4_*j z)|-7TbxsN)%;2XH_+su^4bx4OLH)eD?D}RzEy7)f9v?nY3=g*;=>PtAZH}N9XG6Dw zq(wmAaCXN{f?kpX9b>Qp(L<7vfAy)^i>-)W%A&I&UV)h5t+op@vwiIH_kV0b%q0w_ zZ+s|rI`3ViOR~z}Ejl^#09sHs9}CfjH=`v>SxejixKP9{FXFa$ zCTB4Tg1eyWYkYhyfaX2ovVG-^ivF+2zCv;<)Wi8eU7Tp%ih1lS^sr!7+KCrNC+|Yk za$i(4DCeOBLvka_`ulp*#0=^09X`l~dvjRQ-+P|_^)u4nWxlA3)!)O~#aYtdGH5AvfdGjk2QLqCe^GF;Xii0d%iEVilCxlT!)r4E#H;b*jR_qRin(V~*1ycT>d#64Y8gD55-PZV zlJR`*+3_C<-Z~KvQ%;5Ag(bWG^o6gd??Jpe7EhMa62ST5t&QzRQ(b?PzSi5=Y{ral zAM##1VaeFeezaq56XG?9cw9!VP-I!$^wN#K@5o8lC`C3iegZ6CoX7Y|eC5lD$hQGR k4G5@aLXig$)>dx3PRR}Ezs6sFAi0tz3y;ZH3Si~`10RhYS^xk5 literal 0 HcmV?d00001 diff --git a/SourceCode/dep_lib/pub/00003564_000029CA_md.lib b/SourceCode/dep_lib/pub/00003564_000029CA_md.lib new file mode 100644 index 0000000000000000000000000000000000000000..9b77f5d2a50d00190e4f141e719b3eb6be1b8d97 GIT binary patch literal 898790 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

w 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 QCH5tII2t4ALGZ8t1A-suwEzGB literal 0 HcmV?d00001 diff --git a/SourceCode/dep_lib/pub/00003564_000029CA_md_x64.lib b/SourceCode/dep_lib/pub/00003564_000029CA_md_x64.lib new file mode 100644 index 0000000000000000000000000000000000000000..1135b600b643f8416aba4a3adba2cc1c66cf32c1 GIT binary patch literal 1433788 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⪙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'Bvz~r0@fneLc7dd= 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%0AhWPrOo9;;) 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 z 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 literal 0 HcmV?d00001 diff --git a/SourceCode/dep_lib/pub/sqlite3_win32.lib b/SourceCode/dep_lib/pub/sqlite3_win32.lib new file mode 100644 index 0000000000000000000000000000000000000000..8f6980b4a89d118613032d7aa51c284301be3d98 GIT binary patch literal 49320 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 Szonw!-txHZKlj0Emi`A(D2G`9 literal 0 HcmV?d00001