Parsing float followed by string containing "e" character

Question

I'm trying to parse this type of string

1.2e3ex
1.2e3 ex

And have set up

x3::float_ >> "ex"

Unfortunately, this fails to parse

1ex

Full example code:

#include <iostream>
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;

const auto parser = x3::float_ >> "em";

int main()
{
  std::string input = "1em";
  auto first = input.begin();
  auto last = input.end();

  float value{};
  bool result = x3::phrase_parse(first, last, parser, x3::blank, value);

  if(result)
  {
    if(first == last)
      std::cout << "parse succesful: " << value << '\n';
    else
      std::cout << "incomplete parse: " << value << '\n';
  }
  else
    std::cout << "parse unsuccesful\n";
}

Available live on Coliru as well.

It seems I'd need to jump through some hoops,

struct non_scientific_float_policy : x3::real_policies<float>
{
  template <typename Iterator>
  static bool parse_exp(Iterator& first, Iterator const& last)
  {
    return false;
  }
};

const auto non_scientific_float = x3::real_parser<float, non_scientific_float_policy>{};

and provide an alternative:

const auto parser = non_scientific_float >> "em" | x3::float_ >> "em";

Is there no other way?

Answer 1

You can solve the issue by tuning the real policy parse_exp in such way that exponent detection must expect not only [eE] character but [eE][-+]?[0-9].

#include <iostream>
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;

template <typename T>
struct alt_real_policies : x3::real_policies<T>
{
    template <typename Iterator>
    static bool parse_exp(Iterator& first, Iterator const& last)
    {
        Iterator save = first;
        if (x3::real_policies<T>::parse_exp(first, last)) {
            Iterator iter = first;
            if (x3::extract_int<x3::unused_type, 10, 1, 1>::call(iter, last, x3::unused))
                return true;
        }
        first = save;
        return false;
    }

};

const x3::real_parser<float, alt_real_policies<float>> altfloat;
const auto parser = altfloat >> "em";

int main()
{
    std::string input = "1em";
    auto first = input.begin();
    auto last = input.end();

    float value{};
    bool result = x3::phrase_parse(first, last, parser, x3::blank, value);

    if (result)
    {
        if (first == last)
            std::cout << "parse succesful: " << value << '\n';
        else
            std::cout << "incomplete parse: " << value << '\n';
    }
    else
        std::cout << "parse unsuccesful\n";
}

http://coliru.stacked-crooked.com/a/f60f334c960cb602

Answer 2

You can use an alternative policy for non-greedy parsing of the exponent. The very simplest I can think of is:

Live On Coliru

#include <boost/spirit/home/x3.hpp>
#include <iostream>
namespace x3 = boost::spirit::x3;

template <typename T>
struct no_exponent : x3::real_policies<T> {
    template <typename It>
        static bool parse_exp(It, It) { return false; }
};

x3::real_parser<double, no_exponent<double> > noexp_;

const auto parser = (x3::float_ | noexp_) >> "em";

int main() {
    std::string input = "-1.67em";
    auto first = input.begin();
    auto last = input.end();

    float value{};
    bool result = x3::phrase_parse(first, last, parser, x3::blank, value);

    if (result) {
        if (first == last)
            std::cout << "parse succesful: " << value << '\n';
        else
            std::cout << "incomplete parse: " << value << '\n';
    } else
    {
        std::cout << "parse unsuccesful\n";
    }
}

Printing:

parse succesful: -1.67