[Easycalc-commits] PPCport/compat MemoryManager.cpp, NONE, 1.1 MemoryManager.h, NONE, 1.1

[Mapi B. <ma...@us...>]

Update of /cvsroot/easycalc/PPCport/compat
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv22333

Added Files:
	MemoryManager.cpp MemoryManager.h 
Log Message:
More complex DataManager, and some other updates

--- NEW FILE: MemoryManager.h ---
#pragma once

#ifndef MEM_MANAGER_H
#define MEM_MANAGER_H 1

#include "PalmOS.h"

typedef void *MemPtr;

class c_MemHandle {
public:
//    int   size;
    void *memPtr;
    int   lock;

    c_MemHandle(void);
    ~c_MemHandle(void);
    int serialize(FILE *f);
    int deSerialize(FILE *f);
};

typedef c_MemHandle *MemHandle;

#define MemPtrNew   malloc
#define MemPtrFree  free

MemHandle MemHandleNew (UInt32 size);
Err MemHandleFree (MemHandle h);
MemPtr MemHandleLock (MemHandle h);
Err MemHandleUnlock (MemHandle h);
UInt32 MemHandleSize (MemHandle h);
Err MemHandleResize (MemHandle h, UInt32 newSize);

#endif
--- NEW FILE: MemoryManager.cpp ---
#include "StdAfx.h"
#include "compat/PalmOS.h"
#include "MemoryManager.h"

c_MemHandle::c_MemHandle(void) {
//    size   = 0;
    memPtr = NULL;
    lock   = 0;
}

c_MemHandle::~c_MemHandle(void) {
    if (memPtr != NULL)
        free(memPtr);
}

/***********************************************************************
 * Store the c_MemHandle object to a file, in binary mode.
 ***********************************************************************/
int c_MemHandle::serialize(FILE *f) {
//    size   = 0;
    if (fwrite(&memPtr, sizeof(memPtr), 1, f) != 1)
        return (-1);
    if (fwrite(&lock, sizeof(lock), 1, f) != 1)
        return (-1);
    if (memPtr != 0) {
        size_t siz = _msize(memPtr);
        if (fwrite(&siz, sizeof(siz), 1, f) != 1)
            return (-1);
        if (fwrite(memPtr, siz, 1, f) != 1)
            return (-1);
    }

    return (0);
}

/***********************************************************************
 * Retrieve the c_MemHandle object from a file, in binary mode.
 ***********************************************************************/
int c_MemHandle::deSerialize(FILE *f) {
//    size   = 0;
    if (fread(&memPtr, sizeof(memPtr), 1, f) != 1)
        return (-1);
    if (fread(&lock, sizeof(lock), 1, f) != 1)
        return (-1);
    if (memPtr != 0) {
        size_t siz;
        if (fread(&siz, sizeof(siz), 1, f) != 1)
            return (-1);
        memPtr = malloc(siz);
        if (fread(memPtr, siz, 1, f) != 1)
            return (-1);
    }

    return (0);
}

MemHandle MemHandleNew (UInt32 size) {
    MemHandle h = new c_MemHandle;
    if (h != NULL) {
        if ((h->memPtr = malloc(size)) != NULL) {
//            h->size = size;
        } else {
            delete h;
            h = NULL;
        }        
    }
    return (h);
}

Err MemHandleFree (MemHandle h) {
    delete h;
    return (0);
}

MemPtr MemHandleLock (MemHandle h) {
    h->lock++;
    return (h->memPtr);
}

Err MemHandleUnlock (MemHandle h) {
    if (h->lock > 0)   h->lock--;
    return (0);
}

UInt32 MemHandleSize (MemHandle h) {
    if (h->memPtr == NULL)   return (0);
    else   return (_msize(h->memPtr));
}

Err MemHandleResize (MemHandle h, UInt32 newSize) {
    if (h->lock > 0)
        return (-1);
    h->memPtr = realloc(h->memPtr, newSize);
    if ((newSize != 0) && (h->memPtr == NULL))
        return (-2);
    return (0);
}