123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313 |
- /*=============================================================================
- Copyright (c) 2001-2003 Joel de Guzman
- Copyright (c) 2001-2003 Hartmut Kaiser
- http://spirit.sourceforge.net/
- Use, modification and distribution is subject to 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)
- =============================================================================*/
- #include <boost/spirit/include/classic_core.hpp>
- #include <boost/spirit/include/classic_assign_actor.hpp>
- #include <boost/detail/lightweight_test.hpp>
- #include <iostream>
- #include <climits>
- using namespace std;
- using namespace BOOST_SPIRIT_CLASSIC_NS;
- template <typename T>
- struct ts_real_parser_policies : public ureal_parser_policies<T>
- {
- // These policies can be used to parse thousand separated
- // numbers with at most 2 decimal digits after the decimal
- // point. e.g. 123,456,789.01
- typedef uint_parser<int, 10, 1, 2> uint2_t;
- typedef uint_parser<T, 10, 1, -1> uint_parser_t;
- typedef int_parser<int, 10, 1, -1> int_parser_t;
- ////////////////////////////////// 2 decimal places Max
- template <typename ScannerT>
- static typename parser_result<uint2_t, ScannerT>::type
- parse_frac_n(ScannerT& scan)
- { return uint2_t().parse(scan); }
- ////////////////////////////////// No exponent
- template <typename ScannerT>
- static typename parser_result<chlit<>, ScannerT>::type
- parse_exp(ScannerT& scan)
- { return scan.no_match(); }
- ////////////////////////////////// No exponent
- template <typename ScannerT>
- static typename parser_result<int_parser_t, ScannerT>::type
- parse_exp_n(ScannerT& scan)
- { return scan.no_match(); }
- ////////////////////////////////// Thousands separated numbers
- template <typename ScannerT>
- static typename parser_result<uint_parser_t, ScannerT>::type
- parse_n(ScannerT& scan)
- {
- typedef typename parser_result<uint_parser_t, ScannerT>::type RT;
- static uint_parser<unsigned, 10, 1, 3> uint3_p;
- static uint_parser<unsigned, 10, 3, 3> uint3_3_p;
- if (RT hit = uint3_p.parse(scan))
- {
- T n;
- typedef typename ScannerT::iterator_t iterator_t;
- iterator_t save = scan.first;
- while (match<> next = (',' >> uint3_3_p[assign_a(n)]).parse(scan))
- {
- hit.value((hit.value() * 1000) + n);
- scan.concat_match(hit, next);
- save = scan.first;
- }
- scan.first = save;
- return hit;
- }
- return scan.no_match();
- }
- };
- real_parser<double, ts_real_parser_policies<double> > const
- ts_real_p = real_parser<double, ts_real_parser_policies<double> >();
- template <typename T>
- struct no_trailing_dot : public real_parser_policies<T>
- {
- static const bool allow_trailing_dot = false;
- };
- real_parser<double, no_trailing_dot<double> > const
- notrdot_real_p = real_parser<double, no_trailing_dot<double> >();
- template <typename T>
- struct no_leading_dot : public real_parser_policies<T>
- {
- static const bool allow_leading_dot = false;
- };
- real_parser<double, no_leading_dot<double> > const
- nolddot_real_p = real_parser<double, no_leading_dot<double> >();
- ///////////////////////////////////////////////////////////////////////////////
- int
- main()
- {
- cout << "/////////////////////////////////////////////////////////\n\n";
- cout << "\t\tNumeric tests...\n\n";
- cout << "/////////////////////////////////////////////////////////\n\n";
- // *** The following assumes 32 bit integers. Modify these constant
- // *** strings when appropriate. BEWARE PLATFORM DEPENDENT!
- char const* max_unsigned = "4294967295";
- char const* unsigned_overflow = "4294967296";
- char const* max_int = "2147483647";
- char const* int_overflow = "2147483648";
- char const* min_int = "-2147483648";
- char const* int_underflow = "-2147483649";
- char const* max_binary = "11111111111111111111111111111111";
- char const* binary_overflow = "100000000000000000000000000000000";
- char const* max_octal = "37777777777";
- char const* octal_overflow = "100000000000";
- char const* max_hex = "FFFFFFFF";
- char const* hex_overflow = "100000000";
- #ifdef BOOST_HAS_LONG_LONG
- char const* max_long_long = "9223372036854775807";
- char const* long_long_overflow = "9223372036854775808";
- char const* min_long_long = "-9223372036854775808";
- char const* long_long_underflow = "-9223372036854775809";
- #endif
- // BEGIN TESTS...
- unsigned u;
- // unsigned integer
- parse("123456", uint_p[assign_a(u)]);
- BOOST_TEST(u == 123456);
- parse(max_unsigned, uint_p[assign_a(u)]);
- BOOST_TEST(u == UINT_MAX);
- BOOST_TEST(!parse(unsigned_overflow, uint_p).full);
- // signed integer
- int i;
- parse("123456", int_p[assign_a(i)]);
- BOOST_TEST(i == 123456);
- parse("-123456", int_p[assign_a(i)]);
- BOOST_TEST(i == -123456);
- parse(max_int, int_p[assign_a(i)]);
- BOOST_TEST(i == INT_MAX);
- parse(min_int, int_p[assign_a(i)]);
- BOOST_TEST(i == INT_MIN);
- BOOST_TEST(!parse(int_overflow, int_p).full);
- BOOST_TEST(!parse(int_underflow, int_p).full);
- BOOST_TEST(!parse("-", int_p).hit);
- // binary
- parse("11111110", bin_p[assign_a(u)]);
- BOOST_TEST(u == 0xFE);
- parse(max_binary, bin_p[assign_a(u)]);
- BOOST_TEST(u == UINT_MAX);
- BOOST_TEST(!parse(binary_overflow, bin_p).full);
- // octal
- parse("12545674515", oct_p[assign_a(u)]);
- BOOST_TEST(u == 012545674515);
- parse(max_octal, oct_p[assign_a(u)]);
- BOOST_TEST(u == UINT_MAX);
- BOOST_TEST(!parse(octal_overflow, oct_p).full);
- // hex
- parse("95BC8DF", hex_p[assign_a(u)]);
- BOOST_TEST(u == 0x95BC8DF);
- parse("abcdef12", hex_p[assign_a(u)]);
- BOOST_TEST(u == 0xabcdef12);
- parse(max_hex, hex_p[assign_a(u)]);
- BOOST_TEST(u == UINT_MAX);
- BOOST_TEST(!parse(hex_overflow, hex_p).full);
- // limited fieldwidth
- uint_parser<unsigned, 10, 1, 3> uint3_p;
- parse("123456", uint3_p[assign_a(u)]);
- BOOST_TEST(u == 123);
- uint_parser<unsigned, 10, 1, 4> uint4_p;
- parse("123456", uint4_p[assign_a(u)]);
- BOOST_TEST(u == 1234);
- uint_parser<unsigned, 10, 3, 3> uint3_3_p;
- // thousand separated numbers
- #define r (uint3_p >> *(',' >> uint3_3_p))
- BOOST_TEST(parse("1,234,567,890", r).full); // OK
- BOOST_TEST(parse("12,345,678,900", r).full); // OK
- BOOST_TEST(parse("123,456,789,000", r).full); // OK
- BOOST_TEST(!parse("1000,234,567,890", r).full); // Bad
- BOOST_TEST(!parse("1,234,56,890", r).full); // Bad
- BOOST_TEST(!parse("1,66", r).full); // Bad
- // long long
- #ifdef BOOST_HAS_LONG_LONG
- // Some compilers have long long, but don't define the
- // LONG_LONG_MIN and LONG_LONG_MAX macros in limits.h. This
- // assumes that long long is 64 bits.
- #if !defined(LONG_LONG_MIN) && !defined(LONG_LONG_MAX) \
- && !defined(ULONG_LONG_MAX)
- #define ULONG_LONG_MAX 0xffffffffffffffffLLU
- #define LONG_LONG_MAX 0x7fffffffffffffffLL
- #define LONG_LONG_MIN (-LONG_LONG_MAX - 1)
- #endif
- ::boost::long_long_type ll;
- int_parser< ::boost::long_long_type> long_long_p;
- parse("1234567890123456789", long_long_p[assign_a(ll)]);
- BOOST_TEST(ll == 1234567890123456789LL);
- parse("-1234567890123456789", long_long_p[assign_a(ll)]);
- BOOST_TEST(ll == -1234567890123456789LL);
- parse(max_long_long, long_long_p[assign_a(ll)]);
- BOOST_TEST(ll == LONG_LONG_MAX);
- parse(min_long_long, long_long_p[assign_a(ll)]);
- BOOST_TEST(ll == LONG_LONG_MIN);
- #if defined(__GNUG__) && (__GNUG__ == 3) && (__GNUC_MINOR__ < 3) \
- && !defined(__EDG__)
- // gcc 3.2.3 crashes on parse(long_long_overflow, long_long_p)
- // wrapping long_long_p into a rule avoids the crash
- rule<> gcc_3_2_3_long_long_r = long_long_p;
- BOOST_TEST(!parse(long_long_overflow, gcc_3_2_3_long_long_r).full);
- BOOST_TEST(!parse(long_long_underflow, gcc_3_2_3_long_long_r).full);
- #else
- BOOST_TEST(!parse(long_long_overflow, long_long_p).full);
- BOOST_TEST(!parse(long_long_underflow, long_long_p).full);
- #endif
- #endif
- // real numbers
- double d;
- BOOST_TEST(parse("1234", ureal_p[assign_a(d)]).full && d == 1234); // Good.
- BOOST_TEST(parse("1.2e3", ureal_p[assign_a(d)]).full && d == 1.2e3); // Good.
- BOOST_TEST(parse("1.2e-3", ureal_p[assign_a(d)]).full && d == 1.2e-3); // Good.
- BOOST_TEST(parse("1.e2", ureal_p[assign_a(d)]).full && d == 1.e2); // Good.
- BOOST_TEST(parse(".2e3", ureal_p[assign_a(d)]).full && d == .2e3); // Good.
- BOOST_TEST(parse("2e3", ureal_p[assign_a(d)]).full && d == 2e3); // Good. No fraction
- BOOST_TEST(!parse("e3", ureal_p).full); // Bad! No number
- BOOST_TEST(!parse("-1.2e3", ureal_p).full); // Bad! Negative number
- BOOST_TEST(!parse("+1.2e3", ureal_p).full); // Bad! Positive sign
- BOOST_TEST(!parse("1.2e", ureal_p).full); // Bad! No exponent
- BOOST_TEST(!parse("-.3", ureal_p).full); // Bad! Negative
- BOOST_TEST(parse("-1234", real_p[assign_a(d)]).full && d == -1234); // Good.
- BOOST_TEST(parse("-1.2e3", real_p[assign_a(d)]).full && d == -1.2e3); // Good.
- BOOST_TEST(parse("+1.2e3", real_p[assign_a(d)]).full && d == 1.2e3); // Good.
- BOOST_TEST(parse("-0.1", real_p[assign_a(d)]).full && d == -0.1); // Good.
- BOOST_TEST(parse("-1.2e-3", real_p[assign_a(d)]).full && d == -1.2e-3); // Good.
- BOOST_TEST(parse("-1.e2", real_p[assign_a(d)]).full && d == -1.e2); // Good.
- BOOST_TEST(parse("-.2e3", real_p[assign_a(d)]).full && d == -.2e3); // Good.
- BOOST_TEST(parse("-2e3", real_p[assign_a(d)]).full && d == -2e3); // Good. No fraction
- BOOST_TEST(!parse("-e3", real_p).full); // Bad! No number
- BOOST_TEST(!parse("-1.2e", real_p).full); // Bad! No exponent
- BOOST_TEST(!parse("1234", strict_ureal_p[assign_a(d)]).full); // Bad. Strict real
- BOOST_TEST(parse("1.2", strict_ureal_p[assign_a(d)]).full && d == 1.2); // Good.
- BOOST_TEST(!parse("-1234", strict_real_p[assign_a(d)]).full); // Bad. Strict real
- BOOST_TEST(parse("123.", strict_real_p[assign_a(d)]).full && d == 123); // Good.
- BOOST_TEST(parse("3.E6", strict_real_p[assign_a(d)]).full && d == 3e6); // Good.
- BOOST_TEST(!parse("1234.", notrdot_real_p[assign_a(d)]).full); // Bad trailing dot
- BOOST_TEST(!parse(".1234", nolddot_real_p[assign_a(d)]).full); // Bad leading dot
- // Special thousands separated numbers
- BOOST_TEST(parse("123,456,789.01", ts_real_p[assign_a(d)]).full && d == 123456789.01); // Good.
- BOOST_TEST(parse("12,345,678.90", ts_real_p[assign_a(d)]).full && d == 12345678.90); // Good.
- BOOST_TEST(parse("1,234,567.89", ts_real_p[assign_a(d)]).full && d == 1234567.89); // Good.
- BOOST_TEST(!parse("1234,567,890", ts_real_p).full); // Bad.
- BOOST_TEST(!parse("1,234,5678,9", ts_real_p).full); // Bad.
- BOOST_TEST(!parse("1,234,567.89e6", ts_real_p).full); // Bad.
- BOOST_TEST(!parse("1,66", ts_real_p).full); // Bad.
- // END TESTS.
- /////////////////////////////////////////////////////////////////
- return boost::report_errors();
- }
|