diff options
Diffstat (limited to 'include/jsoncons/config')
| -rw-r--r-- | include/jsoncons/config/binary_config.hpp | 226 | ||||
| -rw-r--r-- | include/jsoncons/config/compiler_support.hpp | 389 | ||||
| -rw-r--r-- | include/jsoncons/config/jsoncons_config.hpp | 308 | ||||
| -rw-r--r-- | include/jsoncons/config/version.hpp | 40 |
4 files changed, 963 insertions, 0 deletions
diff --git a/include/jsoncons/config/binary_config.hpp b/include/jsoncons/config/binary_config.hpp new file mode 100644 index 0000000..51b52a8 --- /dev/null +++ b/include/jsoncons/config/binary_config.hpp @@ -0,0 +1,226 @@ +// Copyright 2017 Daniel Parker +// Distributed under the Boost license, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See https://github.com/danielaparker/jsoncons for latest version + +#ifndef JSONCONS_CONFIG_BINARY_CONFIG_HPP +#define JSONCONS_CONFIG_BINARY_CONFIG_HPP + +#include <cfloat> +#include <cstddef> +#include <cstdint> +#include <cstring> // std::memcpy +#include <memory> +#include <type_traits> // std::enable_if + +// The definitions below follow the definitions in compiler_support_p.h, https://github.com/01org/tinycbor +// MIT license + +#ifdef __F16C__ +# include <immintrin.h> +#endif + +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif + +#if defined(__GNUC__) +#if (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) || (__has_builtin(__builtin_bswap64) && __has_builtin(__builtin_bswap32)) +# define JSONCONS_BYTE_SWAP_64 __builtin_bswap64 +# define JSONCONS_BYTE_SWAP_32 __builtin_bswap32 +# ifdef __INTEL_COMPILER +# define JSONCONS_BYTE_SWAP_16 _bswap16 +# elif (__GNUC__ * 100 + __GNUC_MINOR__ >= 608) || __has_builtin(__builtin_bswap16) +# define JSONCONS_BYTE_SWAP_16 __builtin_bswap16 +# endif +#endif +#elif defined(__sun) +# include <sys/byteorder.h> +#elif defined(_MSC_VER) +// MSVC, which implies sizeof(long) == 4 +# define JSONCONS_BYTE_SWAP_64 _byteswap_uint64 +# define JSONCONS_BYTE_SWAP_32 _byteswap_ulong +# define JSONCONS_BYTE_SWAP_16 _byteswap_ushort +#endif + +namespace jsoncons { +namespace binary { + + struct uint128_holder + { + uint64_t lo; + uint64_t hi; + }; + + static inline bool add_check_overflow(std::size_t v1, std::size_t v2, std::size_t *r) + { + #if ((defined(__GNUC__) && (__GNUC__ >= 5)) && !defined(__INTEL_COMPILER)) || __has_builtin(__builtin_add_overflow) + return __builtin_add_overflow(v1, v2, r); + #else + // unsigned additions are well-defined + *r = v1 + v2; + return v1 > v1 + v2; + #endif + } + + #if defined(__apple_build_version__) && ((__clang_major__ < 8) || ((__clang_major__ == 8) && (__clang_minor__ < 1))) + #define APPLE_MISSING_INTRINSICS 1 + #endif + + inline + uint16_t encode_half(double val) + { + #if defined(__F16C__) && !defined(APPLE_MISSING_INTRINSICS) + return _cvtss_sh((float)val, 3); + #else + uint64_t v; + std::memcpy(&v, &val, sizeof(v)); + int64_t sign = static_cast<int64_t>(v >> 63 << 15); + int64_t exp = (v >> 52) & 0x7ff; + int64_t mant = v << 12 >> 12 >> (53-11); /* keep only the 11 most significant bits of the mantissa */ + exp -= 1023; + if (exp == 1024) { + /* infinity or NaN */ + exp = 16; + mant >>= 1; + } else if (exp >= 16) { + /* overflow, as largest number */ + exp = 15; + mant = 1023; + } else if (exp >= -14) { + /* regular normal */ + } else if (exp >= -24) { + /* subnormal */ + mant |= 1024; + mant >>= -(exp + 14); + exp = -15; + } else { + /* underflow, make zero */ + return 0; + } + + /* safe cast here as bit operations above guarantee not to overflow */ + return static_cast<uint16_t>(sign | ((exp + 15) << 10) | mant); + #endif + } + + /* this function was copied & adapted from RFC 7049 Appendix D */ + inline + double decode_half(uint16_t half) + { + #if defined(__F16C__) && !defined(APPLE_MISSING_INTRINSICS) + return _cvtsh_ss(half); + #else + int64_t exp = (half >> 10) & 0x1f; + int64_t mant = half & 0x3ff; + double val; + if (exp == 0) + { + val = ldexp(static_cast<double>(mant), -24); + } + else if (exp != 31) + { + val = ldexp(static_cast<double>(mant) + 1024.0, static_cast<int>(exp - 25)); + } + else + { + val = mant == 0 ? std::numeric_limits<double>::infinity() : std::nan(""); + } + return half & 0x8000 ? -val : val; + #endif + } + + // byte_swap + + template<class T> + typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(uint8_t),T>::type + byte_swap(T val) + { + return val; + } + + template<class T> + typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(uint16_t),T>::type + byte_swap(T val) + { + #if defined(JSONCONS_BYTE_SWAP_16) + return JSONCONS_BYTE_SWAP_16(val); + #else + return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8); + #endif + } + + template<class T> + typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(uint32_t),T>::type + byte_swap(T val) + { + #if defined(JSONCONS_BYTE_SWAP_32) + return JSONCONS_BYTE_SWAP_32(val); + #else + uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff); + return (tmp << 16) | (tmp >> 16); + #endif + } + + template<class T> + typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(uint64_t),T>::type + byte_swap(T val) + { + #if defined(JSONCONS_BYTE_SWAP_64) + return JSONCONS_BYTE_SWAP_64(val); + #else + uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32); + tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16); + return ((tmp & 0x00ff00ff00ff00ffull) << 8) | ((tmp & 0xff00ff00ff00ff00ull) >> 8); + #endif + } + + template<class T> + typename std::enable_if<std::is_floating_point<T>::value && sizeof(T) == sizeof(uint32_t),T>::type + byte_swap(T val) + { + uint32_t x; + std::memcpy(&x,&val,sizeof(uint32_t)); + uint32_t y = byte_swap(x); + T val2; + std::memcpy(&val2,&y,sizeof(uint32_t)); + return val2; + } + + template<class T> + typename std::enable_if<std::is_floating_point<T>::value && sizeof(T) == sizeof(uint64_t),T>::type + byte_swap(T val) + { + uint64_t x; + std::memcpy(&x,&val,sizeof(uint64_t)); + uint64_t y = byte_swap(x); + T val2; + std::memcpy(&val2,&y,sizeof(uint64_t)); + return val2; + } + + template<class T> + typename std::enable_if<std::is_floating_point<T>::value && sizeof(T) == 2*sizeof(uint64_t),T>::type + byte_swap(T val) + { + uint128_holder x; + uint8_t buf[2*sizeof(uint64_t)]; + std::memcpy(buf,&val,2*sizeof(uint64_t)); + std::memcpy(&x.lo,buf,sizeof(uint64_t)); + std::memcpy(&x.hi,buf+sizeof(uint64_t),sizeof(uint64_t)); + + uint128_holder y; + y.lo = byte_swap(x.hi); + y.hi = byte_swap(x.lo); + + T val2; + std::memcpy(&val2,&y,2*sizeof(uint64_t)); + + return val2; + } + +} // binary +} // jsoncons + +#endif diff --git a/include/jsoncons/config/compiler_support.hpp b/include/jsoncons/config/compiler_support.hpp new file mode 100644 index 0000000..15d30cf --- /dev/null +++ b/include/jsoncons/config/compiler_support.hpp @@ -0,0 +1,389 @@ +// Copyright 2013 Daniel Parker +// Distributed under the Boost license, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See https://github.com/danielaparker/jsoncons for latest version + +#ifndef JSONCONS_COMPILER_SUPPORT_HPP +#define JSONCONS_COMPILER_SUPPORT_HPP + +#include <stdexcept> +#include <string> +#include <cmath> +#include <exception> +#include <ostream> + +#if defined (__clang__) +#define JSONCONS_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) +#endif + +// Uncomment the following line to suppress deprecated names (recommended for new code) +//#define JSONCONS_NO_DEPRECATED + +// The definitions below follow the definitions in compiler_support_p.h, https://github.com/01org/tinycbor +// MIT license + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54577 +#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ < 9 +#define JSONCONS_NO_VECTOR_ERASE_TAKES_CONST_ITERATOR 1 +#define JSONCONS_NO_MAP_CONS_TAKES_ALLOCATOR 1 +#endif + +#if defined(__clang__) +# define JSONCONS_FALLTHROUGH [[clang::fallthrough]] +#elif defined(__GNUC__) && ((__GNUC__ >= 7)) +# define JSONCONS_FALLTHROUGH __attribute__((fallthrough)) +#elif defined (__GNUC__) +# define JSONCONS_FALLTHROUGH // FALLTHRU +#else +# define JSONCONS_FALLTHROUGH +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1) +#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) +#define JSONCONS_UNREACHABLE() __builtin_unreachable() +#elif defined(_MSC_VER) +#define JSONCONS_LIKELY(x) x +#define JSONCONS_UNLIKELY(x) x +#define JSONCONS_UNREACHABLE() __assume(0) +#else +#define JSONCONS_LIKELY(x) x +#define JSONCONS_UNLIKELY(x) x +#define JSONCONS_UNREACHABLE() do {} while (0) +#endif + +// Deprecated symbols markup +#if (defined(__cplusplus) && __cplusplus >= 201402L) +#define JSONCONS_DEPRECATED_MSG(msg) [[deprecated(msg)]] +#endif + +#if !defined(JSONCONS_DEPRECATED_MSG) && defined(__GNUC__) && defined(__has_extension) +#if __has_extension(attribute_deprecated_with_message) +#define JSONCONS_DEPRECATED_MSG(msg) __attribute__((deprecated(msg))) +#endif +#endif + +#if !defined(JSONCONS_DEPRECATED_MSG) && defined(_MSC_VER) +#if (_MSC_VER) >= 1920 +#define JSONCONS_DEPRECATED_MSG(msg) [[deprecated(msg)]] +#else +#define JSONCONS_DEPRECATED_MSG(msg) __declspec(deprecated(msg)) +#endif +#endif + +// Following boost/atomic/detail/config.hpp +#if !defined(JSONCONS_DEPRECATED_MSG) && (\ + (defined(__GNUC__) && ((__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0)) >= 405) ||\ + (defined(__SUNPRO_CC) && (__SUNPRO_CC + 0) >= 0x5130)) + #define JSONCONS_DEPRECATED_MSG(msg) __attribute__((deprecated(msg))) +#endif + +#if !defined(JSONCONS_DEPRECATED_MSG) && defined(__clang__) && defined(__has_extension) + #if __has_extension(attribute_deprecated_with_message) + #define JSONCONS_DEPRECATED_MSG(msg) __attribute__((deprecated(msg))) + #else + #define JSONCONS_DEPRECATED_MSG(msg) __attribute__((deprecated)) + #endif +#endif + +#if !defined(JSONCONS_DEPRECATED_MSG) +#define JSONCONS_DEPRECATED_MSG(msg) +#endif + +#if defined(ANDROID) || defined(__ANDROID__) +#if __ANDROID_API__ >= 21 +#define JSONCONS_HAS_STRTOLD_L +#else +#define JSONCONS_NO_LOCALECONV +#endif +#endif + +#if defined(_MSC_VER) +#define JSONCONS_HAS_MSC_STRTOD_L +#define JSONCONS_HAS_FOPEN_S +#endif + +#ifndef JSONCONS_HAS_CP14 + #if defined(_MSVC_LANG) + #if _MSVC_LANG >= 201402L + #define JSONCONS_HAS_CP14 + #endif + #elif __cplusplus >= 201402L + #define JSONCONS_HAS_CP14 + #endif +#endif + +#if !defined(JSONCONS_HAS_STD_FROM_CHARS) +# if defined(__GNUC__) +# if (__GNUC__ >= 11) +# if (__cplusplus >= 201703) +# define JSONCONS_HAS_STD_FROM_CHARS 1 +# endif // (__cplusplus >= 201703) +# endif // (__GNUC__ >= 11) +# endif // defined(__GNUC__) +# if defined(_MSC_VER) +# if (_MSC_VER >= 1924 && _MSVC_LANG >= 201703) +# define JSONCONS_HAS_STD_FROM_CHARS 1 +# endif // (_MSC_VER >= 1924 && MSVC_LANG >= 201703) +# endif // defined(_MSC_VER) +#endif +#if defined(JSONCONS_HAS_STD_FROM_CHARS) +#include <charconv> +#endif + +#if !defined(JSONCONS_HAS_2017) +# if defined(__clang__) +# if (__cplusplus >= 201703) +# define JSONCONS_HAS_2017 1 +# endif // (__cplusplus >= 201703) +# endif // defined(__clang__) +# if defined(__GNUC__) +# if (__GNUC__ >= 7) +# if (__cplusplus >= 201703) +# define JSONCONS_HAS_2017 1 +# endif // (__cplusplus >= 201703) +# endif // (__GNUC__ >= 7) +# endif // defined(__GNUC__) +# if defined(_MSC_VER) +# if (_MSC_VER >= 1910 && _MSVC_LANG >= 201703) +# define JSONCONS_HAS_2017 1 +# endif // (_MSC_VER >= 1910 && MSVC_LANG >= 201703) +# endif // defined(_MSC_VER) +#endif + +#if defined(JSONCONS_HAS_2017) + #define JSONCONS_NODISCARD [[nodiscard]] + #define JSONCONS_IF_CONSTEXPR if constexpr +#else + #define JSONCONS_NODISCARD + #define JSONCONS_IF_CONSTEXPR if +#endif + +#if !defined(JSONCONS_HAS_STD_STRING_VIEW) +# if (defined JSONCONS_HAS_2017) +# if defined(__clang__) +# if __has_include(<string_view>) +# define JSONCONS_HAS_STD_STRING_VIEW 1 +# endif // __has_include(<string_view>) +# else +# define JSONCONS_HAS_STD_STRING_VIEW 1 +# endif +# endif // defined(JSONCONS_HAS_2017) +#endif // !defined(JSONCONS_HAS_STD_STRING_VIEW) + +#if !defined(JSONCONS_HAS_STD_BYTE) +# if (defined JSONCONS_HAS_2017) +# define JSONCONS_HAS_STD_BYTE 1 +# endif // defined(JSONCONS_HAS_2017) +#endif // !defined(JSONCONS_HAS_STD_BYTE) + +#if !defined(JSONCONS_HAS_STD_OPTIONAL) +# if (defined JSONCONS_HAS_2017) +# if defined(__clang__) +# if __has_include(<optional>) +# define JSONCONS_HAS_STD_OPTIONAL 1 +# endif // __has_include(<string_view>) +# else +# define JSONCONS_HAS_STD_OPTIONAL 1 +# endif +# endif // defined(JSONCONS_HAS_2017) +#endif // !defined(JSONCONS_HAS_STD_OPTIONAL) + +#if !defined(JSONCONS_HAS_STD_VARIANT) +# if (defined JSONCONS_HAS_2017) +# if defined(__clang__) +# if defined(__APPLE__) +# if JSONCONS_CLANG_VERSION >= 100001 +# define JSONCONS_HAS_STD_VARIANT 1 +# endif +# elif __has_include(<variant>) +# define JSONCONS_HAS_STD_VARIANT 1 +# endif // __has_include(<variant>) +# else +# define JSONCONS_HAS_STD_VARIANT 1 +# endif +# endif // defined(JSONCONS_HAS_2017) +#endif // !defined(JSONCONS_HAS_STD_VARIANT) + +#if !defined(JSONCONS_HAS_FILESYSTEM) +# if (defined JSONCONS_HAS_2017) +# if defined(__clang__) +# if __has_include(<filesystem>) +# define JSONCONS_HAS_FILESYSTEM 1 +# endif // __has_include(<filesystem>) +# else +# define JSONCONS_HAS_FILESYSTEM 1 +# endif +# endif // defined(JSONCONS_HAS_2017) +#endif // !defined(JSONCONS_HAS_FILESYSTEM) + +#if (!defined(JSONCONS_NO_EXCEPTIONS)) +// Check if exceptions are disabled. +# if defined( __cpp_exceptions) && __cpp_exceptions == 0 +# define JSONCONS_NO_EXCEPTIONS 1 +# endif +#endif + +#if !defined(JSONCONS_NO_EXCEPTIONS) + +#if defined(__GNUC__) && !__EXCEPTIONS +# define JSONCONS_NO_EXCEPTIONS 1 +#elif _MSC_VER +#if defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0 +# define JSONCONS_NO_EXCEPTIONS 1 +#elif !defined(_CPPUNWIND) +# define JSONCONS_NO_EXCEPTIONS 1 +#endif +#endif +#endif + +// allow to disable exceptions +#if !defined(JSONCONS_NO_EXCEPTIONS) + #define JSONCONS_THROW(exception) throw exception + #define JSONCONS_RETHROW throw + #define JSONCONS_TRY try + #define JSONCONS_CATCH(exception) catch(exception) +#else + #define JSONCONS_THROW(exception) std::terminate() + #define JSONCONS_RETHROW std::terminate() + #define JSONCONS_TRY if (true) + #define JSONCONS_CATCH(exception) if (false) +#endif + +#if !defined(JSONCONS_HAS_STD_MAKE_UNIQUE) + #if defined(__clang__) && defined(__cplusplus) + #if defined(__APPLE__) + #if __clang_major__ >= 6 && __cplusplus >= 201402L // Xcode 6 + #define JSONCONS_HAS_STD_MAKE_UNIQUE + #endif + #elif ((__clang_major__*100 +__clang_minor__) >= 340) && __cplusplus >= 201402L + #define JSONCONS_HAS_STD_MAKE_UNIQUE + #endif + #elif defined(__GNUC__) + #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L + #define JSONCONS_HAS_STD_MAKE_UNIQUE + #endif + #elif defined(_MSC_VER) + #if _MSC_VER >= 1800 + #define JSONCONS_HAS_STD_MAKE_UNIQUE + #endif + #endif +#endif // !defined(JSONCONS_HAS_STD_MAKE_UNIQUE) + +#ifndef JSONCONS_HAS_CP14_CONSTEXPR + #if defined(_MSC_VER) + #if _MSC_VER >= 1910 + #define JSONCONS_HAS_CP14_CONSTEXPR + #endif + #elif defined(__GNUC__) + #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 600 && __cplusplus >= 201402L + #define JSONCONS_HAS_CP14_CONSTEXPR + #endif + #endif +#endif + +#if defined(JSONCONS_HAS_CP14_CONSTEXPR) +# define JSONCONS_CPP14_CONSTEXPR constexpr +#else +# define JSONCONS_CPP14_CONSTEXPR +#endif + +// Follows boost + +// gcc and clang +#if (defined(__clang__) || defined(__GNUC__)) && defined(__cplusplus) +#if defined(__SIZEOF_INT128__) && !defined(_MSC_VER) +# define JSONCONS_HAS_INT128 +#endif + +#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC) +#if (__clang_major__ >= 4) && defined(__has_include) +#if __has_include(<quadmath.h>) +# define JSONCONS_HAS_FLOAT128 +#endif +#endif +#endif +#endif + +#if defined(__GNUC__) +#if defined(_GLIBCXX_USE_FLOAT128) +# define JSONCONS_HAS_FLOAT128 +#endif +#endif + +#if defined(__clang__) +#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC) +#if (__clang_major__ >= 4) && defined(__has_include) +#if __has_include(<quadmath.h>) +# define JSONCONS_HAS_FLOAT128 +#endif +#endif +#endif +#endif + +// Follows boost config/detail/suffix.hpp +#if defined(JSONCONS_HAS_INT128) && defined(__cplusplus) +namespace jsoncons{ +# ifdef __GNUC__ + __extension__ typedef __int128 int128_type; + __extension__ typedef unsigned __int128 uint128_type; +# else + typedef __int128 int128_type; + typedef unsigned __int128 uint128_type; +# endif +} +#endif +#if defined(JSONCONS_HAS_FLOAT128) && defined(__cplusplus) +namespace jsoncons { +# ifdef __GNUC__ + __extension__ typedef __float128 float128_type; +# else + typedef __float128 float128_type; +# endif +} +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1900 + #define JSONCONS_COPY(first,last,d_first) std::copy(first, last, stdext::make_checked_array_iterator(d_first, static_cast<std::size_t>(std::distance(first, last)))) +#else + #define JSONCONS_COPY(first,last,d_first) std::copy(first, last, d_first) +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1900 +#define JSONCONS_CONSTEXPR +#else +#define JSONCONS_CONSTEXPR constexpr +#endif + +namespace jsoncons { + + class assertion_error : public std::runtime_error + { + public: + assertion_error(const std::string& s) noexcept + : std::runtime_error(s) + { + } + const char* what() const noexcept override + { + return std::runtime_error::what(); + } + }; + +} // namespace jsoncons + +#define JSONCONS_STR2(x) #x +#define JSONCONS_STR(x) JSONCONS_STR2(x) + +#ifdef _DEBUG +#define JSONCONS_ASSERT(x) if (!(x)) { \ + JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at " __FILE__ ":" \ + JSONCONS_STR(__LINE__))); } +#else +#define JSONCONS_ASSERT(x) if (!(x)) { \ + JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ + JSONCONS_STR( 0 ))); } +#endif // _DEBUG + +#endif // JSONCONS_COMPILER_SUPPORT_HPP diff --git a/include/jsoncons/config/jsoncons_config.hpp b/include/jsoncons/config/jsoncons_config.hpp new file mode 100644 index 0000000..63c437b --- /dev/null +++ b/include/jsoncons/config/jsoncons_config.hpp @@ -0,0 +1,308 @@ +// Copyright 2019 Daniel Parker +// Distributed under the Boost license, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See https://github.com/danielaparker/jsoncons for latest version + +#ifndef JSONCONS_CONFIG_JSONCONS_CONFIG_HPP +#define JSONCONS_CONFIG_JSONCONS_CONFIG_HPP + +#include <type_traits> +#include <limits> +#include <jsoncons/config/compiler_support.hpp> +#include <jsoncons/config/binary_config.hpp> + +#if !defined(JSONCONS_HAS_STD_STRING_VIEW) +#include <jsoncons/detail/string_view.hpp> +namespace jsoncons { +using jsoncons::detail::basic_string_view; +using string_view = basic_string_view<char, std::char_traits<char>>; +using wstring_view = basic_string_view<wchar_t, std::char_traits<wchar_t>>; +} +#else +#include <string_view> +namespace jsoncons { +using std::basic_string_view; +using std::string_view; +using std::wstring_view; +} +#endif + +#if !defined(JSONCONS_HAS_STD_SPAN) +#include <jsoncons/detail/span.hpp> +namespace jsoncons { +using jsoncons::detail::span; +} +#else +#include <span> +namespace jsoncons { +using std::span; +} +#endif + +#if defined(JSONCONS_HAS_STD_OPTIONAL) + #include <optional> + namespace jsoncons { + using std::optional; + } +#elif defined(JSONCONS_HAS_BOOST_OPTIONAL) + #include <boost/optional.hpp> + namespace jsoncons { + using boost::optional; + } +#else + #include <jsoncons/detail/optional.hpp> + namespace jsoncons { + using jsoncons::detail::optional; +} +#endif // !defined(JSONCONS_HAS_STD_OPTIONAL) + +#if !defined(JSONCONS_HAS_STD_ENDIAN) +#include <jsoncons/detail/endian.hpp> +namespace jsoncons { +using jsoncons::detail::endian; +} +#else +#include <bit> +namespace jsoncons +{ + using std::endian; +} +#endif + +#if !defined(JSONCONS_HAS_STD_MAKE_UNIQUE) + +#include <cstddef> +#include <memory> +#include <type_traits> +#include <utility> + +namespace jsoncons { + + template<class T> + struct unique_if + { + using value_is_not_array = std::unique_ptr<T>; + }; + + template<class T> + struct unique_if<T[]> + { + typedef std::unique_ptr<T[]> value_is_array_of_unknown_bound; + }; + + template<class T, std::size_t N> + struct unique_if<T[N]> { + using value_is_array_of_known_bound = void; + }; + + template<class T, class... Args> + typename unique_if<T>::value_is_not_array + make_unique(Args&&... args) + { + return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); + } + + template<class T> + typename unique_if<T>::value_is_array_of_unknown_bound + make_unique(std::size_t n) + { + using U = typename std::remove_extent<T>::type; + return std::unique_ptr<T>(new U[n]()); + } + + template<class T, class... Args> + typename unique_if<T>::value_is_array_of_known_bound + make_unique(Args&&...) = delete; +} // jsoncons + +#else + +#include <memory> +namespace jsoncons +{ + using std::make_unique; +} + +#endif // !defined(JSONCONS_HAS_STD_MAKE_UNIQUE) + +namespace jsoncons { +namespace binary { + + // native_to_big + + template<typename T, class OutputIt, class Endian=endian> + typename std::enable_if<Endian::native == Endian::big,void>::type + native_to_big(T val, OutputIt d_first) + { + uint8_t buf[sizeof(T)]; + std::memcpy(buf, &val, sizeof(T)); + for (auto item : buf) + { + *d_first++ = item; + } + } + + template<typename T, class OutputIt, class Endian=endian> + typename std::enable_if<Endian::native == Endian::little,void>::type + native_to_big(T val, OutputIt d_first) + { + T val2 = byte_swap(val); + uint8_t buf[sizeof(T)]; + std::memcpy(buf, &val2, sizeof(T)); + for (auto item : buf) + { + *d_first++ = item; + } + } + + // native_to_little + + template<typename T, class OutputIt, class Endian = endian> + typename std::enable_if<Endian::native == Endian::little,void>::type + native_to_little(T val, OutputIt d_first) + { + uint8_t buf[sizeof(T)]; + std::memcpy(buf, &val, sizeof(T)); + for (auto item : buf) + { + *d_first++ = item; + } + } + + template<typename T, class OutputIt, class Endian=endian> + typename std::enable_if<Endian::native == Endian::big, void>::type + native_to_little(T val, OutputIt d_first) + { + T val2 = byte_swap(val); + uint8_t buf[sizeof(T)]; + std::memcpy(buf, &val2, sizeof(T)); + for (auto item : buf) + { + *d_first++ = item; + } + } + + // big_to_native + + template<class T,class Endian=endian> + typename std::enable_if<Endian::native == Endian::big,T>::type + big_to_native(const uint8_t* first, std::size_t count) + { + if (sizeof(T) > count) + { + return T{}; + } + T val; + std::memcpy(&val,first,sizeof(T)); + return val; + } + + template<class T,class Endian=endian> + typename std::enable_if<Endian::native == Endian::little,T>::type + big_to_native(const uint8_t* first, std::size_t count) + { + if (sizeof(T) > count) + { + return T{}; + } + T val; + std::memcpy(&val,first,sizeof(T)); + return byte_swap(val); + } + + // little_to_native + + template<class T,class Endian=endian> + typename std::enable_if<Endian::native == Endian::little,T>::type + little_to_native(const uint8_t* first, std::size_t count) + { + if (sizeof(T) > count) + { + return T{}; + } + T val; + std::memcpy(&val,first,sizeof(T)); + return val; + } + + template<class T,class Endian=endian> + typename std::enable_if<Endian::native == Endian::big,T>::type + little_to_native(const uint8_t* first, std::size_t count) + { + if (sizeof(T) > count) + { + return T{}; + } + T val; + std::memcpy(&val,first,sizeof(T)); + return byte_swap(val); + } + +} // binary +} // jsoncons + +namespace jsoncons { + + template<typename CharT> + constexpr const CharT* cstring_constant_of_type(const char* c, const wchar_t* w); + + template<> inline + constexpr const char* cstring_constant_of_type<char>(const char* c, const wchar_t*) + { + return c; + } + template<> inline + constexpr const wchar_t* cstring_constant_of_type<wchar_t>(const char*, const wchar_t* w) + { + return w; + } + + template<typename CharT> + std::basic_string<CharT> string_constant_of_type(const char* c, const wchar_t* w); + + template<> inline + std::string string_constant_of_type<char>(const char* c, const wchar_t*) + { + return std::string(c); + } + template<> inline + std::wstring string_constant_of_type<wchar_t>(const char*, const wchar_t* w) + { + return std::wstring(w); + } + + template<typename CharT> + jsoncons::basic_string_view<CharT> string_view_constant_of_type(const char* c, const wchar_t* w); + + template<> inline + jsoncons::string_view string_view_constant_of_type<char>(const char* c, const wchar_t*) + { + return jsoncons::string_view(c); + } + template<> inline + jsoncons::wstring_view string_view_constant_of_type<wchar_t>(const char*, const wchar_t* w) + { + return jsoncons::wstring_view(w); + } + +} // jsoncons + +#define JSONCONS_EXPAND(X) X +#define JSONCONS_QUOTE(Prefix, A) JSONCONS_EXPAND(Prefix ## #A) + +#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_QUOTE(L, Str)) +#define JSONCONS_STRING_CONSTANT(CharT, Str) string_constant_of_type<CharT>(Str, JSONCONS_QUOTE(L, Str)) +#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type<CharT>(Str, JSONCONS_QUOTE(L, Str)) + +#if defined(__clang__) +#define JSONCONS_HAS_STD_REGEX 1 +#elif (defined(__GNUC__) && (__GNUC__ == 4)) && (defined(__GNUC__) && __GNUC_MINOR__ < 9) +// GCC 4.8 has broken regex support: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53631 +#else +#define JSONCONS_HAS_STD_REGEX 1 +#endif + +#endif // JSONCONS_CONFIG_JSONCONS_CONFIG_HPP + + diff --git a/include/jsoncons/config/version.hpp b/include/jsoncons/config/version.hpp new file mode 100644 index 0000000..7f11eef --- /dev/null +++ b/include/jsoncons/config/version.hpp @@ -0,0 +1,40 @@ +// Copyright 2017 Daniel Parker +// Distributed under the Boost license, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See https://github.com/danielaparker/jsoncons for latest version + +#ifndef JSONCONS_VERSION_HPP +#define JSONCONS_VERSION_HPP + +#include <iostream> + +#define JSONCONS_VERSION_MAJOR 0 +#define JSONCONS_VERSION_MINOR 168 +#define JSONCONS_VERSION_PATCH 7 + +namespace jsoncons { + +struct versioning_info +{ + unsigned int const major; + unsigned int const minor; + unsigned int const patch; + + friend std::ostream& operator<<(std::ostream& os, const versioning_info& ver) + { + os << ver.major << '.' + << ver.minor << '.' + << ver.patch; + return os; + } +}; + +constexpr versioning_info version() +{ + return versioning_info{JSONCONS_VERSION_MAJOR, JSONCONS_VERSION_MINOR, JSONCONS_VERSION_PATCH}; +} + +} + +#endif |