lua_State* LuaWorld::getState()
{
if(GlobalState==NULL)
{
GlobalState = luaL_newstate();
luaopen_io(GlobalState);
luaopen_base(GlobalState);
luaopen_table(GlobalState);
luaopen_string(GlobalState);
luaopen_math(GlobalState);
luaL_openlibs(GlobalState);
}
return GlobalState;
}
Slayer::Slayer()
{
console->log("Slayer 1.0");
background = new EntityMgr();
foreground = new EntityMgr();
ui = new EntityMgr();
lua_state = lua_open();
luaopen_base(lua_state);
luaopen_Fuego(lua_state);
console->log("Lua initialized.");
}
int LUA::init()
{
lock();
printf("LUA\n");
L = lua_open();
luaL_checkversion(L); /* check that interpreter has correct version */
luaopen_base(L);
luaL_openlibs(L); /* open standard libraries */
hulua::def(L, "_ALERT", LUA::show_error);
hulua::def(L, "jump", Jump);
hulua::def(L, "import_xml",import_xml);
unlock();
}
lua_state::lua_state()
: m_state(lua_open())
{
luaopen_base(m_state);
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
// lua 5.1 or newer
luaL_openlibs(m_state);
#else
// lua 5.0.2 or older
lua_baselibopen(m_state);
#endif
m_top = lua_gettop(m_state);
luabind::open(m_state);
}
MyBuffManager::MyBuffManager()
{
if(m_pSingleton)
throw "Error";
else
m_pSingleton=this;
lua_State* L = lua_open();
luaopen_base(L);
luaL_openlibs(L);
MyBuffManager::DefineInLua(L);
lua_tinker::set(L,"BuffManager",this);
lua_tinker::dofile(L, "./media/lua/Buff/Type.lua");
lua_close(L);
}
int main()
{
// Lua 를 초기화 한다.
lua_State* L = lua_open();
// Lua 기본 함수들을 로드한다.- print() 사용
luaopen_base(L);
// Lua 테이블을 생성하고 스택에 푸쉬한다.
lua_tinker::table haha(L, "haha");
// haha.value = 1 값을 넣는다.
haha.set("value", 1);
// table 내에 table을 만들어 넣는다.
haha.set("inside", lua_tinker::table(L));
// haha.inside 의 포인터를 스택위로 복사한다.
lua_tinker::table inside = haha.get<lua_tinker::table>("inside");
// inside.value = 2 값을 넣는다.
inside.set("value", 2);
// sample4.lua 파일을 로드/실행한다.
lua_tinker::dofile(L, "sample4.lua");
// Lua 에서 생성한 haha.test 값을 읽는다.
const char* test = haha.get<const char*>("test");
printf("haha.test = %s\n", test);
// 전역에 등록하지 않고 Lua 스택에 빈 테이블을 생성한다.(지역변수)
lua_tinker::table temp(L);
// 빈 테이블.name 에 값을 넣는다.
temp.set("name", "local table !!");
// table을 의 인자로 사용하여 print_table 을 호출한다.
lua_tinker::call<void>(L, "print_table", temp);
// 함수가 리턴하는 table을 받는다.
lua_tinker::table ret = lua_tinker::call<lua_tinker::table>(L, "return_table", "give me a table !!");
printf("ret.name =\t%s\n", ret.get<const char*>("name"));
// 프로그램 종료
lua_close(L);
return 0;
}
void Interpreter::initialize(Renderer *renderer)
{
interpreter = this;
mRenderer = renderer;
L = lua_open();
printf("opening lua");
//luaopen_io(L);
luaopen_base(L);
luaopen_table(L);
luaopen_string(L);
luaopen_math(L);
//luaopen_loadlib(L);
printf("registering newIsland");
lua_register(L, "newIsland", func_newIsland);
lua_register(L, "clearIslands", func_clearIslands);
}
LuaScript::LuaScript()
{
m_LuaState = lua_open();
if( m_LuaState )
{
// инициализация стандартных библиотечных функции lua
luaopen_base( m_LuaState );
luaopen_table( m_LuaState );
luaopen_string( m_LuaState );
luaopen_math( m_LuaState );
luaopen_os( m_LuaState );
}
else
Log( "Error Initializing Lua" );
}
void LuaManager::Init()
{
luaState = lua_open();
assert(luaState);
luaopen_base (luaState);
luaopen_table (luaState);
luaopen_string (luaState);
luaopen_math (luaState);
luaopen_debug (luaState);
luaL_openlibs(luaState);
toluafix_open(luaState);
tolua_attempt_open(luaState);
SetLuaLoaderFunc(LuaLoader);
LuaOpenLibName();
}
// 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);
}
static lua_State *_vms_new( void )
{
int error = 0;
lua_State *L = luaL_newstate();
assert( L );
luaopen_base( L );
luaL_openlibs( L );
/*reg func*/
lua_register(L, "supex_http", sync_http);
lua_register(L, "app_lua_get_head_data", app_lua_get_head_data);
lua_register(L, "app_lua_get_body_data", app_lua_get_body_data);
lua_register(L, "app_lua_get_path_data", app_lua_get_path_data);
lua_register(L, "app_lua_get_recv_buf", app_lua_get_recv_buf);
lua_register(L, "app_lua_get_uri_args", app_lua_get_uri_args);
lua_register(L, "app_lua_add_send_data", app_lua_add_send_data);
lua_register(L, "app_lua_mapinit", app_lua_mapinit);
lua_register(L, "app_lua_convert", app_lua_convert);
lua_register(L, "app_lua_reverse", app_lua_reverse);
lua_register(L, "app_lua_ifmatch", app_lua_ifmatch);
#ifdef OPEN_MDDS
lua_register(L, "cal_poi_by_line", cal_poi_by_line);
lua_register(L, "cal_front_road_by_road", cal_front_road_by_road);
#else
lua_register(L, "app_lua_lru_cache_set_value", lrucache_setvalue);
lua_register(L, "app_lua_lru_cache_get_value", lrucache_getvalue);
lua_register(L, "app_lua_lru_cache_remove_value", lrucache_removevalue);
lua_register(L, "libkv_cache_set_value", libkv_setvalue);
lua_register(L, "libkv_cache_get_value", libkv_getvalue);
lua_register(L, "libkv_cache_delete_key", libkv_deletekey);
#endif
/*lua init*/
{
extern struct smart_cfg_list g_smart_cfg_list;
int app_lua_get_serv_name(lua_State *L){
lua_pushstring( L, g_smart_cfg_list.argv_info.serv_name );
return 1;
}
lua_register(L, "app_lua_get_serv_name", app_lua_get_serv_name);
error = luaL_dofile(L, "lua/core/init.lua");
if (error) {
fprintf(stderr,"%s\n", lua_tostring(L,-1));
lua_pop(L,1);
exit(EXIT_FAILURE);
}
}
LuaTcpSocket::LuaTcpSocket(QTcpSocket* socket,boost::function<void ()> disconnect_callback)
: socket_(socket),
lua_(lua_open()),
disconnect_callback_(disconnect_callback)
{
connect(socket_.get(),SIGNAL(readyRead()),SLOT(onReadyRead()));
connect(socket_.get(),SIGNAL(disconnected()),SLOT(onDisconnect()));
luaopen_base(lua_);
luaopen_table(lua_);
luaopen_string(lua_);
luaopen_math(lua_);
luaopen_debug(lua_);
setSocket(lua_,this);
lua_register(lua_,"print",&LuaTcpSocket_Print);
lua_register(lua_,"raw_input",&LuaTcpSocket_RawInput);
}
initlua(void)
{
PyObject *m;
m = Py_InitModule("lua", lua_methods);
if (!L) {
L = lua_open();
luaopen_base(L);
luaopen_table(L);
luaopen_io(L);
luaopen_string(L);
luaopen_debug(L);
luaopen_loadlib(L);
luaopen_python(L);
lua_settop(L, 0);
}
}
int main00000()
{
lua_State* L = lua_open();
luaopen_base(L);
luaopen_string(L);
lua_tinker::class_add<Base>(L, "Base");
lua_tinker::class_def<Base>(L, "getvalue", &Base::getvalue);
lua_tinker::class_add<A>(L, "A");
lua_tinker::class_inh<A, Base>(L);
lua_tinker::class_def<A>(L, "getvalue", &A::getvalue);
lua_tinker::class_mem<A>(L, "value", &A::value);
lua_tinker::class_add<base>(L, "base");
lua_tinker::class_def<base>(L, "is_base", &base::is_base);
lua_tinker::class_add<test>(L, "test");
lua_tinker::class_inh<test, base>(L);
lua_tinker::class_con<test>(L, lua_tinker::constructor<test,int>);
lua_tinker::class_def<test>(L, "is_test", &test::is_test);
lua_tinker::class_def<test>(L, "ret_void", &test::ret_void);
lua_tinker::class_def<test>(L, "ret_int", &test::ret_int);
lua_tinker::class_def<test>(L, "ret_mul", &test::ret_mul);
lua_tinker::class_def<test>(L, "get", &test::get);
lua_tinker::class_def<test>(L, "set", &test::set);
lua_tinker::class_mem<test>(L, "_test", &test::_test);
lua_tinker::set(L, "g_test", &g_test);
lua_tinker::def(L, "createA",&A::create);
lua_tinker::dofile(L, "sample3.lua");
lua_close(L);
return 0;
}
lua_State *lxc_new_state()
{
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
lua_State *L = luaL_newstate(); /* opens Lua */
luaL_openlibs(L);
#else
lua_State *L = lua_open(); /* opens Lua */
luaopen_base(L); /* opens the basic library */
luaopen_table(L); /* opens the table library */
luaopen_io(L); /* opens the I/O library */
luaopen_string(L); /* opens the string lib. */
luaopen_math(L); /* opens the math lib. */
#endif
luaopen_xchat(L);
return L;
}
void
init_lua_state(char *file, char *path, char *cpath){
L=luaL_newstate();
luaopen_base(L);
luaopen_table(L);
luaopen_string(L);
luaopen_math(L);
luaL_openlibs(L);
int err = luaL_dofile(L, file);
if (err) {
fprintf(stderr,"%s\n",lua_tostring(L,-1));
lua_close(L);
exit(1);
}
setenv("LUA_PATH",path,1);
setenv("LUA_CPATH",cpath,1);
}
lua_State* luaInit(char* filename)
{
lua_State* L = lua_open();
luaopen_base(L);
luaopen_string(L);
luaopen_math(L);
if (filename && *filename)
{
if (luaL_loadfile(L, filename) || lua_pcall(L, 0, 0, 0))
{
printf("can not open file: %s", lua_tostring(L, -1));
}
}
return L;
}
int main(int argc, char* argv[]) {
if (argc != 2) {
fprintf(stderr, "lua_curses something.lua\n");
exit(1);
}
lua_State* lua= lua_open();
luaopen_base(lua);
lua_settop(lua, 0);
luaopen_string(lua);
lua_settop(lua, 0);
// bindings
lua_pushcfunction(lua, my_addch);
lua_setglobal(lua, "addch");
lua_pushcfunction(lua, my_getch);
lua_setglobal(lua, "getch");
lua_pushnumber(lua, ERR);
lua_setglobal(lua, "ERR");
lua_pushcfunction(lua, my_move);
lua_setglobal(lua, "move");
lua_pushcfunction(lua, my_rand);
lua_setglobal(lua, "rand");
lua_pushcfunction(lua, my_quit);
lua_setglobal(lua, "quit");
lua_pushcfunction(lua, my_start);
lua_setglobal(lua, "start");
initscr(); // initialize curses
cbreak(); // don't buffer user input into lines, but Ctrl-Z and Ctrl-C work as usual
noecho(); // don't echo user input.
halfdelay(1); // getch returns ERR if the user takes more than a tenth of a second
keypad(stdscr, TRUE); // don't ignore function keys F1, F2, etc.
// TODO: seed the random number generator with the time.
if (lua_dofile(lua, argv[1])) {
fprintf(stderr, "lua_curses had a problem opening %s\n", argv[1]);
endwin();
exit(1);
}
fprintf(stderr, "hello world\n");
lua_close(lua);
endwin();
return 0;
}
bool
runLua(const std::string& filename)
{
GRLUA_DEBUG("Importing scene from " << filename);
// Start a lua interpreter
lua_State* L = lua_open();
GRLUA_DEBUG("Loading base libraries");
// Load some base library
luaopen_base(L);
luaopen_io(L);
luaopen_string(L);
luaopen_math(L);
luaopen_table(L);
GRLUA_DEBUG("Setting up our functions");
// Set up the metatable for gr.node
luaL_newmetatable(L, "gr.node");
lua_pushstring(L, "__index");
lua_pushvalue(L, -2);
lua_settable(L, -3);
// Load the gr.node methods
luaL_openlib(L, 0, grlib_node_methods, 0);
// Load the gr functions
luaL_openlib(L, "gr", grlib_functions, 0);
GRLUA_DEBUG("Parsing the scene");
// Now parse the actual scene
if (luaL_loadfile(L, filename.c_str()) || lua_pcall(L, 0, 0, 0)) {
std::cerr << "Error loading " << filename << ": " << lua_tostring(L, -1) << std::endl;
return false;
}
GRLUA_DEBUG("Closing the interpreter");
// Close the interpreter, free up any resources not needed
lua_close(L);
return true;
}
int main()
{
lua_State* L = lua_open();
luaopen_base(L);
hulua::set(L, "cpp_int", cpp_int);
hulua::dofile(L, "sample2.lua");
int lua_int = hulua::get<int>(L, "lua_int");
printf("lua_int = %d\n", lua_int);
lua_close(L);
return 0;
}
int main()
{
lua_State* L = lua_open();
luaopen_base(L);
lua_tinker::def(L, "cpp_func", cpp_func);
lua_tinker::dofile(L, "sample1.lua");
int result = lua_tinker::call<int>(L, "lua_func", 3, 4);
printf("lua_func(3,4) = %d\n", result);
lua_close(L);
return 0;
}
int main(int argc,char* argv[])
{
lua_State *L;
if (argc<2)
{
printf("%s: <filename.lua>\n",argv[0]);
return 0;
}
L=luaL_newstate();
luaopen_base(L); // load basic libs (eg. print)
luaopen_example(L); // load the wrappered module
if (luaL_loadfile(L,argv[1])==0) // load and run the file
lua_pcall(L,0,0,0);
else
printf("unable to load %s\n",argv[1]);
lua_close(L);
return 0;
}
void ScriptManager::openLuaState() {
_luaState = lua_open();
if (!_luaState) {
throw Common::Exception("Failed to open Lua state");
}
luaopen_base(_luaState);
luaopen_io(_luaState);
luaopen_math(_luaState);
luaopen_string(_luaState);
luaopen_table(_luaState);
luaopen_loadlib(_luaState);
luaopen_debug(_luaState);
tolua_open(_luaState);
lua_atpanic(_luaState, &ScriptManager::atPanic);
}
static bool readConfig()
{
bool ret = false;
try
{
struct msvalue_s config(true);
struct lua_State* L = luaL_newstate();
luaopen_base(L);
luaL_openlibs(L);
/*TODO::由启动参数指定配置路径*/
ConnectionServerPassword::getInstance().load(L);
if (lua_tinker::dofile(L, "ServerConfig//ConnectionServerConfig.lua"))
{
aux_readluatable_byname(L, "ConnectionServerConfig", &config);
}
else
{
throw std::runtime_error("not found ServerConfig//ConnectionServerConfig.lua file");
}
map<string, msvalue_s*>& _submapvalue = *config._map;
selfIP = map_at(_submapvalue, string("selfIP"))->_str;
portForClient = atoi(map_at(_submapvalue, string("portForClient"))->_str.c_str());
portForLogicServer = atoi(map_at(_submapvalue, string("portForLogicServer"))->_str.c_str());
gSelfID = atoi(map_at(_submapvalue, string("id"))->_str.c_str());
map<string, msvalue_s*>& etcdConfig = *map_at(_submapvalue, string("etcdservers"))->_map;
for (auto& v : etcdConfig)
{
map<string, msvalue_s*>& oneconfig = *((v.second)->_map);
etcdServers.push_back(std::make_tuple(map_at(oneconfig, string("ip"))->_str, atoi(map_at(oneconfig, string("port"))->_str.c_str())));
}
lua_close(L);
L = nullptr;
ret = true;
}
catch (const std::exception& e)
{
errorExit(e.what());
}
return ret;
}
static lua_State *filtro_abrir_lua(modulo_t *modulo, const char *ruta) {
dato_filtro_t * dato = (dato_filtro_t*)modulo->m_dato;
lua_State *l;
static const struct luaL_reg arraylib [] = {
{"set", filtro_gestos_setarray},
{"get", filtro_gestos_getarray},
{"size", filtro_gestos_getsize},
{"copiar", filtro_gestos_copiar},
{"crear_copia", filtro_gestos_crear_copia},
{"difuminar", filtro_gestos_difuminar},
{"centrar", filtro_gestos_centrar},
{"rotar", filtro_gestos_rotar},
{"centrar2", filtro_gestos_centrar2},
{"buscar_limites", filtro_gestos_buscar_limites},
{"clean", filtro_gestos_clean},
{"make_up", filtro_gestos_make_up},
{"on_border", filtro_gestos_on_border},
{"borrar_bounds", filtro_gestos_borrar_bounds},
{NULL, NULL}
};
static const struct luaL_reg arrayparam [] = {
{"get_colores", filtro_gestos_get_colores},
{NULL, NULL}
};
dato->m_lua = lua_open();
l = dato->m_lua;
luaL_openlib(l, "imagen", arraylib, 0);
luaL_openlib(l, "parametros", arrayparam, 0);
luaopen_base(l);
luaopen_table(l);
luaopen_io(l);
luaopen_string(l);
luaopen_math(l);
luaopen_loadlib(l);
luaL_loadfile(l, ruta);
lua_pcall(l, 0, 0, 0);
return l;
}
int main(int argc,char* argv[]) {
lua_State *L;
int ok;
printf("[C] Welcome to the simple embedded lua example\n");
printf("[C] We are in C\n");
printf("[C] opening a lua state & loading the libraries\n");
L=lua_open();
luaopen_base(L);
luaopen_string(L);
luaopen_math(L);
printf("[C] now loading the SWIG wrapped library\n");
luaopen_example(L);
printf("[C] all looks ok\n");
printf("\n");
if (argc != 2 || argv[1] == NULL || strlen(argv[1]) == 0) {
printf("[C] ERROR: no lua file given on command line\n");
exit(3);
}
printf("[C] let's load the file '%s'\n", argv[1]);
printf("[C] any lua code in this file will be executed\n");
if (luaL_loadfile(L, argv[1]) || lua_pcall(L, 0, 0, 0)) {
printf("[C] ERROR: cannot run lua file: %s",lua_tostring(L, -1));
exit(3);
}
printf("[C] We are now back in C, all looks ok\n");
printf("\n");
printf("[C] let's call the function 'do_tests()'\n");
ok=dostring(L,"do_tests()");
printf("[C] We are back in C, the dostring() function returned %d\n",ok);
printf("\n");
printf("[C] Let's call lua again, but create an error\n");
ok=dostring(L,"no_such_function()");
printf("[C] We are back in C, the dostring() function returned %d\n",ok);
printf("[C] it should also have returned 1 and printed an error message\n");
printf("\n");
printf("[C] Let's call lua again, calling the greeting function\n");
ok=dostring(L,"call_greeting()");
printf("[C] This was C=>Lua=>C (getting a bit complex)\n");
printf("\n");
printf("[C] all finished, closing the lua state\n");
lua_close(L);
return 0;
}
void CLuaMain::InitVM ( void )
{
assert( !m_luaVM );
// Create a new VM
m_luaVM = lua_open ();
m_pLuaManager->OnLuaMainOpenVM( this, m_luaVM );
// Set the instruction count hook
lua_sethook ( m_luaVM, InstructionCountHook, LUA_MASKCOUNT, HOOK_INSTRUCTION_COUNT );
// Load LUA libraries
luaopen_base ( m_luaVM );
luaopen_math ( m_luaVM );
luaopen_string ( m_luaVM );
luaopen_table ( m_luaVM );
luaopen_debug ( m_luaVM );
luaopen_utf8 ( m_luaVM );
// Initialize security restrictions. Very important to prevent lua trojans and viruses!
InitSecurity ();
// Registering C functions
CLuaCFunctions::RegisterFunctionsWithVM ( m_luaVM );
// Create class metatables
InitClasses ( m_luaVM );
// Oli: Don't forget to add new ones to CLuaManager::LoadCFunctions. Thanks!
// create global vars
lua_pushelement ( m_luaVM, g_pGame->GetMapManager()->GetRootElement() );
lua_setglobal ( m_luaVM, "root" );
lua_pushresource ( m_luaVM, m_pResource );
lua_setglobal ( m_luaVM, "resource" );
lua_pushelement ( m_luaVM, m_pResource->GetResourceRootElement () );
lua_setglobal ( m_luaVM, "resourceRoot" );
// Load pre-loaded lua code
LoadScript ( szPreloadedScript );
}
//---------------------------------------------------------------------------//
// Init
//
//---------------------------------------------------------------------------//
bool CLuaFile::Init(const char *pszFile)
{
End();
BorraVars();
m_pLuaState = lua_open();
if (m_pLuaState)
{
m_bOk = true;
luaopen_base (m_pLuaState);
luaopen_table (m_pLuaState);
luaopen_string (m_pLuaState);
luaopen_math (m_pLuaState);
luaopen_os (m_pLuaState);
// Registrar las funiones y procesar el fichero
#define ITEM(funcname,func) lua_register(m_pLuaState, funcname, func);
#include "EnumFuncionesLua.h"
#undef ITEM
char pBuffer[MAX_PATH];
GetCurrentDirectory(MAX_PATH,pBuffer);
strcat_s(pBuffer, "%s\\demo.lua");
if (luaL_loadfile(m_pLuaState, pBuffer) == 0)
{
if (lua_pcall(m_pLuaState, 0, 0, 0) == 0)
{
}
else
{
GLOG(("ERR: Error procesando el fichero LUA '%s'", pszFile));
End();
}
}
else
{
GLOG(("ERR: Can't load LUA file\n"));
End();
}
}
return (IsOk());
}
CLuaBridge::CLuaBridge(void) : m_pLuaContext(NULL)
{
m_pLuaContext = lua_open();
if (m_pLuaContext != NULL)
{
lua_pushcclosure(m_pLuaContext, LuaDebugMessage, 0);
lua_setglobal(m_pLuaContext, "trace");
lua_atpanic(m_pLuaContext, (lua_CFunction)HandleLuaAsssert);
luaopen_io(m_pLuaContext);
luaopen_math(m_pLuaContext);
luaopen_base(m_pLuaContext);
luaopen_loadlib(m_pLuaContext);
luaopen_table(m_pLuaContext);
luaopen_string(m_pLuaContext);
luaopen_debug(m_pLuaContext);
}
}
int main()
{
// Lua ?? ???? ???.
lua_State* L = lua_open();
// Lua ?? ??????? ?¦Å????.- print() ???
luaopen_base(L);
// Lua ????? ??????? ?¦Å????.- string ???
luaopen_string(L);
// base ??????? Lua ?? ??????.
lua_tinker::class_add<base>(L, "base");
// base ?? ????? ??????.
lua_tinker::class_def<base>(L, "is_base", &base::is_base);
// test ??????? Lua ?? ??????.
lua_tinker::class_add<test>(L, "test");
// test ?? base ?? ??? ??????? ??????.
lua_tinker::class_inh<test, base>(L);
// test ????? ??????? ??????.
lua_tinker::class_con<test>(L, lua_tinker::constructor<test,int>);
// test ?? ??????? ??????.
lua_tinker::class_def<test>(L, "is_test", &test::is_test);
lua_tinker::class_def<test>(L, "ret_void", &test::ret_void);
lua_tinker::class_def<test>(L, "ret_int", &test::ret_int);
lua_tinker::class_def<test>(L, "ret_mul", &test::ret_mul);
lua_tinker::class_def<test>(L, "get", &test::get);
lua_tinker::class_def<test>(L, "set", &test::set);
lua_tinker::class_mem<test>(L, "_test", &test::_test);
// Lua ???? ????? g_test ?? ??????? ??????.
lua_tinker::set(L, "g_test", &g_test);
// sample3.lua ?????? ?¦Å?/???????.
lua_tinker::dofile(L, "sample3.lua");
// ???¦Á?? ????
lua_close(L);
return 0;
}
