518 lines
19 KiB
C++
518 lines
19 KiB
C++
|
/*=============================================================================
|
||
|
|
Copyright (c) 2001-2011 Joel de Guzman
|
||
|
|
Copyright (c) 2001-2011 Hartmut Kaiser
|
||
|
|
Copyright (c) 2011 Jan Frederick Eick
|
||
|
|
Copyright (c) 2011 Christopher Jefferson
|
||
|
|
Copyright (c) 2006 Stephen Nutt
|
||
|
|
|
||
|
|
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)
|
||
|
|
=============================================================================*/
|
||
|
|
#ifndef BOOST_SPIRIT_QI_NUMERIC_DETAIL_NUMERIC_UTILS_HPP
|
||
|
|
#define BOOST_SPIRIT_QI_NUMERIC_DETAIL_NUMERIC_UTILS_HPP
|
||
|
|
|
||
|
|
#if defined(_MSC_VER)
|
||
|
|
#pragma once
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <boost/spirit/home/support/unused.hpp>
|
||
|
|
#include <boost/spirit/home/qi/detail/attributes.hpp>
|
||
|
|
#include <boost/spirit/home/support/char_encoding/ascii.hpp>
|
||
|
|
#include <boost/spirit/home/support/numeric_traits.hpp>
|
||
|
|
#include <boost/preprocessor/repetition/repeat.hpp>
|
||
|
|
#include <boost/preprocessor/iteration/local.hpp>
|
||
|
|
#include <boost/preprocessor/comparison/less.hpp>
|
||
|
|
#include <boost/preprocessor/control/if.hpp>
|
||
|
|
#include <boost/preprocessor/seq/elem.hpp>
|
||
|
|
#include <boost/utility/enable_if.hpp>
|
||
|
|
#include <boost/type_traits/is_integral.hpp>
|
||
|
|
#include <boost/type_traits/is_signed.hpp>
|
||
|
|
#include <boost/mpl/bool.hpp>
|
||
|
|
#include <boost/mpl/and.hpp>
|
||
|
|
#include <boost/limits.hpp>
|
||
|
|
#include <boost/static_assert.hpp>
|
||
|
|
#include <iterator> // for std::iterator_traits
|
||
|
|
|
||
|
|
#if defined(BOOST_MSVC)
|
||
|
|
# pragma warning(push)
|
||
|
|
# pragma warning(disable: 4127) // conditional expression is constant
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if !defined(SPIRIT_NUMERICS_LOOP_UNROLL)
|
||
|
|
# define SPIRIT_NUMERICS_LOOP_UNROLL 3
|
||
|
|
#endif
|
||
|
|
|
||
|
|
namespace boost { namespace spirit { namespace qi { namespace detail
|
||
|
|
{
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// The maximum radix digits that can be represented without
|
||
|
|
// overflow:
|
||
|
|
//
|
||
|
|
// template<typename T, unsigned Radix>
|
||
|
|
// struct digits_traits::value;
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
template <typename T, unsigned Radix>
|
||
|
|
struct digits_traits;
|
||
|
|
|
||
|
|
template <int Digits, unsigned Radix>
|
||
|
|
struct digits2_to_n;
|
||
|
|
|
||
|
|
// lookup table for log2(x) : 2 <= x <= 36
|
||
|
|
#define BOOST_SPIRIT_LOG2 (#error)(#error) \
|
||
|
|
(1000000)(1584960)(2000000)(2321920)(2584960)(2807350) \
|
||
|
|
(3000000)(3169920)(3321920)(3459430)(3584960)(3700430) \
|
||
|
|
(3807350)(3906890)(4000000)(4087460)(4169920)(4247920) \
|
||
|
|
(4321920)(4392310)(4459430)(4523560)(4584960)(4643850) \
|
||
|
|
(4700430)(4754880)(4807350)(4857980)(4906890)(4954190) \
|
||
|
|
(5000000)(5044390)(5087460)(5129280)(5169925) \
|
||
|
|
/***/
|
||
|
|
|
||
|
|
#define BOOST_PP_LOCAL_MACRO(Radix) \
|
||
|
|
template <int Digits> struct digits2_to_n<Digits, Radix> \
|
||
|
|
{ \
|
||
|
|
BOOST_STATIC_CONSTANT(int, value = static_cast<int>( \
|
||
|
|
(Digits * 1000000) / \
|
||
|
|
BOOST_PP_SEQ_ELEM(Radix, BOOST_SPIRIT_LOG2))); \
|
||
|
|
}; \
|
||
|
|
/***/
|
||
|
|
|
||
|
|
#define BOOST_PP_LOCAL_LIMITS (2, 36)
|
||
|
|
#include BOOST_PP_LOCAL_ITERATE()
|
||
|
|
|
||
|
|
#undef BOOST_SPIRIT_LOG2
|
||
|
|
|
||
|
|
template <typename T, unsigned Radix>
|
||
|
|
struct digits_traits : digits2_to_n<std::numeric_limits<T>::digits, Radix>
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix == 2);
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
struct digits_traits<T, 10>
|
||
|
|
{
|
||
|
|
static int const value = std::numeric_limits<T>::digits10;
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Traits class for radix specific number conversion
|
||
|
|
//
|
||
|
|
// Test the validity of a single character:
|
||
|
|
//
|
||
|
|
// template<typename Char> static bool is_valid(Char ch);
|
||
|
|
//
|
||
|
|
// Convert a digit from character representation to binary
|
||
|
|
// representation:
|
||
|
|
//
|
||
|
|
// template<typename Char> static int digit(Char ch);
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
template <unsigned Radix>
|
||
|
|
struct radix_traits
|
||
|
|
{
|
||
|
|
template <typename Char>
|
||
|
|
inline static bool is_valid(Char ch)
|
||
|
|
{
|
||
|
|
return (ch >= '0' && ch <= (Radix > 10 ? '9' : static_cast<Char>('0' + Radix -1)))
|
||
|
|
|| (Radix > 10 && ch >= 'a' && ch <= static_cast<Char>('a' + Radix -10 -1))
|
||
|
|
|| (Radix > 10 && ch >= 'A' && ch <= static_cast<Char>('A' + Radix -10 -1));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Char>
|
||
|
|
inline static unsigned digit(Char ch)
|
||
|
|
{
|
||
|
|
if (Radix <= 10 || (ch >= '0' && ch <= '9'))
|
||
|
|
return ch - '0';
|
||
|
|
return spirit::char_encoding::ascii::tolower(ch) - 'a' + 10;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
// positive_accumulator/negative_accumulator: Accumulator policies for
|
||
|
|
// extracting integers. Use positive_accumulator if number is positive.
|
||
|
|
// Use negative_accumulator if number is negative.
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
template <unsigned Radix>
|
||
|
|
struct positive_accumulator
|
||
|
|
{
|
||
|
|
template <typename T, typename Char>
|
||
|
|
inline static void add(T& n, Char ch, mpl::false_) // unchecked add
|
||
|
|
{
|
||
|
|
const int digit = radix_traits<Radix>::digit(ch);
|
||
|
|
n = n * T(Radix) + T(digit);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T, typename Char>
|
||
|
|
inline static bool add(T& n, Char ch, mpl::true_) // checked add
|
||
|
|
{
|
||
|
|
// Ensure n *= Radix will not overflow
|
||
|
|
T const max = (std::numeric_limits<T>::max)();
|
||
|
|
T const val = max / Radix;
|
||
|
|
|
||
|
|
if (n > val)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
T tmp = n * Radix;
|
||
|
|
|
||
|
|
// Ensure n += digit will not overflow
|
||
|
|
const int digit = radix_traits<Radix>::digit(ch);
|
||
|
|
if (tmp > max - digit)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
n = tmp + static_cast<T>(digit);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <unsigned Radix>
|
||
|
|
struct negative_accumulator
|
||
|
|
{
|
||
|
|
template <typename T, typename Char>
|
||
|
|
inline static void add(T& n, Char ch, mpl::false_) // unchecked subtract
|
||
|
|
{
|
||
|
|
const int digit = radix_traits<Radix>::digit(ch);
|
||
|
|
n = n * T(Radix) - T(digit);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T, typename Char>
|
||
|
|
inline static bool add(T& n, Char ch, mpl::true_) // checked subtract
|
||
|
|
{
|
||
|
|
// Ensure n *= Radix will not underflow
|
||
|
|
T const min = (std::numeric_limits<T>::min)();
|
||
|
|
T const val = min / T(Radix);
|
||
|
|
|
||
|
|
if (n < val)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
T tmp = n * Radix;
|
||
|
|
|
||
|
|
// Ensure n -= digit will not underflow
|
||
|
|
int const digit = radix_traits<Radix>::digit(ch);
|
||
|
|
if (tmp < min + digit)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
n = tmp - static_cast<T>(digit);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
// Common code for extract_int::parse specializations
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
template <unsigned Radix, typename Accumulator, int MaxDigits, bool AlwaysCheckOverflow>
|
||
|
|
struct int_extractor
|
||
|
|
{
|
||
|
|
template <typename Char, typename T>
|
||
|
|
inline static bool
|
||
|
|
call(Char ch, std::size_t count, T& n, mpl::true_)
|
||
|
|
{
|
||
|
|
std::size_t const overflow_free = digits_traits<T, Radix>::value - 1;
|
||
|
|
|
||
|
|
if (!AlwaysCheckOverflow && (count < overflow_free))
|
||
|
|
{
|
||
|
|
Accumulator::add(n, ch, mpl::false_());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!Accumulator::add(n, ch, mpl::true_()))
|
||
|
|
return false; // over/underflow!
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Char, typename T>
|
||
|
|
inline static bool
|
||
|
|
call(Char ch, std::size_t /*count*/, T& n, mpl::false_)
|
||
|
|
{
|
||
|
|
// no need to check for overflow
|
||
|
|
Accumulator::add(n, ch, mpl::false_());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Char>
|
||
|
|
inline static bool
|
||
|
|
call(Char /*ch*/, std::size_t /*count*/, unused_type, mpl::false_)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Char, typename T>
|
||
|
|
inline static bool
|
||
|
|
call(Char ch, std::size_t count, T& n)
|
||
|
|
{
|
||
|
|
return call(ch, count, n
|
||
|
|
, mpl::bool_<
|
||
|
|
( (MaxDigits < 0)
|
||
|
|
|| (MaxDigits > digits_traits<T, Radix>::value)
|
||
|
|
)
|
||
|
|
&& traits::check_overflow<T>::value
|
||
|
|
>()
|
||
|
|
);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
// End of loop checking: check if the number of digits
|
||
|
|
// being parsed exceeds MaxDigits. Note: if MaxDigits == -1
|
||
|
|
// we don't do any checking.
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
template <int MaxDigits>
|
||
|
|
struct check_max_digits
|
||
|
|
{
|
||
|
|
inline static bool
|
||
|
|
call(std::size_t count)
|
||
|
|
{
|
||
|
|
return count < MaxDigits; // bounded
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <>
|
||
|
|
struct check_max_digits<-1>
|
||
|
|
{
|
||
|
|
inline static bool
|
||
|
|
call(std::size_t /*count*/)
|
||
|
|
{
|
||
|
|
return true; // unbounded
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
// extract_int: main code for extracting integers
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
#define SPIRIT_NUMERIC_INNER_LOOP(z, x, data) \
|
||
|
|
if (!check_max_digits<MaxDigits>::call(count + leading_zeros) \
|
||
|
|
|| it == last) \
|
||
|
|
{ \
|
||
|
|
break; \
|
||
|
|
} \
|
||
|
|
ch = *it; \
|
||
|
|
if (!radix_check::is_valid(ch)) \
|
||
|
|
{ \
|
||
|
|
break; \
|
||
|
|
} \
|
||
|
|
if (!extractor::call(ch, count, val)) \
|
||
|
|
{ \
|
||
|
|
if (IgnoreOverflowDigits) \
|
||
|
|
{ \
|
||
|
|
first = it; \
|
||
|
|
} \
|
||
|
|
traits::assign_to(val, attr); \
|
||
|
|
return IgnoreOverflowDigits; \
|
||
|
|
} \
|
||
|
|
++it; \
|
||
|
|
++count; \
|
||
|
|
/**/
|
||
|
|
|
||
|
|
template <
|
||
|
|
typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
|
||
|
|
, typename Accumulator = positive_accumulator<Radix>
|
||
|
|
, bool Accumulate = false
|
||
|
|
, bool IgnoreOverflowDigits = false
|
||
|
|
>
|
||
|
|
struct extract_int
|
||
|
|
{
|
||
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||
|
|
# pragma warning(push)
|
||
|
|
# pragma warning(disable: 4127) // conditional expression is constant
|
||
|
|
#endif
|
||
|
|
template <typename Iterator, typename Attribute>
|
||
|
|
inline static bool
|
||
|
|
parse_main(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, Attribute& attr)
|
||
|
|
{
|
||
|
|
typedef radix_traits<Radix> radix_check;
|
||
|
|
typedef int_extractor<Radix, Accumulator, MaxDigits, Accumulate> extractor;
|
||
|
|
typedef typename std::iterator_traits<Iterator>::value_type char_type;
|
||
|
|
|
||
|
|
Iterator it = first;
|
||
|
|
std::size_t leading_zeros = 0;
|
||
|
|
if (!Accumulate)
|
||
|
|
{
|
||
|
|
// skip leading zeros
|
||
|
|
while (it != last && *it == '0' && (MaxDigits < 0 || leading_zeros < static_cast< std::size_t >(MaxDigits)))
|
||
|
|
{
|
||
|
|
++it;
|
||
|
|
++leading_zeros;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
typedef typename
|
||
|
|
traits::attribute_type<Attribute>::type
|
||
|
|
attribute_type;
|
||
|
|
|
||
|
|
attribute_type val = Accumulate ? attr : attribute_type(0);
|
||
|
|
std::size_t count = 0;
|
||
|
|
char_type ch;
|
||
|
|
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
BOOST_PP_REPEAT(
|
||
|
|
SPIRIT_NUMERICS_LOOP_UNROLL
|
||
|
|
, SPIRIT_NUMERIC_INNER_LOOP, _)
|
||
|
|
}
|
||
|
|
|
||
|
|
if (count + leading_zeros >= MinDigits)
|
||
|
|
{
|
||
|
|
traits::assign_to(val, attr);
|
||
|
|
first = it;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||
|
|
# pragma warning(pop)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
template <typename Iterator>
|
||
|
|
inline static bool
|
||
|
|
parse(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, unused_type)
|
||
|
|
{
|
||
|
|
T n = 0; // must calculate value to detect over/underflow
|
||
|
|
return parse_main(first, last, n);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Iterator, typename Attribute>
|
||
|
|
inline static bool
|
||
|
|
parse(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, Attribute& attr)
|
||
|
|
{
|
||
|
|
return parse_main(first, last, attr);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
#undef SPIRIT_NUMERIC_INNER_LOOP
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
// extract_int: main code for extracting integers
|
||
|
|
// common case where MinDigits == 1 and MaxDigits = -1
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
#define SPIRIT_NUMERIC_INNER_LOOP(z, x, data) \
|
||
|
|
if (it == last) \
|
||
|
|
{ \
|
||
|
|
break; \
|
||
|
|
} \
|
||
|
|
ch = *it; \
|
||
|
|
if (!radix_check::is_valid(ch)) \
|
||
|
|
{ \
|
||
|
|
break; \
|
||
|
|
} \
|
||
|
|
if (!extractor::call(ch, count, val)) \
|
||
|
|
{ \
|
||
|
|
traits::assign_to(val, attr); \
|
||
|
|
return false; \
|
||
|
|
} \
|
||
|
|
++it; \
|
||
|
|
++count; \
|
||
|
|
/**/
|
||
|
|
|
||
|
|
template <typename T, unsigned Radix, typename Accumulator, bool Accumulate>
|
||
|
|
struct extract_int<T, Radix, 1, -1, Accumulator, Accumulate>
|
||
|
|
{
|
||
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||
|
|
# pragma warning(push)
|
||
|
|
# pragma warning(disable: 4127) // conditional expression is constant
|
||
|
|
#endif
|
||
|
|
template <typename Iterator, typename Attribute>
|
||
|
|
inline static bool
|
||
|
|
parse_main(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, Attribute& attr)
|
||
|
|
{
|
||
|
|
typedef radix_traits<Radix> radix_check;
|
||
|
|
typedef int_extractor<Radix, Accumulator, -1, Accumulate> extractor;
|
||
|
|
typedef typename std::iterator_traits<Iterator>::value_type char_type;
|
||
|
|
|
||
|
|
Iterator it = first;
|
||
|
|
std::size_t count = 0;
|
||
|
|
if (!Accumulate)
|
||
|
|
{
|
||
|
|
// skip leading zeros
|
||
|
|
while (it != last && *it == '0')
|
||
|
|
{
|
||
|
|
++it;
|
||
|
|
++count;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (it == last)
|
||
|
|
{
|
||
|
|
if (count == 0) // must have at least one digit
|
||
|
|
return false;
|
||
|
|
traits::assign_to(0, attr);
|
||
|
|
first = it;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
typedef typename
|
||
|
|
traits::attribute_type<Attribute>::type
|
||
|
|
attribute_type;
|
||
|
|
|
||
|
|
attribute_type val = Accumulate ? attr : attribute_type(0);
|
||
|
|
char_type ch = *it;
|
||
|
|
|
||
|
|
if (!radix_check::is_valid(ch) || !extractor::call(ch, 0, val))
|
||
|
|
{
|
||
|
|
if (count == 0) // must have at least one digit
|
||
|
|
return false;
|
||
|
|
traits::assign_to(val, attr);
|
||
|
|
first = it;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// count = 0; $$$ verify: I think this is wrong $$$
|
||
|
|
++it;
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
BOOST_PP_REPEAT(
|
||
|
|
SPIRIT_NUMERICS_LOOP_UNROLL
|
||
|
|
, SPIRIT_NUMERIC_INNER_LOOP, _)
|
||
|
|
}
|
||
|
|
|
||
|
|
traits::assign_to(val, attr);
|
||
|
|
first = it;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||
|
|
# pragma warning(pop)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
template <typename Iterator>
|
||
|
|
inline static bool
|
||
|
|
parse(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, unused_type)
|
||
|
|
{
|
||
|
|
T n = 0; // must calculate value to detect over/underflow
|
||
|
|
return parse_main(first, last, n);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Iterator, typename Attribute>
|
||
|
|
inline static bool
|
||
|
|
parse(
|
||
|
|
Iterator& first
|
||
|
|
, Iterator const& last
|
||
|
|
, Attribute& attr)
|
||
|
|
{
|
||
|
|
return parse_main(first, last, attr);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
#undef SPIRIT_NUMERIC_INNER_LOOP
|
||
|
|
}}}}
|
||
|
|
|
||
|
|
#if defined(BOOST_MSVC)
|
||
|
|
# pragma warning(pop)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|