more literals supported in Interpreter

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index 3eb680414736c41354909398dca9ec6149de260c..47b7744763e23e03475cc14d91bc51913b48e72c 100644 (file)
--- 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 da0cb88de147c2725a6d846bf9782d76f69ca77f..8824a14ecfb2e36eb428519c9268d328d5a3230f 100644 (file)
--- 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 2075828e19b707b28e0afac8e77ca811da588a47..13b1262f93410de52ce0f522bfb538f66531fa6a 100644 (file)
--- 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");
        }