我想解析一个布尔表达式(在C ++中)。输入表格:
a and b xor (c and d or a and b);
我只想将这个表达式解析为树,知道优先级规则(不是,和,xor,或)。 所以上面的表达式应该类似于:
(a and b) xor ((c and d) or (a and b));
到解析器。
树将是形式:
a
and
b
or
c
and
d
xor
a
and
b
输入将通过命令行或以字符串的形式。 我只需要解析器。
是否有任何消息可以帮助我做到这一点?
答案 0 :(得分:89)
这是一个基于Boost Spirit的实现。
因为Boost Spirit基于表达模板生成递归下降解析器,所以尊重'特质'(原文如此)优先级规则(如其他人所提到的)是相当繁琐的。因此语法缺乏一定的优雅。
我使用Boost Variant的递归变体支持定义了一个树数据结构,注意expr的定义:
struct op_or {}; // tag
struct op_and {}; // tag
struct op_xor {}; // tag
struct op_not {}; // tag
typedef std::string var;
template <typename tag> struct binop;
template <typename tag> struct unop;
typedef boost::variant<var,
boost::recursive_wrapper<unop <op_not> >,
boost::recursive_wrapper<binop<op_and> >,
boost::recursive_wrapper<binop<op_xor> >,
boost::recursive_wrapper<binop<op_or> >
> expr;
(完整来源)
如上所述,以下是(稍显乏味)语法定义。
虽然我不认为这个语法是最优的,但它具有很强的可读性,我们自己拥有一个静态编译的解析器,其中包含大约50行代码中的强类型AST数据类型。事情可能会更糟糕。
template <typename It, typename Skipper = qi::space_type>
struct parser : qi::grammar<It, expr(), Skipper>
{
parser() : parser::base_type(expr_)
{
using namespace qi;
expr_ = or_.alias();
or_ = (xor_ >> "or" >> xor_) [ _val = phx::construct<binop<op_or >>(_1, _2) ] | xor_ [ _val = _1 ];
xor_ = (and_ >> "xor" >> and_) [ _val = phx::construct<binop<op_xor>>(_1, _2) ] | and_ [ _val = _1 ];
and_ = (not_ >> "and" >> not_) [ _val = phx::construct<binop<op_and>>(_1, _2) ] | not_ [ _val = _1 ];
not_ = ("not" > simple ) [ _val = phx::construct<unop <op_not>>(_1) ] | simple [ _val = _1 ];
simple = (('(' > expr_ > ')') | var_);
var_ = qi::lexeme[ +alpha ];
}
private:
qi::rule<It, var() , Skipper> var_;
qi::rule<It, expr(), Skipper> not_, and_, xor_, or_, simple, expr_;
};
显然,你想要评估表达式。现在,我决定停止打印,所以我不必为命名变量执行查找表:)
遍历递归变体可能一开始看起来很神秘,但是boost::static_visitor<>
一旦你掌握它就会非常简单:
struct printer : boost::static_visitor<void>
{
printer(std::ostream& os) : _os(os) {}
std::ostream& _os;
//
void operator()(const var& v) const { _os << v; }
void operator()(const binop<op_and>& b) const { print(" & ", b.oper1, b.oper2); }
void operator()(const binop<op_or >& b) const { print(" | ", b.oper1, b.oper2); }
void operator()(const binop<op_xor>& b) const { print(" ^ ", b.oper1, b.oper2); }
void print(const std::string& op, const expr& l, const expr& r) const
{
_os << "(";
boost::apply_visitor(*this, l);
_os << op;
boost::apply_visitor(*this, r);
_os << ")";
}
void operator()(const unop<op_not>& u) const
{
_os << "(";
_os << "!";
boost::apply_visitor(*this, u.oper1);
_os << ")";
}
};
std::ostream& operator<<(std::ostream& os, const expr& e)
{ boost::apply_visitor(printer(os), e); return os; }
对于代码中的测试用例,输出以下内容,通过添加(冗余)括号来演示正确处理优先规则:
result: ((a & b) ^ ((c & d) | (a & b)))
result: ((a & b) ^ ((c & d) | (a & b)))
result: (a & b)
result: (a | b)
result: (a ^ b)
result: (!a)
result: ((!a) & b)
result: (!(a & b))
result: (a | (b | c))
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/variant/recursive_wrapper.hpp>
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
struct op_or {};
struct op_and {};
struct op_xor {};
struct op_not {};
typedef std::string var;
template <typename tag> struct binop;
template <typename tag> struct unop;
typedef boost::variant<var,
boost::recursive_wrapper<unop <op_not> >,
boost::recursive_wrapper<binop<op_and> >,
boost::recursive_wrapper<binop<op_xor> >,
boost::recursive_wrapper<binop<op_or> >
> expr;
template <typename tag> struct binop
{
explicit binop(const expr& l, const expr& r) : oper1(l), oper2(r) { }
expr oper1, oper2;
};
template <typename tag> struct unop
{
explicit unop(const expr& o) : oper1(o) { }
expr oper1;
};
struct printer : boost::static_visitor<void>
{
printer(std::ostream& os) : _os(os) {}
std::ostream& _os;
//
void operator()(const var& v) const { _os << v; }
void operator()(const binop<op_and>& b) const { print(" & ", b.oper1, b.oper2); }
void operator()(const binop<op_or >& b) const { print(" | ", b.oper1, b.oper2); }
void operator()(const binop<op_xor>& b) const { print(" ^ ", b.oper1, b.oper2); }
void print(const std::string& op, const expr& l, const expr& r) const
{
_os << "(";
boost::apply_visitor(*this, l);
_os << op;
boost::apply_visitor(*this, r);
_os << ")";
}
void operator()(const unop<op_not>& u) const
{
_os << "(";
_os << "!";
boost::apply_visitor(*this, u.oper1);
_os << ")";
}
};
std::ostream& operator<<(std::ostream& os, const expr& e)
{ boost::apply_visitor(printer(os), e); return os; }
template <typename It, typename Skipper = qi::space_type>
struct parser : qi::grammar<It, expr(), Skipper>
{
parser() : parser::base_type(expr_)
{
using namespace qi;
expr_ = or_.alias();
or_ = (xor_ >> "or" >> or_ ) [ _val = phx::construct<binop<op_or >>(_1, _2) ] | xor_ [ _val = _1 ];
xor_ = (and_ >> "xor" >> xor_) [ _val = phx::construct<binop<op_xor>>(_1, _2) ] | and_ [ _val = _1 ];
and_ = (not_ >> "and" >> and_) [ _val = phx::construct<binop<op_and>>(_1, _2) ] | not_ [ _val = _1 ];
not_ = ("not" > simple ) [ _val = phx::construct<unop <op_not>>(_1) ] | simple [ _val = _1 ];
simple = (('(' > expr_ > ')') | var_);
var_ = qi::lexeme[ +alpha ];
BOOST_SPIRIT_DEBUG_NODE(expr_);
BOOST_SPIRIT_DEBUG_NODE(or_);
BOOST_SPIRIT_DEBUG_NODE(xor_);
BOOST_SPIRIT_DEBUG_NODE(and_);
BOOST_SPIRIT_DEBUG_NODE(not_);
BOOST_SPIRIT_DEBUG_NODE(simple);
BOOST_SPIRIT_DEBUG_NODE(var_);
}
private:
qi::rule<It, var() , Skipper> var_;
qi::rule<It, expr(), Skipper> not_, and_, xor_, or_, simple, expr_;
};
int main()
{
for (auto& input : std::list<std::string> {
// From the OP:
"(a and b) xor ((c and d) or (a and b));",
"a and b xor (c and d or a and b);",
/// Simpler tests:
"a and b;",
"a or b;",
"a xor b;",
"not a;",
"not a and b;",
"not (a and b);",
"a or b or c;",
})
{
auto f(std::begin(input)), l(std::end(input));
parser<decltype(f)> p;
try
{
expr result;
bool ok = qi::phrase_parse(f,l,p > ';',qi::space,result);
if (!ok)
std::cerr << "invalid input\n";
else
std::cout << "result: " << result << "\n";
} catch (const qi::expectation_failure<decltype(f)>& e)
{
std::cerr << "expectation_failure at '" << std::string(e.first, e.last) << "'\n";
}
if (f!=l) std::cerr << "unparsed: '" << std::string(f,l) << "'\n";
}
return 0;
}
对于奖励积分,要获得与OP中显示的完全相同的树:
static const char indentstep[] = " ";
struct tree_print : boost::static_visitor<void>
{
tree_print(std::ostream& os, const std::string& indent=indentstep) : _os(os), _indent(indent) {}
std::ostream& _os;
std::string _indent;
void operator()(const var& v) const { _os << _indent << v << std::endl; }
void operator()(const binop<op_and>& b) const { print("and ", b.oper1, b.oper2); }
void operator()(const binop<op_or >& b) const { print("or ", b.oper2, b.oper1); }
void operator()(const binop<op_xor>& b) const { print("xor ", b.oper2, b.oper1); }
void print(const std::string& op, const expr& l, const expr& r) const
{
boost::apply_visitor(tree_print(_os, _indent+indentstep), l);
_os << _indent << op << std::endl;
boost::apply_visitor(tree_print(_os, _indent+indentstep), r);
}
void operator()(const unop<op_not>& u) const
{
_os << _indent << "!";
boost::apply_visitor(tree_print(_os, _indent+indentstep), u.oper1);
}
};
std::ostream& operator<<(std::ostream& os, const expr& e)
{
boost::apply_visitor(tree_print(os), e); return os;
}
结果:
a
and
b
or
c
and
d
xor
a
and
b
答案 1 :(得分:5)
要么像Oli Charlesworth已经提到的那样使用解析器生成器(yacc,bison,antlr;后者在我的经验中比其他两个更适合C ++,尽管我看了一下它们的任何时候)或者创建了一个简单的递归下降解析器:对于像你这样简单的语言,这可能是更简单的方法。
答案 2 :(得分:2)
请参阅my SO answer on how to code simple recursive descent parsers。
这种方法对于布尔表达式等简单语言非常方便。这些概念几乎与您的编程语言无关。
答案 3 :(得分:1)
如果像我一样,你发现解析库的开销和特性对于这么小的工作来说太多了,你可以很容易地编写自己的解析器来处理你所呈现的简单场景。有关我在C#中编写的解析器,请参阅here,以便根据您的要求解析简单的C#表达式。
答案 4 :(得分:1)
当我尝试扩展@sehe的示例中设置的二进制运算符时,我遇到了巨大的性能影响。我添加的运算符如下;
eq_ = (neq_ >> "eq" >> eq_ ) [ _val = phx::construct<binop<op_eq>>(_1, _2) ] | neq_ [ _val = _1 ];
neq_ = (gt_ >> "neq" >> neq_ ) [ _val = phx::construct<binop<op_neq>>(_1, _2) ] | gt_ [ _val = _1 ];
gt_ = (lt_ >> "gt" >> gt_ ) [ _val = phx::construct<binop<op_gt>>(_1, _2) ] | lt_ [ _val = _1 ];
lt_ = (gte_ >> "lt" >> lt_ ) [ _val = phx::construct<binop<op_lt>>(_1, _2) ] | gte_ [ _val = _1 ];
gte_ = (lte_ >> "gte" >> gte_ ) [ _val = phx::construct<binop<op_gte>>(_1, _2) ] | lte_ [ _val = _1 ];
lte_ = (or_ >> "lte" >> lte_ ) [ _val = phx::construct<binop<op_lte>>(_1, _2) ] | or_ [ _val = _1 ];
or_ = (xor_ >> "or" >> or_ ) [ _val = phx::construct<binop<op_or >>(_1, _2) ] | xor_ [ _val = _1 ];
xor_ = (and_ >> "xor" >> xor_) [ _val = phx::construct<binop<op_xor>>(_1, _2) ] | and_ [ _val = _1 ];
and_ = (not_ >> "and" >> and_) [ _val = phx::construct<binop<op_and>>(_1, _2) ] | not_ [ _val = _1 ];
not_ = ("not" > simple ) [ _val = phx::construct<unop <op_not>>(_1) ] | simple [ _val = _1 ];
上面的代码解析非常慢,冻结了几分钟。我试图重写上面的等效代码;
/*...*/
parser() : parser::base_type(expr_){
/*...*/
expr_ =
(
( ("not" > simple_ [_val = phx::construct<unop<op_not>>(_1)] ))
|
simple_ [_val = phx::construct<expr>(_1)])
>> *(
("and" >> simple_ [_val = phx::construct<binop<op_and>>(_val, _1)] )
|
("or" >> simple_ [_val = phx::construct<binop<op_or>>(_val, _1)] )
|
("xor" >> simple_ [_val = phx::construct<binop<op_xor>>(_val, _1)] )
|
("not" > simple_ [_val = phx::construct<unop<op_not>>(_val)] )
|
("gt" >> simple_ [_val = phx::construct<binop<op_gt>>(_val, _1)] )
|
("gte" >> simple_ [_val = phx::construct<binop<op_gte>>(_val, _1)] )
|
("lt" >> simple_ [_val = phx::construct<binop<op_lt>>(_val, _1)] )
|
("lte" >> simple_ [_val = phx::construct<binop<op_lte>>(_val, _1)] )
|
("eq" >> simple_ [_val = phx::construct<binop<op_eq>>(_val, _1)] )
|
("neq" >> simple_ [_val = phx::construct<binop<op_neq>>(_val, _1)] )
);
simple_ = (('(' > expr_ > ')') | var_);
var_ = qi::lexeme[ +alpha ];
}
/*...*/
qi::rule<It, var() , Skipper> var_;
qi::rule<It, expr(), Skipper> expr_, simple_;
};
上面的代码立即解析op提供的输入。我不知道是什么导致性能影响,但是第二种实现以某种方式解决了它。很奇怪。
答案 5 :(得分:0)
查看Mini C示例代码https://github.com/boostorg/spirit/tree/master/example/qi/compiler_tutorial/mini_c。
特别要看一下expression.cpp,expression.hpp,expression_def.hpp和ast.hpp。它给出了如何将表达式解析为AST的一个很好的例子。