diff options
author | DongHun Kwak <dh0128.kwak@samsung.com> | 2019-12-05 15:21:30 +0900 |
---|---|---|
committer | DongHun Kwak <dh0128.kwak@samsung.com> | 2019-12-05 15:21:30 +0900 |
commit | d6a306e745acfee00e81ccaf3324a2a03516db41 (patch) | |
tree | 145a26368608982f40ebb0f4836185c44abb9ae4 /boost/spirit | |
parent | 5ce2ccf2f23c6d3de4c79f216f57ca6f2a18ed16 (diff) | |
download | boost-d6a306e745acfee00e81ccaf3324a2a03516db41.tar.gz boost-d6a306e745acfee00e81ccaf3324a2a03516db41.tar.bz2 boost-d6a306e745acfee00e81ccaf3324a2a03516db41.zip |
Imported Upstream version 1.69.0upstream/1.69.0
Diffstat (limited to 'boost/spirit')
24 files changed, 122 insertions, 991 deletions
diff --git a/boost/spirit/home/classic/error_handling/exceptions.hpp b/boost/spirit/home/classic/error_handling/exceptions.hpp index 0fb036a205..224ac468ca 100644 --- a/boost/spirit/home/classic/error_handling/exceptions.hpp +++ b/boost/spirit/home/classic/error_handling/exceptions.hpp @@ -34,7 +34,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN // to allow a single catch handler to catch all exceptions. // /////////////////////////////////////////////////////////////////////////// - class parser_error_base : public std::exception + class BOOST_SYMBOL_VISIBLE parser_error_base : public std::exception { protected: diff --git a/boost/spirit/home/classic/iterator/multi_pass.hpp b/boost/spirit/home/classic/iterator/multi_pass.hpp index 260d2933e5..a4ab6c202e 100644 --- a/boost/spirit/home/classic/iterator/multi_pass.hpp +++ b/boost/spirit/home/classic/iterator/multi_pass.hpp @@ -146,7 +146,7 @@ class first_owner // thrown by buf_id_check CheckingPolicy if an instance of an iterator is // used after another one has invalidated the queue /////////////////////////////////////////////////////////////////////////////// -class illegal_backtracking : public std::exception +class BOOST_SYMBOL_VISIBLE illegal_backtracking : public std::exception { public: diff --git a/boost/spirit/home/classic/utility/loops.hpp b/boost/spirit/home/classic/utility/loops.hpp index 97fc1d3c78..baece7fdcb 100644 --- a/boost/spirit/home/classic/utility/loops.hpp +++ b/boost/spirit/home/classic/utility/loops.hpp @@ -14,6 +14,8 @@ #include <boost/spirit/home/classic/namespace.hpp> #include <boost/spirit/home/classic/core/parser.hpp> #include <boost/spirit/home/classic/core/composite/composite.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_same.hpp> /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { diff --git a/boost/spirit/home/classic/version.hpp b/boost/spirit/home/classic/version.hpp index b0d358a26e..f95532c5a3 100644 --- a/boost/spirit/home/classic/version.hpp +++ b/boost/spirit/home/classic/version.hpp @@ -24,7 +24,7 @@ // This is the version of the current Spirit distribution // /////////////////////////////////////////////////////////////////////////////// -#define SPIRIT_VERSION 0x1809 +#define SPIRIT_VERSION 0x1810 #define SPIRIT_PIZZA_VERSION SPIRIT_MEGA_VEGGI // :-) #endif // defined(SPIRIT_VERSION_HPP) diff --git a/boost/spirit/home/karma/detail/attributes.hpp b/boost/spirit/home/karma/detail/attributes.hpp index c63faace37..a313e319ef 100644 --- a/boost/spirit/home/karma/detail/attributes.hpp +++ b/boost/spirit/home/karma/detail/attributes.hpp @@ -95,14 +95,12 @@ namespace boost { namespace spirit { namespace karma }}} /////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { namespace traits +namespace boost { namespace spirit { namespace traits { namespace detail { template <typename Exposed, typename Transformed> - struct transform_attribute<Exposed, Transformed, karma::domain> + struct transform_attribute_base<Exposed, Transformed, karma::domain> : karma::transform_attribute<Exposed, Transformed> {}; -}}} +}}}} #endif - - diff --git a/boost/spirit/home/karma/detail/output_iterator.hpp b/boost/spirit/home/karma/detail/output_iterator.hpp index 75c984a9bc..fbe3eb3711 100644 --- a/boost/spirit/home/karma/detail/output_iterator.hpp +++ b/boost/spirit/home/karma/detail/output_iterator.hpp @@ -191,7 +191,7 @@ namespace boost { namespace spirit { namespace karma { namespace detail // wchar_t is only 16-bits on Windows. If BOOST_SPIRIT_UNICODE is // defined, the character type is 32-bits wide so we need to make // sure the buffer is at least that wide. -#if defined(BOOST_MSVC) && defined(BOOST_SPIRIT_UNICODE) +#if (defined(_WIN32) || defined(__CYGWIN__)) && defined(BOOST_SPIRIT_UNICODE) typedef spirit::char_encoding::unicode::char_type buffer_char_type; #else typedef wchar_t buffer_char_type; diff --git a/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp b/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp index adbec5b756..5fbbad1228 100644 --- a/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp +++ b/boost/spirit/home/karma/numeric/detail/numeric_utils.hpp @@ -14,6 +14,7 @@ #include <boost/config/no_tr1/cmath.hpp> #include <boost/limits.hpp> +#include <boost/math/special_functions/fpclassify.hpp> #include <boost/type_traits/is_integral.hpp> #include <boost/spirit/home/support/char_class.hpp> #include <boost/spirit/home/support/unused.hpp> diff --git a/boost/spirit/home/qi/detail/attributes.hpp b/boost/spirit/home/qi/detail/attributes.hpp index 6e8ce13f83..c5f5037d8c 100644 --- a/boost/spirit/home/qi/detail/attributes.hpp +++ b/boost/spirit/home/qi/detail/attributes.hpp @@ -143,10 +143,12 @@ namespace boost { namespace spirit { namespace qi /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { namespace traits { - template <typename Exposed, typename Transformed> - struct transform_attribute<Exposed, Transformed, qi::domain> - : qi::transform_attribute<Exposed, Transformed> - {}; + namespace detail { + template <typename Exposed, typename Transformed> + struct transform_attribute_base<Exposed, Transformed, qi::domain> + : qi::transform_attribute<Exposed, Transformed> + {}; + } template <typename Exposed, typename Transformed> struct transform_attribute<Exposed&, Transformed, qi::domain> diff --git a/boost/spirit/home/qi/detail/expectation_failure.hpp b/boost/spirit/home/qi/detail/expectation_failure.hpp index 3571e2f3f1..21ba6895bf 100644 --- a/boost/spirit/home/qi/detail/expectation_failure.hpp +++ b/boost/spirit/home/qi/detail/expectation_failure.hpp @@ -13,11 +13,12 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #include <boost/spirit/home/support/info.hpp> +#include <boost/config.hpp> // for BOOST_SYMBOL_VISIBLE #include <stdexcept> namespace boost { namespace spirit { namespace qi { template <typename Iterator> - struct expectation_failure : std::runtime_error + struct BOOST_SYMBOL_VISIBLE expectation_failure : std::runtime_error { expectation_failure(Iterator first_, Iterator last_, info const& what) : std::runtime_error("boost::spirit::qi::expectation_failure") diff --git a/boost/spirit/home/support/attributes.hpp b/boost/spirit/home/support/attributes.hpp index ceba157fcf..960a8af240 100644 --- a/boost/spirit/home/support/attributes.hpp +++ b/boost/spirit/home/support/attributes.hpp @@ -923,6 +923,14 @@ namespace boost { namespace spirit { namespace traits type; }; + namespace detail { + // Domain-agnostic class template partial specializations and + // type agnostic domain partial specializations are ambious. + // To resolve the ambiguity type agnostic domain partial + // specializations are dispatched via intermediate type. + template <typename Exposed, typename Transformed, typename Domain> + struct transform_attribute_base; + } /////////////////////////////////////////////////////////////////////////// // transform_attribute // @@ -933,7 +941,9 @@ namespace boost { namespace spirit { namespace traits /////////////////////////////////////////////////////////////////////////// template <typename Exposed, typename Transformed, typename Domain , typename Enable/* = void*/> - struct transform_attribute; + struct transform_attribute + : detail::transform_attribute_base<Exposed, Transformed, Domain> + {}; /////////////////////////////////////////////////////////////////////////// template <typename Domain, typename Transformed, typename Exposed> diff --git a/boost/spirit/home/support/detail/endian/endian.hpp b/boost/spirit/home/support/detail/endian/endian.hpp index ac1c13f86a..8ee91c1e63 100644 --- a/boost/spirit/home/support/detail/endian/endian.hpp +++ b/boost/spirit/home/support/detail/endian/endian.hpp @@ -34,7 +34,7 @@ #endif #include <boost/config.hpp> -#include <boost/detail/endian.hpp> +#include <boost/predef/other/endian.h> #define BOOST_MINIMAL_INTEGER_COVER_OPERATORS #define BOOST_NO_IO_COVER_OPERATORS #include <boost/spirit/home/support/detail/endian/cover_operators.hpp> @@ -381,13 +381,13 @@ namespace boost { namespace spirit typedef T value_type; # ifndef BOOST_ENDIAN_NO_CTORS endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT -# ifdef BOOST_BIG_ENDIAN +# if BOOST_ENDIAN_BIG_BYTE explicit endian(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); } # else explicit endian(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); } # endif # endif -# ifdef BOOST_BIG_ENDIAN +# if BOOST_ENDIAN_BIG_BYTE endian & operator=(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); return *this; } operator T() const { return detail::load_big_endian<T, n_bits/8>(m_value); } # else @@ -412,13 +412,13 @@ namespace boost { namespace spirit typedef T value_type; # ifndef BOOST_ENDIAN_NO_CTORS endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT -# ifdef BOOST_BIG_ENDIAN +# if BOOST_ENDIAN_BIG_BYTE endian(T val) : m_value(val) { } # else explicit endian(T val) { detail::store_big_endian<T, sizeof(T)>(&m_value, val); } # endif # endif -# ifdef BOOST_BIG_ENDIAN +# if BOOST_ENDIAN_BIG_BYTE endian & operator=(T val) { m_value = val; return *this; } operator T() const { return m_value; } # else @@ -440,13 +440,13 @@ namespace boost { namespace spirit typedef T value_type; # ifndef BOOST_ENDIAN_NO_CTORS endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT -# ifdef BOOST_LITTLE_ENDIAN +# if BOOST_ENDIAN_LITTLE_BYTE endian(T val) : m_value(val) { } # else explicit endian(T val) { detail::store_little_endian<T, sizeof(T)>(&m_value, val); } # endif # endif -# ifdef BOOST_LITTLE_ENDIAN +# if BOOST_ENDIAN_LITTLE_BYTE endian & operator=(T val) { m_value = val; return *this; } operator T() const { return m_value; } #else diff --git a/boost/spirit/home/support/detail/lexer/runtime_error.hpp b/boost/spirit/home/support/detail/lexer/runtime_error.hpp index 2ab716a517..ab0cfcd201 100644 --- a/boost/spirit/home/support/detail/lexer/runtime_error.hpp +++ b/boost/spirit/home/support/detail/lexer/runtime_error.hpp @@ -6,13 +6,14 @@ #ifndef BOOST_LEXER_RUNTIME_ERROR_HPP #define BOOST_LEXER_RUNTIME_ERROR_HPP +#include <boost/config.hpp> // for BOOST_SYMBOL_VISIBLE #include <stdexcept> namespace boost { namespace lexer { -class runtime_error : public std::runtime_error +class BOOST_SYMBOL_VISIBLE runtime_error : public std::runtime_error { public: runtime_error (const std::string &what_arg_) : diff --git a/boost/spirit/home/support/detail/math/detail/fp_traits.hpp b/boost/spirit/home/support/detail/math/detail/fp_traits.hpp deleted file mode 100644 index 199712a3b9..0000000000 --- a/boost/spirit/home/support/detail/math/detail/fp_traits.hpp +++ /dev/null @@ -1,583 +0,0 @@ -// fp_traits.hpp - -#ifndef BOOST_SPIRIT_MATH_FP_TRAITS_HPP -#define BOOST_SPIRIT_MATH_FP_TRAITS_HPP - -// Copyright (c) 2006 Johan Rade - -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt -// or copy at http://www.boost.org/LICENSE_1_0.txt) - -#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT -# error The VAX floating point mode on VMS is not supported. -#endif - -#if defined(_MSC_VER) -#pragma once -#endif - -#include <cstring> - -#include <boost/assert.hpp> -#include <boost/cstdint.hpp> -#include <boost/detail/endian.hpp> -#include <boost/static_assert.hpp> -#include <boost/type_traits/is_floating_point.hpp> - -//------------------------------------------------------------------------------ - -namespace boost { -namespace spirit { -namespace math { -namespace detail { - -//------------------------------------------------------------------------------ - -/* -Most processors support three different floating point precisions: -single precision (32 bits), double precision (64 bits) -and extended double precision (>64 bits) - -Note that the C++ type long double can be implemented -both as double precision and extended double precision. -*/ - -struct single_precision_tag {}; -struct double_precision_tag {}; -struct extended_double_precision_tag {}; - -//------------------------------------------------------------------------------ - -/* -template<class T, class U> struct fp_traits_impl; - - This is traits class that describes the binary structure of floating - point numbers of C++ type T and precision U - -Requirements: - - T = float, double or long double - U = single_precision_tag, double_precision_tag - or extended_double_precision_tag - -Typedef members: - - bits -- the target type when copying the leading bytes of a floating - point number. It is a typedef for uint32_t or uint64_t. - - coverage -- tells us whether all bytes are copied or not. - It is a typedef for all_bits or not_all_bits. - -Static data members: - - sign, exponent, flag, mantissa -- bit masks that give the meaning of the bits - in the leading bytes. - -Static function members: - - init() -- initializes the static data members, if needed. - (Is a no-op in the specialized versions of the template.) - - get_bits(), set_bits() -- provide access to the leading bytes. -*/ - -struct all_bits {}; -struct not_all_bits {}; - -// Generic version ------------------------------------------------------------- - -// The generic version uses run time initialization to determine the floating -// point format. It is capable of handling most formats, -// but not the Motorola 68K extended double precision format. - -// Currently the generic version is used only for extended double precision -// on Itanium. In all other cases there are specializations of the template -// that use compile time initialization. - -template<class T> struct uint32_t_coverage -{ - typedef not_all_bits type; -}; - -template<> struct uint32_t_coverage<single_precision_tag> -{ - typedef all_bits type; -}; - -template<class T, class U> struct fp_traits_impl -{ - typedef uint32_t bits; - typedef BOOST_DEDUCED_TYPENAME uint32_t_coverage<U>::type coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - static uint32_t exponent; - static uint32_t flag; - static uint32_t mantissa; - - static void init() - { - if(is_init_) return; - do_init_(); - is_init_ = true; - } - - static void get_bits(T x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(T& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - static size_t offset_; - static bool is_init_; - static void do_init_(); -}; - -//.............................................................................. - -template<class T, class U> uint32_t fp_traits_impl<T,U>::exponent; -template<class T, class U> uint32_t fp_traits_impl<T,U>::flag; -template<class T, class U> uint32_t fp_traits_impl<T,U>::mantissa; -template<class T, class U> size_t fp_traits_impl<T,U>::offset_; -template<class T, class U> bool fp_traits_impl<T,U>::is_init_; - -// In a single-threaded program, do_init will be called exactly once. -// In a multi-threaded program, do_init may be called simultaneously -// by more then one thread. That should not be a problem. - -//.............................................................................. - -template<class T, class U> void fp_traits_impl<T,U>::do_init_() -{ - T x = static_cast<T>(3) / static_cast<T>(4); - // sign bit = 0 - // exponent: first and last bit = 0, all other bits = 1 - // flag bit (if present) = 1 - // mantissa: first bit = 1, all other bits = 0 - - uint32_t a; - - for(size_t k = 0; k <= sizeof(T) - 4; ++k) { - - memcpy(&a, reinterpret_cast<unsigned char*>(&x) + k, 4); - - switch(a) { - - case 0x3f400000: // IEEE single precision format - - offset_ = k; - exponent = 0x7f800000; - flag = 0x00000000; - mantissa = 0x007fffff; - return; - - case 0x3fe80000: // IEEE double precision format - // and PowerPC extended double precision format - offset_ = k; - exponent = 0x7ff00000; - flag = 0x00000000; - mantissa = 0x000fffff; - return; - - case 0x3ffe0000: // Motorola extended double precision format - - // Must not get here. Must be handled by specialization. - // To get accurate cutoff between normals and subnormals - // we must use the flag bit that is in the 5th byte. - // Otherwise this cutoff will be off by a factor 2. - // If we do get here, then we have failed to detect the Motorola - // processor at compile time. - - BOOST_ASSERT(false && - "Failed to detect the Motorola processor at compile time"); - return; - - case 0x3ffe8000: // IEEE extended double precision format - // with 15 exponent bits - offset_ = k; - exponent = 0x7fff0000; - flag = 0x00000000; - mantissa = 0x0000ffff; - return; - - case 0x3ffec000: // Intel extended double precision format - - offset_ = k; - exponent = 0x7fff0000; - flag = 0x00008000; - mantissa = 0x00007fff; - return; - - default: - continue; - } - } - - BOOST_ASSERT(false); - - // Unknown format. -} - - -// float (32 bits) ------------------------------------------------------------- - -template<> struct fp_traits_impl<float, single_precision_tag> -{ - typedef uint32_t bits; - typedef all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x007fffff); - - static void init() {} - static void get_bits(float x, uint32_t& a) { memcpy(&a, &x, 4); } - static void set_bits(float& x, uint32_t a) { memcpy(&x, &a, 4); } -}; - - -// double (64 bits) ------------------------------------------------------------ - -#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) - -template<> struct fp_traits_impl<double, double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff); - - static void init() {} - - static void get_bits(double x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(double& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 4); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -//.............................................................................. - -#else - -template<> struct fp_traits_impl<double, double_precision_tag> -{ - typedef uint64_t bits; - typedef all_bits coverage; - - static const uint64_t sign = (uint64_t)0x80000000 << 32; - static const uint64_t exponent = (uint64_t)0x7ff00000 << 32; - static const uint64_t flag = 0; - static const uint64_t mantissa - = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff; - - static void init() {} - static void get_bits(double x, uint64_t& a) { memcpy(&a, &x, 8); } - static void set_bits(double& x, uint64_t a) { memcpy(&x, &a, 8); } -}; - -#endif - - -// long double (64 bits) ------------------------------------------------------- - -#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) - -template<> struct fp_traits_impl<long double, double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff); - - static void init() {} - - static void get_bits(long double x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 4); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -//.............................................................................. - -#else - -template<> struct fp_traits_impl<long double, double_precision_tag> -{ - typedef uint64_t bits; - typedef all_bits coverage; - - static const uint64_t sign = (uint64_t)0x80000000 << 32; - static const uint64_t exponent = (uint64_t)0x7ff00000 << 32; - static const uint64_t flag = 0; - static const uint64_t mantissa - = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff; - - static void init() {} - static void get_bits(long double x, uint64_t& a) { memcpy(&a, &x, 8); } - static void set_bits(long double& x, uint64_t a) { memcpy(&x, &a, 8); } -}; - -#endif - - -// long double (>64 bits), x86 and x64 ----------------------------------------- - -#if defined(__i386) || defined(__i386__) || defined(_M_IX86) \ - || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) \ - || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) - -// Intel extended double precision format (80 bits) - -template<> struct fp_traits_impl<long double, extended_double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff); - - static void init() {} - - static void get_bits(long double x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4); - } -}; - - -// long double (>64 bits), Itanium --------------------------------------------- - -#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64) - -// The floating point format is unknown at compile time -// No template specialization is provided. -// The generic definition is used. - -// The Itanium supports both -// the Intel extended double precision format (80 bits) and -// the IEEE extended double precision format with 15 exponent bits (128 bits). - - -// long double (>64 bits), PowerPC --------------------------------------------- - -#elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \ - || defined(__ppc) || defined(__ppc__) || defined(__PPC__) - -// PowerPC extended double precision format (128 bits) - -template<> struct fp_traits_impl<long double, extended_double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff); - - static void init() {} - - static void get_bits(long double x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 12); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - - -// long double (>64 bits), Motorola 68K ---------------------------------------- - -#elif defined(__m68k) || defined(__m68k__) \ - || defined(__mc68000) || defined(__mc68000__) \ - -// Motorola extended double precision format (96 bits) - -// It is the same format as the Intel extended double precision format, -// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and -// 3) the flag bit is not set for infinity - -template<> struct fp_traits_impl<long double, extended_double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff); - - static void init() {} - - // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding. - - static void get_bits(long double x, uint32_t& a) - { - memcpy(&a, &x, 2); - memcpy(reinterpret_cast<unsigned char*>(&a) + 2, - reinterpret_cast<const unsigned char*>(&x) + 4, 2); - } - - static void set_bits(long double& x, uint32_t a) - { - memcpy(&x, &a, 2); - memcpy(reinterpret_cast<unsigned char*>(&x) + 4, - reinterpret_cast<const unsigned char*>(&a) + 2, 2); - } -}; - - -// long double (>64 bits), All other processors -------------------------------- - -#else - -// IEEE extended double precision format with 15 exponent bits (128 bits) - -template<> struct fp_traits_impl<long double, extended_double_precision_tag> -{ - typedef uint32_t bits; - typedef not_all_bits coverage; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x0000ffff); - - static void init() {} - - static void get_bits(long double x, uint32_t& a) - { - memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 12); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -#endif - - -//------------------------------------------------------------------------------ - -// size_to_precision is a type switch for converting a C++ floating point type -// to the corresponding precision type. - -template<int n> struct size_to_precision; - -template<> struct size_to_precision<4> -{ - typedef single_precision_tag type; -}; - -template<> struct size_to_precision<8> -{ - typedef double_precision_tag type; -}; - -template<> struct size_to_precision<10> -{ - typedef extended_double_precision_tag type; -}; - -template<> struct size_to_precision<12> -{ - typedef extended_double_precision_tag type; -}; - -template<> struct size_to_precision<16> -{ - typedef extended_double_precision_tag type; -}; - -// fp_traits is a type switch that selects the right fp_traits_impl - -template<class T> struct fp_traits -{ - BOOST_STATIC_ASSERT(boost::is_floating_point<T>::value); - typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T)>::type precision; - typedef fp_traits_impl<T, precision> type; -}; - - -//------------------------------------------------------------------------------ - -} // namespace detail -} // namespace math -} // namespace spirit -} // namespace boost - -#endif diff --git a/boost/spirit/home/support/detail/math/fpclassify.hpp b/boost/spirit/home/support/detail/math/fpclassify.hpp deleted file mode 100644 index 3659ec85ea..0000000000 --- a/boost/spirit/home/support/detail/math/fpclassify.hpp +++ /dev/null @@ -1,235 +0,0 @@ -// fpclassify.hpp - -#ifndef BOOST_SPIRIT_MATH_FPCLASSIFY_HPP -#define BOOST_SPIRIT_MATH_FPCLASSIFY_HPP - -// Copyright (c) 2006 Johan Rade - -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt -// or copy at http://www.boost.org/LICENSE_1_0.txt) - -/* -The following algorithm is used: - - If all exponent bits, the flag bit (if there is one), - and all mantissa bits are 0, then the number is zero. - - If all exponent bits and the flag bit (if there is one) are 0, - and at least one mantissa bit is 1, then the number is subnormal. - - If all exponent bits are 1 and all mantissa bits are 0, - then the number is infinity. - - If all exponent bits are 1 and at least one mantissa bit is 1, - then the number is a not-a-number. - - Otherwise the number is normal. - -(Note that the binary representation of infinity -has flag bit 0 for Motorola 68K extended double precision, -and flag bit 1 for Intel extended double precision.) - -To get the bits, the four or eight most significant bytes are copied -into an uint32_t or uint64_t and bit masks are applied. -This covers all the exponent bits and the flag bit (if there is one), -but not always all the mantissa bits. -Some of the functions below have two implementations, -depending on whether all the mantissa bits are copied or not. -*/ - -#if defined(_MSC_VER) -#pragma once -#endif - -#include <cmath> - -#ifndef FP_INFINITE -# define FP_INFINITE 0 -# define FP_NAN 1 -# define FP_NORMAL 2 -# define FP_SUBNORMAL 3 -# define FP_ZERO 4 -#endif - -#include <boost/spirit/home/support/detail/math/detail/fp_traits.hpp> - -namespace boost { -namespace spirit { -namespace math { - -//------------------------------------------------------------------------------ - -template<class T> bool (isfinite)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent; - return a != traits::exponent; -} - -//------------------------------------------------------------------------------ - -template<class T> bool (isnormal)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::flag; - return (a != 0) && (a < traits::exponent); -} - -//------------------------------------------------------------------------------ - -namespace detail { - - template<class T> bool isinf_impl(T x, all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::mantissa; - return a == traits::exponent; - } - - template<class T> bool isinf_impl(T x, not_all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::mantissa; - if(a != traits::exponent) - return false; - - traits::set_bits(x,0); - return x == 0; - } - -} // namespace detail - -template<class T> bool (isinf)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - return detail::isinf_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage()); -} - -//------------------------------------------------------------------------------ - -namespace detail { - - template<class T> bool isnan_impl(T x, all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::mantissa; - return a > traits::exponent; - } - - template<class T> bool isnan_impl(T x, not_all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - - a &= traits::exponent | traits::mantissa; - if(a < traits::exponent) - return false; - - a &= traits::mantissa; - traits::set_bits(x,a); - return x != 0; - } - -} // namespace detail - -template<class T> bool (isnan)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - return detail::isnan_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage()); -} - -//------------------------------------------------------------------------------ - -namespace detail { - - template<class T> int fpclassify_impl(T x, all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::flag | traits::mantissa; - - if(a <= traits::mantissa) { - if(a == 0) - return FP_ZERO; - else - return FP_SUBNORMAL; - } - - if(a < traits::exponent) - return FP_NORMAL; - - a &= traits::mantissa; - if(a == 0) - return FP_INFINITE; - - return FP_NAN; - } - - template<class T> int fpclassify_impl(T x, not_all_bits) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::exponent | traits::flag | traits::mantissa; - - if(a <= traits::mantissa) { - if(x == 0) - return FP_ZERO; - else - return FP_SUBNORMAL; - } - - if(a < traits::exponent) - return FP_NORMAL; - - a &= traits::mantissa; - traits::set_bits(x,a); - if(x == 0) - return FP_INFINITE; - - return FP_NAN; - } - -} // namespace detail - -template<class T> int (fpclassify)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - return detail::fpclassify_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage()); -} - -//------------------------------------------------------------------------------ - -} // namespace math -} // namespace spirit -} // namespace boost - -#endif diff --git a/boost/spirit/home/support/detail/math/signbit.hpp b/boost/spirit/home/support/detail/math/signbit.hpp deleted file mode 100644 index 045fc3a8f0..0000000000 --- a/boost/spirit/home/support/detail/math/signbit.hpp +++ /dev/null @@ -1,92 +0,0 @@ -// signbit.hpp - -#ifndef BOOST_SPIRIT_MATH_SIGNBIT_HPP -#define BOOST_SPIRIT_MATH_SIGNBIT_HPP - -// Copyright (c) 2006 Johan Rade - -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt -// or copy at http://www.boost.org/LICENSE_1_0.txt) - -#if defined(_MSC_VER) -#pragma once -#endif - -#include <boost/spirit/home/support/detail/math/detail/fp_traits.hpp> - -namespace boost { -namespace spirit { -namespace math { - -//------------------------------------------------------------------------------ - -template<class T> bool (signbit)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= traits::sign; - return a != 0; -} - -//------------------------------------------------------------------------------ - -namespace detail { - - template<class T> T copysign_impl(T x, T y) - { - typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a &= ~traits::sign; - - BOOST_DEDUCED_TYPENAME traits::bits b; - traits::get_bits(y,b); - b &= traits::sign; - - traits::set_bits(x,a|b); - return x; - } -} - -inline float (copysign)(float x, float y) // magnitude of x and sign of y -{ - return detail::copysign_impl(x,y); -} - -inline double (copysign)(double x, double y) -{ - return detail::copysign_impl(x,y); -} - -inline long double (copysign)(long double x, long double y) -{ - return detail::copysign_impl(x,y); -} - -//------------------------------------------------------------------------------ - -template<class T> T (changesign)(T x) -{ - typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits; - traits::init(); - - BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); - a ^= traits::sign; - traits::set_bits(x,a); - return x; -} - -//------------------------------------------------------------------------------ - -} // namespace math -} // namespace spirit -} // namespace boost - -#endif diff --git a/boost/spirit/home/support/detail/sign.hpp b/boost/spirit/home/support/detail/sign.hpp index 7c1bfb06c7..a04552a527 100644 --- a/boost/spirit/home/support/detail/sign.hpp +++ b/boost/spirit/home/support/detail/sign.hpp @@ -13,58 +13,21 @@ #pragma once #endif -#include <boost/config/no_tr1/cmath.hpp> -#include <boost/version.hpp> -#if BOOST_VERSION < 104000 -#include <boost/spirit/home/support/detail/math/fpclassify.hpp> -#include <boost/spirit/home/support/detail/math/signbit.hpp> -#else -#include <boost/math/special_functions/fpclassify.hpp> #include <boost/math/special_functions/sign.hpp> -#endif namespace boost { namespace spirit { namespace detail { -#if BOOST_VERSION < 104000 - // signbit(-NAN) is broken for versions of Boost earlier than 1.40.0 - // This routine has been taken and adapted from Johan Rade's fp_traits - // library - template<typename T> - inline bool (signbit)(T x) - { - return (boost::spirit::math::signbit)(x); - } - - template<typename T> - inline T (changesign)(T x) - { - return (boost::spirit::math::changesign)(x); - } -#else template<typename T> inline bool (signbit)(T x) { return (boost::math::signbit)(x) ? true : false; } - // This routine has been taken and adapted from Johan Rade's fp_traits - // library template<typename T> inline T (changesign)(T x) { -#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) - return -x; -#else - typedef typename math::detail::fp_traits<T>::type traits_type; - - typename traits_type::bits a; - traits_type::get_bits(x, a); - a ^= traits_type::sign; - traits_type::set_bits(x, a); - return x; -#endif + return (boost::math::changesign)(x); } -#endif }}} diff --git a/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp b/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp index 9df2d9c151..e732330354 100644 --- a/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp +++ b/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp @@ -20,7 +20,7 @@ namespace boost { namespace spirit { namespace iterator_policies // thrown by buf_id_check CheckingPolicy if an instance of an iterator is // used after another one has invalidated the queue /////////////////////////////////////////////////////////////////////////// - class illegal_backtracking : public std::exception + class BOOST_SYMBOL_VISIBLE illegal_backtracking : public std::exception { public: illegal_backtracking() throw() {} diff --git a/boost/spirit/home/support/utf8.hpp b/boost/spirit/home/support/utf8.hpp index c4883428b1..8b67f505e5 100644 --- a/boost/spirit/home/support/utf8.hpp +++ b/boost/spirit/home/support/utf8.hpp @@ -67,6 +67,44 @@ namespace boost { namespace spirit } return result; } + + // Assume wchar_t content is UTF-16 on Windows and UCS-4 on Unix +#if defined(_WIN32) || defined(__CYGWIN__) + inline utf8_string to_utf8(wchar_t value) + { + utf8_string result; + typedef std::back_insert_iterator<utf8_string> insert_iter; + insert_iter out_iter(result); + utf8_output_iterator<insert_iter> utf8_iter(out_iter); + + u16_to_u32_iterator<wchar_t const*, ucs4_char> ucs4_iter(&value); + *utf8_iter++ = *ucs4_iter; + + return result; + } + + inline utf8_string to_utf8(wchar_t const* str) + { + utf8_string result; + typedef std::back_insert_iterator<utf8_string> insert_iter; + insert_iter out_iter(result); + utf8_output_iterator<insert_iter> utf8_iter(out_iter); + + u16_to_u32_iterator<wchar_t const*, ucs4_char> ucs4_iter(str); + for (ucs4_char c; (c = *ucs4_iter) != ucs4_char(); ++ucs4_iter) { + *utf8_iter++ = c; + } + + return result; + } + + template <typename Traits, typename Allocator> + inline utf8_string + to_utf8(std::basic_string<wchar_t, Traits, Allocator> const& str) + { + return to_utf8(str.c_str()); + } +#endif }} #endif diff --git a/boost/spirit/home/support/utree/utree.hpp b/boost/spirit/home/support/utree/utree.hpp index 67120e90aa..a00fcffbf3 100644 --- a/boost/spirit/home/support/utree/utree.hpp +++ b/boost/spirit/home/support/utree/utree.hpp @@ -43,7 +43,7 @@ namespace boost { namespace spirit { //[utree_exceptions /*` All exceptions thrown by utree are derived from utree_exception. */ - struct utree_exception : std::exception {}; + struct BOOST_SYMBOL_VISIBLE utree_exception : std::exception {}; /*`The `bad_type_exception` is thrown whenever somebody calls a member function, which applies to certain stored utree_type's only, but this diff --git a/boost/spirit/home/x3/directive/expect.hpp b/boost/spirit/home/x3/directive/expect.hpp index 418ecf9b0d..c57e4eb604 100644 --- a/boost/spirit/home/x3/directive/expect.hpp +++ b/boost/spirit/home/x3/directive/expect.hpp @@ -11,13 +11,14 @@ #include <boost/spirit/home/x3/core/parser.hpp> #include <boost/spirit/home/x3/core/detail/parse_into_container.hpp> +#include <boost/config.hpp> // for BOOST_SYMBOL_VISIBLE #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace spirit { namespace x3 { template <typename Iterator> - struct expectation_failure : std::runtime_error + struct BOOST_SYMBOL_VISIBLE expectation_failure : std::runtime_error { public: diff --git a/boost/spirit/home/x3/support/numeric_utils/sign.hpp b/boost/spirit/home/x3/support/numeric_utils/sign.hpp index 3ca326f3ec..4665925ceb 100644 --- a/boost/spirit/home/x3/support/numeric_utils/sign.hpp +++ b/boost/spirit/home/x3/support/numeric_utils/sign.hpp @@ -9,8 +9,6 @@ #if !defined(BOOST_SPIRIT_X3_SIGN_MAR_11_2009_0734PM) #define BOOST_SPIRIT_X3_SIGN_MAR_11_2009_0734PM -#include <boost/config/no_tr1/cmath.hpp> -#include <boost/math/special_functions/fpclassify.hpp> #include <boost/math/special_functions/sign.hpp> namespace boost { namespace spirit { namespace x3 @@ -21,22 +19,10 @@ namespace boost { namespace spirit { namespace x3 return (boost::math::signbit)(x) ? true : false; } - // This routine has been taken and adapted from Johan Rade's fp_traits - // library template<typename T> inline T (changesign)(T x) { -#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) - return -x; -#else - typedef typename math::detail::fp_traits<T>::type traits_type; - - typename traits_type::bits a; - traits_type::get_bits(x, a); - a ^= traits_type::sign; - traits_type::set_bits(x, a); - return x; -#endif + return (boost::math::changesign)(x); } }}} diff --git a/boost/spirit/home/x3/support/utility/utf8.hpp b/boost/spirit/home/x3/support/utility/utf8.hpp index b141cce6d2..e2df577f6e 100644 --- a/boost/spirit/home/x3/support/utility/utf8.hpp +++ b/boost/spirit/home/x3/support/utility/utf8.hpp @@ -62,6 +62,44 @@ namespace boost { namespace spirit { namespace x3 } return result; } + + // Assume wchar_t content is UTF-16 on Windows and UCS-4 on Unix +#if defined(_WIN32) || defined(__CYGWIN__) + inline utf8_string to_utf8(wchar_t value) + { + utf8_string result; + typedef std::back_insert_iterator<utf8_string> insert_iter; + insert_iter out_iter(result); + utf8_output_iterator<insert_iter> utf8_iter(out_iter); + + u16_to_u32_iterator<wchar_t const*, ucs4_char> ucs4_iter(&value); + *utf8_iter++ = *ucs4_iter; + + return result; + } + + inline utf8_string to_utf8(wchar_t const* str) + { + utf8_string result; + typedef std::back_insert_iterator<utf8_string> insert_iter; + insert_iter out_iter(result); + utf8_output_iterator<insert_iter> utf8_iter(out_iter); + + u16_to_u32_iterator<wchar_t const*, ucs4_char> ucs4_iter(str); + for (ucs4_char c; (c = *ucs4_iter) != ucs4_char(); ++ucs4_iter) { + *utf8_iter++ = c; + } + + return result; + } + + template <typename Traits, typename Allocator> + inline utf8_string + to_utf8(std::basic_string<wchar_t, Traits, Allocator> const& str) + { + return to_utf8(str.c_str()); + } +#endif }}} #endif diff --git a/boost/spirit/home/x3/version.hpp b/boost/spirit/home/x3/version.hpp index ae82b4da96..2a3795870e 100644 --- a/boost/spirit/home/x3/version.hpp +++ b/boost/spirit/home/x3/version.hpp @@ -14,6 +14,6 @@ // This is the version of the current Spirit X3 distribution // /////////////////////////////////////////////////////////////////////////////// -#define SPIRIT_X3_VERSION 0x3002 +#define SPIRIT_X3_VERSION 0x3003 #endif diff --git a/boost/spirit/include/version.hpp b/boost/spirit/include/version.hpp index 342df38768..abf82161cb 100644 --- a/boost/spirit/include/version.hpp +++ b/boost/spirit/include/version.hpp @@ -14,7 +14,7 @@ // This is the version of the current Spirit distribution // /////////////////////////////////////////////////////////////////////////////// -#define SPIRIT_VERSION 0x2056 +#define SPIRIT_VERSION 0x2057 #define SPIRIT_PIZZA_VERSION SUPER_HOT_SPANISH_SARDINES // :-O #endif |