int CDbgLuaHelper::PrepareLua(lua_State* l) { // call this function immediatly before calling lua_pcall. //returns index in stack for errorFunc // return 0; lua_register(l, "DEBUGGER_ERRORMESSAGE", errormessageLua ); lua_sethook(l, hookLua, LUA_MASKLINE|LUA_MASKCALL|LUA_MASKRET, 0); int top = lua_gettop(l); lua_getglobal(l, "DEBUGGER_ERRORMESSAGE"); lua_insert(l, top); return top; }
void lua_sr_kemi_register_core(lua_State *L) { int ret; lua_register(L, "KSR_C", sr_kemi_KSR_C); lua_register(L, "KSR_MOD_C", sr_kemi_KSR_MOD_C); ret = luaL_dostring(L, "KSR = {}\n" "KSR.__index = function (table, key)\n" " return function (...)\n" " return KSR_C(key, ...)\n" " end\n" "end\n" "setmetatable(KSR, KSR)\n" ); /* special modules - pv.get(...) can return int or str */ luaL_openlib(L, "KSR.pv", _sr_pv_Map, 0); luaL_openlib(L, "KSR.x", _sr_kemi_x_Map, 0); LM_DBG("pushing lua KSR table definition returned %d\n", ret); }
bool AssetBuilder::InitializeLua(const std::string & i_ScriptDir, const std::string & i_RelativeScriptPath) { // Create a new Lua state { mluaState = luaL_newstate(); if (!mluaState) { return false; } } // Open the standard libraries luaL_openlibs(mluaState); // Register custom functions { lua_register(mluaState, "CopyAssetFile", CopyAssetFile); lua_register(mluaState, "CreateDirectoryIfNecessary", CreateDirectoryIfNecessary); lua_register(mluaState, "DoesFileExist", DoesFileExist); lua_register(mluaState, "GetLastWriteTime", GetLastWriteTime); lua_register(mluaState, "OutputErrorMessage", OutputErrorMessage); } return true; }
//Registers a new LUA data type and its meta methods (operators) and other methods void LUA_OpenLibrary(lua_State* L, const VLUATypeInfo *pInfo, IVRSDUserDataAccessor* pUserDataAccessor /*= NULL*/) { //Add all the meta methods for this class luaL_newmetatable(L, pInfo->pszTypeName); const luaL_Reg* pReg = pInfo->m_pMethods; LUA_RegMetatable(L, pReg); //Register a constructor for the new type if(pInfo->m_Constructor.func) lua_register(L, pInfo->m_Constructor.name, pInfo->m_Constructor.func); if(pUserDataAccessor) VRSDClient::GetGlobalClient().RegisterUserDataAccessor(pUserDataAccessor); }
int main() { lua_State * l = (lua_State *)luaL_newstate(); const luaL_Reg *lib; for (lib = STANDARD_LIBS; lib->func; ++lib) { luaL_requiref(l, lib->name, lib->func, 1); lua_pop(l, 1); } lua_register(l, "sleep", lua_sleep); if (do_lua_file(l, "tests.lua")) return 0; return 1; }
void OpenVarListLibs( lua_State *L ) { lua_register( L, "HasVarList", HasVarList ); lua_register( L, "AddVar", AddVar ); lua_register( L, "RemoveVar", RemoveVar ); lua_register( L, "SetVar", SetVar ); lua_register( L, "GetVar", GetVar ); // some constants. lua_pushinteger( L, Script::VT_SCRIPT ); lua_setglobal( L, "VT_SCRIPT" ); lua_pushinteger( L, Script::VT_SRCSHAPE ); lua_setglobal( L, "VT_SRCSHAPE" ); lua_pushinteger( L, Script::VT_DESTSHAPE ); lua_setglobal( L, "VT_DESTSHAPE" ); lua_pushinteger( L, Script::VT_REGION ); lua_setglobal( L, "VT_REGION" ); lua_pushinteger( L, Script::VT_GLOBAL ); lua_setglobal( L, "VT_GLOBAL" ); lua_pushnumber( L, (lua_Number) Private::TypeTrait<VariableList::Number>::InvalidVal() ); lua_setglobal( L, "INVALID_NUM" ); }
/** * \copydoc LuaData::import_from_lua */ bool DialogResources::import_from_lua(lua_State* l) { lua_pushlightuserdata(l, this); lua_setfield(l, LUA_REGISTRYINDEX, "dialogs"); lua_register(l, "dialog", l_dialog); if (lua_pcall(l, 0, 0, 0) != 0) { Debug::error(std::string("Error in dialog data file: ") + lua_tostring(l, -1)); lua_pop(l, 1); return false; } return true; }
void FactionManager::loadLuaConfig() { info("Loading config file.", true); Lua* lua = new Lua(); lua->init(); lua_register(lua->getLuaState(), "addFaction", addFaction); //Load the faction manager lua file. lua->runFile("scripts/managers/faction_manager.lua"); delete lua; lua = NULL; }
void CLuaManager::DisableFunctions(lua_State *L) { lua_register(L, "dofile", CLuaFunctions::DisableFunction); lua_register(L, "loadfile", CLuaFunctions::DisableFunction); lua_register(L, "loadlib", CLuaFunctions::DisableFunction); lua_register(L, "require", CLuaFunctions::DisableFunction); lua_register(L, "setfenv", CLuaFunctions::DisableFunction); lua_register(L, "getfenv", CLuaFunctions::DisableFunction); }
void CLuaMain::InitSecurity ( void ) { lua_register ( m_luaVM, "dofile", CLuaFunctionDefs::DisabledFunction ); lua_register ( m_luaVM, "loadfile", CLuaFunctionDefs::DisabledFunction ); lua_register ( m_luaVM, "require", CLuaFunctionDefs::DisabledFunction ); lua_register ( m_luaVM, "loadlib", CLuaFunctionDefs::DisabledFunction ); lua_register ( m_luaVM, "getfenv", CLuaFunctionDefs::DisabledFunction ); lua_register ( m_luaVM, "newproxy", CLuaFunctionDefs::DisabledFunction ); }
void map_register2lua(lua_State *L) { lua_register(L,"NewBattleMap",&luaNewBattleMap); lua_register(L,"DelBattleMap",&luaDelBattleMap); lua_register(L,"GetPath",&luaGetPath); lua_register(L,"AoiEnterMap",&luaAoiEnterMap); lua_register(L,"AoiLeaveMap",&luaAoiLeaveMap); lua_register(L,"AoiMoveTo",&luaAoiMoveTo); }
const easy_lua* easy_lua::export_function( const std::string_view& name, const FnCallback callback ) const { if( name.empty() || !callback ) { return nullptr; } lua_register( EASY_LUA_CAST_LUA( this ), name.data(), reinterpret_cast<lua_CFunction>( callback ) ); return this; }
bool CLuaModuleManager::RegisterFunction ( lua_State * luaVM, const char *szFunctionName, lua_CFunction Func ) { if ( luaVM ) { //CLogger::LogPrintf ( "MODULE: Registering function \"%s\"\n", szFunctionName ); if ( szFunctionName ) { CLuaCFunctions::AddFunction ( szFunctionName, Func ); lua_register ( luaVM, szFunctionName, Func ); } } else { CLogger::LogPrintf ( "MODULE: Lua is not initialised.\n" ); } return true; }
int luaopen_lualsp(lua_State *L) { #ifdef THREAD_SAFE lsp_io* io=(lsp_io*)lua_newuserdata(L,sizeof(lsp_io)); memset((char*)io,0,sizeof(lsp_io)); io->lctx=(void*)stdout; io->lputs=llsplib::lsp_def_puts; io->lputc=llsplib::lsp_def_putc; io->lwrite=llsplib::lsp_def_write; lua_setfield(L,LUA_REGISTRYINDEX,llsplib::lsp_io_type); #endif lua_register(L,"dotmpl",llsplib::lua_include); lua_register(L,"dofile_lsp",llsplib::lua_include); lua_register(L,"echo",llsplib::lua_echo); lua_register(L,"write",llsplib::lua_echo); lua_register(L,"print",llsplib::lua_print); luaopen_lualspaux(L); return 0; }
int reg_function(const char *name, lua_CFunction func) { if (L) { if (name && *name != 0 && func) { lua_register(L, name, func); return 0; } return -1; } return -2; }
int initSpells() { std::cout << "Loading Spells...\n"; LuaSpells = luaL_newstate(); //create new lua state luaL_openlibs(LuaSpells); lua_register(LuaSpells,"loadspell",loadspell); //register loadspell lua_register(LuaSpells,"loadsummon",loadsummon); //register loadsummon registerLua(LuaSpells); //register functions if(luaL_loadfile(LuaSpells, "Lua\\Spells.lua") || lua_pcall(LuaSpells, 0, 0, 0)) { std::cout<<"Error: failed to load Spells.lua"<<std::endl; std::cout << lua_tostring(LuaSpells,-1) << "\n"; getch(); return -1; } lua_getglobal(LuaSpells,"loadSpells"); lua_pcall(LuaSpells,0,0,0); //execute once to load units lua_pop(LuaSpells,1); return 0; }
bool Core::init() { lua = luaL_newstate(); assert(lua != 0); luaL_checkversion(lua); // Stop garbage collector. lua_gc(lua, LUA_GCSTOP, 0); // Load Lua core libraries. // \todo maybe don't load lua libraries to save memory (and omit from build). luaL_openlibs(lua); // Register core function with Lua. lua_register(lua, "quit", Script::quit); lua_register(lua, "backgroundColor", Script::backgroundColor); lua_register(lua, "create", Script::create); lua_register(lua, "pos", Script::pos); lua_register(lua, "move", Script::move); lua_register(lua, "destroy", Script::destroy); lua_register(lua, "pc", Script::pc); lua_register(lua, "tone", Script::tone); // Restart garbage collector. lua_gc(lua, LUA_GCRESTART, 0); if (!Graphics::init()) { return false; } if (!assetContainer.setContainerFilename("content.seng")) { Platform::error << "Failed to load content file: content.seng" << std::endl << std::endl; Platform::error << "AssetContainer error: " << assetContainer.getLastError() << std::endl << std::endl; return false; } char initScript[1024]; if (!assetContainer.getString("scripts/init.lua", initScript, 1024)) { Platform::error << "AssetContainer error: " << assetContainer.getLastError(); return false; } doString(initScript); return true; }
void SE_funcs_register( lua_State *L ) { //lua_register( L, "test_func", test_func ); lua_register( L, "l2h_delay", l2h_delay ); lua_register( L, "l2h_print", l2h_print ); lua_register( L, "l2h_console_enable", l2h_console_enable ); lua_register( L, "l2h_soundAlert", l2h_soundAlert ); lua_register( L, "l2h_time", l2h_time ); lua_register( L, "l2h_timeMsec", l2h_timeMsec ); }
void CLuaHTTPDefs::LoadFunctions ( lua_State* luaVM ) { // Register these funcs for that VM lua_register ( luaVM, "httpWrite", CLuaHTTPDefs::httpWrite ); lua_register ( luaVM, "httpSetResponseHeader", CLuaHTTPDefs::httpSetResponseHeader ); lua_register ( luaVM, "httpSetResponseCookie", CLuaHTTPDefs::httpSetResponseCookie ); lua_register ( luaVM, "httpSetResponseCode", CLuaHTTPDefs::httpSetResponseCode ); lua_register ( luaVM, "httpClear", CLuaHTTPDefs::httpClear ); lua_register ( luaVM, "httpRequestLogin", CLuaHTTPDefs::httpRequestLogin ); }
luaopen_gears_async_libluabridge(lua_State *L) #endif { /* Async I/O methods */ lua_register(L, "aio_scan_directory" , lua_aio_scan_directory ); lua_register(L, "aio_file_info" , lua_aio_file_info ); lua_register(L, "aio_watch_gfile" , lua_aio_watch_gfile ); lua_register(L, "aio_load_file" , lua_aio_load_file ); lua_register(L, "aio_append_to_file" , lua_aio_append_to_file ); lua_register(L, "aio_file_write" , lua_aio_file_write ); #ifdef ENABLE_GTK lua_register(L, "aio_load_icon" , lua_aio_load_icon ); lua_register(L, "aio_file_icon" , lua_aio_file_icon ); #endif /* Request helper methods */ lua_register(L, "request_connect" , lua_request_connect ); return 0; }
DnaManager::DnaManager() : Logger("DnaManager") { lua = new Lua(); lua->init(); lua_register(lua->getLuaState(), "addQualityTemplate", addQualityTemplate); lua->setGlobalInt("FORTITUDE", DnaManager::FORTITUDE); lua->setGlobalInt("ENDURANCE", DnaManager::ENDURANCE); lua->setGlobalInt("CLEVERNESS", DnaManager::CLEVERNESS); lua->setGlobalInt("COURAGE", DnaManager::COURAGE); lua->setGlobalInt("POWER", DnaManager::POWER); lua->setGlobalInt("DEPENDABILITY", DnaManager::DEPENDABILITY); lua->setGlobalInt("DEXTERITY", DnaManager::DEXTERITY); lua->setGlobalInt("FIERCENESS", DnaManager::FIERCENESS); lua->setGlobalInt("HARDINESS", DnaManager::HARDINESS); lua->setGlobalInt("INTELLIGENCE", DnaManager::INTELLIGENCE); }
/** Metoda uruchamia skrypt lua, ktory dodaje wszystkie informacje * o spritach. W skrypcie dostepna jest metoda cxx_addSprite * @param void * @return void */ void SpriteManager::loadConfig() { lua_State* L = lua_open(); luaL_openlibs(L); // Rejestracja metody ktora jest wywolywna ze skryptu lua_register( L, "cxx_addSprite", SpriteManager::addSprite ); //Wolanie skryptu if ( luaL_dofile( L, "data/sprite_config.lua" ) != 0 ) { gCritical(lua_tostring( L, -1 )); throw("SpriteManager::loadConfig"); } lua_close(L); }
// Constructor _Scripting::_Scripting() : Server(nullptr), LuaState(nullptr) { // Initialize lua object LuaState = luaL_newstate(); luaopen_base(LuaState); luaopen_math(LuaState); // Set globals lua_pushlightuserdata(LuaState, this); lua_setglobal(LuaState, "param_scripting"); // Register C++ functions used by lua lua_register(LuaState, "map_change", &MapChangeFunction); }
void exportLuaScriptAPI(lua_State* L) { // geometric functions lua_register(L, "reflect", reflect); lua_register(L, "refract", refract); lua_register(L, "faceforward", faceforward); // shading functions lua_register(L, "ambient", ambient); lua_register(L, "diffuse", diffuse); lua_register(L, "specular", specular); }
/// called by Register(), registers object-methods (see cLuaBind constructor for examples) virtual void RegisterMethods (lua_State *L) { PROFILE // mlMethod.push_back((struct luaL_reg){"Meemba", cWidget_L::Get}); // lua_register(L,"MyGlobalFun", MyGlobalFun); // lua_register(L,"MyStaticMethod", &cSomeClass::MyStaticMethod); lua_register(L,"GetWidgetUnderPos", &cWidget_L::GetWidgetUnderPos); #define REGISTER_METHOD(methodname) mlMethod.push_back(make_luaL_reg(#methodname,&cWidget_L::methodname)); REGISTER_METHOD(Destroy); REGISTER_METHOD(CreateChild); REGISTER_METHOD(UpdateClip); REGISTER_METHOD(SetBitMask); REGISTER_METHOD(IsUnderPos); #undef REGISTER_METHOD }
int main(int argc, const char * argv[]) { lua_State *lState; lState = luaL_newstate(); luaL_openlibs( lState ); lua_register( lState, "GetLockpickLevel", lua_GetLockpickLevel ); int iStatus = luaL_loadstring( lState, szLua ); if( iStatus ) { std::cout << "Error: " << lua_tostring( lState, -1 ); return 1; } iStatus = lua_pcall( lState, 0, 0, 0 ); if( iStatus ) { std::cout << "Error: " << lua_tostring( lState, -1 ); return 1; } lua_getfield( lState, LUA_GLOBALSINDEX, "game_door_check" ); CGameData Data( 8 ); lua_pushlightuserdata( lState, (void *) &Data ); iStatus = lua_pcall( lState, 1, 1, 0 ); if( iStatus ) { std::cout << "Error: " << lua_tostring( lState, -1 ); return 1; } int iRet = (int) lua_toboolean( lState, -1 ); if( iRet ) { std::cout << "Door opened!" << std::endl; } else { std::cout << "Door still closed." << std::endl; } lua_close( lState ); return 0; }
void KitsuneSwagConsole::LoadKSCLuaLib(){ lua_sethook(L, luadiehook, LUA_MASKCOUNT, 10000); lua_register(L, "print", lua_putsmyprint); RegFunc( "Clear", lua_cls); RegFunc( "Exit", lua_die); RegFunc( "Close", lua_closesocket); RegFunc( "GetAll", lua_getall); RegFunc( "GetInfo", lua_getinfo); RegFunc("Client", lua_connectclient); RegFunc("Server", lua_connectserver); RegFunc("SetVisible", lua_SetVisible); RegFunc("GetVisible", lua_GetVisible); RegFunc("Focus", lua_Focus); struct luaL_reg driver[] = { { "Send", lua_send }, { "Close", lua_closesocket }, { "AsInt", lua_stoi }, { NULL, NULL }, }; struct luaL_reg ls_meta[] = { { "__gc", ls__gc }, { "__tostring", ls__tostring }, { "__eq", ls__eq }, { "__lt", ls__lt }, { "__le", ls__le }, //{ "__add", Foo_add }, { 0, 0 } }; luaL_openlib(L, PROJECT_TABLENAME, driver, 0); luaL_newmetatable(L, PROJECT_TABLENAME); luaL_openlib(L, 0, ls_meta, 0); lua_pushliteral(L, "__index"); lua_pushvalue(L, -3); lua_rawset(L, -3); lua_pushliteral(L, "__metatable"); lua_pushvalue(L, -3); lua_rawset(L, -3); lua_setglobal(ASWN->L, PROJECT_TABLENAME); }
int main() { int i; const char *file = "my.lua"; lua_State *L = lua_open(); luaL_openlibs(L); lua_register(L, "c_break", c_break); ldb = ldb_new(L, reload); luaL_dofile(L, file); ldb_free(ldb); lua_close(L); return 0; }
template<class T> void bind<T>::reg( lua_State* L, const std::string& name ) { TUMBO_LUA_STACKASSERT(L,0); NAME = name; luaL_Reg meta[] = { { "__add", add }, { "__unm", unary_minus }, { "__sub", sub }, { "__mul", mul }, { "__div", div }, { "__call", mat_call }, { "__tostring", tostr }, { "__index", mat_index }, { "__newindex", mat_assign_index }, { "__len", mat_size }, { NULL, NULL } }; luaL_Reg meth[] = { { "inverse", inverse }, { NULL, NULL } }; int metatable, methodtable; /* Create the metatable. */ luaL_newmetatable( L, NAME.c_str() ); metatable = lua_gettop(L); TUMBO_LUA_SETFUNCS( L, meta ); /* Create methods table. */ lua_newtable( L ); methodtable = lua_gettop(L); TUMBO_LUA_SETFUNCS( L, meth ); /* Set the method table as the meta __index table. */ lua_pushstring(L, "methods"); lua_pushvalue(L, methodtable); lua_rawset(L, metatable); /* Make the constructor available as a global. */ lua_register(L, NAME.c_str(), create); /* Remove the metatable. */ lua_pop(L,2); }
void CustomSystem::Init() { lua_State *L = csLua = lua_open(); luaL_openlibs(L); OOLUA::setup_user_lua_state(L); PiLuaClasses::RegisterClasses(L); LuaConstants::Register(L); OOLUA::register_class<CustomSystem>(L); OOLUA::register_class<CustomSBody>(L); lua_register(L, "load_lua", pi_load_lua); pi_lua_dofile(L, "pisystems.lua"); lua_close(L); }