backup

6 files changed, 407 insertions, 30 deletions

diff --git a/src/plugins/mozjs/MozJsScriptEngine.cpp b/src/plugins/mozjs/MozJsScriptEngine.cpp
index f269eb7..47394a0 100644
--- a/src/plugins/mozjs/MozJsScriptEngine.cpp
+++ b/src/plugins/mozjs/MozJsScriptEngine.cpp
@@ -27,6 +27,7 @@
 
 namespace ousia {
 namespace script {
+namespace mozjs {
 
 /*
  * Some important links to the SpiderMonkey (mozjs) documentation:
@@ -504,4 +505,5 @@ MozJsScriptEngineScope *MozJsScriptEngine::createScope() {
 }
 }
 }
+}
 
diff --git a/src/plugins/mozjs/MozJsScriptEngine.hpp b/src/plugins/mozjs/MozJsScriptEngine.hpp
index 72e8ad7..385c676 100644
--- a/src/plugins/mozjs/MozJsScriptEngine.hpp
+++ b/src/plugins/mozjs/MozJsScriptEngine.hpp
@@ -46,6 +46,7 @@ typedef Rooted<Value> RootedValue;
 
 namespace ousia {
 namespace script {
+namespace mozjs {
 
 class MozJsScriptEngineScope;
 
@@ -121,6 +122,7 @@ public:
 };
 }
 }
+}
 
 #endif /* _MOZ_JS_SCRIPT_ENGINE_HPP_ */
 
diff --git a/src/plugins/xml/XmlParser.cpp b/src/plugins/xml/XmlParser.cpp
index f9bb43e..f6891a8 100644
--- a/src/plugins/xml/XmlParser.cpp
+++ b/src/plugins/xml/XmlParser.cpp
@@ -16,25 +16,15 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <iostream>
+
 #include <expat.h>
 
 #include "XmlParser.hpp"
 
 namespace ousia {
-
-/**
- * The XmlParserData struct holds all information relevant to the expat callback
- * functions.
- */
-struct XmlParserData {
-	Rooted<Node> context;
-	Logger &logger;
-
-	XmlParserData(Handle<Node> context, Logger &logger)
-	    : context(context), logger(logger)
-	{
-	}
-};
+namespace parser {
+namespace xml {
 
 /**
  * Wrapper class around the XML_Parser pointer which safely frees it whenever
@@ -55,13 +45,11 @@ public:
 	 *
 	 * @param encoding is the protocol-defined encoding passed to expat (or
 	 * nullptr if expat should determine the encoding by itself).
-	 * @param namespaceSeparator is the separator used to separate the namespace
-	 * components in the node name given by expat.
 	 */
-	ScopedExpatXmlParser(const XML_Char *encoding, XML_Char namespaceSeparator)
+	ScopedExpatXmlParser(const XML_Char *encoding)
 	    : parser(nullptr)
 	{
-		parser = XML_ParserCreateNS("UTF-8", ':');
+		parser = XML_ParserCreate(encoding);
 		if (!parser) {
 			throw ParserException{
 			    "Internal error: Could not create expat XML parser!"};
@@ -85,20 +73,43 @@ public:
 	XML_Parser operator&() { return parser; }
 };
 
+static void xmlStartElementHandler(void *userData, const XML_Char *name,
+                                   const XML_Char **attrs)
+{
+	std::cout << "start tag: " << name << std::endl;
+	const XML_Char **attr = attrs;
+	while (*attr) {
+		std::cout << "\t" << *attr;
+		attr++;
+		std::cout << " -> " << *attr << std::endl;
+		attr++;
+	}
+}
+
+static void xmlEndElementHandler(void *userData, const XML_Char *name) {
+	std::cout << "end tag: " << name << std::endl;
+}
+
+
+static void xmlCharacterDataHandler(void *userData, const XML_Char *s, int len) {
+	std::cout << "\tdata: " << std::string(s, len) << std::endl;
+}
+
 std::set<std::string> XmlParser::mimetypes()
 {
 	return std::set<std::string>{{"text/vnd.ousia.oxm", "text/vnd.ousia.oxd"}};
 }
 
-Rooted<Node> XmlParser::parse(std::istream &is, Handle<Node> context,
-                              Logger &logger)
+Rooted<Node> XmlParser::parse(std::istream &is, ParserContext &ctx)
 {
 	// Create the parser object
-	ScopedExpatXmlParser p{"UTF-8", ':'};
+	ScopedExpatXmlParser p{"UTF-8"};
+	XML_SetUserData(&p, &ctx);
 
-	// Set the callback functions, provide a pointer to a XmlParserData instance
-	// as user data.
-	XmlParserData ctx{context, logger};
+	// Set the callback functions
+	XML_SetStartElementHandler(&p, xmlStartElementHandler);
+	XML_SetEndElementHandler(&p, xmlEndElementHandler);
+	XML_SetCharacterDataHandler(&p, xmlCharacterDataHandler);
 
 	// Feed data into expat while there is data to process
 	const std::streamsize BUFFER_SIZE = 4096;  // TODO: Move to own header?
@@ -118,8 +129,8 @@ Rooted<Node> XmlParser::parse(std::istream &is, Handle<Node> context,
 			const int column = XML_GetCurrentColumnNumber(&p);
 			const XML_Error code = XML_GetErrorCode(&p);
 			const std::string msg = std::string{XML_ErrorString(code)};
-			logger.error("XML: " + msg, line, column);
-			break;
+			throw ParserException{"XML Syntax Error: " + msg, line, column,
+			                      false};
 		}
 
 		// Abort once there are no more bytes in the stream
@@ -131,4 +142,6 @@ Rooted<Node> XmlParser::parse(std::istream &is, Handle<Node> context,
 	return nullptr;
 }
 }
+}
+}
 
diff --git a/src/plugins/xml/XmlParser.hpp b/src/plugins/xml/XmlParser.hpp
index f6fb060..b19af1e 100644
--- a/src/plugins/xml/XmlParser.hpp
+++ b/src/plugins/xml/XmlParser.hpp
@@ -28,9 +28,11 @@
 #ifndef _OUSIA_XML_PARSER_HPP_
 #define _OUSIA_XML_PARSER_HPP_
 
-#include <core/Parser.hpp>
+#include <core/parser/Parser.hpp>
 
 namespace ousia {
+namespace parser {
+namespace xml {
 
 /**
  * The XmlParser class implements parsing the various types of Ousía XML
@@ -48,15 +50,19 @@ public:
 
 	/**
 	 * Parses the given input stream as XML file and returns the parsed
-	 * top-level node. Throws
+	 * top-level node.
 	 *
 	 * @param is is the input stream that will be parsed.
+	 * @param ctx is a reference to the ParserContext instance that should be
+	 * used.
 	 */
-	Rooted<Node> parse(std::istream &is, Handle<Node> context,
-	                   Logger &logger) override;
+	Rooted<Node> parse(std::istream &is, ParserContext &ctx) override;
 
 	using Parser::parse;
 };
+
+}
+}
 }
 
 #endif /* _OUSIA_XML_PARSER_HPP_ */
diff --git a/src/plugins/xml/XmlStates.cpp b/src/plugins/xml/XmlStates.cpp
new file mode 100644
index 0000000..ec0f002
--- /dev/null
+++ b/src/plugins/xml/XmlStates.cpp
@@ -0,0 +1,53 @@
+/*
+    Ousía
+    Copyright (C) 2014, 2015  Benjamin Paaßen, Andreas Stöckel
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "XmlStates.hpp"
+
+namespace ousia {
+namespace parser {
+namespace xml {
+
+std::set<std::string> StateStack::expectedCommands(State state)
+{
+	std::set<std::string> res;
+	for (const auto &v: handlers) {
+		if (v.second.parentStates.count(state)) {
+			res.insert(v.first);
+		}
+	}
+	return res;
+}
+
+void StateStack::start(std::string tagName, char **attrs) {
+	// Fetch the current handler and the current state
+	const Handler *h = stack.empty() ? nullptr : stack.top();
+	const State currentState = h ? State::NONE : h->state;
+
+	// Fetch all handlers for the given tagName
+	auto range = handlers.equal_range(tagName);
+	if (range->first == handlers.end()) {
+		// There are no handlers registered for this tag name -- check whether
+		// the current handler supports arbitrary children
+		if (h && h->arbitraryChildren)
+	}
+}
+
+}
+}
+}
+
diff --git a/src/plugins/xml/XmlStates.hpp b/src/plugins/xml/XmlStates.hpp
new file mode 100644
index 0000000..70e95f4
--- /dev/null
+++ b/src/plugins/xml/XmlStates.hpp
@@ -0,0 +1,301 @@
+/*
+    Ousía
+    Copyright (C) 2014, 2015  Benjamin Paaßen, Andreas Stöckel
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _OUSIA_XML_STATES_HPP_
+#define _OUSIA_XML_STATES_HPP_
+
+#include <cstdint>
+
+#include <map>
+#include <set>
+#include <stack>
+#include <vector>
+
+namespace ousia {
+namespace parser {
+
+class Scope;
+class Registry;
+class Logger;
+
+namespace xml {
+
+/**
+ * The State class represents all states the XML parser can be in. These states
+ * mostly represent single tags.
+ */
+enum class State : uint8_t {
+	/* Meta states */
+	ALL = -1,
+
+	/* Start state */
+	NONE,
+
+	/* Special commands */
+	INCLUDE,
+	INLINE,
+
+	/* Document states */
+	DOCUMENT,
+	HEAD,
+	BODY,
+
+	/* Domain description states */
+	DOMAIN,
+
+	/* Type system states */
+	TYPESYSTEM,
+	TYPE,
+	TYPE_ELEM
+};
+
+/**
+ * The handler class provides a context for handling an XML tag. It has to be
+ * overridden and registered in the StateStack class to form handlers for
+ * concrete XML tags.
+ */
+class Handler {
+private:
+	Rooted<Node> node;
+
+protected:
+	void setNode(Handle<Node> node) { this->node = node; }
+
+public:
+	/**
+	 * Reference to the ParserContext instance that should be used to resolve
+	 * references to nodes in the Graph.
+	 */
+	const ParserContext &ctx;
+
+	/**
+	 * Contains the name of the tag that is being handled.
+	 */
+	const std::string name;
+
+	/**
+	 * Contains the current state of the state machine.
+	 */
+	const State state;
+
+	/**
+	 * Contains the state of the state machine when the parent node was handled.
+	 */
+	const State parentState;
+
+	/**
+	 * Set to true if the tag that is being handled is not the tag that was
+	 * specified in the state machine but a child tag of that tag.
+	 */
+	const bool isChild;
+
+	/**
+	 * Constructor of the Handler class.
+	 *
+	 * @param ctx is the parser context the handler should be executed in.
+	 * @param name is the name of the string.
+	 * @param state is the state this handler was called for.
+	 * @param parentState is the state of the parent command.
+	 * @param isChild specifies whether this handler was called not for the
+	 * command that was specified in the state machine but a child command.
+	 */
+	Handler(const ParserContext &ctx, std::string name, State state,
+	        State parentState, bool isChild)
+	    : ctx(ctx),
+	      name(std::move(name)),
+	      state(state),
+	      parentState(parentState),
+	      isChild(isChild){};
+
+	/**
+	 * Virtual destructor.
+	 */
+	virtual ~Handler();
+
+	/**
+	 * Returns the node instance that was created by the handler.
+	 *
+	 * @return the Node instance created by the handler. May be nullptr if no
+	 * Node was created.
+	 */
+	Rooted<Node> getNode() { return node; }
+
+	/**
+	 * Called when the command that was specified in the constructor is
+	 * instanciated.
+	 *
+	 * @param attrs contains the attributes that were specified for the command.
+	 * TODO: Replace with StructInstance!
+	 */
+	virtual void start(char **attrs) = 0;
+
+	/**
+	 * Called whenever the command for which this handler
+	 */
+	virtual void end() = 0;
+
+	/**
+	 * Called whenever raw data (int the form of a string) is available for the
+	 * Handler instance.
+	 *
+	 * TODO: Replace with std::string?
+	 *
+	 * @param data is a pointer at the character data that is available for the
+	 * Handler instance.
+	 */
+	virtual void data(char *data, int len){};
+
+	/**
+	 * Called whenever a direct child element was created and has ended.
+	 *
+	 * @param handler is a reference at the child Handler instance.
+	 */
+	virtual void child(Handler *handler){};
+};
+
+/**
+ * HandlerConstructor is a function pointer type used to create concrete
+ * instances of the Handler class.
+ */
+using HandlerConstructor = Handler *(*)(const ParserContext &ctx,
+                                        std::string name, State state,
+                                        State parentState, bool isChild);
+
+/**
+ * The StateStack class is a pushdown automaton responsible for turning a
+ * command stream into a tree of Node instances.
+ */
+class StateStack {
+public:
+	/**
+	 * Used internlly by StateStack to store Handler instances and parameters
+	 * from HandlerDescriptor that are not stored in the Handler instance
+	 * itself. Instances of the HandlerInstance class can be created using the
+	 * HandlerDescriptor "create" method.
+	 */
+	struct HandlerInstance {
+		/**
+		 * Pointer at the actual handler instance.
+		 */
+		std::unique_ptr<Handler> handler;
+
+		/**
+		 * Value of the arbitraryChildren flag stored in the HandlerDescriptor
+		 * class.
+		 */
+		const bool arbitraryChildren;
+
+		HandlerInstance(std::unique_ptr<Handler> handler,
+		                bool arbitraryChildren)
+		    : handler(handler), arbitraryChildren(arbitraryChildren)
+		{
+		}
+	}
+
+	/**
+	 * Used internally by StateStack to store the pushdown automaton
+	 * description.
+	 */
+	struct HandlerDescriptor {
+		/**
+		 * The valid parent states.
+		 */
+		const std::set<State> parentStates;
+
+		/**
+		 * Pointer at a function which creates a new concrete Handler instance.
+		 */
+		const HandlerConstructor ctor;
+
+		/**
+		 * The target state for the registered handler.
+		 */
+		const State targetState;
+
+		/**
+		 * Set to true if this handler instance allows arbitrary children as
+		 * tags.
+		 */
+		const bool arbitraryChildren;
+
+		HandlerDescriptor(std::set<State> parentStates, HandlerConstructor ctor,
+		                  State targetState, bool arbitraryChildren = false)
+		    : parentStates(std::move(parentStates)),
+		      ctor(constructor),
+		      targetState(targetState),
+		      arbitraryChildren(arbitraryChildren)
+		{
+		}
+
+		HandlerInstance create(const ParserContext &ctx, std::string name,
+		                       State parentState, bool isChild)
+		{
+			return HandlerInstance{
+			    ctor(ctx, name, targetState, parentState, isChild),
+			    arbitraryChildren};
+		}
+	};
+
+private:
+	/**
+	 * Map containing all registered command names and the corresponding
+	 * handler
+	 * descriptor.
+	 */
+	const std::multimap<std::string, HandlerDescriptor> handlers;
+
+	/**
+	 * Reference at the parser context.
+	 */
+	const ParserContext &ctx;
+
+	/**
+	 * Internal stack used for managing the currently active Handler instances.
+	 */
+	std::stack<HandlerInstance> stack;
+
+	/**
+	 * Used internally to get all expected command names for the given state
+	 * (does not work if the current Handler instance allows arbitrary
+	 * children). This function is used to build error messages.
+	 *
+	 * @param state is the state for which all expected command names should be
+	 * returned.
+	 */
+	std::set<std::string> expectedCommands(State state);
+
+public:
+	/**
+	 * Creates a new instance of the StateStack class.
+	 *
+	 * @param handlers is a map containing the command names and the
+	 * corresponding HandlerDescriptor instances.
+	 */
+	StateStack(const ParserContext &ctx,
+	           std::multimap<std::string, HandlerDescriptor> handlers)
+	    : handlers(std::move(handlers)),
+	      ctx(ctx),
+	      currentState(State::NONE),
+	      arbitraryChildren(false);
+};
+}
+}
+}
+
+#endif /* _OUSIA_XML_STATES_HPP_ */
+