Lua Stack Module

#include "windows.h"

extern "C" {
#include "math.h"
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "lua/lua.h"
#include "lua/lauxlib.h"
#include "lua/lualib.h"
}

template<typename T> class CStack {
public:
    static enum {CStack_StackEmpty, CStack_BadMemory};

    unsigned int slots()
    {
        return StackSize;
    }

    unsigned int size()
    {
        return StackIter;
    }

    bool empty()
    {
        return StackIter == 0;
    }

    T pop()
    {
        if(StackIter == 0) throw (int)CStack_StackEmpty;

        return _Stack[--StackIter];
    }

    void push(T j)
    {
        if(StackSize >= StackIter && _Stack != 0)
        {
            T* _newstack = (T*)malloc(sizeof(T) * (StackSize + 1));

            if(_newstack == NULL)
            {
                free(_newstack);
                this->~CStack();
                throw (int)CStack_BadMemory;
            }

            for(int i=0;i<StackSize;i++)
                _newstack[i] = _Stack[i];

            free(_Stack);

            _Stack = _newstack;
        }
        else if (_Stack == 0)
        {
            _Stack = (T*)malloc(sizeof(T) * (StackSize == 0 ? 1 : StackSize));
            if(_Stack == 0)
            {
                this->~CStack();
                throw (int)CStack_BadMemory;
            }
        }

        _Stack[StackSize++] = j;

        StackIter = StackSize;

    }

    void clear()
    {
        StackIter = 0;
    }

    CStack()
    {
        StackIter = StackSize = 0;
        _Stack = NULL;
    }

    ~CStack()
    {
        free(_Stack);
        StackIter = StackSize = 0;
    }

private:
    unsigned int StackSize, StackIter;
    T* _Stack;
};

CStack<LUA_NUMBER> *LuaStack = NULL;

extern "C" {
    int __declspec(dllexport) luaopen_stack (lua_State *L);
}

static int luaStack_Create(lua_State *Lua)
{
    if(LuaStack != NULL)
    {
        luaL_error(Lua, "Stack already created!");
        return 0;
    }

    LuaStack = new CStack<LUA_NUMBER>();
    return 0;
}

static int luaStack_Close(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    delete LuaStack;
    LuaStack = NULL;
    return 0;
}

static int luaStack_Push(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    LuaStack->push(lua_tonumber(Lua, 1));
    return 0;
}

static int luaStack_Pop(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    try
    {
        lua_pushnumber(Lua, LuaStack->pop());
    }
    catch (int e)
    {
        switch(e)
        {
        case static_cast<int>(CStack<LUA_NUMBER>::CStack_StackEmpty):
            lua_pushstring(Lua, "Stack is empty!");
            break;
        }
    }
    return 1;
}

static int luaStack_Clear(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    LuaStack->clear();
    return 0;
}

static int luaStack_Size(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    lua_pushnumber(Lua, LuaStack->size());
    return 1;
}

static int luaStack_Empty(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    lua_pushboolean(Lua, LuaStack->empty());
    return 1;
}

static int luaStack_Length(lua_State *Lua)
{
    if(LuaStack == NULL)
    {
        luaL_error(Lua, "Stack is not created!");
        return 0;
    }

    lua_pushnumber(Lua, LuaStack->slots());
    return 1;
}

int __declspec(dllexport) luaopen_stack (lua_State *L) {
    printf("Stack loaded!\n");
    struct luaL_reg driver[] = {
        {"push", luaStack_Push},
        {"pop", luaStack_Pop},
        {"clear", luaStack_Clear},
        {"size", luaStack_Size},
        {"empty", luaStack_Empty},
        {"create", luaStack_Create},
        {"close", luaStack_Close},
        {"length", luaStack_Length},
        {NULL, NULL}
    };

    luaL_openlib (L, "stack", driver, 0);
    return 1;
};