int lua_Curve_static_create(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 2: { if (lua_type(state, 1) == LUA_TNUMBER && lua_type(state, 2) == LUA_TNUMBER) { // Get parameter 1 off the stack. unsigned int param1 = (unsigned int)luaL_checkunsigned(state, 1); // Get parameter 2 off the stack. unsigned int param2 = (unsigned int)luaL_checkunsigned(state, 2); void* returnPtr = (void*)Curve::create(param1, param2); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Curve"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } lua_pushstring(state, "lua_Curve_static_create - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 2)."); lua_error(state); break; } } return 0; }
int lua_Model_static_create(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 1: { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TTABLE || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. bool param1Valid; gameplay::ScriptUtil::LuaArray<Mesh> param1 = gameplay::ScriptUtil::getObjectPointer<Mesh>(1, "Mesh", false, ¶m1Valid); if (!param1Valid) { lua_pushstring(state, "Failed to convert parameter 1 to type 'Mesh'."); lua_error(state); } void* returnPtr = ((void*)Model::create(param1)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Model"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } lua_pushstring(state, "lua_Model_static_create - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 1)."); lua_error(state); break; } } return 0; }
/* ** When creating file handles, always creates a 'closed' file handle ** before opening the actual file; so, if there is a memory error, the ** handle is in a consistent state. */ static LStream *newprefile (lua_State *L) { LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream)); p->closef = NULL; /* mark file handle as 'closed' */ luaL_setmetatable(L, LUA_FILEHANDLE); return p; }
static int tek_lib_exec_run(lua_State *L) { struct LuaExecTask *lexec = tek_lib_exec_check(L); struct TExecBase *TExecBase = lexec->exec; struct LuaExecChild *ctx; const char *fname = TNULL; const char *chunk = TNULL; const char *taskname = TNULL; size_t extralen = 0; struct THook hook; TTAGITEM tags[2]; int nremove = 1; TBOOL abort = TTRUE; for (;;) { if (lua_istable(L, 1)) { lua_getfield(L, 1, "abort"); if (lua_isboolean(L, -1)) abort = lua_toboolean(L, -1); lua_pop(L, 1); lua_getfield(L, 1, "taskname"); taskname = lua_tostring(L, -1); nremove = 2; lua_getfield(L, 1, "func"); if (!lua_isnoneornil(L, -1)) break; lua_pop(L, 1); lua_getfield(L, 1, "filename"); if (!lua_isnoneornil(L, -1)) break; lua_pop(L, 1); lua_getfield(L, 1, "chunk"); if (!lua_isnoneornil(L, -1)) { chunk = luaL_checklstring(L, -1, &extralen); break; } luaL_error(L, "required argument missing"); } lua_pushvalue(L, 1); break; } if (!chunk) { if (lua_type(L, -1) == LUA_TSTRING) fname = luaL_checklstring(L, -1, &extralen); else if (lua_isfunction(L, -1) && !lua_iscfunction(L, -1)) chunk = tek_lib_exec_dump(L, &extralen); else luaL_error(L, "not a Lua function, filename or table"); } ctx = lua_newuserdata(L, sizeof(struct LuaExecChild) + extralen + 1); memset(ctx, 0, sizeof *ctx); ctx->exec = lexec->exec; ctx->parent = lexec; ctx->taskname = tek_lib_exec_taskname(ctx->atomname, taskname); ctx->abort = abort; if (fname) { ctx->fname = (char *) (ctx + 1); strcpy(ctx->fname, (char *) fname); } else if (chunk) { memcpy(ctx + 1, chunk, extralen); ctx->chunklen = extralen; } /* remove arguments under userdata */ while (nremove--) lua_remove(L, -2); ctx->numargs = lua_gettop(L) - 2; /* push arg[0] on the stack, will be extraarg */ lua_getglobal(L, "arg"); if (lua_istable(L, -1)) { lua_rawgeti(L, -1, 0); lua_remove(L, -2); } if (lua_type(L, -1) != LUA_TSTRING) { lua_pop(L, 1); lua_pushnil(L); } ctx->args = tek_lib_exec_getargs(L, TExecBase, 2, ctx->numargs++, 1); lua_pop(L, 1); ctx->L = lua_newstate(tek_lib_exec_allocf, TExecBase); if (ctx->L == TNULL) { tek_lib_exec_freeargs(TExecBase, ctx->args, ctx->numargs); luaL_error(L, "cannot create interpreter"); } tags[0].tti_Tag = TTask_UserData; tags[0].tti_Value = (TTAG) ctx; tags[1].tti_Tag = TTAG_DONE; TInitHook(&hook, tek_lib_exec_run_dispatch, ctx); ctx->task = TCreateTask(&hook, tags); if (ctx->task == TNULL) { tek_lib_exec_freectxargs(ctx); lua_pop(L, 1); lua_pushnil(L); return 1; } lua_getfield(L, LUA_REGISTRYINDEX, TEK_LIB_TASK_CLASSNAME); lua_setmetatable(L, -2); lua_pushvalue(L, -1); ctx->ref = luaL_ref(L, lua_upvalueindex(2)); if (ctx->abort) tek_lib_exec_register_task_hook(L, TExecBase); return 1; }
int lua_Model_getSkin(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 1: { if ((lua_type(state, 1) == LUA_TUSERDATA)) { Model* instance = getInstance(state); void* returnPtr = ((void*)instance->getSkin()); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "MeshSkin"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } lua_pushstring(state, "lua_Model_getSkin - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 1)."); lua_error(state); break; } } return 0; }
/// Wrapper around lua_newuserdata. /// /// This is internal. The public type-safe interface of this method should be /// used instead. /// /// \param size The second parameter to lua_newuserdata. /// /// \return The return value of lua_newuserdata. /// /// \warning Terminates execution if there is not enough memory. void* lutok::state::new_userdata_voidp(const size_t size) { return lua_newuserdata(_pimpl->lua_state, size); }
int lua_TextureSampler_static_create(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 1: { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TTABLE || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. Texture* param1 = ScriptUtil::getObjectPointer<Texture>(1, "Texture", false); void* returnPtr = (void*)Texture::Sampler::create(param1); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "TextureSampler"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else if ((lua_type(state, 1) == LUA_TSTRING || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. const char* param1 = ScriptUtil::getString(1, false); void* returnPtr = (void*)Texture::Sampler::create(param1); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "TextureSampler"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_TextureSampler_static_create - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } case 2: { if ((lua_type(state, 1) == LUA_TSTRING || lua_type(state, 1) == LUA_TNIL) && lua_type(state, 2) == LUA_TBOOLEAN) { // Get parameter 1 off the stack. const char* param1 = ScriptUtil::getString(1, false); // Get parameter 2 off the stack. bool param2 = ScriptUtil::luaCheckBool(state, 2); void* returnPtr = (void*)Texture::Sampler::create(param1, param2); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "TextureSampler"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_TextureSampler_static_create - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 1 or 2)."); lua_error(state); break; } } return 0; }
static void json_create_config(lua_State *l) { json_config_t *cfg; int i; cfg = (json_config_t *)lua_newuserdata(l, sizeof(*cfg)); /* Create GC method to clean up strbuf */ lua_newtable(l); lua_pushcfunction(l, json_destroy_config); lua_setfield(l, -2, "__gc"); lua_setmetatable(l, -2); cfg->encode_sparse_convert = DEFAULT_SPARSE_CONVERT; cfg->encode_sparse_ratio = DEFAULT_SPARSE_RATIO; cfg->encode_sparse_safe = DEFAULT_SPARSE_SAFE; cfg->encode_max_depth = DEFAULT_ENCODE_MAX_DEPTH; cfg->decode_max_depth = DEFAULT_DECODE_MAX_DEPTH; cfg->encode_invalid_numbers = DEFAULT_ENCODE_INVALID_NUMBERS; cfg->decode_invalid_numbers = DEFAULT_DECODE_INVALID_NUMBERS; cfg->encode_keep_buffer = DEFAULT_ENCODE_KEEP_BUFFER; cfg->encode_number_precision = DEFAULT_ENCODE_NUMBER_PRECISION; #if DEFAULT_ENCODE_KEEP_BUFFER > 0 strbuf_init(&cfg->encode_buf, 0); #endif /* Decoding init */ /* Tag all characters as an error */ for (i = 0; i < 256; i++) cfg->ch2token[i] = T_ERROR; /* Set tokens that require no further processing */ cfg->ch2token['{'] = T_OBJ_BEGIN; cfg->ch2token['}'] = T_OBJ_END; cfg->ch2token['['] = T_ARR_BEGIN; cfg->ch2token[']'] = T_ARR_END; cfg->ch2token[','] = T_COMMA; cfg->ch2token[':'] = T_COLON; cfg->ch2token['\0'] = T_END; cfg->ch2token[' '] = T_WHITESPACE; cfg->ch2token['\t'] = T_WHITESPACE; cfg->ch2token['\n'] = T_WHITESPACE; cfg->ch2token['\r'] = T_WHITESPACE; /* Update characters that require further processing */ cfg->ch2token['f'] = T_UNKNOWN; /* false? */ cfg->ch2token['i'] = T_UNKNOWN; /* inf, ininity? */ cfg->ch2token['I'] = T_UNKNOWN; cfg->ch2token['n'] = T_UNKNOWN; /* null, nan? */ cfg->ch2token['N'] = T_UNKNOWN; cfg->ch2token['t'] = T_UNKNOWN; /* true? */ cfg->ch2token['"'] = T_UNKNOWN; /* string? */ cfg->ch2token['+'] = T_UNKNOWN; /* number? */ cfg->ch2token['-'] = T_UNKNOWN; for (i = 0; i < 10; i++) cfg->ch2token['0' + i] = T_UNKNOWN; /* Lookup table for parsing escape characters */ for (i = 0; i < 256; i++) cfg->escape2char[i] = 0; /* String error */ cfg->escape2char['"'] = '"'; cfg->escape2char['\\'] = '\\'; cfg->escape2char['/'] = '/'; cfg->escape2char['b'] = '\b'; cfg->escape2char['t'] = '\t'; cfg->escape2char['n'] = '\n'; cfg->escape2char['f'] = '\f'; cfg->escape2char['r'] = '\r'; cfg->escape2char['u'] = 'u'; /* Unicode parsing required */ }
static int hj_parse_message(lua_State *lua) { lsb_lua_sandbox *lsb = static_cast<lsb_lua_sandbox *> (lua_touserdata(lua, lua_upvalueindex(1))); if (!lsb) { return luaL_error(lua, "%s() invalid lightuserdata", __FUNCTION__); } int n = lua_gettop(lua); int idx = 1; lsb_heka_message *msg = NULL; lsb_heka_sandbox *hsb = static_cast<lsb_heka_sandbox *>(lsb_get_parent(lsb)); if (hsb->type == 'i') { luaL_argcheck(lua, n >= 2 && n <= 4, 0, "invalid number of arguments"); heka_stream_reader *hsr = static_cast<heka_stream_reader *> (luaL_checkudata(lua, 1, mozsvc_heka_stream_reader)); msg = &hsr->msg; idx = 2; } else { luaL_argcheck(lua, n >= 1 && n <= 3, 0, "invalid number of arguments"); if (!hsb->msg || !hsb->msg->raw.s) { return luaL_error(lua, "no active message"); } msg = hsb->msg; } lsb_const_string json = read_message(lua, idx, msg); if (!json.s) return luaL_error(lua, "field not found"); char *inflated = NULL; #ifdef HAVE_ZLIB // automatically handle gzipped strings (optimization for Mozilla telemetry // messages) if (json.len > 2) { if (json.s[0] == 0x1f && (unsigned char)json.s[1] == 0x8b) { size_t mms = (size_t)lua_tointeger(lua, lua_upvalueindex(2)); inflated = lsb_ungzip(json.s, json.len, mms, NULL); if (!inflated) return luaL_error(lua, "lsb_ungzip failed"); } } #endif heka_json *hj = static_cast<heka_json *>(lua_newuserdata(lua, sizeof*hj)); hj->doc = new rj::Document; hj->val = NULL; hj->insitu = inflated; hj->refs = new std::set<rj::Value *>; luaL_getmetatable(lua, mozsvc_heka_json); lua_setmetatable(lua, -2); if (!hj->doc || !hj->refs) { lua_pushstring(lua, "memory allocation failed"); return lua_error(lua); } bool err = false; if (hj->insitu) { if (hj->doc->ParseInsitu<rj::kParseStopWhenDoneFlag>(hj->insitu) .HasParseError()) { err = true; lua_pushfstring(lua, "failed to parse offset:%f %s", (lua_Number)hj->doc->GetErrorOffset(), rj::GetParseError_En(hj->doc->GetParseError())); } } else { rj::MemoryStream ms(json.s, json.len); if (hj->doc->ParseStream<0, rj::UTF8<> >(ms).HasParseError()) { err = true; lua_pushfstring(lua, "failed to parse offset:%f %s", (lua_Number)hj->doc->GetErrorOffset(), rj::GetParseError_En(hj->doc->GetParseError())); } } if (err) return lua_error(lua); hj->refs->insert(hj->doc); return 1; }
int lua_Rectangle__init(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 0: { void* returnPtr = (void*)new Rectangle(); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Rectangle"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; break; } case 1: { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. Rectangle* param1 = ScriptUtil::getObjectPointer<Rectangle>(1, "Rectangle", true); void* returnPtr = (void*)new Rectangle(*param1); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Rectangle"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_Rectangle__init - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } case 2: { if (lua_type(state, 1) == LUA_TNUMBER && lua_type(state, 2) == LUA_TNUMBER) { // Get parameter 1 off the stack. float param1 = (float)luaL_checknumber(state, 1); // Get parameter 2 off the stack. float param2 = (float)luaL_checknumber(state, 2); void* returnPtr = (void*)new Rectangle(param1, param2); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Rectangle"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_Rectangle__init - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } case 4: { if (lua_type(state, 1) == LUA_TNUMBER && lua_type(state, 2) == LUA_TNUMBER && lua_type(state, 3) == LUA_TNUMBER && lua_type(state, 4) == LUA_TNUMBER) { // Get parameter 1 off the stack. float param1 = (float)luaL_checknumber(state, 1); // Get parameter 2 off the stack. float param2 = (float)luaL_checknumber(state, 2); // Get parameter 3 off the stack. float param3 = (float)luaL_checknumber(state, 3); // Get parameter 4 off the stack. float param4 = (float)luaL_checknumber(state, 4); void* returnPtr = (void*)new Rectangle(param1, param2, param3, param4); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Rectangle"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_Rectangle__init - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 0, 1, 2 or 4)."); lua_error(state); break; } } return 0; }
int lua_Ray__init(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 0: { void* returnPtr = (void*)new Ray(); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Ray"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; break; } case 1: { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. ScriptUtil::LuaArray<Ray> param1 = ScriptUtil::getObjectPointer<Ray>(1, "Ray", true); void* returnPtr = (void*)new Ray(*param1); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Ray"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_Ray__init - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } case 2: { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TNIL) && (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TNIL)) { // Get parameter 1 off the stack. ScriptUtil::LuaArray<Vector3> param1 = ScriptUtil::getObjectPointer<Vector3>(1, "Vector3", true); // Get parameter 2 off the stack. ScriptUtil::LuaArray<Vector3> param2 = ScriptUtil::getObjectPointer<Vector3>(2, "Vector3", true); void* returnPtr = (void*)new Ray(*param1, *param2); if (returnPtr) { ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "Ray"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } else { lua_pushstring(state, "lua_Ray__init - Failed to match the given parameters to a valid function signature."); lua_error(state); } break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 0, 1 or 2)."); lua_error(state); break; } } return 0; }
LoadResult SyntaxReader::load ( const string& langDefPath, const string& pluginReadFilePath, OutputType outputType, bool clear ) { currentPath=langDefPath; disableHighlighting=false; if (!Platform::fileExists(langDefPath)){ return LOAD_FAILED; } try { if (luaState) delete luaState; luaState=new Diluculum::LuaState(); Diluculum::LuaState& ls=*luaState; initLuaState(ls, langDefPath, pluginReadFilePath, outputType); lua_register (ls.getState(),"AddKeyword",luaAddKeyword); SyntaxReader **s = (SyntaxReader **)lua_newuserdata(ls.getState(), sizeof(SyntaxReader *)); *s=this; lua_setglobal(ls.getState(), GLOBAL_INSTANCE_NAME); // ececute script and read values ls.doFile (langDefPath); langDesc = ls["Description"].value().asString(); if (pluginChunks.size()){ Diluculum::LuaValueList params; params.push_back(langDesc); for (unsigned int i=0;i<pluginChunks.size();i++){ ls.call(*pluginChunks[i], params, "syntax user function"); } } Diluculum::LuaValueMap globals = ls.globals(); ignoreCase=readFlag(ls["IgnoreCase"]); reformatCode=readFlag(ls["EnableIndentation"]); disableHighlighting=readFlag(ls["DisableHighlighting"]); int idx=1; int keywordIdx=0; int kwId=0; char kwName[5]={0}; while (ls["Keywords"][idx].value() !=Diluculum::Nil) { keywordIdx=ls["Keywords"][idx]["Id"].value().asNumber(); snprintf(kwName, sizeof(kwName), "kw%c", ('a'+keywordIdx-1)); // TODO kwa -> kw1... kwId= generateNewKWClass ( kwName ); if (ls["Keywords"][idx]["List"].value()!=Diluculum::Nil) { int listIdx=1; Diluculum::LuaVariable luaList=ls["Keywords"][idx]["List"]; while (luaList[listIdx].value()!=Diluculum::Nil) { keywords.insert ( make_pair ( luaList[listIdx].value().asString(), kwId ) ); ++listIdx; } } else if (ls["Keywords"][idx]["Regex"].value()!=Diluculum::Nil) { string reString=StringTools::trim(ls["Keywords"][idx]["Regex"].value().asString()); int captGroup=-1; if (ls["Keywords"][idx]["Group"].value()!=Diluculum::Nil) { captGroup=ls["Keywords"][idx]["Group"].value().asNumber(); } regex.push_back ( new RegexElement ( KEYWORD, KEYWORD_END, reString, kwId, captGroup ) ); } idx++; } if (globals.count("Comments")) { int listIdx=1; int openDelimId=0; int closeDelimId=0; while (ls["Comments"][listIdx].value()!=Diluculum::Nil) { if (ls["Comments"][listIdx]["Block"].value().asBoolean()) { if (ls["Comments"][listIdx]["Nested"].value()!=Diluculum::Nil) allowNestedComments = ls["Comments"][listIdx]["Nested"].value().asBoolean(); string openDelim=StringTools::trim(ls["Comments"][listIdx]["Delimiter"][1].value().asString()); RegexElement* elem=new RegexElement ( ML_COMMENT,ML_COMMENT_END, openDelim, 0, -1 ); openDelimId=elem->instanceId; regex.push_back ( elem ); string closeDelim=StringTools::trim(ls["Comments"][listIdx]["Delimiter"][2].value().asString()); elem= new RegexElement ( ML_COMMENT_END,ML_COMMENT_END, closeDelim, 0, -1 ); closeDelimId=elem->instanceId; regex.push_back ( elem); delimiterDistinct[openDelimId]=openDelim!=closeDelim; delimiterDistinct[closeDelimId]=openDelim!=closeDelim; delimIds2[closeDelimId]=openDelimId; } else { regex.push_back ( new RegexElement ( SL_COMMENT, SL_COMMENT_END, StringTools::trim(ls["Comments"][listIdx]["Delimiter"][1].value().asString()), 0, -1 ) ); } ++listIdx; } } //move behind comment section because of fortran comments (^cC.*$) string re_digit = StringTools::trim(ls["Digits"].value().asString()); string re_identifier= StringTools::trim(ls["Identifiers"].value().asString()); // insert identifier and number regex after keyword regexes regex.push_back ( new RegexElement ( IDENTIFIER_BEGIN, IDENTIFIER_END, re_identifier ) ); regex.push_back ( new RegexElement ( NUMBER, NUMBER_END, re_digit ) ); if (globals.count("Strings")) { if (ls["Strings"]["RawPrefix"].value()!=Diluculum::Nil) { rawStringPrefix=ls["Strings"]["RawPrefix"].value().asString().at(0); } if (ls["Strings"]["Delimiter"].value()!=Diluculum::Nil) { RegexElement* elem=new RegexElement ( STRING,STRING_END, StringTools::trim( ls["Strings"]["Delimiter"].value().asString()), 0, -1 ); delimiterDistinct[elem->instanceId]=true; regex.push_back (elem ); } if (ls["Strings"]["Interpolation"].value()!=Diluculum::Nil) { RegexElement* elem=new RegexElement ( STRING_INTERPOLATION, STRING_INTERPOLATION_END, StringTools::trim( ls["Strings"]["Interpolation"].value().asString()), 0, -1 ); regex.push_back (elem ); } if (ls["Strings"]["DelimiterPairs"].value()!=Diluculum::Nil) { int listIdx=1; int openDelimId=0; int closeDelimId=0; while (ls["Strings"]["DelimiterPairs"][listIdx].value()!=Diluculum::Nil) { string openDelim=StringTools::trim(ls["Strings"]["DelimiterPairs"][listIdx]["Open"].value().asString()); RegexElement* elem =new RegexElement(STRING, STRING_END, openDelim, 0, -1); openDelimId=elem->instanceId; regex.push_back( elem ); string closeDelim=StringTools::trim(ls["Strings"]["DelimiterPairs"][listIdx]["Close"].value().asString()); elem = new RegexElement(STRING_END, STRING_END, closeDelim, 0, -1); closeDelimId=elem->instanceId; regex.push_back( elem ); delimIds2[closeDelimId]=openDelimId; if (ls["Strings"]["DelimiterPairs"][listIdx]["Raw"].value()!=Diluculum::Nil){ rawStringOpenDelims[openDelimId]=ls["Strings"]["DelimiterPairs"][listIdx]["Raw"].value().asBoolean(); } ++listIdx; } } string escRegex=(ls["Strings"]["Escape"].value()==Diluculum::Nil)?REGEX_ESCSEQ:ls["Strings"]["Escape"].value().asString(); regex.push_back ( new RegexElement ( ESC_CHAR,ESC_CHAR_END, StringTools::trim(escRegex), 0, -1 ) ); } if (globals.count("PreProcessor")) { regex.push_back ( new RegexElement ( DIRECTIVE,DIRECTIVE_END, StringTools::trim(ls["PreProcessor"]["Prefix"].value().asString()), 0, -1 ) ); if (ls["PreProcessor"]["Continuation"].value()!=Diluculum::Nil) { continuationChar=ls["PreProcessor"]["Continuation"].value().asString().at(0); } } if (globals.count("Operators")) { regex.push_back ( new RegexElement ( SYMBOL,SYMBOL_END, StringTools::trim( ls["Operators"].value().asString()), 0, -1 ) ); } if (globals.count("NestedSections")) { int listIdx=1; while (ls["NestedSections"][listIdx].value()!=Diluculum::Nil) { string lang= ls["NestedSections"][listIdx]["Lang"].value().asString(); string openDelim=StringTools::trim(ls["NestedSections"][listIdx]["Delimiter"][1].value().asString()); regex.insert(regex.begin(), 1, new RegexElement(EMBEDDED_CODE_BEGIN, EMBEDDED_CODE_BEGIN, openDelim, 0, -1, lang)); string closeDelim=StringTools::trim(ls["NestedSections"][listIdx]["Delimiter"][2].value().asString()); exitDelimiters[getNewPath(lang)] = closeDelim; ++listIdx; } } if (globals.count("HeaderInjection")) { headerInjection+= ls["HeaderInjection"].value().asString(); } if (globals.count("FooterInjection")) { footerInjection+= ls["FooterInjection"].value().asString(); } // load hook functions if (globals.count("OnStateChange")) { validateStateChangeFct=new Diluculum::LuaFunction(ls["OnStateChange"].value().asFunction()); } if (globals.count("Decorate")) { decorateFct=new Diluculum::LuaFunction(ls["Decorate"].value().asFunction()); } } catch (Diluculum::LuaError err) { luaErrorMsg = string(err.what()); return LOAD_FAILED_LUA; } return LOAD_OK; }
void* LuaInterface::newUserdata(int size) { return lua_newuserdata(L, size); }
/* ** Read the options specified in the ini file. ** */ void CMeasureScript::ReadOptions(CConfigParser& parser, const WCHAR* section) { CMeasure::ReadOptions(parser, section); std::wstring file = parser.ReadString(section, L"ScriptFile", L""); if (!file.empty()) { if (m_MeterWindow) { m_MeterWindow->MakePathAbsolute(file); } if (!m_Initialized || wcscmp(file.c_str(), m_ScriptFile.c_str()) != 0) { DeleteLuaScript(); lua_State* L = LuaManager::GetState(); m_ScriptFile = file; m_LuaScript = new LuaScript(m_ScriptFile.c_str()); if (m_LuaScript->IsInitialized()) { m_HasInitializeFunction = m_LuaScript->IsFunction(g_InitializeFunctionName); m_HasUpdateFunction = m_LuaScript->IsFunction(g_UpdateFunctionName); m_HasGetStringFunction = m_LuaScript->IsFunction(g_GetStringFunctionName); // For backwards compatbility if (m_HasGetStringFunction) { LogWithArgs(LOG_WARNING, L"Script: Using deprecated GetStringValue() in [%s]", m_Name.c_str()); } lua_rawgeti(L, LUA_GLOBALSINDEX, m_LuaScript->GetRef()); *(CMeterWindow**)lua_newuserdata(L, sizeof(CMeterWindow*)) = m_MeterWindow; lua_getglobal(L, "CMeterWindow"); lua_setmetatable(L, -2); lua_setfield(L, -2, "SKIN"); *(CMeasure**)lua_newuserdata(L, sizeof(CMeasure*)) = this; lua_getglobal(L, "CMeasure"); lua_setmetatable(L, -2); lua_setfield(L, -2, "SELF"); // For backwards compatibility lua_getfield(L, -1, "PROPERTIES"); if (lua_isnil(L, -1) == 0) { lua_pushnil(L); // Look in the table for values to read from the section while (lua_next(L, -2)) { lua_pop(L, 1); const char* strKey = lua_tostring(L, -1); std::wstring wstrKey = ConvertToWide(strKey); const std::wstring& wstrValue = parser.ReadString(section, wstrKey.c_str(), L""); if (!wstrValue.empty()) { LuaManager::PushWide(L, wstrValue.c_str()); lua_setfield(L, -3, strKey); } } } // Pop PROPERTIES table and our table lua_pop(L, 2); } else { DeleteLuaScript(); } } } else { LogWithArgs(LOG_ERROR, L"Script: File not valid in [%s]", m_Name.c_str()); DeleteLuaScript(); } }
static void net_server_connected(void *arg) // for tcp only { NODE_DBG("net_server_connected is called.\n"); struct espconn *pesp_conn = arg; int i = 0; lnet_userdata *skt = NULL; if(pesp_conn == NULL) return; #if 0 char temp[20] = {0}; c_sprintf(temp, IPSTR, IP2STR( &(pesp_conn->proto.tcp->remote_ip) ) ); NODE_DBG("remote "); NODE_DBG(temp); NODE_DBG(":"); NODE_DBG("%d",pesp_conn->proto.tcp->remote_port); NODE_DBG(" connected.\n"); #endif for(i=0;i<MAX_SOCKET;i++){ if(socket[i] == LUA_NOREF) // found empty slot { break; } } if(i>=MAX_SOCKET) // can't create more socket { NODE_ERR("MAX_SOCKET\n"); pesp_conn->reverse = NULL; // not accept this conn if(pesp_conn->proto.tcp->remote_port || pesp_conn->proto.tcp->local_port) espconn_disconnect(pesp_conn); return; } if(tcpserver_cb_connect_ref == LUA_NOREF) return; if(!gL) return; lua_rawgeti(gL, LUA_REGISTRYINDEX, tcpserver_cb_connect_ref); // get function // create a new client object skt = (lnet_userdata *)lua_newuserdata(gL, sizeof(lnet_userdata)); if(!skt){ NODE_ERR("can't newudata\n"); lua_pop(gL, 1); return; } // set its metatable luaL_getmetatable(gL, "net.socket"); lua_setmetatable(gL, -2); // pre-initialize it, in case of errors skt->self_ref = LUA_NOREF; lua_pushvalue(gL, -1); // copy the top of stack skt->self_ref = luaL_ref(gL, LUA_REGISTRYINDEX); // ref to it self, for module api to find the userdata socket[i] = skt->self_ref; // save to socket array socket_num++; skt->cb_connect_ref = LUA_NOREF; // this socket already connected skt->cb_reconnect_ref = LUA_NOREF; skt->cb_disconnect_ref = LUA_NOREF; skt->cb_receive_ref = LUA_NOREF; skt->cb_send_ref = LUA_NOREF; skt->cb_dns_found_ref = LUA_NOREF; #ifdef CLIENT_SSL_ENABLE skt->secure = 0; // as a server SSL is not supported. #endif skt->pesp_conn = pesp_conn; // point to the espconn made by low level sdk pesp_conn->reverse = skt; // let espcon carray the info of this userdata(net.socket) espconn_regist_recvcb(pesp_conn, net_socket_received); espconn_regist_sentcb(pesp_conn, net_socket_sent); espconn_regist_disconcb(pesp_conn, net_server_disconnected); espconn_regist_reconcb(pesp_conn, net_server_reconnected); // now socket[i] has the client ref, and stack top has the userdata lua_call(gL, 1, 0); // function(conn) }
int lua_Technique_getPass(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 2: { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL)) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); Technique* instance = getInstance(state); void* returnPtr = ((void*)instance->getPass(param1)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Pass"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } lua_pushstring(state, "lua_Technique_getPass - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 2)."); lua_error(state); break; } } return 0; }
// Lua: s = net.create(type, secure/timeout, function(conn)) static int net_create( lua_State* L, const char* mt ) { NODE_DBG("net_create is called.\n"); struct espconn *pesp_conn = NULL; lnet_userdata *nud, *temp = NULL; unsigned type; #ifdef CLIENT_SSL_ENABLE unsigned secure = 0; #endif uint8_t stack = 1; bool isserver = false; if (mt!=NULL && c_strcmp(mt, "net.server")==0) isserver = true; else if (mt!=NULL && c_strcmp(mt, "net.socket")==0) isserver = false; else { NODE_DBG("wrong metatable for net_create.\n"); return 0; } type = luaL_checkinteger( L, stack ); if ( type != ESPCONN_TCP && type != ESPCONN_UDP ) return luaL_error( L, "wrong arg type" ); stack++; #ifdef CLIENT_SSL_ENABLE if(!isserver){ if ( lua_isnumber(L, stack) ) { secure = lua_tointeger(L, stack); stack++; if ( secure != 0 && secure != 1 ){ return luaL_error( L, "wrong arg type" ); } } else { secure = 0; // default to 0 } } #endif if(isserver && type == ESPCONN_TCP){ if ( lua_isnumber(L, stack) ) { unsigned to = lua_tointeger(L, stack); stack++; if ( to < 1 || to > 28800 ){ return luaL_error( L, "wrong arg type" ); } tcp_server_timeover = (uint16_t)to; } else { tcp_server_timeover = 30; // default to 30 } } // create a object nud = (lnet_userdata *)lua_newuserdata(L, sizeof(lnet_userdata)); // pre-initialize it, in case of errors nud->self_ref = LUA_NOREF; nud->cb_connect_ref = LUA_NOREF; nud->cb_reconnect_ref = LUA_NOREF; nud->cb_disconnect_ref = LUA_NOREF; nud->cb_receive_ref = LUA_NOREF; nud->cb_send_ref = LUA_NOREF; nud->cb_dns_found_ref = LUA_NOREF; nud->pesp_conn = NULL; #ifdef CLIENT_SSL_ENABLE nud->secure = secure; #endif // set its metatable luaL_getmetatable(L, mt); lua_setmetatable(L, -2); // create the espconn struct if(isserver && type==ESPCONN_TCP && pTcpServer){ if(tcpserver_cb_connect_ref != LUA_NOREF){ // self_ref should be unref in close() lua_pop(L,1); return luaL_error(L, "only one tcp server allowed"); } pesp_conn = nud->pesp_conn = pTcpServer; } else if(isserver && type==ESPCONN_UDP && pUdpServer){ temp = (lnet_userdata *)pUdpServer->reverse; if(temp && temp->self_ref != LUA_NOREF){ lua_pop(L,1); return luaL_error(L, "only one udp server allowed"); } pesp_conn = nud->pesp_conn = pUdpServer; } else { pesp_conn = nud->pesp_conn = (struct espconn *)c_zalloc(sizeof(struct espconn)); if(!pesp_conn) return luaL_error(L, "not enough memory"); pesp_conn->proto.tcp = NULL; pesp_conn->proto.udp = NULL; pesp_conn->reverse = NULL; if( type==ESPCONN_TCP ) { pesp_conn->proto.tcp = (esp_tcp *)c_zalloc(sizeof(esp_tcp)); if(!pesp_conn->proto.tcp){ c_free(pesp_conn); pesp_conn = nud->pesp_conn = NULL; return luaL_error(L, "not enough memory"); } NODE_DBG("TCP server/socket is set.\n"); } else if( type==ESPCONN_UDP ) { pesp_conn->proto.udp = (esp_udp *)c_zalloc(sizeof(esp_udp)); if(!pesp_conn->proto.udp){ c_free(pesp_conn); pesp_conn = nud->pesp_conn = NULL; return luaL_error(L, "not enough memory"); } NODE_DBG("UDP server/socket is set.\n"); } } pesp_conn->type = type; pesp_conn->state = ESPCONN_NONE; // reverse is for the callback function pesp_conn->reverse = nud; if(isserver && type==ESPCONN_TCP && pTcpServer==NULL){ pTcpServer = pesp_conn; } else if(isserver && type==ESPCONN_UDP && pUdpServer==NULL){ pUdpServer = pesp_conn; } gL = L; // global L for net module. // if call back function is specified, call it with para userdata // luaL_checkanyfunction(L, 2); if (lua_type(L, stack) == LUA_TFUNCTION || lua_type(L, stack) == LUA_TLIGHTFUNCTION){ lua_pushvalue(L, stack); // copy argument (func) to the top of stack lua_pushvalue(L, -2); // copy the self_ref(userdata) to the top lua_call(L, 1, 0); } return 1; }
/* * rspamd_dispatcher.create(base,fd, read_cb, write_cb, err_cb[, timeout]) */ static int lua_io_dispatcher_create (lua_State *L) { struct rspamd_io_dispatcher_s *io_dispatcher, **pdispatcher; gint fd; struct lua_dispatcher_cbdata *cbdata; struct timeval tv = {0, 0}; double tv_num, tmp; if (lua_gettop (L) >= 5 && lua_isfunction (L, 3) && lua_isfunction (L, 5)) { cbdata = g_slice_alloc0 (sizeof (struct lua_dispatcher_cbdata)); cbdata->base = lua_check_event_base (L); if (cbdata->base == NULL) { /* Create new event base */ msg_warn ("create new event base as it is not specified"); cbdata->base = event_init (); } cbdata->L = L; fd = lua_tointeger (L, 2); lua_pushvalue (L, 3); cbdata->cbref_read = luaL_ref (L, LUA_REGISTRYINDEX); if (lua_isfunction (L, 4)) { /* Push write callback as well */ lua_pushvalue (L, 4); cbdata->cbref_write = luaL_ref (L, LUA_REGISTRYINDEX); } /* Error callback */ lua_pushvalue (L, 5); cbdata->cbref_err = luaL_ref (L, LUA_REGISTRYINDEX); if (lua_gettop (L) > 5) { tv_num = lua_tonumber (L, 6); tv.tv_sec = trunc (tv_num); tv.tv_usec = modf (tv_num, &tmp) * 1000.; io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, &tv, cbdata); } else { io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, NULL, cbdata); } cbdata->d = io_dispatcher; /* Push result */ pdispatcher = lua_newuserdata (L, sizeof (struct rspamd_io_dispatcher_s *)); rspamd_lua_setclass (L, "rspamd{io_dispatcher}", -1); *pdispatcher = io_dispatcher; } else { msg_err ("invalid number of arguments to io_dispatcher.create: %d", lua_gettop (L)); lua_pushnil (L); } return 1; }
void ExeciteAspPage(lua_State *L, const char *asp_page, const struct AspPageContext *context) { void *compiled_page = NULL; int result; char *error_message = NULL; struct AspliteCallbackUserdata *udata; int stack = lua_gettop(L); luaL_openlibs(L); luaopen_asplite(L); // create and populate 'context' table lua_pushstring(L, "context"); lua_newtable(L); lua_pushstring(L, "write_func"); udata = lua_newuserdata(L, sizeof(struct AspliteCallbackUserdata)); udata->context = context; udata->write_func = context->write_func; lua_pushcclosure(L, WriteCallbackWrapper, 1); lua_settable(L, -3); lua_pushstring(L, "error_func"); udata = lua_newuserdata(L, sizeof(struct AspliteCallbackUserdata)); udata->context = context; udata->write_func = context->error_func; lua_pushcclosure(L, WriteCallbackWrapper, 1); lua_settable(L, -3); lua_pushstring(L, "log_func"); udata = lua_newuserdata(L, sizeof(struct AspliteCallbackUserdata)); udata->context = context; udata->write_func = context->log_func; lua_pushcclosure(L, WriteCallbackWrapper, 1); lua_settable(L, -3); // create request table lua_pushstring(L, "request"); lua_newtable(L); lua_pushstring(L, "QUERY_STRING"); lua_pushstring(L, context->request.query_string); lua_settable(L, -3); lua_pushstring(L, "HTTP_METHOD"); lua_pushstring(L, context->request.request_method); lua_settable(L, -3); lua_pushstring(L, "REQUEST_METHOD"); lua_pushstring(L, context->request.request_method); lua_settable(L, -3); // set context.request field lua_settable(L, -3); // set asplite.context field lua_settable(L, -3); lua_pop(L, 1); // pop asplite table result = CompileAspPage(L, asp_page, &context->engine_config, &error_message); if (result) { udata = lua_newuserdata(L, sizeof(struct AspliteCallbackUserdata)); udata->context = context; udata->write_func = context->error_func; lua_pushcclosure(L, WriteCallbackWrapper, 1); lua_pushstring(L, error_message); lua_call(L, 1, 0); free(error_message); assert(stack == lua_gettop(L)); return; } #ifdef USE_EMBEDDED_DRIVER result = luaL_loadbufferx(L, asplite_Driver, sizeof(asplite_Driver), "asplite_Driver", NULL); #else result = luaL_loadfile(L, "asplite.lua"); #endif // USE_EMBEDDED_DRIVER if (result == LUA_OK) { result = lua_pcall(L, 0, 0, 0); } if (result != LUA_OK) { udata = lua_newuserdata(L, sizeof(struct AspliteCallbackUserdata)); udata->context = context; udata->write_func = context->error_func; lua_pushcclosure(L, WriteCallbackWrapper, 1); lua_pushvalue(L, -2); lua_call(L, 1, 0); } assert(stack == lua_gettop(L)); return; }
LUA_API void lua_pushvmatrix (lua_State *L, lua_VMatrix &matrix) { lua_VMatrix *pMat = (lua_VMatrix *)lua_newuserdata(L, sizeof(lua_VMatrix)); *pMat = matrix; luaL_getmetatable(L, "VMatrix"); lua_setmetatable(L, -2); }
TMODENTRY int luaopen_tek_lib_exec(lua_State *L) { struct TExecBase *TExecBase; struct LuaExecTask *lexec; TTAGITEM tags[2]; luaL_newmetatable(L, TEK_LIB_EXEC_CLASSNAME); tek_lua_register(L, NULL, tek_lib_exec_methods, 0); /* execmeta */ #if defined(ENABLE_TASKS) luaL_newmetatable(L, TEK_LIB_TASK_CLASSNAME); /* execmeta, taskmeta */ lua_pushvalue(L, -2); /* execmeta, taskmeta, execmeta */ tek_lua_register(L, NULL, tek_lib_exec_child_methods, 1); lua_pushvalue(L, -1); /* execmeta, taskmeta, taskmeta */ lua_setfield(L, -2, "__index"); lua_pop(L, 1); /* execmeta */ #endif lexec = (struct LuaExecTask *)lua_newuserdata(L, sizeof(struct LuaExecTask)); /* execmeta, luaexec */ lexec->exec = TNULL; lua_pushvalue(L, -1); /* execmeta, luaexec, luaexec */ lua_pushvalue(L, -3); /* execmeta, luaexec, luaexec, execmeta */ tek_lua_register(L, "tek.lib.exec", tek_lib_exec_funcs, 2); /* execmeta, luaexec, libtab */ lua_pushvalue(L, -2); /* execmeta, luaexec, libtab, libtab */ lua_pushvalue(L, -4); /* execmeta, luaexec, libtab, libtab, execmeta */ lua_remove(L, -4); lua_remove(L, -4); /* libtab, libtab, execmeta */ lua_setmetatable(L, -2); /* libtab, libtab */ lua_setfield(L, -2, "base"); /* libtab */ tags[0].tti_Tag = TExecBase_ModInit; tags[0].tti_Value = (TTAG) tek_lib_exec_initmodules; tags[1].tti_Tag = TTAG_DONE; lexec->task = TEKCreate(tags); if (lexec->task == TNULL) luaL_error(L, "Failed to initialize TEKlib"); lexec->exec = TExecBase = (struct TExecBase *)TGetExecBase(lexec->task); #if defined(ENABLE_TASKS) if (!tek_lib_exec_init_link_to_parent(L, lexec)) { lua_pop(L, 1); return 0; } #endif return 1; }
void addon_pload_data_push(lua_State *L) { lua_newuserdata(L, sizeof(struct addon_pload_data)); luaL_getmetatable(L, ADDON_PLOAD_DATA_METATABLE); lua_setmetatable(L, -2); }
/** * Push a new Lua proxy object (struct object) onto the Lua stack. It gets an * entry in the aliases table (unless it is a stack object); the caller must * take care of an entry in the objects table. * * @param p pointer to the object to make the Lua object for; must not be NULL. * @param ts what the pointer type is; 0 for auto detect * @param flags see lg_get_object * @return -1 on error (nothing pushed), NULL (stack object) or >0 (normal) * * Lua stack: unless -1 is returned, a new object is pushed. */ static struct object *_make_object(lua_State *L, void *p, typespec_t ts, int flags) { struct object *o; // 0 is valid - for autodetection. == module_count is OK as it is 1 based. if (ts.module_idx > module_count) { luaL_error(L, "%s invalid module_idx %d in _make_object", msgprefix, ts.module_idx); return (void*) -1; } /* If the structure number is not given, the object must be derived from * GObject; otherwise, the result is undefined (probably SEGV). */ if (!ts.type_idx) { ts = _determine_object_type(L, p); if (!ts.value) return (void*) -1; } if (ts.type_idx <= 0 || ts.type_idx >= modules[ts.module_idx]->type_count) { luaL_error(L, "%s invalid type_idx %d in _make_object", msgprefix, ts.type_idx); return (void*) -1; } /* make new Lua object with meta table */ o = (struct object*) lua_newuserdata(L, sizeof(*o)); memset(o, 0, sizeof(*o)); o->p = p; o->ts = ts; o->is_new = 1; /* determine which object type to use. */ lg_guess_object_type(L, o, flags); /* set metatable - shared among objects of the same type */ _get_object_meta(L, ts); // o meta lua_setmetatable(L, -2); // o /* Set the environment to an empty table - used to store data with * arbitrary keys for a specific object. The env can't be nil. To avoid * having an unused table for each object, use the same for all and replace * with a private table when the first data is stored. */ lua_getglobal(L, LUAGNOME_TBL); // o gnome lua_getfield(L, -1, LUAGNOME_EMPTYATTR); // o gnome emptyattr lua_setfenv(L, -3); // o gnome // Increase refcount (but not always - see ffi2lua_struct_ptr). flags // may have FLAG_NEW_OBJECT set. lg_inc_refcount(L, o, flags); // Stack objects neither get an entry in gnome.objects, nor in // gnome.aliases. They can't be reused anyway. if (_is_on_stack(p)) { lua_pop(L, 1); // o return NULL; } // Store the new object in the aliases table, using its own address // as a key. lua_getfield(L, -1, LUAGNOME_ALIASES); // o gnome aliases lua_pushlightuserdata(L, o); // o gnome aliases *o lua_pushvalue(L, -4); // o gnome aliases *o o lua_rawset(L, -3); // o gnome aliases lua_pop(L, 2); // o return o; }
static int lua_Pass_getParameterByIndex(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 2: { if ((lua_type(state, 1) == LUA_TUSERDATA) && lua_type(state, 2) == LUA_TNUMBER) { // Get parameter 1 off the stack. unsigned int param1 = (unsigned int)luaL_checkunsigned(state, 2); Pass* instance = getInstance(state); void* returnPtr = ((void*)instance->getParameterByIndex(param1)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "MaterialParameter"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } lua_pushstring(state, "lua_Pass_getParameterByIndex - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 2)."); lua_error(state); break; } } return 0; }
int lua_Model_setMaterial(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 2: { do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL)) { // Get parameter 1 off the stack. bool param1Valid; gameplay::ScriptUtil::LuaArray<Material> param1 = gameplay::ScriptUtil::getObjectPointer<Material>(2, "Material", false, ¶m1Valid); if (!param1Valid) break; Model* instance = getInstance(state); instance->setMaterial(param1); return 0; } } while (0); do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL)) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); Model* instance = getInstance(state); void* returnPtr = ((void*)instance->setMaterial(param1)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Material"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); lua_pushstring(state, "lua_Model_setMaterial - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } case 3: { do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL) && lua_type(state, 3) == LUA_TNUMBER) { // Get parameter 1 off the stack. bool param1Valid; gameplay::ScriptUtil::LuaArray<Material> param1 = gameplay::ScriptUtil::getObjectPointer<Material>(2, "Material", false, ¶m1Valid); if (!param1Valid) break; // Get parameter 2 off the stack. int param2 = (int)luaL_checkint(state, 3); Model* instance = getInstance(state); instance->setMaterial(param1, param2); return 0; } } while (0); do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) && (lua_type(state, 3) == LUA_TSTRING || lua_type(state, 3) == LUA_TNIL)) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); // Get parameter 2 off the stack. const char* param2 = gameplay::ScriptUtil::getString(3, false); Model* instance = getInstance(state); void* returnPtr = ((void*)instance->setMaterial(param1, param2)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Material"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) && lua_type(state, 3) == LUA_TNUMBER) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); // Get parameter 2 off the stack. int param2 = (int)luaL_checkint(state, 3); Model* instance = getInstance(state); void* returnPtr = ((void*)instance->setMaterial(param1, param2)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Material"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); lua_pushstring(state, "lua_Model_setMaterial - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } case 4: { do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) && (lua_type(state, 3) == LUA_TSTRING || lua_type(state, 3) == LUA_TNIL) && (lua_type(state, 4) == LUA_TSTRING || lua_type(state, 4) == LUA_TNIL)) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); // Get parameter 2 off the stack. const char* param2 = gameplay::ScriptUtil::getString(3, false); // Get parameter 3 off the stack. const char* param3 = gameplay::ScriptUtil::getString(4, false); Model* instance = getInstance(state); void* returnPtr = ((void*)instance->setMaterial(param1, param2, param3)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Material"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); lua_pushstring(state, "lua_Model_setMaterial - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } case 5: { do { if ((lua_type(state, 1) == LUA_TUSERDATA) && (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) && (lua_type(state, 3) == LUA_TSTRING || lua_type(state, 3) == LUA_TNIL) && (lua_type(state, 4) == LUA_TSTRING || lua_type(state, 4) == LUA_TNIL) && lua_type(state, 5) == LUA_TNUMBER) { // Get parameter 1 off the stack. const char* param1 = gameplay::ScriptUtil::getString(2, false); // Get parameter 2 off the stack. const char* param2 = gameplay::ScriptUtil::getString(3, false); // Get parameter 3 off the stack. const char* param3 = gameplay::ScriptUtil::getString(4, false); // Get parameter 4 off the stack. int param4 = (int)luaL_checkint(state, 5); Model* instance = getInstance(state); void* returnPtr = ((void*)instance->setMaterial(param1, param2, param3, param4)); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = false; luaL_getmetatable(state, "Material"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); lua_pushstring(state, "lua_Model_setMaterial - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 2, 3, 4 or 5)."); lua_error(state); break; } } return 0; }
static int lua_FontGlyph__init(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 0: { void* returnPtr = ((void*)new Font::Glyph()); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "FontGlyph"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 0)."); lua_error(state); break; } } return 0; }
static int config_env_os_execute(lua_State *L) { if(lua_type(L, 1) == LUA_TTABLE) { struct execute_options options; memset(&options, 0, sizeof(struct execute_options)); process_options(L, &options); pid_t pid; pid = fork(); if(pid == -1) { lua_pushnil(L); lua_pushstring(L, strerror(errno)); lua_pushinteger(L, errno); return 3; } else { if(pid) { int status; if(options.stdout_handle) { fclose(options.stdout_handle); } if(options.stderr_handle) { fclose(options.stderr_handle); } waitpid(pid, &status, 0); if(status) { lua_pushnil(L); lua_pushliteral(L, "execution failed"); lua_pushinteger(L, status); return 3; } else { lua_pushboolean(L, 1); return 1; } } else { char **argv; int nargs; int i; if(options.stdout_handle) { dup2(fileno(options.stdout_handle), fileno(stdout)); } if(options.stderr_handle) { dup2(fileno(options.stderr_handle), fileno(stderr)); } nargs = lua_objlen(L, 1); argv = lua_newuserdata(L, sizeof(char *) * (nargs + 1)); for(i = 1; i <= nargs; i++) { const char *arg; lua_rawgeti(L, 1, i); arg = luaL_checkstring(L, -1); argv[i - 1] = arg; /* we don't need to make a copy, since * we're keeping the table on the stack */ lua_pop(L, 1); } argv[nargs] = NULL; execvp(argv[0], argv); exit(255); /* this should never be reached */ } } } else { lua_pushvalue(L, lua_upvalueindex(1)); lua_insert(L, 1); lua_call(L, lua_gettop(L) - 1, LUA_MULTRET); return lua_gettop(L); } }
static int pb_port_cb_packet(int portfd, int linefd, int bodyfd){ Port *port = port_from_fd(portfd); Line *line = line_from_fd(linefd); if(port == NULL){ LOG_ERROR("port is null"); return 0; } if(line == NULL){ LOG_ERROR("line is null"); return 0; } char *body = ar_ptr(bodyfd); int body_len = ar_remain(bodyfd); int plen = *(int *)body + 4; body += sizeof(int); body_len -= sizeof(int); int msg_name_len = *(unsigned short *)body; body += sizeof(unsigned short); body_len -= sizeof(unsigned short); if(msg_name_len >= MAX_MSG_NAME_LEN - 1){ LOG_ERROR("reach max msg name len %d/%d", msg_name_len, MAX_MSG_NAME_LEN); return 0; } memcpy(recv_msg_name, body, msg_name_len); recv_msg_name[msg_name_len] = 0; XOR(recv_msg_name, msg_name_len); body += msg_name_len; body_len -= msg_name_len; int seq = *(int *)body; body += sizeof(int); body_len -= sizeof(int); lua_State *L = luas_open(); const char *func = port->lua_cb_packet; line->recv_seq = 4 * line->recv_seq + 9; if(line->uid != 0 && line->recv_seq != seq){ LOG_ERROR("seq error expected %d recv %d", line->recv_seq, seq); }else if(func[0] != 0){ struct timeval t1; gettimeofday(&t1, NULL); google::protobuf::Message* message = pbc_load_msg(recv_msg_name); if(message == NULL){ LOG_ERROR("can not load %d msg %s", msg_name_len, recv_msg_name); return 0; } google::protobuf::io::ArrayInputStream stream(body, body_len); if(message->ParseFromZeroCopyStream(&stream) == 0){ delete message; LOG_ERROR("parse fail\n"); return 0; } LOG_MSG("[%d]RECV %s plen:%d FROM %s", line->uid, recv_msg_name, plen, port->name); if(message->ByteSize() < 4096){ LOG_DEBUG("%s", message->DebugString().data()); } luas_pushluafunction(func); //sock lua_pushnumber(L, linefd); //cmd lua_pushstring(L, recv_msg_name); //msg LuaMessage *message_lua = (LuaMessage *)lua_newuserdata(L, sizeof(LuaMessage)); if(message_lua == NULL){ lua_pop(L, lua_gettop(L)); delete message; LOG_ERROR("newuserdata null %s", recv_msg_name); return 0; } message_lua->message = message; message_lua->root_message = message_lua; message_lua->dirty = 0; luaL_getmetatable(L, "LuaMessage"); lua_setmetatable(L, -2); int args_num = 3; if (lua_pcall(L, args_num, 1, 0) != 0){ LOG_ERROR("error running function %s: %s", func, lua_tostring(L, -1)); } struct timeval t2; gettimeofday(&t2, NULL); LOG_MSG("[%d]RECV_END %s usec:%d FROM %s", line->uid, recv_msg_name, time_diff(&t1, &t2), port->name); lua_pop(L, lua_gettop(L)); } return 1; }
int lua_PhysicsCollisionShapeDefinition__init(lua_State* state) { // Get the number of parameters. int paramCount = lua_gettop(state); // Attempt to match the parameters to a valid binding. switch (paramCount) { case 0: { void* returnPtr = (void*)new PhysicsCollisionShape::Definition(); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "PhysicsCollisionShapeDefinition"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; break; } case 1: { do { if ((lua_type(state, 1) == LUA_TUSERDATA || lua_type(state, 1) == LUA_TNIL)) { // Get parameter 1 off the stack. bool param1Valid; gameplay::ScriptUtil::LuaArray<PhysicsCollisionShape::Definition> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionShape::Definition>(1, "PhysicsCollisionShapeDefinition", true, ¶m1Valid); if (!param1Valid) break; void* returnPtr = (void*)new PhysicsCollisionShape::Definition(*param1); if (returnPtr) { gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject)); object->instance = returnPtr; object->owns = true; luaL_getmetatable(state, "PhysicsCollisionShapeDefinition"); lua_setmetatable(state, -2); } else { lua_pushnil(state); } return 1; } } while (0); lua_pushstring(state, "lua_PhysicsCollisionShapeDefinition__init - Failed to match the given parameters to a valid function signature."); lua_error(state); break; } default: { lua_pushstring(state, "Invalid number of parameters (expected 0 or 1)."); lua_error(state); break; } } return 0; }
int addon_output_init(struct output *o) { struct addon *addon = o->info->reg_info->mod->priv; lua_State *L = addon_create_state(addon->filename); // Stack : empty if (!L) { pomlog(POMLOG_ERR "Error while creating new lua state for output %s", o->info->reg_info->name); return POM_ERR; } // Get the output from the outputs table lua_getfield(L, LUA_REGISTRYINDEX, ADDON_OUTPUTS_TABLE); // Stack : outputs lua_getfield(L, -1, o->info->reg_info->name); // Stack : outputs, output // Get rid of the outputs table lua_remove(L, -2); // Stack : output lua_pushnil(L); // Stack : output, nil lua_setfield(L, LUA_REGISTRYINDEX, ADDON_OUTPUTS_TABLE); // Stack : output // Add the output to the registry lua_pushvalue(L, -1); // Stack : output, output lua_setfield(L, LUA_REGISTRYINDEX, ADDON_INSTANCE); // Stack : output // Create the private data // TODO make __priv read-only struct addon_instance_priv *p = lua_newuserdata(L, sizeof(struct addon_instance_priv)); // Stack : output, priv if (!p) { pom_oom(sizeof(struct addon_instance_priv)); return POM_ERR; } memset(p, 0, sizeof(struct addon_instance_priv)); o->priv = p; p->instance = o; p->L = L; if (pthread_mutex_init(&p->lock, NULL)) { pomlog(POMLOG_ERR "Error while initializing mutex : %s", pom_strerror(errno)); abort(); return POM_ERR; } // Assign the output_priv metatable luaL_getmetatable(L, ADDON_OUTPUT_PRIV_METATABLE); // Stack : output, priv, metatable lua_setmetatable(L, -2); // Stack : output, priv // Add it to __priv lua_setfield(L, -2, "__priv"); // Stack : output // Fetch the parameters table lua_getfield(L, -1, "__params"); // Stack : output, params // Parse each param from the class lua_pushnil(L); // Stack : output, params, nil while (lua_next(L, -2) != 0) { // Stack : output, params, key, param if (!lua_istable(L, -1)) { pomlog(POMLOG_ERR "Parameters should be described in tables"); goto err; } // Fetch the name lua_pushinteger(L, 1); // Stack : output, params, key, param, 1 lua_gettable(L, -2); // Stack : output, params, key, param, name if (!lua_isstring(L, -1)) { pomlog(POMLOG_ERR "Parameter name is not a string"); goto err; } const char *name = luaL_checkstring(L, -1); lua_pop(L, 1); // Stack : output, params, key, param // Fetch the ptype type lua_pushinteger(L, 2); // Stack : output, params, key, param, 2 lua_gettable(L, -2); // Stack : output, params, key, param, type if (!lua_isstring(L, -1)) { pomlog(POMLOG_ERR "Parameter type is not a string"); goto err; } const char *type = lua_tostring(L, -1); lua_pop(L, 1); // Stack : output, params, key, param // Fetch the default value lua_pushinteger(L, 3); // Stack : output, params, key, param, 3 lua_gettable(L, -2); // Stack : output, params, key, param, defval if (!lua_isstring(L, -1)) { pomlog(POMLOG_ERR "Parameter default value is not a string"); goto err; } const char *defval = lua_tostring(L, -1); lua_pop(L, 1); // Stack : output, params, key, param // Fetch the description lua_pushinteger(L, 4); // Stack : output, params, key, param, 4 lua_gettable(L, -2); // Stack : output, params, key, param, descr if (!lua_isstring(L, -1)) { pomlog(POMLOG_ERR "Parameter description is not a string"); goto err; } const char *descr = lua_tostring(L, -1); lua_pop(L, 1); // Stack : output, params, key, param // Allocate it struct addon_param *param = malloc(sizeof(struct addon_param)); if (!param) { pom_oom(sizeof(struct addon_param)); goto err; } param->name = strdup(name); if (!param->name) { free(param); pom_oom(strlen(name) + 1); goto err; } param->value = ptype_alloc(type); if (!param->value) { free(param->name); free(param); goto err; } struct registry_param *reg_param = registry_new_param((char*)name, (char*)defval, param->value, (char*)descr, 0); if (output_add_param(o, reg_param) != POM_OK) { pomlog(POMLOG_ERR "Error while adding parameter to the output instance"); if (reg_param) registry_cleanup_param(reg_param); free(param->name); ptype_cleanup(param->value); free(param); goto err; } param->next = p->params; p->params = param; // Pop the value (the param table) lua_pop(L, 1); // Stack : output, params, key } // At this point the stack is : output, params lua_pop(L, 2); // Stack : empty pomlog(POMLOG_DEBUG "Output %s created", o->name); return POM_OK; err: lua_close(L); p->L = NULL; return POM_ERR; }