---

palm/stack.c

Go to the documentation of this file.

#include <MemoryMgr.h>
#include <ErrorMgr.h>
#include <FeatureMgr.h>

#include <ui.h>
#include <mem_compat.h>

typedef struct tag_dsobj {
        MemHandle   sh; 
        Int32     *ss; 
        Int32     *sp; 
        Int32     *se; 
        Int32      sl; /*<! Stack Len */
} dsObj;

#define STACK_IMPL
#include <stack.h>

dsObj *
StackNew(void)
{
        dsObj *s = (dsObj *)MemPtrNew(sizeof (dsObj));
        if (s == NULL)
                return (NULL);
        s->sl = 4;
        s->sh = MemHandleNew(s->sl * sizeof (Int32));
        if (s->sh == NULL) {
                MemPtrFree(s);
                return (NULL);
        }

        if ((NULL == (s->ss = (Int32 *)MemHandleLock(s->sh)))) {
                MemHandleFree(s->sh);
                MemPtrFree(s);
                return (NULL);
        }
        s->se = s->ss + (s->sl - 1);
        s->sp = s->ss - 1;
        return (s);
}

void
StackDelete(dsObj *sp)
{
        if (sp->sh) {
                MemHandleUnlock(sp->sh);
                MemHandleFree(sp->sh);
        }
        MemPtrFree(sp);
}

static void
StackResize(dsObj *sp, Int32 newsize)
{
        Int32 sd = sp->sp - sp->ss;
        Int32 sn;
        sp->sl = newsize;
        sn = (Int32)(sp->sl * sizeof (Int32));
        MemHandleUnlock(sp->sh);
        if (errNone != MemHandleResize(sp->sh, (UInt32)sn)) {
                ErrFatalDisplayIf(1, "Resize of myStack Chunk Failed");
        }
        sp->ss = (Int32 *)MemHandleLock(sp->sh);
        sp->se = sp->ss + (sp->sl - 1);
        sp->sp = sp->ss + sd;
}

Int32
StackPop(dsObj *sp)
{
        if (sp->sp >= sp->ss) {
                Int32 rv = *sp->sp--;
                if (((sp->sl >> 2) > (sp->sp - sp->ss)) && (sp->sl > 4))
                        StackResize(sp, sp->sl >> 1);
                return (rv);
        }
        ErrFatalDisplayIf(1, "myStack Underflow");
        return (-1);
}

void
StackPush(dsObj *sp, Int32 elt)
{
        if (sp->sp >= sp->se)
                StackResize(sp, sp->sl << 1);
        *(++sp->sp) = elt;
}

Int8
StackIsEmpty(dsObj *sp)
{
        return ((Int8)(sp->sp < sp->ss));
}

void
StackDoEmpty(dsObj *sp)
{
        sp->sp = sp->ss - 1;
}

Int32
StackNElements(dsObj *sp)
{
        return ((sp->sp+1) - sp->ss);
}

Int32
ListGet(dsObj *sp, Int32 index)
{
        if (index >= (sp->sp - sp->ss))
                return (-1);
        return (sp->ss[index + 1]);
}

void
ListSet(dsObj *sp, Int32 index, Int32 element)
{
        if (index < (sp->sp - sp->ss))
                sp->ss[index + 1] = element;
}

---