Removing horrible CR/LF line endings.

1 files changed, 119 insertions, 119 deletions

diff --git a/Database/internals/database-segment.cpp b/Database/internals/database-segment.cpp
index 4b94000..55689f8 100644
--- a/Database/internals/database-segment.cpp
+++ b/Database/internals/database-segment.cpp
@@ -1,119 +1,119 @@
-#include "database-segment.h"

-

-Segment::Segment(Uint32 size, Uint32 id, Uint64 cpu_base, Uint32 extra_size, const Byte * data) : patches(0), plainmemory(0), size(size), extra_size(extra_size), id(id), cpu_base(cpu_base) {

-    Uint64 fullsize = size + extra_size;

-    

-    assert(size);

-    

-    if (data) {

-        plainmemory = (Byte *) data;

-        loaded = true;

-        allocated = false

-    } else {

-        plainmemory = Allocator<Byte>::alloc(size);

-        loaded = false;

-        allocated = true;

-    }

-    tags = Allocator<memory_tags_t>::alloc(fullsize);

-    refData = Allocator<SegmentRefData *>::alloc(fullsize);

-}

-

-Segment::~Segment() {

-    if (allocated)

-        Allocator<Byte>::free(plainmemory);

-    if (patches)

-        Allocator<Byte>::free(patches);

-    if (patchesmemory)

-        Allocator<Byte>::free(patchesmap);

-    Allocator<memory_tags_t>::free(tags);

-    Allocator<SegmentRefData *>::free(refData);

-}

-

-short Segment::Read(Uint32 ptr) {

-    if (ptr >= size) {

-        LOG(CONSOLE, ERROR, "Out of bound read attempt in segment %i at %08X\n", id, ptr);

-        return -1;

-    }

-    if (IsPatched(ptr))

-        return patches[ptr];

-    return plainmemory[ptr];

-}

-

-short Segment::RawRead(Uint32 ptr) {

-    if (ptr >= size) {

-        LOG(CONSOLE, ERROR, "Out of bound rawread attempt in segment %i at %08X\n", id, ptr);

-        return -1;

-    }

-    return plainmemory[ptr];

-}

-

-void Segment::Patch(Uint32 ptr, Byte val) {

-    if (!patchesmap) {

-        patches = Allocator<Byte>::alloc(size);

-        patchesmap = Allocator<Byte>::alloc((size << 3) + ((size & 7) ? 1 : 0));

-    }

-    if (ptr >= size) {

-        LOG(CONSOLE, ERROR, "Out of bound patch attempt in segment %i at %08X\n", id, ptr);

-        return;

-    }

-    patches[ptr] = val;

-    patchesmap[ptr / 8] |= (1 << ptr % 8);

-}

-

-void Segment::Restore(Uint32 ptr) {

-    if (!patchesmap)

-        return;

-    if (ptr >= size) {

-        LOG(CONSOLE, ERROR, "Out of bound patch attempt in segment %i at %08X\n", id, ptr);

-        return;

-    }

-    patchesmap[ptr / 8] &= ~(1 << (ptr % 8));

-}

-

-bool Segment::IsPatched(Uint32 ptr) {

-    if (!patchesmap)

-        return false;

-    return patchesmap[ptr / 8] & (1 << (ptr % 8));

-}

-

-void Segment::LoadMemory(Handle * src) {

-    if (loaded) {

-        LOG(CONSOLE, WARNING, "Memory segment already loaded, second attempt ignored.");

-        return;

-    }

-

-    src->Read(plainmemory, size);

-}

-

-void setTag(Uint32 ptr, memory_tags_t tag) {

-    if (ptr >= (size + extra_size)) {

-        LOG(CONSOLE, ERROR, "Out of bound setTag attempt in segment %i at %08X\n", id, ptr);

-        return;

-    }

-    tags[ptr] = tag;

-}

-

-memory_tags_t getTag(Uint32 ptr) {

-    if (ptr >= (size + extra_size)) {

-        memory_tags_t z = { 0, 0 };

-        LOG(CONSOLE, ERROR, "Out of bound getTag attempt in segment %i at %08X\n", id, ptr);

-        return z;

-    }

-    return tags[ptr];

-}

-

-SegmentRefData * Segment::getSegmentRefData(Uint32 ptr) {

-    if (ptr >= (size + extra_size)) {

-        LOG(CONSOLE, ERROR, "Out of bound getSegmentRefData attempt in segment %i at %08X\n", id, ptr);

-        return 0;

-    }

-    return refData[ptr];

-}

-

-void Segment::setSegmentRefData(Uint32 ptr, SegmentRefData * data) {

-    if (ptr >= (size + extra_size)) {

-        LOG(CONSOLE, ERROR, "Out of bound setSegmentRefData attempt in segment %i at %08X\n", id, ptr);

-        return;

-    }

-    refData[ptr] = data;

-}

+#include "database-segment.h"
+
+Segment::Segment(Uint32 size, Uint32 id, Uint64 cpu_base, Uint32 extra_size, const Byte * data) : patches(0), plainmemory(0), size(size), extra_size(extra_size), id(id), cpu_base(cpu_base) {
+    Uint64 fullsize = size + extra_size;
+    
+    assert(size);
+    
+    if (data) {
+        plainmemory = (Byte *) data;
+        loaded = true;
+        allocated = false
+    } else {
+        plainmemory = Allocator<Byte>::alloc(size);
+        loaded = false;
+        allocated = true;
+    }
+    tags = Allocator<memory_tags_t>::alloc(fullsize);
+    refData = Allocator<SegmentRefData *>::alloc(fullsize);
+}
+
+Segment::~Segment() {
+    if (allocated)
+        Allocator<Byte>::free(plainmemory);
+    if (patches)
+        Allocator<Byte>::free(patches);
+    if (patchesmemory)
+        Allocator<Byte>::free(patchesmap);
+    Allocator<memory_tags_t>::free(tags);
+    Allocator<SegmentRefData *>::free(refData);
+}
+
+short Segment::Read(Uint32 ptr) {
+    if (ptr >= size) {
+        LOG(CONSOLE, ERROR, "Out of bound read attempt in segment %i at %08X\n", id, ptr);
+        return -1;
+    }
+    if (IsPatched(ptr))
+        return patches[ptr];
+    return plainmemory[ptr];
+}
+
+short Segment::RawRead(Uint32 ptr) {
+    if (ptr >= size) {
+        LOG(CONSOLE, ERROR, "Out of bound rawread attempt in segment %i at %08X\n", id, ptr);
+        return -1;
+    }
+    return plainmemory[ptr];
+}
+
+void Segment::Patch(Uint32 ptr, Byte val) {
+    if (!patchesmap) {
+        patches = Allocator<Byte>::alloc(size);
+        patchesmap = Allocator<Byte>::alloc((size << 3) + ((size & 7) ? 1 : 0));
+    }
+    if (ptr >= size) {
+        LOG(CONSOLE, ERROR, "Out of bound patch attempt in segment %i at %08X\n", id, ptr);
+        return;
+    }
+    patches[ptr] = val;
+    patchesmap[ptr / 8] |= (1 << ptr % 8);
+}
+
+void Segment::Restore(Uint32 ptr) {
+    if (!patchesmap)
+        return;
+    if (ptr >= size) {
+        LOG(CONSOLE, ERROR, "Out of bound patch attempt in segment %i at %08X\n", id, ptr);
+        return;
+    }
+    patchesmap[ptr / 8] &= ~(1 << (ptr % 8));
+}
+
+bool Segment::IsPatched(Uint32 ptr) {
+    if (!patchesmap)
+        return false;
+    return patchesmap[ptr / 8] & (1 << (ptr % 8));
+}
+
+void Segment::LoadMemory(Handle * src) {
+    if (loaded) {
+        LOG(CONSOLE, WARNING, "Memory segment already loaded, second attempt ignored.");
+        return;
+    }
+
+    src->Read(plainmemory, size);
+}
+
+void setTag(Uint32 ptr, memory_tags_t tag) {
+    if (ptr >= (size + extra_size)) {
+        LOG(CONSOLE, ERROR, "Out of bound setTag attempt in segment %i at %08X\n", id, ptr);
+        return;
+    }
+    tags[ptr] = tag;
+}
+
+memory_tags_t getTag(Uint32 ptr) {
+    if (ptr >= (size + extra_size)) {
+        memory_tags_t z = { 0, 0 };
+        LOG(CONSOLE, ERROR, "Out of bound getTag attempt in segment %i at %08X\n", id, ptr);
+        return z;
+    }
+    return tags[ptr];
+}
+
+SegmentRefData * Segment::getSegmentRefData(Uint32 ptr) {
+    if (ptr >= (size + extra_size)) {
+        LOG(CONSOLE, ERROR, "Out of bound getSegmentRefData attempt in segment %i at %08X\n", id, ptr);
+        return 0;
+    }
+    return refData[ptr];
+}
+
+void Segment::setSegmentRefData(Uint32 ptr, SegmentRefData * data) {
+    if (ptr >= (size + extra_size)) {
+        LOG(CONSOLE, ERROR, "Out of bound setSegmentRefData attempt in segment %i at %08X\n", id, ptr);
+        return;
+    }
+    refData[ptr] = data;
+}