不应用Boost精神解析规则

时间：2017-10-13 11:43:57

标签： c++ parsing boost-spirit

我在这里看不到我的错误..这条规则解析了一些东西，但最后两个样本没有。有人可以给我一个提示......

目标是一种解析器，可以识别成员属性访问和成员函数调用。还以某种方式链接

 a()
 a(para)
 x.a()
 x.a(para)
 x.a(para).g(para).j()
 x.y
 x.y.z
 x.y.z()    <---fail
 y.z.z(para) <--- fail

  lvalue =
         iter_pos >> name[_val = _1]
          >> *(lit('(') > paralistopt  > lit(')') >> iter_pos)[_val = construct<common_node>(type_cmd_fnc_call, LOCATION_NODE_ITER(_val, _2), key_this, construct<common_node>(_val), key_parameter, construct<std::vector<common_node> >(_1))]        
       >> *(lit('.') >> name_pure >> lit('(') > paralistopt > lit(')') >> iter_pos)[_val = construct<common_node>(type_cmd_fnc_call, LOCATION_NODE_ITER(_val, _3), key_this, construct<common_node>(_val), key_callname, construct<std::wstring>(_1), key_parameter, construct<std::vector<common_node> >(_2))]
       >> *(lit('.') >> name_pure >> iter_pos)[_val = construct<common_node>(type_cmd_dot_call, LOCATION_NODE_ITER(_val, _2), key_this, construct<common_node>(_val), key_propname, construct<std::wstring>(_1))]
    ;
谢谢你   马库斯

2 个答案:

答案 0 :(得分：1)

您提供的信息非常少。让我通过这个猜谜游戏来幽默你：

假设你想要解析一个简单的“语言”，它只允许成员表达式和函数调用，但是链接。

现在，你的语法没有说明参数（虽然很明显param列表可以是空的），所以让我走到下一英里并假设你想接受那里的相同类型的表达式（所以{{1} }没关系，还有foo(a)或bar(foo(a))）。

由于您接受函数调用的链接，看起来函数是第一类对象（并且函数可以返回函数），因此也应该接受bar(b.foo(a))。

您没有提及它，但参数通常包括文字（foo(a)(b, c, d)浮现在脑海中，或sqrt(9)）。

其他项目：

  • 你没有说，但你可能想忽略某些地方的空白
    • 来自println("hello world")（ab）的
  • 似乎您对跟踪生成的AST中的原始源位置感兴趣。

1。定义AST

我们应该保持简单：

iter_pos
  

注意我们不会专注于显示源位置，但已经做了一个配置，将标识符存储为迭代器范围。

     

注意融合 - 适应Spirit不直接支持的唯一类型：

namespace Ast {
    using Identifier = boost::iterator_range<It>;

    struct MemberExpression;
    struct FunctionCall;

    using Expression = boost::variant<
                double,       // some literal types
                std::string,
                // non-literals
                Identifier,
                boost::recursive_wrapper<MemberExpression>,
                boost::recursive_wrapper<FunctionCall>
            >;

    struct MemberExpression {
        Expression object; // antecedent
        Identifier member; // function or field
    };

    using Parameter  = Expression;
    using Parameters = std::vector<Parameter>;

    struct FunctionCall {
        Expression function; // could be a member function
        Parameters parameters;
    };
}
     

我们会发现我们不使用这些，因为语义操作在这里更方便。

2。匹配语法

BOOST_FUSION_ADAPT_STRUCT(Ast::MemberExpression, object, member)
BOOST_FUSION_ADAPT_STRUCT(Ast::FunctionCall, function, parameters)

在这个框架中，大多数规则都受益于自动属性传播。没有的是Grammar() : Grammar::base_type(start) { using namespace qi; start = skip(space) [expression]; identifier = raw [ (alpha|'_') >> *(alnum|'_') ]; parameters = -(expression % ','); expression = literal | identifier >> *( ('.' >> identifier) | ('(' >> parameters >> ')') ); literal = double_ | string_; string_ = '"' >> *('\\' >> char_ | ~char_('"')) >> '"'; BOOST_SPIRIT_DEBUG_NODES( (identifier)(start)(parameters)(expression)(literal)(string_) ); } ：

expression

所以，让我们为语义动作创建一些帮助器。

  

注意这里重要的一点是创建自己的高级构建块，而不是使用qi::rule<It, Expression()> start; using Skipper = qi::space_type; qi::rule<It, Expression(), Skipper> expression, literal; qi::rule<It, Parameters(), Skipper> parameters; // lexemes qi::rule<It, Identifier()> identifier; qi::rule<It, std::string()> string_; 等等。

定义两个简单的构造函数：

boost::phoenix::construct<>

然后使用它们：

struct mme_f { MemberExpression operator()(Expression lhs, Identifier rhs) const { return { lhs, rhs }; } };
struct mfc_f { FunctionCall operator()(Expression f, Parameters params) const { return { f, params }; } };
phx::function<mme_f> make_member_expression;
phx::function<mfc_f> make_function_call;

这就是全部。我们准备好了！

3。 DEMO

<强> Live On Coliru

我创建了一个看起来像这样的试验床：

expression 
    = literal [_val=_1]
    | identifier [_val=_1] >> *(
                ('.' >> identifier)        [ _val = make_member_expression(_val, _1)]
              | ('(' >> parameters >> ')') [ _val = make_function_call(_val, _1) ]
            );

可能看起来令人难以置信，这已经解析了所有测试用例和打印：

int main() {
    using It = std::string::const_iterator;
    Parser::Grammar<It> const g;

    for (std::string const input : {
             "a()", "a(para)", "x.a()", "x.a(para)", "x.a(para).g(para).j()", "x.y", "x.y.z",
             "x.y.z()",
             "y.z.z(para)",
             // now let's add some funkyness that you didn't mention
             "bar(foo(a))",
             "bar(b.foo(a))",
             "foo(a)(b, c, d)", // first class functions
             "sqrt(9)",
             "println(\"hello world\")",
             "allocate(strlen(\"aaaaa\"))",
             "3.14",
             "object.rotate(180)",
             "object.rotate(event.getAngle(), \"torque\")",
             "app.mainwindow().find_child(\"InputBox\").font().size(12)",
             "app.mainwindow().find_child(\"InputBox\").font(config().preferences.baseFont(style.PROPORTIONAL))"
         }) {
        std::cout << " =========== '" << input << "' ========================\n";
        It f(input.begin()), l(input.end());

        Ast::Expression parsed;
        bool ok = parse(f, l, g, parsed);
        if (ok) {
            std::cout << "Parsed: " << parsed << "\n";
        }
        else
            std::cout << "Parse failed\n";

        if (f != l)
            std::cout << "Remaining unparsed input: '" << std::string(f, l) << "'\n";
    }
}

4。太好了？

你是对的。我作弊了。我没有向您展示调试打印已解析的AST所需的代码：

 =========== 'a()' ========================
Parsed: a()
 =========== 'a(para)' ========================
Parsed: a(para)
 =========== 'x.a()' ========================
Parsed: x.a()
 =========== 'x.a(para)' ========================
Parsed: x.a(para)
 =========== 'x.a(para).g(para).j()' ========================
Parsed: x.a(para).g(para).j()
 =========== 'x.y' ========================
Parsed: x.y
 =========== 'x.y.z' ========================
Parsed: x.y.z
 =========== 'x.y.z()' ========================
Parsed: x.y.z()
 =========== 'y.z.z(para)' ========================
Parsed: y.z.z(para)
 =========== 'bar(foo(a))' ========================
Parsed: bar(foo(a))
 =========== 'bar(b.foo(a))' ========================
Parsed: bar(b.foo(a))
 =========== 'foo(a)(b, c, d)' ========================
Parsed: foo(a)(b, c, d)
 =========== 'sqrt(9)' ========================
Parsed: sqrt(9)
 =========== 'println("hello world")' ========================
Parsed: println(hello world)
 =========== 'allocate(strlen("aaaaa"))' ========================
Parsed: allocate(strlen(aaaaa))
 =========== '3.14' ========================
Parsed: 3.14
 =========== 'object.rotate(180)' ========================
Parsed: object.rotate(180)
 =========== 'object.rotate(event.getAngle(), "torque")' ========================
Parsed: object.rotate(event.getAngle(), torque)
 =========== 'app.mainwindow().find_child("InputBox").font().size(12)' ========================
Parsed: app.mainwindow().find_child(InputBox).font().size(12)
 =========== 'app.mainwindow().find_child("InputBox").font(config().preferences.baseFont(style.PROPORTIONAL))' ========================
Parsed: app.mainwindow().find_child(InputBox).font(config().preferences.baseFont(style.PROPORTIONAL))

这只是调试打印，因为字符串文字没有正确地往返。但它只有10行代码，这是一个奖励。

5。 Full Monty：源位置

这有你的兴趣，所以让我们展示它的工作原理。让我们添加一个简单的循环来打印标识符的所有位置：

namespace Ast {
    static inline std::ostream& operator<<(std::ostream& os, MemberExpression const& me) {
        return os << me.object << "." << me.member;
    }

    static inline std::ostream& operator<<(std::ostream& os, FunctionCall const& fc) {
        os << fc.function << "(";
        bool first = true;
        for (auto& p : fc.parameters) { if (!first) os << ", "; first = false; os << p; }
        return os << ")";
    }
}

当然，这引出了一个问题，using IOManip::showpos; for (auto& id : all_identifiers(parsed)) { std::cout << " - " << id << " at " << showpos(id, input) << "\n"; } 和showpos是什么？

all_identifiers

至于标识符提取：

namespace IOManip {
    struct showpos_t {
        boost::iterator_range<It> fragment;
        std::string const& source;

        friend std::ostream& operator<<(std::ostream& os, showpos_t const& manip) {
            auto ofs = [&](It it) { return it - manip.source.begin(); };
            return os << "[" << ofs(manip.fragment.begin()) << ".." << ofs(manip.fragment.end()) << ")";
        }
    };

    showpos_t showpos(boost::iterator_range<It> fragment, std::string const& source) {
        return {fragment, source};
    }
}

这是一个树访问者，以递归方式收集所有标识符，将它们插入容器的后面。

<强> Live On Coliru

输出的样子（摘录）：

std::vector<Identifier> all_identifiers(Expression const& expr) {
    std::vector<Identifier> result;
    struct Harvest {
        using result_type = void;
        std::back_insert_iterator<std::vector<Identifier> > out;
        void operator()(Identifier const& id)       { *out++ = id; }
        void operator()(MemberExpression const& me) { apply_visitor(*this, me.object); *out++ = me.member; }
        void operator()(FunctionCall const& fc)     {
            apply_visitor(*this, fc.function); 
            for (auto& p : fc.parameters) apply_visitor(*this, p);
        }
        // non-identifier expressions
        void operator()(std::string const&) { }
        void operator()(double) { }
    } harvest { back_inserter(result) };
    boost::apply_visitor(harvest, expr);

    return result;
}

答案 1 :(得分：0)

尝试更改

>> *(lit('.') >> name_pure >> lit('(') > paralistopt > lit(')'))

到

>> *(*(lit('.') >> name_pure) >> lit('(') > paralistopt > lit(')'))
相关问题
最新问题