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 | #ifndef RAPIDJSON_NOEXCEPT_ASSERT |
611 | #ifdef RAPIDJSON_ASSERT_THROWS |
612 | #if RAPIDJSON_HAS_CXX11_NOEXCEPT |
613 | #define RAPIDJSON_NOEXCEPT_ASSERT(x) |
614 | #else |
615 | #define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x) |
616 | #endif // RAPIDJSON_HAS_CXX11_NOEXCEPT |
617 | #else |
618 | #define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x) |
619 | #endif // RAPIDJSON_ASSERT_THROWS |
620 | #endif // RAPIDJSON_NOEXCEPT_ASSERT |
621 | |
622 | /////////////////////////////////////////////////////////////////////////////// |
623 | // new/delete |
624 | |
625 | #ifndef RAPIDJSON_NEW |
626 | ///! customization point for global \c new |
627 | #define RAPIDJSON_NEW(TypeName) new TypeName |
628 | #endif |
629 | #ifndef RAPIDJSON_DELETE |
630 | ///! customization point for global \c delete |
631 | #define RAPIDJSON_DELETE(x) delete x |
632 | #endif |
633 | |
634 | /////////////////////////////////////////////////////////////////////////////// |
635 | // Type |
636 | |
637 | /*! \namespace rapidjson |
638 | \brief main RapidJSON namespace |
639 | \see RAPIDJSON_NAMESPACE |
640 | */ |
641 | RAPIDJSON_NAMESPACE_BEGIN |
642 | |
643 | //! Type of JSON value |
644 | enum Type { |
645 | kNullType = 0, //!< null |
646 | kFalseType = 1, //!< false |
647 | kTrueType = 2, //!< true |
648 | kObjectType = 3, //!< object |
649 | kArrayType = 4, //!< array |
650 | kStringType = 5, //!< string |
651 | kNumberType = 6 //!< number |
652 | }; |
653 | |
654 | RAPIDJSON_NAMESPACE_END |
655 | |
656 | #endif // RAPIDJSON_RAPIDJSON_H_ |
657 | |