ceph/src/boost/libs/spirit/include/boost/spirit/home/classic/core/primitives/numerics.hpp

   1 /*=============================================================================
   2     Copyright (c) 1998-2003 Joel de Guzman
   3     Copyright (c) 2001-2003 Hartmut Kaiser
   4     http://spirit.sourceforge.net/
   5
   6   Distributed under the Boost Software License, Version 1.0. (See accompanying
   7   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8 =============================================================================*/
   9 #ifndef BOOST_SPIRIT_NUMERICS_HPP
  10 #define BOOST_SPIRIT_NUMERICS_HPP
  11
  12 #include <boost/config.hpp>
  13 #include <boost/spirit/home/classic/namespace.hpp>
  14 #include <boost/spirit/home/classic/core/parser.hpp>
  15 #include <boost/spirit/home/classic/core/composite/directives.hpp>
  16
  17 #include <boost/spirit/home/classic/core/primitives/numerics_fwd.hpp>
  18 #include <boost/spirit/home/classic/core/primitives/impl/numerics.ipp>
  19
  20 namespace boost { namespace spirit {
  21
  22 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
  23
  24     ///////////////////////////////////////////////////////////////////////////
  25     //
  26     //  uint_parser class
  27     //
  28     ///////////////////////////////////////////////////////////////////////////
  29     template <
  30         typename T,
  31         int Radix,
  32         unsigned MinDigits,
  33         int MaxDigits
  34     >
  35     struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits> >
  36     {
  37         typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t;
  38
  39         template <typename ScannerT>
  40         struct result
  41         {
  42             typedef typename match_result<ScannerT, T>::type type;
  43         };
  44
  45         template <typename ScannerT>
  46         typename parser_result<self_t, ScannerT>::type
  47         parse(ScannerT const& scan) const
  48         {
  49             typedef impl::uint_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
  50             typedef typename parser_result<impl_t, ScannerT>::type result_t;
  51             return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
  52         }
  53     };
  54
  55     ///////////////////////////////////////////////////////////////////////////
  56     //
  57     //  int_parser class
  58     //
  59     ///////////////////////////////////////////////////////////////////////////
  60     template <
  61         typename T,
  62         int Radix,
  63         unsigned MinDigits,
  64         int MaxDigits
  65     >
  66     struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits> >
  67     {
  68         typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t;
  69
  70         template <typename ScannerT>
  71         struct result
  72         {
  73             typedef typename match_result<ScannerT, T>::type type;
  74         };
  75
  76         template <typename ScannerT>
  77         typename parser_result<self_t, ScannerT>::type
  78         parse(ScannerT const& scan) const
  79         {
  80             typedef impl::int_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
  81             typedef typename parser_result<impl_t, ScannerT>::type result_t;
  82             return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
  83         }
  84     };
  85
  86     ///////////////////////////////////////////////////////////////////////////
  87     //
  88     //  uint_parser/int_parser instantiations
  89     //
  90     ///////////////////////////////////////////////////////////////////////////
  91     int_parser<int> const
  92         int_p   = int_parser<int>();
  93
  94     uint_parser<unsigned> const
  95         uint_p  = uint_parser<unsigned>();
  96
  97     uint_parser<unsigned, 2> const
  98         bin_p   = uint_parser<unsigned, 2>();
  99
 100     uint_parser<unsigned, 8> const
 101         oct_p   = uint_parser<unsigned, 8>();
 102
 103     uint_parser<unsigned, 16> const
 104         hex_p   = uint_parser<unsigned, 16>();
 105
 106     ///////////////////////////////////////////////////////////////////////////
 107     //
 108     //  sign_parser class
 109     //
 110     ///////////////////////////////////////////////////////////////////////////
 111     namespace impl
 112     {
 113         //  Utility to extract the prefix sign ('-' | '+')
 114         template <typename ScannerT>
 115         bool extract_sign(ScannerT const& scan, std::size_t& count);
 116     }
 117
 118     struct sign_parser : public parser<sign_parser>
 119     {
 120         typedef sign_parser self_t;
 121
 122         template <typename ScannerT>
 123         struct result
 124         {
 125             typedef typename match_result<ScannerT, bool>::type type;
 126         };
 127
 128         sign_parser() {}
 129
 130         template <typename ScannerT>
 131         typename parser_result<self_t, ScannerT>::type
 132         parse(ScannerT const& scan) const
 133         {
 134             if (!scan.at_end())
 135             {
 136                 std::size_t length;
 137                 typename ScannerT::iterator_t save(scan.first);
 138                 bool neg = impl::extract_sign(scan, length);
 139                 if (length)
 140                     return scan.create_match(1, neg, save, scan.first);
 141             }
 142             return scan.no_match();
 143         }
 144     };
 145
 146     sign_parser const sign_p = sign_parser();
 147
 148     ///////////////////////////////////////////////////////////////////////////
 149     //
 150     //  default real number policies
 151     //
 152     ///////////////////////////////////////////////////////////////////////////
 153     template <typename T>
 154     struct ureal_parser_policies
 155     {
 156         // trailing dot policy suggested suggested by Gustavo Guerra
 157         BOOST_STATIC_CONSTANT(bool, allow_leading_dot = true);
 158         BOOST_STATIC_CONSTANT(bool, allow_trailing_dot = true);
 159         BOOST_STATIC_CONSTANT(bool, expect_dot = false);
 160
 161         typedef uint_parser<T, 10, 1, -1>   uint_parser_t;
 162         typedef int_parser<T, 10, 1, -1>    int_parser_t;
 163
 164         template <typename ScannerT>
 165         static typename match_result<ScannerT, nil_t>::type
 166         parse_sign(ScannerT& scan)
 167         {
 168             return scan.no_match();
 169         }
 170
 171         template <typename ScannerT>
 172         static typename parser_result<uint_parser_t, ScannerT>::type
 173         parse_n(ScannerT& scan)
 174         {
 175             return uint_parser_t().parse(scan);
 176         }
 177
 178         template <typename ScannerT>
 179         static typename parser_result<chlit<>, ScannerT>::type
 180         parse_dot(ScannerT& scan)
 181         {
 182             return ch_p('.').parse(scan);
 183         }
 184
 185         template <typename ScannerT>
 186         static typename parser_result<uint_parser_t, ScannerT>::type
 187         parse_frac_n(ScannerT& scan)
 188         {
 189             return uint_parser_t().parse(scan);
 190         }
 191
 192         template <typename ScannerT>
 193         static typename parser_result<chlit<>, ScannerT>::type
 194         parse_exp(ScannerT& scan)
 195         {
 196             return as_lower_d['e'].parse(scan);
 197         }
 198
 199         template <typename ScannerT>
 200         static typename parser_result<int_parser_t, ScannerT>::type
 201         parse_exp_n(ScannerT& scan)
 202         {
 203             return int_parser_t().parse(scan);
 204         }
 205     };
 206
 207     template <typename T>
 208     struct real_parser_policies : public ureal_parser_policies<T>
 209     {
 210         template <typename ScannerT>
 211         static typename parser_result<sign_parser, ScannerT>::type
 212         parse_sign(ScannerT& scan)
 213         {
 214             return sign_p.parse(scan);
 215         }
 216     };
 217
 218     ///////////////////////////////////////////////////////////////////////////
 219     //
 220     //  real_parser class
 221     //
 222     ///////////////////////////////////////////////////////////////////////////
 223     template <
 224         typename T,
 225         typename RealPoliciesT
 226     >
 227     struct real_parser
 228     :   public parser<real_parser<T, RealPoliciesT> >
 229     {
 230         typedef real_parser<T, RealPoliciesT> self_t;
 231
 232         template <typename ScannerT>
 233         struct result
 234         {
 235             typedef typename match_result<ScannerT, T>::type type;
 236         };
 237
 238         real_parser() {}
 239
 240         template <typename ScannerT>
 241         typename parser_result<self_t, ScannerT>::type
 242         parse(ScannerT const& scan) const
 243         {
 244             typedef typename parser_result<self_t, ScannerT>::type result_t;
 245             return impl::real_parser_impl<result_t, T, RealPoliciesT>::parse(scan);
 246         }
 247     };
 248
 249     ///////////////////////////////////////////////////////////////////////////
 250     //
 251     //  real_parser instantiations
 252     //
 253     ///////////////////////////////////////////////////////////////////////////
 254     real_parser<double, ureal_parser_policies<double> > const
 255         ureal_p     = real_parser<double, ureal_parser_policies<double> >();
 256
 257     real_parser<double, real_parser_policies<double> > const
 258         real_p      = real_parser<double, real_parser_policies<double> >();
 259
 260     ///////////////////////////////////////////////////////////////////////////
 261     //
 262     //  strict reals (do not allow plain integers (no decimal point))
 263     //
 264     ///////////////////////////////////////////////////////////////////////////
 265     template <typename T>
 266     struct strict_ureal_parser_policies : public ureal_parser_policies<T>
 267     {
 268         BOOST_STATIC_CONSTANT(bool, expect_dot = true);
 269     };
 270
 271     template <typename T>
 272     struct strict_real_parser_policies : public real_parser_policies<T>
 273     {
 274         BOOST_STATIC_CONSTANT(bool, expect_dot = true);
 275     };
 276
 277     real_parser<double, strict_ureal_parser_policies<double> > const
 278         strict_ureal_p
 279             = real_parser<double, strict_ureal_parser_policies<double> >();
 280
 281     real_parser<double, strict_real_parser_policies<double> > const
 282         strict_real_p
 283             = real_parser<double, strict_real_parser_policies<double> >();
 284
 285 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 286
 287 }} // namespace BOOST_SPIRIT_CLASSIC_NS
 288
 289 #endif