有趣。为此，我必须学习 Regex 的全新领域。对此表示敬意。
问题是Recursive Expressions。您需要非常确定这些模式不会轻易地随意递归，这样您就不会陷入无限递归，或者，就像这里的情况一样，“只是”递归很容易随着冗长的输入而变得很深。
所以，我先整理了一下：
const std::string pattern(
R"((?(DEFINE)(?'NAMESPACE'\w*::)))"
R"((?(DEFINE)(?'CONSTANT'("(?:[^"\\]|\\.)*")|(\d+\.?\d*f?))))"
R"((?(DEFINE)(?'VARIABLE'(?P>NAMESPACE)*([A-Za-z_]\w*\.)*[A-Za-z_]\w*)))"
R"((?(DEFINE)(?'OPERAND'(\+|-)*((?P>VARIABLE)|(?P>CONSTANT)))))"
R"((?(DEFINE)(?'EXPRESSION'\s*(?P>OPERAND)\s*(\s*[\*\+-\/]\s*(?P>OPERAND))*)))"
R"((?(DEFINE)(?'ARGUMENTS'(?P>EXPRESSION)(,\s*(?P>EXPRESSION))*)))"
R"((?(DEFINE)(?'FUNCTION_CALL'(?P>VARIABLE)\(\s*(?P>ARGUMENTS)?\s*\))))"
R"((?P>FUNCTION_CALL))");
现在我开始“理解”该模式，我决定我可能不会将 Regex 用于语法¹，并在 Spirit X3 中重写它：
namespace rules {
using namespace x3;
auto WORD = (alnum | char_('_'));
auto NAMESPACE = +WORD >> "::";
auto CONSTANT = ( lexeme [ '"' >> *~char_('"') >> '"' ] | double_ );
auto ident = lexeme [ char_("A-Za-z_") >> *WORD ];
auto VARIABLE = *NAMESPACE >> ident % '.';
auto OPERAND = *(char_("+-")) >> (VARIABLE | CONSTANT);
auto EXPRESSION = OPERAND % char_("*+/-");
auto ARGUMENTS = EXPRESSION % ',';
auto FUNCTION_CALL = VARIABLE >> '(' >> -ARGUMENTS >> ')';
auto simple_function = rule<struct simple_function_, std::string> {"simple_function"}
= skip(space) [ x3::raw[FUNCTION_CALL] ];
}
现在，由于在更多相关位置接受空格（skip 与 lexeme²），因此这更加准确。此外，它显然没有遇到糟糕的回溯问题：
Live On Wandbox
#include <iostream>
#include <fstream>
#include <sstream>
#include <iterator>
#include <string>
#include <boost/regex.hpp>
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;
namespace rules {
using namespace x3;
auto WORD = (alnum | char_('_'));
auto NAMESPACE = +WORD >> "::";
auto CONSTANT = ( lexeme [ '"' >> *~char_('"') >> '"' ] | double_ );
auto ident = lexeme [ char_("A-Za-z_") >> *WORD ];
auto VARIABLE = *NAMESPACE >> ident % '.';
auto OPERAND = *(char_("+-")) >> (VARIABLE | CONSTANT);
auto EXPRESSION = OPERAND % char_("*+/-");
auto ARGUMENTS = EXPRESSION % ',';
auto FUNCTION_CALL = VARIABLE >> '(' >> -ARGUMENTS >> ')';
auto simple_function = rule<struct simple_function_, std::string> {"simple_function"}
= skip(space) [ x3::raw[FUNCTION_CALL] ];
}
int main()
{
std::ifstream file("flask");
std::string const context(std::istreambuf_iterator<char>(file), {});
std::vector<std::string> calls;
parse(context.begin(), context.end(), *x3::seek[rules::simple_function], calls);
for (auto& call : calls) {
std::cout << call << "\n";
}
}
打印出来的
anno::copyright_notice("XXXXX")
anno::author("Someone")
anno::contributor("")
state::texture_coordinate(0)
state::texture_tangent_u(0)
state::texture_tangent_v(0)
¹我知道 Perl6 很棒，但仍然
²Boost spirit skipper issues
更新/奖励
只是为了展示除了匹配文本与 Spirit X3 之外的一些内容，这里对快速端口进行了轻微改进，展示了如何使用相同的规则来解析强类型的 AST 数据类型。
所做的更改：
- 修复了在命名空间限定符中没有
lexeme 标识符的错误
- 同时使名称空间的标识符解析一致（很可能，名称空间名称也不能以数字字符开头）
- 解析为强类型数据类型
AST::Variable、AST::Literal（用于字符串或数字文字）和AST::FunctionCall
- 支持字符串文字中的转义。这意味着
"A\"B" 现在将被正确解析为包含A"B 的AST::Literal。
- 如果您检查调试输出 (
#define BOOST_SPIRIT_X3_DEBUG)，您实际上可以看到这些文字正在被解析
Live On Wandbox
//#define BOOST_SPIRIT_X3_DEBUG
#include <iostream>
#include <fstream>
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/include/support_istream_iterator.hpp>
namespace x3 = boost::spirit::x3;
namespace AST {
struct Variable {
std::vector<std::string> namespaces, nested_objects;
friend std::ostream& operator<<(std::ostream& os, Variable const& v) {
for (auto ns : v.namespaces)
os << '[' << ns << "]::";
bool first = true;
for (auto obj : v.nested_objects) {
os << (first?"":".") << '[' << obj << ']';
first = false;
}
return os;
}
};
using Literal = boost::variant<std::string, double>;
struct FunctionCall {
Variable name;
std::vector<std::string> arguments;
};
}
BOOST_FUSION_ADAPT_STRUCT(AST::Variable, namespaces, nested_objects)
BOOST_FUSION_ADAPT_STRUCT(AST::FunctionCall, name, arguments)
namespace rules {
using namespace x3;
auto ident = rule<struct ident_, std::string> {"ident"}
= lexeme [ raw [ (alpha|'_') >> *(alnum|'_') ] ];
auto namespace_ = rule<struct namespace_, std::string> {"namespace_"}
= ident >> "::";
auto quoted_str = rule<struct quoted_str_, std::string> {"quoted_str"}
= lexeme [ '"' >> *('\\' >> char_ | ~char_('"')) >> '"' ];
auto constant = rule<struct constant_, AST::Literal> {"constant"}
= quoted_str | double_;
auto variable = rule<struct variable_, AST::Variable> {"variable"}
= *namespace_ >> ident % '.';
auto operand = rule<struct operand_> {"operand"}
= *char_("+-") >> (variable | constant);
auto expression = rule<struct expression_, std::string> {"expression"}
= raw [ operand % char_("*+/-") ];
auto arguments = expression % ',';
auto function_call = rule<struct function_call_, AST::FunctionCall> {"function_call"}
= variable >> '(' >> -arguments >> ')';
auto simple_function = skip(space) [ function_call ];
}
int main()
{
// parsing the raw sources out as string
{
std::ifstream file("flask");
boost::spirit::istream_iterator f(file), l;
std::vector<std::string> src;
parse(f, l, *x3::seek[x3::raw[rules::simple_function]], src);
for (auto& call : src)
std::cout << call << "\n";
}
// parsing AST::FunctionCall objects
{
std::ifstream file("flask");
boost::spirit::istream_iterator f(file), l;
std::vector<AST::FunctionCall> parsed;
parse(f, l, *x3::seek[rules::simple_function], parsed);
for (auto& call : parsed) {
std::cout << call.name << "\n";
for (auto& argument : call.arguments)
std::cout << " - argument: " << argument << "\n";
}
}
}
同时打印“源”解析和“AST”解析：
anno::copyright_notice("XXXXX")
anno::author("Som\"e\"one")
anno::contributor("")
state::texture_coordinate(0)
state::texture_tangent_u(0)
state::texture_tangent_v(0)
[anno]::[copyright_notice]
- argument: "XXXXX"
[anno]::[author]
- argument: "Som\"e\"one"
[anno]::[contributor]
- argument: ""
[state]::[texture_coordinate]
- argument: 0
[state]::[texture_tangent_u]
- argument: 0
[state]::[texture_tangent_v]
- argument: 0