//----------------------------------------------------------------//
void MOAILuaObject::SetMemberTable ( MOAILuaState& state, int idx ) {
	UNUSED ( state );
	UNUSED ( idx );

	// TODO: what if object is a singleton?
	assert ( !this->GetLuaClass ()->IsSingleton ()); // TODO: should actually set the member table, not just crash

	idx = state.AbsIndex ( idx );
	
	this->PushLuaUserdata ( state ); // userdata
	lua_getmetatable ( state, - 1 ); // ref table
	lua_getmetatable ( state, - 1 ); // member table
	lua_getmetatable ( state, - 1 ); // interface table

	lua_pushvalue ( state, idx );
	lua_replace ( state, -3 );
	
	this->MakeLuaBinding ( state );
	state.Pop ( 1 );
}
Exemple #2
0
static struct sprite *
lookup(lua_State *L, struct sprite * spr) {
	int i;
	struct sprite * root = (struct sprite *)lua_touserdata(L, -1);
	lua_getuservalue(L,-1);
	for (i=0;sprite_component(root, i)>=0;i++) {
		struct sprite * child = root->data.children[i];
		if (child) {
			lua_rawgeti(L, -1, i+1);
			if (child == spr) {
				lua_replace(L,-2);
				return child;
			} else {
				lua_pop(L,1);
			}
		}
	}
	lua_pop(L,1);
	return NULL;
}
Exemple #3
0
LUALIB_API int luaopen_io(lua_State* L)
{
	createmeta(L);
	/* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
	newfenv(L, io_fclose);
	lua_replace(L, LUA_ENVIRONINDEX);
	/* open library */
	luaL_register(L, LUA_IOLIBNAME, iolib);
	/* create (and set) default files */
	newfenv(L, io_noclose);  /* close function for default files */
	createstdfile(L, stdin, IO_INPUT, "stdin");
	createstdfile(L, stdout, IO_OUTPUT, "stdout");
	createstdfile(L, stderr, 0, "stderr");
	lua_pop(L, 1);  /* pop environment for default files */
	lua_getfield(L, -1, "popen");
	newfenv(L, io_pclose);  /* create environment for 'popen' */
	lua_setfenv(L, -2);  /* set fenv for 'popen' */
	lua_pop(L, 1);  /* pop 'popen' */
	return 1;
}
static int class_call_event(lua_State* L) {

    if (lua_istable(L, 1)) {
        //class is not a metatable now, so must get it's metatable to access ".call" function. 2014.6.5 by SunLightJuly
        if (lua_getmetatable(L, 1)) {
            lua_replace(L, 1);
            lua_pushstring(L, ".call");
            lua_rawget(L, 1);
            if (lua_isfunction(L, -1)) {
                
                lua_insert(L, 1);
                lua_call(L, lua_gettop(L)-1, 1);
                
                return 1;
            }
        }
    }
    tolua_error(L,"Attempt to call a non-callable object.",NULL);
    return 0;
};
Exemple #5
0
int Xml_load (lua_State *L) {
    const char * filename = luaL_checkstring(L,1);
    FILE * file=fopen(filename,"r");
    char* buffer;
    size_t sz;

    if(!file)
        return luaL_error(L,"LuaXml ERROR: \"%s\" file error or file not found!",filename);

    fseek (file , 0 , SEEK_END);
    sz = ftell (file);
    rewind (file);
    buffer = (char*)malloc(sz+1);
    sz = fread (buffer,1,sz,file);
    fclose(file);
    buffer[sz]=0;
    lua_pushlightuserdata(L,buffer);
    lua_replace(L,1);
    return Xml_eval(L);
};
Exemple #6
0
int luaopen_sdl_audio(lua_State *L)
{
    lua_newtable(L);
    luaL_register(L, NULL, sdl_audiolib);
    lua_pushboolean(L, 1);
    lua_setfield(L, -2, "loaded");

    lua_createtable(L, 0, 2);
    lua_pushvalue(L, -1);
    lua_replace(L, luaT_environindex);
    lua_pushvalue(L, luaT_environindex);
    lua_pushcclosure(L, luaT_stdgc<music_t, luaT_environindex>, 1);
    lua_setfield(L, -2, "__gc");
    lua_pushvalue(L, 1);
    lua_setfield(L, -2, "__index");
    lua_pop(L, 1);
    luaT_register(L, NULL, sdl_musiclib);

    return 1;
}
Exemple #7
0
static int lua_member_lookup(lua_State* L) {
#define IFLUA_NUM_MEMB_LOOKUP(n, m) \
		if (strncmp(cstr, n, sizeof(n))==0){\
		lua_pushnumber(L, m );\
	}
#define IFLUA_STR_MEMB_LOOKUP(n, m) \
		if (strncmp(cstr, n, sizeof(n))==0){\
		lua_pushlstring(L, m.c_str(), m.size() );\
	}

	bind_t* state = lunar_t::check(L, 1);
	const char* cstr = lua_tostring(L, 2);
	CombatStats* stats = state->get_stats(L);

	if (!stats) {
		lua_pushnil(L);
		return 1;
	}

	IFLUA_NUM_MEMB_LOOKUP("hp", stats->core.hp)
	else IFLUA_NUM_MEMB_LOOKUP("mp", stats->core.mp)
	else IFLUA_NUM_MEMB_LOOKUP("max_hp", stats->core.max_hp)
	else IFLUA_NUM_MEMB_LOOKUP("max_mp", stats->core.max_mp)
	else IFLUA_NUM_MEMB_LOOKUP("strength", stats->core.strength)
	else IFLUA_NUM_MEMB_LOOKUP("magic", stats->core.magic)
	else IFLUA_NUM_MEMB_LOOKUP("defence", stats->core.defence)
	else IFLUA_NUM_MEMB_LOOKUP("willpower", stats->core.willpower)
	else IFLUA_NUM_MEMB_LOOKUP("speed", stats->movespeed)
	else IFLUA_NUM_MEMB_LOOKUP("xp", stats->class_stats.xp)
	else IFLUA_NUM_MEMB_LOOKUP("xpneeded", stats->class_stats.xpneeded)
	else IFLUA_NUM_MEMB_LOOKUP("level", stats->class_stats.xplevel)
	else IFLUA_STR_MEMB_LOOKUP("weapon_type", stats->equipment.weapon.weapon_entry().weapon_class)
	else {
		lua_getglobal(L, bind_t::className);
		int tableind = lua_gettop(L);
		lua_pushvalue(L, 2);
		lua_gettable(L, tableind);
		lua_replace(L, tableind);
	}
	return 1;
}
int jiveL_update_screen(lua_State *L) {
	JiveSurface *screen;

	/* stack is:
	 * 1: framework
	 */

	/* ping watchdog */
	// FIXME 30 seconds
	watchdog_keepalive(ui_watchdog, 3);

	if (!update_screen) {
		return 0;
	}

	lua_pushcfunction(L, jive_traceback);  /* push traceback function */

	lua_pushcfunction(L, _draw_screen);
	lua_pushvalue(L, 1);

	lua_getfield(L, 1, "screen");
	lua_getfield(L, -1, "surface");
	lua_replace(L, -2);
	screen = tolua_tousertype(L, -1, 0);

	lua_pushboolean(L, 0);

	if (lua_pcall(L, 3, 1, 2) != 0) {
		LOG_WARN(log_ui_draw, "error in update_screen:\n\t%s\n", lua_tostring(L, -1));
		return 0;
	}

	/* flip screen */
	if (lua_toboolean(L, -1)) {
		jive_surface_flip(screen);
	}

	lua_pop(L, 2);

	return 0;
}
Exemple #9
0
/*-------------------------------------------------------------------------*\
* object:receive() interface
\*-------------------------------------------------------------------------*/
int buffer_meth_receive(lua_State *L, p_buffer buf) {
    int err = IO_DONE, top = lua_gettop(L);
    luaL_Buffer b;
    size_t size;
    const char *part = luaL_optlstring(L, 3, "", &size);
    p_timeout tm = timeout_markstart(buf->tm);
    /* initialize buffer with optional extra prefix 
     * (useful for concatenating previous partial results) */
    luaL_buffinit(L, &b);
    luaL_addlstring(&b, part, size);
    /* receive new patterns */
    if (!lua_isnumber(L, 2)) {
        const char *p= luaL_optstring(L, 2, "*l");
        if (p[0] == '*' && p[1] == 'l') err = recvline(buf, &b);
        else if (p[0] == '*' && p[1] == 'a') err = recvall(buf, &b); 
        else luaL_argcheck(L, 0, 2, "invalid receive pattern");
        /* get a fixed number of bytes (minus what was already partially 
         * received) */
    } else err = recvraw(buf, (size_t) lua_tonumber(L, 2)-size, &b);
    /* check if there was an error */
    if (err != IO_DONE) {
        /* we can't push anyting in the stack before pushing the
         * contents of the buffer. this is the reason for the complication */
        luaL_pushresult(&b);
        lua_pushstring(L, buf->io->error(buf->io->ctx, err)); 
        lua_pushvalue(L, -2); 
        lua_pushnil(L);
        lua_replace(L, -4);
    } else {
        luaL_pushresult(&b);
        lua_pushnil(L);
        lua_pushnil(L);
    }
#ifdef LUASOCKET_DEBUG
    /* push time elapsed during operation as the last return value */
    lua_pushnumber(L, timeout_gettime() - timeout_getstart(tm));
#else
	(void)tm;
#endif
    return lua_gettop(L) - top;
}
	/// @brief __newindex closure
	/// @note upvalue 1: Member descriptor, non-permissions, and lookup data
	/// @note upvalue 2: Member setter table
	/// @note upvalue 3: Propagation boolean
	/// @note object: Object being accessed
	/// @note key: Lookup key
	/// @note value: Value to assign
	static int NewIndex (lua_State * L)
	{
		Lookup(L);	// object, key, value, data

		//
		lua_pushvalue(L, 2);// object, key, value, data, key
		lua_gettable(L, lua_upvalueindex(2));	// object, key, value, data, setter

		if (!lua_isnil(L, 5))
		{
			lua_insert(L, 1);	// setter, object, key, value, data
			lua_call(L, 4, 1);	// result

			if (!lua_isnil(L, 1) && lua_toboolean(L, lua_upvalueindex(3))) return 1;
		}

		//
		else
		{
			lua_pop(L, 1);	// object, key, value, data
			lua_replace(L, 1);	// data, key, value
			lua_rawgeti(L, lua_upvalueindex(1), eNoWrite);	// data, key, value, nowrite
			lua_pushvalue(L, 2);// data, key, value, nowrite, key
			lua_gettable(L, 4);	// data, key, value, nowrite, bNoWrite

			if (!lua_toboolean(L, 5))
			{
				//
				lua_pop(L, 2);	// data, key, value
				lua_rawgeti(L, lua_upvalueindex(1), eDescriptors);	// data, key, value, D
				lua_pushvalue(L, 2);// data, key, value, D, key
				lua_gettable(L, 4);	// data, key, value, D, D[key]

				if (!lua_isnil(L, 5)) NewIndexMember(L);

				else if (lua_toboolean(L, lua_upvalueindex(3))) return 1;
			}
		}

		return 0;
	}
Exemple #11
0
static int lua_SettingIterator(lua_State *L)
{
	int i = lua_tointeger(L, lua_upvalueindex(1));
	enumDBSettingsParam* param = (enumDBSettingsParam*)lua_touserdata(L, lua_upvalueindex(2));

	if (i < param->count)
	{
		lua_pushinteger(L, (i + 1));
		lua_replace(L, lua_upvalueindex(1));
		lua_pushstring(L, ptrA(mir_utf8encode(param->pszSettingName[i])));
		mir_free(param->pszSettingName[i]);
	}
	else
	{
		lua_pushnil(L);
		mir_free(param->pszSettingName);
		mir_free(param);
	}

	return 1;
}
Exemple #12
0
int push_table_instance(lua_State* L, int lo) {

    if (lua_istable(L, lo)) {

        lua_pushstring(L, ".c_instance");
        lua_gettable(L, lo);
        if (lua_isuserdata(L, -1)) {

            lua_replace(L, lo);
            return 1;
        } else {

            lua_pop(L, 1);
            return 0;
        };
    } else {
        return 0;
    };

    return 0;
};
static void *proxy_ThFunc(void *__ ) { 
	int ret_= 0, i; 
	TH_STATE *th= __th_state[(int )__ ]; 
	//在 L 中执行, 进行数据处理 ... 
	lua_State *L= th->L; //ret_= lua_resume(L, 0 ); 
	ret_= lua_pcall(L, 0, 1, 0 ); 
	//如果执行正确, L 栈高度 <= 1, 否则 > 1 
	i= lua_gettop(L ); if(1< i ) //清理不需要的返回值
		{ lua_replace(L, 1 ); lua_settop(L, 1 ); } 
	if(0!= ret_ ) { lua_pushinteger(L, ret_ ); //错误号 
		lua_pushvalue(L, -2 ); lua_remove(L, 1 ); //进行位置交换 
	} 
	pthread_mutex_lock(&MUTEX_S_ ); 
	__th_state[(int )__ ]= NULL; 
	pthread_mutex_unlock(&MUTEX_S_ ); 
	
	lua_gc(th->L, LUA_GCCOLLECT, 0 ); lua_close(th->L ); 
	pthread_detach(th->hTh ); if(th ) free(th ); 
	
	return NULL; 
} 
int luaopen_libmodbus(lua_State *L)
{

#ifdef LUA_ENVIRONINDEX
	/* set private environment for this module */
	lua_newtable(L);
	lua_replace(L, LUA_ENVIRONINDEX);
#endif

	/* metatable.__index = metatable */
	luaL_newmetatable(L, MODBUS_META_CTX);
	lua_pushvalue(L, -1);
	lua_setfield(L, -2, "__index");
	luaL_setfuncs(L, ctx_M, 0);

	luaL_newlib(L, R);

	modbus_register_defs(L, D, S);

	return 1;
}
int L_Container<Lua_MonsterClasses_Name, Lua_MonsterClass>::_iterator(lua_State *L)
{
    int32 index = static_cast<int32>(lua_tonumber(L, lua_upvalueindex(1)));
    while (index < Length())
    {
        if (Lua_MonsterClass::Valid(1 << index))
        {
            Lua_MonsterClass::Push(L, 1 << index);
            lua_pushnumber(L, ++index);
            lua_replace(L, lua_upvalueindex(1));
            return 1;
        }
        else
        {
            ++index;
        }
    }

    lua_pushnil(L);
    return 1;
}
int frmMain::_l_init(lua_State *L)
{
    frmMain *pThis = reinterpret_cast<frmMain*>(lua_touserdata(L, 1));

    THMapWrapper::wrap(L);

    // Create a new environment table: {
    //   [1] = <light userdata pThis>,
    // }
    lua_newtable(L);
    lua_insert(L, 1);
    lua_rawseti(L, 1, 1);
    lua_replace(L, LUA_ENVIRONINDEX);
    // NB: Following functions registered with above environment table

    luaT_execute(L, "MapEditorSetBlocks = ...", _l_set_blocks);
    luaT_execute(L, "MapEditorSetBlockBrush = ...", _l_set_block_brush);
    luaT_execute(L, "MapEditorInitWithLuaApp = ...", _l_init_with_lua_app);

    return 0;
}
Exemple #17
0
static int call_funcarray_from_lua(lua_State *L)
{
    mrp_funcarray_t *fa;
    int narg, top;
    size_t i;
    int j;
    int success;

    top  = lua_gettop(L);
    narg = top - 1;

    if (!(fa = to_funcarray(L, 1)))
        luaL_typerror(L, 1, "function array");

    if (fa->nfunc > 0 && !fa->funcs)
        luaL_error(L, "attempt to call a corruptfunction array");

    success = true;

    for (i = 0;   i < fa->nfunc;   i++) {
        mrp_funcbridge_push(L, fa->funcs[i]);

        for (j = 0;  j < narg;  j++)
            lua_pushvalue(L, j+2);

        make_lua_call(L, fa->funcs[i], top+1);

        if (!lua_isboolean(L, -1) || !lua_toboolean(L, -1))
            success = false;

        lua_settop(L, top);
    }

    lua_pushboolean(L, success);
    lua_replace(L, 1);

    lua_settop(L, 1);

    return 1;
}
Exemple #18
0
int jiveL_style_path(lua_State *L) {
	int numStrings = 0;

	lua_pushvalue(L, 1);
	while (!lua_isnil(L, -1)) {
		lua_getfield(L, -1, "style");
		if (!lua_isnil(L, -1)) {
			lua_insert(L, 2);
			lua_pushstring(L, ".");
			lua_insert(L, 2);
			numStrings += 2;
		}
		else {
			lua_pop(L, 1);
		}
		
		lua_getfield(L, -1, "styleModifier");
		if (!lua_isnil(L, -1)) {
			lua_insert(L, 2);
			lua_pushstring(L, ".");
			lua_insert(L, 2);
			numStrings += 2;
		}
		else {
		    lua_pop(L, 1);
		}

		lua_getfield(L, -1, "parent");
		lua_replace(L, -2);
	}
	lua_pop(L, 1);

	lua_concat(L, numStrings - 1);
	lua_remove(L, -2);

	lua_pushvalue(L, -1);
	lua_setfield(L, 1, "_stylePath");

	return 1;
}
Exemple #19
0
// __len metamethod handler
static int l_str_len(lua_State *L)
{
    luaL_checktype(L, 1, LUA_TUSERDATA);

    // Fetch proxied value
    aux_push_weak_table(L, 0);
    lua_pushvalue(L, 1);
    lua_gettable(L, -2);

    // String tables are proxied in Lua, and Lua tables do not honour __len
    // so use ipairs to get the unproxied table to call __len on.
    if(lua_type(L, -1) == LUA_TTABLE)
    {
        lua_getglobal(L, "ipairs");
        lua_insert(L, -2);
        lua_call(L, 1, 2);
        lua_replace(L, -2);
    }

    lua_pushinteger(L, (lua_Integer)lua_objlen(L, -1));
    return 1;
}
Exemple #20
0
//----------------------------------------------------------------//
bool MOAILuaObject::PushRefTable ( MOAILuaState& state ) {

	MOAILuaClass* luaClass = this->GetLuaClass ();
	if ( !luaClass ) {
		lua_pushnil ( state );
		return false;
	}
	
	if ( luaClass->IsSingleton ()) {
		luaClass->PushRefTable ( state );
		return true;
	}

	if ( this->PushLuaUserdata ( state )) {
		int result = lua_getmetatable ( state, -1 );
		if ( result ) {
			lua_replace ( state, -2 );
			return true;
		}
	}
	return false;
}
Exemple #21
0
/* See STRATEGY section below */
static int got_array_value(lua_State* L) {
    /* ..., Table, Integer, Func, Value */
    lua_pushliteral(L, "length");
    /* ..., Table, Integer, Func, Value, "length" */
    lua_pushvalue(L, -1);
    /* ..., Table, Integer, Func, Value, "length", "length" */
    lua_rawget(L, -6);
    /* ..., Table, Integer, Func, Value, "length", len */
    long len = lua_tonumber(L, -1);
    lua_pop(L, 1);
    /* ..., Table, Integer, Func, Value, "length" */
    lua_pushnumber(L, len + 1);
    /* ..., Table, Integer, Func, Value, "length", len */
    lua_rawset(L, -6);

    /* ..., Table, Integer, Func, Value */
    lua_rawseti(L, -4, lua_tointeger(L, -3));
    lua_pushinteger(L, lua_tointeger(L, -2)+1);
    lua_replace(L, -3);

    return 0; /* Ignored. */
}
Exemple #22
0
static int search_path(lua_State *L, int widget, char *path, const char *key) {
	char *tok = strtok(path, ".");
	while (tok) {
		lua_pushstring(L, tok);
		lua_gettable(L, -2);

		if (lua_isnil(L, -1)) {
			lua_pop(L, 1);
			return 0;
		}

		luaL_checktype(L, -1, LUA_TTABLE);
		lua_replace(L, -2);

		tok = strtok(NULL, ".");
	}

	lua_pushstring(L, key);
	lua_gettable(L, -2);

	return 1;
}
Exemple #23
0
void *lualoom_getnativepointer(lua_State *L, int index, bool replaceIndex, const char *typecheck)
{
    index = lua_absindex(L, index);

    lmAssert(!lua_isnil(L, index), "Interal Error: lua_getnativepointer() passes null value for type %s", typecheck ? typecheck : "Undefined");
    lmAssert(lua_istable(L, index), "Interal Error: lua_getnativepointer() received non-table for type %s", typecheck ? typecheck : "Undefined");

    if (typecheck)
    {
        lua_rawgeti(L, index, LSINDEXTYPE);
        Type *type = (Type *)lua_topointer(L, -1);
        lmAssert(type, "Interal Error: Unable to get valid Type* from native instance table");
        lmAssert(type->getFullName() == typecheck, "Interal Error: Type mismatch in lua_getnativepointer().  Expected %s, received %s", typecheck, type->getFullName().c_str());
        lua_pop(L, 1);
    }

    lua_rawgeti(L, index, LSINDEXNATIVE);

    lmAssert(lua_isuserdata(L, -1), "Interal Error: lua_getpointer() native index is not a userdata");

    int _index = -1;
    if (replaceIndex)
    {
        lua_replace(L, index);
        _index = index;
    }

    LS::Detail::Userdata *p = (Detail::Userdata *)lua_topointer(L, _index);
    lmAssert(p, "Interal Error: lua_getpointer() invalid pointer on lua stack");
    void *pointer = p->getPointer();
    lmAssert(pointer, "Interal Error: lua_getpointer() unable to get pointer from Userdata");

    if (!replaceIndex)
    {
        lua_pop(L, 1);
    }

    return pointer;
}
Exemple #24
0
static inline int get_callback(int win, const char* name)
{
	// get callback registry for active window
	lua_pushstring(LUA, CALLBACKS_NAME);
	lua_rawget(LUA, LUA_REGISTRYINDEX);
	lua_pushinteger(LUA, win);
	lua_rawget(LUA, -2);

	// get requested callback
	lua_pushstring(LUA, name);
	lua_rawget(LUA, -2);

	int is_function = lua_isfunction(LUA, -1);
	if (is_function) {
		// leave only function on stack
		lua_replace(LUA, -3);
		lua_pop(LUA, 1);
	} else {
		lua_pop(LUA, 3);
	}
	return is_function;
}
Exemple #25
0
LUA_API int luaS_rawnetobj(lua_State *L, int index)
{
	int *ud;

	if (lua_istable(L, index))
	{
		lua_pushvalue(L, index);
		while (lua_istable(L, -1))
		{
			lua_pushstring(L, "__base");
			lua_rawget(L, -2);
			lua_remove(L, -2);
		}
		if (lua_isuserdata(L, -1) > 0)
			lua_replace(L, index);
		else
			luaL_error(L, "arg %d expect object, but get a table", index);
	}

	ud = lua_touserdata(L, index);
	return (ud != NULL)?*ud:-1;
}
Exemple #26
0
void
luaconf_freeElt(luaconf_elt *elt)
{
    int         top;
    lua_State   *L;

    L = elt->L;
    top = lua_gettop(L);

    if (top == elt->pos) {          // at top
        lua_pop(L, 1);

        while (lua_gettop(L) > 0 && lua_isnil(L, -1))
            lua_pop(L, 1);

    } else {
        lua_pushnil(L);
        lua_replace(L, elt->pos);
    }

    free(elt);
}
Exemple #27
0
LUALIB_API int luaopen_package (lua_State *L) {
  int i;
  /* create new type _LOADLIB */
  luaL_newmetatable(L, "_LOADLIB");
  lua_pushcfunction(L, gctm);
  lua_setfield(L, -2, "__gc");
  /* create `package' table */
  luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
#if defined(LUA_COMPAT_LOADLIB)
  lua_getfield(L, -1, "loadlib");
  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
#endif
  lua_pushvalue(L, -1);
  lua_replace(L, LUA_ENVIRONINDEX);
  /* create `loaders' table */
  lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);
  /* fill it with pre-defined loaders */
  for (i=0; loaders[i] != nullptr; i++) {
    lua_pushcfunction(L, loaders[i]);
    lua_rawseti(L, -2, i+1);
  }
  lua_setfield(L, -2, "loaders");  /* put it in field `loaders' */
  setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT);  /* set field `path' */
  setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
  /* store config information */
  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
                     LUA_EXECDIR "\n" LUA_IGMARK);
  lua_setfield(L, -2, "config");
  /* set field `loaded' */
  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
  lua_setfield(L, -2, "loaded");
  /* set field `preload' */
  lua_newtable(L);
  lua_setfield(L, -2, "preload");
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  luaL_register(L, nullptr, ll_funcs);  /* open lib into global table */
  lua_pop(L, 1);
  return 1;  /* return 'package' table */
}
Exemple #28
0
int
mlua_index_with_properties (lua_State *L, const struct luaL_Reg *properties,
			    bool use_cache)
{
  char const * key;
  const struct luaL_Reg *reg;

  key = lua_tostring (L, 2);
  if (key == NULL)
    return 0;

  reg = mlua_find_method (properties, key);
  if (reg)
    {
      return mlua_get_property (L, reg, use_cache);
    }

  lua_getmetatable (L, 1);
  lua_replace (L, 1);
  lua_gettable (L, 1);
  return 1;
}
Exemple #29
0
static int fluent_Do(lua_State *L)
{
	luaL_checktype(L, 1, LUA_TFUNCTION);

	lua_getfield(L, lua_upvalueindex(1), "Interval");
	int interval = luaL_optinteger(L, -1, 0);
	lua_pop(L, 1);

	lua_getfield(L, lua_upvalueindex(1), "Timestamp");
	time_t timestamp = lua_tointeger(L, -1);
	lua_pop(L, 1);

	time_t now = time(NULL);
	if (timestamp < now)
	{
		if (interval == 0)
			return 0;
		timestamp += (((now - timestamp) / interval) + 1) * interval;
	}

	lua_pushnil(L);
	lua_replace(L, lua_upvalueindex(1));

	ScheduleTask *task = new ScheduleTask();
	task->timestamp = timestamp;
	task->interval = interval;
	task->L = lua_newthread(L);
	task->threadRef = luaL_ref(L, LUA_REGISTRYINDEX);
	lua_pushvalue(L, 1);
	task->callbackRef = luaL_ref(L, LUA_REGISTRYINDEX);
	{
		mir_cslock lock(threadLock);
		tasks.insert(task);
	}
	SetEvent(hScheduleEvent);

	return 0;
}
static int magnet_env_next(lua_State *L) {
	server *srv;
	connection *con;
	int pos = lua_tointeger(L, lua_upvalueindex(1));

	buffer *dest;

	lua_pushstring(L, "lighty.srv");
	lua_gettable(L, LUA_REGISTRYINDEX);
	srv = lua_touserdata(L, -1);
	lua_pop(L, 1);

	lua_pushstring(L, "lighty.con");
	lua_gettable(L, LUA_REGISTRYINDEX);
	con = lua_touserdata(L, -1);
	lua_pop(L, 1);

	lua_settop(L, 0);

	if (NULL == magnet_env[pos].name) return 0; /* end of list */

	lua_pushstring(L, magnet_env[pos].name);

	dest = magnet_env_get_buffer_by_id(srv, con, magnet_env[pos].type);
	if (dest && dest->used) {
		lua_pushlstring(L, dest->ptr, dest->used - 1);
	} else {
		lua_pushnil(L);
	}

	/* Update our positional upval to reflect our new current position */
	pos++;
	lua_pushinteger(L, pos);
	lua_replace(L, lua_upvalueindex(1));

	/* Returning 2 items on the stack (key, value) */
	return 2;
}