rapidjson.h
Go to the documentation of this file.
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. Currently the default uses 4 bytes
273  alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
274  User can customize by defining the RAPIDJSON_ALIGN function macro.
275 */
276 #ifndef RAPIDJSON_ALIGN
277 #if RAPIDJSON_64BIT == 1
278 #define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
279 #else
280 #define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
281 #endif
282 #endif
283 
284 ///////////////////////////////////////////////////////////////////////////////
285 // RAPIDJSON_UINT64_C2
286 
287 //! Construct a 64-bit literal by a pair of 32-bit integer.
288 /*!
289  64-bit literal with or without ULL suffix is prone to compiler warnings.
290  UINT64_C() is C macro which cause compilation problems.
291  Use this macro to define 64-bit constants by a pair of 32-bit integer.
292 */
293 #ifndef RAPIDJSON_UINT64_C2
294 #define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
295 #endif
296 
297 ///////////////////////////////////////////////////////////////////////////////
298 // RAPIDJSON_48BITPOINTER_OPTIMIZATION
299 
300 //! Use only lower 48-bit address for some pointers.
301 /*!
302  \ingroup RAPIDJSON_CONFIG
303 
304  This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
305  The higher 16-bit can be used for storing other data.
306  \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
307 */
308 #ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
309 #if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
310 #define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
311 #else
312 #define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
313 #endif
314 #endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
315 
316 #if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
317 #if RAPIDJSON_64BIT != 1
318 #error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
319 #endif
320 #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))))
321 #define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
322 #else
323 #define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
324 #define RAPIDJSON_GETPOINTER(type, p) (p)
325 #endif
326 
327 ///////////////////////////////////////////////////////////////////////////////
328 // RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD
329 
330 /*! \def RAPIDJSON_SIMD
331  \ingroup RAPIDJSON_CONFIG
332  \brief Enable SSE2/SSE4.2/Neon optimization.
333 
334  RapidJSON supports optimized implementations for some parsing operations
335  based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
336  or ARM compatible processors.
337 
338  To enable these optimizations, three different symbols can be defined;
339  \code
340  // Enable SSE2 optimization.
341  #define RAPIDJSON_SSE2
342 
343  // Enable SSE4.2 optimization.
344  #define RAPIDJSON_SSE42
345  \endcode
346 
347  // Enable ARM Neon optimization.
348  #define RAPIDJSON_NEON
349  \endcode
350 
351  \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
352 
353  If any of these symbols is defined, RapidJSON defines the macro
354  \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
355 */
356 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
357  || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING)
358 #define RAPIDJSON_SIMD
359 #endif
360 
361 ///////////////////////////////////////////////////////////////////////////////
362 // RAPIDJSON_NO_SIZETYPEDEFINE
363 
364 #ifndef RAPIDJSON_NO_SIZETYPEDEFINE
365 /*! \def RAPIDJSON_NO_SIZETYPEDEFINE
366  \ingroup RAPIDJSON_CONFIG
367  \brief User-provided \c SizeType definition.
368 
369  In order to avoid using 32-bit size types for indexing strings and arrays,
370  define this preprocessor symbol and provide the type rapidjson::SizeType
371  before including RapidJSON:
372  \code
373  #define RAPIDJSON_NO_SIZETYPEDEFINE
374  namespace rapidjson { typedef ::std::size_t SizeType; }
375  #include "rapidjson/..."
376  \endcode
377 
378  \see rapidjson::SizeType
379 */
380 #ifdef RAPIDJSON_DOXYGEN_RUNNING
381 #define RAPIDJSON_NO_SIZETYPEDEFINE
382 #endif
383 RAPIDJSON_NAMESPACE_BEGIN
384 //! Size type (for string lengths, array sizes, etc.)
385 /*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
386  instead of using \c size_t. Users may override the SizeType by defining
387  \ref RAPIDJSON_NO_SIZETYPEDEFINE.
388 */
389 typedef unsigned SizeType;
390 RAPIDJSON_NAMESPACE_END
391 #endif
392 
393 // always import std::size_t to rapidjson namespace
394 RAPIDJSON_NAMESPACE_BEGIN
395 using std::size_t;
396 RAPIDJSON_NAMESPACE_END
397 
398 ///////////////////////////////////////////////////////////////////////////////
399 // RAPIDJSON_ASSERT
400 
401 //! Assertion.
402 /*! \ingroup RAPIDJSON_CONFIG
403  By default, rapidjson uses C \c assert() for internal assertions.
404  User can override it by defining RAPIDJSON_ASSERT(x) macro.
405 
406  \note Parsing errors are handled and can be customized by the
407  \ref RAPIDJSON_ERRORS APIs.
408 */
409 #ifndef RAPIDJSON_ASSERT
410 #include <cassert>
411 #define RAPIDJSON_ASSERT(x) assert(x)
412 #endif // RAPIDJSON_ASSERT
413 
414 ///////////////////////////////////////////////////////////////////////////////
415 // RAPIDJSON_STATIC_ASSERT
416 
417 // Prefer C++11 static_assert, if available
418 #ifndef RAPIDJSON_STATIC_ASSERT
419 #if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
420 #define RAPIDJSON_STATIC_ASSERT(x) \
421  static_assert(x, RAPIDJSON_STRINGIFY(x))
422 #endif // C++11
423 #endif // RAPIDJSON_STATIC_ASSERT
424 
425 // Adopt C++03 implementation from boost
426 #ifndef RAPIDJSON_STATIC_ASSERT
427 #ifndef __clang__
428 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
429 #endif
430 RAPIDJSON_NAMESPACE_BEGIN
431 template <bool x> struct STATIC_ASSERTION_FAILURE;
432 template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
433 template <size_t x> struct StaticAssertTest {};
434 RAPIDJSON_NAMESPACE_END
435 
436 #if defined(__GNUC__) || defined(__clang__)
437 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
438 #else
439 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
440 #endif
441 #ifndef __clang__
442 //!@endcond
443 #endif
444 
445 /*! \def RAPIDJSON_STATIC_ASSERT
446  \brief (Internal) macro to check for conditions at compile-time
447  \param x compile-time condition
448  \hideinitializer
449  */
450 #define RAPIDJSON_STATIC_ASSERT(x) \
451  typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
452  sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
453  RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
454 #endif // RAPIDJSON_STATIC_ASSERT
455 
456 ///////////////////////////////////////////////////////////////////////////////
457 // RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
458 
459 //! Compiler branching hint for expression with high probability to be true.
460 /*!
461  \ingroup RAPIDJSON_CONFIG
462  \param x Boolean expression likely to be true.
463 */
464 #ifndef RAPIDJSON_LIKELY
465 #if defined(__GNUC__) || defined(__clang__)
466 #define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
467 #else
468 #define RAPIDJSON_LIKELY(x) (x)
469 #endif
470 #endif
471 
472 //! Compiler branching hint for expression with low probability to be true.
473 /*!
474  \ingroup RAPIDJSON_CONFIG
475  \param x Boolean expression unlikely to be true.
476 */
477 #ifndef RAPIDJSON_UNLIKELY
478 #if defined(__GNUC__) || defined(__clang__)
479 #define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
480 #else
481 #define RAPIDJSON_UNLIKELY(x) (x)
482 #endif
483 #endif
484 
485 ///////////////////////////////////////////////////////////////////////////////
486 // Helpers
487 
488 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
489 
490 #define RAPIDJSON_MULTILINEMACRO_BEGIN do {
491 #define RAPIDJSON_MULTILINEMACRO_END \
492 } while((void)0, 0)
493 
494 // adopted from Boost
495 #define RAPIDJSON_VERSION_CODE(x,y,z) \
496  (((x)*100000) + ((y)*100) + (z))
497 
498 ///////////////////////////////////////////////////////////////////////////////
499 // RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
500 
501 #if defined(__GNUC__)
502 #define RAPIDJSON_GNUC \
503  RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
504 #endif
505 
506 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
507 
508 #define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
509 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
510 #define RAPIDJSON_DIAG_OFF(x) \
511  RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
512 
513 // push/pop support in Clang and GCC>=4.6
514 #if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
515 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
516 #define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop)
517 #else // GCC >= 4.2, < 4.6
518 #define RAPIDJSON_DIAG_PUSH /* ignored */
519 #define RAPIDJSON_DIAG_POP /* ignored */
520 #endif
521 
522 #elif defined(_MSC_VER)
523 
524 // pragma (MSVC specific)
525 #define RAPIDJSON_PRAGMA(x) __pragma(x)
526 #define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
527 
528 #define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
529 #define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
530 #define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop)
531 
532 #else
533 
534 #define RAPIDJSON_DIAG_OFF(x) /* ignored */
535 #define RAPIDJSON_DIAG_PUSH /* ignored */
536 #define RAPIDJSON_DIAG_POP /* ignored */
537 
538 #endif // RAPIDJSON_DIAG_*
539 
540 ///////////////////////////////////////////////////////////////////////////////
541 // C++11 features
542 
543 #ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
544 #if defined(__clang__)
545 #if __has_feature(cxx_rvalue_references) && \
546  (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
547 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
548 #else
549 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
550 #endif
551 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
552  (defined(_MSC_VER) && _MSC_VER >= 1600) || \
553  (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
554 
555 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
556 #else
557 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
558 #endif
559 #endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
560 
561 #ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
562 #if defined(__clang__)
563 #define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
564 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
565  (defined(_MSC_VER) && _MSC_VER >= 1900) || \
566  (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
567 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
568 #else
569 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
570 #endif
571 #endif
572 #if RAPIDJSON_HAS_CXX11_NOEXCEPT
573 #define RAPIDJSON_NOEXCEPT noexcept
574 #else
575 #define RAPIDJSON_NOEXCEPT /* noexcept */
576 #endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
577 
578 // no automatic detection, yet
579 #ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
580 #if (defined(_MSC_VER) && _MSC_VER >= 1700)
581 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
582 #else
583 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
584 #endif
585 #endif
586 
587 #ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
588 #if defined(__clang__)
589 #define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
590 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
591  (defined(_MSC_VER) && _MSC_VER >= 1700) || \
592  (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
593 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
594 #else
595 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
596 #endif
597 #endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
598 
599 //!@endcond
600 
601 ///////////////////////////////////////////////////////////////////////////////
602 // new/delete
603 
604 #ifndef RAPIDJSON_NEW
605 ///! customization point for global \c new
606 #define RAPIDJSON_NEW(TypeName) new TypeName
607 #endif
608 #ifndef RAPIDJSON_DELETE
609 ///! customization point for global \c delete
610 #define RAPIDJSON_DELETE(x) delete x
611 #endif
612 
613 ///////////////////////////////////////////////////////////////////////////////
614 // Type
615 
616 /*! \namespace rapidjson
617  \brief main RapidJSON namespace
618  \see RAPIDJSON_NAMESPACE
619 */
620 RAPIDJSON_NAMESPACE_BEGIN
621 
622 //! Type of JSON value
623 enum Type {
624  kNullType = 0, //!< null
625  kFalseType = 1, //!< false
626  kTrueType = 2, //!< true
627  kObjectType = 3, //!< object
628  kArrayType = 4, //!< array
629  kStringType = 5, //!< string
630  kNumberType = 6 //!< number
631 };
632 
633 RAPIDJSON_NAMESPACE_END
634 
635 #endif // RAPIDJSON_RAPIDJSON_H_
true
Definition: rapidjson.h:626
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:389
false
Definition: rapidjson.h:625
Type
Type of JSON value.
Definition: rapidjson.h:623
object
Definition: rapidjson.h:627
array
Definition: rapidjson.h:628
null
Definition: rapidjson.h:624
string
Definition: rapidjson.h:629
number
Definition: rapidjson.h:630