X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Floader%2FInterpreter.cpp;h=1888361c465dd3c75de8f8a0057e68f8025bd0ec;hb=HEAD;hp=c2ce0d4145abf20ee1b90c291ad7965d2e5446aa;hpb=77915e0186f4fc0788054eb34651c726b80d981c;p=l2e.git diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp index c2ce0d4..1888361 100644 --- a/src/loader/Interpreter.cpp +++ b/src/loader/Interpreter.cpp @@ -1,13 +1,7 @@ -/* - * Interpreter.cpp - * - * Created on: Aug 26, 2012 - * Author: holy - */ - #include "Interpreter.h" #include "ParsedSource.h" +#include "TypeDescription.h" #include "../battle/Hero.h" #include "../battle/Monster.h" #include "../battle/PartyLayout.h" @@ -47,7 +41,7 @@ using graphics::Gauge; using graphics::ComplexAnimation; using graphics::SimpleAnimation; using graphics::Sprite; -using geometry::Vector; +using math::Vector; using std::make_pair; using std::set; using std::string; @@ -62,24 +56,76 @@ Interpreter::~Interpreter() { } +const Interpreter::ParsedDefinition &Interpreter::GetDefinition(const string &identifier) { + std::map::const_iterator i(parsedDefinitions.find(identifier)); + if (i != parsedDefinitions.end()) { + return i->second; + } else if (source.IsDefined(identifier)) { + ReadDefinition(source.GetDefinition(identifier)); + return parsedDefinitions.at(identifier); + } else { + throw Error("access to undefined object " + identifier); + } +} + const Interpreter::ParsedDefinition &Interpreter::GetDefinition(const string &identifier) const { - return parsedDefinitions.at(identifier); + std::map::const_iterator i(parsedDefinitions.find(identifier)); + if (i != parsedDefinitions.end()) { + return i->second; + } else { + throw Error("access to undefined object " + identifier); + } } -void *Interpreter::GetObject(int typeId, const std::string &name) { - std::map::const_iterator i(parsedDefinitions.find(name)); +void *Interpreter::GetObject( + int typeId, + const std::string &name) { + std::map::const_iterator + i(parsedDefinitions.find(name)); if (i != parsedDefinitions.end()) { - const TypeDescription &requested(TypeDescription::Get(typeId)); - const TypeDescription &actual(TypeDescription::Get(i->second.type)); + const TypeDescription &requested = + TypeDescription::Get(typeId); + const TypeDescription &actual = + TypeDescription::Get(i->second.type); if (requested.TypeId() == actual.TypeId()) { return values[actual.TypeId()][i->second.id]; } else if (actual.IsSubtypeOf(requested)) { - char *sub(reinterpret_cast(values[actual.TypeId()][i->second.id])); - std::ptrdiff_t offset(actual.SupertypeOffset(requested)); + char *sub = reinterpret_cast( + values[actual.TypeId()][i->second.id]); + std::ptrdiff_t offset = + actual.SupertypeOffset(requested); return sub - offset; } else { - throw Error("cannot cast " + actual.TypeName() + " to " + requested.TypeName()); + throw Error("cannot cast " + actual.TypeName() + + " to " + requested.TypeName()); + } + } else { + throw Error("access to undefined object " + name); + } +} + +const void *Interpreter::GetObject( + int typeId, + const std::string &name) const { + std::map::const_iterator + i(parsedDefinitions.find(name)); + if (i != parsedDefinitions.end()) { + const TypeDescription &requested = + TypeDescription::Get(typeId); + const TypeDescription &actual = + TypeDescription::Get(i->second.type); + if (requested.TypeId() == actual.TypeId()) { + return values.at(actual.TypeId()).at(i->second.id); + } else if (actual.IsSubtypeOf(requested)) { + char *sub = reinterpret_cast( + values.at(actual.TypeId()).at(i->second.id)); + std::ptrdiff_t offset = + actual.SupertypeOffset(requested); + return sub - offset; + } else { + throw Error("cannot cast " + actual.TypeName() + + " to " + requested.TypeName()); } } else { throw Error("access to undefined object " + name); @@ -114,22 +160,21 @@ void Interpreter::ReadLiteral(const Definition &dfn) { || dfn.GetLiteral()->GetType() == Literal::STRING) ? dfn.GetLiteral()->GetString().size() : td.Size()); char *object(alloc.Alloc(size)); + values[typeId].push_back(object); + parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id))); if (dfn.GetLiteral()->GetType() == Literal::OBJECT) { ReadObject(typeId, id, object, *dfn.GetLiteral()->GetProperties()); } else { ReadLiteral(typeId, id, object, *dfn.GetLiteral()); } - values[typeId].push_back(object); - parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id))); } void Interpreter::ReadLiteral(int typeId, int id, char *object, const Literal &literal) { switch (literal.GetType()) { case Literal::ARRAY_VALUES: - throw Error("named value arrays are not supported, sorry"); - break; case Literal::ARRAY_PROPS: - throw Error("named property list arrays are not supported, sorry"); + case Literal::ARRAY_IDENTS: + throw Error("named arrays are not supported, sorry"); break; case Literal::BOOLEAN: new (object) bool(literal.GetBoolean()); @@ -176,10 +221,9 @@ void *Interpreter::GetObject(int typeId, const Value &v) { int typeId(0), id(0); switch (v.GetLiteral().GetType()) { case Literal::ARRAY_VALUES: - throw Error("cannot copy value arrays, sorry"); - break; case Literal::ARRAY_PROPS: - throw Error("cannot copy property list arrays, sorry"); + case Literal::ARRAY_IDENTS: + throw Error("cannot copy arrays, sorry"); break; case Literal::BOOLEAN: { @@ -221,8 +265,9 @@ void *Interpreter::GetObject(int typeId, const Value &v) { case Literal::SCRIPT: { typeId = TypeDescription::GetTypeId("Script"); + char *script(ReadScript(v.GetLiteral().GetScript())); id = values[typeId].size(); - values[typeId].push_back(ReadScript(v.GetLiteral().GetScript())); + values[typeId].push_back(script); } break; case Literal::STRING: @@ -271,8 +316,8 @@ void Interpreter::ReadObject(const Definition &dfn) { char *object(alloc.Alloc(td.Size())); td.Construct(object); values[typeId].push_back(object); - ReadObject(typeId, id, object, *dfn.GetProperties()); parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id))); + ReadObject(typeId, id, object, *dfn.GetProperties()); } @@ -285,28 +330,65 @@ void Interpreter::ReadObject(int typeId, int id, char *object, const PropertyLis char *dest(object + fd.Offset()); if (fd.IsAggregate()) { int arraySize(i->second->GetLiteral().ArraySize()); - char *aggregate(alloc.Alloc(fieldType.Size() * arraySize)); - char *iter(aggregate); + size_t memberSize = fd.IsReferenced() ? sizeof(char *) : fieldType.Size(); + Array array; + array.typeId = fd.TypeId(); + array.size = arraySize * memberSize; + array.data = alloc.Alloc(array.size); + array.ref = fd.IsReferenced(); + arrays.push_back(array); + std::memset(array.data, 0, array.size); + char *iter = reinterpret_cast(array.data); if (i->second->GetLiteral().GetType() == Literal::ARRAY_PROPS) { const vector &list(i->second->GetLiteral().GetPropertyLists()); - for (vector::const_iterator j(list.begin()), end(list.end()); j != end; ++j, iter += fieldType.Size()) { - fieldType.Construct(iter); - ReadObject(fieldType.TypeId(), -1, iter, **j); + for (vector::const_iterator + j(list.begin()), end(list.end()); + j != end; ++j, iter += memberSize) { + char *member; + if (fd.IsReferenced()) { + member = alloc.Alloc(fieldType.Size()); + *reinterpret_cast(iter) = member; + } else { + member = iter; + } + fieldType.Construct(member); + ReadObject(fieldType.TypeId(), -1, member, **j); } - } else { + } else if (i->second->GetLiteral().GetType() == Literal::ARRAY_VALUES) { const vector &list(i->second->GetLiteral().GetValues()); - for (vector::const_iterator j(list.begin()), end(list.end()); j != end; ++j, iter += fieldType.Size()) { - fieldType.Construct(iter); - ReadLiteral(fieldType.TypeId(), -1, iter, (*j)->GetLiteral()); + for (vector::const_iterator j(list.begin()), end(list.end()); + j != end; ++j, iter += memberSize) { + char *member; + if (fd.IsReferenced()) { + member = alloc.Alloc(fieldType.Size()); + *reinterpret_cast(iter) = member; + } else { + member = iter; + } + fieldType.Construct(member); + ReadLiteral(fieldType.TypeId(), -1, member, (*j)->GetLiteral()); } - } - if (fd.IsReferenced()) { - std::memcpy(dest, &aggregate, sizeof(char *)); - dest += sizeof(char *); - std::memcpy(dest, &arraySize, sizeof(int)); } else { - throw Error("aggregate type fields must be referenced"); + if (!fd.IsReferenced()) { + // TODO: implement inline identifier arrays + throw std::runtime_error("inline identifier arrays not implemented (yet)"); + } + const vector &list(i->second->GetLiteral().GetIdentifiers()); + for (vector::const_iterator j(list.begin()), end(list.end()); + j != end; ++j, iter += memberSize) { + if (source.IsDefined(*j)) { + *reinterpret_cast(iter) + = GetObject(fd.TypeId(), *j); + } else { + Postpone(reinterpret_cast(array.data), + iter, *j, fd.TypeId(), false); + } + } } + size_t pLen = sizeof(char *); + std::memcpy(dest, &array.data, pLen); + dest += sizeof(char *); + std::memcpy(dest, &arraySize, sizeof(int)); } else if (i->second->IsLiteral() && !fd.IsReferenced()) { // inline literals if (i->second->GetLiteral().IsObject()) { @@ -326,7 +408,7 @@ void Interpreter::ReadObject(int typeId, int id, char *object, const PropertyLis } } } else { - Postpone(typeId, id, fd.Offset(), i->second->GetIdentifier(), fd.TypeId(), !fd.IsReferenced()); + Postpone(object, object + fd.Offset(), i->second->GetIdentifier(), fd.TypeId(), !fd.IsReferenced(), fd.IsAggregate()); } } td.Load(object); @@ -334,12 +416,19 @@ void Interpreter::ReadObject(int typeId, int id, char *object, const PropertyLis void Interpreter::ReadScript(const std::vector &s, Script *script) { + std::map labels; int size(0); for (vector::const_iterator i(s.begin()), end(s.end()); i != end; ++i) { - if ((*i)->GetType() != ScriptToken::COMMAND) { + if ((*i)->GetType() == ScriptToken::LABEL) { + if (labels.count((*i)->Label())) { + throw Error("duplicate label " + (*i)->Label()); + } else { + labels[(*i)->Label()] = size; + } + } else if ((*i)->GetType() != ScriptToken::COMMAND) { throw Error("unexpected script token"); } - ++size; + size += sizeof(Script::Code); const string &cmd((*i)->CommandName()); if (cmd == "move") { ++i; @@ -347,62 +436,126 @@ void Interpreter::ReadScript(const std::vector &s, Script *script throw Error("unexpected script end after move"); } const string ®((*i)->RegisterName()); - switch (reg[0]) { - case 'a': - size += sizeof(void *); - break; - case 'i': - size += sizeof(int); - break; - case 'v': - size += sizeof(Vector); - break; - default: - throw Error("unknown register " + reg); + if (reg.size() != 2) { + throw Error("invalid register name " + reg); } ++i; if (i == end) { throw Error("unexpected script end after move"); } + if ((*i)->GetType() != ScriptToken::REGISTER) { + switch (reg[0]) { + case 'a': + size += sizeof(void *); + break; + case 'i': + size += sizeof(int); + break; + case 'v': + size += sizeof(Vector); + break; + default: + throw Error("unknown register " + reg); + } + } } else if (cmd == "add") { ++i; if (i == end) { throw Error("unexpected script end after add"); } const string ®((*i)->RegisterName()); - switch (reg[0]) { - case 'i': - size += sizeof(int); - break; - case 'v': - size += sizeof(Vector); - break; - default: - throw Error("expected register after add " + reg); + if (reg.size() != 2) { + throw Error("invalid register name " + reg); } ++i; if (i == end) { throw Error("unexpected script end after add"); } + if ((*i)->GetType() != ScriptToken::REGISTER) { + switch (reg[0]) { + case 'i': + size += sizeof(int); + break; + case 'v': + size += sizeof(Vector); + break; + default: + throw Error("expected register after add " + reg); + } + } } else if (cmd == "mod") { ++i; if (i == end) { throw Error("unexpected script end after mod"); } - size += sizeof(int); ++i; if (i == end) { throw Error("unexpected script end after mod"); } + if ((*i)->GetType() != ScriptToken::REGISTER) { + size += sizeof(int); + } } else if (cmd == "rand") { ++i; if (i == end) { throw Error("unexpected script end after rand"); } + } else if (cmd == "cmp") { + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + if ((*i)->GetType() != ScriptToken::REGISTER) { + size += sizeof(int); + } + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + if ((*i)->GetType() != ScriptToken::REGISTER) { + size += sizeof(int); + } + } else if (cmd == "jmp") { size += sizeof(int); ++i; if (i == end) { - throw Error("unexpected script end after rand"); + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jeq") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jne") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jl") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jle") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jg") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); + } + } else if (cmd == "jge") { + size += sizeof(int); + ++i; + if (i == end) { + throw Error("unexpected script end after cmp"); } } else if (cmd == "sysc") { @@ -411,109 +564,272 @@ void Interpreter::ReadScript(const std::vector &s, Script *script } } - unsigned char *text(reinterpret_cast(alloc.Alloc(size))); + char *text(alloc.Alloc(size)); int cursor(0); for (vector::const_iterator i(s.begin()), end(s.end()); i != end; ++i) { + if ((*i)->GetType() == ScriptToken::LABEL) { + continue; + } if ((*i)->GetType() != ScriptToken::COMMAND) { throw Error("unexpected script token"); } const string &cmd((*i)->CommandName()); if (cmd == "move") { + Script::Code &code(CreateScriptCode(Script::COMMAND_MOVE, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 2; ++i; const string ®((*i)->RegisterName()); + switch (reg[0]) { + case 'a': + code.type = Script::TYPE_ADDRESS; + break; + case 'i': + code.type = Script::TYPE_INTEGER; + break; + case 'v': + code.type = Script::TYPE_VECTOR; + break; + default: + throw Error("invalid register " + reg); + } + int regnum(reg[1] - '0'); + if (regnum < 0 || regnum > 6) { + throw Error("invalid register " + reg); + } + code.reg1 = regnum; ++i; - if (reg == "a0") { - text[cursor] = Script::CODE_MOVE_A0; - ++cursor; - ReadScriptAddress(**i, text + cursor); - cursor += sizeof(void *); - } else if (reg == "a1") { - text[cursor] = Script::CODE_MOVE_A1; - ++cursor; - ReadScriptAddress(**i, text + cursor); - cursor += sizeof(void *); - } else if (reg == "i0") { - text[cursor] = Script::CODE_MOVE_I0; - ++cursor; - ReadScriptInteger(**i, text + cursor); - cursor += sizeof(int); - } else if (reg == "i1") { - text[cursor] = Script::CODE_MOVE_I1; - ++cursor; - ReadScriptInteger(**i, text + cursor); - cursor += sizeof(int); - } else if (reg == "v0") { - text[cursor] = Script::CODE_MOVE_V0; - ++cursor; - ReadScriptVector(**i, text + cursor); - cursor += sizeof(Vector); - } else if (reg == "v1") { - text[cursor] = Script::CODE_MOVE_V1; - ++cursor; - ReadScriptVector(**i, text + cursor); - cursor += sizeof(Vector); + + if ((*i)->GetType() == ScriptToken::REGISTER) { + string reg2((*i)->RegisterName()); + if (reg[0] != reg2[0]) { + throw Error("mixed-type commands not allowed"); + } + int reg2num(reg[1] - '0'); + if (reg2num < 0 || reg2num > 6) { + throw Error("invalid register " + reg2); + } + code.reg2 = reg2num; } else { - throw Error("unknown register " + reg); + code.reg2 = 7; + switch (code.type) { + case Script::TYPE_ADDRESS: + ReadScriptAddress(**i, text + cursor); + cursor += sizeof(void *); + break; + case Script::TYPE_INTEGER: + ReadScriptInteger(**i, text + cursor); + cursor += sizeof(int); + break; + case Script::TYPE_VECTOR: + ReadScriptVector(**i, text + cursor); + cursor += sizeof(Vector); + break; + default: + break; + } } } else if (cmd == "add") { + Script::Code &code(CreateScriptCode(Script::COMMAND_ADD, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 2; ++i; const string ®((*i)->RegisterName()); + switch (reg[0]) { + case 'i': + code.type = Script::TYPE_INTEGER; + break; + case 'v': + code.type = Script::TYPE_VECTOR; + break; + default: + throw Error("invalid register " + reg); + } + int regnum(reg[1] - '0'); + if (regnum < 0 || regnum > 6) { + throw Error("invalid register " + reg); + } + code.reg1 = regnum; ++i; - if (reg == "i0") { - text[cursor] = Script::CODE_ADD_I0; - ++cursor; - ReadScriptInteger(**i, text + cursor); - cursor += sizeof(int); - } else if (reg == "i1") { - text[cursor] = Script::CODE_ADD_I1; - ++cursor; - ReadScriptInteger(**i, text + cursor); - cursor += sizeof(int); - } else if (reg == "v0") { - text[cursor] = Script::CODE_ADD_V0; - ++cursor; - ReadScriptVector(**i, text + cursor); - cursor += sizeof(Vector); - } else if (reg == "v1") { - text[cursor] = Script::CODE_ADD_V1; - ++cursor; - ReadScriptVector(**i, text + cursor); - cursor += sizeof(Vector); + + if ((*i)->GetType() == ScriptToken::REGISTER) { + string reg2((*i)->RegisterName()); + if (reg[0] != reg2[0]) { + throw Error("mixed-type commands not allowed"); + } + int reg2num(reg[1] - '0'); + if (reg2num < 0 || reg2num > 6) { + throw Error("invalid register name " + reg2); + } + code.reg2 = reg2num; } else { - throw Error("unexpected register " + reg); + code.reg2 = 7; + switch (code.type) { + case Script::TYPE_INTEGER: + ReadScriptInteger(**i, text + cursor); + cursor += sizeof(int); + break; + case Script::TYPE_VECTOR: + ReadScriptVector(**i, text + cursor); + cursor += sizeof(Vector); + break; + default: + break; + } } } else if (cmd == "mod") { + Script::Code &code(CreateScriptCode(Script::COMMAND_MOD, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 2; ++i; const string ®((*i)->RegisterName()); + if (reg[0] != 'i') { + throw Error("invalid register " + reg); + } + code.type = Script::TYPE_INTEGER; + int regnum(reg[1] - '0'); + if (regnum < 0 || regnum > 6) { + throw Error("invalid register " + reg); + } + code.reg1 = regnum; ++i; - if (reg == "i0") { - text[cursor] = Script::CODE_MOD_I0; - ++cursor; - ReadScriptInteger(**i, text + cursor); - cursor += sizeof(int); - } else if (reg == "i1") { - text[cursor] = Script::CODE_MOD_I1; - ++cursor; + + if ((*i)->GetType() == ScriptToken::REGISTER) { + string reg2((*i)->RegisterName()); + if (reg[0] != reg2[0]) { + throw Error("mixed-type commands not allowed"); + } + int reg2num(reg[1] - '0'); + if (reg2num < 0 || reg2num > 6) { + throw Error("invalid register name " + reg2); + } + code.reg2 = reg2num; + } else { + code.reg2 = 7; ReadScriptInteger(**i, text + cursor); cursor += sizeof(int); - } else { - throw Error("unexpected register " + reg); } } else if (cmd == "rand") { + Script::Code &code(CreateScriptCode(Script::COMMAND_RAND, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; ++i; const string ®((*i)->RegisterName()); - if (reg == "i0") { - text[cursor] = Script::CODE_RAND_I0; - ++cursor; - } else if (reg == "i1") { - text[cursor] = Script::CODE_RAND_I1; - ++cursor; + if (reg[0] != 'i') { + throw Error("invalid register " + reg); + } + code.type = Script::TYPE_INTEGER; + int regnum(reg[1] - '0'); + if (regnum < 0 || regnum > 6) { + throw Error("invalid register " + reg); + } + code.reg1 = regnum; + } else if (cmd == "cmp") { + Script::Code &code(CreateScriptCode(Script::COMMAND_CMP, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 2; + ++i; + const string ®((*i)->RegisterName()); + if (reg[0] != 'i') { + throw Error("invalid register " + reg); + } + code.type = Script::TYPE_INTEGER; + int regnum(reg[1] - '0'); + if (regnum < 0 || regnum > 6) { + throw Error("invalid register " + reg); + } + code.reg1 = regnum; + ++i; + + if ((*i)->GetType() == ScriptToken::REGISTER) { + string reg2((*i)->RegisterName()); + if (reg[0] != reg2[0]) { + throw Error("mixed-type commands not allowed"); + } + int reg2num(reg[1] - '0'); + if (reg2num < 0 || reg2num > 6) { + throw Error("invalid register name " + reg2); + } + code.reg2 = reg2num; } else { - throw Error("unexpected register " + reg); + code.reg2 = 7; + ReadScriptInteger(**i, text + cursor); + cursor += sizeof(int); } + } else if (cmd == "jmp") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JMP, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jeq") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JEQ, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jne") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JNE, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jl") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JL, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jle") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JLE, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jg") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JG, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); + } else if (cmd == "jge") { + Script::Code &code(CreateScriptCode(Script::COMMAND_JGE, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 1; + ++i; + if (!labels.count((*i)->Identifier())) { + throw Error("use of undefined label " + (*i)->Identifier()); + } + *reinterpret_cast(text + cursor) = labels[(*i)->Identifier()]; + cursor += sizeof(int); } else if (cmd == "sysc") { - text[cursor] = Script::CODE_SYSCALL; - ++cursor; + Script::Code &code(CreateScriptCode(Script::COMMAND_SYSC, text + cursor)); + cursor += sizeof(Script::Code); + code.numParams = 0; } else { throw Error("unknown command " + cmd); } @@ -531,23 +847,33 @@ char *Interpreter::ReadScript(const vector &s) { return mem; } -void Interpreter::ReadScriptAddress(const ScriptToken &t, unsigned char *dest) { +Script::Code &Interpreter::CreateScriptCode(Script::Command c, char *dest) { + Script::Code &code(*reinterpret_cast(dest)); + code.command = c; + code.numParams = 0; + code.type = Script::TYPE_NONE; + code.reg1 = 7; + code.reg2 = 7; + return code; +} + +void Interpreter::ReadScriptAddress(const ScriptToken &t, char *dest) { if (t.GetType() != ScriptToken::IDENTIFIER) { throw Error("expected identifier for address"); } - if (source.IsDefined(t.GetIdentifier())) { - const ParsedDefinition &def(GetDefinition(t.GetIdentifier())); - void *addr(GetObject(def.type, t.GetIdentifier())); + if (source.IsDefined(t.Identifier())) { + const ParsedDefinition &def(GetDefinition(t.Identifier())); + void *addr(GetObject(def.type, t.Identifier())); *reinterpret_cast(dest) = addr; } else { throw Error("postponing values in scripts not implemented"); } } -void Interpreter::ReadScriptInteger(const ScriptToken &t, unsigned char *dest) { +void Interpreter::ReadScriptInteger(const ScriptToken &t, char *dest) { if (t.GetType() == ScriptToken::IDENTIFIER) { - if (source.IsDefined(t.GetIdentifier())) { - void *num(GetObject(TypeDescription::GetTypeId("Number"), t.GetIdentifier())); + if (source.IsDefined(t.Identifier())) { + void *num(GetObject(TypeDescription::GetTypeId("Number"), t.Identifier())); *reinterpret_cast(dest) = *reinterpret_cast(num); } else { throw Error("postponing values in scripts not implemented"); @@ -559,10 +885,10 @@ void Interpreter::ReadScriptInteger(const ScriptToken &t, unsigned char *dest) { } } -void Interpreter::ReadScriptVector(const ScriptToken &t, unsigned char *dest) { +void Interpreter::ReadScriptVector(const ScriptToken &t, char *dest) { if (t.GetType() == ScriptToken::IDENTIFIER) { - if (source.IsDefined(t.GetIdentifier())) { - void *vec(GetObject(TypeDescription::GetTypeId("Vector"), t.GetIdentifier())); + if (source.IsDefined(t.Identifier())) { + void *vec(GetObject(TypeDescription::GetTypeId("Vector"), t.Identifier())); *reinterpret_cast *>(dest) = *reinterpret_cast *>(vec); } else { throw Error("postponing values in scripts not implemented"); @@ -586,27 +912,42 @@ SDL_Surface *Interpreter::GetImage(const string &path) { } } +const string &Interpreter::FindImage(SDL_Surface *img) const { + for (std::map::const_iterator + i(imageCache.begin()), end(imageCache.end()); + i != end; ++i) { + if (i->second == img) { + return i->first; + } + } + throw Error("unable to locate image"); +} + bool Interpreter::CanLink(const Value &v) const { return v.IsLiteral() || source.IsDefined(v.GetIdentifier()); } -void Interpreter::Postpone(int type, int id, std::ptrdiff_t offset, const std::string &identifier, int linkedType, bool inlined) { - char *str(alloc.Alloc(identifier.size() + 1)); - std::memcpy(str, identifier.c_str(), identifier.size()); - str[identifier.size()] = '\0'; - postponedDefinitions.push_back(PostponedDefinition(type, id, offset, str, linkedType, inlined)); +void Interpreter::Postpone( + char *object, + char *dest, + const std::string &identifier, + int type, + bool inlined, + bool aggregate) { + postponedDefinitions.push_back( + PostponedDefinition(object, dest, identifier, type, inlined, aggregate)); } void Interpreter::CreateTypeDescriptions() { { - TypeDescription &td(TypeDescription::CreateOrGet("Boolean")); + TypeDescription &td(TypeDescription::Create(BOOLEAN_ID, "Boolean")); td.SetDescription("Logical value which can be either true or false."); td.SetSize(sizeof(bool)); } { - TypeDescription &td(TypeDescription::CreateOrGet("Color")); + TypeDescription &td(TypeDescription::Create(COLOR_ID, "Color")); td.SetDescription( "A color in RGB format with an optional alpha channel.\n" "Components range from 0 to 255.\n" @@ -614,34 +955,35 @@ void Interpreter::CreateTypeDescriptions() { td.SetSize(sizeof(Color)); } { - TypeDescription &td(TypeDescription::CreateOrGet("Image")); + TypeDescription &td(TypeDescription::Create(IMAGE_ID, "Image")); td.SetDescription("Path to a PNG file with image data."); td.SetSize(sizeof(SDL_Surface)); } { - TypeDescription &td(TypeDescription::CreateOrGet("Number")); + TypeDescription &td(TypeDescription::Create(NUMBER_ID, "Number")); td.SetDescription("A signed integer."); td.SetSize(sizeof(int)); } { - int stringId(TypeDescription::GetTypeId("String")); - TypeDescription &td(TypeDescription::CreateOrGet("Path")); + TypeDescription &td(TypeDescription::Create(PATH_ID, "Path")); td.SetDescription("A path in the filesystem which is interpreted relative to the source file's location."); td.SetSize(1); - td.AddSupertype(stringId, 0); + td.AddSupertype(STRING_ID, 0); } { - TypeDescription &td(TypeDescription::CreateOrGet("Script")); + Script s; + TypeDescription &td(TypeDescription::Create(SCRIPT_ID, "Script")); td.SetDescription("Collection of commands that define a behaviour."); td.SetSize(sizeof(Script)); + td.AddField("text", FieldDescription(((char *)&s.text) - ((char *)&s), STRING_ID).SetAggregate()); } { - TypeDescription &td(TypeDescription::CreateOrGet("String")); + TypeDescription &td(TypeDescription::Create(STRING_ID, "String")); td.SetDescription("Some characters."); td.SetSize(1); } { - TypeDescription &td(TypeDescription::CreateOrGet("Vector")); + TypeDescription &td(TypeDescription::Create(VECTOR_ID, "Vector")); td.SetDescription("A pair of numbers usually describing a 2D translation or offset."); td.SetSize(sizeof(Vector)); }