add cmakelists for CLion, tons and tons of reorganisation using new info from the Pro8 compiler

1 files changed, 266 insertions, 0 deletions

diff --git a/command_line/CmdLine/Src/MacEmul/Memory.c b/command_line/CmdLine/Src/MacEmul/Memory.c
new file mode 100644
index 0000000..8b956a0
--- /dev/null
+++ b/command_line/CmdLine/Src/MacEmul/Memory.c
@@ -0,0 +1,266 @@
+#include "mwcc_decomp.h"
+
+static OSErr memError;
+
+typedef struct HandleStructure {
+    char *addr;
+    OSHandle hand;
+} HandleStructure;
+
+#define HS(h) ((HandleStructure *) (h))
+
+OSHandle *OS_PeekMacHandle(Handle h) {
+    return &HS(h)->hand;
+}
+
+static void FixHandlePtr(Handle h, void *ptr) {
+    HS(h)->hand.addr = ptr;
+}
+
+Handle OS_CreateMacHandle(OSHandle *h) {
+    HandleStructure *hs = malloc(sizeof(HandleStructure));
+    if (!hs) {
+        memError = -108;
+        return 0;
+    };
+
+    hs->hand = *h;
+    OS_InvalidateHandle(h);
+    hs->addr = OS_LockHandle(&hs->hand);
+    OS_UnlockHandle(&hs->hand);
+    return (Handle) hs;
+}
+
+Handle OS_CreateMacHandleDup(OSHandle *h) {
+    HandleStructure *hs = malloc(sizeof(HandleStructure));
+    if (!hs) {
+        memError = -108;
+        return 0;
+    };
+
+    hs->hand = *h;
+    hs->addr = OS_LockHandle(&hs->hand);
+    OS_UnlockHandle(&hs->hand);
+    return (Handle) hs;
+}
+
+void OS_DestroyMacHandle(Handle h, OSHandle *ret) {
+    *ret = HS(h)->hand;
+    free(h);
+}
+
+OSErr MemError() {
+    return memError;
+}
+
+Handle NewHandle(SInt32 dataSize) {
+    int err;
+    OSHandle oh;
+
+    err = OS_NewHandle(dataSize, &oh);
+    if (err) {
+        memError = OS_MacError(err);
+        return 0;
+    }
+
+    return OS_CreateMacHandle(&oh);
+}
+
+Handle NewHandleClear(UInt32 dataSize) {
+    Handle hdl = NewHandle(dataSize);
+
+    if (hdl) {
+        HLock(hdl);
+        if (*hdl)
+            memset(*hdl, 0, dataSize);
+        HUnlock(hdl);
+    }
+
+    return hdl;
+}
+
+Handle TempNewHandle(UInt32 dataSize, OSErr *resultCode) {
+    *resultCode = 0;
+    Handle hdl = NewHandle(dataSize);
+    if (!hdl)
+        *resultCode = memError;
+    return hdl;
+}
+
+void DisposeHandle(Handle h) {
+    if (h) {
+        memError = OS_MacError(OS_FreeHandle(&HS(h)->hand));
+        FixHandlePtr(h, 0);
+    } else {
+        memError = -109;
+    }
+}
+
+void HLock(Handle h) {
+    void *buffer;
+
+    if (h) {
+        buffer = OS_LockHandle(&HS(h)->hand);
+        FixHandlePtr(h, buffer);
+        memError = 0;
+    } else {
+        memError = -109;
+    }
+}
+
+void HLockHi(Handle h) {
+    HLock(h);
+}
+
+void HUnlock(Handle h) {
+    if (h) {
+        memError = 0;
+        OS_UnlockHandle(&HS(h)->hand);
+    } else {
+        memError = -109;
+    }
+}
+
+void HPurge(Handle theHandle) {
+    memError = 0;
+}
+
+void HNoPurge(Handle theHandle) {
+    memError = 0;
+}
+
+SInt8 HGetState(Handle theHandle) {
+    memError = 0;
+    return 0;
+}
+
+void HSetState(Handle theHandle, SInt8 flags) {
+    memError = 0;
+}
+
+SInt32 GetHandleSize(Handle h) {
+    UInt32 sz;
+
+    if (h) {
+        memError = OS_MacError(OS_GetHandleSize(&HS(h)->hand, &sz));
+    } else {
+        sz = 0;
+        memError = -109;
+    }
+
+    return sz;
+}
+
+void SetHandleSize(Handle h, SInt32 newSize) {
+    memError = OS_MacError(OS_ResizeHandle(&HS(h)->hand, newSize));
+    FixHandlePtr(h, OS_LockHandle(&HS(h)->hand));
+    OS_UnlockHandle(&HS(h)->hand);
+}
+
+OSErr PtrAndHand(const void *srcPtr, Handle destHandle, SInt32 size) {
+    OSErr err;
+
+    err = OS_MacError(OS_AppendHandle(&HS(destHandle)->hand, srcPtr, size));
+    FixHandlePtr(h, OS_LockHandle(&HS(destHandle)->hand));
+    OS_UnlockHandle(&HS(h)->hand);
+
+    return err;
+}
+
+OSErr PtrToHand(const void *srcPtr, Handle *destHandle, SInt32 size) {
+    *destHandle = NewHandle(size);
+    if (!*destHandle)
+        return MemError();
+
+    HLock(*destHandle);
+    memcpy(**destHandle, srcPtr, size);
+    HUnlock(*destHandle);
+
+    return MemError();
+}
+
+OSErr HandToHand(Handle *destHandle) {
+    Handle srcHandle = *destHandle;
+    SInt32 size;
+
+    size = GetHandleSize(srcHandle);
+    *destHandle = NewHandle(size);
+    if (!*destHandle)
+        return MemError();
+
+    HLock(*destHandle);
+    HLock(srcHandle);
+    memcpy(**destHandle, *srcHandle, size);
+    HUnlock(srcHandle);
+    HUnlock(*destHandle);
+
+    return MemError();
+}
+
+OSErr HandAndHand(Handle src, Handle dst) {
+    OSErr err;
+    SInt32 size;
+
+    HLock(src);
+    size = GetHandleSize(src);
+    err = PtrAndHand(*src, dst, size);
+    HUnlock(src);
+    return err;
+}
+
+void MoveHHi(Handle theHandle) {
+    memError = theHandle ? 0 : -109;
+}
+
+void BlockMove(const void *srcPtr, void *destPtr, UInt32 byteCount) {
+    memmove(destPtr, srcPtr, byteCount);
+}
+
+void BlockMoveData(const void *srcPtr, void *destPtr, UInt32 byteCount) {
+    memmove(destPtr, srcPtr, byteCount);
+}
+
+Ptr NewPtr(SInt32 dataSize) {
+    Ptr p;
+
+    if (!dataSize)
+        dataSize = 1;
+
+    p = malloc(dataSize);
+    memError = p ? 0 : -108;
+    return p;
+}
+
+void DisposePtr(Ptr p) {
+    memError = 0;
+    if (p)
+        free(p);
+}
+
+Ptr NewPtrClear(SInt32 dataSize) {
+    Ptr p;
+
+    memError = -108;
+    if (!dataSize)
+        dataSize = 1;
+
+    p = malloc(dataSize);
+    if (p) {
+        memError = 0;
+        memset(p, 0, dataSize);
+    }
+
+    return p;
+}
+
+void DebugStr(ConstStringPtr str) {
+    fprintf(stderr, "*.*s", str[0], str[1], &str[1]);
+}
+
+struct Zone *HandleZone() {
+    return 0;
+}
+
+struct Zone *ApplicationZone() {
+    return 0;
+}