简单解决方案

Question

我正在写一个简单的表达式解析器。它基于Boost.Spirit.Qi语法构建，基于Boost.Spirit.Lex标记（Boost版本1.56）。

令牌定义如下：

using namespace boost::spirit;

template<
    typename lexer_t
>
struct tokens
    : lex::lexer<lexer_t>
{
    tokens()
        : /* ... */,
          variable("%(\\w+)")
    {
        this->self =
            /* ... */ |
            variable;
    }

    /* ... */
    lex::token_def<std::string> variable;
};

现在我希望variable标记值只是名称（匹配组(\\w+)）而没有前缀%符号。我该怎么做？

使用匹配组本身并没有帮助。静止值为完整字符串，包括前缀%。

有没有办法强制使用匹配组？

或者至少以某种方式在令牌的行动中引用它？

我也尝试过这样的动作：

variable[lex::_val = std::string(lex::_start + 1, lex::_end)]

但无法编译。错误声称std::string构造函数重载都不能匹配参数：

(const boost::phoenix::actor<Expr>, const boost::spirit::lex::_end_type)

更简单

variable[lex::_val = std::string(lex::_start, lex::_end)]

无法编译。由于类似的原因，现在只有第一个参数类型为boost::spirit::lex::_start_type。

最后我尝试了这个（即使它看起来很浪费）：

lex::_val = std::string(lex::_val).erase(0, 1)

但也无法编译。这次编译器无法从const boost::spirit::lex::_val_type转换为std::string。

有没有办法解决这个问题？

Answer 1

简单解决方案

构建std::string属性值的正确形式如下：

variable[lex::_val = boost::phoenix::construct<std::string>(lex::_start + 1, lex::_end)]

完全按照jv_ {/ 3}} comment的建议。

boost::phoenix::construct由<boost/phoenix/object/construct.hpp>标头提供。或者使用<boost/phoenix.hpp>。

正则表达式解决方案

然而，上述解决方案仅在简单情况下才有效。并且排除了从外部提供模式的可能性（特别是来自配置数据）。由于将模式更改为%(\\w+)%，因此需要更改值构造代码。

这就是为什么能够从定义令牌的正则表达式中引用捕获组会更好。

现在请注意，这仍然不是完美的，因为像%(\\w+)%(\\w+)%这样的奇怪案例仍然需要更改代码才能正确处理。这可以通过不仅配置令牌的正则表达式而且还可以从匹配的范围中形成值来解决。然而，这超出了问题的范围。在许多情况下，直接使用捕获组似乎足够灵活。

在其他地方sehe中的

comment，没有办法使用令牌的正则表达式中的捕获组。更不用说令牌实际上只支持正则表达式的一个子集。（在显着的差异中，例如缺乏对命名捕获组或忽略它们的支持！）。

我在这方面的实验也支持这一点。遗憾地没有办法使用捕获组。但是有一种解决方法 - 你必须在你的行动中重新应用正则表达式。

获取捕获范围的操作

为了使它有点模块化，让我们从最简单的任务开始 - 这个动作返回与指定捕获相对应的令牌匹配的boost::iterator_range部分。

template<typename Attribute, typename Char, typename Idtype>
class basic_get_capture
{
public:
    typedef lex::token_def<Attribute, Char, Idtype> token_type;
    typedef boost::basic_regex<Char> regex_type;

    explicit basic_get_capture(token_type const& token, int capture_index = 1)
        : token(token),
          regex(),
          capture_index(capture_index)
    {
    }

    template<typename Iterator, typename IdType, typename Context>
    boost::iterator_range<Iterator> operator ()(Iterator& first, Iterator& last, lex::pass_flags& /*flag*/, IdType& /*id*/, Context& /*context*/)
    {
        typedef boost::match_results<Iterator> match_results_type;

        match_results_type results;
        regex_match(first, last, results, get_regex());
        typename match_results_type::const_reference capture = results[capture_index];
        return boost::iterator_range<Iterator>(capture.first, capture.second);
    }

private:
    regex_type& get_regex()
    {
        if(regex.empty())
        {
            token_type::string_type const& regex_text = token.definition();
            regex.assign(regex_text);
        }
        return regex;
    }

    token_type const& token;
    regex_type regex;
    int capture_index;
};

template<typename Attribute, typename Char, typename Idtype>
basic_get_capture<Attribute, Char, Idtype> get_capture(lex::token_def<Attribute, Char, Idtype> const& token, int capture_index = 1)
{
    return basic_get_capture<Attribute, Char, Idtype>(token, capture_index);
}

该操作使用Boost.Regex（包括<boost/regex.hpp>）。

获取捕获为字符串的操作

现在因为捕获范围是一件好事，因为它没有为字符串分配任何新的内存，所以它毕竟是我们想要的字符串。所以这里的另一个动作建立在前一个动作之上。

template<typename Attribute, typename Char, typename Idtype>
class basic_get_capture_as_string
{
public:
    typedef basic_get_capture<Attribute, Char, Idtype> basic_get_capture_type;
    typedef typename basic_get_capture_type::token_type token_type;

    explicit basic_get_capture_as_string(token_type const& token, int capture_index = 1)
        : get_capture_functor(token, capture_index)
    {
    }

    template<typename Iterator, typename IdType, typename Context>
    std::basic_string<Char> operator ()(Iterator& first, Iterator& last, lex::pass_flags& flag, IdType& id, Context& context)
    {
        boost::iterator_range<Iterator> const& capture = get_capture_functor(first, last, flag, id, context);
        return std::basic_string<Char>(capture.begin(), capture.end());
    }

private:
    basic_get_capture_type get_capture_functor;
};

template<typename Attribute, typename Char, typename Idtype>
basic_get_capture_as_string<Attribute, Char, Idtype> get_capture_as_string(lex::token_def<Attribute, Char, Idtype> const& token, int capture_index = 1)
{
    return basic_get_capture_as_string<Attribute, Char, Idtype>(token, capture_index);
}

这里没有魔力。我们只是从更简单的操作返回的范围中创建std::basic_string。

动作从捕获中分配值

返回值的操作对我们没用。最终目标是从捕获中设置标记值。这是通过最后一次行动完成的。

template<typename Attribute, typename Char, typename Idtype>
class basic_set_val_from_capture
{
public:
    typedef basic_get_capture_as_string<Attribute, Char, Idtype> basic_get_capture_as_string_type;
    typedef typename basic_get_capture_as_string_type::token_type token_type;

    explicit basic_set_val_from_capture(token_type const& token, int capture_index = 1)
        : get_capture_as_string_functor(token, capture_index)
    {
    }

    template<typename Iterator, typename IdType, typename Context>
    void operator ()(Iterator& first, Iterator& last, lex::pass_flags& flag, IdType& id, Context& context)
    {
        std::basic_string<Char> const& capture = get_capture_as_string_functor(first, last, flag, id, context);
        context.set_value(capture);
    }

private:
    basic_get_capture_as_string_type get_capture_as_string_functor;
};

template<typename Attribute, typename Char, typename Idtype>
basic_set_val_from_capture<Attribute, Char, Idtype> set_val_from_capture(lex::token_def<Attribute, Char, Idtype> const& token, int capture_index = 1)
{
    return basic_set_val_from_capture<Attribute, Char, Idtype>(token, capture_index);
}

讨论

动作的使用方式如下：

variable[set_val_from_capture(variable)]

您可以选择提供第二个参数作为要使用的捕获索引。它默认为1，在大多数情况下似乎都适用。

创建功能

set_val_from_capture（或分别为get_capture_as_string或get_capture）是一个辅助函数，用于从token_def自动扣除模板参数。特别是我们需要的是Char类型来制作相应的正则表达式。

我不确定这是否可以合理地避免，即使这样也会使调用操作符复杂化（特别是如果我们努力缓存正则表达式对象而不是每次重新构建它）。我的疑虑主要来自于不确定Char类型token_def是否需要与标记化序列字符类型相同。我认为他们不必是一样的。

重复令牌

行动绝对令人不快的部分是需要提供令牌本身作为重复的参数。

然而，如上所述和的Char类型需要令牌才能获得正则表达式！

在我看来，至少在理论上我们能够以某种方式获得令牌＆＃34;在运行时＆＃34;基于动作的id参数（我们当前忽略）。但是，我无法找到基于令牌标识符获取token_def的任何方法，无论是来自context参数还是词法分析器本身（可以作为this传递给操作通过创建功能）。

<强>可重用性

由于这些是行动，因此在更复杂的情况下，它们不能真正重复使用（开箱即用）。例如，如果您不仅要获取捕获而且还要将其转换为某个数值，则必须以这种方式编写另一个操作，而不是在令牌处执行复杂操作。

起初我试图达到这样的目的：

variable[lex::_val = get_capture_as_string(variable)]

它似乎更灵活，因为您可以轻松地在其周围添加更多代码 - 例如将其包装在某些转换函数中。

但我没能实现它。虽然我觉得我没有那么努力。了解Boost.Phoenix的更多信息肯定会对此有所帮助。

双重工作

所有这些解决方法并不能阻止我们进行双重工作。两者都在正则表达式解析然后匹配。但正如开头所提到的，似乎没有更好的方法（不改变Boost.Spirit本身）。

如何使Boost.Spirit.Lex标记值成为匹配序列的子字符串（最好通过正则表达式匹配组）

1 个答案:

简单解决方案

正则表达式解决方案

获取捕获范围的操作

获取捕获为字符串的操作

动作从捕获中分配值

讨论