| // 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 |
| |
