boost::spirit::qi::grammar for Replacing/Removing/append before the parsing of number is executed

[Omar-Medina]

Hello Everyone,
The following grammar can be used for parsing and conversion of String-Hexadezimal/String-Dezimal to number

From string "123" to number 123 OR
From string "0x123" to number 291

template <typename Iterator, typename Skipper>
struct my_grammar : qi::grammar<Iterator, Skipper>
{
  my_grammar() : my_grammar::base_type{value}
  {
    mxnH = qi::no_case[qi::lit("0x")] >> qi::int_parser<int,16>();
    mxnD = qi::int_parser<int,10>();
    nv = mxnH | mxnD ;
  }
  qi::rule<Iterator, int()> mxnH, mxnD, nv;
};

I would like to know, if it is possible to extend the grammar above to parser the following String-Hexadezimal to number:
From string "-0x123" to number -291
From string "+0x123" to number 291
That means . the string to parsed by qi::int_parser<int,16>() shall applied for "-123" or for "+123".
"0x" shall be ignored AND the sign ('-' or '+') shall be considered in the parsing by qi::int_parser<int,16>()

template <typename Iterator, typename Skipper>
struct my_grammar : qi::grammar<Iterator, Skipper>
{
  my_grammar() : my_grammar::base_type{value}
  {
    /* here shall the string to be parsed by int_parser starting with + */
    mxnPH = qi::no_case[qi::lit("+0x")] >> qi::int_parser<int,16>();
    /* here shall the string to be parsed by int_parser starting with - */
    mxnNH = qi::no_case[qi::lit("-0x")] >> qi::int_parser<int,16>();

    mxnH = qi::no_case[qi::lit("0x")] >> qi::int_parser<int,16>();
    mxnD = qi::int_parser<int,10>();
    nv = mxnPH | mxnNH mxnH | mxnD ;
  }
  qi::rule<Iterator, int()> mxnH, mxnD, mxnPH, mxnNH, nv;
};

Thanks in advance for the response

Omar

[Kojoley]

Hmm, int_parser has no extension point or policy to customize extract_sign, that seems like an omission :-(
There is also a question how you would like 0xFFFFFFFF should be handled, fail parsing or produce min() value.

An ugly workaround solution:

#if 1
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;
#else
#include <boost/spirit/home/qi.hpp>
namespace x3 = boost::spirit::qi;
#endif
#include <limits>
#include <iostream>


template <typename T>
struct my_hex_policy
{
    // no nan, no inf, no fraction, no exponent, just plain int
    bool parse_nan(auto&...) const { return false; }
    bool parse_inf(auto&...) const { return false; }
    bool parse_frac_n(auto&...) const { return false; }
    static bool const allow_leading_dot = false;
    static bool const allow_trailing_dot = false;
    static bool const expect_dot = false;
    bool parse_dot(auto&...) const { return false; }
    bool parse_exp(auto&...) const { return false; }
    bool parse_exp_n(auto&...) const { return false; }

    static bool parse_sign(auto& first, auto last)
    {
        return x3::extract_sign(first, last);
    }

    bool parse_n(auto& iter, auto last, T& n) const {
        static_assert(std::numeric_limits<T>::is_integer);
        return x3::parse(iter, last, "0x")
            && x3::parse(iter, last, x3::uint_parser<T, 16>{}, n);
    }
};

template <typename T>
x3::real_parser<T, my_hex_policy<T>> const my_hex{};


int main()
{
    for (auto const& test : { "-0x123", "+0x123", "0x123" }) {
        std::cout << test << ": ";
        int n;
        auto iter = test + 0, end = test + strlen(test);
        if (x3::parse(iter, end, my_hex<int>, n)) {
            std::cout << n;
            if (iter != end)
                std::cout << " (left unparsed: '" << std::string(iter, end) << "')";
            std::cout << '\n';
        }
        else {
            std::cout << "failed to parse";
        }
    }
}

-0x123: -291
+0x123: 291
0x123: 291

[Omar-Medina]

Hello Nikita,
Thanks very much for your time and your reply. I would like to keep my current solution, which consists of checking if the string is starting with "^\s*(+|-)?0[xX]", if yes then the sub-string "0[xX]" will be removed from the string and the modified string is passed to the a specific grammar for "hex". I am managing two grammars. One for decimal-string-values and one for hexadezimal-string-values. In the future. i would like to find a suitable solution for that. It looks like that a grammar can not be parameterized to indicate a hexadecimal- or decimal string-value.
Relate to your question about 0xFFFFFFFF. Yes. I think, i knew , why your are asking. but with the aboved mentioned remove-solution then the response is now delegated to the currenty implementetion of spirit.