/*============================================================================= | |
Copyright (c) 1998-2003 Joel de Guzman | |
Copyright (c) 2001-2003 Hartmut Kaiser | |
http://spirit.sourceforge.net/ | |
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_NUMERICS_HPP | |
#define BOOST_SPIRIT_NUMERICS_HPP | |
#include <boost/config.hpp> | |
#include <boost/spirit/home/classic/namespace.hpp> | |
#include <boost/spirit/home/classic/core/parser.hpp> | |
#include <boost/spirit/home/classic/core/composite/directives.hpp> | |
#include <boost/spirit/home/classic/core/primitives/numerics_fwd.hpp> | |
#include <boost/spirit/home/classic/core/primitives/impl/numerics.ipp> | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// uint_parser class | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template < | |
typename T, | |
int Radix, | |
unsigned MinDigits, | |
int MaxDigits | |
> | |
struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits> > | |
{ | |
typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t; | |
template <typename ScannerT> | |
struct result | |
{ | |
typedef typename match_result<ScannerT, T>::type type; | |
}; | |
template <typename ScannerT> | |
typename parser_result<self_t, ScannerT>::type | |
parse(ScannerT const& scan) const | |
{ | |
typedef impl::uint_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t; | |
typedef typename parser_result<impl_t, ScannerT>::type result_t; | |
return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan); | |
} | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// int_parser class | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template < | |
typename T, | |
int Radix, | |
unsigned MinDigits, | |
int MaxDigits | |
> | |
struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits> > | |
{ | |
typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t; | |
template <typename ScannerT> | |
struct result | |
{ | |
typedef typename match_result<ScannerT, T>::type type; | |
}; | |
template <typename ScannerT> | |
typename parser_result<self_t, ScannerT>::type | |
parse(ScannerT const& scan) const | |
{ | |
typedef impl::int_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t; | |
typedef typename parser_result<impl_t, ScannerT>::type result_t; | |
return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan); | |
} | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// uint_parser/int_parser instantiations | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
int_parser<int> const | |
int_p = int_parser<int>(); | |
uint_parser<unsigned> const | |
uint_p = uint_parser<unsigned>(); | |
uint_parser<unsigned, 2> const | |
bin_p = uint_parser<unsigned, 2>(); | |
uint_parser<unsigned, 8> const | |
oct_p = uint_parser<unsigned, 8>(); | |
uint_parser<unsigned, 16> const | |
hex_p = uint_parser<unsigned, 16>(); | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// sign_parser class | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
namespace impl | |
{ | |
// Utility to extract the prefix sign ('-' | '+') | |
template <typename ScannerT> | |
bool extract_sign(ScannerT const& scan, std::size_t& count); | |
} | |
struct sign_parser : public parser<sign_parser> | |
{ | |
typedef sign_parser self_t; | |
template <typename ScannerT> | |
struct result | |
{ | |
typedef typename match_result<ScannerT, bool>::type type; | |
}; | |
sign_parser() {} | |
template <typename ScannerT> | |
typename parser_result<self_t, ScannerT>::type | |
parse(ScannerT const& scan) const | |
{ | |
if (!scan.at_end()) | |
{ | |
std::size_t length; | |
typename ScannerT::iterator_t save(scan.first); | |
bool neg = impl::extract_sign(scan, length); | |
if (length) | |
return scan.create_match(1, neg, save, scan.first); | |
} | |
return scan.no_match(); | |
} | |
}; | |
sign_parser const sign_p = sign_parser(); | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// default real number policies | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename T> | |
struct ureal_parser_policies | |
{ | |
// trailing dot policy suggested suggested by Gustavo Guerra | |
BOOST_STATIC_CONSTANT(bool, allow_leading_dot = true); | |
BOOST_STATIC_CONSTANT(bool, allow_trailing_dot = true); | |
BOOST_STATIC_CONSTANT(bool, expect_dot = false); | |
typedef uint_parser<T, 10, 1, -1> uint_parser_t; | |
typedef int_parser<T, 10, 1, -1> int_parser_t; | |
template <typename ScannerT> | |
static typename match_result<ScannerT, nil_t>::type | |
parse_sign(ScannerT& scan) | |
{ | |
return scan.no_match(); | |
} | |
template <typename ScannerT> | |
static typename parser_result<uint_parser_t, ScannerT>::type | |
parse_n(ScannerT& scan) | |
{ | |
return uint_parser_t().parse(scan); | |
} | |
template <typename ScannerT> | |
static typename parser_result<chlit<>, ScannerT>::type | |
parse_dot(ScannerT& scan) | |
{ | |
return ch_p('.').parse(scan); | |
} | |
template <typename ScannerT> | |
static typename parser_result<uint_parser_t, ScannerT>::type | |
parse_frac_n(ScannerT& scan) | |
{ | |
return uint_parser_t().parse(scan); | |
} | |
template <typename ScannerT> | |
static typename parser_result<chlit<>, ScannerT>::type | |
parse_exp(ScannerT& scan) | |
{ | |
return as_lower_d['e'].parse(scan); | |
} | |
template <typename ScannerT> | |
static typename parser_result<int_parser_t, ScannerT>::type | |
parse_exp_n(ScannerT& scan) | |
{ | |
return int_parser_t().parse(scan); | |
} | |
}; | |
template <typename T> | |
struct real_parser_policies : public ureal_parser_policies<T> | |
{ | |
template <typename ScannerT> | |
static typename parser_result<sign_parser, ScannerT>::type | |
parse_sign(ScannerT& scan) | |
{ | |
return sign_p.parse(scan); | |
} | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// real_parser class | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template < | |
typename T, | |
typename RealPoliciesT | |
> | |
struct real_parser | |
: public parser<real_parser<T, RealPoliciesT> > | |
{ | |
typedef real_parser<T, RealPoliciesT> self_t; | |
template <typename ScannerT> | |
struct result | |
{ | |
typedef typename match_result<ScannerT, T>::type type; | |
}; | |
real_parser() {} | |
template <typename ScannerT> | |
typename parser_result<self_t, ScannerT>::type | |
parse(ScannerT const& scan) const | |
{ | |
typedef typename parser_result<self_t, ScannerT>::type result_t; | |
return impl::real_parser_impl<result_t, T, RealPoliciesT>::parse(scan); | |
} | |
}; | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// real_parser instantiations | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
real_parser<double, ureal_parser_policies<double> > const | |
ureal_p = real_parser<double, ureal_parser_policies<double> >(); | |
real_parser<double, real_parser_policies<double> > const | |
real_p = real_parser<double, real_parser_policies<double> >(); | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// strict reals (do not allow plain integers (no decimal point)) | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template <typename T> | |
struct strict_ureal_parser_policies : public ureal_parser_policies<T> | |
{ | |
BOOST_STATIC_CONSTANT(bool, expect_dot = true); | |
}; | |
template <typename T> | |
struct strict_real_parser_policies : public real_parser_policies<T> | |
{ | |
BOOST_STATIC_CONSTANT(bool, expect_dot = true); | |
}; | |
real_parser<double, strict_ureal_parser_policies<double> > const | |
strict_ureal_p | |
= real_parser<double, strict_ureal_parser_policies<double> >(); | |
real_parser<double, strict_real_parser_policies<double> > const | |
strict_real_p | |
= real_parser<double, strict_real_parser_policies<double> >(); | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
}} // namespace BOOST_SPIRIT_CLASSIC_NS | |
#endif |