~extracted_ptree_iterator(void) {
while (! ended_()) {
auto& top = extracted_ptree_.stack_.top();
top.it = top.end;
collapse_();
}
}
void increment(void) {
if (ended_()) return;
auto& top = extracted_ptree_.stack_.top();
if (top.it == top.end) return;
++(top.it);
collapse_();
extract_include_();
}
~extracted_ptree_iterator(void) {
if (node_) {
delete node_;
node_ = nullptr;
}
while (! ended_()) {
auto& top = extracted_ptree_.stack_.top();
top.it = top.end;
collapse_();
}
}
void extract_include_(void) const {
if (ended_()) return;
const auto& xml_compiler = extracted_ptree_.xml_compiler_;
auto& top = extracted_ptree_.stack_.top();
const auto& it = *(top.it);
if (it.first != "include") return;
// ----------------------------------------
// replacement
std::tr1::shared_ptr<pqrs::string::replacement> replacement_ptr(new pqrs::string::replacement);
if (! it.second.empty()) {
replacement_loader loader(xml_compiler, *replacement_ptr);
loader.traverse(extracted_ptree(extracted_ptree_, top.parent_replacement, it.second));
}
auto end = replacement_ptr->end();
for (const auto& i : top.parent_replacement) {
if (replacement_ptr->find(i.first) == end) {
(*replacement_ptr)[i.first] = i.second;
}
}
// ----------------------------------------
std::string xml_file_path;
{
auto path = it.second.get_optional<std::string>("<xmlattr>.path");
if (path) {
if (extracted_ptree_.included_files_.empty()) {
throw xml_compiler_logic_error("included_files_.empty() in extracted_ptree_iterator::extract_include_.");
}
xml_file_path = xml_compiler.make_file_path(pqrs::file_path::dirname(extracted_ptree_.included_files_.back()),
*path);
}
}
if (! xml_file_path.empty()) {
for (const auto& i : extracted_ptree_.included_files_) {
if (i == xml_file_path) {
xml_compiler.error_information_.set("An infinite include loop is detected:\n" + xml_file_path);
return;
}
}
ptree_ptr pt_ptr;
xml_compiler.read_xml_(pt_ptr,
xml_file_path,
*replacement_ptr);
if (pt_ptr) {
// Skip <include> next time.
++(top.it);
// Do not call collapse_ here.
// (Keep included_files_ to detect an infinite include loop.)
if (! pt_ptr->empty()) {
auto root_node = pt_ptr->begin();
const auto& root_children = root_node->second;
if (! root_children.empty()) {
extracted_ptree_.stack_.push(stack_data(pt_ptr, replacement_ptr, root_children));
extracted_ptree_.included_files_.push_back(xml_file_path);
extract_include_();
}
}
collapse_();
}
}
}
