diff options
Diffstat (limited to 'boost/lexical_cast/detail')
| -rw-r--r-- | boost/lexical_cast/detail/converter_lexical.hpp | 520 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/converter_lexical_streams.hpp | 817 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/converter_numeric.hpp | 179 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/inf_nan.hpp | 197 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/is_character.hpp | 57 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/lcast_char_constants.hpp | 46 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/lcast_float_converters.hpp | 294 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/lcast_unsigned_converters.hpp | 295 | ||||
| -rw-r--r-- | boost/lexical_cast/detail/widest_char.hpp | 40 |
9 files changed, 2445 insertions, 0 deletions
diff --git a/boost/lexical_cast/detail/converter_lexical.hpp b/boost/lexical_cast/detail/converter_lexical.hpp new file mode 100644 index 0000000000..ee9f5f132e --- /dev/null +++ b/boost/lexical_cast/detail/converter_lexical.hpp @@ -0,0 +1,520 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP +#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) +#define BOOST_LCAST_NO_WCHAR_T +#endif + +#include <cstddef> +#include <string> +#include <boost/limits.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/ice.hpp> +#include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/is_float.hpp> +#include <boost/type_traits/has_left_shift.hpp> +#include <boost/type_traits/has_right_shift.hpp> +#include <boost/static_assert.hpp> +#include <boost/detail/lcast_precision.hpp> + +#include <boost/lexical_cast/detail/widest_char.hpp> +#include <boost/lexical_cast/detail/is_character.hpp> + +#ifndef BOOST_NO_CXX11_HDR_ARRAY +#include <array> +#endif + +#include <boost/array.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/container/container_fwd.hpp> + +#include <boost/lexical_cast/detail/converter_lexical_streams.hpp> + +namespace boost { + + namespace detail // normalize_single_byte_char<Char> + { + // Converts signed/unsigned char to char + template < class Char > + struct normalize_single_byte_char + { + typedef Char type; + }; + + template <> + struct normalize_single_byte_char< signed char > + { + typedef char type; + }; + + template <> + struct normalize_single_byte_char< unsigned char > + { + typedef char type; + }; + } + + namespace detail // deduce_character_type_later<T> + { + // Helper type, meaning that stram character for T must be deduced + // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) + template < class T > struct deduce_character_type_later {}; + } + + namespace detail // stream_char_common<T> + { + // Selectors to choose stream character type (common for Source and Target) + // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types + // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>) + template < typename Type > + struct stream_char_common: public boost::mpl::if_c< + boost::detail::is_character< Type >::value, + Type, + boost::detail::deduce_character_type_later< Type > + > {}; + + template < typename Char > + struct stream_char_common< Char* >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< Char* > + > {}; + + template < typename Char > + struct stream_char_common< const Char* >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< const Char* > + > {}; + + template < typename Char > + struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< boost::iterator_range< Char* > > + > {}; + + template < typename Char > + struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > > + > {}; + + template < class Char, class Traits, class Alloc > + struct stream_char_common< std::basic_string< Char, Traits, Alloc > > + { + typedef Char type; + }; + + template < class Char, class Traits, class Alloc > + struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > > + { + typedef Char type; + }; + + template < typename Char, std::size_t N > + struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< boost::array< Char, N > > + > {}; + + template < typename Char, std::size_t N > + struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< boost::array< const Char, N > > + > {}; + +#ifndef BOOST_NO_CXX11_HDR_ARRAY + template < typename Char, std::size_t N > + struct stream_char_common< std::array<Char, N > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< std::array< Char, N > > + > {}; + + template < typename Char, std::size_t N > + struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c< + boost::detail::is_character< Char >::value, + Char, + boost::detail::deduce_character_type_later< std::array< const Char, N > > + > {}; +#endif + +#ifdef BOOST_HAS_INT128 + template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {}; + template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {}; +#endif + +#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T) + template <> + struct stream_char_common< wchar_t > + { + typedef char type; + }; +#endif + } + + namespace detail // deduce_source_char_impl<T> + { + // If type T is `deduce_character_type_later` type, then tries to deduce + // character type using boost::has_left_shift<T> metafunction. + // Otherwise supplied type T is a character type, that must be normalized + // using normalize_single_byte_char<Char>. + // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) + template < class Char > + struct deduce_source_char_impl + { + typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type; + }; + + template < class T > + struct deduce_source_char_impl< deduce_character_type_later< T > > + { + typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t; + +#if defined(BOOST_LCAST_NO_WCHAR_T) + BOOST_STATIC_ASSERT_MSG((result_t::value), + "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation"); + typedef char type; +#else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + result_t::value, char, wchar_t + >::type type; + + BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value), + "Source type is neither std::ostream`able nor std::wostream`able"); +#endif + }; + } + + namespace detail // deduce_target_char_impl<T> + { + // If type T is `deduce_character_type_later` type, then tries to deduce + // character type using boost::has_right_shift<T> metafunction. + // Otherwise supplied type T is a character type, that must be normalized + // using normalize_single_byte_char<Char>. + // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) + template < class Char > + struct deduce_target_char_impl + { + typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type; + }; + + template < class T > + struct deduce_target_char_impl< deduce_character_type_later<T> > + { + typedef boost::has_right_shift<std::basic_istream<char>, T > result_t; + +#if defined(BOOST_LCAST_NO_WCHAR_T) + BOOST_STATIC_ASSERT_MSG((result_t::value), + "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation"); + typedef char type; +#else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + result_t::value, char, wchar_t + >::type type; + + BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value), + "Target type is neither std::istream`able nor std::wistream`able"); +#endif + }; + } + + namespace detail // deduce_target_char<T> and deduce_source_char<T> + { + // We deduce stream character types in two stages. + // + // Stage 1 is common for Target and Source. At Stage 1 we get + // non normalized character type (may contain unsigned/signed char) + // or deduce_character_type_later<T> where T is the original type. + // Stage 1 is executed by stream_char_common<T> + // + // At Stage 2 we normalize character types or try to deduce character + // type using metafunctions. + // Stage 2 is executed by deduce_target_char_impl<T> and + // deduce_source_char_impl<T> + // + // deduce_target_char<T> and deduce_source_char<T> functions combine + // both stages + + template < class T > + struct deduce_target_char + { + typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type; + typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type; + + typedef stage2_type type; + }; + + template < class T > + struct deduce_source_char + { + typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type; + typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type; + + typedef stage2_type type; + }; + } + + namespace detail // extract_char_traits template + { + // We are attempting to get char_traits<> from T + // template parameter. Otherwise we'll be using std::char_traits<Char> + template < class Char, class T > + struct extract_char_traits + : boost::false_type + { + typedef std::char_traits< Char > trait_t; + }; + + template < class Char, class Traits, class Alloc > + struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > > + : boost::true_type + { + typedef Traits trait_t; + }; + + template < class Char, class Traits, class Alloc> + struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > > + : boost::true_type + { + typedef Traits trait_t; + }; + } + + namespace detail // array_to_pointer_decay<T> + { + template<class T> + struct array_to_pointer_decay + { + typedef T type; + }; + + template<class T, std::size_t N> + struct array_to_pointer_decay<T[N]> + { + typedef const T * type; + }; + } + + namespace detail // is_this_float_conversion_optimized<Float, Char> + { + // this metafunction evaluates to true, if we have optimized comnversion + // from Float type to Char array. + // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...) + template <typename Float, typename Char> + struct is_this_float_conversion_optimized + { + typedef boost::type_traits::ice_and< + boost::is_float<Float>::value, +#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__) + boost::type_traits::ice_or< + boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value, + boost::is_same<Char, wchar_t>::value + >::value +#else + boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value +#endif + > result_type; + + BOOST_STATIC_CONSTANT(bool, value = (result_type::value) ); + }; + } + + namespace detail // lcast_src_length + { + // Return max. length of string representation of Source; + template< class Source, // Source type of lexical_cast. + class Enable = void // helper type + > + struct lcast_src_length + { + BOOST_STATIC_CONSTANT(std::size_t, value = 1); + }; + + // Helper for integral types. + // Notes on length calculation: + // Max length for 32bit int with grouping "\1" and thousands_sep ',': + // "-2,1,4,7,4,8,3,6,4,7" + // ^ - is_signed + // ^ - 1 digit not counted by digits10 + // ^^^^^^^^^^^^^^^^^^ - digits10 * 2 + // + // Constant is_specialized is used instead of constant 1 + // to prevent buffer overflow in a rare case when + // <boost/limits.hpp> doesn't add missing specialization for + // numeric_limits<T> for some integral type T. + // When is_specialized is false, the whole expression is 0. + template <class Source> + struct lcast_src_length< + Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type + > + { +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + BOOST_STATIC_CONSTANT(std::size_t, value = + std::numeric_limits<Source>::is_signed + + std::numeric_limits<Source>::is_specialized + /* == 1 */ + std::numeric_limits<Source>::digits10 * 2 + ); +#else + BOOST_STATIC_CONSTANT(std::size_t, value = 156); + BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256); +#endif + }; + +#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION + // Helper for floating point types. + // -1.23456789e-123456 + // ^ sign + // ^ leading digit + // ^ decimal point + // ^^^^^^^^ lcast_precision<Source>::value + // ^ "e" + // ^ exponent sign + // ^^^^^^ exponent (assumed 6 or less digits) + // sign + leading digit + decimal point + "e" + exponent sign == 5 + template<class Source> + struct lcast_src_length< + Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type + > + { + BOOST_STATIC_ASSERT( + std::numeric_limits<Source>::max_exponent10 <= 999999L && + std::numeric_limits<Source>::min_exponent10 >= -999999L + ); + + BOOST_STATIC_CONSTANT(std::size_t, value = + 5 + lcast_precision<Source>::value + 6 + ); + }; +#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION + } + + namespace detail // lexical_cast_stream_traits<Source, Target> + { + template <class Source, class Target> + struct lexical_cast_stream_traits { + typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src; + typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type no_cv_src; + + typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc; + typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t; + typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t; + + typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char< + target_char_t, src_char_t + >::type char_type; + +#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS) + BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value + && !boost::is_same<char16_t, target_char_t>::value), + "Your compiler does not have full support for char16_t" ); +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS) + BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value + && !boost::is_same<char32_t, target_char_t>::value), + "Your compiler does not have full support for char32_t" ); +#endif + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + boost::detail::extract_char_traits<char_type, Target>::value, + BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>, + BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src> + >::type::trait_t traits; + + typedef boost::type_traits::ice_and< + boost::is_same<char, src_char_t>::value, // source is not a wide character based type + boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value, // target type is based on wide character + boost::type_traits::ice_not< + boost::detail::is_character<no_cv_src>::value // single character widening is optimized + >::value // and does not requires stringbuffer + > is_string_widening_required_t; + + typedef boost::type_traits::ice_not< boost::type_traits::ice_or< + boost::is_integral<no_cv_src>::value, + boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value, + boost::detail::is_character< + BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1 + >::value // then we have no optimization for that type + >::value > is_source_input_not_optimized_t; + + // If we have an optimized conversion for + // Source, we do not need to construct stringbuf. + BOOST_STATIC_CONSTANT(bool, requires_stringbuf = + (boost::type_traits::ice_or< + is_string_widening_required_t::value, is_source_input_not_optimized_t::value + >::value) + ); + + typedef boost::detail::lcast_src_length<no_cv_src> len_t; + }; + } + + namespace detail + { + template<typename Target, typename Source> + struct lexical_converter_impl + { + typedef lexical_cast_stream_traits<Source, Target> stream_trait; + + typedef detail::lexical_istream_limited_src< + BOOST_DEDUCED_TYPENAME stream_trait::char_type, + BOOST_DEDUCED_TYPENAME stream_trait::traits, + stream_trait::requires_stringbuf, + stream_trait::len_t::value + 1 + > i_interpreter_type; + + typedef detail::lexical_ostream_limited_src< + BOOST_DEDUCED_TYPENAME stream_trait::char_type, + BOOST_DEDUCED_TYPENAME stream_trait::traits + > o_interpreter_type; + + static inline bool try_convert(const Source& arg, Target& result) { + i_interpreter_type i_interpreter; + + // Disabling ADL, by directly specifying operators. + if (!(i_interpreter.operator <<(arg))) + return false; + + o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend()); + + // Disabling ADL, by directly specifying operators. + if(!(out.operator >>(result))) + return false; + + return true; + } + }; + } + +} // namespace boost + +#undef BOOST_LCAST_NO_WCHAR_T + +#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP + diff --git a/boost/lexical_cast/detail/converter_lexical_streams.hpp b/boost/lexical_cast/detail/converter_lexical_streams.hpp new file mode 100644 index 0000000000..7f8cfd946e --- /dev/null +++ b/boost/lexical_cast/detail/converter_lexical_streams.hpp @@ -0,0 +1,817 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP +#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + + +#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) +#define BOOST_LCAST_NO_WCHAR_T +#endif + +#include <cstddef> +#include <string> +#include <cstring> +#include <cstdio> +#include <boost/limits.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/ice.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/static_assert.hpp> +#include <boost/detail/workaround.hpp> + + +#ifndef BOOST_NO_STD_LOCALE +# include <locale> +#else +# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + // Getting error at this point means, that your STL library is old/lame/misconfigured. + // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE, + // but beware: lexical_cast will understand only 'C' locale delimeters and thousands + // separators. +# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force " +# error "boost::lexical_cast to use only 'C' locale during conversions." +# endif +#endif + +#ifdef BOOST_NO_STRINGSTREAM +#include <strstream> +#else +#include <sstream> +#endif + +#include <boost/lexical_cast/detail/lcast_char_constants.hpp> +#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp> +#include <boost/lexical_cast/detail/inf_nan.hpp> +#include <boost/lexical_cast/detail/lcast_float_converters.hpp> + +#include <istream> + +#ifndef BOOST_NO_CXX11_HDR_ARRAY +#include <array> +#endif + +#include <boost/array.hpp> +#include <boost/type_traits/make_unsigned.hpp> +#include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/is_float.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/container/container_fwd.hpp> +#include <boost/integer.hpp> +#include <boost/detail/basic_pointerbuf.hpp> +#include <boost/noncopyable.hpp> +#ifndef BOOST_NO_CWCHAR +# include <cwchar> +#endif + +namespace boost { + + namespace detail // basic_unlockedbuf + { + // acts as a stream buffer which wraps around a pair of pointers + // and gives acces to internals + template <class BufferType, class CharT> + class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> { + public: + typedef basic_pointerbuf<CharT, BufferType> base_type; + typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize; + +#ifndef BOOST_NO_USING_TEMPLATE + using base_type::pptr; + using base_type::pbase; + using base_type::setbuf; +#else + charT* pptr() const { return base_type::pptr(); } + charT* pbase() const { return base_type::pbase(); } + BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); } +#endif + }; + } + + namespace detail + { + struct do_not_construct_out_stream_t{}; + + template <class CharT, class Traits> + struct out_stream_helper_trait { +#if defined(BOOST_NO_STRINGSTREAM) + typedef std::ostrstream out_stream_t; + typedef void buffer_t; +#elif defined(BOOST_NO_STD_LOCALE) + typedef std::ostringstream out_stream_t; + typedef basic_unlockedbuf<std::streambuf, char> buffer_t; +#else + typedef std::basic_ostringstream<CharT, Traits> + out_stream_t; + typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT> + buffer_t; +#endif + }; + } + + namespace detail // optimized stream wrappers + { + template< class CharT // a result of widest_char transformation + , class Traits + , bool RequiresStringbuffer + , std::size_t CharacterBufferSize + > + class lexical_istream_limited_src: boost::noncopyable { + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t + buffer_t; + + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t + out_stream_t; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + RequiresStringbuffer, + out_stream_t, + do_not_construct_out_stream_t + >::type deduced_out_stream_t; + + // A string representation of Source is written to `buffer`. + deduced_out_stream_t out_stream; + CharT buffer[CharacterBufferSize]; + + // After the `operator <<` finishes, `[start, finish)` is + // the range to output by `operator >>` + const CharT* start; + const CharT* finish; + + public: + lexical_istream_limited_src() BOOST_NOEXCEPT + : start(buffer) + , finish(buffer + CharacterBufferSize) + {} + + const CharT* cbegin() const BOOST_NOEXCEPT { + return start; + } + + const CharT* cend() const BOOST_NOEXCEPT { + return finish; + } + + private: + // Undefined: + lexical_istream_limited_src(lexical_istream_limited_src const&); + void operator=(lexical_istream_limited_src const&); + +/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/ + bool shl_char(CharT ch) BOOST_NOEXCEPT { + Traits::assign(buffer[0], ch); + finish = start + 1; + return true; + } + +#ifndef BOOST_LCAST_NO_WCHAR_T + template <class T> + bool shl_char(T ch) { + BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) , + "boost::lexical_cast does not support narrowing of char types." + "Use boost::locale instead" ); +#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + std::locale loc; + CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch); +#else + CharT const w = static_cast<CharT>(ch); +#endif + Traits::assign(buffer[0], w); + finish = start + 1; + return true; + } +#endif + + bool shl_char_array(CharT const* str) BOOST_NOEXCEPT { + start = str; + finish = start + Traits::length(str); + return true; + } + + template <class T> + bool shl_char_array(T const* str) { + BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)), + "boost::lexical_cast does not support narrowing of char types." + "Use boost::locale instead" ); + return shl_input_streamable(str); + } + + bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT { + start = str; + finish = std::find(start, start + max_size, Traits::to_char_type(0)); + return true; + } + + template<typename InputStreamable> + bool shl_input_streamable(InputStreamable& input) { +#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE) + // If you have compilation error at this point, than your STL library + // does not support such conversions. Try updating it. + BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value)); +#endif + +#ifndef BOOST_NO_EXCEPTIONS + out_stream.exceptions(std::ios::badbit); + try { +#endif + bool const result = !(out_stream << input).fail(); + const buffer_t* const p = static_cast<buffer_t*>( + static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf()) + ); + start = p->pbase(); + finish = p->pptr(); + return result; +#ifndef BOOST_NO_EXCEPTIONS + } catch (const ::std::ios_base::failure& /*f*/) { + return false; + } +#endif + } + + template <class T> + inline bool shl_unsigned(const T n) { + CharT* tmp_finish = buffer + CharacterBufferSize; + start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert(); + finish = tmp_finish; + return true; + } + + template <class T> + inline bool shl_signed(const T n) { + CharT* tmp_finish = buffer + CharacterBufferSize; + typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype; + CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert(); + if (n < 0) { + --tmp_start; + CharT const minus = lcast_char_constants<CharT>::minus; + Traits::assign(*tmp_start, minus); + } + start = tmp_start; + finish = tmp_finish; + return true; + } + + template <class T, class SomeCharT> + bool shl_real_type(const T& val, SomeCharT* /*begin*/) { + lcast_set_precision(out_stream, &val); + return shl_input_streamable(val); + } + + bool shl_real_type(float val, char* begin) { + using namespace std; + const double val_as_double = val; + finish = start + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + sprintf_s(begin, CharacterBufferSize, +#else + sprintf(begin, +#endif + "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double); + return finish > start; + } + + bool shl_real_type(double val, char* begin) { + using namespace std; + finish = start + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + sprintf_s(begin, CharacterBufferSize, +#else + sprintf(begin, +#endif + "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val); + return finish > start; + } + +#ifndef __MINGW32__ + bool shl_real_type(long double val, char* begin) { + using namespace std; + finish = start + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + sprintf_s(begin, CharacterBufferSize, +#else + sprintf(begin, +#endif + "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val ); + return finish > start; + } +#endif + + +#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__) + bool shl_real_type(float val, wchar_t* begin) { + using namespace std; + const double val_as_double = val; + finish = start + swprintf(begin, CharacterBufferSize, + L"%.*g", + static_cast<int>(boost::detail::lcast_get_precision<float >()), + val_as_double ); + return finish > start; + } + + bool shl_real_type(double val, wchar_t* begin) { + using namespace std; + finish = start + swprintf(begin, CharacterBufferSize, + L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val ); + return finish > start; + } + + bool shl_real_type(long double val, wchar_t* begin) { + using namespace std; + finish = start + swprintf(begin, CharacterBufferSize, + L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val ); + return finish > start; + } +#endif + template <class T> + bool shl_real(T val) { + CharT* tmp_finish = buffer + CharacterBufferSize; + if (put_inf_nan(buffer, tmp_finish, val)) { + finish = tmp_finish; + return true; + } + + return shl_real_type(val, static_cast<CharT*>(buffer)); + } + +/************************************ OPERATORS << ( ... ) ********************************/ + public: + template<class Alloc> + bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT { + start = str.data(); + finish = start + str.length(); + return true; + } + + template<class Alloc> + bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT { + start = str.data(); + finish = start + str.length(); + return true; + } + + bool operator<<(bool value) BOOST_NOEXCEPT { + CharT const czero = lcast_char_constants<CharT>::zero; + Traits::assign(buffer[0], Traits::to_char_type(czero + value)); + finish = start + 1; + return true; + } + + template <class C> + BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type + operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range<const C*>(rng.begin(), rng.end()); + } + + bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT { + start = rng.begin(); + finish = rng.end(); + return true; + } + + bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range<const char*>( + reinterpret_cast<const char*>(rng.begin()), + reinterpret_cast<const char*>(rng.end()) + ); + } + + bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT { + return (*this) << iterator_range<const char*>( + reinterpret_cast<const char*>(rng.begin()), + reinterpret_cast<const char*>(rng.end()) + ); + } + + bool operator<<(char ch) { return shl_char(ch); } + bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); } + bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); } +#if !defined(BOOST_LCAST_NO_WCHAR_T) + bool operator<<(wchar_t const* str) { return shl_char_array(str); } + bool operator<<(wchar_t * str) { return shl_char_array(str); } +#ifndef BOOST_NO_INTRINSIC_WCHAR_T + bool operator<<(wchar_t ch) { return shl_char(ch); } +#endif +#endif +#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + bool operator<<(char16_t ch) { return shl_char(ch); } + bool operator<<(char16_t * str) { return shl_char_array(str); } + bool operator<<(char16_t const * str) { return shl_char_array(str); } +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + bool operator<<(char32_t ch) { return shl_char(ch); } + bool operator<<(char32_t * str) { return shl_char_array(str); } + bool operator<<(char32_t const * str) { return shl_char_array(str); } +#endif + bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); } + bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); } + bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); } + bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); } + bool operator<<(char const* str) { return shl_char_array(str); } + bool operator<<(char* str) { return shl_char_array(str); } + bool operator<<(short n) { return shl_signed(n); } + bool operator<<(int n) { return shl_signed(n); } + bool operator<<(long n) { return shl_signed(n); } + bool operator<<(unsigned short n) { return shl_unsigned(n); } + bool operator<<(unsigned int n) { return shl_unsigned(n); } + bool operator<<(unsigned long n) { return shl_unsigned(n); } + +#if defined(BOOST_HAS_LONG_LONG) + bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); } + bool operator<<(boost::long_long_type n) { return shl_signed(n); } +#elif defined(BOOST_HAS_MS_INT64) + bool operator<<(unsigned __int64 n) { return shl_unsigned(n); } + bool operator<<( __int64 n) { return shl_signed(n); } +#endif + +#ifdef BOOST_HAS_INT128 + bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); } + bool operator<<(const boost::int128_type& n) { return shl_signed(n); } +#endif + bool operator<<(float val) { return shl_real(val); } + bool operator<<(double val) { return shl_real(val); } + bool operator<<(long double val) { +#ifndef __MINGW32__ + return shl_real(val); +#else + return shl_real(static_cast<double>(val)); +#endif + } + + // Adding constness to characters. Constness does not change layout + template <class C, std::size_t N> + BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type + operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)), + "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout." + ); + return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input)); + } + + template <std::size_t N> + bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT { + return shl_char_array_limited(input.begin(), N); + } + + template <std::size_t N> + bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT { + return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); + } + + template <std::size_t N> + bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT { + return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); + } + +#ifndef BOOST_NO_CXX11_HDR_ARRAY + // Making a Boost.Array from std::array + template <class C, std::size_t N> + bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)), + "std::array and boost::array must have exactly the same layout. " + "Bug in implementation of std::array or boost::array." + ); + return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input)); + } +#endif + template <class InStreamable> + bool operator<<(const InStreamable& input) { return shl_input_streamable(input); } + }; + + + template <class CharT, class Traits> + class lexical_ostream_limited_src: boost::noncopyable { + //`[start, finish)` is the range to output by `operator >>` + const CharT* start; + const CharT* const finish; + + public: + lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT + : start(begin) + , finish(end) + {} + +/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/ + private: + template <typename Type> + bool shr_unsigned(Type& output) { + if (start == finish) return false; + CharT const minus = lcast_char_constants<CharT>::minus; + CharT const plus = lcast_char_constants<CharT>::plus; + bool const has_minus = Traits::eq(minus, *start); + + /* We won`t use `start' any more, so no need in decrementing it after */ + if (has_minus || Traits::eq(plus, *start)) { + ++start; + } + + bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert(); + + if (has_minus) { + output = static_cast<Type>(0u - output); + } + + return succeed; + } + + template <typename Type> + bool shr_signed(Type& output) { + if (start == finish) return false; + CharT const minus = lcast_char_constants<CharT>::minus; + CharT const plus = lcast_char_constants<CharT>::plus; + typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype; + utype out_tmp = 0; + bool const has_minus = Traits::eq(minus, *start); + + /* We won`t use `start' any more, so no need in decrementing it after */ + if (has_minus || Traits::eq(plus, *start)) { + ++start; + } + + bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert(); + if (has_minus) { + utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits); + succeed = succeed && out_tmp<=comp_val; + output = static_cast<Type>(0u - out_tmp); + } else { + utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)()); + succeed = succeed && out_tmp<=comp_val; + output = static_cast<Type>(out_tmp); + } + return succeed; + } + + template<typename InputStreamable> + bool shr_using_base_class(InputStreamable& output) + { + BOOST_STATIC_ASSERT_MSG( + (!boost::is_pointer<InputStreamable>::value), + "boost::lexical_cast can not convert to pointers" + ); + +#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE) + BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value), + "boost::lexical_cast can not convert, because your STL library does not " + "support such conversions. Try updating it." + ); +#endif + typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t + buffer_t; + +#if defined(BOOST_NO_STRINGSTREAM) + std::istrstream stream(start, finish - start); +#else + + buffer_t buf; + // Usually `istream` and `basic_istream` do not modify + // content of buffer; `buffer_t` assures that this is true + buf.setbuf(const_cast<CharT*>(start), finish - start); +#if defined(BOOST_NO_STD_LOCALE) + std::istream stream(&buf); +#else + std::basic_istream<CharT, Traits> stream(&buf); +#endif // BOOST_NO_STD_LOCALE +#endif // BOOST_NO_STRINGSTREAM + +#ifndef BOOST_NO_EXCEPTIONS + stream.exceptions(std::ios::badbit); + try { +#endif + stream.unsetf(std::ios::skipws); + lcast_set_precision(stream, static_cast<InputStreamable*>(0)); + + return (stream >> output) + && (stream.get() == Traits::eof()); + +#ifndef BOOST_NO_EXCEPTIONS + } catch (const ::std::ios_base::failure& /*f*/) { + return false; + } +#endif + } + + template<class T> + inline bool shr_xchar(T& output) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ), + "boost::lexical_cast does not support narrowing of character types." + "Use boost::locale instead" ); + bool const ok = (finish - start == 1); + if (ok) { + CharT out; + Traits::assign(out, *start); + output = static_cast<T>(out); + } + return ok; + } + + template <std::size_t N, class ArrayT> + bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT { + using namespace std; + const std::size_t size = static_cast<std::size_t>(finish - start); + if (size > N - 1) { // `-1` because we need to store \0 at the end + return false; + } + + memcpy(&output[0], start, size * sizeof(CharT)); + output[size] = Traits::to_char_type(0); + return true; + } + +/************************************ OPERATORS >> ( ... ) ********************************/ + public: + bool operator>>(unsigned short& output) { return shr_unsigned(output); } + bool operator>>(unsigned int& output) { return shr_unsigned(output); } + bool operator>>(unsigned long int& output) { return shr_unsigned(output); } + bool operator>>(short& output) { return shr_signed(output); } + bool operator>>(int& output) { return shr_signed(output); } + bool operator>>(long int& output) { return shr_signed(output); } +#if defined(BOOST_HAS_LONG_LONG) + bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); } + bool operator>>(boost::long_long_type& output) { return shr_signed(output); } +#elif defined(BOOST_HAS_MS_INT64) + bool operator>>(unsigned __int64& output) { return shr_unsigned(output); } + bool operator>>(__int64& output) { return shr_signed(output); } +#endif + +#ifdef BOOST_HAS_INT128 + bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); } + bool operator>>(boost::int128_type& output) { return shr_signed(output); } +#endif + + bool operator>>(char& output) { return shr_xchar(output); } + bool operator>>(unsigned char& output) { return shr_xchar(output); } + bool operator>>(signed char& output) { return shr_xchar(output); } +#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) + bool operator>>(wchar_t& output) { return shr_xchar(output); } +#endif +#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + bool operator>>(char16_t& output) { return shr_xchar(output); } +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + bool operator>>(char32_t& output) { return shr_xchar(output); } +#endif + template<class Alloc> + bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { + str.assign(start, finish); return true; + } + + template<class Alloc> + bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) { + str.assign(start, finish); return true; + } + + template <std::size_t N> + bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT { + return shr_std_array<N>(output); + } + + template <std::size_t N> + bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT { + return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); + } + + template <std::size_t N> + bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT { + return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); + } + +#ifndef BOOST_NO_CXX11_HDR_ARRAY + template <class C, std::size_t N> + bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG( + (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)), + "std::array<C, N> and boost::array<C, N> must have exactly the same layout." + ); + return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output)); + } +#endif + + bool operator>>(bool& output) BOOST_NOEXCEPT { + output = false; // Suppress warning about uninitalized variable + + if (start == finish) return false; + CharT const zero = lcast_char_constants<CharT>::zero; + CharT const plus = lcast_char_constants<CharT>::plus; + CharT const minus = lcast_char_constants<CharT>::minus; + + const CharT* const dec_finish = finish - 1; + output = Traits::eq(*dec_finish, zero + 1); + if (!output && !Traits::eq(*dec_finish, zero)) { + return false; // Does not ends on '0' or '1' + } + + if (start == dec_finish) return true; + + // We may have sign at the beginning + if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) { + ++ start; + } + + // Skipping zeros + while (start != dec_finish) { + if (!Traits::eq(zero, *start)) { + return false; // Not a zero => error + } + + ++ start; + } + + return true; + } + + bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); } + + private: + // Not optimised converter + template <class T> + bool float_types_converter_internal(T& output, int /*tag*/) { + if (parse_inf_nan(start, finish, output)) return true; + bool const return_value = shr_using_base_class(output); + + /* Some compilers and libraries successfully + * parse 'inf', 'INFINITY', '1.0E', '1.0E-'... + * We are trying to provide a unified behaviour, + * so we just forbid such conversions (as some + * of the most popular compilers/libraries do) + * */ + CharT const minus = lcast_char_constants<CharT>::minus; + CharT const plus = lcast_char_constants<CharT>::plus; + CharT const capital_e = lcast_char_constants<CharT>::capital_e; + CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e; + if ( return_value && + ( + Traits::eq(*(finish-1), lowercase_e) // 1.0e + || Traits::eq(*(finish-1), capital_e) // 1.0E + || Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E- + || Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+ + ) + ) return false; + + return return_value; + } + + // Optimised converter + bool float_types_converter_internal(double& output, char /*tag*/) { + return lcast_ret_float<Traits>(output, start, finish); + } + public: + + bool operator>>(double& output) { + /* + * Some compilers implement long double as double. In that case these types have + * same size, same precision, same max and min values... And it means, + * that current implementation of lcast_ret_float cannot be used for type + * double, because it will give a big precision loss. + * */ + boost::mpl::if_c< +#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) + boost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value, +#else + 1, +#endif + int, + char + >::type tag = 0; + + return float_types_converter_internal(output, tag); + } + + bool operator>>(long double& output) { + int tag = 0; + return float_types_converter_internal(output, tag); + } + + // Generic istream-based algorithm. + // lcast_streambuf_for_target<InputStreamable>::value is true. + template <typename InputStreamable> + bool operator>>(InputStreamable& output) { + return shr_using_base_class(output); + } + }; + } +} // namespace boost + +#undef BOOST_LCAST_NO_WCHAR_T + +#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP + diff --git a/boost/lexical_cast/detail/converter_numeric.hpp b/boost/lexical_cast/detail/converter_numeric.hpp new file mode 100644 index 0000000000..83600f7e0b --- /dev/null +++ b/boost/lexical_cast/detail/converter_numeric.hpp @@ -0,0 +1,179 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP +#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#include <boost/limits.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/ice.hpp> +#include <boost/type_traits/make_unsigned.hpp> +#include <boost/type_traits/is_signed.hpp> +#include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/is_arithmetic.hpp> +#include <boost/type_traits/is_base_of.hpp> + +#include <boost/numeric/conversion/cast.hpp> + +namespace boost { namespace detail { + +template <class Source > +struct detect_precision_loss +{ + typedef Source source_type; + typedef boost::numeric::Trunc<Source> Rounder; + typedef BOOST_DEDUCED_TYPENAME mpl::if_< + boost::is_arithmetic<Source>, Source, Source const& + >::type argument_type ; + + static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT { + const source_type near_int = Rounder::nearbyint(s); + if (near_int && is_ok) { + const source_type orig_div_round = s / near_int; + const source_type eps = std::numeric_limits<source_type>::epsilon(); + + is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps); + } + + return s; + } + + typedef typename Rounder::round_style round_style; +}; + +template <typename Base, class Source> +struct fake_precision_loss: public Base +{ + typedef Source source_type ; + typedef BOOST_DEDUCED_TYPENAME mpl::if_< + boost::is_arithmetic<Source>, Source, Source const& + >::type argument_type ; + + static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT { + return s; + } +}; + +struct nothrow_overflow_handler +{ + inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT { + return (r == boost::numeric::cInRange); + } +}; + +template <typename Target, typename Source> +inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT { + typedef boost::numeric::converter< + Target, + Source, + boost::numeric::conversion_traits<Target, Source >, + nothrow_overflow_handler, + detect_precision_loss<Source > + > converter_orig_t; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value, + converter_orig_t, + fake_precision_loss<converter_orig_t, Source> + >::type converter_t; + + bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg)); + result = converter_t::low_level_convert(converter_t::nearbyint(arg, res)); + return res; +} + +template <typename Target, typename Source> +struct lexical_cast_dynamic_num_not_ignoring_minus +{ + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { + return noexcept_numeric_convert<Target, Source >(arg, result); + } +}; + +template <typename Target, typename Source> +struct lexical_cast_dynamic_num_ignoring_minus +{ + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { + typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c< + boost::is_float<Source>::value, + boost::mpl::identity<Source>, + boost::make_unsigned<Source> + >::type usource_t; + + if (arg < 0) { + const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result); + result = static_cast<Target>(0u - result); + return res; + } else { + return noexcept_numeric_convert<Target, usource_t>(arg, result); + } + } +}; + +/* + * lexical_cast_dynamic_num follows the rules: + * 1) If Source can be converted to Target without precision loss and + * without overflows, then assign Source to Target and return + * + * 2) If Source is less than 0 and Target is an unsigned integer, + * then negate Source, check the requirements of rule 1) and if + * successful, assign static_casted Source to Target and return + * + * 3) Otherwise throw a bad_lexical_cast exception + * + * + * Rule 2) required because boost::lexical_cast has the behavior of + * stringstream, which uses the rules of scanf for conversions. And + * in the C99 standard for unsigned input value minus sign is + * optional, so if a negative number is read, no errors will arise + * and the result will be the two's complement. + */ +template <typename Target, typename Source> +struct dynamic_num_converter_impl +{ + static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + boost::type_traits::ice_and< + boost::is_unsigned<Target>::value, + boost::type_traits::ice_or< + boost::is_signed<Source>::value, + boost::is_float<Source>::value + >::value, + boost::type_traits::ice_not< + boost::is_same<Source, bool>::value + >::value, + boost::type_traits::ice_not< + boost::is_same<Target, bool>::value + >::value + >::value, + lexical_cast_dynamic_num_ignoring_minus<Target, Source>, + lexical_cast_dynamic_num_not_ignoring_minus<Target, Source> + >::type caster_type; + + return caster_type::try_convert(arg, result); + } +}; + +}} // namespace boost::detail + +#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP + diff --git a/boost/lexical_cast/detail/inf_nan.hpp b/boost/lexical_cast/detail/inf_nan.hpp new file mode 100644 index 0000000000..c10457ecd2 --- /dev/null +++ b/boost/lexical_cast/detail/inf_nan.hpp @@ -0,0 +1,197 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP +#define BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) +#define BOOST_LCAST_NO_WCHAR_T +#endif + +#include <cstddef> +#include <cstring> +#include <boost/limits.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/math/special_functions/sign.hpp> +#include <boost/math/special_functions/fpclassify.hpp> + +#include <boost/lexical_cast/detail/lcast_char_constants.hpp> + +namespace boost { + namespace detail + { + template <class CharT> + bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT { + for( unsigned int i=0; i < len; ++i ) { + if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false; + } + + return true; + } + + /* Returns true and sets the correct value if found NaN or Inf. */ + template <class CharT, class T> + inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value + , const CharT* lc_NAN, const CharT* lc_nan + , const CharT* lc_INFINITY, const CharT* lc_infinity + , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT + { + using namespace std; + if (begin == end) return false; + const CharT minus = lcast_char_constants<CharT>::minus; + const CharT plus = lcast_char_constants<CharT>::plus; + const int inifinity_size = 8; // == sizeof("infinity") - 1 + + /* Parsing +/- */ + bool const has_minus = (*begin == minus); + if (has_minus || *begin == plus) { + ++ begin; + } + + if (end - begin < 3) return false; + if (lc_iequal(begin, lc_nan, lc_NAN, 3)) { + begin += 3; + if (end != begin) { + /* It is 'nan(...)' or some bad input*/ + + if (end - begin < 2) return false; // bad input + -- end; + if (*begin != opening_brace || *end != closing_brace) return false; // bad input + } + + if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN(); + else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN()); + return true; + } else if ( + ( /* 'INF' or 'inf' */ + end - begin == 3 // 3 == sizeof('inf') - 1 + && lc_iequal(begin, lc_infinity, lc_INFINITY, 3) + ) + || + ( /* 'INFINITY' or 'infinity' */ + end - begin == inifinity_size + && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size) + ) + ) + { + if( !has_minus ) value = std::numeric_limits<T>::infinity(); + else value = (boost::math::changesign) (std::numeric_limits<T>::infinity()); + return true; + } + + return false; + } + + template <class CharT, class T> + bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value + , const CharT* lc_nan + , const CharT* lc_infinity) BOOST_NOEXCEPT + { + using namespace std; + const CharT minus = lcast_char_constants<CharT>::minus; + if ((boost::math::isnan)(value)) { + if ((boost::math::signbit)(value)) { + *begin = minus; + ++ begin; + } + + memcpy(begin, lc_nan, 3 * sizeof(CharT)); + end = begin + 3; + return true; + } else if ((boost::math::isinf)(value)) { + if ((boost::math::signbit)(value)) { + *begin = minus; + ++ begin; + } + + memcpy(begin, lc_infinity, 3 * sizeof(CharT)); + end = begin + 3; + return true; + } + + return false; + } + + +#ifndef BOOST_LCAST_NO_WCHAR_T + template <class T> + bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT { + return parse_inf_nan_impl(begin, end, value + , L"NAN", L"nan" + , L"INFINITY", L"infinity" + , L'(', L')'); + } + + template <class T> + bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT { + return put_inf_nan_impl(begin, end, value, L"nan", L"infinity"); + } + +#endif +#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + template <class T> + bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT { + return parse_inf_nan_impl(begin, end, value + , u"NAN", u"nan" + , u"INFINITY", u"infinity" + , u'(', u')'); + } + + template <class T> + bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT { + return put_inf_nan_impl(begin, end, value, u"nan", u"infinity"); + } +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) + template <class T> + bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT { + return parse_inf_nan_impl(begin, end, value + , U"NAN", U"nan" + , U"INFINITY", U"infinity" + , U'(', U')'); + } + + template <class T> + bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT { + return put_inf_nan_impl(begin, end, value, U"nan", U"infinity"); + } +#endif + + template <class CharT, class T> + bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT { + return parse_inf_nan_impl(begin, end, value + , "NAN", "nan" + , "INFINITY", "infinity" + , '(', ')'); + } + + template <class CharT, class T> + bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT { + return put_inf_nan_impl(begin, end, value, "nan", "infinity"); + } + } +} // namespace boost + +#undef BOOST_LCAST_NO_WCHAR_T + +#endif // BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP + diff --git a/boost/lexical_cast/detail/is_character.hpp b/boost/lexical_cast/detail/is_character.hpp new file mode 100644 index 0000000000..e967f58525 --- /dev/null +++ b/boost/lexical_cast/detail/is_character.hpp @@ -0,0 +1,57 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP +#define BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#include <boost/type_traits/is_same.hpp> + +namespace boost { + + namespace detail // is_character<...> + { + // returns true, if T is one of the character types + template < typename T > + struct is_character + { + typedef boost::type_traits::ice_or< + boost::is_same< T, char >::value, + #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING) + boost::is_same< T, wchar_t >::value, + #endif + #ifndef BOOST_NO_CXX11_CHAR16_T + boost::is_same< T, char16_t >::value, + #endif + #ifndef BOOST_NO_CXX11_CHAR32_T + boost::is_same< T, char32_t >::value, + #endif + boost::is_same< T, unsigned char >::value, + boost::is_same< T, signed char >::value + > result_type; + + BOOST_STATIC_CONSTANT(bool, value = (result_type::value) ); + }; + } +} + +#endif // BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP + diff --git a/boost/lexical_cast/detail/lcast_char_constants.hpp b/boost/lexical_cast/detail/lcast_char_constants.hpp new file mode 100644 index 0000000000..fd651ee3e9 --- /dev/null +++ b/boost/lexical_cast/detail/lcast_char_constants.hpp @@ -0,0 +1,46 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP +#define BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +namespace boost +{ + namespace detail // '0', '-', '+', 'e', 'E' and '.' constants + { + template < typename Char > + struct lcast_char_constants { + // We check in tests assumption that static casted character is + // equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0') + BOOST_STATIC_CONSTANT(Char, zero = static_cast<Char>('0')); + BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-')); + BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+')); + BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e')); + BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E')); + BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.')); + }; + } +} // namespace boost + + +#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP + diff --git a/boost/lexical_cast/detail/lcast_float_converters.hpp b/boost/lexical_cast/detail/lcast_float_converters.hpp new file mode 100644 index 0000000000..9ef7126865 --- /dev/null +++ b/boost/lexical_cast/detail/lcast_float_converters.hpp @@ -0,0 +1,294 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_FLOAT_CONVERTERS_HPP +#define BOOST_LEXICAL_CAST_DETAIL_LCAST_FLOAT_CONVERTERS_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#include <cstddef> +#include <cmath> +#include <boost/limits.hpp> +#include <boost/detail/workaround.hpp> + +#ifndef BOOST_NO_STD_LOCALE +# include <locale> +#else +# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + // Getting error at this point means, that your STL library is old/lame/misconfigured. + // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE, + // but beware: lexical_cast will understand only 'C' locale delimeters and thousands + // separators. +# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force " +# error "boost::lexical_cast to use only 'C' locale during conversions." +# endif +#endif + +#include <boost/lexical_cast/detail/lcast_char_constants.hpp> + +#include <boost/math/special_functions/sign.hpp> +#include <boost/math/special_functions/fpclassify.hpp> + +namespace boost { + + namespace detail // lcast_ret_float + { + +// Silence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data +#if defined(_MSC_VER) && (_MSC_VER == 1400) +# pragma warning(push) +# pragma warning(disable:4244) +#endif + template <class T> + struct mantissa_holder_type + { + /* Can not be used with this type */ + }; + + template <> + struct mantissa_holder_type<float> + { + typedef unsigned int type; + typedef double wide_result_t; + }; + + template <> + struct mantissa_holder_type<double> + { +#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS + typedef long double wide_result_t; +#if defined(BOOST_HAS_LONG_LONG) + typedef boost::ulong_long_type type; +#elif defined(BOOST_HAS_MS_INT64) + typedef unsigned __int64 type; +#endif +#endif + }; + + template<class Traits, class T, class CharT> + inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* const end) + { + value = static_cast<T>(0); + if (begin == end) return false; + if (parse_inf_nan(begin, end, value)) return true; + + CharT const czero = lcast_char_constants<CharT>::zero; + CharT const minus = lcast_char_constants<CharT>::minus; + CharT const plus = lcast_char_constants<CharT>::plus; + CharT const capital_e = lcast_char_constants<CharT>::capital_e; + CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e; + + /* Getting the plus/minus sign */ + bool const has_minus = Traits::eq(*begin, minus); + if (has_minus || Traits::eq(*begin, plus)) { + ++ begin; + if (begin == end) return false; + } + +#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + std::locale loc; + typedef std::numpunct<CharT> numpunct; + numpunct const& np = BOOST_USE_FACET(numpunct, loc); + std::string const grouping( + (loc == std::locale::classic()) + ? std::string() + : np.grouping() + ); + std::string::size_type const grouping_size = grouping.size(); + CharT const thousands_sep = static_cast<CharT>(grouping_size ? np.thousands_sep() : 0); + CharT const decimal_point = np.decimal_point(); + bool found_grouping = false; + std::string::size_type last_grouping_pos = grouping_size - 1; +#else + CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator; +#endif + + bool found_decimal = false; + bool found_number_before_exp = false; + typedef int pow_of_10_t; + pow_of_10_t pow_of_10 = 0; + + typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type; + mantissa_type mantissa=0; + bool is_mantissa_full = false; + char length_since_last_delim = 0; + + while (begin != end) { + if (found_decimal) { + /* We allow no thousand_separators after decimal point */ + + const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero); + if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break; + if ( *begin < czero || *begin >= czero + 10 ) return false; + if ( is_mantissa_full + || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u < mantissa + ) { + is_mantissa_full = true; + ++ begin; + continue; + } + + -- pow_of_10; + mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value); + + found_number_before_exp = true; + } else { + + if (*begin >= czero && *begin < czero + 10) { + + /* Checking for mantissa overflow. If overflow will + * occur, them we only increase multiplyer + */ + const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero); + if( is_mantissa_full + || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u < mantissa + ) + { + is_mantissa_full = true; + ++ pow_of_10; + } else { + mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value); + } + + found_number_before_exp = true; + ++ length_since_last_delim; + } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) { +#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + /* If ( we need to check grouping + * and ( grouping missmatches + * or grouping position is incorrect + * or we are using the grouping position 0 twice + * ) + * ) then return error + */ + if( grouping_size && found_grouping + && ( + length_since_last_delim != grouping[0] + || last_grouping_pos>1 + || (last_grouping_pos==0 && grouping_size>1) + ) + ) return false; +#endif + + if (Traits::eq(*begin, decimal_point)) { + ++ begin; + found_decimal = true; + if (!found_number_before_exp && begin==end) return false; + continue; + } else { + if (!found_number_before_exp) return false; + break; + } + } +#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + else if (grouping_size && Traits::eq(*begin, thousands_sep)){ + if(found_grouping) + { + /* It is not he first time, when we find thousands separator, + * so we need to chek, is the distance between two groupings + * equal to grouping[last_grouping_pos] */ + + if (length_since_last_delim != grouping[last_grouping_pos] ) + { + if (!last_grouping_pos) return false; + else + { + -- last_grouping_pos; + if (length_since_last_delim != grouping[last_grouping_pos]) return false; + } + } else + /* We are calling the grouping[0] twice, when grouping size is more than 1 */ + if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false; + + } else { + /* Delimiter at the begining ',000' */ + if (!length_since_last_delim) return false; + + found_grouping = true; + if (length_since_last_delim > grouping[last_grouping_pos] ) return false; + } + + length_since_last_delim = 0; + ++ begin; + + /* Delimiter at the end '100,' */ + if (begin == end) return false; + continue; + } +#endif + else return false; + } + + ++begin; + } + + // Exponent found + if (begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e))) { + ++ begin; + if (begin == end) return false; + + bool const exp_has_minus = Traits::eq(*begin, minus); + if (exp_has_minus || Traits::eq(*begin, plus)) { + ++ begin; + if (begin == end) return false; + } + + pow_of_10_t exp_pow_of_10 = 0; + while (begin != end) { + pow_of_10_t const sub_value = *begin - czero; + + if ( *begin < czero || *begin >= czero + 10 + || ((std::numeric_limits<pow_of_10_t>::max)() - sub_value) / 10 < exp_pow_of_10) + return false; + + exp_pow_of_10 *= 10; + exp_pow_of_10 += sub_value; + ++ begin; + }; + + if (exp_has_minus) { + if ((std::numeric_limits<pow_of_10_t>::min)() + exp_pow_of_10 > pow_of_10) + return false; // failed overflow check + pow_of_10 -= exp_pow_of_10; + } else { + if ((std::numeric_limits<pow_of_10_t>::max)() - exp_pow_of_10 < pow_of_10) + return false; // failed overflow check + pow_of_10 += exp_pow_of_10; + } + } + + /* We need a more accurate algorithm... We can not use current algorithm + * with long doubles (and with doubles if sizeof(double)==sizeof(long double)). + */ + typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t; + const wide_result_t result = std::pow(static_cast<wide_result_t>(10.0), pow_of_10) * mantissa; + value = static_cast<T>( has_minus ? (boost::math::changesign)(result) : result); + + return !((boost::math::isinf)(value) || (boost::math::isnan)(value)); + } +// Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data +#if defined(_MSC_VER) && (_MSC_VER == 1400) +# pragma warning(pop) +#endif + } +} // namespace boost + +#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_FLOAT_CONVERTERS_HPP + diff --git a/boost/lexical_cast/detail/lcast_unsigned_converters.hpp b/boost/lexical_cast/detail/lcast_unsigned_converters.hpp new file mode 100644 index 0000000000..f75b419d2f --- /dev/null +++ b/boost/lexical_cast/detail/lcast_unsigned_converters.hpp @@ -0,0 +1,295 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP +#define BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#include <climits> +#include <cstddef> +#include <string> +#include <cstring> +#include <cstdio> +#include <boost/limits.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/ice.hpp> +#include <boost/static_assert.hpp> +#include <boost/detail/workaround.hpp> + + +#ifndef BOOST_NO_STD_LOCALE +# include <locale> +#else +# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + // Getting error at this point means, that your STL library is old/lame/misconfigured. + // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE, + // but beware: lexical_cast will understand only 'C' locale delimeters and thousands + // separators. +# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force " +# error "boost::lexical_cast to use only 'C' locale during conversions." +# endif +#endif + +#include <boost/lexical_cast/detail/lcast_char_constants.hpp> +#include <boost/type_traits/make_unsigned.hpp> +#include <boost/type_traits/is_signed.hpp> +#include <boost/noncopyable.hpp> + +namespace boost +{ + namespace detail // lcast_to_unsigned + { + template<class T> + inline + BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT { + typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type; + return value < 0 + ? static_cast<result_type>(0u - static_cast<result_type>(value)) + : static_cast<result_type>(value); + } + } + + namespace detail // lcast_put_unsigned + { + template <class Traits, class T, class CharT> + class lcast_put_unsigned: boost::noncopyable { + typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type; + BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + (sizeof(int_type) > sizeof(T)) + , int_type + , T + >::type m_value; + CharT* m_finish; + CharT const m_czero; + int_type const m_zero; + + public: + lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT + : m_value(n_param), m_finish(finish) + , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero)) + { +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed); +#endif + } + + CharT* convert() { +#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + std::locale loc; + if (loc == std::locale::classic()) { + return main_convert_loop(); + } + + typedef std::numpunct<CharT> numpunct; + numpunct const& np = BOOST_USE_FACET(numpunct, loc); + std::string const grouping = np.grouping(); + std::string::size_type const grouping_size = grouping.size(); + + if (!grouping_size || grouping[0] <= 0) { + return main_convert_loop(); + } + +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + // Check that ulimited group is unreachable: + BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX); +#endif + CharT const thousands_sep = np.thousands_sep(); + std::string::size_type group = 0; // current group number + char last_grp_size = grouping[0]; + char left = last_grp_size; + + do { + if (left == 0) { + ++group; + if (group < grouping_size) { + char const grp_size = grouping[group]; + last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size); + } + + left = last_grp_size; + --m_finish; + Traits::assign(*m_finish, thousands_sep); + } + + --left; + } while (main_convert_iteration()); + + return m_finish; +#else + return main_convert_loop(); +#endif + } + + private: + inline bool main_convert_iteration() BOOST_NOEXCEPT { + --m_finish; + int_type const digit = static_cast<int_type>(m_value % 10U); + Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit)); + m_value /= 10; + return !!m_value; // supressing warnings + } + + inline CharT* main_convert_loop() BOOST_NOEXCEPT { + while (main_convert_iteration()); + return m_finish; + } + }; + } + + namespace detail // lcast_ret_unsigned + { + template <class Traits, class T, class CharT> + class lcast_ret_unsigned: boost::noncopyable { + bool m_multiplier_overflowed; + T m_multiplier; + T& m_value; + const CharT* const m_begin; + const CharT* m_end; + + public: + lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT + : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end) + { +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed); + + // GCC when used with flag -std=c++0x may not have std::numeric_limits + // specializations for __int128 and unsigned __int128 types. + // Try compilation with -std=gnu++0x or -std=gnu++11. + // + // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856 + BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized, + "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast" + ); +#endif + } + + inline bool convert() { + CharT const czero = lcast_char_constants<CharT>::zero; + --m_end; + m_value = static_cast<T>(0); + + if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10) + return false; + m_value = static_cast<T>(*m_end - czero); + --m_end; + +#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE + return main_convert_loop(); +#else + std::locale loc; + if (loc == std::locale::classic()) { + return main_convert_loop(); + } + + typedef std::numpunct<CharT> numpunct; + numpunct const& np = BOOST_USE_FACET(numpunct, loc); + std::string const& grouping = np.grouping(); + std::string::size_type const grouping_size = grouping.size(); + + /* According to Programming languages - C++ + * we MUST check for correct grouping + */ + if (!grouping_size || grouping[0] <= 0) { + return main_convert_loop(); + } + + unsigned char current_grouping = 0; + CharT const thousands_sep = np.thousands_sep(); + char remained = static_cast<char>(grouping[current_grouping] - 1); + + for (;m_end >= m_begin; --m_end) + { + if (remained) { + if (!main_convert_iteration()) { + return false; + } + --remained; + } else { + if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false; + { + /* + * According to Programming languages - C++ + * Digit grouping is checked. That is, the positions of discarded + * separators is examined for consistency with + * use_facet<numpunct<charT> >(loc ).grouping() + * + * BUT what if there is no separators at all and grouping() + * is not empty? Well, we have no extraced separators, so we + * won`t check them for consistency. This will allow us to + * work with "C" locale from other locales + */ + return main_convert_loop(); + } else { + if (m_begin == m_end) return false; + if (current_grouping < grouping_size - 1) ++current_grouping; + remained = grouping[current_grouping]; + } + } + } /*for*/ + + return true; +#endif + } + + private: + // Iteration that does not care about grouping/separators and assumes that all + // input characters are digits + inline bool main_convert_iteration() BOOST_NOEXCEPT { + CharT const czero = lcast_char_constants<CharT>::zero; + T const maxv = (std::numeric_limits<T>::max)(); + + m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier); + m_multiplier = static_cast<T>(m_multiplier * 10); + + T const dig_value = static_cast<T>(*m_end - czero); + T const new_sub_value = static_cast<T>(m_multiplier * dig_value); + + // We must correctly handle situations like `000000000000000000000000000001`. + // So we take care of overflow only if `dig_value` is not '0'. + if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit + || (dig_value && ( // checking for overflow of ... + m_multiplier_overflowed // ... multiplier + || static_cast<T>(maxv / dig_value) < m_multiplier // ... subvalue + || static_cast<T>(maxv - new_sub_value) < m_value // ... whole expression + )) + ) return false; + + m_value = static_cast<T>(m_value + new_sub_value); + + return true; + } + + bool main_convert_loop() BOOST_NOEXCEPT { + for ( ; m_end >= m_begin; --m_end) { + if (!main_convert_iteration()) { + return false; + } + } + + return true; + } + }; + } +} // namespace boost + +#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP + diff --git a/boost/lexical_cast/detail/widest_char.hpp b/boost/lexical_cast/detail/widest_char.hpp new file mode 100644 index 0000000000..013aaf119d --- /dev/null +++ b/boost/lexical_cast/detail/widest_char.hpp @@ -0,0 +1,40 @@ +// Copyright Kevlin Henney, 2000-2005. +// Copyright Alexander Nasonov, 2006-2010. +// Copyright Antony Polukhin, 2011-2014. +// +// 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) +// +// what: lexical_cast custom keyword cast +// who: contributed by Kevlin Henney, +// enhanced with contributions from Terje Slettebo, +// with additional fixes and suggestions from Gennaro Prota, +// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, +// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, +// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters +// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 + +#ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP +#define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP + +#include <boost/config.hpp> +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +namespace boost { namespace detail { + + template <typename TargetChar, typename SourceChar> + struct widest_char { + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< + (sizeof(TargetChar) > sizeof(SourceChar)) + , TargetChar + , SourceChar + >::type type; + }; + +}} // namespace boost::detail + +#endif // BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP + |