Fixes relocation and slowly starts implmenting base DOS and DPMI interrupts.

6 files changed, 74 insertions, 43 deletions

diff --git a/le/le_file.cpp b/le/le_file.cpp
index 2e0a9d5..5fbb34a 100644
--- a/le/le_file.cpp
+++ b/le/le_file.cpp
@@ -78,4 +78,4 @@ std::ostream&operator<<(std::ostream& os, File const& file)
 	return binparse::operator<<(os, file);
 }
 
-}
\ No newline at end of file
+}
diff --git a/le/le_file.hpp b/le/le_file.hpp
index 0807ea4..0e9a488 100644
--- a/le/le_file.hpp
+++ b/le/le_file.hpp
@@ -48,5 +48,4 @@ struct File
 File parse_file(std::istream& is);
 
 std::ostream& operator<<(std::ostream& os, File const& file);
-
-}
\ No newline at end of file
+}
diff --git a/le/le_fixup_record_table.cpp b/le/le_fixup_record_table.cpp
index e909203..c4d7b58 100644
--- a/le/le_fixup_record_table.cpp
+++ b/le/le_fixup_record_table.cpp
@@ -227,9 +227,14 @@ FixupRecordTable parse_fixup_record_table(std::istream& is, Offset32 offset, Fix
 	return table;
 }
 
-std::ostream&operator<<(std::ostream& os, const FixupRecordTable& table)
+std::ostream& operator<<(std::ostream& os, const FixupRecordTable& table)
 {
-	return binparse::operator<<(os, table.entries);	
+	return binparse::operator<<(os, table.entries);
+}
+
+std::ostream& operator<<(std::ostream& os, FixupRecordTable::Entry const& entry)
+{
+	return binparse::operator<<(os, entry);
 }
 
 }
diff --git a/le/le_fixup_record_table.hpp b/le/le_fixup_record_table.hpp
index 6a07da5..dff8ef5 100644
--- a/le/le_fixup_record_table.hpp
+++ b/le/le_fixup_record_table.hpp
@@ -52,5 +52,6 @@ FixupRecordTable::Entry parse(std::istream& is);
 FixupRecordTable parse_fixup_record_table(std::istream& is, Offset32 offset, FixupPageTable fixups);
 
 std::ostream& operator<<(std::ostream& os, FixupRecordTable const& table);
+std::ostream& operator<<(std::ostream& os, FixupRecordTable::Entry const& entry);
 
-}
\ No newline at end of file
+}
diff --git a/le/le_parse_util.cpp b/le/le_parse_util.cpp
index 003c953..4455d24 100644
--- a/le/le_parse_util.cpp
+++ b/le/le_parse_util.cpp
@@ -1,5 +1,8 @@
 #include "le_parse_util.hpp"
 
+#include <sstream>
+#include <iomanip>
+
 #include <boost/assert.hpp>
 
 #include "parse.hpp"
@@ -34,37 +37,65 @@ le::File parse_file(std::istream& is)
 	return file;
 }
 
-void relocate(std::vector<le::FixupRecordTable::Entry> fixups, uint8_t* binary, binparse::Value32 page_nr, le::File const& file) {
-	binparse::Offset32 page_offset;
-	for(auto&& object : file.object_table.entries) {
-		if(page_nr >= object.second.page_table_index && page_nr < object.second.page_table_index + object.second.nr_page_table_entries) {
-			page_offset = object.second.reloc_base_address;
-			page_offset += ((page_nr - 1) - object.second.page_table_index) * file.le_header.page_size;
-			break;
-		}
-	}
-	
-	for(auto&& fixup : fixups) {
-		auto internal = boost::get<le::FixupRecordTable::Entry::Internal>(fixup.data);
-		
-		auto source_offset = boost::get<binparse::Offset16>(fixup.source_offset_or_source_list_count);
-		
-		auto target_object = boost::get<binparse::Value8>(internal.object_number);
-				
-		auto binary_offset = page_offset + (int32_t) source_offset;
-		
-		binparse::Offset32 dest_offset;
-		if(bit(4, fixup.target_flags)) {
-			dest_offset = boost::get<binparse::Offset32>(internal.target_offset);
-		} else {
-			dest_offset = binparse::Offset32(boost::get<binparse::Offset16>(internal.target_offset));
-		}
-		dest_offset += file.object_table.entries.at(target_object).reloc_base_address;
-		for(int i = 0; i < 4; ++i) {
-            uint8_t& byte = *(binary + binary_offset + i);
-			byte = ((dest_offset >> (i * 8)) & 255);
-		}
-	}
+//works only for relocation type 7 (internal) (source flags == 7)
+void relocate(le::File const& file, std::vector<uint8_t>& binary, binparse::Offset32 offset)  {
+    for(auto&& entry : file.fixup_record_table.entries) {
+        auto&& page_nr = entry.first;
+        auto&& fixups = entry.second;
+
+        std::cout << "page_nr: " << page_nr << std::endl;
+        binparse::Offset32 page_offset;
+        for(auto&& object : file.object_table.entries) {
+            if(page_nr >= object.second.page_table_index && page_nr < object.second.page_table_index + object.second.nr_page_table_entries) {
+                page_offset = object.second.reloc_base_address;
+                //both page_nr and page_table_index are  1-indexed so this subtraction works out.
+                page_offset += (page_nr - object.second.page_table_index) * file.le_header.page_size;
+                break;
+            }
+        }
+
+        std::cout << "Page_offset: " << page_offset << std::endl;
+
+        for(auto&& fixup : fixups) {
+            auto internal = boost::get<le::FixupRecordTable::Entry::Internal>(fixup.data);
+
+            auto source_offset = boost::get<binparse::Offset16>(fixup.source_offset_or_source_list_count);
+
+            auto target_object = boost::get<binparse::Value8>(internal.object_number);
+
+            auto binary_offset = page_offset + source_offset;
+
+            binparse::Offset32 dest_offset;
+            if(bit(4, fixup.target_flags)) {
+                dest_offset = boost::get<binparse::Offset32>(internal.target_offset);
+            } else {
+                dest_offset = binparse::Offset32(boost::get<binparse::Offset16>(internal.target_offset));
+            }
+            dest_offset += file.object_table.entries.at(target_object).reloc_base_address;
+            dest_offset += offset;
+
+            std::stringstream byte_stream;
+            std::stringstream fixup_stream;
+
+            for(int i = 3; i >= 0; --i) {
+                uint8_t& byte = *(binary.data() + binary_offset + i);
+                const uint8_t fixup_byte = (dest_offset >> (i * 8)) & 255;
+
+                byte_stream << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) byte;
+                fixup_stream << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) fixup_byte;
+
+                byte = fixup_byte;
+            }
+
+            std::cout << fixup << std::endl;
+
+            std::cout <<
+                "Fixup ("
+                << std::hex << binary_offset <<
+                "): " << byte_stream.str() << " => " << fixup_stream.str() << std::endl;
+
+        }
+    }
 }
 
 size_t determine_binary_size(le::File const& file) {
@@ -93,11 +124,6 @@ static void load_binary_into(le::File const& file, uint8_t* buffer, size_t buffe
             std::copy(page.begin(), page.end(), buffer + dest_offset);
         }
     }
-
-    for(auto&& entry : file.fixup_record_table.entries) {
-        auto&& relocation = entry.second;
-        relocate(relocation, buffer, entry.first, file);
-    }
 }
 
 std::vector<uint8_t> load_binary(le::File const& file)
diff --git a/le/le_parse_util.hpp b/le/le_parse_util.hpp
index aea5e6e..2f0574a 100644
--- a/le/le_parse_util.hpp
+++ b/le/le_parse_util.hpp
@@ -10,7 +10,7 @@ std::vector<uint8_t> read_file_part(std::istream& is, std::streamsize offset, si
 
 std::vector<uint8_t> read_object(std::istream& is, le::File file, binparse::Value32 object_id);
 
-std::vector<uint8_t> relocate(le::File& file, std::vector<uint8_t> page, size_t index);
+void relocate(le::File const& file, std::vector<uint8_t>& binary, binparse::Offset32 offset = binparse::Offset32(0));
 size_t determine_binary_size(le::File const& file);
 std::vector<uint8_t> load_binary(le::File const& file);
 void load_binary(le::File const& file, uint8_t* buffer, size_t buffer_size);