MWCC/command_line/CmdLine/Src/MacEmul/Memory.c

#include "cmdline.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)->addr = ptr;
}

Handle OS_CreateMacHandle(OSHandle *h) {
    HandleStructure *hs = malloc(sizeof(HandleStructure));
    if (!hs) {
        memError = memFullErr;
        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 = memFullErr;
        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 = *OS_PeekMacHandle(h);
    free(h);
}

OSErr MemError(void) {
    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) {
    Handle hdl;

    *resultCode = 0;
    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 = nilHandleErr;
    }
}

void HLock(Handle h) {
    void *buffer;

    if (h) {
        buffer = OS_LockHandle(&HS(h)->hand);
        FixHandlePtr(h, buffer);
        memError = 0;
    } else {
        memError = nilHandleErr;
    }
}

void HLockHi(Handle h) {
    HLock(h);
}

void HUnlock(Handle h) {
    if (h) {
        memError = 0;
        OS_UnlockHandle(&HS(h)->hand);
    } else {
        memError = nilHandleErr;
    }
}

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 = nilHandleErr;
    }

    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(destHandle, OS_LockHandle(&HS(destHandle)->hand));
    OS_UnlockHandle(&HS(destHandle)->hand);

    return err;
}

OSErr PtrToHand(const void *srcPtr, Handle *destHandle, SInt32 size) {
    if (!(*destHandle = NewHandle(size)))
        return MemError();

    HLock(*destHandle);
    memcpy(**destHandle, srcPtr, size);
    HUnlock(*destHandle);

    return MemError();
}

OSErr HandToHand(Handle *destHandle) {
    Handle srcHandle = *destHandle;
    SInt32 size;

    size = GetHandleSize(srcHandle);
    if (!(*destHandle = NewHandle(size)))
        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 ? noErr : nilHandleErr;
}

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 ? noErr : memFullErr;
    return p;
}

void DisposePtr(Ptr p) {
    memError = 0;
    if (p)
        free(p);
}

Ptr NewPtrClear(SInt32 dataSize) {
    Ptr p;

    memError = memFullErr;
    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[0], &str[1]);
}

struct Zone *HandleZone(void) {
    return NULL;
}

struct Zone *ApplicationZone(void) {
    return NULL;
}