more information in parsed source and output

[l2e.git] / src / loader / ParsedSource.cpp

diff --git a/src/loader/ParsedSource.cpp b/src/loader/ParsedSource.cpp
index 75d7efbc1bfa2dbc49ff404a89245dcb7fee2382..ec263042a68cdba8d7c9c27e43479ae9fee1455f 100644 (file)
--- a/src/loader/ParsedSource.cpp
+++ b/src/loader/ParsedSource.cpp
@@ -28,6 +28,15 @@ void ParsedSource::AddDeclaration(Declaration *d) {
        }
 }
 
+void ParsedSource::AddDefinition(Definition *d) {
+       map<string, Definition *>::iterator i(definitions.find(d->Identifier()));
+       if (i != definitions.end()) {
+               throw runtime_error("redefinition of " + i->second->TypeName() + " " + d->Identifier());
+       } else {
+               definitions.insert(std::make_pair(d->Identifier(), d));
+       }
+}
+
 void ParsedSource::ExportDeclaration(Declaration *d) {
        AddDeclaration(d);
        exports.insert(d->Identifier());
@@ -98,7 +107,17 @@ Literal::Literal(const vector<Value *> &v)
 , i1(0), i2(0)
 , i3(0), i4(0)
 , b(false)
-, type(ARRAY) {
+, type(ARRAY_VALUES) {
+
+}
+
+Literal::Literal(const std::vector<PropertyList *> &pls)
+: props(0)
+, propertyLists(pls)
+, i1(0), i2(0)
+, i3(0), i4(0)
+, b(false)
+, type(ARRAY_PROPS) {
 
 }
 
@@ -120,6 +139,15 @@ Literal::Literal(int r, int g, int b, int a)
 
 }
 
+Literal::Literal(int number)
+: props(0)
+, i1(number), i2(0)
+, i3(0), i4(0)
+, b(false)
+, type(NUMBER) {
+
+}
+
 Literal::Literal(const string &str)
 : props(0)
 , str(str)
@@ -149,6 +177,111 @@ Literal::Literal(const string &typeName, PropertyList *properties)
 
 }
 
+
+const vector<Value *> &Literal::GetValues() const {
+       if (type == ARRAY_VALUES) {
+               return values;
+       } else {
+               throw runtime_error("tried to access values of non-array literal");
+       }
+}
+
+const vector<PropertyList *> &Literal::GetPropertyLists() const {
+       if (type == ARRAY_PROPS) {
+               return propertyLists;
+       } else {
+               throw runtime_error("tried to access property lists of non-array literal");
+       }
+}
+
+bool Literal::GetBoolean() const {
+       if (type == BOOLEAN) {
+               return b;
+       } else {
+               throw runtime_error("tried to access boolean value of non-boolean literal");
+       }
+}
+
+int Literal::GetRed() const {
+       if (type == COLOR) {
+               return i1;
+       } else {
+               throw runtime_error("tried to access red component of non-color literal");
+       }
+}
+
+int Literal::GetGreen() const {
+       if (type == COLOR) {
+               return i2;
+       } else {
+               throw runtime_error("tried to access green component of non-color literal");
+       }
+}
+
+int Literal::GetBlue() const {
+       if (type == COLOR) {
+               return i3;
+       } else {
+               throw runtime_error("tried to access blue component of non-color literal");
+       }
+}
+
+int Literal::GetAlpha() const {
+       if (type == COLOR) {
+               return i4;
+       } else {
+               throw runtime_error("tried to access alpha component of non-color literal");
+       }
+}
+
+int Literal::GetNumber() const {
+       if (type == NUMBER) {
+               return i1;
+       } else {
+               throw runtime_error("tried to access numerical value of non-number literal");
+       }
+}
+
+const string &Literal::GetString() const {
+       if (type == STRING) {
+               return str;
+       } else {
+               throw runtime_error("tried to access string value of non-color literal");
+       }
+}
+
+int Literal::GetX() const {
+       if (type == VECTOR) {
+               return i1;
+       } else {
+               throw runtime_error("tried to access x component of non-vector literal");
+       }
+}
+
+int Literal::GetY() const {
+       if (type == VECTOR) {
+               return i2;
+       } else {
+               throw runtime_error("tried to access y component of non-vector literal");
+       }
+}
+
+const string &Literal::GetTypeName() const {
+       if (type == OBJECT) {
+               return str;
+       } else {
+               throw runtime_error("tried to access type name of non-object literal");
+       }
+}
+
+const PropertyList *Literal::GetProperties() const {
+       if (type == OBJECT) {
+               return props;
+       } else {
+               throw runtime_error("tried to access properties of non-object literal");
+       }
+}
+
 }
 
 
@@ -160,6 +293,13 @@ ostream &operator <<(ostream &out, const loader::ParsedSource &source) {
        for (map<string, loader::Declaration *>::const_iterator i(source.Declarations().begin()), end(source.Declarations().end()); i != end; ++i) {
                out << " - " << i->first << " of type " << i->second->TypeName() << endl;
        }
+       out << "defined objects: " << endl;
+       for (map<string, loader::Definition *>::const_iterator i(source.Definitions().begin()), end(source.Definitions().end()); i != end; ++i) {
+               out << " - " << i->first << " of type " << i->second->TypeName() << endl;
+               if (i->second->HasLiteralValue()) {
+                       out << "     literal value: " << *i->second->GetLiteral() << endl;
+               }
+       }
        out << "exported objects: " << endl;
        for (set<string>::const_iterator i(source.Exports().begin()), end(source.Exports().end()); i != end; ++i) {
                out << " - " << *i << endl;
@@ -167,4 +307,34 @@ ostream &operator <<(ostream &out, const loader::ParsedSource &source) {
        return out;
 }
 
+ostream &operator <<(ostream &out, const loader::Literal &l) {
+       switch (l.GetType()) {
+               case loader::Literal::ARRAY_VALUES:
+                       out << "array of values";
+                       break;
+               case loader::Literal::ARRAY_PROPS:
+                       out << "array of property lists";
+                       break;
+               case loader::Literal::BOOLEAN:
+                       out << "boolean, " << (l.GetBoolean() ? "true" : "false");
+                       break;
+               case loader::Literal::COLOR:
+                       out << "color, (" << l.GetRed() << ',' << l.GetGreen() << ',' << l.GetBlue() << ',' << l.GetAlpha() << ')';
+                       break;
+               case loader::Literal::NUMBER:
+                       out << "number, " << l.GetNumber();
+                       break;
+               case loader::Literal::STRING:
+                       out << "string, \"" << l.GetString() << '"';
+                       break;
+               case loader::Literal::VECTOR:
+                       out << "vector, <" << l.GetX() << ',' << l.GetY() << '>';
+                       break;
+               case loader::Literal::OBJECT:
+                       out << "object of type " << l.GetTypeName();
+                       break;
+       }
+       return out;
+}
+
 }