LuaState.h

Go to the documentation of this file.

 
// LuaState.h
 
// Declares the cLuaState class representing the wrapper over lua_State *, provides associated helper functions
 
/*
The contained lua_State can be either owned or attached.
Owned lua_State is created by calling Create() and the cLuaState automatically closes the state
Or, lua_State can be attached by calling Attach(), the cLuaState doesn't close such a state
If owning a state, trying to attach a state will automatically close the previously owned state.
 
Calling a Lua function is done internally by pushing the function using PushFunction(), then pushing the
arguments and finally executing CallFunction(). cLuaState automatically keeps track of the number of
arguments and the name of the function (for logging purposes). After the call the return values are read from
the stack using GetStackValue(). All of this is wrapped in a templated function overloads cLuaState::Call().
 
Reference management is provided by the cLuaState::cRef class. This is used when you need to hold a reference to
any Lua object across several function calls. The class is RAII-like, with automatic resource management. Note
that the cRef object is not inherently thread-safe and is not notified when its cLuaState is closed. For those
purposes, cTrackedRef can be used.
 
Callbacks management is provided by the cLuaState::cCallback class. Use a GetStackValue() with cCallbackPtr
parameter to store the callback, and then at any time you can use the cCallback's Call() templated function
to call the callback. The callback management takes care of cLuaState being destroyed - the cCallback object
stays valid but doesn't call into Lua code anymore, returning false for "failure" instead.
*/
 
 
 
 
#pragma once
 
extern "C"
{
    #include "lua/src/lauxlib.h"
}
 
#include "../Defines.h"
#include "../FunctionRef.h"
#include "../Registries/CustomStatistics.h"
#include "PluginManager.h"
#include "LuaState_Typedefs.inc"
 
// fwd:
class cLuaServerHandle;
class cLuaTCPLink;
class cLuaUDPEndpoint;
class cDeadlockDetect;
 
 
 
 
 
class cLuaState
{
public:
 
    #ifndef NDEBUG
        class cStackBalanceCheck
        {
        public:
            cStackBalanceCheck(const char * a_FileName, int a_LineNum, lua_State * a_LuaState, bool a_ShouldLogStack = true):
                m_FileName(a_FileName),
                m_LineNum(a_LineNum),
                m_LuaState(a_LuaState),
                m_StackPos(lua_gettop(a_LuaState))
            {
                if (a_ShouldLogStack)
                {
                    // DEBUG: If an unbalanced stack is reported, uncommenting the next line can help debug the imbalance
                    // cLuaState::LogStackValues(a_LuaState, fmt::format(FMT_STRING("Started checking Lua stack balance, currently {} items:"), m_StackPos).c_str());
                    // Since LogStackValues() itself uses the balance check, we must not call it recursively
                }
            }
 
            ~cStackBalanceCheck() noexcept(false)
            {
                auto currStackPos = lua_gettop(m_LuaState);
                if (currStackPos != m_StackPos)
                {
                    LOGD("Lua stack not balanced. Expected %d items, found %d items. Stack watching started in %s:%d",
                        m_StackPos, currStackPos,
                        m_FileName.c_str(), m_LineNum
                    );
                    cLuaState::LogStackValues(m_LuaState);
                    ASSERT(!"Lua stack unbalanced");  // If this assert fires, the Lua stack is inbalanced, check the callstack / m_FileName / m_LineNum
                }
            }
 
        protected:
            const AString m_FileName;
            int m_LineNum;
            lua_State * m_LuaState;
            int m_StackPos;
        };
 
        #define STRINGIFY2(X, Y) X##Y
        #define STRINGIFY(X, Y) STRINGIFY2(X, Y)
        #define ASSERT_LUA_STACK_BALANCE(...) cStackBalanceCheck STRINGIFY(Check, __COUNTER__)(__FILE__, __LINE__, __VA_ARGS__)
    #else
        #define ASSERT_LUA_STACK_BALANCE(...)
    #endif
 
 
    class cStackBalancePopper
    {
    public:
        cStackBalancePopper(cLuaState & a_LuaState):
            m_LuaState(a_LuaState),
            m_Count(lua_gettop(a_LuaState))
        {
        }
 
        ~cStackBalancePopper() noexcept(false)
        {
            auto curTop = lua_gettop(m_LuaState);
            if (curTop > m_Count)
            {
                // There are some leftover elements, adjust the stack:
                m_LuaState.LogStackValues(fmt::format(FMT_STRING("Re-balancing Lua stack, expected {} values, got {}:"), m_Count, curTop).c_str());
                lua_pop(m_LuaState, curTop - m_Count);
            }
            else if (curTop < m_Count)
            {
                // This is an irrecoverable error, rather than letting the Lua engine crash undefinedly later on, abort now:
                LOGERROR("Unable to re-balance Lua stack, there are elements missing. Expected at least %d elements, got %d.", m_Count, curTop);
                throw std::runtime_error(fmt::format(FMT_STRING("Unable to re-balance Lua stack, there are elements missing. Expected at least {} elements, got {}."), m_Count, curTop));
            }
        }
 
    protected:
        cLuaState & m_LuaState;
        int m_Count;
    };
 
 
    class cLock
    {
    public:
        cLock(cLuaState & a_LuaState):
            m_Lock(a_LuaState.m_CS)
        {
        }
    protected:
        cCSLock m_Lock;
    };
 
 
    class cRef
    {
    public:
        cRef(void);
 
        cRef(cLuaState & a_LuaState, int a_StackPos);
 
        cRef(cRef && a_FromRef);
 
        ~cRef();
 
        void RefStack(cLuaState & a_LuaState, int a_StackPos);
 
        void UnRef(void);
 
        bool IsValid(void) const {return (m_Ref != LUA_REFNIL); }
 
        explicit operator int(void) const { return m_Ref; }
 
        lua_State * GetLuaState(void) { return m_LuaState; }
 
        template <typename T> void CreateFromObject(cLuaState & a_LuaState, T && a_Object)
        {
            a_LuaState.Push(std::forward<T>(a_Object));
            RefStack(a_LuaState, -1);
            a_LuaState.Pop();
        }
 
    protected:
        lua_State * m_LuaState;
        int m_Ref;
 
        // Remove the copy-constructor:
        cRef(const cRef &) = delete;
    } ;
 
 
    class cTrackedRef
    {
        friend class ::cLuaState;
    public:
        cTrackedRef(void);
 
        ~cTrackedRef()
        {
            Clear();
        }
 
        bool RefStack(cLuaState & a_LuaState, int a_StackPos);
 
        void Clear(void);
 
        bool IsValid(void);
 
        bool IsSameLuaState(cLuaState & a_LuaState);
 
    protected:
        friend class cLuaState;
 
        std::atomic<cCriticalSection *> m_CS;
 
        cRef m_Ref;
 
 
        void Invalidate(void);
 
        cRef & GetRef() { return m_Ref; }
 
        cTrackedRef(const cTrackedRef &) = delete;
 
        cTrackedRef(cTrackedRef &&) = delete;
    };
    typedef std::unique_ptr<cTrackedRef> cTrackedRefPtr;
    typedef std::shared_ptr<cTrackedRef> cTrackedRefSharedPtr;
 
 
    class cCallback:
        public cTrackedRef
    {
        using Super = cTrackedRef;
 
    public:
 
        cCallback(void) {}
 
        template <typename... Args>
        bool Call(Args &&... args)
        {
            auto cs = m_CS.load();
            if (cs == nullptr)
            {
                return false;
            }
            cCSLock Lock(*cs);
            if (!m_Ref.IsValid())
            {
                return false;
            }
            return cLuaState(m_Ref.GetLuaState()).Call(m_Ref, std::forward<Args>(args)...);
        }
 
        bool RefStack(cLuaState & a_LuaState, int a_StackPos);
 
    protected:
 
        cCallback(const cCallback &) = delete;
 
        cCallback(cCallback &&) = delete;
    };
    typedef std::unique_ptr<cCallback> cCallbackPtr;
    typedef std::shared_ptr<cCallback> cCallbackSharedPtr;
 
 
    class cOptionalCallback:
        public cCallback
    {
        using Super = cCallback;
 
    public:
 
        cOptionalCallback(void) {}
 
        bool RefStack(cLuaState & a_LuaState, int a_StackPos);
 
    protected:
 
        cOptionalCallback(const cOptionalCallback &) = delete;
 
        cOptionalCallback(cOptionalCallback &&) = delete;
    };
    typedef std::unique_ptr<cOptionalCallback> cOptionalCallbackPtr;
 
 
    class cTableRef:
        public cTrackedRef
    {
        using Super = cTrackedRef;
 
    public:
        cTableRef(void) {}
 
        template <typename... Args>
        bool CallTableFn(const char * a_FnName, Args &&... args)
        {
            auto cs = m_CS.load();
            if (cs == nullptr)
            {
                return false;
            }
            cCSLock Lock(*cs);
            if (!m_Ref.IsValid())
            {
                return false;
            }
            return cLuaState(m_Ref.GetLuaState()).CallTableFn(m_Ref, a_FnName, std::forward<Args>(args)...);
        }
 
        template <typename... Args>
        bool CallTableFnWithSelf(const char * a_FnName, Args &&... args)
        {
            auto cs = m_CS.load();
            if (cs == nullptr)
            {
                return false;
            }
            cCSLock Lock(*cs);
            if (!m_Ref.IsValid())
            {
                return false;
            }
            return cLuaState(m_Ref.GetLuaState()).CallTableFn(m_Ref, a_FnName, m_Ref, std::forward<Args>(args)...);
        }
 
        bool RefStack(cLuaState & a_LuaState, int a_StackPos);
    };
    typedef std::unique_ptr<cTableRef> cTableRefPtr;
 
 
    template <typename T>
    class cOptionalParam
    {
    public:
        explicit cOptionalParam(T & a_Dest):
            m_Dest(a_Dest)
        {
        }
 
        T & GetDest(void) { return m_Dest; }
 
    protected:
        T & m_Dest;
    };
 
 
    class cRet
    {
    } ;
    static const cRet Return;  // Use this constant to delimit function args from return values for cLuaState::Call()
 
 
    class cNil
    {
    };
    static const cNil Nil;  // Use this constant to give a function a nil parameter in Call()
 
 
    class cStackValue
    {
    public:
        cStackValue(void):
            m_LuaState(nullptr)
        {
        }
 
        cStackValue(cLuaState & a_LuaState):
            m_LuaState(a_LuaState)
        {
            m_StackLen = lua_gettop(a_LuaState);
        }
 
        cStackValue(cStackValue && a_Src):
            m_LuaState(nullptr),
            m_StackLen(-1)
        {
            std::swap(m_LuaState, a_Src.m_LuaState);
            std::swap(m_StackLen, a_Src.m_StackLen);
        }
 
        ~cStackValue() noexcept(false)
        {
            if (m_LuaState != nullptr)
            {
                ASSERT(m_StackLen == lua_gettop(m_LuaState));
                lua_pop(m_LuaState, 1);
            }
        }
 
        void Set(cLuaState & a_LuaState)
        {
            m_LuaState = a_LuaState;
            m_StackLen = lua_gettop(a_LuaState);
        }
 
        bool IsValid(void) const
        {
            return (m_LuaState != nullptr);
        }
 
    protected:
        lua_State * m_LuaState;
 
        int m_StackLen;
 
        // Remove the copy-constructor:
        cStackValue(const cStackValue &) = delete;
    };
 
 
    class cStackTable
    {
    public:
        cStackTable(cLuaState & a_LuaState, int a_StackPos);
 
        void ForEachArrayElement(cFunctionRef<bool(cLuaState & a_LuaState, int a_Index)> a_ElementCallback) const;
 
        void ForEachElement(cFunctionRef<bool(cLuaState & a_LuaState)> a_ElementCallback) const;
 
        cLuaState & GetLuaState(void) const { return m_LuaState; }
 
    protected:
        cLuaState & m_LuaState;
 
        int m_StackPos;
    };
    typedef std::unique_ptr<cStackTable> cStackTablePtr;
 
 
    cLuaState(const AString & a_SubsystemName);
 
    explicit cLuaState(lua_State * a_AttachState);
 
    ~cLuaState();
 
    operator lua_State * (void) { return m_LuaState; }
 
    void Create(void);
 
    void RegisterAPILibs(void);
 
    void Close(void);
 
    void Attach(lua_State * a_State);
 
    void Detach(void);
 
    bool IsValid(void) const { return (m_LuaState != nullptr); }
 
    AString GetSubsystemName(void) const { return m_SubsystemName; }
 
    void AddPackagePath(const AString & a_PathVariable, const AString & a_Path);
 
    bool LoadFile(const AString & a_FileName, bool a_LogWarnings = true);
 
    bool LoadString(const AString & a_StringToLoad, const AString & a_FileName, bool a_LogWarnings = true);
 
    bool HasFunction(const char * a_FunctionName);
 
    template <typename Arg1, typename Arg2, typename... Args>
    void Push(Arg1 && a_Arg1, Arg2 && a_Arg2, Args &&... a_Args)
    {
        Push(std::forward<Arg1>(a_Arg1));
        Push(std::forward<Arg2>(a_Arg2), std::forward<Args>(a_Args)...);
    }
 
    // Push a const value onto the stack (keep alpha-sorted):
    // Note that these functions will make a copy of the actual value, because Lua doesn't have the concept
    // of "const", and there would be lifetime management problems if they didn't.
    void Push(const AString & a_String);
    void Push(const AStringMap & a_Dictionary);
    void Push(const AStringVector & a_Vector);
    void Push(const char * a_Value);
    void Push(const cItem & a_Item);
    void Push(const cNil & a_Nil);
    void Push(const cRef & a_Ref);
    void Push(ContiguousByteBufferView a_Data);
    void Push(const Vector3d & a_Vector);
    void Push(const Vector3i & a_Vector);
 
    // Push a simple value onto the stack (keep alpha-sorted):
    void Push(bool a_Value);
    void Push(cEntity * a_Entity);
    void Push(const cEntity * a_Entity);
    void Push(cLuaServerHandle * a_ServerHandle);
    void Push(cLuaTCPLink * a_TCPLink);
    void Push(cLuaUDPEndpoint * a_UDPEndpoint);
    void Push(double a_Value);
    void Push(int a_Value);
    void Push(long a_Value);
    void Push(const UInt32 a_Value);
    void Push(std::chrono::milliseconds a_time);
 
    void Pop(int a_NumValuesToPop = 1);
 
    // GetStackValue() retrieves the value at a_StackPos, if it is a valid type. If not, a_Value is unchanged.
    // Returns whether value was changed
    // Enum values are checked for their allowed values and fail if the value is not assigned.
    bool GetStackValue(int a_StackPos, AString & a_Value);
    bool GetStackValue(int a_StackPos, AStringMap & a_Value);
    bool GetStackValue(int a_StackPos, AStringVector & a_Value);
    bool GetStackValue(int a_StackPos, bool & a_Value);
    bool GetStackValue(int a_StackPos, cCallback & a_Callback);
    bool GetStackValue(int a_StackPos, cCallbackPtr & a_Callback);
    bool GetStackValue(int a_StackPos, cCallbackSharedPtr & a_Callback);
    bool GetStackValue(int a_StackPos, cOptionalCallback & a_Callback);
    bool GetStackValue(int a_StackPos, cOptionalCallbackPtr & a_Callback);
    bool GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result);
    bool GetStackValue(int a_StackPos, cRef & a_Ref);
    bool GetStackValue(int a_StackPos, cStackTablePtr & a_StackTable);
    bool GetStackValue(int a_StackPos, cTableRef & a_TableRef);
    bool GetStackValue(int a_StackPos, cTableRefPtr & a_TableRef);
    bool GetStackValue(int a_StackPos, cTrackedRef & a_Ref);
    bool GetStackValue(int a_StackPos, cTrackedRefPtr & a_Ref);
    bool GetStackValue(int a_StackPos, cTrackedRefSharedPtr & a_Ref);
    bool GetStackValue(int a_StackPos, ContiguousByteBuffer & a_Data);
    bool GetStackValue(int a_StackPos, CustomStatistic & a_Value);
    bool GetStackValue(int a_StackPos, double & a_Value);
    bool GetStackValue(int a_StackPos, eBlockFace & a_Value);
    bool GetStackValue(int a_StackPos, eWeather & a_Value);
    bool GetStackValue(int a_StackPos, float & a_ReturnedVal);
    bool GetStackValue(int a_StackPos, cUUID & a_Value);
    bool GetStackValue(int a_StackPos, std::string_view & a_Value);
 
    // template to catch all of the various c++ integral types without overload conflicts
    template <class T, typename = std::enable_if_t<std::is_integral_v<T>>>
    bool GetStackValue(int a_StackPos, T & a_ReturnedVal)
    {
        if (!lua_isnumber(m_LuaState, a_StackPos))  // Also accepts strings representing a number: https://pgl.yoyo.org/luai/i/lua_isnumber
        {
            return false;
        }
        lua_Number Val = lua_tonumber(m_LuaState, a_StackPos);
        if (Val > std::numeric_limits<T>::max())
        {
            return false;
        }
        if (Val < std::numeric_limits<T>::min())
        {
            return false;
        }
        a_ReturnedVal = static_cast<T>(Val);
        return true;
    }
 
    template <typename T>
    bool GetStackValue(int a_StackPos, cOptionalParam<T> && a_ReturnedVal)
    {
        if (lua_isnoneornil(m_LuaState, a_StackPos))
        {
            return true;
        }
        return GetStackValue(a_StackPos, a_ReturnedVal.GetDest());
    }
 
    template <typename T>
    bool GetStackValue(int a_StackPos, Vector3<T> & a_ReturnedVal);
 
    cStackValue WalkToValue(const AString & a_Name);
 
    cStackValue WalkToNamedGlobal(const AString & a_Name);
 
    template <typename T> bool GetNamedValue(const AString & a_Name, T & a_Value)
    {
        auto stk = WalkToValue(a_Name);
        if (!stk.IsValid())
        {
            // Name not found
            return false;
        }
        return GetStackValue(-1, a_Value);
    }
 
    template <typename T> bool GetNamedGlobal(const AString & a_Name, T & a_Value)
    {
        // Push the globals table onto the stack and make it RAII-removed:
        lua_getglobal(m_LuaState, "_G");
        cStackValue stk(*this);
 
        // Get the named global:
        return GetNamedValue(a_Name, a_Value);
    }
 
    // Include the auto-generated Push and GetStackValue() functions:
    #include "LuaState_Declaration.inc"
 
    template <typename FnT, typename... Args>
    bool Call(const FnT & a_Function, Args &&... args)
    {
        cStackBalancePopper balancer(*this);
        m_NumCurrentFunctionArgs = -1;
        if (!PushFunction(std::forward<const FnT &>(a_Function)))
        {
            // Pushing the function failed
            return false;
        }
        auto res = PushCallPop(std::forward<Args>(args)...);
        return res;
    }
 
    template <typename Arg1, typename... Args>
    inline bool GetStackValues(int a_StartStackPos, Arg1 && a_Arg1, Args &&... args)
    {
        if (!GetStackValue(a_StartStackPos, std::forward<Arg1>(a_Arg1)))
        {
            return false;
        }
        return GetStackValues(a_StartStackPos + 1, std::forward<Args>(args)...);
    }
 
    bool CheckParamUserTable(int a_StartParam, const char * a_UserTable, int a_EndParam = -1);
 
    bool CheckParamUserType(int a_StartParam, const char * a_UserType, int a_EndParam = -1);
 
    bool CheckParamTable(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamNumber(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamBool(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamString(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamFunction(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamFunctionOrNil(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamUUID(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamVector3(int a_StartParam, int a_EndParam = -1);
 
    bool CheckParamEnd(int a_Param);
 
    bool CheckParamSelf(const char * a_SelfClassName);
 
    bool CheckParamStaticSelf(const char * a_SelfClassName);
 
    bool IsParamUserType(int a_ParamIdx, const AString & a_UserType);
 
    bool IsParamNumber(int a_ParamIdx);
 
    bool IsParamVector3(int a_ParamIdx);
 
    bool ReportErrors(int status);
 
    static bool ReportErrors(lua_State * a_LuaState, int status);
 
    void LogStackTrace(int a_StartingDepth = 0);
 
    static void LogStackTrace(lua_State * a_LuaState, int a_StartingDepth = 0);
 
    int ApiParamError(std::string_view a_Msg);
 
    AString GetTypeText(int a_StackPos);
 
    int CallFunctionWithForeignParams(
        const AString & a_FunctionName,
        cLuaState & a_SrcLuaState,
        int a_SrcParamStart,
        int a_SrcParamEnd
    );
 
    int CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_SrcEnd, int a_NumAllowedNestingLevels = 16);
 
    bool CopyTableFrom(cLuaState & a_SrcLuaState, int a_TableIdx, int a_NumAllowedNestingLevels);
 
    bool CopySingleValueFrom(cLuaState & a_SrcLuaState, int a_StackIdx, int a_NumAllowedNestingLevels);
 
    void ToString(int a_StackPos, AString & a_String);
 
    void LogStackValues(const char * a_Header = nullptr);
 
    static void LogStackValues(lua_State * a_LuaState, const char * a_Header = nullptr);
 
    cLuaState * QueryCanonLuaState(void) const;
 
    void LogApiCallParamFailure(const char * a_FnName, const char * a_ParamNames);
 
    void TrackInDeadlockDetect(cDeadlockDetect & a_DeadlockDetect);
 
    void UntrackInDeadlockDetect(cDeadlockDetect & a_DeadlockDetect);
 
protected:
 
    cCriticalSection m_CS;
 
    lua_State * m_LuaState;
 
    bool m_IsOwned;
 
    AString m_SubsystemName;
 
    AString m_CurrentFunctionName;
 
    int m_NumCurrentFunctionArgs;
 
    std::vector<cTrackedRef *> m_TrackedRefs;
 
    cCriticalSection m_CSTrackedRefs;
 
 
    template <typename... Args>
    bool CallTableFn(const cRef & a_TableRef, const char * a_FnName, Args &&... args)
    {
        if (!PushFunction(a_TableRef, a_FnName))
        {
            // Pushing the function failed
            return false;
        }
        return PushCallPop(std::forward<Args>(args)...);
    }
 
    bool PushCallPop(void)
    {
        return CallFunction(0);
    }
 
    template <typename T, typename... Args>
    inline bool PushCallPop(T && a_Param, Args &&... args)
    {
        Push(std::forward<T>(a_Param));
        m_NumCurrentFunctionArgs += 1;
        return PushCallPop(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    bool PushCallPop(cLuaState::cRet, Args &&... args)
    {
        // Calculate the number of return values (number of args left):
        int NumReturns = sizeof...(args);
 
        // Call the function:
        if (!CallFunction(NumReturns))
        {
            return false;
        }
 
        // Collect the return values:
        GetStackValues(-NumReturns, std::forward<Args>(args)...);
        lua_pop(m_LuaState, NumReturns);
 
        // All successful:
        return true;
    }
 
    bool GetStackValues(int a_StartingStackPos)
    {
        return true;
    }
 
    bool PushFunction(const char * a_FunctionName);
 
    bool PushFunction(const cRef & a_FnRef);
 
    bool PushFunction(const cRef & a_TableRef, const char * a_FnName);
 
    // void PushUserType(void * a_Object, const char * a_Type);
 
    bool CallFunction(int a_NumReturnValues);
 
    static int ReportFnCallErrors(lua_State * a_LuaState);
 
    static int BreakIntoDebugger(lua_State * a_LuaState);
 
    void TrackRef(cTrackedRef & a_Ref);
 
    void UntrackRef(cTrackedRef & a_Ref);
};  // cLuaState
 
// Instantiate the GetStackValue(Vector3<>) function for all Vector3 types:
extern template bool cLuaState::GetStackValue(int a_StackPos, Vector3d & a_ReturnedVal);
extern template bool cLuaState::GetStackValue(int a_StackPos, Vector3f & a_ReturnedVal);
extern template bool cLuaState::GetStackValue(int a_StackPos, Vector3i & a_ReturnedVal);
 
 
 
 
 
class cLuaStateTracker
{
public:
    static void Add(cLuaState & a_LuaState);
 
    static void Del(cLuaState & a_LuaState);
 
    static AString GetStats(void);
 
protected:
    typedef cLuaState * cLuaStatePtr;
    typedef std::vector<cLuaStatePtr> cLuaStatePtrs;
 
    cLuaStatePtrs m_LuaStates;
 
    cCriticalSection m_CSLuaStates;
 
 
    static cLuaStateTracker & Get(void);
};