1 // Tencent is pleased to support the open source community by making RapidJSON available. 2 // 3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved. 4 // 5 // Licensed under the MIT License (the "License"); you may not use this file except 6 // in compliance with the License. You may obtain a copy of the License at 7 // 8 // http://opensource.org/licenses/MIT 9 // 10 // Unless required by applicable law or agreed to in writing, software distributed 11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the 13 // specific language governing permissions and limitations under the License. 14 15 #ifndef RAPIDJSON_RAPIDJSON_H_ 16 #define RAPIDJSON_RAPIDJSON_H_ 17 18 /*!\file rapidjson.h 19 \brief common definitions and configuration 20 21 \see RAPIDJSON_CONFIG 22 */ 23 24 /*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration 25 \brief Configuration macros for library features 26 27 Some RapidJSON features are configurable to adapt the library to a wide 28 variety of platforms, environments and usage scenarios. Most of the 29 features can be configured in terms of overriden or predefined 30 preprocessor macros at compile-time. 31 32 Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs. 33 34 \note These macros should be given on the compiler command-line 35 (where applicable) to avoid inconsistent values when compiling 36 different translation units of a single application. 37 */ 38 39 #include <cstdlib> // malloc(), realloc(), free(), size_t 40 #include <cstring> // memset(), memcpy(), memmove(), memcmp() 41 42 /////////////////////////////////////////////////////////////////////////////// 43 // RAPIDJSON_VERSION_STRING 44 // 45 // ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt. 46 // 47 48 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN 49 // token stringification 50 #define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x) 51 #define RAPIDJSON_DO_STRINGIFY(x) #x 52 //!@endcond 53 54 /*! \def RAPIDJSON_MAJOR_VERSION 55 \ingroup RAPIDJSON_CONFIG 56 \brief Major version of RapidJSON in integer. 57 */ 58 /*! \def RAPIDJSON_MINOR_VERSION 59 \ingroup RAPIDJSON_CONFIG 60 \brief Minor version of RapidJSON in integer. 61 */ 62 /*! \def RAPIDJSON_PATCH_VERSION 63 \ingroup RAPIDJSON_CONFIG 64 \brief Patch version of RapidJSON in integer. 65 */ 66 /*! \def RAPIDJSON_VERSION_STRING 67 \ingroup RAPIDJSON_CONFIG 68 \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format. 69 */ 70 #define RAPIDJSON_MAJOR_VERSION 1 71 #define RAPIDJSON_MINOR_VERSION 1 72 #define RAPIDJSON_PATCH_VERSION 0 73 #define RAPIDJSON_VERSION_STRING \ 74 RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION) 75 76 /////////////////////////////////////////////////////////////////////////////// 77 // RAPIDJSON_NAMESPACE_(BEGIN|END) 78 /*! \def RAPIDJSON_NAMESPACE 79 \ingroup RAPIDJSON_CONFIG 80 \brief provide custom rapidjson namespace 81 82 In order to avoid symbol clashes and/or "One Definition Rule" errors 83 between multiple inclusions of (different versions of) RapidJSON in 84 a single binary, users can customize the name of the main RapidJSON 85 namespace. 86 87 In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE 88 to a custom name (e.g. \c MyRapidJSON) is sufficient. If multiple 89 levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref 90 RAPIDJSON_NAMESPACE_END need to be defined as well: 91 92 \code 93 // in some .cpp file 94 #define RAPIDJSON_NAMESPACE my::rapidjson 95 #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson { 96 #define RAPIDJSON_NAMESPACE_END } } 97 #include "rapidjson/..." 98 \endcode 99 100 \see rapidjson 101 */ 102 /*! \def RAPIDJSON_NAMESPACE_BEGIN 103 \ingroup RAPIDJSON_CONFIG 104 \brief provide custom rapidjson namespace (opening expression) 105 \see RAPIDJSON_NAMESPACE 106 */ 107 /*! \def RAPIDJSON_NAMESPACE_END 108 \ingroup RAPIDJSON_CONFIG 109 \brief provide custom rapidjson namespace (closing expression) 110 \see RAPIDJSON_NAMESPACE 111 */ 112 #ifndef RAPIDJSON_NAMESPACE 113 #define RAPIDJSON_NAMESPACE rapidjson 114 #endif 115 #ifndef RAPIDJSON_NAMESPACE_BEGIN 116 #define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE { 117 #endif 118 #ifndef RAPIDJSON_NAMESPACE_END 119 #define RAPIDJSON_NAMESPACE_END } 120 #endif 121 122 /////////////////////////////////////////////////////////////////////////////// 123 // RAPIDJSON_HAS_STDSTRING 124 125 #ifndef RAPIDJSON_HAS_STDSTRING 126 #ifdef RAPIDJSON_DOXYGEN_RUNNING 127 #define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation 128 #else 129 #define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default 130 #endif 131 /*! \def RAPIDJSON_HAS_STDSTRING 132 \ingroup RAPIDJSON_CONFIG 133 \brief Enable RapidJSON support for \c std::string 134 135 By defining this preprocessor symbol to \c 1, several convenience functions for using 136 \ref rapidjson::GenericValue with \c std::string are enabled, especially 137 for construction and comparison. 138 139 \hideinitializer 140 */ 141 #endif // !defined(RAPIDJSON_HAS_STDSTRING) 142 143 #if RAPIDJSON_HAS_STDSTRING 144 #include <string> 145 #endif // RAPIDJSON_HAS_STDSTRING 146 147 /////////////////////////////////////////////////////////////////////////////// 148 // RAPIDJSON_NO_INT64DEFINE 149 150 /*! \def RAPIDJSON_NO_INT64DEFINE 151 \ingroup RAPIDJSON_CONFIG 152 \brief Use external 64-bit integer types. 153 154 RapidJSON requires the 64-bit integer types \c int64_t and \c uint64_t types 155 to be available at global scope. 156 157 If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to 158 prevent RapidJSON from defining its own types. 159 */ 160 #ifndef RAPIDJSON_NO_INT64DEFINE 161 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN 162 #if defined(_MSC_VER) && (_MSC_VER < 1800) // Visual Studio 2013 163 #include "msinttypes/stdint.h" 164 #include "msinttypes/inttypes.h" 165 #else 166 // Other compilers should have this. 167 #include <stdint.h> 168 #include <inttypes.h> 169 #endif 170 //!@endcond 171 #ifdef RAPIDJSON_DOXYGEN_RUNNING 172 #define RAPIDJSON_NO_INT64DEFINE 173 #endif 174 #endif // RAPIDJSON_NO_INT64TYPEDEF 175 176 /////////////////////////////////////////////////////////////////////////////// 177 // RAPIDJSON_FORCEINLINE 178 179 #ifndef RAPIDJSON_FORCEINLINE 180 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN 181 #if defined(_MSC_VER) && defined(NDEBUG) 182 #define RAPIDJSON_FORCEINLINE __forceinline 183 #elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG) 184 #define RAPIDJSON_FORCEINLINE __attribute__((always_inline)) 185 #else 186 #define RAPIDJSON_FORCEINLINE 187 #endif 188 //!@endcond 189 #endif // RAPIDJSON_FORCEINLINE 190 191 /////////////////////////////////////////////////////////////////////////////// 192 // RAPIDJSON_ENDIAN 193 #define RAPIDJSON_LITTLEENDIAN 0 //!< Little endian machine 194 #define RAPIDJSON_BIGENDIAN 1 //!< Big endian machine 195 196 //! Endianness of the machine. 197 /*! 198 \def RAPIDJSON_ENDIAN 199 \ingroup RAPIDJSON_CONFIG 200 201 GCC 4.6 provided macro for detecting endianness of the target machine. But other 202 compilers may not have this. User can define RAPIDJSON_ENDIAN to either 203 \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN. 204 205 Default detection implemented with reference to 206 \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html 207 \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp 208 */ 209 #ifndef RAPIDJSON_ENDIAN 210 // Detect with GCC 4.6's macro 211 # ifdef __BYTE_ORDER__ 212 # if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 213 # define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN 214 # elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 215 # define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN 216 # else 217 # error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN. 218 # endif // __BYTE_ORDER__ 219 // Detect with GLIBC's endian.h 220 # elif defined(__GLIBC__) 221 # include <endian.h> 222 # if (__BYTE_ORDER == __LITTLE_ENDIAN) 223 # define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN 224 # elif (__BYTE_ORDER == __BIG_ENDIAN) 225 # define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN 226 # else 227 # error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN. 228 # endif // __GLIBC__ 229 // Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro 230 # elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) 231 # define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN 232 # elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) 233 # define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN 234 // Detect with architecture macros 235 # elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__) 236 # define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN 237 # 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__) 238 # define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN 239 # elif defined(_MSC_VER) && defined(_M_ARM) 240 # define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN 241 # elif defined(RAPIDJSON_DOXYGEN_RUNNING) 242 # define RAPIDJSON_ENDIAN 243 # else 244 # error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN. 245 # endif 246 #endif // RAPIDJSON_ENDIAN 247 248 /////////////////////////////////////////////////////////////////////////////// 249 // RAPIDJSON_64BIT 250 251 //! Whether using 64-bit architecture 252 #ifndef RAPIDJSON_64BIT 253 #if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__) 254 #define RAPIDJSON_64BIT 1 255 #else 256 #define RAPIDJSON_64BIT 0 257 #endif 258 #endif // RAPIDJSON_64BIT 259 260 /////////////////////////////////////////////////////////////////////////////// 261 // RAPIDJSON_ALIGN 262 263 //! Data alignment of the machine. 264 /*! \ingroup RAPIDJSON_CONFIG 265 \param x pointer to align 266 267 Some machines require strict data alignment. Currently the default uses 4 bytes 268 alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms. 269 User can customize by defining the RAPIDJSON_ALIGN function macro. 270 */ 271 #ifndef RAPIDJSON_ALIGN 272 #if RAPIDJSON_64BIT == 1 273 #define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u)) 274 #else 275 #define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u) 276 #endif 277 #endif 278 279 /////////////////////////////////////////////////////////////////////////////// 280 // RAPIDJSON_UINT64_C2 281 282 //! Construct a 64-bit literal by a pair of 32-bit integer. 283 /*! 284 64-bit literal with or without ULL suffix is prone to compiler warnings. 285 UINT64_C() is C macro which cause compilation problems. 286 Use this macro to define 64-bit constants by a pair of 32-bit integer. 287 */ 288 #ifndef RAPIDJSON_UINT64_C2 289 #define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32)) 290 #endif 291 292 /////////////////////////////////////////////////////////////////////////////// 293 // RAPIDJSON_48BITPOINTER_OPTIMIZATION 294 295 //! Use only lower 48-bit address for some pointers. 296 /*! 297 \ingroup RAPIDJSON_CONFIG 298 299 This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address. 300 The higher 16-bit can be used for storing other data. 301 \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture. 302 */ 303 #ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION 304 #if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64) 305 #define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1 306 #else 307 #define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0 308 #endif 309 #endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION 310 311 #if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1 312 #if RAPIDJSON_64BIT != 1 313 #error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1 314 #endif 315 #define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x)))) 316 #define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF)))) 317 #else 318 #define RAPIDJSON_SETPOINTER(type, p, x) (p = (x)) 319 #define RAPIDJSON_GETPOINTER(type, p) (p) 320 #endif 321 322 /////////////////////////////////////////////////////////////////////////////// 323 // RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD 324 325 /*! \def RAPIDJSON_SIMD 326 \ingroup RAPIDJSON_CONFIG 327 \brief Enable SSE2/SSE4.2 optimization. 328 329 RapidJSON supports optimized implementations for some parsing operations 330 based on the SSE2 or SSE4.2 SIMD extensions on modern Intel-compatible 331 processors. 332 333 To enable these optimizations, two different symbols can be defined; 334 \code 335 // Enable SSE2 optimization. 336 #define RAPIDJSON_SSE2 337 338 // Enable SSE4.2 optimization. 339 #define RAPIDJSON_SSE42 340 \endcode 341 342 \c RAPIDJSON_SSE42 takes precedence, if both are defined. 343 344 If any of these symbols is defined, RapidJSON defines the macro 345 \c RAPIDJSON_SIMD to indicate the availability of the optimized code. 346 */ 347 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \ 348 || defined(RAPIDJSON_DOXYGEN_RUNNING) 349 #define RAPIDJSON_SIMD 350 #endif 351 352 /////////////////////////////////////////////////////////////////////////////// 353 // RAPIDJSON_NO_SIZETYPEDEFINE 354 355 #ifndef RAPIDJSON_NO_SIZETYPEDEFINE 356 /*! \def RAPIDJSON_NO_SIZETYPEDEFINE 357 \ingroup RAPIDJSON_CONFIG 358 \brief User-provided \c SizeType definition. 359 360 In order to avoid using 32-bit size types for indexing strings and arrays, 361 define this preprocessor symbol and provide the type rapidjson::SizeType 362 before including RapidJSON: 363 \code 364 #define RAPIDJSON_NO_SIZETYPEDEFINE 365 namespace rapidjson { typedef ::std::size_t SizeType; } 366 #include "rapidjson/..." 367 \endcode 368 369 \see rapidjson::SizeType 370 */ 371 #ifdef RAPIDJSON_DOXYGEN_RUNNING 372 #define RAPIDJSON_NO_SIZETYPEDEFINE 373 #endif 374 RAPIDJSON_NAMESPACE_BEGIN 375 //! Size type (for string lengths, array sizes, etc.) 376 /*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms, 377 instead of using \c size_t. Users may override the SizeType by defining 378 \ref RAPIDJSON_NO_SIZETYPEDEFINE. 379 */ 380 typedef unsigned SizeType; 381 RAPIDJSON_NAMESPACE_END 382 #endif 383 384 // always import std::size_t to rapidjson namespace 385 RAPIDJSON_NAMESPACE_BEGIN 386 using std::size_t; 387 RAPIDJSON_NAMESPACE_END 388 389 /////////////////////////////////////////////////////////////////////////////// 390 // RAPIDJSON_ASSERT 391 392 //! Assertion. 393 /*! \ingroup RAPIDJSON_CONFIG 394 By default, rapidjson uses C \c assert() for internal assertions. 395 User can override it by defining RAPIDJSON_ASSERT(x) macro. 396 397 \note Parsing errors are handled and can be customized by the 398 \ref RAPIDJSON_ERRORS APIs. 399 */ 400 #ifndef RAPIDJSON_ASSERT 401 #include <cassert> 402 #define RAPIDJSON_ASSERT(x) assert(x) 403 #endif // RAPIDJSON_ASSERT 404 405 /////////////////////////////////////////////////////////////////////////////// 406 // RAPIDJSON_STATIC_ASSERT 407 408 // Adopt from boost 409 #ifndef RAPIDJSON_STATIC_ASSERT 410 #ifndef __clang__ 411 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN 412 #endif 413 RAPIDJSON_NAMESPACE_BEGIN 414 template <bool x> struct STATIC_ASSERTION_FAILURE; 415 template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; }; 416 template<int x> struct StaticAssertTest {}; 417 RAPIDJSON_NAMESPACE_END 418 419 #define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y) 420 #define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y) 421 #define RAPIDJSON_DO_JOIN2(X, Y) X##Y 422 423 #if defined(__GNUC__) 424 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused)) 425 #else 426 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 427 #endif 428 #ifndef __clang__ 429 //!@endcond 430 #endif 431 432 /*! \def RAPIDJSON_STATIC_ASSERT 433 \brief (Internal) macro to check for conditions at compile-time 434 \param x compile-time condition 435 \hideinitializer 436 */ 437 #define RAPIDJSON_STATIC_ASSERT(x) \ 438 typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \ 439 sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \ 440 RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 441 #endif 442 443 /////////////////////////////////////////////////////////////////////////////// 444 // RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY 445 446 //! Compiler branching hint for expression with high probability to be true. 447 /*! 448 \ingroup RAPIDJSON_CONFIG 449 \param x Boolean expression likely to be true. 450 */ 451 #ifndef RAPIDJSON_LIKELY 452 #if defined(__GNUC__) || defined(__clang__) 453 #define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1) 454 #else 455 #define RAPIDJSON_LIKELY(x) (x) 456 #endif 457 #endif 458 459 //! Compiler branching hint for expression with low probability to be true. 460 /*! 461 \ingroup RAPIDJSON_CONFIG 462 \param x Boolean expression unlikely to be true. 463 */ 464 #ifndef RAPIDJSON_UNLIKELY 465 #if defined(__GNUC__) || defined(__clang__) 466 #define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0) 467 #else 468 #define RAPIDJSON_UNLIKELY(x) (x) 469 #endif 470 #endif 471 472 /////////////////////////////////////////////////////////////////////////////// 473 // Helpers 474 475 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN 476 477 #define RAPIDJSON_MULTILINEMACRO_BEGIN do { 478 #define RAPIDJSON_MULTILINEMACRO_END \ 479 } while((void)0, 0) 480 481 // adopted from Boost 482 #define RAPIDJSON_VERSION_CODE(x,y,z) \ 483 (((x)*100000) + ((y)*100) + (z)) 484 485 /////////////////////////////////////////////////////////////////////////////// 486 // RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF 487 488 #if defined(__GNUC__) 489 #define RAPIDJSON_GNUC \ 490 RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__) 491 #endif 492 493 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0)) 494 495 #define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x)) 496 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x) 497 #define RAPIDJSON_DIAG_OFF(x) \ 498 RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x))) 499 500 // push/pop support in Clang and GCC>=4.6 501 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) 502 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) 503 #define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) 504 #else // GCC >= 4.2, < 4.6 505 #define RAPIDJSON_DIAG_PUSH /* ignored */ 506 #define RAPIDJSON_DIAG_POP /* ignored */ 507 #endif 508 509 #elif defined(_MSC_VER) 510 511 // pragma (MSVC specific) 512 #define RAPIDJSON_PRAGMA(x) __pragma(x) 513 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x)) 514 515 #define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x) 516 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) 517 #define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) 518 519 #else 520 521 #define RAPIDJSON_DIAG_OFF(x) /* ignored */ 522 #define RAPIDJSON_DIAG_PUSH /* ignored */ 523 #define RAPIDJSON_DIAG_POP /* ignored */ 524 525 #endif // RAPIDJSON_DIAG_* 526 527 /////////////////////////////////////////////////////////////////////////////// 528 // C++11 features 529 530 #ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS 531 #if defined(__clang__) 532 #if __has_feature(cxx_rvalue_references) && \ 533 (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306) 534 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 535 #else 536 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 537 #endif 538 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ 539 (defined(_MSC_VER) && _MSC_VER >= 1600) 540 541 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 542 #else 543 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 544 #endif 545 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS 546 547 #ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT 548 #if defined(__clang__) 549 #define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept) 550 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) 551 // (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported 552 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 1 553 #else 554 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 0 555 #endif 556 #endif 557 #if RAPIDJSON_HAS_CXX11_NOEXCEPT 558 #define RAPIDJSON_NOEXCEPT noexcept 559 #else 560 #define RAPIDJSON_NOEXCEPT /* noexcept */ 561 #endif // RAPIDJSON_HAS_CXX11_NOEXCEPT 562 563 // no automatic detection, yet 564 #ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS 565 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 0 566 #endif 567 568 #ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR 569 #if defined(__clang__) 570 #define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for) 571 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ 572 (defined(_MSC_VER) && _MSC_VER >= 1700) 573 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 1 574 #else 575 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 0 576 #endif 577 #endif // RAPIDJSON_HAS_CXX11_RANGE_FOR 578 579 //!@endcond 580 581 /////////////////////////////////////////////////////////////////////////////// 582 // new/delete 583 584 #ifndef RAPIDJSON_NEW 585 ///! customization point for global \c new 586 #define RAPIDJSON_NEW(x) new x 587 #endif 588 #ifndef RAPIDJSON_DELETE 589 ///! customization point for global \c delete 590 #define RAPIDJSON_DELETE(x) delete x 591 #endif 592 593 /////////////////////////////////////////////////////////////////////////////// 594 // Type 595 596 /*! \namespace rapidjson 597 \brief main RapidJSON namespace 598 \see RAPIDJSON_NAMESPACE 599 */ 600 RAPIDJSON_NAMESPACE_BEGIN 601 602 //! Type of JSON value 603 enum Type { 604 kNullType = 0, //!< null 605 kFalseType = 1, //!< false 606 kTrueType = 2, //!< true 607 kObjectType = 3, //!< object 608 kArrayType = 4, //!< array 609 kStringType = 5, //!< string 610 kNumberType = 6 //!< number 611 }; 612 613 RAPIDJSON_NAMESPACE_END 614 615 #endif // RAPIDJSON_RAPIDJSON_H_ 616