我想解析点语言（http://www.graphviz.org/content/dot-language）。它是一种图形定义语言，用于定义它们之间的节点和连接。典型的陈述看起来像node1->node2->node3;。使用boost :: spirit列表运算符%来制作节点列表会很不错。一种天真的方法是：
edge_stmt %=
(
node_or_subgraph(_r1) % (qi::eps(_r1) >> tok.diredgeop | tok.undiredgeop)
) >> -attr_list;
_r1表示这是有向图还是无向图，diredgeop是->的标记，undiredgeop分别是--的标记。
问题是上面的代码仅对node1;成功，这是不正确的。为了获得正确的解析器，我必须以某种方式声明%构建的列表中必须至少有两个元素。怎么样？
文档说a % b等同于a >> *(omit[b] >> a)，这是不正确的。有人可能想试试这个：
edge_stmt %=
(
node_or_subgraph(_r1) >>
+(
qi::omit
[
qi::eps(_r1) >> tok.diredgeop | tok.undiredgeop
] >>
node_or_subgraph(_r1)
)
) >> -attr_list;
但是这段代码并没有产生一个向量，它的合成属性是一个元组。
我当然可以尝试语义行为，但有没有一个优雅的替代方案而没有单调行动？
答案 0 :(得分：2)
问题是上面的代码只会成功
node1;，这是不正确的。
你正在游泳。只有node1;在DOT中没问题。因此，安排你的语法也可能更容易反映它。
Graphviz的语法有很多特性，很难将语法树直接翻译成有用的图形表示。
我认为这反映了他们自己的解析函数动态构建图形，而不是试图表示源语法树。
这很明显，因为语义是有状态的，在全局状态，词法范围和子图命名空间之间有微妙的混合。图中的外观顺序很重要。节点总是共享一个“全局”命名空间和这一事实可以隐式声明，这是一个不能简化事情的因素。
虽然我不是通常是语义动作的粉丝¹，但似乎在这里使用语义动作。您可以通过使用“事件”响应每个已解析的规则来模仿Graphviz解析器的行为，该事件可以由有状态的“构建器”处理，从而导致对域模型进行适当的更改。
然而，我尝试这样做，它变得非常复杂，主要是因为规则的合成类型不便于构建。
分离关注是消除此类瓶颈的关键。
如果先解析纯AST并从中构建模型，则解析器和语义逻辑都会大大简化。
我发明了以下Model表示，我认为它很好地捕获了GraphViz域模型的语义：
TODO
让我们创建一个单独的类来表示源文档。注意：
namespace Model {
using Id = std::string;
using Attributes = std::map<Id, std::string>;
enum class GraphKind { directed, undirected };
enum class CompassPoint { n, ne, e, se, s, sw, w, nw, c, _ };
struct NodeRef {
Id id;
Id port;
CompassPoint compass_pt = CompassPoint::_;
};
}
namespace Ast {
using Model::CompassPoint;
using Model::Id;
using Model::NodeRef;
using Model::GraphKind;
using OptionalId = boost::optional<Id>;
using AList = Model::Attributes;
using AttrList = std::vector<AList>;
struct AttrStmt {
enum Group { graph, node, edge } group;
AttrList attributes;
};
struct Attr {
Id key, value;
operator std::pair<Id, Id>() const { return {key, value}; }
};
struct NodeStmt {
NodeRef node_id;
AttrList attributes;
};
struct EdgeStmt;
using Stmt = boost::variant<
AttrStmt,
Attr,
NodeStmt,
boost::recursive_wrapper<EdgeStmt> // includes sub graphs
>;
using StmtList = std::vector<Stmt>;
struct Graph {
OptionalId id;
StmtList stmt_list;
};
struct EdgeStmt {
std::vector<boost::variant<NodeRef, Graph> > hops;
AttrList attributes;
};
struct GraphViz {
bool strict;
GraphKind kind;
Graph graph;
};
}
语法只是严格遵循规范，并将1：1映射到Ast，所以我们不需要做任何魔术（¹再次）。
namespace Parser {
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
template <typename It>
struct GraphViz : qi::grammar<It, Ast::GraphViz()> {
GraphViz() : GraphViz::base_type(start) {
using namespace qi;
using boost::spirit::repository::qi::distinct;
auto kw = distinct(char_("a-zA-Z0-9_"));
start = skip(space) [matches[kw["strict"]] >> kind_ >> graph_];
kind_ %= kw["digraph"] >> attr(GraphKind::directed) [ set_arrow_(px::val("->")) ]
| kw["graph"] >> attr(GraphKind::undirected) [ set_arrow_(px::val("--")) ]
;
graph_ = -ID_ >> stmt_list;
subgraph_ = -(kw["subgraph"] >> -ID_) >> stmt_list;
string_ = '"' >> *('\\' >> char_ | ~char_('"')) >> '"';
ID_ = string_ | +char_("a-zA-Z0-9_");
stmt_list = '{' >> *(stmt >> -lit(';')) >> '}';
stmt = attr_stmt
| attribute
| node_stmt
| edge_stmt
;
attr_stmt = kw[attr_group] >> attr_list;
attribute = ID_ >> '=' >> ID_;
node_stmt = node_id >> -attr_list >> !arrow_;
edge_stmt
= (node_id | subgraph_) % arrow_ >> -attr_list
;
a_list = '[' >> *(attribute >> -omit[char_(",;")]) >> ']';
attr_list = +a_list;
node_id
= ID_ >> (
(attr(Ast::Id{})) >> (':' >> kw[compass_pt]) >> !lit(':')
| (':' >> ID_ | attr(Ast::Id{})) >> (':' >> kw[compass_pt] | attr(Ast::CompassPoint::_))
)
;
BOOST_SPIRIT_DEBUG_NODES(
(graph_) (subgraph_)
(a_list) (attr_list)
(stmt) (attr_stmt) (attribute) (node_stmt) (edge_stmt) (stmt_list)
(node_id)
(start)(kind_)(ID_)(string_)
)
}
private:
////////////////////////
using Skipper = qi::space_type;
//////////////////////////////
// Arrows depend on GraphKind
qi::symbols<const char> arrow_;
struct set_arrow_t { // allow dynamic setting
qi::symbols<const char>& _ref;
void operator()(const char* op) const { _ref.clear(); _ref.add(op); }
};
px::function<set_arrow_t> set_arrow_ { {arrow_} };
////////////////////////
// enums using symbols<>
struct AttrGroup : qi::symbols<const char, Ast::AttrStmt::Group> {
AttrGroup() { add
("graph", Ast::AttrStmt::Group::graph)
("node", Ast::AttrStmt::Group::node)
("edge", Ast::AttrStmt::Group::edge);
}
} attr_group;
struct CompassPoint : qi::symbols<const char, Ast::CompassPoint> {
CompassPoint() { add
("n", Ast::CompassPoint::n)
("ne", Ast::CompassPoint::ne)
("e", Ast::CompassPoint::e)
("se", Ast::CompassPoint::se)
("s", Ast::CompassPoint::s)
("sw", Ast::CompassPoint::sw)
("w", Ast::CompassPoint::w)
("nw", Ast::CompassPoint::nw)
("c", Ast::CompassPoint::c)
("_", Ast::CompassPoint::_);
}
} compass_pt;
////////////////////////
// productions
qi::rule<It, Ast::Graph(), Skipper> graph_, subgraph_;
qi::rule<It, Ast::AList(), Skipper> a_list;
qi::rule<It, Ast::AttrList(), Skipper> attr_list;
qi::rule<It, Ast::NodeRef(), Skipper> node_id; // misnomer
qi::rule<It, Ast::Stmt(), Skipper> stmt;
qi::rule<It, Ast::AttrStmt(), Skipper> attr_stmt;
qi::rule<It, Ast::Attr(), Skipper> attribute;
qi::rule<It, Ast::NodeStmt(), Skipper> node_stmt;
qi::rule<It, Ast::EdgeStmt(), Skipper> edge_stmt;
qi::rule<It, Ast::StmtList(), Skipper> stmt_list;
// implicit lexemes
using GraphKind = Ast::GraphKind;
qi::rule<It, Ast::GraphViz()> start;
qi::rule<It, GraphKind()> kind_;
qi::rule<It, Ast::Id()> ID_;
qi::rule<It, std::string()> string_;
};
}
演示时间
实际上，这部分已经解析了GraphViz文档。没有在线编译器愿意接受这个（超出资源限制）。以下是此阶段的完整示例：https://wandbox.org/permlink/AYmxpD6lzOdhOeiS
来自我的机器的输出（在pastebin中有完整的调试信息）
Parse success (0 directed ( G {(graph {["rankdir"="LR"; ]; }); (node {["shape"="record"; ]; }); ((Bar _) {["label"="{ \"Bar\"|{<p1>pin 1|<p2> 2|<p3> 3|<p4> 4|<p5> 5} }"; ]; }); ((Foo _) {["label"="{ {<data0>data0|<data1>data1|<data2>data2|<data3>data3|<data4>data4}|\"Foo\" |{<out0>out0|<out1>out1|<out2>out2|<GND>gnd|<ex0>ex0|<hi>hi|<lo>lo} }"; ]; }); ((Bew _) {["label"="{ {<clk>clk|<syn>syn|<mux0>mux0|<mux1>mux1|<signal>signal}|\"Bew\" |{<out0>out0|<out1>out1|<out2>out2} }"; ]; }); ({(Bar p1 _); (Foo data0 _); } {}); ({(Bar p2 _); (Foo data1 _); } {}); ({(Bar p3 _); (Foo data2 _); } {}); ({(Bar p4 _); (Foo data3 _); } {}); ({(Bar p5 _); (Foo data4 _); } {}); ((hijacked _) {}); ({(Foo out0 _); (Bew mux0 _); } {}); ({(Foo out1 _); (Bew mux1 _); } {}); ({(Bew clk _); (Foo ex0 _); } {}); ((Gate _) {["label"="{ {<a>a|<b>b}|OR|{<ab>a|b} }"; ]; }); ({(Foo hi _); (Gate a _); } {}); ({(Foo lo _); (Gate b _); } {}); ({(Gate ab _); (Bew signal _); } {}); ((subgraph _) {}); ((cluster1 _) {}); ({(-- {(graph {["label"="G1"; ]; }); ((2 _) {}); ((3 _) {}); ({(2 _); (4 _); } {}); ({(3 _); (9 _); } {}); ({(3 _); (12 _); } {}); ({(9 _); (11 _); } {}); ({(9 _); (10 _); } {}); ({(10 _); (3 _); } {}); }); } {}); ((subgraph _) {}); ((cluster2 _) {}); ({(-- {(graph {["label"="G2"; ]; }); ({(10 _); (3 _); } {}); ((more _) {}); ((subgraph _) {}); ((clusterNested _) {}); ({(-- {(graph {["label"="nested"; ]; }); ((innermost _) {}); ((hijacked _) {["shape"="diamond"; ]; }); }); } {}); }); } {}); ((subgraph _) {}); ((cluster1 _) {}); ({(-- {(graph {["label"="G1_override"; ]; }); ({(11 _); (4 _); } {}); ((last _) {}); ((hijacked _) {}); ((subgraph _) {}); ((clusterNested _) {}); ({(-- {(graph {["label"="can override nested?"; ]; }); ({(-- {((unnested _) {}); ((first_override _) {}); }); } {["color"="red"; ]; }); }); } {}); }); } {}); ((10 _) {["shape"="circle"; ]; ["color"="red"; ]; }); ((10 _) {["color"="red"; "shape"="circle"; ]; }); ((10 _) {["color"="red"; "shape"="circle"; ]; }); ((subgraph _) {}); ((clusterNested _) {}); ({(-- {(graph {["label"="can't override nested"; ]; }); ((unnested _) {}); ((second_override _) {}); }); } {}); ({(more _); (last _); } {}); })) Remaining unparsed input: ' '
¹Boost Spirit: "Semantic actions are evil"?
²我将这类复杂性归类为“阻抗不匹配”，这是我最初从对象关系映射框架中学到的一个术语
答案 1 :(得分：1)
使列表运算符接受最少数量的元素需要创建引入该行为的全新解析器，因为与repeat不同，它不配置为执行此操作。我希望以下示例可以帮助您了解如何使用a >> +(omit[b] >> a)来实现您的目标。
#include <iostream>
#include <vector>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/std_pair.hpp>
namespace qi= boost::spirit::qi;
void print(const std::vector<std::string>& data)
{
std::cout << "{ ";
for(const auto& elem : data) {
std::cout << elem << " ";
}
std::cout << "} ";
}
void print(const std::pair<std::string,double>& data)
{
std::cout << "[ " << data.first << ", " << data.second << " ]";
}
template <typename Parser,typename... Attrs>
void parse(const std::string& str, const Parser& parser, Attrs&... attrs)
{
std::string::const_iterator iter=std::begin(str), end=std::end(str);
bool result = qi::phrase_parse(iter,end,parser,qi::space,attrs...);
if(result && iter==end) {
std::cout << "Success.";
int ignore[] = {(print(attrs),0)...};
std::cout << "\n";
} else {
std::cout << "Something failed. Unparsed: \"" << std::string(iter,end) << "\"\n";
}
}
template <typename Parser>
void parse_with_nodes(const std::string& str, const Parser& parser)
{
std::vector<std::string> nodes;
parse(str,parser,nodes);
}
template <typename Parser>
void parse_with_nodes_and_attr(const std::string& str, const Parser& parser)
{
std::vector<std::string> nodes;
std::pair<std::string,double> attr_pair;
parse(str,parser,nodes,attr_pair);
}
int main()
{
qi::rule<std::string::const_iterator,std::string()> node=+qi::alnum;
qi::rule<std::string::const_iterator,std::pair<std::string,double>(),qi::space_type> attr = +qi::alpha >> '=' >> qi::double_;
parse_with_nodes("node1->node2", node % "->");
parse_with_nodes_and_attr("node1->node2 arrowsize=1.0", node % "->" >> attr);
parse_with_nodes("node1->node2", node >> +("->" >> node));
//parse_with_nodes_and_attr("node1->node2 arrowsize=1.0", node >> +("->" >> node) >> attr);
qi::rule<std::string::const_iterator,std::vector<std::string>(),qi::space_type> at_least_two_nodes = node >> +("->" >> node);
parse_with_nodes_and_attr("node1->node2 arrowsize=1.0", at_least_two_nodes >> attr);
}