support for arrays containing (yet) undefined references

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

diff --git a/src/loader/Loader.cpp b/src/loader/Loader.cpp
index 961ec7cff6d315dec5537338fe08ba8cfc0b9450..ba5dcc066d2b6c941534eb1160f57ded7106b74a 100644 (file)
--- a/src/loader/Loader.cpp
+++ b/src/loader/Loader.cpp
@@ -3,12 +3,15 @@
 #include <climits>
 #include <cstring>
 #include <fstream>
+#include <ostream>
 #include <stdexcept>
 #include <utility>
 #include <SDL_image.h>
 
+using std::endl;
 using std::make_pair;
 using std::map;
+using std::ostream;
 using std::string;
 using std::vector;
 
@@ -73,6 +76,34 @@ void Loader::Load(const std::string &filePath) {
                throw;
        }
        objectFiles.insert(make_pair(filePath, block));
+
+       if (objectFiles.size() > 1) {
+               for (std::vector<MissingExternal>::iterator
+                               i(unlinked.begin()); i != unlinked.end();) {
+                       std::map<string, LoadedExport>::const_iterator
+                                       found(exports.find(i->identifier));
+                       if (found != exports.end()) {
+                               LinkExternal(*i, found->second);
+                               i = unlinked.erase(i);
+                       } else {
+                               ++i;
+                       }
+               }
+       }
+}
+
+void Loader::LinkExternal(
+               const MissingExternal &ext,
+               const LoadedExport &exp) {
+       if (ext.typeId != exp.typeId) {
+               throw std::runtime_error("casting not implemented in loader");
+       }
+       const TypeDescription &td = TypeDescription::Get(ext.typeId);
+       if (ext.inlined) {
+               std::memcpy(ext.dest, exp.location, td.Size());
+       } else {
+               std::memcpy(ext.dest, &exp.location, sizeof(void *));
+       }
 }
 
 void Loader::LoadExports(char *src, Export *begin, Export *end) {
@@ -88,18 +119,24 @@ void Loader::LoadExports(char *src, Export *begin, Export *end) {
 void Loader::LoadExternals(char *src, External *begin, External *end) {
        for (External *i = begin; i < end; ++i) {
                string identifier(src + i->nameOffset);
+               char *dest = src + i->referenceOffset;
+
                map<string, LoadedExport>::const_iterator
                                exp(exports.find(identifier));
                if (exp == exports.end()) {
-                       throw std::runtime_error("undefined reference to "
-                                       + identifier);
-               }
-               const TypeDescription &td(TypeDescription::Get(exp->second.typeId));
-               char *dest = src + i->referenceOffset;
-               if (i->inlined) {
-                       std::memcpy(dest, exp->second.location, td.Size());
+                       MissingExternal m;
+                       m.identifier = identifier;
+                       m.dest = dest;
+                       m.typeId = i->typeId;
+                       m.inlined = i->inlined;
+                       unlinked.push_back(m);
                } else {
-                       std::memcpy(dest, &exp->second.location, sizeof(char *));
+                       const TypeDescription &td(TypeDescription::Get(exp->second.typeId));
+                       if (i->inlined) {
+                               std::memcpy(dest, exp->second.location, td.Size());
+                       } else {
+                               std::memcpy(dest, &exp->second.location, sizeof(char *));
+                       }
                }
        }
 }
@@ -204,4 +241,47 @@ void Loader::InitArrays(Array *begin, Array *end) {
        }
 }
 
+
+ostream &Loader::Dump(ostream &out) const {
+       out << "loaded objects" << endl;
+       out << "==============" << endl;
+
+       out << objectFiles.size() << " object files" << endl;
+       for (std::map<string, char *>::const_iterator
+                       i(objectFiles.begin()), end(objectFiles.end());
+                       i != end; ++i) {
+               out << " - " << i->first << endl;
+       }
+
+       out << exports.size() << " exports" << endl;
+       for (std::map<string, LoadedExport>::const_iterator
+                       i(exports.begin()), end(exports.end());
+                       i != end; ++i) {
+               const TypeDescription &td = TypeDescription::Get(i->second.typeId);
+               out << " - " << td.TypeName() << ' ' << i->first << endl;
+       }
+
+       out << images.size() << " images" << endl;
+       for (std::map<string, SDL_Surface *>::const_iterator
+                       i(images.begin()), end(images.end());
+                       i != end; ++i) {
+               out << " - " << i->first << endl;
+       }
+
+       out << unlinked.size() << " missing objects" << endl;
+       for (std::vector<MissingExternal>::const_iterator
+                       i(unlinked.begin()), end(unlinked.end());
+                       i != end; ++i) {
+               const TypeDescription &td = TypeDescription::Get(
+                               i->typeId);
+               out << " - " << td.TypeName() << ' ';
+               if (!i->inlined) {
+                       out << '*';
+               }
+               out << i->identifier << endl;
+       }
+
+       return out;
+}
+
 }