我已经使用来自网络上各种来源的boost库拼凑了一个解析器。它的工作原理（尽管不像我希望的那样干净），但我遇到了一个特殊的问题。在解析器的第一部分中，我首先解析函数名，然后用括号括起来的一组参数。稍后，在解析实际表达式时，在解析factor中我允许解析数字和变量。但是，我想只解析先前在vars解析器中声明的变量。这是我的语法：
template<typename Iterator>
struct exp_parser : qi::grammar<Iterator, expression(), ascii::space_type>
{
exp_parser() : exp_parser::base_type(all)
{
using qi::_val;
using qi::_1;
using qi::char_;
using qi::double_;
using qi::lit;
using phoenix::at_c;
using phoenix::push_back;
using phoenix::bind;
all =
name [at_c<0>(_val) = _1] >> '(' >> vars [at_c<1>(_val) = _1] >> ')' >> '='
>> expr [at_c<2>(_val) = _1];
// Parsing of actual expression
expr =
term [_val = _1]
>> *( ('+' >> term [_val += _1])
| ('-' >> term [_val -= _1])
);
term =
factor [_val = _1]
>> *( ('*' >> factor [_val *= _1])
| ('/' >> factor [_val /= _1])
);
factor =
simple [_val = _1]
| '(' >> expr [_val = _1] >> ')'
| ('-' >> factor [_val = bind(make_unary, UN_OP::MIN, _1)])
| ("sin" >> factor [_val = bind(make_unary, UN_OP::SIN, _1)])
| ("cos" >> factor [_val = bind(make_unary, UN_OP::COS, _1)])
| ("tan" >> factor [_val = bind(make_unary, UN_OP::TAN, _1)])
| ('+' >> factor [_val = _1]);
// Prototyping of expression
prtctd %= lit("sin") | lit("cos") | lit("tan");
var %= !prtctd >> char_('a','z');
num %= double_;
simple %= var | num | ('(' >> expr >> ')');
name %= ((char_('a','z') | char_('A','Z') ) >> *(char_('a','z') | char_('A','Z') | char_('0','9') ));
vars %= (char_('a','z') >> *(',' >> char_('a','z')));
}
qi::rule<Iterator, ast(), ascii::space_type> expr, term, factor, simple;
qi::rule<Iterator, expression(), ascii::space_type> all;
qi::rule<Iterator, std::string(), ascii::space_type> name, prtctd;
qi::rule<Iterator, std::vector<char>(), ascii::space_type> vars;
qi::rule<Iterator, char(), ascii::space_type> var;
qi::rule<Iterator, double(), ascii::space_type> num;
};
这是我用来存储它的结构：
struct expression {
std::string name;
std::vector<char> arguments;
ast syntax_tree;
};
现在，我如何访问std::vector<char>解析器中的factor，以便我只解析正确的变量。
此外，我是新手使用提升并将此作为练习对自己开始学习一点点。如果有人有任何建议，请告诉我如何清理此代码。
提前致谢！
答案 0 :(得分：2)
这是Spirit中的一个大反模式：
all =
name [at_c<0>(_val) = _1] >> '(' >> vars [at_c<1>(_val) = _1] >> ')' >> '='
>> expr [at_c<2>(_val) = _1];
事实上，我确信您一直在寻找的样本显示出更好的方法。此外，我注意到您从冲突的方法中选择了代码（当语义操作动态评估表达式值时，您无法合成语法树。）
首先，摆脱语义行为思维：Boost Spirit: "Semantic actions are evil"?
BOOST_FUSION_ADAPT_STRUCT(expression, name, arguments, syntax_tree)
all = name >> '(' >> vars >> ')' >> '=' >> expr;
还有很多其他＆＃34;疾病＆＃34;：
prtctd应该是一个词汇，因此si\nn不匹配*(char_('a','z') | char_('A','Z') | char_('0','9') )只是*alnum 名称也应该是一个词汇，所以只需
name = alpha >> *alnum;
vars甚至使用 var？
总而言之，这里是这些规则的简化（假设你从prtctd和name删除了队长）：
prtctd = lit("sin") | "cos" | "tan";
var = !prtctd >> ascii::lower;
num = double_;
simple = var | num | '(' >> expr >> ')';
name = ascii::alpha >> *ascii::alnum;
vars = var % ',';
让我们在上面添加一些模拟部分，然后我们可以测试一下：
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/adapted.hpp>
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
struct ast {
template <typename T> ast& operator+=(T&&) { return *this; }
template <typename T> ast& operator*=(T&&) { return *this; }
template <typename T> ast& operator/=(T&&) { return *this; }
template <typename T> ast& operator-=(T&&) { return *this; }
ast() = default;
template <typename T> ast(T&&) { }
template <typename T> ast& operator =(T&&) { return *this; }
friend std::ostream& operator<<(std::ostream& os, ast) { return os << "syntax_tree"; }
};
struct expression {
std::string name;
std::vector<std::string> arguments;
ast syntax_tree;
friend std::ostream& operator<<(std::ostream& os, expression const& e) {
os << e.name << "(";
for (auto arg : e.arguments) os << arg << ", ";
return os << ") = " << e.syntax_tree;
}
};
BOOST_FUSION_ADAPT_STRUCT(expression, name, arguments, syntax_tree)
enum UN_OP { MIN, SIN, COS, TAN };
struct make_unary_f {
template <typename... Ts> qi::unused_type operator()(Ts&&...) const { return qi::unused; }
} static const make_unary = {};
template<typename Iterator>
struct exp_parser : qi::grammar<Iterator, expression(), ascii::space_type>
{
exp_parser() : exp_parser::base_type(all)
{
using qi::_val;
using qi::_1;
using qi::char_;
using qi::double_;
using qi::lit;
using phoenix::at_c;
using phoenix::push_back;
using phoenix::bind;
all = name >> '(' >> vars >> ')' >> '=' >> expr;
// Parsing of actual expression
expr =
term [_val = _1]
>> *( ('+' >> term [_val += _1])
| ('-' >> term [_val -= _1])
);
term =
factor [_val = _1]
>> *( ('*' >> factor [_val *= _1])
| ('/' >> factor [_val /= _1])
);
factor =
simple [_val = _1]
| '(' >> expr [_val = _1] >> ')'
| ('-' >> factor [_val = bind(make_unary, UN_OP::MIN, _1)])
| ("sin" >> factor [_val = bind(make_unary, UN_OP::SIN, _1)])
| ("cos" >> factor [_val = bind(make_unary, UN_OP::COS, _1)])
| ("tan" >> factor [_val = bind(make_unary, UN_OP::TAN, _1)])
| ('+' >> factor [_val = _1]);
// Prototyping of expression
prtctd = lit("sin") | "cos" | "tan";
var = !prtctd >> ascii::lower;
num = double_;
simple = var | num | '(' >> expr >> ')';
name = ascii::alpha >> *ascii::alnum;
vars = var % ',';
}
private:
qi::rule<Iterator, ast(), ascii::space_type> expr, term, factor, simple;
qi::rule<Iterator, expression(), ascii::space_type> all;
qi::rule<Iterator, std::vector<std::string>(), ascii::space_type> vars;
// lexemes
qi::rule<Iterator, std::string()> name, prtctd;
qi::rule<Iterator, std::string()> var;
qi::rule<Iterator, double()> num;
};
int main() {
for (std::string const& input : {
"",
"foo (a) = 3*8+a",
"bar (x, y) = (sin(x) + y*y) / (x + y)",
"oops (x, y) = (sin(x) + y*y) / (x + a)",
})
try {
using It = std::string::const_iterator;
It f = input.begin(), l = input.end();
expression e;
bool ok = qi::phrase_parse(f, l, exp_parser<It>{} >> qi::eoi, ascii::space, e);
if (ok) {
std::cout << "Parse success: '" << input << "' -> " << e << "\n";
} else {
std::cout << "Parse failed: '" << input << "'\n";
}
if (f != l)
std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
} catch(std::exception const& e) {
std::cout << "Exception: '" << e.what() << "'\n";
}
}
正如预期的那样，它仍会解析所有非空行，包括错误地使用oops代替a的{{1}}：
y为了匹配声明的变量，我{d} {d} {/ 3}：
Parse failed: ''
Parse success: 'foo (a) = 3*8+a' -> foo(a, ) = syntax_tree
Parse success: 'bar (x, y) = (sin(x) + y*y) / (x + y)' -> bar(x, y, ) = syntax_tree
Parse success: 'oops (x, y) = (sin(x) + y*y) / (x + a)' -> oops(x, y, ) = syntax_tree
现在，要添加声明的项目，我们将设计一个Phoenix函数，
qi::symbols<char> _declared;
simple = _declared | num | '(' >> expr >> ')';
并使用它：
struct add_declaration_f {
add_declaration_f(qi::symbols<char>& ref) : _p(std::addressof(ref)) {}
qi::symbols<char>* _p;
void operator()(std::string const& arg) const { _p->add(arg); }
};
phoenix::function<add_declaration_f> _declare { _declared };
vars %= var [ _declare(_1) ] % ',';
打印哪些：
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/adapted.hpp>
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
struct ast {
template <typename T> ast& operator+=(T&&) { return *this; }
template <typename T> ast& operator*=(T&&) { return *this; }
template <typename T> ast& operator/=(T&&) { return *this; }
template <typename T> ast& operator-=(T&&) { return *this; }
ast() = default;
template <typename T> ast(T&&) { }
template <typename T> ast& operator =(T&&) { return *this; }
friend std::ostream& operator<<(std::ostream& os, ast) { return os << "syntax_tree"; }
};
struct expression {
std::string name;
std::vector<std::string> arguments;
ast syntax_tree;
friend std::ostream& operator<<(std::ostream& os, expression const& e) {
os << e.name << "(";
for (auto arg : e.arguments) os << arg << ", ";
return os << ") = " << e.syntax_tree;
}
};
BOOST_FUSION_ADAPT_STRUCT(expression, name, arguments, syntax_tree)
enum UN_OP { MIN, SIN, COS, TAN };
struct make_unary_f {
template <typename... Ts> qi::unused_type operator()(Ts&&...) const { return qi::unused; }
} static const make_unary = {};
template<typename Iterator>
struct exp_parser : qi::grammar<Iterator, expression(), ascii::space_type>
{
exp_parser() : exp_parser::base_type(all)
{
using qi::_val;
using qi::_1;
using qi::char_;
using qi::double_;
using qi::lit;
using phoenix::at_c;
using phoenix::push_back;
using phoenix::bind;
all = name >> '(' >> vars >> ')' >> '=' >> expr;
// Parsing of actual expression
expr =
term [_val = _1]
>> *( ('+' >> term [_val += _1])
| ('-' >> term [_val -= _1])
);
term =
factor [_val = _1]
>> *( ('*' >> factor [_val *= _1])
| ('/' >> factor [_val /= _1])
);
factor =
simple [_val = _1]
| '(' >> expr [_val = _1] >> ')'
| ('-' >> factor [_val = bind(make_unary, UN_OP::MIN, _1)])
| ("sin" >> factor [_val = bind(make_unary, UN_OP::SIN, _1)])
| ("cos" >> factor [_val = bind(make_unary, UN_OP::COS, _1)])
| ("tan" >> factor [_val = bind(make_unary, UN_OP::TAN, _1)])
| ('+' >> factor [_val = _1]);
// Prototyping of expression
prtctd = lit("sin") | "cos" | "tan";
var = !prtctd >> ascii::lower;
num = double_;
simple = _declared | num | '(' >> expr >> ')';
name = ascii::alpha >> *ascii::alnum;
vars %= var [ _declare(_1) ] % ',';
}
private:
qi::symbols<char> _declared;
struct add_declaration_f {
add_declaration_f(qi::symbols<char>& ref) : _p(std::addressof(ref)) {}
qi::symbols<char>* _p;
void operator()(std::string const& arg) const { _p->add(arg); }
};
phoenix::function<add_declaration_f> _declare { _declared };
qi::rule<Iterator, ast(), ascii::space_type> expr, term, factor, simple;
qi::rule<Iterator, expression(), ascii::space_type> all;
qi::rule<Iterator, std::vector<std::string>(), ascii::space_type> vars;
// lexemes
qi::rule<Iterator, std::string()> name, prtctd;
qi::rule<Iterator, std::string()> var;
qi::rule<Iterator, double()> num;
};
int main() {
for (std::string const& input : {
"",
"foo (a) = 3*8+a",
"bar (x, y) = (sin(x) + y*y) / (x + y)",
"oops (x, y) = (sin(x) + y*y) / (x + a)",
})
try {
using It = std::string::const_iterator;
It f = input.begin(), l = input.end();
expression e;
bool ok = qi::phrase_parse(f, l, exp_parser<It>{}, ascii::space, e);
if (ok) {
std::cout << "Parse success: '" << input << "' -> " << e << "\n";
} else {
std::cout << "Parse failed: '" << input << "'\n";
}
if (f != l)
std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
} catch(std::exception const& e) {
std::cout << "Exception: '" << e.what() << "'\n";
}
}
将Parse failed: ''
Parse success: 'foo (a) = 3*8+a' -> foo(a, ) = syntax_tree
Parse success: 'bar (x, y) = (sin(x) + y*y) / (x + y)' -> bar(x, y, ) = syntax_tree
Parse success: 'oops (x, y) = (sin(x) + y*y) / (x + a)' -> oops(x, y, ) = syntax_tree
Remaining unparsed: '/ (x + a)'
添加到我们获得的解析器表达式中： Live On Coliru
>> qi::eoi