stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
@@ -0,0 +1,159 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2009 Hartmut Kaiser
|
||||
Copyright (c) 2014 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(SPIRIT_X3_BOOL_SEP_29_2009_0709AM)
|
||||
#define SPIRIT_X3_BOOL_SEP_29_2009_0709AM
|
||||
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/numeric/bool_policies.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
template <typename T, typename Encoding, typename BoolPolicies = bool_policies<T>>
|
||||
struct bool_parser : parser<bool_parser<T, Encoding, BoolPolicies>>
|
||||
{
|
||||
typedef Encoding encoding;
|
||||
typedef T attribute_type;
|
||||
static bool const has_attribute = true;
|
||||
|
||||
bool_parser()
|
||||
: policies() {}
|
||||
|
||||
bool_parser(BoolPolicies const& policies)
|
||||
: policies(policies) {}
|
||||
|
||||
template <typename Iterator, typename Context>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, T& attr) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
return policies.parse_true(first, last, attr, get_case_compare<encoding>(context))
|
||||
|| policies.parse_false(first, last, attr, get_case_compare<encoding>(context));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute& attr_param) const
|
||||
{
|
||||
// this case is called when Attribute is not T
|
||||
T attr_;
|
||||
if (parse(first, last, context, unused, attr_))
|
||||
{
|
||||
traits::move_to(attr_, attr_param);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
BoolPolicies policies;
|
||||
};
|
||||
|
||||
template <typename T, typename Encoding, typename BoolPolicies = bool_policies<T>>
|
||||
struct literal_bool_parser : parser<bool_parser<T, Encoding, BoolPolicies>>
|
||||
{
|
||||
typedef Encoding encoding;
|
||||
typedef T attribute_type;
|
||||
static bool const has_attribute = true;
|
||||
|
||||
template <typename Value>
|
||||
literal_bool_parser(Value const& n)
|
||||
: policies(), n_(n) {}
|
||||
|
||||
template <typename Value>
|
||||
literal_bool_parser(Value const& n, BoolPolicies const& policies)
|
||||
: policies(policies), n_(n) {}
|
||||
|
||||
template <typename Iterator, typename Context>
|
||||
bool parse_main(Iterator& first, Iterator const& last
|
||||
, Context& context, T& attr) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
return (n_ && policies.parse_true(first, last, attr, get_case_compare<encoding>(context)))
|
||||
|| (!n_ && policies.parse_false(first, last, attr, get_case_compare<encoding>(context)));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Context>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context& context, unused_type, T& attr) const
|
||||
{
|
||||
return parse_main(first, last, context, attr);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute& attr_param) const
|
||||
{
|
||||
// this case is called when Attribute is not T
|
||||
T attr_;
|
||||
if (parse_main(first, last, context, attr_))
|
||||
{
|
||||
traits::move_to(attr_, attr_param);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
BoolPolicies policies;
|
||||
T n_;
|
||||
};
|
||||
|
||||
namespace standard
|
||||
{
|
||||
typedef bool_parser<bool, char_encoding::standard> bool_type;
|
||||
bool_type const bool_ = {};
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::standard> true_type;
|
||||
true_type const true_ = { true };
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::standard> false_type;
|
||||
false_type const false_ = { false };
|
||||
}
|
||||
|
||||
namespace standard_wide
|
||||
{
|
||||
typedef bool_parser<bool, char_encoding::standard_wide> bool_type;
|
||||
bool_type const bool_ = {};
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::standard_wide> true_type;
|
||||
true_type const true_ = { true };
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::standard_wide> false_type;
|
||||
false_type const false_ = { false };
|
||||
}
|
||||
|
||||
namespace ascii
|
||||
{
|
||||
typedef bool_parser<bool, char_encoding::ascii> bool_type;
|
||||
bool_type const bool_ = {};
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::ascii> true_type;
|
||||
true_type const true_ = { true };
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::ascii> false_type;
|
||||
false_type const false_ = { false };
|
||||
}
|
||||
|
||||
namespace iso8859_1
|
||||
{
|
||||
typedef bool_parser<bool, char_encoding::iso8859_1> bool_type;
|
||||
bool_type const bool_ = {};
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::iso8859_1> true_type;
|
||||
true_type const true_ = { true };
|
||||
|
||||
typedef literal_bool_parser<bool, char_encoding::iso8859_1> false_type;
|
||||
false_type const false_ = { false };
|
||||
}
|
||||
|
||||
using standard::bool_;
|
||||
using standard::true_;
|
||||
using standard::false_;
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,48 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2009 Hartmut Kaiser
|
||||
Copyright (c) 2014 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(SPIRIT_QI_BOOL_POLICIES_SEP_29_2009_0710AM)
|
||||
#define SPIRIT_QI_BOOL_POLICIES_SEP_29_2009_0710AM
|
||||
|
||||
#include <boost/spirit/home/x3/string/detail/string_parse.hpp>
|
||||
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// Default boolean policies
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <typename T = bool>
|
||||
struct bool_policies
|
||||
{
|
||||
template <typename Iterator, typename Attribute, typename CaseCompare>
|
||||
static bool
|
||||
parse_true(Iterator& first, Iterator const& last, Attribute& attr_, CaseCompare const& case_compare)
|
||||
{
|
||||
if (detail::string_parse("true", first, last, unused, case_compare))
|
||||
{
|
||||
traits::move_to(T(true), attr_); // result is true
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Attribute, typename CaseCompare>
|
||||
static bool
|
||||
parse_false(Iterator& first, Iterator const& last, Attribute& attr_, CaseCompare const& case_compare)
|
||||
{
|
||||
if (detail::string_parse("false", first, last, unused, case_compare))
|
||||
{
|
||||
traits::move_to(T(false), attr_); // result is false
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,62 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(BOOST_SPIRIT_X3_INT_APR_17_2006_0830AM)
|
||||
#define BOOST_SPIRIT_X3_INT_APR_17_2006_0830AM
|
||||
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/support/numeric_utils/extract_int.hpp>
|
||||
#include <cstdint>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <
|
||||
typename T
|
||||
, unsigned Radix = 10
|
||||
, unsigned MinDigits = 1
|
||||
, int MaxDigits = -1>
|
||||
struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits>>
|
||||
{
|
||||
// check template parameter 'Radix' for validity
|
||||
static_assert(
|
||||
(Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16),
|
||||
"Error Unsupported Radix");
|
||||
|
||||
typedef T attribute_type;
|
||||
static bool const has_attribute = true;
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute& attr) const
|
||||
{
|
||||
typedef extract_int<T, Radix, MinDigits, MaxDigits> extract;
|
||||
x3::skip_over(first, last, context);
|
||||
return extract::call(first, last, attr);
|
||||
}
|
||||
};
|
||||
|
||||
#define BOOST_SPIRIT_X3_INT_PARSER(int_type, name) \
|
||||
typedef int_parser<int_type> name##type; \
|
||||
name##type const name = {}; \
|
||||
/***/
|
||||
|
||||
BOOST_SPIRIT_X3_INT_PARSER(long, long_)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(short, short_)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(int, int_)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(long long, long_long)
|
||||
|
||||
BOOST_SPIRIT_X3_INT_PARSER(int8_t, int8)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(int16_t, int16)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(int32_t, int32)
|
||||
BOOST_SPIRIT_X3_INT_PARSER(int64_t, int64)
|
||||
|
||||
#undef BOOST_SPIRIT_X3_INT_PARSER
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,62 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(BOOST_SPIRIT_X3_REAL_APRIL_18_2006_0850AM)
|
||||
#define BOOST_SPIRIT_X3_REAL_APRIL_18_2006_0850AM
|
||||
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/numeric/real_policies.hpp>
|
||||
#include <boost/spirit/home/x3/support/numeric_utils/extract_real.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
template <typename T, typename RealPolicies = real_policies<T> >
|
||||
struct real_parser : parser<real_parser<T, RealPolicies> >
|
||||
{
|
||||
typedef T attribute_type;
|
||||
static bool const has_attribute = true;
|
||||
|
||||
real_parser()
|
||||
: policies() {}
|
||||
|
||||
real_parser(RealPolicies const& policies)
|
||||
: policies(policies) {}
|
||||
|
||||
template <typename Iterator, typename Context>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context& context, unused_type, T& attr_) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
return extract_real<T, RealPolicies>::parse(first, last, attr_, policies);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context& context, unused_type, Attribute& attr_param) const
|
||||
{
|
||||
// this case is called when Attribute is not T
|
||||
T attr_;
|
||||
if (parse(first, last, context, unused, attr_))
|
||||
{
|
||||
traits::move_to(attr_, attr_param);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
RealPolicies policies;
|
||||
};
|
||||
|
||||
typedef real_parser<float> float_type;
|
||||
float_type const float_ = {};
|
||||
|
||||
typedef real_parser<double> double_type;
|
||||
double_type const double_ = {};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,182 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
Copyright (c) 2001-2011 Hartmut Kaiser
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(SPIRIT_REAL_POLICIES_APRIL_17_2006_1158PM)
|
||||
#define SPIRIT_REAL_POLICIES_APRIL_17_2006_1158PM
|
||||
|
||||
#include <boost/spirit/home/x3/string/detail/string_parse.hpp>
|
||||
#include <boost/spirit/home/x3/support/numeric_utils/extract_int.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// Default (unsigned) real number policies
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <typename T>
|
||||
struct ureal_policies
|
||||
{
|
||||
// trailing dot policy suggested by Gustavo Guerra
|
||||
static bool const allow_leading_dot = true;
|
||||
static bool const allow_trailing_dot = true;
|
||||
static bool const expect_dot = false;
|
||||
|
||||
template <typename Iterator>
|
||||
static bool
|
||||
parse_sign(Iterator& /*first*/, Iterator const& /*last*/)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Attribute>
|
||||
static bool
|
||||
parse_n(Iterator& first, Iterator const& last, Attribute& attr_)
|
||||
{
|
||||
return extract_uint<T, 10, 1, -1>::call(first, last, attr_);
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
static bool
|
||||
parse_dot(Iterator& first, Iterator const& last)
|
||||
{
|
||||
if (first == last || *first != '.')
|
||||
return false;
|
||||
++first;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Attribute>
|
||||
static bool
|
||||
parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr_)
|
||||
{
|
||||
return extract_uint<T, 10, 1, -1, true>::call(first, last, attr_);
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
static bool
|
||||
parse_exp(Iterator& first, Iterator const& last)
|
||||
{
|
||||
if (first == last || (*first != 'e' && *first != 'E'))
|
||||
return false;
|
||||
++first;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
static bool
|
||||
parse_exp_n(Iterator& first, Iterator const& last, int& attr_)
|
||||
{
|
||||
return extract_int<int, 10, 1, -1>::call(first, last, attr_);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
// The parse_nan() and parse_inf() functions get called whenever:
|
||||
//
|
||||
// - a number to parse does not start with a digit (after having
|
||||
// successfully parsed an optional sign)
|
||||
//
|
||||
// or
|
||||
//
|
||||
// - after a floating point number of the value 1 (having no
|
||||
// exponential part and a fractional part value of 0) has been
|
||||
// parsed.
|
||||
//
|
||||
// The first call allows to recognize representations of NaN or Inf
|
||||
// starting with a non-digit character (such as NaN, Inf, QNaN etc.).
|
||||
//
|
||||
// The second call allows to recognize representation formats starting
|
||||
// with a 1.0 (such as 1.0#NAN or 1.0#INF etc.).
|
||||
//
|
||||
// The functions should return true if a Nan or Inf has been found. In
|
||||
// this case the attr should be set to the matched value (NaN or
|
||||
// Inf). The optional sign will be automatically applied afterwards.
|
||||
//
|
||||
// The default implementation below recognizes representations of NaN
|
||||
// and Inf as mandated by the C99 Standard and as proposed for
|
||||
// inclusion into the C++0x Standard: nan, nan(...), inf and infinity
|
||||
// (the matching is performed case-insensitively).
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
template <typename Iterator, typename Attribute>
|
||||
static bool
|
||||
parse_nan(Iterator& first, Iterator const& last, Attribute& attr_)
|
||||
{
|
||||
if (first == last)
|
||||
return false; // end of input reached
|
||||
|
||||
if (*first != 'n' && *first != 'N')
|
||||
return false; // not "nan"
|
||||
|
||||
// nan[(...)] ?
|
||||
if (detail::string_parse("nan", "NAN", first, last, unused))
|
||||
{
|
||||
if (*first == '(')
|
||||
{
|
||||
// skip trailing (...) part
|
||||
Iterator i = first;
|
||||
|
||||
while (++i != last && *i != ')')
|
||||
;
|
||||
if (i == last)
|
||||
return false; // no trailing ')' found, give up
|
||||
|
||||
first = ++i;
|
||||
}
|
||||
attr_ = std::numeric_limits<T>::quiet_NaN();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Attribute>
|
||||
static bool
|
||||
parse_inf(Iterator& first, Iterator const& last, Attribute& attr_)
|
||||
{
|
||||
if (first == last)
|
||||
return false; // end of input reached
|
||||
|
||||
if (*first != 'i' && *first != 'I')
|
||||
return false; // not "inf"
|
||||
|
||||
// inf or infinity ?
|
||||
if (detail::string_parse("inf", "INF", first, last, unused))
|
||||
{
|
||||
// skip allowed 'inity' part of infinity
|
||||
detail::string_parse("inity", "INITY", first, last, unused);
|
||||
attr_ = std::numeric_limits<T>::infinity();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// Default (signed) real number policies
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <typename T>
|
||||
struct real_policies : ureal_policies<T>
|
||||
{
|
||||
template <typename Iterator>
|
||||
static bool
|
||||
parse_sign(Iterator& first, Iterator const& last)
|
||||
{
|
||||
return extract_sign(first, last);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct strict_ureal_policies : ureal_policies<T>
|
||||
{
|
||||
static bool const expect_dot = true;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct strict_real_policies : real_policies<T>
|
||||
{
|
||||
static bool const expect_dot = true;
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,75 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
Copyright (c) 2011 Jan Frederick Eick
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(BOOST_SPIRIT_X3_UINT_APR_17_2006_0901AM)
|
||||
#define BOOST_SPIRIT_X3_UINT_APR_17_2006_0901AM
|
||||
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/support/numeric_utils/extract_int.hpp>
|
||||
#include <cstdint>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <
|
||||
typename T
|
||||
, unsigned Radix = 10
|
||||
, unsigned MinDigits = 1
|
||||
, int MaxDigits = -1>
|
||||
struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits>>
|
||||
{
|
||||
// check template parameter 'Radix' for validity
|
||||
static_assert(
|
||||
(Radix >= 2 && Radix <= 36),
|
||||
"Error Unsupported Radix");
|
||||
|
||||
typedef T attribute_type;
|
||||
static bool const has_attribute = true;
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute& attr) const
|
||||
{
|
||||
typedef extract_uint<T, Radix, MinDigits, MaxDigits> extract;
|
||||
x3::skip_over(first, last, context);
|
||||
return extract::call(first, last, attr);
|
||||
}
|
||||
};
|
||||
|
||||
#define BOOST_SPIRIT_X3_UINT_PARSER(uint_type, name) \
|
||||
typedef uint_parser<uint_type> name##type; \
|
||||
name##type const name = {}; \
|
||||
/***/
|
||||
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned long, ulong_)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned short, ushort_)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned int, uint_)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned long long, ulong_long)
|
||||
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(uint8_t, uint8)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(uint16_t, uint16)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(uint32_t, uint32)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(uint64_t, uint64)
|
||||
|
||||
#undef BOOST_SPIRIT_X3_UINT_PARSER
|
||||
|
||||
#define BOOST_SPIRIT_X3_UINT_PARSER(uint_type, radix, name) \
|
||||
typedef uint_parser<uint_type, radix> name##type; \
|
||||
name##type const name = name##type(); \
|
||||
/***/
|
||||
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned, 2, bin)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned, 8, oct)
|
||||
BOOST_SPIRIT_X3_UINT_PARSER(unsigned, 16, hex)
|
||||
|
||||
#undef BOOST_SPIRIT_X3_UINT_PARSER
|
||||
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user