Storing type and name in the HandlerData once again, using a Token

10 files changed, 148 insertions, 221 deletions

diff --git a/src/core/parser/stack/Callbacks.hpp b/src/core/parser/stack/Callbacks.hpp
index 092664a..dfe41fc 100644
--- a/src/core/parser/stack/Callbacks.hpp
+++ b/src/core/parser/stack/Callbacks.hpp
@@ -87,7 +87,8 @@ public:
 	 * @param tokens is a list of TokenSyntaxDescriptor instances that should be
 	 * stored on the stack.
 	 */
-	void pushTokens(const std::vector<SyntaxDescriptor> &tokens);
+	virtual void pushTokens(const std::vector<SyntaxDescriptor> &tokens) = 0;
+
 	/**
 	 * Removes the previously pushed list of tokens from the stack.
 	 */
diff --git a/src/core/parser/stack/DocumentHandler.cpp b/src/core/parser/stack/DocumentHandler.cpp
index de6e367..e931d8d 100644
--- a/src/core/parser/stack/DocumentHandler.cpp
+++ b/src/core/parser/stack/DocumentHandler.cpp
@@ -37,8 +37,7 @@ namespace parser_stack {
 
 /* DocumentHandler */
 
-bool DocumentHandler::startCommand(const std::string &commandName,
-                                   Variant::mapType &args)
+bool DocumentHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<Document> document =
 	    context().getProject()->createDocument(args["name"].asString());
@@ -54,24 +53,10 @@ void DocumentHandler::end() { scope().pop(logger()); }
 /* DocumentChildHandler */
 
 DocumentChildHandler::DocumentChildHandler(const HandlerData &handlerData)
-    : Handler(handlerData), mode(Mode::STRUCT)
+    : Handler(handlerData), isExplicitField(false)
 {
 }
 
-void DocumentChildHandler::setMode(Mode mode, const std::string &name)
-{
-	this->mode = mode;
-	this->name = name;
-	this->token = Token();
-}
-
-void DocumentChildHandler::setMode(Mode mode, const Token &token)
-{
-	this->mode = mode;
-	this->name = token.content;
-	this->token = token;
-}
-
 void DocumentChildHandler::preamble(Rooted<Node> &parentNode, size_t &fieldIdx,
                                     DocumentEntity *&parent)
 {
@@ -142,12 +127,8 @@ void DocumentChildHandler::createPath(const size_t &firstFieldIdx,
 	scope().setFlag(ParserFlag::POST_EXPLICIT_FIELDS, false);
 }
 
-bool DocumentChildHandler::startCommand(const std::string &commandName,
-                                        Variant::mapType &args)
+bool DocumentChildHandler::startCommand(Variant::mapType &args)
 {
-	// Set the internal mode to STRUCT and copy the name
-	setMode(Mode::STRUCT, name);
-
 	// Extract the special "name" attribute from the input arguments.
 	// The remaining attributes will be forwarded to the newly constructed
 	// element.
@@ -176,11 +157,11 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 				return false;
 			}
 			Rooted<StructuredClass> strct = scope().resolve<StructuredClass>(
-			    Utils::split(name, ':'), logger());
+			    Utils::split(name(), ':'), logger());
 			if (strct == nullptr) {
 				// if we could not resolve the name, throw an exception.
 				throw LoggableException(
-				    std::string("\"") + name + "\" could not be resolved.",
+				    std::string("\"") + name() + "\" could not be resolved.",
 				    location());
 			}
 			entity = parentNode.cast<Document>()->createRootStructuredEntity(
@@ -200,7 +181,7 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 			 */
 			{
 				ssize_t newFieldIdx =
-				    parent->getDescriptor()->getFieldDescriptorIndex(name);
+				    parent->getDescriptor()->getFieldDescriptorIndex(name());
 				if (newFieldIdx != -1) {
 					// Check whether explicit fields are allowed here, if not
 					if (scope().getFlag(ParserFlag::POST_EXPLICIT_FIELDS)) {
@@ -208,7 +189,7 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 						    std::string(
 						        "Data or structure commands have already been "
 						        "given, command \"") +
-						        name + std::string(
+						        name() + std::string(
 						                   "\" is not interpreted explicit "
 						                   "field. Move explicit field "
 						                   "references to the beginning."),
@@ -218,7 +199,7 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 						    manager(), parentNode, newFieldIdx, false)};
 						field->setLocation(location());
 						scope().push(field);
-						setMode(Mode::EXPLICIT_FIELD, name);
+						isExplicitField = true;
 						return true;
 					}
 				}
@@ -227,11 +208,11 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 			// Otherwise create a new StructuredEntity
 			// TODO: Consider Anchors and AnnotationEntities
 			Rooted<StructuredClass> strct = scope().resolve<StructuredClass>(
-			    Utils::split(name, ':'), logger());
+			    Utils::split(name(), ':'), logger());
 			if (strct == nullptr) {
 				// if we could not resolve the name, throw an exception.
 				throw LoggableException(
-				    std::string("\"") + name + "\" could not be resolved.",
+				    std::string("\"") + name() + "\" could not be resolved.",
 				    location());
 			}
 
@@ -278,26 +259,15 @@ bool DocumentChildHandler::startCommand(const std::string &commandName,
 	}
 }
 
-bool DocumentChildHandler::startAnnotation(const std::string &name,
-                                           Variant::mapType &args,
+bool DocumentChildHandler::startAnnotation(Variant::mapType &args,
                                            AnnotationType annotationType)
 {
-	// Set the internal mode and name correctly
-	if (annotationType == AnnotationType::START) {
-		setMode(Mode::ANNOTATION_START, name);
-	} else {
-		setMode(Mode::ANNOTATION_END, name);
-	}
-
 	// TODO: Handle annotation
 	return false;
 }
 
-bool DocumentChildHandler::startToken(const Token &token, Handle<Node> node)
+bool DocumentChildHandler::startToken(Handle<Node> node)
 {
-	// Set the internal mode correctly
-	setMode(Mode::TOKEN, token);
-
 	// TODO: Handle token start
 	return false;
 }
@@ -313,7 +283,7 @@ void DocumentChildHandler::end()
 {
 	// In case of explicit fields we do not want to pop something from the
 	// stack.
-	if (mode == Mode::STRUCT) {
+	if (!isExplicitField) {
 		// pop the "main" element.
 		scope().pop(logger());
 	}
@@ -321,8 +291,7 @@ void DocumentChildHandler::end()
 
 bool DocumentChildHandler::fieldStart(bool &isDefault, size_t fieldIdx)
 {
-	// TODO: Handle other cases
-	if (mode == Mode::EXPLICIT_FIELD) {
+	if (isExplicitField) {
 		// In case of explicit fields we do not want to create another field.
 		isDefault = true;
 		return fieldIdx == 0;
@@ -471,7 +440,7 @@ bool DocumentChildHandler::data()
 	// this fact
 	Variant text = readData();
 	if (defaultFields.empty()) {
-		logger().error("Got data, but structure \"" + name +
+		logger().error("Got data, but structure \"" + name() +
 		                   "\" does not have any primitive field",
 		               text);
 	} else {
diff --git a/src/core/parser/stack/DocumentHandler.hpp b/src/core/parser/stack/DocumentHandler.hpp
index 9a41508..d34c020 100644
--- a/src/core/parser/stack/DocumentHandler.hpp
+++ b/src/core/parser/stack/DocumentHandler.hpp
@@ -53,8 +53,7 @@ class DocumentHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	/**
@@ -92,55 +91,11 @@ public:
  * defined elements in an Ousía document.
  */
 class DocumentChildHandler : public Handler {
-public:
-	/**
-	 * Enum type used to represent the mode of the DocumentChildHandler.
-	 * TODO: Having to have such a type is actually quite stupid, it would be
-	 * nicer to have separate handler classes for each of these cases. But this
-	 * is a story for a different day.
-	 */
-	enum class Mode {
-		STRUCT,
-		EXPLICIT_FIELD,
-		ANNOTATION_START,
-		ANNOTATION_END,
-		TOKEN
-	};
-
 private:
 	/**
-	 * Internal Mode of the DocumentChildHandler.
-	 */
-	Mode mode;
-
-	/**
-	 * Contains the name of the command or the annotation that is represented
-	 * by this DocumentChildHandler.
-	 */
-	std::string name;
-
-	/**
-	 * Token represented by the document child handler.
+	 * If set to true, this handler represents an explicit field.
 	 */
-	Token token;
-
-	/**
-	 * Switches the mode to the given mode and copies the given name. Resets the
-	 * token.
-	 *
-	 * @param mode is the new mode.
-	 * @param name is the new name.
-	 */
-	void setMode(Mode mode, const std::string &name);
-
-	/**
-	 * Switches the mode to the given mode and copies the given token, sets the
-	 * name to the content of the token.
-	 *
-	 * @param mode is the new mode.
-	 * @param token is the new token.
-	 */
-	void setMode(Mode mode, const Token &token);
+	bool isExplicitField;
 
 	/**
 	 * Code shared by both the start(), fieldStart() and the data() method.
@@ -211,11 +166,10 @@ private:
 public:
 	DocumentChildHandler(const HandlerData &handlerData);
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
-	bool startAnnotation(const std::string &name, Variant::mapType &args,
+	bool startCommand(Variant::mapType &args) override;
+	bool startAnnotation(Variant::mapType &args,
 	                     AnnotationType annotationType) override;
-	bool startToken(const Token &token, Handle<Node> node) override;
+	bool startToken(Handle<Node> node) override;
 	EndTokenResult endToken(const Token &token, Handle<Node> node) override;
 	void end() override;
 	bool data() override;
@@ -257,3 +211,4 @@ extern const Rtti DocumentField;
 }
 
 #endif /* _OUSIA_PARSER_STACK_DOCUMENT_HANDLER_HPP_ */
+
diff --git a/src/core/parser/stack/DomainHandler.cpp b/src/core/parser/stack/DomainHandler.cpp
index 5ca4f5b..aef5b47 100644
--- a/src/core/parser/stack/DomainHandler.cpp
+++ b/src/core/parser/stack/DomainHandler.cpp
@@ -33,8 +33,7 @@ namespace parser_stack {
 
 /* DomainHandler */
 
-bool DomainHandler::startCommand(const std::string &commandName,
-                                 Variant::mapType &args)
+bool DomainHandler::startCommand(Variant::mapType &args)
 {
 	// Create the Domain node
 	Rooted<Domain> domain =
@@ -58,8 +57,7 @@ void DomainHandler::end() { scope().pop(logger()); }
 
 /* DomainStructHandler */
 
-bool DomainStructHandler::startCommand(const std::string &commandName,
-                                       Variant::mapType &args)
+bool DomainStructHandler::startCommand(Variant::mapType &args)
 {
 	scope().setFlag(ParserFlag::POST_HEAD, true);
 
@@ -90,8 +88,7 @@ bool DomainStructHandler::startCommand(const std::string &commandName,
 void DomainStructHandler::end() { scope().pop(logger()); }
 
 /* DomainAnnotationHandler */
-bool DomainAnnotationHandler::startCommand(const std::string &commandName,
-                                           Variant::mapType &args)
+bool DomainAnnotationHandler::startCommand(Variant::mapType &args)
 {
 	scope().setFlag(ParserFlag::POST_HEAD, true);
 
@@ -109,8 +106,7 @@ void DomainAnnotationHandler::end() { scope().pop(logger()); }
 
 /* DomainAttributesHandler */
 
-bool DomainAttributesHandler::startCommand(const std::string &commandName,
-                                           Variant::mapType &args)
+bool DomainAttributesHandler::startCommand(Variant::mapType &args)
 {
 	// Fetch the current typesystem and create the struct node
 	Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
@@ -126,8 +122,7 @@ void DomainAttributesHandler::end() { scope().pop(logger()); }
 
 /* DomainFieldHandler */
 
-bool DomainFieldHandler::startCommand(const std::string &commandName,
-                                      Variant::mapType &args)
+bool DomainFieldHandler::startCommand(Variant::mapType &args)
 {
 	FieldDescriptor::FieldType type;
 	if (args["isSubtree"].asBool()) {
@@ -157,16 +152,15 @@ void DomainFieldHandler::end() { scope().pop(logger()); }
 
 /* DomainFieldRefHandler */
 
-bool DomainFieldRefHandler::startCommand(const std::string &commandName,
-                                         Variant::mapType &args)
+bool DomainFieldRefHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
 
-	const std::string &ref = args["ref"].asString();
+	const std::string &name = args["ref"].asString();
 
 	auto loc = location();
 
-	scope().resolveFieldDescriptor(ref, parent, logger(),
+	scope().resolveFieldDescriptor(name, parent, logger(),
 	                               [loc](Handle<Node> field,
 	                                     Handle<Node> parent, Logger &logger) {
 		if (field != nullptr) {
@@ -188,8 +182,7 @@ void DomainFieldRefHandler::end() {}
 
 /* DomainPrimitiveHandler */
 
-bool DomainPrimitiveHandler::startCommand(const std::string &commandName,
-                                          Variant::mapType &args)
+bool DomainPrimitiveHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<Descriptor> parent = scope().selectOrThrow<Descriptor>();
 
@@ -229,14 +222,13 @@ void DomainPrimitiveHandler::end() { scope().pop(logger()); }
 
 /* DomainChildHandler */
 
-bool DomainChildHandler::startCommand(const std::string &commandName,
-                                      Variant::mapType &args)
+bool DomainChildHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<FieldDescriptor> field = scope().selectOrThrow<FieldDescriptor>();
 
-	const std::string &ref = args["ref"].asString();
+	const std::string &name = args["ref"].asString();
 	scope().resolve<StructuredClass>(
-	    ref, field, logger(),
+	    name, field, logger(),
 	    [](Handle<Node> child, Handle<Node> field, Logger &logger) {
 		    if (child != nullptr) {
 			    field.cast<FieldDescriptor>()->addChild(
@@ -248,8 +240,7 @@ bool DomainChildHandler::startCommand(const std::string &commandName,
 
 /* DomainParentHandler */
 
-bool DomainParentHandler::startCommand(const std::string &commandName,
-                                       Variant::mapType &args)
+bool DomainParentHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<StructuredClass> strct = scope().selectOrThrow<StructuredClass>();
 
@@ -264,8 +255,7 @@ void DomainParentHandler::end() { scope().pop(logger()); }
 
 /* DomainParentFieldHandler */
 
-bool DomainParentFieldHandler::startCommand(const std::string &commandName,
-                                            Variant::mapType &args)
+bool DomainParentFieldHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<DomainParent> parentNameNode = scope().selectOrThrow<DomainParent>();
 	FieldDescriptor::FieldType type;
@@ -275,7 +265,7 @@ bool DomainParentFieldHandler::startCommand(const std::string &commandName,
 		type = FieldDescriptor::FieldType::TREE;
 	}
 
-	const std::string &fieldName = args["name"].asString();
+	const std::string &name = args["name"].asString();
 	const bool optional = args["optional"].asBool();
 	Rooted<StructuredClass> strct =
 	    parentNameNode->getParent().cast<StructuredClass>();
@@ -284,12 +274,12 @@ bool DomainParentFieldHandler::startCommand(const std::string &commandName,
 	// StructuredClass as child to it.
 	scope().resolve<Descriptor>(
 	    parentNameNode->getName(), strct, logger(),
-	    [type, fieldName, optional](Handle<Node> parent, Handle<Node> strct,
+	    [type, name, optional](Handle<Node> parent, Handle<Node> strct,
 	                                Logger &logger) {
 		    if (parent != nullptr) {
 			    Rooted<FieldDescriptor> field =
 			        (parent.cast<Descriptor>()->createFieldDescriptor(
-			             logger, type, fieldName, optional)).first;
+			             logger, type, name, optional)).first;
 			    field->addChild(strct.cast<StructuredClass>());
 		    }
 		});
@@ -298,12 +288,11 @@ bool DomainParentFieldHandler::startCommand(const std::string &commandName,
 
 /* DomainParentFieldRefHandler */
 
-bool DomainParentFieldRefHandler::startCommand(const std::string &commandName,
-                                               Variant::mapType &args)
+bool DomainParentFieldRefHandler::startCommand(Variant::mapType &args)
 {
 	Rooted<DomainParent> parentNameNode = scope().selectOrThrow<DomainParent>();
 
-	const std::string &ref = args["ref"].asString();
+	const std::string &name = args["ref"].asString();
 	Rooted<StructuredClass> strct =
 	    parentNameNode->getParent().cast<StructuredClass>();
 	auto loc = location();
@@ -311,14 +300,14 @@ bool DomainParentFieldRefHandler::startCommand(const std::string &commandName,
 	// resolve the parent, get the referenced field and add the declared
 	// StructuredClass as child to it.
 	scope().resolve<Descriptor>(parentNameNode->getName(), strct, logger(),
-	                            [ref, loc](Handle<Node> parent,
+	                            [name, loc](Handle<Node> parent,
 	                                       Handle<Node> strct, Logger &logger) {
 		if (parent != nullptr) {
 			Rooted<FieldDescriptor> field =
-			    parent.cast<Descriptor>()->getFieldDescriptor(ref);
+			    parent.cast<Descriptor>()->getFieldDescriptor(name);
 			if (field == nullptr) {
 				logger.error(
-				    std::string("Could not find referenced field ") + ref, loc);
+				    std::string("Could not find referenced field ") + name, loc);
 				return;
 			}
 			field->addChild(strct.cast<StructuredClass>());
diff --git a/src/core/parser/stack/DomainHandler.hpp b/src/core/parser/stack/DomainHandler.hpp
index 4116919..f12d863 100644
--- a/src/core/parser/stack/DomainHandler.hpp
+++ b/src/core/parser/stack/DomainHandler.hpp
@@ -46,7 +46,7 @@ class DomainHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -59,7 +59,7 @@ class DomainStructHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -72,7 +72,7 @@ class DomainAnnotationHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -85,7 +85,7 @@ class DomainAttributesHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -98,7 +98,7 @@ class DomainFieldHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -111,7 +111,7 @@ class DomainFieldRefHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -124,7 +124,7 @@ class DomainPrimitiveHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -137,7 +137,7 @@ class DomainChildHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 
 	static Handler *create(const HandlerData &handlerData)
 	{
@@ -154,7 +154,7 @@ class DomainParentHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	static Handler *create(const HandlerData &handlerData)
@@ -167,7 +167,7 @@ class DomainParentFieldHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 
 	static Handler *create(const HandlerData &handlerData)
 	{
@@ -179,7 +179,7 @@ class DomainParentFieldRefHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &name, Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 
 	static Handler *create(const HandlerData &handlerData)
 	{
diff --git a/src/core/parser/stack/Handler.cpp b/src/core/parser/stack/Handler.cpp
index 006e521..c01e74c 100644
--- a/src/core/parser/stack/Handler.cpp
+++ b/src/core/parser/stack/Handler.cpp
@@ -32,8 +32,9 @@ namespace parser_stack {
 /* Class HandlerData */
 
 HandlerData::HandlerData(ParserContext &ctx, HandlerCallbacks &callbacks,
-                         const State &state, const SourceLocation &location)
-    : ctx(ctx), callbacks(callbacks), state(state), location(location)
+                         const State &state, const Token &token,
+                         HandlerType type)
+    : ctx(ctx), callbacks(callbacks), state(state), token(token), type(type)
 {
 }
 
@@ -60,7 +61,20 @@ Logger &Handler::logger()
 	return handlerData.ctx.getLogger();
 }
 
-const SourceLocation &Handler::location() const { return handlerData.location; }
+const std::string &Handler::name() const { return handlerData.token.content; }
+
+TokenId Handler::tokenId() const { return handlerData.token.id; }
+
+const Token &Handler::token() const { return handlerData.token; }
+
+const SourceLocation &Handler::location() const
+{
+	return handlerData.token.location;
+}
+
+HandlerType Handler::type() const { return handlerData.type; }
+
+const State &Handler::state() const { return handlerData.state; }
 
 Variant Handler::readData() { return handlerData.callbacks.readData(); }
 
@@ -81,8 +95,6 @@ void Handler::unregisterToken(TokenId id)
 	handlerData.callbacks.unregisterToken(id);
 }
 
-const State &Handler::getState() const { return handlerData.state; }
-
 void Handler::setLogger(Logger &logger) { internalLogger = &logger; }
 
 void Handler::resetLogger() { internalLogger = nullptr; }
@@ -91,15 +103,13 @@ const SourceLocation &Handler::getLocation() const { return location(); }
 
 /* Class EmptyHandler */
 
-bool EmptyHandler::startCommand(const std::string &commandName,
-                                Variant::mapType &args)
+bool EmptyHandler::startCommand(Variant::mapType &args)
 {
 	// Well, we'll support any command we get, don't we?
 	return true;
 }
 
-bool EmptyHandler::startAnnotation(const std::string &name,
-                                   Variant::mapType &args,
+bool EmptyHandler::startAnnotation(Variant::mapType &args,
                                    Handler::AnnotationType annotationType)
 {
 	// Do not support annotations. Annotations are too complicated for poor
@@ -107,7 +117,7 @@ bool EmptyHandler::startAnnotation(const std::string &name,
 	return false;
 }
 
-bool EmptyHandler::startToken(const Token &token, Handle<Node> node)
+bool EmptyHandler::startToken(Handle<Node> node)
 {
 	// EmptyHandler does not support tokens.
 	return false;
@@ -149,24 +159,19 @@ Handler *EmptyHandler::create(const HandlerData &handlerData)
 
 /* Class StaticHandler */
 
-bool StaticHandler::startCommand(const std::string &commandName,
-                                 Variant::mapType &args)
+bool StaticHandler::startCommand(Variant::mapType &args)
 {
 	// Do nothing in the default implementation, accept anything
 	return true;
 }
 
-bool StaticHandler::startAnnotation(const std::string &name,
-                                    Variant::mapType &args,
+bool StaticHandler::startAnnotation(Variant::mapType &args,
                                     Handler::AnnotationType annotationType)
 {
 	return false;
 }
 
-bool StaticHandler::startToken(const Token &token, Handle<Node> node)
-{
-	return false;
-}
+bool StaticHandler::startToken(Handle<Node> node) { return false; }
 
 Handler::EndTokenResult StaticHandler::endToken(const Token &token,
                                                 Handle<Node> node)
@@ -209,8 +214,7 @@ StaticFieldHandler::StaticFieldHandler(const HandlerData &handlerData,
 {
 }
 
-bool StaticFieldHandler::startCommand(const std::string &commandName,
-                                      Variant::mapType &args)
+bool StaticFieldHandler::startCommand(Variant::mapType &args)
 {
 	if (!argName.empty()) {
 		auto it = args.find(argName);
diff --git a/src/core/parser/stack/Stack.cpp b/src/core/parser/stack/Stack.cpp
index 3545c37..cad4078 100644
--- a/src/core/parser/stack/Stack.cpp
+++ b/src/core/parser/stack/Stack.cpp
@@ -42,11 +42,6 @@ namespace {
 class HandlerInfo {
 public:
 	/**
-	 * Name of the command or the token sequence.
-	 */
-	std::string name;
-
-	/**
 	 * Pointer pointing at the actual handler instance.
 	 */
 	std::shared_ptr<Handler> handler;
@@ -362,7 +357,7 @@ public:
 	void unregisterToken(TokenId id) override;
 	Variant readData() override;
 	bool hasData();
-	void pushTokens(const std::vector<TokenSyntaxDescriptor> &tokens) override;
+	void pushTokens(const std::vector<SyntaxDescriptor> &tokens) override;
 	void popTokens() override;
 };
 
@@ -394,7 +389,7 @@ StackImpl::~StackImpl()
 			    !info.inImplicitDefaultField) {
 				logger().error(
 				    std::string("Reached end of stream, but command \"") +
-				        info.name +
+				        currentCommandName() +
 				        "\" has not ended yet. Command was started here:",
 				    info.handler->getLocation());
 			}
@@ -428,8 +423,8 @@ void StackImpl::deduceState()
 	HandlerConstructor ctor =
 	    state.elementHandler ? state.elementHandler : EmptyHandler::create;
 
-	std::shared_ptr<Handler> handler =
-	    std::shared_ptr<Handler>{ctor({ctx, *this, state, SourceLocation{}})};
+	std::shared_ptr<Handler> handler = std::shared_ptr<Handler>{
+	    ctor({ctx, *this, state, SourceLocation{}, HandlerType::COMMAND})};
 	stack.emplace_back(handler);
 
 	// Set the correct flags for this implicit handler
@@ -452,12 +447,12 @@ std::set<std::string> StackImpl::expectedCommands()
 
 const State &StackImpl::currentState() const
 {
-	return stack.empty() ? States::None : stack.back().handler->getState();
+	return stack.empty() ? States::None : stack.back().handler->state();
 }
 
 std::string StackImpl::currentCommandName() const
 {
-	return stack.empty() ? std::string{} : stack.back().name;
+	return stack.empty() ? std::string{} : stack.back().handler->name();
 }
 
 const State *StackImpl::findTargetState(const std::string &name)
@@ -616,21 +611,29 @@ void StackImpl::commandStart(const Variant &name, const Variant::mapType &args,
 		                              ? targetState->elementHandler
 		                              : EmptyHandler::create;
 		std::shared_ptr<Handler> handler{
-		    ctor({ctx, *this, *targetState, name.getLocation()})};
+		    ctor({ctx,
+		          *this,
+		          *targetState,
+		          {name.asString(), name.getLocation()},
+		          HandlerType::COMMAND})};
 		stack.emplace_back(handler);
 
-		// Fetch the HandlerInfo for the parent element and the current element
+		// Fetch the HandlerInfo for the parent element and the current
+		// element
 		HandlerInfo &parentInfo = lastInfo();
 		HandlerInfo &info = currentInfo();
 
-		// Call the "start" method of the handler, store the result of the start
-		// method as the validity of the handler -- do not call the start method
+		// Call the "start" method of the handler, store the result of the
+		// start
+		// method as the validity of the handler -- do not call the start
+		// method
 		// if the stack is currently invalid (as this may cause further,
 		// unwanted errors)
 		bool validStack = handlersValid();
 		info.valid = false;
 		if (validStack) {
-			// Canonicalize the arguments (if this has not already been done),
+			// Canonicalize the arguments (if this has not already been
+			// done),
 			// allow additional arguments and numeric indices
 			Variant::mapType canonicalArgs = args;
 			targetState->arguments.validateMap(canonicalArgs, loggerFork, true,
@@ -638,8 +641,7 @@ void StackImpl::commandStart(const Variant &name, const Variant::mapType &args,
 
 			handler->setLogger(loggerFork);
 			try {
-				info.valid =
-				    handler->startCommand(name.asString(), canonicalArgs);
+				info.valid = handler->startCommand(canonicalArgs);
 			}
 			catch (LoggableException ex) {
 				loggerFork.log(ex);
@@ -647,8 +649,10 @@ void StackImpl::commandStart(const Variant &name, const Variant::mapType &args,
 			handler->resetLogger();
 		}
 
-		// We started the command within an implicit default field and it is not
-		// valid -- remove both the new handler and the parent field from the
+		// We started the command within an implicit default field and it is
+		// not
+		// valid -- remove both the new handler and the parent field from
+		// the
 		// stack
 		if (!info.valid && parentInfo.inImplicitDefaultField) {
 			endCurrentHandler();
@@ -656,7 +660,8 @@ void StackImpl::commandStart(const Variant &name, const Variant::mapType &args,
 			continue;
 		}
 
-		// If we ended up here, starting the command may or may not have worked,
+		// If we ended up here, starting the command may or may not have
+		// worked,
 		// but after all, we cannot unroll the stack any further. Update the
 		// "valid" flag, commit any potential error messages and return.
 		info.valid = parentInfo.valid && info.valid;
@@ -687,13 +692,15 @@ void StackImpl::data(const TokenizedData &data)
 	// TODO: Rewrite this function for token handling
 	// TODO: This loop needs to be refactored out
 	/*while (!data.atEnd()) {
-	    // End handlers that already had a default field and are currently not
+	    // End handlers that already had a default field and are currently
+	not
 	    // active.
 	    endOverdueHandlers();
 
 	    const bool hasNonWhitespaceText = data.hasNonWhitespaceText();
 
-	    // Check whether there is any command the data can be sent to -- if not,
+	    // Check whether there is any command the data can be sent to -- if
+	not,
 	    // make sure the data actually is data
 	    if (stack.empty()) {
 	        if (hasNonWhitespaceText) {
@@ -712,10 +719,12 @@ void StackImpl::data(const TokenizedData &data)
 	        continue;
 	    }
 
-	    // If this field should not get any data, log an error and do not call
+	    // If this field should not get any data, log an error and do not
+	call
 	    // the "data" handler
 	    if (!info.inValidField) {
-	        // If the "hadDefaultField" flag is set, we already issued an error
+	        // If the "hadDefaultField" flag is set, we already issued an
+	error
 	        // message
 	        if (!info.hadDefaultField) {
 	            if (hasNonWhitespaceText) {
@@ -726,8 +735,10 @@ void StackImpl::data(const TokenizedData &data)
 	    }
 
 	    if (handlersValid() && info.inValidField) {
-	        // Fork the logger and set it as temporary logger for the "start"
-	        // method. We only want to keep error messages if this was not a try
+	        // Fork the logger and set it as temporary logger for the
+	"start"
+	        // method. We only want to keep error messages if this was not a
+	try
 	        // to implicitly open a default field.
 	        LoggerFork loggerFork = logger().fork();
 	        info.handler->setLogger(loggerFork);
@@ -735,12 +746,14 @@ void StackImpl::data(const TokenizedData &data)
 	        // Pass the data to the current Handler instance
 	        bool valid = false;
 	        try {
-	            // Create a fork of the TokenizedData and let the handler work
+	            // Create a fork of the TokenizedData and let the handler
+	work
 	            // on it
 	            TokenizedData dataFork = data;
 	            valid = info.handler->data(dataFork);
 
-	            // If the data was validly handled by the handler, commit the
+	            // If the data was validly handled by the handler, commit
+	the
 	            // change
 	            if (valid) {
 	                data = dataFork;
@@ -754,14 +767,16 @@ void StackImpl::data(const TokenizedData &data)
 	        info.handler->resetLogger();
 
 	        // If placing the data here failed and we're currently in an
-	        // implicitly opened field, just unroll the stack to the next field
+	        // implicitly opened field, just unroll the stack to the next
+	field
 	        // and try again
 	        if (!valid && info.inImplicitDefaultField) {
 	            endCurrentHandler();
 	            continue;
 	        }
 
-	        // Commit the content of the logger fork. Do not change the valid
+	        // Commit the content of the logger fork. Do not change the
+	valid
 	        // flag.
 	        loggerFork.commit();
 	    }
@@ -783,12 +798,14 @@ void StackImpl::fieldStart(bool isDefault)
 	HandlerInfo &info = currentInfo();
 	if (info.inField) {
 		logger().error(
-		    "Got field start, but there is no command for which to start the "
+		    "Got field start, but there is no command for which to start "
+		    "the "
 		    "field.");
 		return;
 	}
 
-	// If the handler already had a default field we cannot start a new field
+	// If the handler already had a default field we cannot start a new
+	// field
 	// (the default field always is the last field) -- mark the command as
 	// invalid
 	if (info.hadDefaultField) {
@@ -797,7 +814,8 @@ void StackImpl::fieldStart(bool isDefault)
 		               std::string("\" does not have any more fields"));
 	}
 
-	// Copy the isDefault flag to a local variable, the fieldStart method will
+	// Copy the isDefault flag to a local variable, the fieldStart method
+	// will
 	// write into this variable
 	bool defaultField = isDefault;
 
@@ -843,7 +861,8 @@ void StackImpl::fieldEnd()
 		return;
 	}
 
-	// Only continue if the current handler stack is in a valid state, do not
+	// Only continue if the current handler stack is in a valid state, do
+	// not
 	// call the fieldEnd function if something went wrong before
 	if (handlersValid() && !info.hadDefaultField && info.inValidField) {
 		try {
@@ -868,7 +887,7 @@ void StackImpl::unregisterToken(TokenId id)
 	tokenRegistry.unregisterToken(id);
 }
 
-void StackImpl::pushTokens(const std::vector<TokenSyntaxDescriptor> &tokens)
+void StackImpl::pushTokens(const std::vector<SyntaxDescriptor> &tokens)
 {
 	// TODO
 }
diff --git a/src/core/parser/stack/TokenStack.hpp b/src/core/parser/stack/TokenStack.hpp
index af734bb..f2e7edc 100644
--- a/src/core/parser/stack/TokenStack.hpp
+++ b/src/core/parser/stack/TokenStack.hpp
@@ -82,9 +82,9 @@ public:
 	TokenStack(const TokenStack &parentStack) : TokenStack(&parentStack) {}
 
 	/**
-	 * Pushes a list of TokenSyntaxDescriptor instances onto the internal stack.
+	 * Pushes a list of SyntaxDescriptor instances onto the internal stack.
 	 *
-	 * @param tokens is a list of TokenSyntaxDescriptor instances that should be
+	 * @param tokens is a list of SyntaxDescriptor instances that should be
 	 * stored on the stack.
 	 */
 	void pushTokens(const std::vector<SyntaxDescriptor> &tokens);
diff --git a/src/core/parser/stack/TypesystemHandler.cpp b/src/core/parser/stack/TypesystemHandler.cpp
index 110c56f..3fa641a 100644
--- a/src/core/parser/stack/TypesystemHandler.cpp
+++ b/src/core/parser/stack/TypesystemHandler.cpp
@@ -32,8 +32,7 @@ namespace parser_stack {
 
 /* TypesystemHandler */
 
-bool TypesystemHandler::startCommand(const std::string &commandName,
-                                     Variant::mapType &args)
+bool TypesystemHandler::startCommand(Variant::mapType &args)
 {
 	// Create the typesystem instance
 	Rooted<Typesystem> typesystem =
@@ -64,8 +63,7 @@ void TypesystemHandler::end() { scope().pop(logger()); }
 
 /* TypesystemEnumHandler */
 
-bool TypesystemEnumHandler::startCommand(const std::string &commandName,
-                                         Variant::mapType &args)
+bool TypesystemEnumHandler::startCommand(Variant::mapType &args)
 {
 	scope().setFlag(ParserFlag::POST_HEAD, true);
 
@@ -93,8 +91,7 @@ void TypesystemEnumEntryHandler::doHandle(const Variant &fieldData,
 
 /* TypesystemStructHandler */
 
-bool TypesystemStructHandler::startCommand(const std::string &commandName,
-                                           Variant::mapType &args)
+bool TypesystemStructHandler::startCommand(Variant::mapType &args)
 {
 	scope().setFlag(ParserFlag::POST_HEAD, true);
 
@@ -127,8 +124,7 @@ void TypesystemStructHandler::end() { scope().pop(logger()); }
 
 /* TypesystemStructFieldHandler */
 
-bool TypesystemStructFieldHandler::startCommand(const std::string &commandName,
-                                                Variant::mapType &args)
+bool TypesystemStructFieldHandler::startCommand(Variant::mapType &args)
 {
 	// Read the argument values
 	const std::string &fieldName = args["name"].asString();
@@ -167,8 +163,7 @@ bool TypesystemStructFieldHandler::startCommand(const std::string &commandName,
 
 /* TypesystemConstantHandler */
 
-bool TypesystemConstantHandler::startCommand(const std::string &commandName,
-                                             Variant::mapType &args)
+bool TypesystemConstantHandler::startCommand(Variant::mapType &args)
 {
 	scope().setFlag(ParserFlag::POST_HEAD, true);
 
diff --git a/src/core/parser/stack/TypesystemHandler.hpp b/src/core/parser/stack/TypesystemHandler.hpp
index 75cba01..0773a3a 100644
--- a/src/core/parser/stack/TypesystemHandler.hpp
+++ b/src/core/parser/stack/TypesystemHandler.hpp
@@ -43,8 +43,7 @@ class TypesystemHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	/**
@@ -68,8 +67,7 @@ class TypesystemEnumHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	/**
@@ -116,8 +114,7 @@ class TypesystemStructHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 	void end() override;
 
 	/**
@@ -142,8 +139,7 @@ class TypesystemStructFieldHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 
 	/**
 	 * Creates a new instance of the TypesystemStructFieldHandler.
@@ -166,8 +162,7 @@ class TypesystemConstantHandler : public StaticHandler {
 public:
 	using StaticHandler::StaticHandler;
 
-	bool startCommand(const std::string &commandName,
-	                  Variant::mapType &args) override;
+	bool startCommand(Variant::mapType &args) override;
 
 	/**
 	 * Creates a new instance of the TypesystemConstantHandler.