如何获取正则表达式字符串的AST？

时间：2011-10-05 05:42:03

标签： c++ regex boost

如何获得正则表达式的抽象语法树（AST）（在C ++中）？

例如，

 (XYZ)|(123)

应该产生一棵树：

        |
      /   \
    .       .
   / \     / \
  .   Z   .   3    
 / \     / \   
X  Y     1 2

是否有boost::spirit语法来解析正则表达式模式？ boost::regex库应该有它，但我找不到它。是否还有其他开源工具可以为我提供正则表达式的抽象表示？

3 个答案:

答案 0 :(得分：27)

我再次偶然发现了这个问题。我决定看看使用Boost Spirit为正则表达式语法的重要子集编写解析器实际上有多难。

所以，像往常一样，我开始使用笔和纸，过了一段时间就考虑了一些规则草案。是时候画出类似的AST：

namespace ast
{
    struct multiplicity 
    {
        unsigned minoccurs;
        boost::optional<unsigned> maxoccurs;
        bool greedy;

        multiplicity(unsigned minoccurs = 1, boost::optional<unsigned> maxoccurs = 1) 
            : minoccurs(minoccurs), maxoccurs(maxoccurs), greedy(true)
        { }

        bool unbounded() const { return !maxoccurs; }
        bool repeating() const { return !maxoccurs || *maxoccurs > 1; }
    };

    struct charset
    {
        bool negated;

        using range   = boost::tuple<char, char>; // from, till
        using element = boost::variant<char, range>;

        std::set<element> elements; 
        // TODO: single set for loose elements, simplify() method
    };

    struct start_of_match {};
    struct end_of_match {};
    struct any_char {};
    struct group;

    typedef boost::variant<   // unquantified expression
        start_of_match,
        end_of_match,
        any_char,
        charset,
        std::string,          // literal
        boost::recursive_wrapper<group> // sub expression
    > simple;

    struct atom               // quantified simple expression
    {
        simple       expr;
        multiplicity mult;
    };

    using sequence    = std::vector<atom>;
    using alternative = std::vector<sequence>;
    using regex       = boost::variant<atom, sequence, alternative>;

    struct group {
        alternative root;

        group() = default;
        group(alternative root) : root(std::move(root)) { }
    };
}

这是你典型的AST（58 LoC）与Spirit合作（由于通过variant和optional进行整合，以及策略性选择的构造函数）。

语法结尾只是稍长一点：

template <typename It>
    struct parser : qi::grammar<It, ast::alternative()>
{
    parser() : parser::base_type(alternative)
    {
        using namespace qi;
        using phx::construct;
        using ast::multiplicity;

        alternative = sequence % '|';
        sequence    = *atom;

        simple      = 
                      (group)
                    | (charset)
                    | ('.' >> qi::attr(ast::any_char()))
                    | ('^' >> qi::attr(ast::start_of_match()))
                    | ('$' >> qi::attr(ast::end_of_match()))
                    // optimize literal tree nodes by grouping unquantified literal chars
                    | (as_string [ +(literal >> !char_("{?+*")) ])
                    | (as_string [ literal ]) // lone char/escape + explicit_quantifier
                    ;

        atom        = (simple >> quantifier); // quantifier may be implicit

        explicit_quantifier  =
                    // bounded ranges:
                      lit('?')                                   [ _val = construct<multiplicity>( 0, 1)   ]
                    | ('{'  >> uint_ >> '}' )                    [ _val = construct<multiplicity>(_1, _1)  ]
                    // repeating ranges can be marked non-greedy:
                    | (                                        
                          lit('+')                               [ _val = construct<multiplicity>( 1, boost::none) ]
                        | lit('*')                               [ _val = construct<multiplicity>( 0, boost::none) ]
                        | ('{'  >> uint_ >> ",}")                [ _val = construct<multiplicity>(_1, boost::none) ]
                        | ('{'  >> uint_ >> "," >> uint_ >> '}') [ _val = construct<multiplicity>(_1, _2)  ]
                        | ("{," >> uint_ >> '}' )                [ _val = construct<multiplicity>( 0, _1)  ]
                      ) >> -lit('?')       [ phx::bind(&multiplicity::greedy, _val) = false ]
                    ;

        quantifier = explicit_quantifier | attr(ast::multiplicity());

        charset     = '[' 
                   >> (lit('^') >> attr(true) | attr(false)) // negated
                   >> *(range | charset_el)
                    > ']'
                    ;

        range       = charset_el >> '-' >> charset_el;

        group       = '(' >> alternative >> ')';

        literal     = unescape | ~char_("\\+*?.^$|{()") ;

        unescape    = ('\\' > char_);

        // helper to optionally unescape waiting for raw ']'
        charset_el  = !lit(']') >> (unescape|char_);
    }

  private:
    qi::rule<It, ast::alternative()>    alternative;
    qi::rule<It, ast::sequence()>       sequence;
    qi::rule<It, ast::atom()>           atom;
    qi::rule<It, ast::simple()>         simple;
    qi::rule<It, ast::multiplicity()>   explicit_quantifier, quantifier;
    qi::rule<It, ast::charset()>        charset;
    qi::rule<It, ast::charset::range()> range;
    qi::rule<It, ast::group()>          group;
    qi::rule<It, char()>                literal, unescape, charset_el;
};

现在，真正有趣的是用AST做点什么。由于您想要可视化树，我想到了从AST生成DOT图。所以我做了：

int main()
{
    std::cout << "digraph common {\n";

    for (std::string pattern: { 
            "abc?",
            "ab+c",
            "(ab)+c",
            "[^-a\\-f-z\"\\]aaaa-]?",
            "abc|d",
            "a?",
            ".*?(a|b){,9}?",
            "(XYZ)|(123)",
        })
    {
        std::cout << "// ================= " << pattern << " ========\n";
        ast::regex tree;
        if (doParse(pattern, tree))
        {
            check_roundtrip(tree, pattern);

            regex_todigraph printer(std::cout, pattern);
            boost::apply_visitor(printer, tree);
        }
    }

    std::cout << "}\n";
}

该程序产生以下图表：

enter image description here

自我边缘描绘重复，颜色表示匹配是贪婪（红色）还是非贪婪（蓝色）。正如您所看到的那样，为了清晰起见，我已经优化了AST，但是（联合国）对相关行进行评论会产生不同：

enter image description here

我认为调整起来并不难。希望它能成为某人的灵感。

此要点的完整代码：https://gist.github.com/sehe/8678988

答案 1 :(得分：9)

我认为Boost Xpressive必须能够“几乎”开箱即用。

  

xpressive is an advanced, object-oriented regular expression template library for C++. Regular expressions can be written as strings that are parsed at run-time, or as expression templates that are parsed at compile-time. Regular expressions can refer to each other and to themselves recursively, allowing you to build arbitrarily complicated grammars out of them.

我会看到我是否可以确认（使用一小部分样本）。

其他想法包括使用Boost Spirit和通用的utree工具来“存储”AST。你必须重现一个语法（这对于Regex语法的常见子集来说相对简单），所以它可能意味着更多的工作。

进度报告1

看着Xpressive，我取得了一些进展。我使用DDD的图形数据显示得到了漂亮的图片。但还不够。

然后我更多地探讨了'代码'方面：Xpressive是建立在Boost Proto之上的。它使用Proto来定义一个直接在C ++代码中对正则表达式建模的DSEL。 Proto完全从C ++代码生成表达式树（通用AST，如果你愿意）（通过重载所有可能的运算符）。然后，库（Xpressive，在这种情况下）需要通过走树来定义语义，例如

  • 构建特定于域的表达式树
  • 使用语义信息对其进行注释/装饰
  • 可能直接采取语义行为（例如Boost Spirit如何在Qi和Karma 1 中进行语义行为）

正如你所看到的，天空真的是极限，而且看起来令人不安地类似于Boo，Nemerle，Lisp等编译器宏。

可视化表达式Trres

现在，Boost Proto表达式树可以 通常可视化 ：

从Expressive C++: Playing with Syntax的示例开始，我稍微扩展了Xpressive的“Hello World”示例，以显示表达式树：

#include <iostream>
#include <boost/xpressive/xpressive.hpp>
#include <boost/proto/proto.hpp>

using namespace boost::xpressive;

int main()
{
    std::string hello( "hello world!" );

    sregex rex = sregex::compile( "(\\w+) (\\w+)!" );

    // equivalent proto based expression
    rex = (s1= +_w) >> ' ' >> (s2= +_w) >> '!';
    boost::proto::display_expr( (s1= +_w) >> ' ' >> (s2= +_w) >> '!');

    smatch what;

    if( regex_match( hello, what, rex ) )
    {
        std::cout << what[0] << '\n'; // whole match
        std::cout << what[1] << '\n'; // first capture
        std::cout << what[2] << '\n'; // second capture
    }

    return 0;
}

其输出接近（请注意compiler ABI特定typeid名称）：

shift_right(
    shift_right(
        shift_right(
            assign(
                terminal(N5boost9xpressive6detail16mark_placeholderE)
              , unary_plus(
                    terminal(N5boost9xpressive6detail25posix_charset_placeholderE)
                )
            )
          , terminal( )
        )
      , assign(
            terminal(N5boost9xpressive6detail16mark_placeholderE)
          , unary_plus(
                terminal(N5boost9xpressive6detail25posix_charset_placeholderE)
            )
        )
    )
  , terminal(!)
)
hello world!
hello
world
  

免责声明您应该意识到这实际上并没有显示正则表达式AST，而是来自Proto的通用表达式树，因此它没有特定于域的（正则表达式）信息。我提到它是因为差异可能会导致更多的工作（？除非我找到Xpressive编译结构的钩子），因为它对原始问题真正有用。

现在就是

我会留下那张纸条，因为这是午餐时间而我正在接孩子们，但这肯定引起了我的兴趣，所以我打算稍后发帖！

结论/进展报告1.0000001

这个坏消息：它不会起作用。

这就是原因。这个免责声明是对的钱。当周末到来时，我已经考虑了一些事情并且“预测”整个事情会在我离开的地方崩溃：AST基于原型表达树（不是正则表达式 matchable_ex ）。

在一些代码检查后很快就确认了这个事实：在编译之后，原型表达式树不再可用于显示。更不用说当basic_regex首先被指定为动态模式时（从来没有一个proto表达式）。

我已经半希望匹配已直接在proto表达树上实现（使用原型评估/评估上下文），但很快就确认不是这种情况。

所以，主要的内容是：

  • 这对于显示任何正则表达式AST
    • 都不起作用
  • 您可以使用上述内容实现的最佳功能是可视化 proto 表达式，您必须直接在代码中创建。这是一种在同一代码中手动编写AST的奇特方式......

略微不那么严格的观察包括

  • Boost Proto和Boost Expressive是非常有趣的图书馆（我不介意去那里钓鱼）。我显然已经学到了一些关于模板元编程库的重要课程，特别是这些库。
  • 很难设计构建静态类型表达式树的正则表达式解析器。事实上，在一般情况下它是不可能的 - 它需要编译器将所有可能的表达式树组合实例化到某个深度。这显然不会扩大规模。你可以通过引入多态组合和使用多态调用来解决这个问题，但这会消除模板元编程的好处（静态实例化类型/特化的编译时优化）。
  • Boost Regex和Boost Expressive都可能在内部支持某种正则表达式AST（以支持匹配评估）但
    • 尚未曝光/记录
    • 没有明显的显示设施

<子> 1 就此而言，甚至Spirit Lex都支持他们（但默认情况下不支持）

答案 2 :(得分：2)

boost :: regex似乎在basic_regex_parser.hpp中有一个手写的递归下降解析器。虽然它非常像重新发明轮子，但是你自己在boost :: spirit中编写语法时可能会更快，特别是在大量的正则表达式格式中。

相关问题
最新问题