]>
Commit | Line | Data |
---|---|---|
31f18b77 FG |
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_ |