Exemplo n.º 1
0
static int auxupvalue (lua_State *L, int get) {
  const char *name;
  int n = luaL_checkint(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
  if (name == NULL) return 0;
  lua_pushstring(L, name);
  lua_insert(L, -(get+1));
  return get + 1;
}
Exemplo n.º 2
0
/* copies upvalues between lua states' stacks */
static int luaproc_copyupvalues( lua_State *Lfrom, lua_State *Lto, 
                                 int funcindex ) {

  int i = 1;
  const char *str;
  size_t len;

  /* test the type of each upvalue and, if it's supported, copy it */
  while ( lua_getupvalue( Lfrom, funcindex, i ) != NULL ) {
    switch ( lua_type( Lfrom, -1 )) {
      case LUA_TBOOLEAN:
        lua_pushboolean( Lto, lua_toboolean( Lfrom, -1 ));
        break;
      case LUA_TNUMBER:
        copynumber( Lto, Lfrom, -1 );
        break;
      case LUA_TSTRING: {
        str = lua_tolstring( Lfrom, -1, &len );
        lua_pushlstring( Lto, str, len );
        break;
      }
      case LUA_TNIL:
        lua_pushnil( Lto );
        break;
      /* if upvalue is a table, check whether it is the global environment
         (_ENV) from the source state Lfrom. in case so, push in the stack of
         the destination state Lto its own global environment to be set as the
         corresponding upvalue; otherwise, treat it as a regular non-supported
         upvalue type. */
      case LUA_TTABLE:
        lua_pushglobaltable( Lfrom );
        if ( isequal( Lfrom, -1, -2 )) {
          lua_pop( Lfrom, 1 );
          lua_pushglobaltable( Lto );
          break;
        }
        lua_pop( Lfrom, 1 );
        /* FALLTHROUGH */
      default: /* value type not supported: table, function, userdata, etc. */
        lua_pushnil( Lfrom );
        lua_pushfstring( Lfrom, "failed to copy upvalue of unsupported type "
                                "'%s'", luaL_typename( Lfrom, -2 ));
        return FALSE;
    }
    lua_pop( Lfrom, 1 );
    if ( lua_setupvalue( Lto, 1, i ) == NULL ) {
      lua_pushnil( Lfrom );
      lua_pushstring( Lfrom, "failed to set upvalue" );
      return FALSE;
    }
    i++;
  }
  return TRUE;
}
Exemplo n.º 3
0
static int luaB_loadfile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  const char *mode = luaL_optstring(L, 2, NULL);
  int env = !lua_isnone(L, 3);  /* 'env' parameter? */
  int status = luaL_loadfilex(L, fname, mode);
  if (status == LUA_OK && env) {  /* 'env' parameter? */
    lua_pushvalue(L, 3);
    lua_setupvalue(L, -2, 1);  /* set it as 1st upvalue of loaded chunk */
  }
  return load_aux(L, status);
}
Exemplo n.º 4
0
void am_setfenv(lua_State *L, int index) {
    assert(lua_isfunction(L, index));
    assert(lua_istable(L, -1));
#if defined(AM_LUAJIT) || defined(AM_LUA51)
    lua_setfenv(L, index);
#else
    const char *name = lua_setupvalue(L, index, 1);
    assert(strcmp(name, "_ENV") == 0);
    AM_UNUSED(name);
#endif
}
Exemplo n.º 5
0
static int Lcallback(lua_State *L) {
    ls_EventSlot *slot = checkslot(L, 1);
    lua_settop(L, 2);
    lua_pushvalue(L, 1);
    setcbinfo(L, slot, 4);
    lua_getupvalue(L, -1, UV_SELF);
    if (!lua_isnone(L, 2)) {
        lua_pushvalue(L, 2);
        lua_setupvalue(L, -3, UV_CB);
    }
    return 1;
}
Exemplo n.º 6
0
static void setcbinfo(lua_State *L, ls_EventSlot *slot, int upvalue) {
    lsL_getregistry(L, LS_EVENT_CBOX); /* 1 */
    lua_rawgetp(L, -1, (void*)slot); /* 2 */
    if (lua_isnil(L, -1)) {
        lua_settop(L, lua_gettop(L) + 3); /* 2,3,4,5 */
        lua_pushcclosure(L, Lcb_impl, 4); /* 2,3,4,5->2 */
        lua_pushvalue(L, -1); /* 2->3 */
        lua_rawsetp(L, -3, (void*)slot); /* 3->1 */
    }
    lua_remove(L, -2); /* (1) */
    lua_pushvalue(L, -2);
    lua_setupvalue(L, -2, upvalue);
}
Exemplo n.º 7
0
/*
** changes the environment variable of calling function
*/
static void set_env(lua_State *L)
{
	lua_Debug ar;

	if(lua_getstack(L, 1, &ar) == 0 ||
	        lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
	        lua_iscfunction(L, -1))
		luaL_error(L, LUA_QL("module") " not called from a Lua function");

	lua_pushvalue(L, -2);  /* copy new environment table to top */
	lua_setupvalue(L, -2, 1);
	lua_pop(L, 1);  /* remove function */
}
Exemplo n.º 8
0
const char * io_template_render(io_template_t *T)
{
	lua_State *L;
	size_t len;
	char *lua_code, *lua_name;

	L = luaL_newstate();

	luaL_openlibs(L);
	io_require_io(L);

	lua_pushlightuserdata(L, T);
	lua_setfield(L, LUA_REGISTRYINDEX, "io_template");

	sds output = sdsempty();
	lua_pushlightuserdata(L, &output);
	lua_setfield(L, LUA_REGISTRYINDEX, "io_output");

	lua_code = T->code;
	lua_name = T->name;

	if (luaL_loadbuffer(L, lua_code, strlen(lua_code), lua_name) == LUA_OK) {
		// stash = ...
		io_object_to_lua_stack(T->stash, L);

		// stash_mt = { __index = _G }
		lua_newtable(L);
		lua_pushinteger(L, LUA_RIDX_GLOBALS);
		lua_gettable(L, LUA_REGISTRYINDEX);
		lua_setfield(L, -2, "__index");

		// setmetatable(stash, stash_mt)
		lua_setmetatable(L, -2);

		// Set environment and call function.
		lua_setupvalue(L, -2, 1);
		lua_pcall(L, 0, 0, 0);
	} else {
		fprintf(stderr, "Error: %s\n", lua_tostring(L, -1));
	}

	len = sdslen(output);
	free(T->last_render);
	T->last_render = malloc(sizeof(char) * (len+1));
	strncpy(T->last_render, output, len+1);
	sdsfree(output);

	lua_close(L);

	return T->last_render;
}
Exemplo n.º 9
0
static int Ldeleteslot(lua_State *L) {
    ls_EventSlot **pslot = testslot(L, 1);
    if (pslot && *pslot) {
        ls_event_disconnect(*pslot);
        lua_pushnil(L);
        setcbinfo(L, *pslot, UV_SIGN);
        lua_pushnil(L);
        lua_setupvalue(L, -2, UV_SELF);
        lua_pushnil(L);
        lua_setmetatable(L, 1);
        *pslot = NULL;
    }
    return 0;
}
Exemplo n.º 10
0
static int luahtml_load(lua_State *L)
{
	struct luahtml_readdata rd;
	const char *outfunc = luaL_checkstring(L, 2);
	const char *chunkname = luaL_checkstring(L, 3);
	int res;

	if (lua_isuserdata(L, 1))
	{
		rd.utf8.file = luahtml_tofile(L);
		rd.utf8.readchar = luahtml_readfile;
	}
	else
	{
		rd.utf8.src = (unsigned char *) lua_tolstring(L, 1, &rd.utf8.srclen);
		rd.utf8.readchar = luahtml_readstring;
	}

	rd.utf8.accu = 0;
	rd.utf8.numa = 0;
	rd.utf8.bufc = -1;
	rd.code_present = 0;

	rd.state = PARSER_UNDEF;
	strcpy((char *) rd.buf0, " ");
	strcat((char *) rd.buf0, outfunc);
	strcat((char *) rd.buf0, "(");
	rd.buf = rd.buf0 + strlen((char *) rd.buf0);

#if LUA_VERSION_NUM < 502
	res = lua_load(L, luahtml_readparsed, &rd, chunkname);
#else
	res = lua_load(L, luahtml_readparsed, &rd, chunkname, NULL);
#endif
	if (res == 0)
	{
#if LUA_VERSION_NUM >= 502
		lua_pushvalue(L, 4);
		lua_setupvalue(L, -2, 1);
#endif
		lua_pushboolean(L, rd.code_present);
		return 2;
	}

	lua_pushnil(L);
	lua_insert(L, -2);
	/* nil, message on stack */
	return 2;
}
Exemplo n.º 11
0
static int debug_getupvalue(lua_State *L, int get)
{
  int32_t n = lj_lib_checkint(L, 2);
  if (isluafunc(lj_lib_checkfunc(L, 1))) {
    const char *name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
    if (name) {
      lua_pushstring(L, name);
      if (!get) return 1;
      copyTV(L, L->top, L->top-2);
      L->top++;
      return 2;
    }
  }
  return 0;
}
Exemplo n.º 12
0
static int load_aux (lua_State *L, int status, int envidx) {
  if (status == LUA_OK) {
    if (envidx != 0) {  /* 'env' parameter? */
      lua_pushvalue(L, envidx);  /* environment for loaded function */
      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
    }
    return 1;
  }
  else {  /* error (message is on top of the stack) */
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}
Exemplo n.º 13
0
static int console_autoexec(lua_State* l) {
	LUA_DEBUG_START(l);

	init_global_table(l); // _ENV

	LuaConsole *c = static_cast<LuaConsole *>(lua_touserdata(l, lua_upvalueindex(1)));
	RefCountedPtr<FileSystem::FileData> code = FileSystem::userFiles.ReadFile("console.lua");
	if (!code) {
		lua_pop(l, 1);
		LUA_DEBUG_END(l, 0);
		return 0;
	}

	int ret = pi_lua_loadfile(l, *code); // code, _ENV
	if (ret != LUA_OK) {
		if (ret == LUA_ERRSYNTAX) {
			const char *msg = lua_tostring(l, -1);
			Output("console.lua: %s\n", msg);
			lua_pop(l, 1);
		}
		c->AddOutput("Failed to run console.lua");
		lua_pop(l, 1); //popping _ENV
		LUA_DEBUG_END(l, 0);
		return 0;
	}

	// set the chunk's _ENV (globals) var
	lua_insert(l, -2); // _ENV, code
	lua_setupvalue(l, -2, 1); // code

	lua_pushcfunction(l, &capture_traceback); // traceback, code
	lua_insert(l, -2); // code, traceback

	ret = lua_pcall(l, 0, 0, -2);
	if (ret != LUA_OK) {
		const char *msg = lua_tostring(l, -1);
		Output("console.lua:\n%s\n", msg);
		c->AddOutput("Failed to run console.lua");
		lua_pop(l, 1);
	}

	// pop capture_traceback function
	lua_pop(l, 1);
	LUA_DEBUG_END(l, 0);

	return 0;

}
Exemplo n.º 14
0
/**
 * Apply the environment to the function on the top of the stack.
 *
 * The environment will be initialized for the first time if needed.
 *
 * The function will remain on the stack afterwards.
 */
void Env::SetupEnv()
{
	lua_State *state = GetState();

	// fn - The compiled function.
	// env - The table that will be the environment for the function.

	// Initial stack: fn

	PushEnv();  // fn env

	// Apply the environment to the function.
	// Compiled Lua functions have one upvalue, which is the environment
	// it will execute in.
	lua_setupvalue(state, -2, 1);  // fn
}
Exemplo n.º 15
0
void Script::Start() {
    // run on_start in gameobject's _ENV
    if (ObjectId == -1) {
        return;
    }
    lua_getglobal(vm, "objects");
    lua_geti(vm, -1, ObjectId);
    lua_getfield(vm, -1, "on_start");
    // push ms
    lua_pushvalue(vm, -2);
    lua_setupvalue(vm, -2, 1);
    int ret = lua_pcall(vm, 0, LUA_MULTRET, 0);
    if (ret) {
        printf("eror pcall: %s\n", lua_tostring(vm, -1));
    }
    lua_pop(vm, 2);
}
Exemplo n.º 16
0
static inline void luaqueue_grown(lua_State* L,struct queue* q,int functab,int valuetbl){
    uint64_t i;
    uint64_t newsz=q->size<<1;
    lua_createtable(L,newsz,0);
    setreadonly(L,-1);
    for(i=q->read;i<q->write;i++){
        lua_rawgeti(L,valuetbl,(i&(q->size-1))+1);
        lua_rawseti(L,-2,(i&(newsz-1))+1);
    }
    lua_pushnil(L);
    while(lua_next(L,functab)){
        lua_pushvalue(L,-3);
        lua_setupvalue(L,-2,2);
        lua_pop(L,1);
    }
    q->size=newsz;
}
Exemplo n.º 17
0
lua_scripts::script_info *lua_scripts::load_script(lua_State *L, char *filename) {
    if (int error = luaL_loadfile(L, filename)) {
        switch (error) {
            case LUA_ERRSYNTAX:
                gcs().send_text(MAV_SEVERITY_CRITICAL, "Lua: Syntax error in %s", filename);
                return nullptr;
            case LUA_ERRMEM:
                gcs().send_text(MAV_SEVERITY_CRITICAL, "Lua: Insufficent memory loading %s", filename);
                return nullptr;
            case LUA_ERRFILE:
                gcs().send_text(MAV_SEVERITY_CRITICAL, "Lua: Unable to load the file: %s", lua_tostring(L, -1));
                hal.console->printf("Lua: File error: %s\n", lua_tostring(L, -1));
                return nullptr;
            default:
                gcs().send_text(MAV_SEVERITY_CRITICAL, "Lua: Unknown error (%d) loading %s", error, filename);
                return nullptr;
        }
    }

    script_info *new_script = (script_info *)hal.util->heap_realloc(_heap, nullptr, sizeof(script_info));
    if (new_script == nullptr) {
        // No memory, shouldn't happen, we even attempted to do a GC
        gcs().send_text(MAV_SEVERITY_CRITICAL, "Lua: Insufficent memory loading %s", filename);
        lua_pop(L, 1); // we can't use the function we just loaded, so ditch it
        return nullptr;
    }

    new_script->name = filename;
    new_script->next = nullptr;


    // find and create a sandbox for the new chunk
    lua_getglobal(L, "get_sandbox_env");
    if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
        gcs().send_text(MAV_SEVERITY_CRITICAL, "Scripting: Could not create sandbox: %s", lua_tostring(L, -1));
        hal.console->printf("Lua: Scripting: Could not create sandbox: %s", lua_tostring(L, -1));
        return nullptr;
    }
    load_generated_sandbox(L);
    lua_setupvalue(L, -2, 1);

    new_script->lua_ref = luaL_ref(L, LUA_REGISTRYINDEX);   // cache the reference
    new_script->next_run_ms = AP_HAL::millis64() - 1; // force the script to be stale

    return new_script;
}
Exemplo n.º 18
0
int luaT_setfenv52(lua_State *L, int iIndex)
{
    int iType = lua_type(L, iIndex);
    switch(iType)
    {
    case LUA_TUSERDATA:
        lua_setuservalue(L, iIndex);
        return 1;
    case LUA_TFUNCTION:
        if(lua_iscfunction(L, iIndex))
        {
            // Our convention: upvalue at #1 is environment
            if(lua_setupvalue(L, iIndex, 1) == nullptr)
            {
                lua_pop(L, 1);
                return 0;
            }
            return 1;
        }
        else
        {
            // Language convention: upvalue called _ENV is environment, which
            // might be shared with other functions.
            const char* sUpName = nullptr;
            for(int i = 1; (sUpName = lua_getupvalue(L, iIndex, i)) ; ++i)
            {
                lua_pop(L, 1); // lua_getupvalue puts the value on the stack, but we just want to replace it
                if(std::strcmp(sUpName, "_ENV") == 0)
                {
                    luaL_loadstring(L, "local upv = ... return function() return upv end");
                    lua_insert(L, -2);
                    lua_call(L, 1, 1);
                    lua_upvaluejoin(L, iIndex, i, -1, 1);
                    lua_pop(L, 1);
                    return 1;
                }
            }
            lua_pop(L, 1);
            return 0;
        }
    default:
        return 0;
    }
}
Exemplo n.º 19
0
int Script::Update(int ms) {
    // run update in gameobject's _ENV
    if (ObjectId == -1) {
        return 1;
    }
    lua_getglobal(vm, "objects");
    lua_geti(vm, -1, ObjectId);
    lua_getfield(vm, -1, "update");
    // push ms
    lua_pushinteger(vm, ms);
    lua_pushvalue(vm, -3);
    lua_setupvalue(vm, -3, 1);
    int ret = lua_pcall(vm, 1, LUA_MULTRET, 0);
    if (ret) {
        printf("eror pcall: %s\n", lua_tostring(vm, -1));
    }
    lua_pop(vm, 2);
    // printf("%d\n", lua_gettop(vm));
    return 0;
}
Exemplo n.º 20
0
static void magnet_setfenv_mainfn(lua_State *L, int funcIndex) { /* (-1, 0, -) */
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
	/* set "_ENV" upvalue, which should be the first upvalue of a "main" lua
	 * function if it uses any global names
	 */

	const char* first_upvalue_name = lua_getupvalue(L, funcIndex, 1);
	if (NULL == first_upvalue_name) return; /* doesn't have any upvalues */
	lua_pop(L, 1); /* only need the name of the upvalue, not the value */

	if (0 != strcmp(first_upvalue_name, "_ENV")) return;

	if (NULL == lua_setupvalue(L, funcIndex, 1)) {
		/* pop value if lua_setupvalue didn't set the (not existing) upvalue */
		lua_pop(L, 1);
	}
#else
	lua_setfenv(L, funcIndex);
#endif
}
Exemplo n.º 21
0
static int luaB_load(lua_State *L) {
    int status;
    size_t l;
    int top = lua_gettop(L);
    const char *s = lua_tolstring(L, 1, &l);
    const char *mode = luaL_optstring(L, 3, "bt");
    if(s != NULL) {   /* loading a string? */
        const char *chunkname = luaL_optstring(L, 2, s);
        status = luaL_loadbufferx(L, s, l, chunkname, mode);
    } else { /* loading from a reader function */
        const char *chunkname = luaL_optstring(L, 2, "=(load)");
        luaL_checktype(L, 1, LUA_TFUNCTION);
        lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
        status = lua_load(L, generic_reader, NULL, chunkname, mode);
    }
    if(status == LUA_OK && top >= 4) {   /* is there an 'env' argument */
        lua_pushvalue(L, 4);  /* environment for loaded function */
        lua_setupvalue(L, -2, 1);  /* set it as 1st upvalue */
    }
    return load_aux(L, status);
}
Exemplo n.º 22
0
static void Lcb_helper(void *ud, void *evtdata, ls_EventSignal *signal, ls_EventSlot *self) {
    lua_State *L = (lua_State*)ud;
    int top = lua_gettop(L);
    (void)signal; /* unused argument */
    lsL_getregistry(L, LS_EVENT_CBOX);
    lua_rawgetp(L, -1, (void*)self);
    if (!lua_isnil(L, -1)) {
        if (evtdata != NULL) {
            lsL_getregistry(L, LS_EVENT_PBOX);
            lua_rawgetp(L, -1, evtdata);
            lua_setupvalue(L, -3, UV_UD);
            lua_call(L, 0, 0);
        }
        else {
            int i, args = lua_tointeger(L, top);
            for (i = 0; i < args; ++i)
                lua_pushvalue(L, top-args+i);
            lua_call(L, args, 0);
        }
    }
    lua_settop(L, top);
}
Exemplo n.º 23
0
//handle event
int Script::HandleEvent(Event * Evt) {
    if (ObjectId == -1) {
        return 1;
    }
    // user event is larger than USER_EVENT
    if (Evt->EventId > USER_EVENT) {
        // this is event sent from scripts	
        // get evnet table
        lua_getglobal(vm, "objects");
        lua_geti(vm, -1, ObjectId);
        lua_getfield(vm, -1, "event");
        // call callback within _ENV
        lua_geti(vm, -1, Evt->EventId);
        lua_pushvalue(vm, -3);
        lua_setupvalue(vm, -2, 1);
        int ret = lua_pcall(vm, 0, LUA_MULTRET, 0);
        if (ret) {
            printf("eror pcall: %s %d\n", lua_tostring(vm, -1), __LINE__);
        }
        // balance the stack
        lua_pop(vm, 3);
    }
    return 0;
}
Exemplo n.º 24
0
void LuaConsole::ExecOrContinue() {
	const std::string stmt = m_entryField->GetText();
	int result;
	lua_State *L = Lua::manager->GetLuaState();

    // If the statement is an expression, print its final value.
	result = luaL_loadbuffer(L, ("return " + stmt).c_str(), stmt.size()+7, CONSOLE_CHUNK_NAME);
	if (result == LUA_ERRSYNTAX)
		result = luaL_loadbuffer(L, stmt.c_str(), stmt.size(), CONSOLE_CHUNK_NAME);

	// check for an incomplete statement
	// (follows logic from the official Lua interpreter lua.c:incomplete())
	if (result == LUA_ERRSYNTAX) {
		const char eofstring[] = "<eof>";
		size_t msglen;
		const char *msg = lua_tolstring(L, -1, &msglen);
		if (msglen >= (sizeof(eofstring) - 1)) {
			const char *tail = msg + msglen - (sizeof(eofstring) - 1);
			if (strcmp(tail, eofstring) == 0) {
				// statement is incomplete -- allow the user to continue on the next line
				m_entryField->SetText(stmt + "\n");
				m_entryField->ResizeRequest();
				ResizeRequest();
				lua_pop(L, 1);
				return;
			}
		}
	}

	if (result == LUA_ERRSYNTAX) {
		size_t msglen;
		const char *msg = lua_tolstring(L, -1, &msglen);
		AddOutput(std::string(msg, msglen));
		lua_pop(L, 1);
		return;
	}

	if (result == LUA_ERRMEM) {
		// this will probably fail too, since we've apparently
		// just had a memory allocation failure...
		AddOutput("memory allocation failure");
		return;
	}

	// set the global table
	lua_getfield(L, LUA_REGISTRYINDEX, "ConsoleGlobal");
	lua_setupvalue(L, -2, 1);

	std::istringstream stmt_stream(stmt);
	std::string string_buffer;

	std::getline(stmt_stream, string_buffer);
	AddOutput("> " + string_buffer);

	while(!stmt_stream.eof()) {
		std::getline(stmt_stream, string_buffer);
		AddOutput("  " + string_buffer);
	}

	// perform a protected call
	int top = lua_gettop(L) - 1; // -1 for the chunk itself
	result = lua_pcall(L, 0, LUA_MULTRET, 0);

	if (result == LUA_ERRRUN) {
		size_t len;
		const char *s = lua_tolstring(L, -1, &len);
		AddOutput(std::string(s, len));
	} else if (result == LUA_ERRERR) {
		size_t len;
		const char *s = lua_tolstring(L, -1, &len);
		AddOutput("error in error handler: " + std::string(s, len));
	} else if (result == LUA_ERRMEM) {
		AddOutput("memory allocation failure");
	} else {
		int nresults = lua_gettop(L) - top;
		if (nresults) {
			std::ostringstream ss;

			// call tostring() on each value and display it
			lua_getglobal(L, "tostring");
			// i starts at 1 because Lua stack uses 1-based indexing
			for (int i = 1; i <= nresults; ++i) {
				ss.str(std::string());
				if (nresults > 1)
					ss << "[" << i << "] ";

				// duplicate the tostring function for the call
				lua_pushvalue(L, -1);
				lua_pushvalue(L, top+i);

				result = lua_pcall(L, 1, 1, 0);
				size_t len = 0;
				const char *s = 0;
				if (result == 0)
					s = lua_tolstring(L, -1, &len);
				ss << s ? std::string(s, len) : "<internal error when converting result to string>";

				// pop the result
				lua_pop(L, 1);

				AddOutput(ss.str());
			}
		}
	}

	// pop all return values
	lua_settop(L, top);

	// update the history list

	if (! result) {
		// command succeeded... add it to the history unless it's just
		// an exact repeat of the immediate last command
		if (m_statementHistory.empty() || (stmt != m_statementHistory.back()))
			m_statementHistory.push_back(stmt);

		// clear the entry box
		m_entryField->SetText("");
		ResizeRequest();
	}

	// always forget the history position and clear the stashed command
	m_historyPosition = -1;
	m_stashedStatement.clear();
}
Exemplo n.º 25
0
LUAMOD_API int
luaopen_profile(lua_State *L) {
	luaL_checkversion(L);
	luaL_Reg l[] = {
		{ "start", lstart },
		{ "stop", lstop },
		{ "resume", lresume },
		{ "yield", lyield },
		{ "resume_co", lresume_co },
		{ "yield_co", lyield_co },
		{ NULL, NULL },
	};
	luaL_newlibtable(L,l);
	lua_newtable(L);	// table thread->start time
	lua_newtable(L);	// table thread->total time

	lua_newtable(L);	// weak table
	lua_pushliteral(L, "kv");
	lua_setfield(L, -2, "__mode");

	lua_pushvalue(L, -1);
	lua_setmetatable(L, -3); 
	lua_setmetatable(L, -3);

	lua_pushnil(L);	// cfunction (coroutine.resume or coroutine.yield)
	luaL_setfuncs(L,l,3);

	int libtable = lua_gettop(L);

	lua_getglobal(L, "coroutine");
	lua_getfield(L, -1, "resume");

	lua_CFunction co_resume = lua_tocfunction(L, -1);
	if (co_resume == NULL)
		return luaL_error(L, "Can't get coroutine.resume");
	lua_pop(L,1);

	lua_getfield(L, libtable, "resume");
	lua_pushcfunction(L, co_resume);
	lua_setupvalue(L, -2, 3);
	lua_pop(L,1);

	lua_getfield(L, libtable, "resume_co");
	lua_pushcfunction(L, co_resume);
	lua_setupvalue(L, -2, 3);
	lua_pop(L,1);

	lua_getfield(L, -1, "yield");

	lua_CFunction co_yield = lua_tocfunction(L, -1);
	if (co_yield == NULL)
		return luaL_error(L, "Can't get coroutine.yield");
	lua_pop(L,1);

	lua_getfield(L, libtable, "yield");
	lua_pushcfunction(L, co_yield);
	lua_setupvalue(L, -2, 3);
	lua_pop(L,1);

	lua_getfield(L, libtable, "yield_co");
	lua_pushcfunction(L, co_yield);
	lua_setupvalue(L, -2, 3);
	lua_pop(L,1);

	lua_settop(L, libtable);

	return 1;
}
Exemplo n.º 26
0
bool CMLuaScript::Load()
{
	status = Failed;

	if (luaL_loadfile(L, T2Utf(filePath)))
	{
		Log(lua_tostring(L, -1));
		return false;
	}

	lua_createtable(L, 0, 2);
	lua_pushvalue(L, -1);
	lua_setfield(L, -2, "_G");
	lua_pushlightuserdata(L, this);
	lua_setfield(L, -2, "Script");
	lua_createtable(L, 0, 2);
	lua_getglobal(L, "_G");
	lua_setfield(L, -2, "__index");
	lua_setmetatable(L, -2);
	lua_setupvalue(L, -2, 1);

	if (luaM_pcall(L, 0, 1))
		return false;

	status = Loaded;

	if (lua_isnoneornil(L, -1))
		return true;

	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
	lua_getfield(L, -1, moduleName);
	if (!lua_toboolean(L, -1))
	{
		lua_pop(L, 1);
		lua_pushvalue(L, -2);
		lua_setfield(L, -2, moduleName);
		lua_pop(L, 1);
	}
	else
		lua_remove(L, -2);

	if (!lua_istable(L, -1))
		return true;

	lua_getfield(L, -1, "Load");
	if (lua_isfunction(L, -1))
		luaM_pcall(L);
	else
		lua_pop(L, 1);

	lua_getfield(L, -1, "Unload");
	if (lua_isfunction(L, -1))
	{
		lua_pushvalue(L, -1);
		unloadRef = luaL_ref(L, LUA_REGISTRYINDEX);
	}
	lua_pop(L, 1);

	lua_pop(L, 1);

	return true;
}
Exemplo n.º 27
0
static void unpack_value
    (lua_State *L, const char *buf, size_t len, const char **p, int *idx)
{
    size_t l;
    char val_type = **p;
    mar_incr_ptr(MAR_CHR);
    switch (val_type) {
    case LUA_TBOOLEAN:
        lua_pushboolean(L, *(char*)*p);
        mar_incr_ptr(MAR_CHR);
        break;
    case LUA_TNUMBER:
        lua_pushnumber(L, *(lua_Number*)*p);
        mar_incr_ptr(MAR_I64);
        break;
    case LUA_TSTRING:
        mar_next_len(l, uint32_t);
        lua_pushlstring(L, *p, l);
        mar_incr_ptr(l);
        break;
    case LUA_TTABLE: {
        char tag = *(char*)*p;
        mar_incr_ptr(MAR_CHR);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, 2, ref);
        }
        else if (tag == MAR_TVAL) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            lua_pushvalue(L, -1);
            lua_rawseti(L, 2, (*idx)++);
            mar_unpack(L, *p, l, idx);
            mar_incr_ptr(l);
        }
        else if (tag == MAR_TUSR) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_unpack(L, *p, l, idx);
            lua_rawgeti(L, -1, 1);
            lua_call(L, 0, 1);
            lua_remove(L, -2);
            lua_pushvalue(L, -1);
            lua_rawseti(L, 2, (*idx)++);
            mar_incr_ptr(l);
        }
        else {
            luaL_error(L, "bad encoded data");
        }
        break;
    }
    case LUA_TFUNCTION: {
        size_t nups;
        int i;
        mar_Buffer dec_buf;
        char tag = *(char*)*p;
        mar_incr_ptr(1);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, 2, ref);
        }
        else {
            mar_next_len(l, uint32_t);
            dec_buf.data = (char*)*p;
            dec_buf.size = l;
            dec_buf.head = l;
            dec_buf.seek = 0;
            lua_load(L, (lua_Reader)buf_read, &dec_buf, "=marshal");
            mar_incr_ptr(l);

            lua_pushvalue(L, -1);
            lua_rawseti(L, 2, (*idx)++);

            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_unpack(L, *p, l, idx);
            nups = lua_objlen(L, -1);
            for (i=1; i <= nups; i++) {
                lua_rawgeti(L, -1, i);
                lua_setupvalue(L, -3, i);
            }
            lua_pop(L, 1);
            mar_incr_ptr(l);
        }
        break;
    }
    case LUA_TUSERDATA: {
        char tag = *(char*)*p;
        mar_incr_ptr(MAR_CHR);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, 2, ref);
        }
        else if (tag == MAR_TUSR) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_unpack(L, *p, l, idx);
            lua_rawgeti(L, -1, 1);
            lua_call(L, 0, 1);
            lua_remove(L, -2);
            lua_pushvalue(L, -1);
            lua_rawseti(L, 2, (*idx)++);
            mar_incr_ptr(l);
        }
        else { /* tag == MAR_TVAL */
            lua_pushnil(L);
        }
        break;
    }
    case LUA_TTHREAD:
        lua_pushnil(L);
        break;
    default:
        luaL_error(L, "bad code");
    }
}
Exemplo n.º 28
0
const char * LuaDebug::SetUpvalue(int funcindex, int n) const
{
	return lua_setupvalue(L(), funcindex, n);
}
Exemplo n.º 29
0
static void mar_decode_value
    (lua_State *L, const char *buf, size_t len, const char **p, size_t *idx)
{
    size_t l;
    char val_type = **p;
    mar_incr_ptr(MAR_CHR);
    switch (val_type) {
    case LUA_TBOOLEAN:
        lua_pushboolean(L, *(char*)*p);
        mar_incr_ptr(MAR_CHR);
        break;
    case LUA_TNUMBER:
        lua_pushnumber(L, *(lua_Number*)*p);
        mar_incr_ptr(MAR_I64);
        break;
    case LUA_TLIGHTUSERDATA: {
        void * ptr=(void*)*(void**)*p;
        lua_pushlightuserdata(L, ptr);
        mar_incr_ptr(MAR_I64);
        } break;
    case LUA_TSTRING:
        mar_next_len(l, uint32_t);
        lua_pushlstring(L, *p, l);
        mar_incr_ptr(l);
        break;
    case LUA_TTABLE: {
        char tag = *(char*)*p;
        mar_incr_ptr(MAR_CHR);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, SEEN_IDX, ref);
        }
        else if (tag == MAR_TVAL) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            lua_pushvalue(L, -1);
            lua_rawseti(L, SEEN_IDX, (*idx)++);
            mar_decode_table(L, *p, l, idx);
            mar_incr_ptr(l);
        }
        else if (tag == MAR_TUSR) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_decode_table(L, *p, l, idx);
            lua_rawgeti(L, -1, 1);
            lua_call(L, 0, 1);
            lua_remove(L, -2);
            lua_pushvalue(L, -1);
            lua_rawseti(L, SEEN_IDX, (*idx)++);
            mar_incr_ptr(l);
        }
        else {
            luaL_error(L, "bad encoded data");
        }
        break;
    }
    case LUA_TFUNCTION: {
        size_t nups;
        int i;
        mar_Buffer dec_buf;
        char tag = *(char*)*p;
        mar_incr_ptr(1);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, SEEN_IDX, ref);
        }
        else {
            mar_next_len(l, uint32_t);
            dec_buf.data = (char*)*p;
            dec_buf.size = l;
            dec_buf.head = l;
            dec_buf.seek = 0;
            lua_load(L, (lua_Reader)buf_read, &dec_buf, "=marshal"
            #if LUA_VERSION_NUM > 501
               ,NULL
            #endif
            );
            mar_incr_ptr(l);

            lua_pushvalue(L, -1);
            lua_rawseti(L, SEEN_IDX, (*idx)++);

            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_decode_table(L, *p, l, idx);
            nups = lua_objlen(L, -1);
            for (i=1; i <= nups; i++) {
                lua_rawgeti(L, -1, i);
                #if LUA_VERSION_NUM > 501
                if(lua_type(L,-1)==LUA_TSTRING) {
                	size_t len=0;
                	const char * s=lua_tolstring(L,-1,&len);
                	if(!strncmp(s,LEDA_ENV_MARKER,sizeof(LEDA_ENV_MARKER))) {
                		lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
                		lua_remove(L,-2);
                	}
                }
                #endif
                lua_setupvalue(L, -3, i);
            }
            lua_pop(L, 1);
            mar_incr_ptr(l);
        }
        break;
    }
    case LUA_TUSERDATA: {
        char tag = *(char*)*p;
        mar_incr_ptr(MAR_CHR);
        if (tag == MAR_TREF) {
            int ref;
            mar_next_len(ref, int);
            lua_rawgeti(L, SEEN_IDX, ref);
        }
        else if (tag == MAR_TUSR) {
            mar_next_len(l, uint32_t);
            lua_newtable(L);
            mar_decode_table(L, *p, l, idx);
            lua_rawgeti(L, -1, 1);
            lua_call(L, 0, 1);
            lua_remove(L, -2);
            lua_pushvalue(L, -1);
            lua_rawseti(L, SEEN_IDX, (*idx)++);
            mar_incr_ptr(l);
        }
        else { /* tag == MAR_TVAL */
            lua_pushnil(L);
        }
        break;
    }
    case LUA_TNIL:
    case LUA_TTHREAD:
        lua_pushnil(L);
        break;
    default:
        luaL_error(L, "bad code");
    }
}
static inline int _cloneNoTable(lua_State *L, const int idx, 
	lua_State *L_, const int r_lv ) { 
	int ret_= 1; switch(lua_type(L, idx ) ) { 
		case LUA_TSTRING: { 
			size_t l; const char *s= lua_tolstring(L, idx, &l ); 
			lua_pushlstring(L_, s, l ); 
		} break; 
		case LUA_TNUMBER: 
		lua_pushnumber(L_, lua_tonumber(L, idx ) ); 
		break; 
		case LUA_TLIGHTUSERDATA: 
		lua_pushlightuserdata(L_, lua_touserdata(L, idx ) ); 
		break; 
		case LUA_TBOOLEAN: 
		lua_pushboolean(L_, lua_toboolean(L, idx ) ); 
		break; 
		case LUA_TUSERDATA: { // userdata 的 meta 暂时不能拷贝 
			const size_t l= lua_objlen(L, idx ); 
			memmove(lua_newuserdata(L_, l ), 
				lua_touserdata(L, idx ), l ); if(0) //屏蔽 meta 处理 
			if(lua_getmetatable(L, idx ) ) { 
				const int k= _cloneRecursion(L, lua_gettop(L ), L_, 
					((0<= r_lv )? r_lv: -1 ) ); lua_pop(L, 1 ); 
				if((0<= r_lv )&& lua_istable(L_, -1 )&& (0< k ) ) 
					printf("%*.s__{%3d}\n", (r_lv- 1 )* 2, "", k ); 
				lua_setmetatable(L_, -2 ); 
			} 
		} break; 
		case LUA_TFUNCTION: 
		if(lua_iscfunction(L, idx ) ) { 
			int j= 1; lua_CFunction f= lua_tocfunction(L, idx ); 
			for(j= 1; UPVALUE_MAX>= j; ++j ) { 
				//设置函数的 upvalue 
				if(!lua_getupvalue(L, idx, j ) ) break; 
				_cloneRecursion(L, lua_gettop(L ), L_, 
					((0<= r_lv )? (r_lv+ 1 ): -1 ) ); lua_pop(L, 1 ); 
			} lua_pushcclosure(L_, f, j- 1 ); 
		} else 
		{ int j= 1; DUMP_CB ud; memset(&ud, 0, sizeof(ud ) ); 
			lua_pushvalue(L, idx ); lua_dump(L, writer_CB, &ud ); 
			if(ud.p ) { //载入函数到新的栈 
				lua_load(L_, reader_CB, &ud, (char * )0 ); free(ud.p ); 
			} lua_pop(L, 1 ); 
			for(j= 1; UPVALUE_MAX>= j; ++j ) { 
				//设置函数的 upvalue 
				if(!lua_getupvalue(L, idx, j ) ) break; 
printf("upvalue %d\n", j ); 
				_cloneRecursion(L, lua_gettop(L ), L_, 
					((0<= r_lv )? (r_lv+ 1 ): -1 ) ); lua_pop(L, 1 ); 
				lua_setupvalue(L_, -2, j ); 
			} 
		} break; 
		case LUA_TNIL: 
		lua_pushnil(L_ ); 
		break; 
		case LUA_TNONE: 
		case LUA_TTHREAD: //?
		default: 
		ret_= 0; break; 
	} 
	return ret_; 
}