Question

当我在词法分析器中定义时

typedef boost::mpl::vector<std::string, unsigned int, bool>
            token_value_types;
lex::token_def<unsigned int> lit_uint("[0-9]+", token_ids::lit_uint);

然后在某些语法中使用它

primary_expr =
        lexer.lit_uint
    |   lexer.true_or_false
    |   identifier
    |   '(' > expr > ')'
    ;

那么如何将字符串转换为正确的标记值类型（在这种情况下为unsigned int）的值？如果将自定义类型或浮点类型指定为标记值类型，会发生什么？转换例程的存在在哪里（我认为类似 boost::iterator_range到double 转换）？

Answer 1

实现目标的方法是专攻assign_to_attribute_from_iterators。您可以找到自定义类型here的示例。如果您在令牌定义中使用double作为属性，则精灵在内部使用qi::double_来解析值。（你可以找到here double和其他基本类型的专门化。

愚蠢的例子，我将real令牌定义为非,或;的任何内容，以显示double s的解析。

#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/qi.hpp>

namespace lex = boost::spirit::lex;
namespace qi = boost::spirit::qi;
namespace mpl = boost::mpl;


template <typename Lexer>
struct my_lexer : lex::lexer<Lexer>
{
    my_lexer()
    {
        real = "[^,;]*"; //anything that is not a , or ; is a real number

        this->self=lex::token_def<lex::omit>(',')| ';';

        this->self.add(real);
    }
    lex::token_def<double> real;
};


int main()
{
    // the token type needs to know the iterator type of the underlying
    // input and the set of used token value types
    typedef lex::lexertl::token<std::string::iterator,
        mpl::vector<double> > token_type;

    // use actor_lexer<> here if your token definitions have semantic
    // actions
    typedef lex::lexertl::lexer<token_type> lexer_type;

    // this is the iterator exposed by the lexer, we use this for parsing
    typedef lexer_type::iterator_type iterator_type;

    // create a lexer instance
    std::string input("3.4,2,.4,4.,infinity,NaN,-3.8,1e2,1.5E3;");
    std::string::iterator s = input.begin();

    my_lexer<lexer_type> lex;
    iterator_type b = lex.begin(s, input.end());

    // use the embedded token_def as a parser, it exposes its token value type
    // as its parser attribute type
    std::vector<double> result;
    qi::rule<iterator_type,double()> number= lex.real;
    qi::rule<iterator_type,std::vector<double>()> sequence= number >> *(',' >> number) >> ';';
    BOOST_SPIRIT_DEBUG_NODE(number);
    BOOST_SPIRIT_DEBUG_NODE(sequence);
    if (!qi::parse(b, lex.end(), sequence, result))
    {
        std::cerr << "Parsing failed!" << std::endl;
        return -1;
    }

    std::cout << "Parsing succeeded:"  << std::endl;
    for(auto& n : result)
        std::cout << n << std::endl;
    return 0;
}

编辑： 我对正则表达式的经验很少，但我相信令牌定义等同于评论中链接的语法（我认为应该有{ {1}}而不是fractional_constant >> -exponent_part）将是：

fractional_constant >> !exponent_part

转换为token_def的值类型

1 个答案: