NewtMem.c

説明を見る。

/*------------------------------------------------------------------------*/
/* ヘッダファイル */
#include <string.h>
#include "NewtMem.h"


/*------------------------------------------------------------------------*/
newtPool NewtPoolAlloc(int32_t expandspace)
{
    newtPool    pool;

    pool = (newtPool)calloc(1, sizeof(newtpool_t));

    if (pool != NULL)
    {
        pool->maxspace = pool->expandspace = expandspace;
    }

    return pool;
}


/*------------------------------------------------------------------------*/
void * NewtMemAlloc(newtPool pool, size_t size)
{
    if (pool != NULL)
    {
    }

    return malloc(size);
}


/*------------------------------------------------------------------------*/
void * NewtMemCalloc(newtPool pool, size_t number, size_t size)
{
    if (pool != NULL)
    {
    }

    return calloc(number, size);
}


/*------------------------------------------------------------------------*/
void * NewtMemRealloc(newtPool pool, void * ptr, size_t size)
{
    if (pool != NULL)
    {
    }

    return realloc(ptr, size);
}


/*------------------------------------------------------------------------*/
void NewtMemFree(void * ptr)
{
    free(ptr);
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NewtStackSetup(newtStack * stackinfo,
        newtPool pool, uint32_t datasize, uint32_t blocksize)
{
    memset(stackinfo, 0, sizeof(newtStack));

    stackinfo->pool = pool;
    stackinfo->datasize = datasize;
    stackinfo->blocksize = blocksize;
}


/*------------------------------------------------------------------------*/
void NewtStackFree(newtStack * stackinfo)
{
    if (stackinfo->stackp != NULL)
    {
        NewtMemFree(stackinfo->stackp);
        stackinfo->stackp = NULL;
    }

    stackinfo->nums = 0;
    stackinfo->sp = 0;
}


/*------------------------------------------------------------------------*/
bool NewtStackExpand(newtStack * stackinfo, uint32_t n)
{
    if (stackinfo->nums < n)
    {
        uint32_t    newsize;
        uint32_t    nums;
        void *      newp;
    
        nums = stackinfo->nums + stackinfo->blocksize;
        newsize = stackinfo->datasize * nums;

        newp = NewtMemRealloc(stackinfo->pool, stackinfo->stackp, newsize);

        if (newp == NULL) return false;
    
        stackinfo->stackp = newp;
        stackinfo->nums = nums;
    }

    return true;
}


/*------------------------------------------------------------------------*/
void NewtStackSlim(newtStack * stackinfo, uint32_t n)
{
    if (0 < n)
    {
        uint32_t    newsize;
        void *      newp;

        newsize = stackinfo->datasize * n;
        newp = NewtMemRealloc(stackinfo->pool, stackinfo->stackp, newsize);

        if (newp != NULL)
        {
            stackinfo->stackp = newp;
            stackinfo->nums = n;
        }
    }
    else
    {
        NewtStackFree(stackinfo);
    }
}


#pragma mark -
/*------------------------------------------------------------------------*/
uint32_t NewtAlign(uint32_t n, uint16_t byte)
{
    uint32_t    mod;

    mod = n % byte;
    if (0 < mod) n += byte - mod;

    return n;
}

---