activated the loader

produces segfaults en masse but actually loads some of the data

diff --git a/src/loader/Caster.cpp b/src/loader/Caster.cpp
index 050ac930e9ef956d90bb16763fd94a47e02697b5..63b389adc9d848dda118d22490a23eb3b5ed2049 100644 (file)
--- a/src/loader/Caster.cpp
+++ b/src/loader/Caster.cpp
@@ -1,5 +1,7 @@
 #include "Caster.h"
 
+#include "Interpreter.h"
+#include "Loader.h"
 #include "TypeDescription.h"
 #include "../battle/Resources.h"
 #include "../battle/Monster.h"
@@ -23,49 +25,71 @@ using std::string;
 
 namespace loader {
 
-Caster::Caster(Interpreter &intp)
-: intp(intp) {
+Caster::Caster(Loader &ld, Interpreter &intp)
+: ld(ld)
+, intp(intp) {
 
 }
 
 
 battle::Resources *Caster::GetBattleResources(const string &ident) {
        return reinterpret_cast<battle::Resources *>(
-                       intp.GetObject(battle::Resources::TYPE_ID, ident));
+                       GetObject(battle::Resources::TYPE_ID, ident));
 }
 
 Capsule *Caster::GetCapsule(const string &ident) {
-       return reinterpret_cast<Capsule *>(intp.GetObject(Capsule::TYPE_ID, ident));
+       return reinterpret_cast<Capsule *>(
+                       GetObject(Capsule::TYPE_ID, ident));
 }
 
 Hero *Caster::GetHero(const string &ident) {
-       return reinterpret_cast<Hero *>(intp.GetObject(Hero::TYPE_ID, ident));
+       return reinterpret_cast<Hero *>(
+                       GetObject(Hero::TYPE_ID, ident));
 }
 
 Item *Caster::GetItem(const string &ident) {
-       return reinterpret_cast<Item *>(intp.GetObject(Item::TYPE_ID, ident));
+       return reinterpret_cast<Item *>(
+                       GetObject(Item::TYPE_ID, ident));
 }
 
 Map *Caster::GetMap(const string &ident) {
-       return reinterpret_cast<Map *>(intp.GetObject(Map::TYPE_ID, ident));
+       return reinterpret_cast<Map *>(
+                       GetObject(Map::TYPE_ID, ident));
 }
 
 menu::Resources *Caster::GetMenuResources(const string &ident) {
        return reinterpret_cast<menu::Resources *>(
-                       intp.GetObject(menu::Resources::TYPE_ID, ident));
+                       GetObject(menu::Resources::TYPE_ID, ident));
 }
 
 Monster *Caster::GetMonster(const string &ident) {
-       return reinterpret_cast<Monster *>(intp.GetObject(Monster::TYPE_ID, ident));
+       return reinterpret_cast<Monster *>(
+                       GetObject(Monster::TYPE_ID, ident));
 }
 
 PartyLayout *Caster::GetPartyLayout(const string &ident) {
        return reinterpret_cast<PartyLayout *>(
-                       intp.GetObject(PartyLayout::TYPE_ID, ident));
+                       GetObject(PartyLayout::TYPE_ID, ident));
 }
 
 Spell *Caster::GetSpell(const string &ident) {
-       return reinterpret_cast<Spell *>(intp.GetObject(Spell::TYPE_ID, ident));
+       return reinterpret_cast<Spell *>(
+                       GetObject(Spell::TYPE_ID, ident));
+}
+
+
+void *Caster::GetObject(int typeId, const string &ident) {
+       std::map<string, LoadedExport>::const_iterator i(
+                       ld.Exports().find(ident));
+       if (i != ld.Exports().end()) {
+               if (i->second.typeId != typeId) {
+                       throw std::runtime_error("mismatched type for "
+                                       + ident);
+               } else {
+                       return i->second.location;
+               }
+       }
+       return intp.GetObject(typeId, ident);
 }
 
 }

diff --git a/src/loader/Caster.h b/src/loader/Caster.h
index c20f5d949c32a9ccb6ad8dc8960e6db06e9506a7..05eada4c8b5ef964cb00aae94bc691050de56732 100644 (file)
--- a/src/loader/Caster.h
+++ b/src/loader/Caster.h
@@ -12,6 +12,10 @@ namespace common {
        class Item;
        class Spell;
 }
+namespace loader {
+       class Interpreter;
+       class Loader;
+}
 namespace map {
        class Map;
 }
@@ -19,8 +23,6 @@ namespace menu {
        struct Resources;
 }
 
-#include "Interpreter.h"
-
 #include <string>
 
 namespace loader {
@@ -28,7 +30,7 @@ namespace loader {
 class Caster {
 
 public:
-       Caster(Interpreter &intp);
+       Caster(Loader &ld, Interpreter &intp);
        ~Caster() { }
 private:
        Caster(const Caster &);
@@ -46,6 +48,10 @@ public:
        common::Spell *GetSpell(const std::string &identifier);
 
 private:
+       void *GetObject(int typeId, const std::string &ident);
+
+private:
+       Loader &ld;
        Interpreter &intp;
 
 };

diff --git a/src/loader/Compiler.cpp b/src/loader/Compiler.cpp
index d122643fbedc7c29ddac0eef0ad6fb8d8fe53f3c..bb96b28728ecf82e1abb03fbb195722eb02dec83 100644 (file)
--- a/src/loader/Compiler.cpp
+++ b/src/loader/Compiler.cpp
@@ -75,11 +75,11 @@ void Compiler::WriteOwnStrings(ostream &out) {
                        i(intp.ExportedIdentifiers().begin()),
                        end(intp.ExportedIdentifiers().end());
                        i != end; ++i) {
-               addressMap.insert(make_pair(i->c_str(), cursor));
                Object object;
                object.typeId = Interpreter::STRING_ID;
                object.size = i->size() + 1;
                Write(out, &object, sizeof(Object));
+               addressMap.insert(make_pair(i->c_str(), cursor));
                Write(out, i->c_str(), object.size);
        }
        for(vector<Interpreter::PostponedDefinition>::const_iterator

diff --git a/src/loader/Loader.cpp b/src/loader/Loader.cpp
index 2403044ad20fb819a23fafc0b43c2ded125a317c..9c8739aabee00191584852973971f203fc8afa5e 100644 (file)
--- a/src/loader/Loader.cpp
+++ b/src/loader/Loader.cpp
@@ -4,7 +4,9 @@
 #include <cstring>
 #include <fstream>
 #include <stdexcept>
+#include <utility>
 
+using std::make_pair;
 using std::map;
 using std::string;
 using std::vector;
@@ -52,6 +54,9 @@ void Loader::Load(const std::string &filePath) {
                LoadObjects(header->ident,
                                header->ObjectsBegin(),
                                header->ObjectsEnd());
+               LoadArrays(header->ident,
+                               header->ArraysBegin(),
+                               header->ArraysEnd());
        } catch (...) {
                delete[] block;
                throw;
@@ -65,6 +70,7 @@ void Loader::LoadExports(char *src, Export *begin, Export *end) {
                LoadedExport &exp(exports[identifier]);
                exp.typeId = i->typeId;
                exp.location = src + i->dataOffset;
+               exports.insert(make_pair(identifier, exp));
        }
 }
 
@@ -112,4 +118,17 @@ void Loader::LoadObject(char *src, char *object, const TypeDescription &td) {
        }
 }
 
+void Loader::LoadArrays(char *src, Array *begin, Array *end) {
+       for (Array *i = begin; i < end; i = i->Next()) {
+               if (!i->ref) {
+                       continue;
+               }
+               for (char *j = i->Data(), *end = i->Data() + i->size;
+                               j < end; j += sizeof(void *)) {
+                       *reinterpret_cast<char **>(j) =
+                                       src + *reinterpret_cast<unsigned int *>(j);
+               }
+       }
+}
+
 }

diff --git a/src/loader/Loader.h b/src/loader/Loader.h
index cf7dd132a3e76b60c44464cb44aff5a0af82a6fd..0a7f845e062d8f9861d22d2debf4ff5aa3471cb2 100644 (file)
--- a/src/loader/Loader.h
+++ b/src/loader/Loader.h
@@ -19,11 +19,14 @@ public:
 public:
        void Load(const std::string &file);
 
+       const std::map<std::string, LoadedExport> &Exports() const { return exports; }
+
 private:
        void LoadExports(char *src, Export *begin, Export *end);
        void LoadExternals(char *src, External *begin, External *end);
        void LoadObjects(char *src, Object *begin, Object *end);
        void LoadObject(char *src, char *dest, const TypeDescription &);
+       void LoadArrays(char *src, Array *begin, Array *end);
 
 private:
        std::map<std::string, char *> objectFiles;

diff --git a/src/main.cpp b/src/main.cpp
index 73a9f16fff877eb6ddc013e6cd3b2b4f7e2169ee..c01154e0368038757444a418c8cb19340802a64c 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -211,7 +211,7 @@ int main(int argc, char **argv) {
                        return 3;
                }
 
-               Caster caster(intp);
+               Caster caster(ld, intp);
 
                GameState gameState;