---

LuaState.h

Go to the documentation of this file.

// This source file is part of the LuaState (Lua Wrapper) source distribution
// and is Copyright 2000-2001 by Joshua C. Jensen (jjensen@workspacewhiz.com).
// The latest version may be obtained from http://www.workspacewhiz.com/.
//
// The code presented in this file may be freely used and modified for all
// non-commercial and commercial purposes.
#pragma once

#include <stdarg.h>
#include <wchar.h>
#include <assert.h>

#pragma warning(disable: 4127)

extern "C" {
#define LUA_PRIVATE

#include "Lua.h"
#include "luadebug.h"
#include "lauxlib.h"
}

class LuaStateOutFile;
class LuaState;

typedef lua_CFunction LuaCFunction;
typedef int (*LuaStateCFunction)(LuaState state);

struct luaState_reg
{
  const lua_char *name;
  union
  {
      LuaStateCFunction luaStateCFunction;
      lua_CFunction luaCFunction;
  };
};

typedef luaState_reg LuaFunctionList;


class LUA_API LuaObject
{
public:
    LuaObject(lua_State* state, int stackIndex) :
        m_state(state),
        m_stackIndex(stackIndex)
    {
    }

    LuaObject(LuaState* state, int stackIndex);

    LuaObject(LuaState& state, int stackIndex);

    LuaObject(const LuaObject& src) :
        m_state(src.m_state),
        m_stackIndex(src.m_stackIndex)
    {
    }

    const LuaObject& operator=(const LuaObject& src)
    {
        m_state = src.m_state;
        m_stackIndex = src.m_stackIndex;
        return *this;
    }

    LuaState GetLuaState() const;
    lua_State* GetState() const         {  return m_state;  }
    operator lua_State*() const         {  return m_state;  }
    operator int() const                {  return m_stackIndex;  }

    const char* GetTypeStr() const      {  return lua_type(m_state, m_stackIndex);  }
    int GetType() const                 {  return lua_rawtag(m_state, m_stackIndex);  }

    bool IsNil() const                  {  return lua_isnil(m_state, m_stackIndex);  }
    bool IsTable() const                {  return lua_istable(m_state, m_stackIndex);  }
    bool IsUserData() const             {  return lua_isuserdata(m_state, m_stackIndex);  }
    bool IsCFunction() const            {  return lua_iscfunction(m_state, m_stackIndex) != 0;  }
    bool IsNumber() const               {  return lua_rawtag(m_state, m_stackIndex) == LUA_TNUMBER;  }
    bool IsString() const               {  return lua_isstring(m_state, m_stackIndex) != 0;  }
    bool IsUString() const              {  return lua_isustring(m_state, m_stackIndex) != 0;  }
    bool IsFunction() const             {  return lua_isfunction(m_state, m_stackIndex);  }
    bool IsNull() const                 {  return lua_isnull(m_state, m_stackIndex);  }
    bool IsPointer() const              {  return lua_ispointer(m_state, m_stackIndex) != 0;  }

    int GetInteger() const              {  return (int)lua_tonumber(m_state, m_stackIndex);  }
    float GetNumber() const             {  return (float)lua_tonumber(m_state, m_stackIndex);  }
    const char* GetString() const
    {
        const char* str = lua_tostring(m_state, m_stackIndex);
        assert(str);
        return str;
    }
    const wchar_t* GetUString() const
    {
        const wchar_t* str = (const wchar_t*)lua_toustring(m_state, m_stackIndex);
        assert(str);
        return str;
    }
    int StrLen() const                  {  return lua_strlen(m_state, m_stackIndex);  }
    LuaCFunction GetCFunction() const   {  return lua_tocfunction(m_state, m_stackIndex);  }
    void* GetUserData() const           {  return lua_touserdata(m_state, m_stackIndex);  }
    const void* GetLuaPointer() const   {  return lua_topointer(m_state, m_stackIndex);  }
    const void* GetPointer() const      {  return lua_getpointer(m_state, m_stackIndex);  }

    void Push()                         {  lua_pushvalue(m_state, m_stackIndex);  }
    void Pop()                          {  lua_remove(m_state, m_stackIndex);  }

    LuaObject GetMethods()              {  lua_getmethods(m_state, m_stackIndex);  return LuaObject(m_state, lua_gettop(m_state));  }
    void SetMethods()                   {  lua_setmethods(m_state, m_stackIndex);  }

    void SetTable()                     {  lua_settable(m_state, m_stackIndex);  }
    int Tag()                           {  return lua_tag(m_state, m_stackIndex);  }
    int GetCount()                      {  return lua_getn(m_state, m_stackIndex);  }


    LuaObject CreateTable(const char* name, int size = 0)
    {
        lua_newtablesize(m_state, size);                    // T
        lua_pushstring(m_state, name);                      // T name
        lua_pushvalue(m_state, lua_gettop(m_state) - 1);    // T name T
        lua_settable(m_state, m_stackIndex);

        return LuaObject(m_state, lua_gettop(m_state));
    }
    
    LuaObject CreateTable(int index, int size = 0)
    {
        lua_newtablesize(m_state, size);                    // T
        lua_pushnumber(m_state, index);                     // T name
        lua_pushvalue(m_state, lua_gettop(m_state) - 1);    // T name T
        lua_settable(m_state, m_stackIndex);

        return LuaObject(m_state, lua_gettop(m_state));
    }
    
    void SetNil(const char* name)
    {
        lua_pushstring(m_state, name);
        lua_pushnil(m_state);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetNil(int index)
    {
        lua_pushnumber(m_state, index);
        lua_pushnil(m_state);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetNumber(const char* name, double value)
    {
        lua_pushstring(m_state, name);
        lua_pushnumber(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetNumber(int index, double value)
    {
        lua_pushnumber(m_state, index);
        lua_pushnumber(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetString(const char* name, const char* value)
    {
        lua_pushstring(m_state, name);
        lua_pushstring(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetString(int index, const char* value)
    {
        lua_pushnumber(m_state, index);
        lua_pushstring(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetString(const char* name, const wchar_t* value)
    {
        lua_pushstring(m_state, name);
        lua_pushustring(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetString(int index, const wchar_t* value)
    {
        lua_pushnumber(m_state, index);
        lua_pushustring(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }
    
    void SetUserData(const char* name, void* value)
    {
        lua_pushstring(m_state, name);
        lua_newuserdatabox(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    void SetUserData(int index, void* value)
    {
        lua_pushnumber(m_state, index);
        lua_newuserdatabox(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    void SetPointer(const char* name, const void* value)
    {
        lua_pushstring(m_state, name);
        lua_pushpointer(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    void SetPointer(int index, const void* value)
    {
        lua_pushnumber(m_state, index);
        lua_pushpointer(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    void SetObject(const char* name, LuaObject value)
    {
        lua_pushstring(m_state, name);
        lua_pushvalue(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    void SetObject(int index, LuaObject value)
    {
        lua_pushnumber(m_state, index);
        lua_pushvalue(m_state, value);
        lua_settable(m_state, m_stackIndex);
    }

    LuaObject GetByName(const char* name)
    {
        lua_pushstring(m_state, name);
        lua_rawget(m_state, m_stackIndex);
        return LuaObject(m_state, lua_gettop(m_state));
    }

    LuaObject GetByIndex(int index)
    {
        lua_rawgeti(m_state, m_stackIndex, index);
        return LuaObject(m_state, lua_gettop(m_state));
    }

    void Register(const char* funcName, lua_CFunction function)
    {
        lua_pushstring(m_state, funcName);
        lua_pushcclosure(m_state, (lua_CFunction)function, 0);
        lua_settable(m_state, m_stackIndex);
    }

    void Register(const char* funcName, LuaStateCFunction function)
    {
        lua_pushstring(m_state, funcName);
        lua_pushcclosure(m_state, (lua_CFunction)function, 0);
        lua_settable(m_state, m_stackIndex);
    }

    void Register(const LuaFunctionList* functionList)
    {
        int i = 0;
        while (true)
        {
            if (!functionList[i].name)
                break;
            Register(functionList[i].name, functionList[i].luaStateCFunction);
            i++;
        }
    }

    void Unregister(const char* funcName)
    {
        lua_pushstring(m_state, funcName);
        lua_pushnil(m_state);
        lua_settable(m_state, m_stackIndex);
    }

    void Unregister(const LuaFunctionList* functionList)
    {
        int i = 0;
        while (true)
        {
            if (!functionList[i].name)
                break;
            Unregister(functionList[i].name);
            i++;
        }
    }

protected:
    friend class LuaState;

    lua_State* m_state;     
    int m_stackIndex;       
};


class LUA_API LuaState
{
public:
    enum { NOREF = LUA_NOREF };
    enum { REFNIL = LUA_REFNIL };

    LuaState(lua_State* state);
    ~LuaState() {};

    LuaObject GetMethods(int index)             {  lua_getmethods(m_state, index);  return LuaObject(this, lua_gettop(m_state));  }
    LuaObject GetDefaultMethods(int type)       {  lua_getdefaultmethods(m_state, type);  return LuaObject(this, lua_gettop(m_state));  }
    void SetMethods(int index)                  {  lua_setmethods(m_state, index);  }

    // Basic stack manipulation.
    int GetTop()                                {  return lua_gettop(m_state);  }
    void SetTop(int index)                      {  lua_settop(m_state, index);  }
    void PushValue(int index)                   {  lua_pushvalue(m_state, index);  }
    void PushValue(LuaObject object)            {  lua_pushvalue(m_state, object);  }
    void RemoveStack(int index)                 {  lua_remove(m_state, index);  }
    void InsertStack(int index)                 {  lua_insert(m_state, index);  }
    int StackSpace()                            {  return lua_stackspace(m_state);  }

    // access functions (stack -> C)
    const lua_char *Type(int index)             {  return lua_type(m_state, index);  }
    int IsNumber(int index)                     {  return lua_isnumber(m_state, index);  }
    int IsString(int index)                     {  return lua_isstring(m_state, index);  }
    int IsUString(int index)                    {  return lua_isustring(m_state, index);  }
    int IsCFunction(int index)                  {  return lua_iscfunction(m_state, index);  }
    bool IsFunction(int index)                  {  return lua_isfunction(m_state, index);  }
    bool IsTable(int index)                     {  return lua_istable(m_state, index);  }
    bool IsUserData(int index)                  {  return lua_isuserdata(m_state, index);  }
    bool IsNil(int index)                       {  return lua_isnil(m_state, index);  }
    bool IsNull(int index)                      {  return lua_isnull(m_state, index);  }
    bool IsPointer(int index) const             {  return lua_ispointer(m_state, index) != 0;  }
    int Tag(int index)                          {  return lua_tag(m_state, index);  }
    int RawTag(int index)                       {  return lua_rawtag(m_state, index);  }

    int Equal(int index1, int index2)           {  return lua_equal(m_state, index1, index2);  }
    int LessThan(int index1, int index2)        {  return lua_lessthan(m_state, index1, index2);  }

    lua_Number ToNumber(int index)              {  return lua_tonumber(m_state, index);  }
    int ToInteger(int index)                    {  return (int)lua_tonumber(m_state, index);  }
    const lua_char* ToString(int index)         {  return lua_tostring(m_state, index);  }
    const wchar_t* ToUString(int index)         {  return lua_toustring(m_state, index);  }
    size_t StrLen(int index)                    {  return lua_strlen(m_state, index);  }
    lua_CFunction ToCFunction(int index)        {  return lua_tocfunction(m_state, index);  }
    void *ToUserData(int index)                 {  return lua_touserdata(m_state, index);  }
    const void* ToPointer(int index)            {  return lua_getpointer(m_state, index);  }
    const void *ToLuaPointer(int index)         {  return lua_topointer(m_state, index);  }

    // push functions (C -> stack)
    void PushBool(bool value)                   {  if (value)  lua_pushnumber(m_state, 1);  else  lua_pushnil(m_state);  }
    void PushNil()                              {  lua_pushnil(m_state);  }
    void PushNumber(double n)                   {  lua_pushnumber(m_state, n);  }
    void PushLString(const char *s, size_t len) {  lua_pushlstring(m_state, s, len);  }
    void PushString(const char *s)              {  lua_pushstring(m_state, s);  }
    void PushLUString(const wchar_t* s, size_t len){  lua_pushlustring(m_state, s, len);  }
    void PushUString(const wchar_t* s)          {  lua_pushustring(m_state, s);  }
    void PushCClosure(lua_CFunction fn, int n)  {  lua_pushcclosure(m_state, fn, n);  }
    void PushCClosure(LuaStateCFunction fn, int n)  {  lua_pushcclosure(m_state, (lua_CFunction)fn, n);  }
    void PushPointer(const void* p)             {  lua_pushpointer(m_state, p);  }

    // get functions (Lua -> stack)
    LuaObject GetGlobal(const char *name)       {  lua_getglobal(m_state, name);  return LuaObject(*this, GetTop());  }
    void GetTable(int index)                    {  lua_gettable(m_state, index);  }
    void RawGet(int index)                      {  lua_rawget(m_state, index);  }
    void RawGetI(int index, int n)              {  lua_rawgeti(m_state, index, n);  }
    LuaObject GetGlobals()                      {  lua_getglobals(m_state);  return LuaObject(*this, GetTop());  }
    void GetTagMethod(int tag, const char *event)   {  lua_gettagmethod(m_state, tag, event);  }
    LuaObject GetRef(int ref)                   {  lua_getref(m_state, ref);  return LuaObject(*this, GetTop());  }
    LuaObject NewTable(int size = 0)            {  lua_newtablesize(m_state, size);  return LuaObject(*this, GetTop());  }
    void GetRegistry()                          {  lua_getregistry(m_state);  }
    void GetWeakRegistry()                      {  lua_getweakregistry(m_state);  }

    // set functions(stack -> Lua)
    void SetGlobal(const char *name)            {  lua_setglobal(m_state, name);  }
    void SetTable(int index)                    {  lua_settable(m_state, index);  }
    void RawSet(int index)                      {  lua_rawset(m_state, index);  }
    void RawSetI(int index, int n)              {  lua_rawseti(m_state, index, n);  }
    void SetGlobals()                           {  lua_setglobals(m_state);  }
    void SetTagMethod(int tag, const char *event)   {  lua_settagmethod(m_state, tag, event);  }
    int Ref(int lock)                           {  return lua_ref(m_state, lock);  }

    // `load' and `do' functions (load and run Lua code)
    int Call(int nargs, int nresults)           {  return lua_call(m_state, nargs, nresults);  }
    void RawCall(int nargs, int nresults)       {  lua_rawcall(m_state, nargs, nresults);  }
    int LoadFile(const lua_char* filename)      {  return lua_loadfile(m_state, filename);  }
    int DoFile(const char *filename)            {  return lua_dofile(m_state, filename);  }
    int DoString(const char *str)               {  return lua_dostring(m_state, str);  }
    int LoadBuffer(const lua_char* buff, size_t size, const lua_char* name)
    {
        return lua_loadbuffer(m_state, buff, size, name);
    }
    int DoBuffer(const char *buff, size_t size, const char *name)
    {
        return lua_dobuffer(m_state, buff, size, name);
    }

    // Garbage-collection functions
    int GetGCThreshold()                        {  return lua_getgcthreshold(m_state);  }
    int GetGCCount()                            {  return lua_getgccount(m_state);  }
    void SetGCThreshold(int newthreshold)       {  lua_setgcthreshold(m_state, newthreshold);  }

    // Miscellaneous functions
    int NewType(const lua_char *name, int basictype)    {  return lua_newtype(m_state, name, basictype);  }
    int CopyTagMethods(int tagto, int tagfrom)  {  return lua_copytagmethods(m_state, tagto, tagfrom);  }
    void SetTag(int tag)                        {  lua_settag(m_state, tag);  }

    int Name2Tag(const lua_char* name)          {  return lua_name2tag(m_state, name);  }
    const lua_char* Tag2Name(int tag)           {  return lua_tag2name(m_state, tag);  }

    void Error(const lua_char* errorStr)        {  lua_error(m_state, errorStr);  }

    void Unref(int ref)                         {  lua_unref(m_state, ref);  }

    int Next(int index)                         {  return lua_next(m_state, index);  }
    int GetN(int index)                         {  return lua_getn(m_state, index);  }

    void Concat(int n)                          {  lua_concat(m_state, n);  }

    void PushUserData(void* u);
    void* NewUserData(size_t size)              {  return lua_newuserdata(m_state, size);  }
    void NewUserDataBox(void* u)                {  lua_newuserdatabox(m_state, u);  }

    void SetWeakMode(int mode)                  {  lua_setweakmode(m_state, mode);  }
    int GetWeakMode(int index)                  {  return lua_getweakmode(m_state, index);  }


    // Helper functions
    void Pop()                                  {  lua_pop(m_state, 1);  }
    void Pop(int amount)                        {  lua_pop(m_state, amount);  }

    void Register(const char* funcName, lua_CFunction function)  {  lua_register(m_state, funcName, function);  }
    void Register(const char* funcName, LuaStateCFunction function)
    {
        lua_pushcfunction(m_state, (lua_CFunction)function);
        lua_setglobal(m_state, funcName);
    }

    void Unregister(const char* funcName)
    {
        LuaObject globals = GetGlobals();
        lua_pushstring(m_state, funcName);
        lua_pushnil(m_state);
        lua_settable(m_state, globals);
    }

    void Register(const LuaFunctionList* functionList)
    {
        int i = 0;
        while (true)
        {
            if (!functionList[i].name)
                break;
            Register(functionList[i].name, functionList[i].luaStateCFunction);
            i++;
        }
    }


    void Unregister(const LuaFunctionList* functionList)
    {
        int i = 0;
        while (true)
        {
            if (!functionList[i].name)
                break;
            Unregister(functionList[i].name);
            i++;
        }
    }

    void PushCFunction(lua_CFunction f)         {  lua_pushcclosure(m_state, f, 0);  }
    void PushCFunction(LuaStateCFunction f)     {  lua_pushcclosure(m_state, (lua_CFunction)f, 0);  }
    int CloneTag(int t)                         {  return lua_copytagmethods(m_state, lua_newtag(m_state), t);  }

    void CollectGarbage()                       {  lua_setgcthreshold(m_state, 0);  }   

    void SetNilGCMethod(LuaStateCFunction f)
    {  
        PushNil();
        PushCFunction(f);
        SetTagMethod(Tag(-2), "gc");
        Pop();
    }
    
    int ConfigGetInteger(const char* section, const char* entry, int defaultValue = 0);
    float ConfigGetReal(const char* section, const char* entry, double defaultValue = 0.0);
    const char* ConfigGetString(const char* section, const char* entry, const char* defaultValue = "");
    void ConfigSetInteger(const char* section, const char* entry, int value);
    void ConfigSetReal(const char* section, const char* entry, double value);
    void ConfigSetString(const char* section, const char* entry, const char* value);

    void WriteLuaGlobalsFile(const char* filename, bool writeAll = false, bool alphabetical = false,
                        bool writeTablePointers = false, unsigned int maxIndentLevel = 0xffffffff);
    void WriteLuaFile(const char* filename, const char* name, LuaObject value,
                         int indentLevel, bool writeAll = false,
                         bool alphabetical = false, bool writeTablePointers = false,
                         unsigned int maxIndentLevel = 0xffffffff);
    bool WriteLuaObject(LuaStateOutFile& file, const char* name, LuaObject value,
                         int indentLevel, bool writeAll = false,
                         bool alphabetical = false, bool writeTablePointers = false,
                         unsigned int maxIndentLevel = 0xffffffff);
    bool WriteLuaObject(FILE* file, const char* name, LuaObject value,
                         int indentLevel, bool writeAll = false,
                         bool alphabetical = false, bool writeTablePointers = false,
                         unsigned int maxIndentLevel = 0xffffffff);

    operator lua_State*()                       {  return m_state;  }

public:
    lua_State* m_state;

protected:
    LuaState() {}
};


class LUA_API LuaStateOwner : public LuaState
{
public:
    LuaStateOwner(bool initStandardLibrary = true, unsigned long stackSize = 0, bool multithreaded = false);
    LuaStateOwner(LuaState& script, bool initStandardLibrary = true, unsigned long stackSize = 0);
    ~LuaStateOwner();

protected:
    void Init(bool initStandardLibrary, unsigned long stackSize);
};



class LuaAutoBlock
{
public:
    LuaAutoBlock(lua_State* state) :
        m_state(state)
    {
        m_stackTop = lua_gettop(m_state);
    }

    LuaAutoBlock(LuaState* state) :
        m_state(*state)
    {
        m_stackTop = lua_gettop(m_state);
    }

    LuaAutoBlock(LuaState& state) :
        m_state(state)
    {
        m_stackTop = lua_gettop(m_state);
    }

    LuaAutoBlock(LuaObject& object) :
        m_state(object)
    {
        m_stackTop = lua_gettop(m_state);
    }

    ~LuaAutoBlock()
    {
        lua_settop(m_state, m_stackTop);
    }

private:
    LuaAutoBlock(const LuaAutoBlock& src);                  // Not implemented
    const LuaAutoBlock& operator=(const LuaAutoBlock& src); // Not implemented

    lua_State* m_state;
    int m_stackTop;
};


inline LuaState::LuaState(lua_State* state)
{
    m_state = state;
}


inline LuaStateOwner::~LuaStateOwner()
{
    lua_close(m_state);
}


inline LuaObject::LuaObject(LuaState* state, int stackIndex) :
    m_state(*state),
    m_stackIndex(stackIndex)
{
}


inline LuaObject::LuaObject(LuaState& state, int stackIndex) :
    m_state(state),
    m_stackIndex(stackIndex)
{
}

    
inline LuaState LuaObject::GetLuaState() const
{
    return LuaState(m_state);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Output file helper class.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class LUA_API LuaStateOutFile
{
public:
    LuaStateOutFile() : m_file(NULL), m_fileOwner(false) {}
    virtual ~LuaStateOutFile()
    {
        if (m_file  &&  m_fileOwner)
            fclose(m_file);
    }

    virtual bool Open(const char* fileName)
    {
        Close();

        m_file = fopen(fileName, "wb");
        m_fileOwner = true;

        return true;
    }

    virtual void Close()
    {
        if (m_file  &&  m_fileOwner)
            fclose(m_file);
    }

    virtual void Print(const char* str, ...)
    {
        char message[800];
        va_list arglist;

        va_start(arglist, str);
        vsprintf(message, str, arglist);
        va_end(arglist);

        fputs(message, m_file);
    }

    bool Assign(FILE* file)
    {
        m_file = file;
        m_fileOwner = false;

        return true;
    }
    
protected:
    FILE* m_file;
    bool m_fileOwner;
};

---