英文:
How to parse code definition text into XML structure with the latest Boost Spirit?
问题
我是新手学习C++，第一次使用Boost Spirit来处理一个团队的任务，学习并使用C++（我来自web开发背景 :））。在互联网上搜索时，我看到了一些来自这个社区的很好的示例（尤其是来自Sehe），但由于XML结构的复杂性，我无法将所有东西完全组合在一起以完成此任务。
这个解析器将充当中间人，将结构代码定义（由其他团队编写）翻译成XML，以供多个集成团队使用，并根据XML结构生成他们选择的语言的代码。
以下是代码结构定义文本的小例子（来自外部文件）。这个文件根据任务的复杂性可能非常大
Class Simple caption;
Class Simple columns "Column Name";
Class Container CONTAINER_NAME (
Complex OBJECT_NAME (
Simple obj_id
Simple obj_property1
Simple obj_attribute enumeration(EnumOption1, EnumOption2,EnumOption3,EnumOption4)
Container OBJECT_ITEMS (
Complex OBJECT_ITEM (
Simple obj_item_name
Container set_value (
Simple obj_item_value
)
)
)
)
);
解析器将评估并生成以下格式的XML
<task>
<class>
<simple>
<identifier>caption</identifier>
<literal>" "</literal>
</simple>
</class>
<class>
<simple>
<identifier>caption</identifier>
<literal>"Column Name"</literal>
</simple>
</class>
<class>
<container>
<identifier>CONTAINER_NAME:CONTAINER_NAME</identifier>
<literal>" "</literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_NAME</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_id</identifier>
<literal>" "</literal>
</simple>
<simple>
<identifier>CONTAINER_NAME:obj_property1</identifier>
<literal>" "</literal>
</simple>
<simple>
<identifier>CONTAINER_NAME:obj_attribute</identifier>
<literal>" "</literal>
<enumeration>
<word>EnumOption1</word>
<word>EnumOption2</word>
<word>EnumOption3</word>
<word>EnumOption4</word>
</enumeration>
</simple>
<container>
<identifier>CONTAINER_NAME:OBJECT_ITEMS</identifier>
<literal>" "</literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_ITEM</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_name</identifier>
<literal>" "</literal>
</simple>
<container>
<identifier>CONTAINER_NAME:set_value</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_value</identifier>
<literal>" "</literal>
</simple>
</container>
</complex>
</container>
</complex>
</container>
</class>
</task>
根据我所了解，我需要以下内容（只是我基本了解的思路）：
- 具有Class、Container、Complex、Simple等规则的语法定义，以解析代码定义文本（我的最大挑战）；
- 一些语义动作/函数来为每个组（Simple、Complex、Container、Class等）创建XML节点。我看到我可以在这里使用msxml6.dll来生成XML，但无法弄清楚如何将它们连接起来。
我看到一些示例是从AST构建XML，但他们使用的XML结构不完全遵循任何标准，因为Container可以包含Complex，但Complex也可以包含Container。
任何帮助、指导或示例，指向我从哪里开始将不胜感激。
更新
- 分号用于表示CLASS块的结束。
- 存在注释，但将位于单独的一行上。没有内联注释。
- 代码定义中没有literal标签。字面内容位于双引号内。请参阅更新的代码定义结构块第2行。
英文:
I'm new to C++ and first time using Boost Spirit taking on a task for my team to learn and work with C++ (coming from web developer background :)). Searching from the internet, I saw some great examples from this community (especially from Sehe) but can't quite piece all things together to achieve this task due to the complication of the XML structure.
This parser will act as the middle man to translate structure code definition (written by some other teams) to XML for multiple integration teams to use and generate code from it to the language of their choices base on the XML structure.
Below is a small example of the code structure definition text (from external file). This file could be very large depending on the task
Class Simple caption;
Class Simple columns "Column Name";
Class Container CONTAINER_NAME (
Complex OBJECT_NAME (
Simple obj_id
Simple obj_property1
Simple obj_attribute enumeration(EnumOption1, EnumOption2,EnumOption3,EnumOption4)
Container OBJECT_ITEMS (
Complex OBJECT_ITEM (
Simple obj_item_name
Container set_value (
Simple obj_item_value
)
)
)
)
);
The parser will evaluate and produce XML in this format
<task>
<class>
<simple>
<identifier>caption</identifier>
<literal>" "</literal>
</simple>
</class>
<class>
<simple>
<identifier>caption</identifier>
<literal>"Column Name"</literal>
</simple>
</class>
<class>
<container>
<identifier>CONTAINER_NAME:CONTAINER_NAME</identifier>
<literal>" "</literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_NAME</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_id</identifier>
<literal>" "</literal>
</simple>
<simple>
<identifier>CONTAINER_NAME:obj_property1</identifier>
<literal>" "</literal>
</simple>
<simple>
<identifier>CONTAINER_NAME:obj_attribute</identifier>
<literal>" "</literal>
<enumeration>
<word>EnumOption1</word>
<word>EnumOption2</word>
<word>EnumOption3</word>
<word>EnumOption4</word>
</enumeration>
</simple>
<container>
<identifier>CONTAINER_NAME:OBJECT_ITEMS</identifier>
<literal>" "</literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_ITEM</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_name</identifier>
<literal>" "</literal>
</simple>
<container>
<identifier>CONTAINER_NAME:set_value</identifier>
<literal>" "</literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_value</identifier>
<literal>" "</literal>
</simple>
</container>
</complex>
</container>
</complex>
</container>
</class>
</task>
From what I've read, I will need (just my thought process with a very basic knowledge of this) the following:
- Grammar definition with rules for Class, Container, Complex, Simple, to parse the code definition text (my biggest challenge);
- Some kind of semantic actions/functions to create XML node for each group (Simple, complex, container, class, etc.). I see that I can use msxml6.dll here for xml generator, but can't figure out how to go hook them in.
I saw a few examples to construct AST then build XML from it but the XML structure they use is not quite follow any standard as Container can have Complex, but Complex can also have Container
Any help or instruction or example to point me to where to begin would be greatly appreciate.
UPDATED
- Semicolon is used to indicate the end of CLASS block.
- Comment exists but will be on separate line. No inline comment.
- There is no literal tag in code definition. literal content is inside doublequote. See updated code definition structure block line #2.
答案1
得分: 1
好的，以下是您请求的翻译部分：
好的，这些解释帮助我意识到了输入和XML之间的对应关系。仍然有一些不太清楚的规范，但让我们继续。
# 解析
1. ### _AST_
一如既往，我从AST开始。这一次，与其基于示例输入，不如基于输出XML更容易：
namespace Ast {
using boost::recursive_wrapper;
using Id = std::string;
using Literal = std::string;
using Enum = std::vector<Id>;
struct Base {
Id id;
Literal literal;
};
struct Simple : Base {
Enum enumeration;
};
struct Complex;
struct Container;
using Class = boost::variant<
Simple,
recursive_wrapper<Complex>,
recursive_wrapper<Container>
>;
using Classes = std::vector<Class>;
struct Container : Base { Class element; };
struct Complex : Base { Classes members; };
using Task = std::vector<Class>;
} // namespace Ast
到目前为止还好，没有什么意外。主要的事情是使用递归变体来允许嵌套复杂/容器类型。作为副产品，我将所有类型的共同部分都反映为`Base`。让我们适应这些，以便作为Fusion序列使用：
BOOST_FUSION_ADAPT_STRUCT(Ast::Simple, id, literal, enumeration);
BOOST_FUSION_ADAPT_STRUCT(Ast::Complex, id, literal, members)
BOOST_FUSION_ADAPT_STRUCT(Ast::Container, id, literal, element)
现在Spirit将知道如何传播属性，无需进一步帮助。
2. ### _语法_
骨架很简单，只是将AST节点映射到规则：
template <typename It> struct Task : qi::grammar<It, Ast::Task()> {
Task() : Task::base_type(start) {
start = skip(space)[task_];
// ...
}
private:
qi::rule<It, Ast::Task()> start;
using Skipper = qi::space_type;
qi::rule<It, Ast::Task(), Skipper> task_;
qi::rule<It, Ast::Class(), Skipper> class_;
qi::rule<It, Ast::Simple(), Skipper> simple_;
qi::rule<It, Ast::Complex(), Skipper> complex_;
qi::rule<It, Ast::Container(), Skipper> container_;
// 词法单元：
qi::rule<It, Ast::Id()> id_;
qi::rule<It, Ast::Literal()> literal_;
};
注意，我将词法单元（不允许跳过）分组，并将`space`跳过器封装到起始规则中。
因为“classes”可以明确出现，也可以没有前导的`Class`关键字，所以我将引入额外的规则`type_`，这样我们可以这样说：
task_ = *class_ > eoi;
type_ = simple_ | complex_ | container_;
class_ = "Class" > type_ > ';';
并在可以接受Simple/Complex/Container的地方使用`type_`。
对于其余部分，没有太多意外，所以让我们展示整个构造块：
Task() : Task::base_type(start) {
using namespace qi;
start = skip(space)[task_];
// 词法单元：
id_ = raw[alpha >> *('_' | alnum)];
literal_ = '"' > *('\\' >> char_ | ~char_('"')) > '"';
auto optlit = copy(literal_ | attr(std::string(" "))); // 奇怪，但可以
task_ = *class_ > eoi;
type_ = simple_ | complex_ | container_;
class_ = lit("Class") > type_ > ';';
simple_ = lit("Simple") >> id_ >> optlit >> enum_;
complex_ = lit("Complex") >> id_ >> optlit >> '(' >> *type_ >> ')';
container_ = lit("Container") >> id_ >> optlit >> '(' >> type_ >> ')';
enum_ = -(lit("enumeration") >> '(' >> (id_ % ',') > ')' );
BOOST_SPIRIT_DEBUG_NODES(
(task_)(class_)(type_)(simple_)(complex_)(container_)(enum_)(id_)(literal_))
}
> _请注意另一个“额外”的规则（`enum_`）。当然，我可以将所有内容都保留在`simple_`规则中。_
这里有一个**[演示链接](http://coliru.stacked-crooked.com/a/7c57ff4ecf6708f8)**，用于打印示例输入的原始AST：
- (caption " " {})
- (columns "Column Name" {})
- (CONTAINER_NAME " " (OBJECT_NAME " " {(obj_id " " {}), (obj_property1 " " {}), (obj_attribute " " {EnumOption1, EnumOption2, EnumOption3, EnumOption4}), (OBJECT_ITEMS " " (OBJECT_ITEM " " {(obj_item_name " " {}), (set_value " " (obj_item_value " " {}))}))})
遗憾的是，我的所有漂亮的错误处理代码都没有启动:) 输出显然非常丑陋，所以让我们修复它。
# 生成XML
我不是微软的粉丝，也更喜欢其他库来处理XML（参见https://stackoverflow.com/questions/9387610/what-xml-parser-should-i-use-in-c）。
所以我选择了
<details>
<summary>英文:</summary>
Okay, the explanations helped me realize the correspondence between the input and the XML. There's still a number of ... unclear specs, but let's roll with it.
# Parsing
----
1. ### _AST_
As always, I start out with the AST. This time instead of basing it on the sample input, it was easier to base it on the output XML:
namespace Ast {
using boost::recursive_wrapper;
using Id = std::string;
using Literal = std::string;
using Enum = std::vector<Id>;
struct Base {
Id id;
Literal literal;
};
struct Simple : Base {
Enum enumeration;
};
struct Complex;
struct Container;
using Class = boost::variant<
Simple,
recursive_wrapper<Complex>,
recursive_wrapper<Container>
>;
using Classes = std::vector<Class>;
struct Container : Base { Class element; };
struct Complex : Base { Classes members; };
using Task = std::vector<Class>;
} // namespace Ast
So far so good. No surprises. The main thing is using recursive variants to allow nesting complex/container types. As a side note I reflected the common parts of all types as `Base`. Let's adapt these for use as Fusion sequences:
BOOST_FUSION_ADAPT_STRUCT(Ast::Simple, id, literal, enumeration);
BOOST_FUSION_ADAPT_STRUCT(Ast::Complex, id, literal, members)
BOOST_FUSION_ADAPT_STRUCT(Ast::Container, id, literal, element)
Now Spirit will know how to propagate attributes without further help.
1. ### _Grammar_
The skeleton is easy, just mapping AST nodes to rules:
template <typename It> struct Task : qi::grammar<It, Ast::Task()> {
Task() : Task::base_type(start) {
start = skip(space)[task_];
// ...
}
private:
qi::rule<It, Ast::Task()> start;
using Skipper = qi::space_type;
qi::rule<It, Ast::Task(), Skipper> task_;
qi::rule<It, Ast::Class(), Skipper> class_;
qi::rule<It, Ast::Simple(), Skipper> simple_;
qi::rule<It, Ast::Complex(), Skipper> complex_;
qi::rule<It, Ast::Container(), Skipper> container_;
// lexemes:
qi::rule<It, Ast::Id()> id_;
qi::rule<It, Ast::Literal()> literal_;
};
Note I grouped the lexemes (that [do not allow a skipper](https://stackoverflow.com/a/17073965/85371)) and encapsulated the `space` skipper into the start rule.
Because "classes" can appear explicitly, but also without the leading `Class` keyword, I will introduce an extra rule `type_` so we can say:
task_ = *class_ > eoi;
type_ = simple_ | complex_ | container_;
class_ = "Class" > type_ > ';';
And also use `type_` where Simple/Complex/Container is acceptable.
For the rest, there aren't many surprises, so let's show the whole constructor block:
Task() : Task::base_type(start) {
using namespace qi;
start = skip(space)[task_];
// lexemes:
id_ = raw[alpha >> *('_' | alnum)];
literal_ = '"' > *('\\' >> char_ | ~char_('"')) > '"';
auto optlit = copy(literal_ | attr(std::string(" "))); // weird, but okay
task_ = *class_ > eoi;
type_ = simple_ | complex_ | container_;
class_ = lit("Class") > type_ > ';';
simple_ = lit("Simple") >> id_ >> optlit >> enum_;
complex_ = lit("Complex") >> id_ >> optlit >> '(' >> *type_ >> ')';
container_ = lit("Container") >> id_ >> optlit >> '(' >> type_ > ')';
enum_ = -(lit("enumeration") >> '(' >> (id_ % ',') > ')');
BOOST_SPIRIT_DEBUG_NODES(
(task_)(class_)(type_)(simple_)(complex_)(container_)(enum_)(id_)(literal_))
}
> _Note the other "extra" (`enum_`). Of course, I could have kept it all in the `simple_` rule instead._
Here's a **[Live Demo](http://coliru.stacked-crooked.com/a/7c57ff4ecf6708f8)** printing the raw AST for the sample input:
- (caption " " {})
- (columns "Column Name" {})
- (CONTAINER_NAME " " (OBJECT_NAME " " {(obj_id " " {}), (obj_property1 " " {}), (obj_attribute " " {EnumOption1, EnumOption2, EnumOption3, EnumOption4}), (OBJECT_ITEMS " " (OBJECT_ITEM " " {(obj_item_name " " {}), (set_value " " (obj_item_value " " {}))}))}))
It's just a shame that all my pretty error handling code is not firing :) The output is obviously pretty ugly, so let's fix that.
# Generating XML
----
I'm not a Microsoft fan, and prefer other libraries for XML anyways (see https://stackoverflow.com/questions/9387610/what-xml-parser-should-i-use-in-c).
So I'll choose PugiXML here.
1. ### Generator
Simply put, we have to teach the computer how to convert any Ast node into XML:
#include <pugixml.hpp>
namespace Generate {
using namespace Ast;
struct XML {
using Node = pugi::xml_node;
// callable for variant visiting:
template <typename T> void operator()(Node parent, T const& node) const { apply(parent, node); }
private:
void apply(Node parent, Ast::Class const& c) const {
using std::placeholders::_1;
boost::apply_visitor(std::bind(*this, parent, _1), c);
}
void apply(Node parent, Id const& id) const {
auto identifier = named_child(parent, "identifier");
identifier.text().set(id.c_str());
}
void apply(Node parent, Literal const& l) const {
auto literal = named_child(parent, "literal");
literal.text().set(l.c_str());
}
void apply(Node parent, Simple const& s) const {
auto simple = named_child(parent, "simple");
apply(simple, s.id);
apply(simple, s.literal);
apply(simple, s.enumeration);
}
void apply(Node parent, Enum const& e) const {
if (!e.empty()) {
auto enum_ = named_child(parent, "enumeration");
for (auto& v : e)
named_child(enum_, "word").text().set(v.c_str());
}
}
void apply(Node parent, Complex const& c) const {
auto complex_ = named_child(parent, "complex");
apply(complex_, c.id);
apply(complex_, c.literal);
for (auto& m : c.members)
apply(complex_, m);
}
void apply(Node parent, Container const& c) const {
auto cont = named_child(parent, "container");
apply(cont, c.id);
apply(cont, c.literal);
apply(cont, c.element);
}
void apply(Node parent, Task const& t) const {
auto task = named_child(parent, "task");
for (auto& c : t)
apply(task, c);
}
private:
Node named_child(Node parent, std::string const& name) const {
auto child = parent.append_child();
child.set_name(name.c_str());
return child;
}
};
} // namespace Generate
I'm not gonna say I typed this up error-free in a jiffy, but you'll recognize the pattern: It's following the Ast 1:1 to great success.
# FULL DEMO
------
Integrating all the above, and printing the XML output:
**[Live On Compiler Explorer](https://compiler-explorer.com/z/9a17K4Gdf)**
// #define BOOST_SPIRIT_DEBUG 1
#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/qi.hpp>
#include <iomanip>
namespace qi = boost::spirit::qi;
namespace Ast {
using boost::recursive_wrapper;
using Id = std::string;
using Literal = std::string;
using Enum = std::vector<Id>;
struct Base {
Id id;
Literal literal;
};
struct Simple : Base {
Enum enumeration;
};
struct Complex;
struct Container;
using Class = boost::variant< //
Simple, //
recursive_wrapper<Complex>, //
recursive_wrapper<Container> //
>;
using Classes = std::vector<Class>;
struct Container : Base { Class element; };
struct Complex : Base { Classes members; };
using Task = std::vector<Class>;
} // namespace Ast
BOOST_FUSION_ADAPT_STRUCT(Ast::Simple, id, literal, enumeration);
BOOST_FUSION_ADAPT_STRUCT(Ast::Complex, id, literal, members)
BOOST_FUSION_ADAPT_STRUCT(Ast::Container, id, literal, element)
namespace Parser {
template <typename It> struct Task : qi::grammar<It, Ast::Task()> {
Task() : Task::base_type(start) {
using namespace qi;
start = skip(space)[task_];
// lexemes:
id_ = raw[alpha >> *('_' | alnum)];
literal_ = '"' > *('\\' >> char_ | ~char_('"')) > '"';
auto optlit = copy(literal_ | attr(std::string(" "))); // weird, but okay
task_ = *class_ > eoi;
type_ = simple_ | complex_ | container_;
class_ = lit("Class") > type_ > ';';
simple_ = lit("Simple") >> id_ >> optlit >> enum_;
complex_ = lit("Complex") >> id_ >> optlit >> '(' >> *type_ >> ')';
container_ = lit("Container") >> id_ >> optlit >> '(' >> type_ > ')';
enum_ = -(lit("enumeration") >> '(' >> (id_ % ',') > ')');
BOOST_SPIRIT_DEBUG_NODES(
(task_)(class_)(type_)(simple_)(complex_)(container_)(enum_)(id_)(literal_))
}
private:
qi::rule<It, Ast::Task()> start;
using Skipper = qi::space_type;
qi::rule<It, Ast::Task(), Skipper> task_;
qi::rule<It, Ast::Class(), Skipper> class_, type_;
qi::rule<It, Ast::Simple(), Skipper> simple_;
qi::rule<It, Ast::Complex(), Skipper> complex_;
qi::rule<It, Ast::Container(), Skipper> container_;
qi::rule<It, Ast::Enum(), Skipper> enum_;
// lexemes:
qi::rule<It, Ast::Id()> id_;
qi::rule<It, Ast::Literal()> literal_;
};
}
#include <pugixml.hpp>
namespace Generate {
using namespace Ast;
struct XML {
using Node = pugi::xml_node;
// callable for variant visiting:
template <typename T> void operator()(Node parent, T const& node) const { apply(parent, node); }
private:
void apply(Node parent, Ast::Class const& c) const {
using std::placeholders::_1;
boost::apply_visitor(std::bind(*this, parent, _1), c);
}
void apply(Node parent, std::string const& s, char const* kind) const {
named_child(parent, kind).text().set(s.c_str());
}
void apply(Node parent, Simple const& s) const {
auto simple = named_child(parent, "simple");
apply(simple, s.id, "identifier");
apply(simple, s.literal, "literal");
apply(simple, s.enumeration);
}
void apply(Node parent, Enum const& e) const {
if (!e.empty()) {
auto enum_ = named_child(parent, "enumeration");
for (auto& v : e)
named_child(enum_, "word").text().set(v.c_str());
}
}
void apply(Node parent, Complex const& c) const {
auto complex_ = named_child(parent, "complex");
apply(complex_, c.id, "identifier");
apply(complex_, c.literal, "literal");
for (auto& m : c.members)
apply(complex_, m);
}
void apply(Node parent, Container const& c) const {
auto cont = named_child(parent, "container");
apply(cont, c.id, "identifier");
apply(cont, c.literal, "literal");
apply(cont, c.element);
}
void apply(Node parent, Task const& t) const {
auto task = named_child(parent, "task");
for (auto& c : t)
apply(task.append_child("class"), c);
}
private:
Node named_child(Node parent, std::string const& name) const {
auto child = parent.append_child();
child.set_name(name.c_str());
return child;
}
};
} // namespace Generate
int main() {
using It = std::string_view::const_iterator;
static const Parser::Task<It> p;
static const Generate::XML to_xml;
for (std::string_view input :
{
R"(Class Simple caption;
Class Simple columns "Column Name";
Class Container CONTAINER_NAME (
Complex OBJECT_NAME (
Simple obj_id
Simple obj_property1
Simple obj_attribute enumeration(EnumOption1, EnumOption2,EnumOption3,EnumOption4)
Container OBJECT_ITEMS (
Complex OBJECT_ITEM (
Simple obj_item_name
Container set_value (
Simple obj_item_value
)
)
)
)
);)",
}) //
{
try {
Ast::Task t;
if (qi::parse(begin(input), end(input), p, t)) {
pugi::xml_document doc;
to_xml(doc.root(), t);
doc.print(std::cout, " ", pugi::format_default);
std::cout << std::endl;
} else {
std::cout << " -> INVALID" << std::endl;
}
} catch (qi::expectation_failure<It> const& ef) {
auto f = begin(input);
auto p = ef.first - input.begin();
auto bol = input.find_last_of("\r\n", p) + 1;
auto line = std::count(f, f + bol, '\n') + 1;
auto eol = input.find_first_of("\r\n", p);
std::cerr << " -> EXPECTED " << ef.what_ << " in line:" << line << "\n"
<< input.substr(bol, eol - bol) << "\n"
<< std::setw(p - bol) << ""
<< "^--- here" << std::endl;
}
}
}
Printing the coveted output:
<!-- language: xml -->
<task>
<class>
<simple>
<identifier>caption</identifier>
<literal> </literal>
</simple>
</class>
<class>
<simple>
<identifier>columns</identifier>
<literal>Column Name</literal>
</simple>
</class>
<class>
<container>
<identifier>CONTAINER_NAME</identifier>
<literal> </literal>
<complex>
<identifier>OBJECT_NAME</identifier>
<literal> </literal>
<simple>
<identifier>obj_id</identifier>
<literal> </literal>
</simple>
<simple>
<identifier>obj_property1</identifier>
<literal> </literal>
</simple>
<simple>
<identifier>obj_attribute</identifier>
<literal> </literal>
<enumeration>
<word>EnumOption1</word>
<word>EnumOption2</word>
<word>EnumOption3</word>
<word>EnumOption4</word>
</enumeration>
</simple>
<container>
<identifier>OBJECT_ITEMS</identifier>
<literal> </literal>
<complex>
<identifier>OBJECT_ITEM</identifier>
<literal> </literal>
<simple>
<identifier>obj_item_name</identifier>
<literal> </literal>
</simple>
<container>
<identifier>set_value</identifier>
<literal> </literal>
<simple>
<identifier>obj_item_value</identifier>
<literal> </literal>
</simple>
</container>
</complex>
</container>
</complex>
</container>
</class>
</task>
> _I still don't unserstand how the `CONTAINER_NAME:` "namespacing" works, so I'll leave that to you to get right._
</details>
# 答案2
**得分**: 0
感谢你再次提供这么棒的教训。回答你关于 CONTAINER_NAME 命名空间的问题，它只是用于分组（并不是我规定的，而是定义结构的制定者们想要它这样）。
因此，如果我们解析这行代码：
```cpp
Class Simple caption;
那么结果应该是：
<task>
<class>
<simple>
<identifier>caption:caption</identifier>
<literal>" "</literal>
</simple>
</class>
</task>
命名空间 caption: 被添加，因为这是该类的第一个子元素。但是如果我们解析：
Class Container CONTAINER_NAME (
Complex OBJECT_NAME (
Simple obj_id
Container OBJECT_ITEMS (
Complex OBJECT_ITEM (
Simple obj_item_name
Container set_value (
Simple obj_item_value
)
)
)
)
);
那么 CONTAINER_NAME: 命名空间将被附加到所有子元素的标识符名称中。
<class>
<container>
<identifier>CONTAINER_NAME:CONTAINER_NAME</identifier>
<literal> </literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_NAME</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_id</identifier>
<literal> </literal>
</simple>
<container>
<identifier>CONTAINER_NAME:OBJECT_ITEMS</identifier>
<literal> </literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_ITEM</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_name</identifier>
<literal> </literal>
</simple>
<container>
<identifier>CONTAINER_NAME:set_value</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_value</identifier>
<literal> </literal>
</simple>
</container>
</complex>
</container>
</complex>
</container>
</class>
我添加了以下函数来处理命名空间到 XML 结构：
std::string get_namespace(Node parent, std::string const& ident) const {
auto parent_name = std::string(parent.name());
std::string ns = ident + ":" + ident; // 默认命名空间
// 如果这是类容器的子节点，只需返回对象的标识符值并添加冒号(:)
if (parent_name != "class") {
// 父级不是类类型，只需从此父节点的标识符中提取命名空间。
std::string parent_id = parent.child("identifier").text().as_string();
ns = parent_id.substr(0, parent_id.find(":") + 1) + ident;
}
return ns;
};
然后在处理 Simple、Complex 和 Container 的 XML 时，我只需调用此函数：
void apply(Node parent, Simple const& s) const {
auto simple = named_child(parent, "simple");
apply(simple, get_namespace(parent, s.id), "identifier");
apply(simple, s.literal, "literal");
apply(simple, s.enumeration);
}
总之，还有很多工作要做，我还需要解析 if-else、case 语句，但这给了我一个很好的起点。再次感谢你花时间与我分享你的知识。
英文:
Thanks again for this great lesson. To answer your question about the CONTAINER_NAME: namespace, it just simply for grouping (not my rule, just the folks who come up with the definition structure want it that way).
So if we parse this line
Class Simple caption;
then the out come should be:
<task>
<class>
<simple>
<identifier>caption:caption</identifier>
<literal>" "</literal>
</simple>
</class>
</task>
The namespace caption: is added since this is the first child of this class. But if we are parsing
Class Container CONTAINER_NAME (
Complex OBJECT_NAME (
Simple obj_id
Container OBJECT_ITEMS (
Complex OBJECT_ITEM (
Simple obj_item_name
Container set_value (
Simple obj_item_value
)
)
)
)
);
Then the CONTAINER_NAME: namespace will be appended to all chidren's identifier name.
<class>
<container>
<identifier>CONTAINER_NAME:CONTAINER_NAME</identifier>
<literal> </literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_NAME</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_id</identifier>
<literal> </literal>
</simple>
<container>
<identifier>CONTAINER_NAME:OBJECT_ITEMS</identifier>
<literal> </literal>
<complex>
<identifier>CONTAINER_NAME:OBJECT_ITEM</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_name</identifier>
<literal> </literal>
</simple>
<container>
<identifier>CONTAINER_NAME:set_value</identifier>
<literal> </literal>
<simple>
<identifier>CONTAINER_NAME:obj_item_value</identifier>
<literal> </literal>
</simple>
</container>
</complex>
</container>
</complex>
</container>
</class>
I add the following function to handle the namespace to XML struct. It did the job but I'm pretty sure you will come up with just one line to do this...:)
std::string get_namespace(Node parent, std::string const& ident) const {
auto parent_name = std::string(parent.name());
std::string ns = ident + ":" + ident; // Default namespace
// If this is the child of class container, just return the object's identifier value and add colon (:)
if (parent_name != "class") {
// Parent is not a class type, just extract the namespace from
// identifier of this parent node.
std::string parent_id = parent.child("identifier").text().as_string();
ns = parent_id.substr(0, parent_id.find(":") + 1) + ident;
}
return ns;
};
Then I just call this function when handling XML for Simple, Complex, and Container
void apply(Node parent, Simple const& s) const {
auto simple = named_child(parent, "simple");
apply(simple, get_namespace(parent, s.id), "identifier");
apply(simple, s.literal, "literal");
apply(simple, s.enumeration);
}
Anyway, there's a lot more for me to do as I need to also parse if-else, case statements but this give me a great starting point. Again, thanks for taking time sharing your knowledge with me.
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。
评论