inference-engine/thirdparty/clDNN/utils/rapidjson/rapidjson.h

   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 overridden 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
  53 // token concatenation
  54 #define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
  55 #define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
  56 #define RAPIDJSON_DO_JOIN2(X, Y) X##Y
  57 //!@endcond
  58
  59 /*! \def RAPIDJSON_MAJOR_VERSION
  60     \ingroup RAPIDJSON_CONFIG
  61     \brief Major version of RapidJSON in integer.
  62 */
  63 /*! \def RAPIDJSON_MINOR_VERSION
  64     \ingroup RAPIDJSON_CONFIG
  65     \brief Minor version of RapidJSON in integer.
  66 */
  67 /*! \def RAPIDJSON_PATCH_VERSION
  68     \ingroup RAPIDJSON_CONFIG
  69     \brief Patch version of RapidJSON in integer.
  70 */
  71 /*! \def RAPIDJSON_VERSION_STRING
  72     \ingroup RAPIDJSON_CONFIG
  73     \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
  74 */
  75 #define RAPIDJSON_MAJOR_VERSION 1
  76 #define RAPIDJSON_MINOR_VERSION 1
  77 #define RAPIDJSON_PATCH_VERSION 0
  78 #define RAPIDJSON_VERSION_STRING \
  79     RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82 // RAPIDJSON_NAMESPACE_(BEGIN|END)
  83 /*! \def RAPIDJSON_NAMESPACE
  84     \ingroup RAPIDJSON_CONFIG
  85     \brief   provide custom rapidjson namespace
  86
  87     In order to avoid symbol clashes and/or "One Definition Rule" errors
  88     between multiple inclusions of (different versions of) RapidJSON in
  89     a single binary, users can customize the name of the main RapidJSON
  90     namespace.
  91
  92     In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
  93     to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
  94     levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
  95     RAPIDJSON_NAMESPACE_END need to be defined as well:
  96
  97     \code
  98     // in some .cpp file
  99     #define RAPIDJSON_NAMESPACE my::rapidjson
 100     #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
 101     #define RAPIDJSON_NAMESPACE_END   } }
 102     #include "rapidjson/..."
 103     \endcode
 104
 105     \see rapidjson
 106  */
 107 /*! \def RAPIDJSON_NAMESPACE_BEGIN
 108     \ingroup RAPIDJSON_CONFIG
 109     \brief   provide custom rapidjson namespace (opening expression)
 110     \see RAPIDJSON_NAMESPACE
 111 */
 112 /*! \def RAPIDJSON_NAMESPACE_END
 113     \ingroup RAPIDJSON_CONFIG
 114     \brief   provide custom rapidjson namespace (closing expression)
 115     \see RAPIDJSON_NAMESPACE
 116 */
 117 #ifndef RAPIDJSON_NAMESPACE
 118 #define RAPIDJSON_NAMESPACE rapidjson
 119 #endif
 120 #ifndef RAPIDJSON_NAMESPACE_BEGIN
 121 #define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
 122 #endif
 123 #ifndef RAPIDJSON_NAMESPACE_END
 124 #define RAPIDJSON_NAMESPACE_END }
 125 #endif
 126
 127 ///////////////////////////////////////////////////////////////////////////////
 128 // RAPIDJSON_HAS_STDSTRING
 129
 130 #ifndef RAPIDJSON_HAS_STDSTRING
 131 #ifdef RAPIDJSON_DOXYGEN_RUNNING
 132 #define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
 133 #else
 134 #define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
 135 #endif
 136 /*! \def RAPIDJSON_HAS_STDSTRING
 137     \ingroup RAPIDJSON_CONFIG
 138     \brief Enable RapidJSON support for \c std::string
 139
 140     By defining this preprocessor symbol to \c 1, several convenience functions for using
 141     \ref rapidjson::GenericValue with \c std::string are enabled, especially
 142     for construction and comparison.
 143
 144     \hideinitializer
 145 */
 146 #endif // !defined(RAPIDJSON_HAS_STDSTRING)
 147
 148 #if RAPIDJSON_HAS_STDSTRING
 149 #include <string>
 150 #endif // RAPIDJSON_HAS_STDSTRING
 151
 152 ///////////////////////////////////////////////////////////////////////////////
 153 // RAPIDJSON_NO_INT64DEFINE
 154
 155 /*! \def RAPIDJSON_NO_INT64DEFINE
 156     \ingroup RAPIDJSON_CONFIG
 157     \brief Use external 64-bit integer types.
 158
 159     RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
 160     to be available at global scope.
 161
 162     If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
 163     prevent RapidJSON from defining its own types.
 164 */
 165 #ifndef RAPIDJSON_NO_INT64DEFINE
 166 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 167 #if defined(_MSC_VER) && (_MSC_VER < 1800)      // Visual Studio 2013
 168 #include "msinttypes/stdint.h"
 169 #include "msinttypes/inttypes.h"
 170 #else
 171 // Other compilers should have this.
 172 #include <stdint.h>
 173 #include <inttypes.h>
 174 #endif
 175 //!@endcond
 176 #ifdef RAPIDJSON_DOXYGEN_RUNNING
 177 #define RAPIDJSON_NO_INT64DEFINE
 178 #endif
 179 #endif // RAPIDJSON_NO_INT64TYPEDEF
 180
 181 ///////////////////////////////////////////////////////////////////////////////
 182 // RAPIDJSON_FORCEINLINE
 183
 184 #ifndef RAPIDJSON_FORCEINLINE
 185 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 186 #if defined(_MSC_VER) && defined(NDEBUG)
 187 #define RAPIDJSON_FORCEINLINE __forceinline
 188 #elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
 189 #define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
 190 #else
 191 #define RAPIDJSON_FORCEINLINE
 192 #endif
 193 //!@endcond
 194 #endif // RAPIDJSON_FORCEINLINE
 195
 196 ///////////////////////////////////////////////////////////////////////////////
 197 // RAPIDJSON_ENDIAN
 198 #define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
 199 #define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
 200
 201 //! Endianness of the machine.
 202 /*!
 203     \def RAPIDJSON_ENDIAN
 204     \ingroup RAPIDJSON_CONFIG
 205
 206     GCC 4.6 provided macro for detecting endianness of the target machine. But other
 207     compilers may not have this. User can define RAPIDJSON_ENDIAN to either
 208     \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
 209
 210     Default detection implemented with reference to
 211     \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
 212     \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
 213 */
 214 #ifndef RAPIDJSON_ENDIAN
 215 // Detect with GCC 4.6's macro
 216 #  ifdef __BYTE_ORDER__
 217 #    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 218 #      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
 219 #    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 220 #      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 221 #    else
 222 #      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
 223 #    endif // __BYTE_ORDER__
 224 // Detect with GLIBC's endian.h
 225 #  elif defined(__GLIBC__)
 226 #    include <endian.h>
 227 #    if (__BYTE_ORDER == __LITTLE_ENDIAN)
 228 #      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
 229 #    elif (__BYTE_ORDER == __BIG_ENDIAN)
 230 #      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 231 #    else
 232 #      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
 233 #   endif // __GLIBC__
 234 // Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
 235 #  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
 236 #    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
 237 #  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
 238 #    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 239 // Detect with architecture macros
 240 #  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
 241 #    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 242 #  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__)
 243 #    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
 244 #  elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
 245 #    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
 246 #  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
 247 #    define RAPIDJSON_ENDIAN
 248 #  else
 249 #    error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
 250 #  endif
 251 #endif // RAPIDJSON_ENDIAN
 252
 253 ///////////////////////////////////////////////////////////////////////////////
 254 // RAPIDJSON_64BIT
 255
 256 //! Whether using 64-bit architecture
 257 #ifndef RAPIDJSON_64BIT
 258 #if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
 259 #define RAPIDJSON_64BIT 1
 260 #else
 261 #define RAPIDJSON_64BIT 0
 262 #endif
 263 #endif // RAPIDJSON_64BIT
 264
 265 ///////////////////////////////////////////////////////////////////////////////
 266 // RAPIDJSON_ALIGN
 267
 268 //! Data alignment of the machine.
 269 /*! \ingroup RAPIDJSON_CONFIG
 270     \param x pointer to align
 271
 272     Some machines require strict data alignment. The default is 8 bytes.
 273     User can customize by defining the RAPIDJSON_ALIGN function macro.
 274 */
 275 #ifndef RAPIDJSON_ALIGN
 276 #define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
 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_NEON/RAPIDJSON_SIMD
 324
 325 /*! \def RAPIDJSON_SIMD
 326     \ingroup RAPIDJSON_CONFIG
 327     \brief Enable SSE2/SSE4.2/Neon optimization.
 328
 329     RapidJSON supports optimized implementations for some parsing operations
 330     based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
 331     or ARM compatible processors.
 332
 333     To enable these optimizations, three 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     // Enable ARM Neon optimization.
 343     #define RAPIDJSON_NEON
 344     \endcode
 345
 346     \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
 347
 348     If any of these symbols is defined, RapidJSON defines the macro
 349     \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
 350 */
 351 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
 352     || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING)
 353 #define RAPIDJSON_SIMD
 354 #endif
 355
 356 ///////////////////////////////////////////////////////////////////////////////
 357 // RAPIDJSON_NO_SIZETYPEDEFINE
 358
 359 #ifndef RAPIDJSON_NO_SIZETYPEDEFINE
 360 /*! \def RAPIDJSON_NO_SIZETYPEDEFINE
 361     \ingroup RAPIDJSON_CONFIG
 362     \brief User-provided \c SizeType definition.
 363
 364     In order to avoid using 32-bit size types for indexing strings and arrays,
 365     define this preprocessor symbol and provide the type rapidjson::SizeType
 366     before including RapidJSON:
 367     \code
 368     #define RAPIDJSON_NO_SIZETYPEDEFINE
 369     namespace rapidjson { typedef ::std::size_t SizeType; }
 370     #include "rapidjson/..."
 371     \endcode
 372
 373     \see rapidjson::SizeType
 374 */
 375 #ifdef RAPIDJSON_DOXYGEN_RUNNING
 376 #define RAPIDJSON_NO_SIZETYPEDEFINE
 377 #endif
 378 RAPIDJSON_NAMESPACE_BEGIN
 379 //! Size type (for string lengths, array sizes, etc.)
 380 /*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
 381     instead of using \c size_t. Users may override the SizeType by defining
 382     \ref RAPIDJSON_NO_SIZETYPEDEFINE.
 383 */
 384 typedef unsigned SizeType;
 385 RAPIDJSON_NAMESPACE_END
 386 #endif
 387
 388 // always import std::size_t to rapidjson namespace
 389 RAPIDJSON_NAMESPACE_BEGIN
 390 using std::size_t;
 391 RAPIDJSON_NAMESPACE_END
 392
 393 ///////////////////////////////////////////////////////////////////////////////
 394 // RAPIDJSON_ASSERT
 395
 396 //! Assertion.
 397 /*! \ingroup RAPIDJSON_CONFIG
 398     By default, rapidjson uses C \c assert() for internal assertions.
 399     User can override it by defining RAPIDJSON_ASSERT(x) macro.
 400
 401     \note Parsing errors are handled and can be customized by the
 402           \ref RAPIDJSON_ERRORS APIs.
 403 */
 404 #ifndef RAPIDJSON_ASSERT
 405 #include <cassert>
 406 #define RAPIDJSON_ASSERT(x) assert(x)
 407 #endif // RAPIDJSON_ASSERT
 408
 409 ///////////////////////////////////////////////////////////////////////////////
 410 // RAPIDJSON_STATIC_ASSERT
 411
 412 // Prefer C++11 static_assert, if available
 413 #ifndef RAPIDJSON_STATIC_ASSERT
 414 #if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
 415 #define RAPIDJSON_STATIC_ASSERT(x) \
 416    static_assert(x, RAPIDJSON_STRINGIFY(x))
 417 #endif // C++11
 418 #endif // RAPIDJSON_STATIC_ASSERT
 419
 420 // Adopt C++03 implementation from boost
 421 #ifndef RAPIDJSON_STATIC_ASSERT
 422 #ifndef __clang__
 423 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 424 #endif
 425 RAPIDJSON_NAMESPACE_BEGIN
 426 template <bool x> struct STATIC_ASSERTION_FAILURE;
 427 template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
 428 template <size_t x> struct StaticAssertTest {};
 429 RAPIDJSON_NAMESPACE_END
 430
 431 #if defined(__GNUC__) || defined(__clang__)
 432 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
 433 #else
 434 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
 435 #endif
 436 #ifndef __clang__
 437 //!@endcond
 438 #endif
 439
 440 /*! \def RAPIDJSON_STATIC_ASSERT
 441     \brief (Internal) macro to check for conditions at compile-time
 442     \param x compile-time condition
 443     \hideinitializer
 444  */
 445 #define RAPIDJSON_STATIC_ASSERT(x) \
 446     typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
 447       sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
 448     RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
 449 #endif // RAPIDJSON_STATIC_ASSERT
 450
 451 ///////////////////////////////////////////////////////////////////////////////
 452 // RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
 453
 454 //! Compiler branching hint for expression with high probability to be true.
 455 /*!
 456     \ingroup RAPIDJSON_CONFIG
 457     \param x Boolean expression likely to be true.
 458 */
 459 #ifndef RAPIDJSON_LIKELY
 460 #if defined(__GNUC__) || defined(__clang__)
 461 #define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
 462 #else
 463 #define RAPIDJSON_LIKELY(x) (x)
 464 #endif
 465 #endif
 466
 467 //! Compiler branching hint for expression with low probability to be true.
 468 /*!
 469     \ingroup RAPIDJSON_CONFIG
 470     \param x Boolean expression unlikely to be true.
 471 */
 472 #ifndef RAPIDJSON_UNLIKELY
 473 #if defined(__GNUC__) || defined(__clang__)
 474 #define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
 475 #else
 476 #define RAPIDJSON_UNLIKELY(x) (x)
 477 #endif
 478 #endif
 479
 480 ///////////////////////////////////////////////////////////////////////////////
 481 // Helpers
 482
 483 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 484
 485 #define RAPIDJSON_MULTILINEMACRO_BEGIN do {
 486 #define RAPIDJSON_MULTILINEMACRO_END \
 487 } while((void)0, 0)
 488
 489 // adopted from Boost
 490 #define RAPIDJSON_VERSION_CODE(x,y,z) \
 491   (((x)*100000) + ((y)*100) + (z))
 492
 493 ///////////////////////////////////////////////////////////////////////////////
 494 // RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
 495
 496 #if defined(__GNUC__)
 497 #define RAPIDJSON_GNUC \
 498     RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
 499 #endif
 500
 501 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
 502
 503 #define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
 504 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
 505 #define RAPIDJSON_DIAG_OFF(x) \
 506     RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
 507
 508 // push/pop support in Clang and GCC>=4.6
 509 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
 510 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
 511 #define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
 512 #else // GCC >= 4.2, < 4.6
 513 #define RAPIDJSON_DIAG_PUSH /* ignored */
 514 #define RAPIDJSON_DIAG_POP /* ignored */
 515 #endif
 516
 517 #elif defined(_MSC_VER)
 518
 519 // pragma (MSVC specific)
 520 #define RAPIDJSON_PRAGMA(x) __pragma(x)
 521 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
 522
 523 #define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
 524 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
 525 #define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
 526
 527 #else
 528
 529 #define RAPIDJSON_DIAG_OFF(x) /* ignored */
 530 #define RAPIDJSON_DIAG_PUSH   /* ignored */
 531 #define RAPIDJSON_DIAG_POP    /* ignored */
 532
 533 #endif // RAPIDJSON_DIAG_*
 534
 535 ///////////////////////////////////////////////////////////////////////////////
 536 // C++11 features
 537
 538 #ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
 539 #if defined(__clang__)
 540 #if __has_feature(cxx_rvalue_references) && \
 541     (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
 542 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
 543 #else
 544 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
 545 #endif
 546 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
 547       (defined(_MSC_VER) && _MSC_VER >= 1600) || \
 548       (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 549
 550 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
 551 #else
 552 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
 553 #endif
 554 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
 555
 556 #ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
 557 #if defined(__clang__)
 558 #define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
 559 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
 560     (defined(_MSC_VER) && _MSC_VER >= 1900) || \
 561     (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 562 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
 563 #else
 564 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
 565 #endif
 566 #endif
 567 #if RAPIDJSON_HAS_CXX11_NOEXCEPT
 568 #define RAPIDJSON_NOEXCEPT noexcept
 569 #else
 570 #define RAPIDJSON_NOEXCEPT /* noexcept */
 571 #endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
 572
 573 // no automatic detection, yet
 574 #ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
 575 #if (defined(_MSC_VER) && _MSC_VER >= 1700)
 576 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
 577 #else
 578 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
 579 #endif
 580 #endif
 581
 582 #ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
 583 #if defined(__clang__)
 584 #define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
 585 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
 586       (defined(_MSC_VER) && _MSC_VER >= 1700) || \
 587       (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 588 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
 589 #else
 590 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
 591 #endif
 592 #endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
 593
 594 //!@endcond
 595
 596 //! Assertion (in non-throwing contexts).
 597  /*! \ingroup RAPIDJSON_CONFIG
 598     Some functions provide a \c noexcept guarantee, if the compiler supports it.
 599     In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
 600     throw an exception.  This macro adds a separate customization point for
 601     such cases.
 602
 603     Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
 604     supported, and to \ref RAPIDJSON_ASSERT otherwise.
 605  */
 606
 607 ///////////////////////////////////////////////////////////////////////////////
 608 // RAPIDJSON_NOEXCEPT_ASSERT
 609
 610 #ifdef RAPIDJSON_ASSERT_THROWS
 611 #if RAPIDJSON_HAS_CXX11_NOEXCEPT
 612 #define RAPIDJSON_NOEXCEPT_ASSERT(x)
 613 #else
 614 #define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
 615 #endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
 616 #else
 617 #define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
 618 #endif // RAPIDJSON_ASSERT_THROWS
 619
 620 ///////////////////////////////////////////////////////////////////////////////
 621 // new/delete
 622
 623 #ifndef RAPIDJSON_NEW
 624 ///! customization point for global \c new
 625 #define RAPIDJSON_NEW(TypeName) new TypeName
 626 #endif
 627 #ifndef RAPIDJSON_DELETE
 628 ///! customization point for global \c delete
 629 #define RAPIDJSON_DELETE(x) delete x
 630 #endif
 631
 632 ///////////////////////////////////////////////////////////////////////////////
 633 // Type
 634
 635 /*! \namespace rapidjson
 636     \brief main RapidJSON namespace
 637     \see RAPIDJSON_NAMESPACE
 638 */
 639 RAPIDJSON_NAMESPACE_BEGIN
 640
 641 //! Type of JSON value
 642 enum Type {
 643     kNullType = 0,      //!< null
 644     kFalseType = 1,     //!< false
 645     kTrueType = 2,      //!< true
 646     kObjectType = 3,    //!< object
 647     kArrayType = 4,     //!< array
 648     kStringType = 5,    //!< string
 649     kNumberType = 6     //!< number
 650 };
 651
 652 RAPIDJSON_NAMESPACE_END
 653
 654 #endif // RAPIDJSON_RAPIDJSON_H_