Suche Tester

[Ad aCTa]

Hallo!
Ich Zuge der Ferien baue ich gerade einen rudimentären XML-Interpreter. Nun habe ich einen kleinen Parser, Lexer und eine Vorform eines DOM-Baumes fertig gestellt, der XML-Syntax der Form

<root>
   <node>data</node>
   <node>
      <more>data</more>
   </node>
</root>

interpretieren kann (also erst mal ohne Attribute). Ich würde mich über Kritik oder Bugs freuen, damit ich das Programm robust machen kann.

Ein Beispielprogramm:

#include <fstream>
#include <vector>
#include <stdexcept>
#include <string>
#include <stack>
#include <vector>
#include <map>
#include <sstream>
#include <cctype>
#include <iostream>

namespace xml {

	class tag {
	public:
		tag(const std::string& str, bool open)
			: tagname_(str), value_(), open_(open) { }

		tag(const std::string& info)
			: tagname_(), value_(info), open_(false) 
		{
		}

		tag(const tag& t) {
			if(t.is_tag()) {
				tagname_ = t.tagname_;
				open_ = t.open_;
			}
			else {
				value_ = t.value_;
			}
		}

		bool is_tag() const { return !tagname_.empty(); }
		const std::string& name() const { return tagname_; }
		const std::string& value() const { return value_; }
		bool open() const { return open_; }
	private:
		std::string tagname_, value_;
		bool open_;
	};

	bool operator <(const tag& t1, const tag& t2) {
		return t1.name() < t2.name();
	}

	class lexer {
	public:
		lexer(std::fstream& fs) {
			char c = 0;
			bool in_tag = false;
			unsigned line_counter = 1, column_counter = 0;
			bool open = false;
			std::string tagname, content;
			bool single_space = true;
			while(!fs.eof()) {
				c = fs.get();
				column_counter++;
				switch(c) {
				case ' ':
				case '\n':
				case '\t':
					if(in_tag)
						throw format_error("unexpected whitespace in tag name found", line_counter, column_counter);
					if(c == '\n') {
						line_counter++;
						column_counter = 0;
					}
					if(c == ' ') {
						if(single_space) {
							content.push_back(c);
							single_space = false;
						}
					}
					continue;
				case '<':
					in_tag = true; // Reading Tag-Name begins
					open = true;
					if(!content.empty()) {
						tags_.push_back(tag(content));
						content.clear();
					}
					if(!std::isalpha((c = fs.get())) && c != '/') {
						column_counter++;
						throw format_error("invalid tag name beginning", line_counter, column_counter);
					}
					else
						fs.putback(c);
					continue;
				case '>':
					in_tag = false; // Reading Tag-Name ends
					tags_.push_back(tag(tagname, open));
					tagname.clear();
					continue;
				case '/':
					if(in_tag)
						open = false; // Close-Tag
					continue; // next char
				default:
					single_space = true;
				}

				if(std::isalnum(c)) {
					if(in_tag) {
						tagname.push_back(c);
					}
					else {
						content.push_back(c);
					}
				}
				else {
					if(in_tag)
						throw format_error("invalid tag name", line_counter, column_counter);
				}
			}
		}

		class format_error : public std::exception {
		public:
			format_error(const char* message, unsigned line, unsigned column)
				: std::exception(message), line_(line), column_(column)
			{ }

			unsigned line() const { return line_; }
			unsigned column() const { return column_; }
		private:
			unsigned line_, column_;
		};

		const std::vector<tag>& tags() const { return tags_; }

	private:
		char next(std::fstream& fs) {
			char c = ' ';
			while(c == ' ')
				c = fs.get();
			return c;
		}

		std::vector<tag> tags_;
	};

	class node {
	public:
		class element_selecter {
		public:
		template <typename In>
		element_selecter(In begin, In end)
			: elements_(std::distance(begin, end))
		{
			for(unsigned n = 0; n < elements_.size(); ++n) {
				elements_[n] = begin->second;
				++begin;
			}
		}

		node& operator [](unsigned index) const {
			return *elements_.at(index);
		}

	private:
		std::vector<node*> elements_;
	};

		node(const tag& tag, node* parent)
			: name_(tag), data_(), children_(), parent_(parent) 
		{ }

		~node() {
			std::multimap<tag, node*>::iterator end = children_.end();
			for(auto iter = children_.begin(); iter != end; ++iter) {
				delete iter->second;
			}
		}

		void add_data(const tag& t) {
			data_.push_back(t);
		}

		void add_sibling(node* n) {
			children_.insert(std::make_pair(n->get_tag(), n));
		}

		const tag& get_tag() const { return name_; }
		node* get_parent() { return parent_; }

		std::pair<std::multimap<tag, node*>::iterator, std::multimap<tag, node*>::iterator> find(const std::string& tagname) {
			return children_.equal_range(tag(tagname, true));
		}

		const std::string& data() {
			if(!children_.empty() || data_.empty()) {
				std::stringstream ss;
				ss << "DOM error: no text value for <" << name_.name() << "> available";
				throw std::exception(ss.str().c_str());
			}
			return data_[0].value();
		}

		element_selecter operator [](const std::string& tagname) {
			auto iter_pair = find(tagname);
			if(iter_pair.first == iter_pair.second || iter_pair.first == children_.end()) {
				std::stringstream ss;
				ss << "error: \"tag <" << tagname << "> not found\"";
				throw std::exception(ss.str().c_str());
			}
			return element_selecter(iter_pair.first, iter_pair.second);
		}

		const tag& operator ->() {
			return name_;
		}

	private:
		tag name_;
		std::vector<tag> data_;
		std::multimap<tag, node*> children_;
		node* parent_;
	};

	class parser {
	public:
		parser(const std::vector<tag>& tags)
			: tags_(tags)
		{
			// Syntax-Check
			std::stack<const tag*> tag_stack;
			for(std::size_t n = 0; n < tags.size(); ++n) {
				if(tags[n].is_tag()) {
					if(tags[n].open()) {
						tag_stack.push(&tags[n]);
					}
					else {
						if(tag_stack.empty()) {
							std::stringstream ss;
							ss << "tag mismatch: unexpected closing tag </" << tags[n].name() << "> found";
							throw parse_error(ss.str().c_str());
						}
						if(tag_stack.top()->name() != tags[n].name()) {
							std::stringstream ss;
							ss << "tag mismatch: </" << tag_stack.top()->name() << "> expected, but </" << tags[n].name() << "> found";
							throw parse_error(ss.str().c_str());
						}
						tag_stack.pop();
					}
				}
			}
			if(!tag_stack.empty()) {
				std::stringstream ss;
				ss << "closing tag </" << tag_stack.top()->name() << "> expected, but not found";
				throw parse_error(ss.str().c_str());
			}
		}

		node* generate() {
			node* root = new node(tags_[0], 0);
			node* current = root;
			for(unsigned n = 1; n < tags_.size(); ++n) {
				if(tags_[n].is_tag()) { // nested tag found
					if(tags_[n].open()) { // if this tag is open, it's a new one
						node* next = new node(tags_[n], current);
						current->add_sibling(next);
						current = next;
					}
					else { // current tag must have been closed (parser checks this in constructor)
						current = current->get_parent(); // back to parent tag
					}
				}
				else { // it's data
					current->add_data(tags_[n]);
				}
			}
			return root;
		}

		class parse_error : public std::exception {
		public:
			parse_error(const char* message)
				: std::exception(message)
			{ }
		};

	private:
		const std::vector<tag>& tags_;
	};

	class document {
	public:
		document() { }
		document(const std::string& filename)
			: file_(filename.c_str(), std::ios_base::binary | std::ios_base::in | std::ios_base::out), root_(0)
		{
			if(!file_)
				throw std::ios_base::failure("can't open XML file");
			lexer lx(file_);
			parser prs(lx.tags());
			root_ = prs.generate();
		}

		void open(const std::string& filename) {
			file_.open(filename.c_str(), std::ios_base::binary);
		}

		void close() {
			file_.close();
		}

		friend std::ostream& operator << (std::ostream&, document&);

		~document() {
			delete root_;
		}

		node::element_selecter operator [](const std::string& index) {
			auto iter_pair = root_->find(index);
			if(iter_pair.first == iter_pair.second) {
				std::stringstream ss;
				ss << "error: \"tag <" << index << "> not found\"";
				throw std::exception(ss.str().c_str());
			}
			return node::element_selecter(iter_pair.first, iter_pair.second);
		}

	private:
		std::fstream file_;
		node* root_;
	};

	std::ostream& operator << (std::ostream& os, document& doc) {
		std::string line;
		while(std::getline(doc.file_, line)) {
			os << line << '\n';
		}
		if(os.fail() || os.eof())
			os.clear();
		return os;
	}

}

int main() {
	try {
		xml::document doc("data.xml");
		std::string name;
		std::cout << "Bitte geben Sie den Namen des Kindes ein: ";
		std::cin >> name;
		std::cout << name << " ist " << doc["kinder"][0][name][0]["alter"][0].data() << ".";
	}
	catch(std::ios_base::failure& e) {
		std::cerr << e.what() << '\n';
	}
	catch(xml::lexer::format_error& e) {
		std::cerr << "format error: \"" << e.what() << "\" in line " << e.line() << " and column " << e.column() << '\n';
	}
	catch(xml::parser::parse_error& e) {
		std::cerr << "parse error: \"" << e.what() << "\"\n";
	}
	catch(std::exception& e) {
		std::cerr << e.what() << '\n';
	}
	std::cin.sync();
	std::cin.get();
}

data.xml:

<familie>
  <eltern>
    <vater>Peter</vater>
    <mutter>Hanna</mutter>
  </eltern>
  <kinder>
    <Paul>
      <alter>23</alter>
      <geschlecht>maennlich</geschlecht>
    </Paul>
    <Lisa>
      <alter>14</alter>
      <geschlecht>weiblich</geschlecht>
    </Lisa>
    <Raoule>
      <alter>18</alter>
    </Raoule>
  </kinder>
</familie>

Vielen Dank!