X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Floader%2FParsedSource.cpp;h=90597475726663807fdc2beaa5b8f1d7fc627c98;hb=a67f7e662c85b2b8d46f26a3c6e018b2df6eb318;hp=75d7efbc1bfa2dbc49ff404a89245dcb7fee2382;hpb=af9e0b57dac45dc5591f16fb34236b1356cda8a2;p=l2e.git diff --git a/src/loader/ParsedSource.cpp b/src/loader/ParsedSource.cpp index 75d7efb..9059747 100644 --- a/src/loader/ParsedSource.cpp +++ b/src/loader/ParsedSource.cpp @@ -1,12 +1,7 @@ -/* - * ParsedSource.cpp - * - * Created on: Aug 26, 2012 - * Author: holy - */ - #include "ParsedSource.h" +#include "utility.h" + #include #include @@ -17,6 +12,12 @@ using std::vector; namespace loader { +ParsedSource::~ParsedSource() { + for (map::const_iterator i(declarations.begin()), end(declarations.end()); i != end; ++i) { + delete i->second; + } +} + void ParsedSource::AddDeclaration(Declaration *d) { map::iterator i(declarations.find(d->Identifier())); if (i != declarations.end()) { @@ -28,6 +29,15 @@ void ParsedSource::AddDeclaration(Declaration *d) { } } +void ParsedSource::AddDefinition(Definition *d) { + map::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()); @@ -42,6 +52,79 @@ void ParsedSource::ExportIdentifier(const std::string &i) { } +bool ParsedSource::IsDeclared(const std::string &name) const { + return declarations.count(name); +} + +Declaration &ParsedSource::GetDeclaration(const std::string &name) { + map::const_iterator i(declarations.find(name)); + if (i != declarations.end()) { + return *i->second; + } else { + throw runtime_error("undeclared identifier " + name); + } +} + +const Declaration &ParsedSource::GetDeclaration(const std::string &name) const { + map::const_iterator i(declarations.find(name)); + if (i != declarations.end()) { + return *i->second; + } else { + throw runtime_error("undeclared identifier " + name); + } +} + +bool ParsedSource::IsDefined(const std::string &name) const { + return definitions.count(name); +} + +Definition &ParsedSource::GetDefinition(const std::string &name) { + map::const_iterator i(definitions.find(name)); + if (i != definitions.end()) { + return *i->second; + } else { + string msg("undefined identifier " + name); + map::const_iterator i(declarations.find(name)); + if (i != declarations.end()) { + msg += ", declared as " + i->second->TypeName(); + } else { + msg += ", not declared"; + } + throw runtime_error(msg); + } +} + +const Definition &ParsedSource::GetDefinition(const std::string &name) const { + map::const_iterator i(definitions.find(name)); + if (i != definitions.end()) { + return *i->second; + } else { + string msg("undefined identifier " + name); + map::const_iterator i(declarations.find(name)); + if (i != declarations.end()) { + msg += ", declared as " + i->second->TypeName(); + } else { + msg += ", not declared"; + } + throw runtime_error(msg); + } +} + +void ParsedSource::WriteHeader(std::ostream &out) const { + for (std::set::const_iterator i(exports.begin()), end(exports.end()); i != end; ++i) { + out << GetDeclaration(*i).TypeName() << ' ' << *i << std::endl; + } +} + + +Definition::~Definition() { + if (isLiteral) { + delete reinterpret_cast(value); + } else { + delete reinterpret_cast(value); + } +} + void Definition::SetValue(Literal *v) { value = v; isLiteral = true; @@ -54,7 +137,7 @@ void Definition::SetValue(PropertyList *v) { Literal *Definition::GetLiteral() { if (isLiteral) { - return (Literal *)value; + return reinterpret_cast(value); } else { throw runtime_error("tried to access properties as literal"); } @@ -62,7 +145,7 @@ Literal *Definition::GetLiteral() { const Literal *Definition::GetLiteral() const { if (isLiteral) { - return (Literal *)value; + return reinterpret_cast(value); } else { throw runtime_error("tried to access properties as literal"); } @@ -70,7 +153,7 @@ const Literal *Definition::GetLiteral() const { PropertyList *Definition::GetProperties() { if (!isLiteral) { - return (PropertyList *)value; + return reinterpret_cast(value); } else { throw runtime_error("tried to access literal value as property list"); } @@ -78,7 +161,9 @@ PropertyList *Definition::GetProperties() { const PropertyList *Definition::GetProperties() const { if (!isLiteral) { - return (PropertyList *)value; + 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"); } @@ -98,12 +183,37 @@ Literal::Literal(const vector &v) , i1(0), i2(0) , i3(0), i4(0) , b(false) -, type(ARRAY) { +, type(ARRAY_VALUES) { + if (!v.empty()) { + typeName = v.front()->GetLiteral().GetTypeName(); + } +} + +Literal::Literal(const string &typeName, const vector &pls) +: props(0) +, typeName(typeName) +, propertyLists(pls) +, i1(0), i2(0) +, i3(0), i4(0) +, b(false) +, type(ARRAY_PROPS) { + +} + +Literal::Literal(const string &typeName, const vector &ids) +: props(0) +, typeName(typeName) +, identifiers(ids) +, i1(0), i2(0) +, i3(0), i4(0) +, b(false) +, type(ARRAY_IDENTS) { } Literal::Literal(bool b) : props(0) +, typeName("Boolean") , i1(0), i2(0) , i3(0), i4(0) , b(b) @@ -113,6 +223,7 @@ Literal::Literal(bool b) Literal::Literal(int r, int g, int b, int a) : props(0) +, typeName("Color") , i1(r), i2(g) , i3(b), i4(a) , b(false) @@ -120,8 +231,30 @@ Literal::Literal(int r, int g, int b, int a) } +Literal::Literal(int number) +: props(0) +, typeName("Number") +, i1(number), i2(0) +, i3(0), i4(0) +, b(false) +, type(NUMBER) { + +} + +Literal::Literal(const string &dir, const string &path) +: props(0) +, typeName("Path") +, str(CatPath(dir, path)) +, i1(0), i2(0) +, i3(0), i4(0) +, b(false) +, type(STRING) { + +} + Literal::Literal(const string &str) : props(0) +, typeName("String") , str(str) , i1(0), i2(0) , i3(0), i4(0) @@ -132,6 +265,7 @@ Literal::Literal(const string &str) Literal::Literal(int x, int y) : props(0) +, typeName("Vector") , i1(x), i2(y) , i3(0), i4(0) , b(false) @@ -141,7 +275,7 @@ Literal::Literal(int x, int y) Literal::Literal(const string &typeName, PropertyList *properties) : props(properties) -, str(typeName) +, typeName(typeName) , i1(0), i2(0) , i3(0), i4(0) , b(false) @@ -149,6 +283,244 @@ Literal::Literal(const string &typeName, PropertyList *properties) } +Literal::Literal(const vector &s) +: props(0) +, script(s) +, i1(0), i2(0) +, i3(0), i4(0) +, b(false) +, type(SCRIPT) { + +} + +Literal::~Literal() { + switch (type) { + case ARRAY_VALUES: + for (vector::const_iterator i(values.begin()), end(values.end()); i != end; ++i) { + delete *i; + } + break; + case ARRAY_PROPS: + for (vector::const_iterator i(propertyLists.begin()), end(propertyLists.end()); i != end; ++i) { + delete *i; + } + break; + case OBJECT: + delete props; + break; + case SCRIPT: + for (vector::const_iterator i(script.begin()), end(script.end()); i != end; ++i) { + delete *i; + } + break; + default: + break; + } +} + + +const vector &Literal::GetValues() const { + if (type == ARRAY_VALUES) { + return values; + } else { + throw runtime_error("tried to access values of non-array literal"); + } +} + +const vector &Literal::GetPropertyLists() const { + if (type == ARRAY_PROPS) { + return propertyLists; + } else { + throw runtime_error("tried to access property lists of non-array literal"); + } +} + +const vector &Literal::GetIdentifiers() const { + if (type == ARRAY_IDENTS) { + return identifiers; + } else { + throw runtime_error("tried to access identifiers 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 { + return typeName; +} + +const PropertyList *Literal::GetProperties() const { + if (type == OBJECT) { + return props; + } else { + throw runtime_error("tried to access properties of non-object literal"); + } +} + +const vector &Literal::GetScript() const { + if (type == SCRIPT) { + return script; + } else { + throw runtime_error("tried to access script of non-script literal"); + } +} + + +Value::~Value() { + if (isLiteral) { + delete literal; + } +} + +const Literal &Value::GetLiteral() const { + if (isLiteral) { + return *literal; + } else { + throw runtime_error("tried to access literal of identifier value"); + } +} + +const std::string &Value::GetIdentifier() const { + if (!isLiteral) { + return identifier; + } else { + throw runtime_error("tried to access identifier of literal value"); + } +} + + +ScriptToken::ScriptToken(const string &s, Type t) +: literal(0) +, str(s) +, type(t) { + if (type == LITERAL) { + throw runtime_error("cannot create script literal without literal"); + } +} + +ScriptToken::ScriptToken(Literal *l) +: literal(l) +, str() +, type(LITERAL) { + if (!literal) { + throw runtime_error("cannot create script literal without literal"); + } +} + +ScriptToken::~ScriptToken() { + delete literal; +} + +const string &ScriptToken::RegisterName() const { + if (type == REGISTER) { + return str; + } else { + throw runtime_error("access to register name of non-register script token"); + } +} + +const string &ScriptToken::CommandName() const { + if (type == COMMAND) { + return str; + } else { + throw runtime_error("access to command name of non-command script token"); + } +} + +const string &ScriptToken::Identifier() const { + if (type == IDENTIFIER) { + return str; + } else { + throw runtime_error("access to identifier of non-identifier script token"); + } +} + +const string &ScriptToken::Label() const { + if (type == LABEL) { + return str; + } else { + throw runtime_error("access to label of non-label script token"); + } +} + +const Literal *ScriptToken::GetLiteral() const { + if (type == LITERAL) { + return literal; + } else { + throw runtime_error("access to literal value of non-literal script token"); + } +} + } @@ -160,6 +532,13 @@ ostream &operator <<(ostream &out, const loader::ParsedSource &source) { for (map::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::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::const_iterator i(source.Exports().begin()), end(source.Exports().end()); i != end; ++i) { out << " - " << *i << endl; @@ -167,4 +546,43 @@ 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::ARRAY_IDENTS: + out << "array of identifiers"; + 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::PATH: + out << "path, \"" << l.GetString() << '"'; + 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; + case loader::Literal::SCRIPT: + out << "script"; + break; + } + return out; +} + }