From 774c652e18456863dc1ae03e3a5bb4a75f40a956 Mon Sep 17 00:00:00 2001 From: Daniel Karbach Date: Fri, 31 Aug 2012 20:13:55 +0200 Subject: [PATCH] more literals supported in Interpreter --- src/loader/Interpreter.cpp | 108 +++++++++++++++++++++++++++--------- src/loader/Interpreter.h | 31 ++++++++++- src/loader/ParsedSource.cpp | 2 + 3 files changed, 113 insertions(+), 28 deletions(-) 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 +#include #include using battle::Hero; @@ -52,6 +53,9 @@ Interpreter::~Interpreter() { for (vector::const_iterator i(sprites.begin()), end(sprites.end()); i != end; ++i) { delete *i; } + for (vector::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::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::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::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 Interpreter::GetVector(const std::string &name) const { + map::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::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(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 &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 &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 &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 Interpreter::GetVector(const Value &v) { if (v.IsLiteral()) { return Vector(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 &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 GetVector(const std::string &name) const; + +public: + const std::vector &Booleans() const { return booleans; } + const std::vector &ComplexAnimations() const { return complexAnimations; } + const std::vector &Heroes() const { return heroes; } + const std::vector &Images() const { return images; } + const std::vector &Monsters() const { return monsters; } + const std::vector &Numbers() const { return numbers; } + const std::vector &SimpleAnimations() const { return simpleAnimations; } + const std::vector &Sprites() const { return sprites; } + const std::vector &Strings() const { return strings; } + const std::vector > &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 &GetValueArray(const Value &); - const std::vector &GetPropertyListArray(const Value &); bool GetBoolean(const Value &); SDL_Surface *GetImage(const Value &); int GetNumber(const Value &); const PropertyList *GetPropertyList(const Value &); + const std::vector &GetPropertyListArray(const Value &); graphics::Sprite *GetSprite(const Value &); const char *GetString(const Value &); + const std::vector &GetValueArray(const Value &); geometry::Vector 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 parsedDefinitions; + std::vector booleans; std::vector complexAnimations; std::vector heroes; std::vector images; std::vector monsters; std::vector numbers; + std::vector propertyLists; + std::vector > propertyListArrays; std::vector simpleAnimations; std::vector sprites; + std::vector strings; + std::vector > valueArrays; + std::vector > 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(value); + } else if (GetLiteral()->GetType() == Literal::OBJECT) { + return GetLiteral()->GetProperties(); } else { throw runtime_error("tried to access literal value as property list"); } -- 2.39.2