NPLScriptingState.h

#pragma once
#include <map>
#include "NPLCommon.h"

namespace NPL
{
    class CNPLStateMemAllocator;
}

namespace ParaScripting
{
    using namespace luabind;

    class CNPLScriptingState 
    {
    public:
        enum NPL_MemAllocatorType
        {
            // using the system's default malloc/realloc/free functions, please note that NPL makes heavy use of realloc
            MEM_ALLOC_TYPE_SYS_MALLOC,
            // using fixed sized pool. I thought this one should be fastest, but it turns out to the slowest. 
            // perhaps due to lua memory allocator heavily depends on realloc instead of malloc. 
            MEM_ALLOC_TYPE_POOL_MALLOC,
            // using the Doug Lea memory allocator. This is a fast thread local memory allocator. 
            MEM_ALLOC_TYPE_DL_MALLOC,
        };

        CNPLScriptingState(bool bCreateState=true);
        virtual ~CNPLScriptingState(void);

        int GetLastReturnValue() const;
        void SetLastReturnValue(int val);
    public:
        lua_State* GetLuaState();

        bool IsValid();

        void LoadNPLLib();

        void LoadParaLib();

        // following are individual group of HAPI

        void LoadHAPI_Globals();
        void LoadHAPI_SceneManager();
        void LoadHAPI_ResourceManager();
        void LoadHAPI_UI();
        void LoadHAPI_UI_Extension();
        void LoadHAPI_Audio();
        void LoadHAPI_Network();
        void LoadHAPI_AI();
        void LoadHAPI_NPL();
        void LoadHAPI_Jabber();
    public:
        static int GetNPLCodeFromFile(ParaEngine::CParaFile* pFile, char** pBuffer, int* pBufferSize);

        static void AddSearchPath(const char* sSearchPath, bool bIsAdding = true);

        static uint32 GetScriptDiskPath(const string& filePath, string& sFileName);

        bool IsScriptFileLoaded(const string& filepath);

        bool LoadFile(const string& filePath, bool bReload, lua_State* L = 0, bool bNoReturn = false);

        int DoString(const char* sCode, int nLength = 0, const char* sFileName = NULL, bool bPopReturnValue = true);

        NPL::NPLReturnCode ActivateFile(const string& filepath, const char * code = NULL, int nLength=0);

        bool BindFileActivateFunc(const object& funcActivate, const std::string& filename);

        static NPL::NPLRuntimeState_ptr GetRuntimeStateFromLuaObject(const object& obj);
        static NPL::NPLRuntimeState_ptr GetRuntimeStateFromLuaState(lua_State* L);

        const string& GetFileName();
        const char* GetCurrentFileName(lua_State* L = 0);

        bool CreateSetState(lua_State* pLuaState = NULL);

        void SetOwnLuaState(bool bOwn);

        int NPL_export(lua_State* L = 0);

        const std::map <std::string, int32>& GetLoadedFiles();
    protected:

        void DestroyState();

        void LoadLuabind();

        void SetRuntimeState(NPL::NPLRuntimeState_ptr runtime_state);

        void ProcessResult(int nResult, lua_State* L = 0);

        int CacheFileModule(const std::string& filename, int nResult, lua_State* L = 0);

        int PopFileModule(const std::string& filename, lua_State* L = 0);

        std::string GetModuleFilePath(const std::string& modulename, lua_State* L = 0);

        int GetFileLoadStatus(const string& filepath);
        void SetFileLoadStatus(const string& filepath, int nStatus);

    private:
        class CFileNameStack
        {
        public:
            CFileNameStack(CNPLScriptingState* pState, const string& filename):m_pState(pState){
                if(m_pState)
                    m_pState->PushFileName(filename);
            }
            ~CFileNameStack(){
                if(m_pState)
                    m_pState->PopFileName();
            }
            CNPLScriptingState* m_pState;
        };

        void PushFileName(const string& filename);

        void PopFileName();

    
        void LoadParaScene();
        void LoadParaWorld();

        lua_State* m_pState;
        /* whether we own the luastate. true by default. false if luastate is set externally.*/
        bool m_bOwnLuaState;
        
        int m_nStackSize;

        int m_nLastReturnValue;
        
        NPL_MemAllocatorType m_nMemAllocatorType;

        union
        {
            NPL::CNPLStateMemAllocator* m_pMemAlloc;
            void* m_mspace;
        };

        std::map <std::string, int32> m_loaded_files;

        std::stack <std::string> m_stack_current_file;

        /* currently only a single search path is supported. */
        static std::string m_searchpath;
    };
}