From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Fri, 31 Aug 2012 18:13:55 +0000 (+0200)
Subject: more literals supported in Interpreter
X-Git-Url: https://git.localhorst.tv/?a=commitdiff_plain;h=774c652e18456863dc1ae03e3a5bb4a75f40a956;p=l2e.git

more literals supported in Interpreter
---

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index 3eb6804..47b7744 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -15,6 +15,7 @@
 #include "../graphics/Sprite.h"
 
 #include <algorithm>
+#include <cstring>
 #include <SDL_image.h>
 
 using battle::Hero;
@@ -52,6 +53,9 @@ Interpreter::~Interpreter() {
 	for (vector<Sprite *>::const_iterator i(sprites.begin()), end(sprites.end()); i != end; ++i) {
 		delete *i;
 	}
+	for (vector<const char *>::const_iterator i(strings.begin()), end(strings.end()); i != end; ++i) {
+		delete *i;
+	}
 }
 
 
@@ -70,6 +74,19 @@ Animation *Interpreter::GetAnimation(const std::string &name) {
 	}
 }
 
+bool Interpreter::GetBoolean(const std::string &name) const {
+	map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
+	if (i != parsedDefinitions.end()) {
+		if (i->second.type == BOOLEAN) {
+			return booleans[i->second.index];
+		} else {
+			throw Error("cannot cast " + i->second.dfn->TypeName() + " to Boolean");
+		}
+	} else {
+		throw Error("access to undefined Boolean " + name);
+	}
+}
+
 Hero *Interpreter::GetHero(const std::string &name) {
 	map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
 	if (i != parsedDefinitions.end()) {
@@ -122,6 +139,32 @@ Sprite *Interpreter::GetSprite(const std::string &name) {
 	}
 }
 
+const char *Interpreter::GetString(const std::string &name) const {
+	map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
+	if (i != parsedDefinitions.end()) {
+		if (i->second.type == STRING) {
+			return strings[i->second.index];
+		} else {
+			throw Error("cannot cast " + i->second.dfn->TypeName() + " to String");
+		}
+	} else {
+		throw Error("access to undefined String " + name);
+	}
+}
+
+Vector<int> Interpreter::GetVector(const std::string &name) const {
+	map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
+	if (i != parsedDefinitions.end()) {
+		if (i->second.type == VECTOR) {
+			return vectors[i->second.index];
+		} else {
+			throw Error("cannot cast " + i->second.dfn->TypeName() + " to Vector");
+		}
+	} else {
+		throw Error("access to undefined Vector " + name);
+	}
+}
+
 
 void Interpreter::ReadSource() {
 	for (set<string>::const_iterator i(source.Exports().begin()), end(source.Exports().end()); i != end; ++i) {
@@ -143,13 +186,16 @@ void Interpreter::ReadDefinition(const Definition &dfn) {
 void Interpreter::ReadLiteral(const Definition &dfn) {
 	switch (dfn.GetLiteral()->GetType()) {
 		case Literal::ARRAY_VALUES:
-			throw Error("unhandled literal: array of values");
+			valueArrays.push_back(dfn.GetLiteral()->GetValues());
+			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, VALUE_ARRAY, valueArrays.size() - 1)));
 			break;
 		case Literal::ARRAY_PROPS:
-			throw Error("unhandled literal: array of properties");
+			propertyListArrays.push_back(dfn.GetLiteral()->GetPropertyLists());
+			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, PROPERTY_LIST_ARRAY, propertyListArrays.size() - 1)));
 			break;
 		case Literal::BOOLEAN:
-			throw Error("unhandled literal: boolean");
+			booleans.push_back(dfn.GetLiteral()->GetBoolean());
+			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, BOOLEAN, booleans.size() - 1)));
 			break;
 		case Literal::COLOR:
 			throw Error("unhandled literal: color");
@@ -159,13 +205,20 @@ void Interpreter::ReadLiteral(const Definition &dfn) {
 			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, NUMBER, numbers.size() - 1)));
 			break;
 		case Literal::STRING:
-			throw Error("unhandled literal: string");
+			{
+				char *str(new char[dfn.GetLiteral()->GetString().size() + 1]);
+				std::memcpy(str, dfn.GetLiteral()->GetString().c_str(), dfn.GetLiteral()->GetString().size());
+				str[dfn.GetLiteral()->GetString().size()] = '\0';
+				strings.push_back(str);
+			}
+			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, STRING, strings.size() - 1)));
 			break;
 		case Literal::VECTOR:
-			throw Error("unhandled literal: vector");
+			vectors.push_back(Vector<int>(dfn.GetLiteral()->GetX(), dfn.GetLiteral()->GetY()));
+			parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, VECTOR, vectors.size() - 1)));
 			break;
 		case Literal::OBJECT:
-			throw Error("unhandled literal: object");
+			ReadObject(dfn);
 			break;
 	}
 }
@@ -189,27 +242,12 @@ Animation *Interpreter::GetAnimation(const Value &v) {
 	}
 }
 
-const vector<Value *> &Interpreter::GetValueArray(const Value &v) {
-	if (v.IsLiteral()) {
-		return v.GetLiteral().GetValues();
-	} else {
-		throw Error("identifier resolution not implemented for arrays of values");
-	}
-}
-
-const vector<PropertyList *> &Interpreter::GetPropertyListArray(const Value &v) {
-	if (v.IsLiteral()) {
-		return v.GetLiteral().GetPropertyLists();
-	} else {
-		throw Error("identifier resolution not implemented for arrays of property lists");
-	}
-}
-
 bool Interpreter::GetBoolean(const Value &v) {
 	if (v.IsLiteral()) {
 		return v.GetLiteral().GetBoolean();
 	} else {
-		throw Error("identifier resolution not implemented for booleans");
+		ReadDefinition(source.GetDefinition(v.GetIdentifier()));
+		return GetBoolean(v.GetIdentifier());
 	}
 }
 
@@ -233,7 +271,15 @@ const PropertyList *Interpreter::GetPropertyList(const Value &v) {
 	if (v.IsLiteral()) {
 		return v.GetLiteral().GetProperties();
 	} else {
-		throw Error("identifier resolution not implemented for property lists");
+		throw Error("cannot reference property lists");
+	}
+}
+
+const vector<PropertyList *> &Interpreter::GetPropertyListArray(const Value &v) {
+	if (v.IsLiteral()) {
+		return v.GetLiteral().GetPropertyLists();
+	} else {
+		throw Error("cannot reference property list arrays");
 	}
 }
 
@@ -252,7 +298,8 @@ const char *Interpreter::GetString(const Value &v) {
 	if (v.IsLiteral()) {
 		return v.GetLiteral().GetString().c_str();
 	} else {
-		throw Error("identifier resolution not implemented for strings");
+		ReadDefinition(source.GetDefinition(v.GetIdentifier()));
+		return GetString(v.GetIdentifier());
 	}
 }
 
@@ -260,7 +307,16 @@ Vector<int> Interpreter::GetVector(const Value &v) {
 	if (v.IsLiteral()) {
 		return Vector<int>(v.GetLiteral().GetX(), v.GetLiteral().GetY());
 	} else {
-		throw Error("identifier resolution not implemented for vectors");
+		ReadDefinition(source.GetDefinition(v.GetIdentifier()));
+		return GetVector(v.GetIdentifier());
+	}
+}
+
+const vector<Value *> &Interpreter::GetValueArray(const Value &v) {
+	if (v.IsLiteral()) {
+		return v.GetLiteral().GetValues();
+	} else {
+		throw Error("cannot reference value arrays");
 	}
 }
 
diff --git a/src/loader/Interpreter.h b/src/loader/Interpreter.h
index da0cb88..8824a14 100644
--- a/src/loader/Interpreter.h
+++ b/src/loader/Interpreter.h
@@ -56,10 +56,25 @@ public:
 
 public:
 	graphics::Animation *GetAnimation(const std::string &name);
+	bool GetBoolean(const std::string &name) const;
 	battle::Hero *GetHero(const std::string &name);
 	battle::Monster *GetMonster(const std::string &name);
 	int GetNumber(const std::string &name) const;
 	graphics::Sprite *GetSprite(const std::string &name);
+	const char *GetString(const std::string &name) const;
+	geometry::Vector<int> GetVector(const std::string &name) const;
+
+public:
+	const std::vector<bool> &Booleans() const { return booleans; }
+	const std::vector<graphics::ComplexAnimation *> &ComplexAnimations() const { return complexAnimations; }
+	const std::vector<battle::Hero *> &Heroes() const { return heroes; }
+	const std::vector<SDL_Surface *> &Images() const { return images; }
+	const std::vector<battle::Monster *> &Monsters() const { return monsters; }
+	const std::vector<int> &Numbers() const { return numbers; }
+	const std::vector<graphics::SimpleAnimation *> &SimpleAnimations() const { return simpleAnimations; }
+	const std::vector<graphics::Sprite *> &Sprites() const { return sprites; }
+	const std::vector<const char *> &Strings() const { return strings; }
+	const std::vector<geometry::Vector<int> > &Vectors() const { return vectors; }
 
 private:
 	void ReadDefinition(const Definition &);
@@ -67,14 +82,14 @@ private:
 	void ReadObject(const Definition &);
 
 	graphics::Animation *GetAnimation(const Value &);
-	const std::vector<Value *> &GetValueArray(const Value &);
-	const std::vector<PropertyList *> &GetPropertyListArray(const Value &);
 	bool GetBoolean(const Value &);
 	SDL_Surface *GetImage(const Value &);
 	int GetNumber(const Value &);
 	const PropertyList *GetPropertyList(const Value &);
+	const std::vector<PropertyList *> &GetPropertyListArray(const Value &);
 	graphics::Sprite *GetSprite(const Value &);
 	const char *GetString(const Value &);
+	const std::vector<Value *> &GetValueArray(const Value &);
 	geometry::Vector<int> GetVector(const Value &);
 
 	void ReadComplexAnimation(graphics::ComplexAnimation &, const PropertyList &);
@@ -88,12 +103,18 @@ private:
 private:
 	const ParsedSource &source;
 	enum Type {
+		BOOLEAN,
 		COMPLEX_ANIMATION,
 		HERO,
+		IMAGE,
 		MONSTER,
 		NUMBER,
+		PROPERTY_LIST_ARRAY,
 		SIMPLE_ANIMATION,
 		SPRITE,
+		STRING,
+		VECTOR,
+		VALUE_ARRAY,
 	};
 	struct ParsedDefinition {
 		ParsedDefinition(const Definition *dfn, Type type, int index)
@@ -104,13 +125,19 @@ private:
 	};
 	std::map<std::string, ParsedDefinition> parsedDefinitions;
 
+	std::vector<bool> booleans;
 	std::vector<graphics::ComplexAnimation *> complexAnimations;
 	std::vector<battle::Hero *> heroes;
 	std::vector<SDL_Surface *> images;
 	std::vector<battle::Monster *> monsters;
 	std::vector<int> numbers;
+	std::vector<PropertyList *> propertyLists;
+	std::vector<std::vector<PropertyList *> > propertyListArrays;
 	std::vector<graphics::SimpleAnimation *> simpleAnimations;
 	std::vector<graphics::Sprite *> sprites;
+	std::vector<const char *> strings;
+	std::vector<std::vector<Value *> > valueArrays;
+	std::vector<geometry::Vector<int> > vectors;
 
 };
 
diff --git a/src/loader/ParsedSource.cpp b/src/loader/ParsedSource.cpp
index 2075828..13b1262 100644
--- a/src/loader/ParsedSource.cpp
+++ b/src/loader/ParsedSource.cpp
@@ -147,6 +147,8 @@ PropertyList *Definition::GetProperties() {
 const PropertyList *Definition::GetProperties() const {
 	if (!isLiteral) {
 		return reinterpret_cast<PropertyList *>(value);
+	} else if (GetLiteral()->GetType() == Literal::OBJECT) {
+		return GetLiteral()->GetProperties();
 	} else {
 		throw runtime_error("tried to access literal value as property list");
 	}