自学教程：C++ sr_lua_env_get函数代码示例

static int lua_sr_pv_is_null (lua_State *L){	str pvn;	pv_spec_t pvs;    pv_value_t val;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	pvn.s = (char*)lua_tostring(L, -1);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv is null test: %s/n", pvn.s);	if(pv_parse_spec(&pvn, &pvs)<0)	{		LM_ERR("unable to parse pv [%s]/n", pvn.s);		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	if(pv_get_spec_value(env_L->msg, &pvs, &val) != 0)	{		LM_ERR("unable to get pv value for [%s]/n", pvn.s);		return 0;	}	if(val.flags&PV_VAL_NULL)	{		lua_pushboolean(L, 1);	} else {		lua_pushboolean(L, 0);	}	return 1;}

static int lua_sr_pv_unset (lua_State *L){	str pvn;	pv_spec_t pvs;    pv_value_t val;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	pvn.s = (char*)lua_tostring(L, -1);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv unset: %s/n", pvn.s);	if(pv_parse_spec(&pvn, &pvs)<0)	{		LM_ERR("unable to parse pv [%s]/n", pvn.s);		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	val.flags |= PV_VAL_NULL;	if(pv_set_spec_value(env_L->msg, &pvs, 0, &val)<0)	{		LM_ERR("unable to unset pv [%s]/n", pvn.s);		return 0;	}	return 0;}

static int lua_sr_isflagset (lua_State *L){	int flag;	int ret;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	flag = lua_tointeger(L, -1);	if(env_L->msg==NULL)	{		LM_WARN("invalid parameters from Lua env/n");		return app_lua_return_false(L);	}	if (!flag_in_range(flag))	{		LM_ERR("invalid flag parameter %d/n", flag);		return app_lua_return_false(L);	}	ret = isflagset(env_L->msg, flag);	if(ret>0)		return app_lua_return_true(L);	return app_lua_return_false(L);}

int sr_kemi_exec_func(lua_State* L, str *mname, int midx, str *fname){	int pdelta;	sr_kemi_t *ket = NULL;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	if(env_L==NULL || env_L->msg==NULL) {		LM_ERR("invalid Lua environment attributes/n");		return app_lua_return_false(L);	}	ket = sr_kemi_lookup(mname, midx, fname);	if(ket==NULL) {		LM_ERR("cannot find function (%d): %.*s.%.*s/n", midx,				(mname && mname->len>0)?mname->len:0,				(mname && mname->len>0)?mname->s:"",				fname->len, fname->s);		return app_lua_return_false(L);	}	if(mname->len<=0) {		pdelta = 1;	} else {		pdelta = 3;	}	return sr_kemi_lua_exec_func_ex(L, ket, pdelta);}

static int lua_sr_setdsturi (lua_State *L){	str uri;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	uri.s = (char*)lua_tostring(L, -1);	if(uri.s==NULL)	{		LM_ERR("invalid uri parameter/n");		return app_lua_return_false(L);	}	uri.len = strlen(uri.s);	if(env_L->msg==NULL)	{		LM_WARN("invalid parameters from Lua env/n");		return app_lua_return_false(L);	}	if (set_dst_uri(env_L->msg, &uri)<0)	{		LM_ERR("setting dst uri failed/n");		return app_lua_return_false(L);	}	return app_lua_return_true(L);}

static int lua_sr_resetbflag (lua_State *L){	int flag;	int branch;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	if(lua_gettop(L)==1)	{		flag = lua_tointeger(L, -1);		branch = 0;	} else if(lua_gettop(L)==2) {		flag = lua_tointeger(L, -2);		branch = lua_tointeger(L, -1);	} else {		LM_WARN("invalid number of parameters from Lua/n");		return app_lua_return_false(L);	}	if(env_L->msg==NULL)	{		LM_WARN("invalid parameters from Lua env/n");		return app_lua_return_false(L);	}	if (!flag_in_range(flag))	{		LM_ERR("invalid flag parameter %d/n", flag);		return app_lua_return_false(L);	}	resetbflag(branch, flag);	return app_lua_return_true(L);}

static int lua_sr_hdr_insert (lua_State *L){	struct lump* anchor;	struct hdr_field *hf;	char *txt;	int len;	char *hdr;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	txt = (char*)lua_tostring(L, -1);	if(txt==NULL || env_L->msg==NULL)		return 0;	LM_DBG("insert hf: %s/n", txt);	hf = env_L->msg->headers;	len = strlen(txt);	hdr = (char*)pkg_malloc(len);	if(hdr==NULL)	{		LM_ERR("no pkg memory left/n");		return 0;	}	memcpy(hdr, txt, len);	anchor = anchor_lump(env_L->msg,				hf->name.s + hf->len - env_L->msg->buf, 0, 0);	if(insert_new_lump_before(anchor, hdr, len, 0) == 0)	{		LM_ERR("can't insert lump/n");		pkg_free(hdr);		return 0;	}	return 0;}

static int lua_sr_sethost (lua_State *L){	struct action  act;	struct run_act_ctx h;	str uri;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	uri.s = (char*)lua_tostring(L, -1);	if(uri.s==NULL)	{		LM_ERR("invalid uri parameter/n");		return app_lua_return_false(L);	}	uri.len = strlen(uri.s);	if(env_L->msg==NULL)	{		LM_WARN("invalid parameters from Lua env/n");		return app_lua_return_false(L);	}	memset(&act, 0, sizeof(act));	act.val[0].type = STRING_ST;	act.val[0].u.string = uri.s;	act.type = SET_HOST_T;	init_run_actions_ctx(&h);	if (do_action(&h, &act, env_L->msg)<0)	{		LM_ERR("do action failed/n");		return app_lua_return_false(L);	}	return app_lua_return_true(L);}

/** * puts a table with content of a xavp */static int lua_sr_xavp_get(lua_State *L){	str xavp_name;	int indx = 0;	sr_lua_env_t *env_L;	sr_xavp_t *avp;	int num_param = 0;	int param = -1;	int simple_flag = 0;	env_L = sr_lua_env_get();	num_param = lua_gettop(L);	if(num_param<2 && num_param>3)	{		LM_ERR("wrong number of parameters [%d]/n", num_param);		return 0;	}	if(num_param==3)	{		if(!lua_isnumber(L, param))		{			LM_ERR("invalid int parameter/n");			return 0;		}		simple_flag = lua_tointeger(L, param);		param = param - 1;	}	if(!lua_isnumber(L, param))	{		LM_ERR("invalid int parameter/n");		return 0;	}	indx = lua_tointeger(L, param);	param = param - 1;	xavp_name.s = (char*)lua_tostring(L, param);	if(xavp_name.s==NULL || env_L->msg==NULL)		return 0;	xavp_name.len = strlen(xavp_name.s);	avp = xavp_get_by_index(&xavp_name, indx, NULL);	if(avp==NULL){		LM_ERR("can't get xavp:%.*s index:%d/n", xavp_name.len, xavp_name.s, indx);		lua_pushnil(L);		return 1;	}	if (simple_flag != 0)	{		lua_sr_push_xavp_table_simple(L, avp);	}	else	{		lua_sr_push_xavp_table(L, avp);	}	return 1;}

static int lua_sr_pv_sets (lua_State *L){	str pvn;	pv_spec_t *pvs;	pv_value_t val;	sr_lua_env_t *env_L;	int pl;	env_L = sr_lua_env_get();	if(lua_gettop(L)<2)	{		LM_ERR("to few parameters [%d]/n",lua_gettop(L));		return 0;	}	if(!lua_isstring(L, -1))	{		LM_ERR("Cannot convert to a string when assigning value to variable: %s/n",				lua_tostring(L, -2));		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	val.rs.s = (char*)lua_tostring(L, -1);	val.rs.len = strlen(val.rs.s);	val.flags |= PV_VAL_STR;	pvn.s = (char*)lua_tostring(L, -2);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv set: %s/n", pvn.s);	pl = pv_locate_name(&pvn);	if(pl != pvn.len)	{		LM_ERR("invalid pv [%s] (%d/%d)/n", pvn.s, pl, pvn.len);		return 0;	}	pvs = pv_cache_get(&pvn);	if(pvs==NULL)	{		LM_ERR("cannot get pv spec for [%s]/n", pvn.s);		return 0;	}	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)	{		LM_ERR("unable to set pv [%s]/n", pvn.s);		return 0;	}	return 0;}

static int lua_sr_pv_seti (lua_State *L){	str pvn;	pv_spec_t *pvs;	pv_value_t val;	sr_lua_env_t *env_L;	int pl;	env_L = sr_lua_env_get();	if(lua_gettop(L)<2)	{		LM_ERR("to few parameters [%d]/n", lua_gettop(L));		return 0;	}	if(!lua_isnumber(L, -1))	{		LM_ERR("invalid int parameter/n");		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	val.ri = lua_tointeger(L, -1);	val.flags |= PV_TYPE_INT|PV_VAL_INT;	pvn.s = (char*)lua_tostring(L, -2);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv set: %s/n", pvn.s);	pl = pv_locate_name(&pvn);	if(pl != pvn.len)	{		LM_ERR("invalid pv [%s] (%d/%d)/n", pvn.s, pl, pvn.len);		return 0;	}	pvs = pv_cache_get(&pvn);	if(pvs==NULL)	{		LM_ERR("cannot get pv spec for [%s]/n", pvn.s);		return 0;	}	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)	{		LM_ERR("unable to set pv [%s]/n", pvn.s);		return 0;	}	return 0;}

static int lua_sr_resetdsturi (lua_State *L){	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	if(env_L->msg==NULL)	{		LM_WARN("invalid parameters from Lua env/n");		return app_lua_return_false(L);	}	reset_dst_uri(env_L->msg);	return app_lua_return_true(L);}

static int lua_sr_hdr_append (lua_State *L){	struct lump* anchor;	struct hdr_field *hf;	char *txt;	int len;	char *hdr;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	txt = (char*)lua_tostring(L, -1);	if(txt==NULL || env_L->msg==NULL)		return 0;	LM_DBG("append hf: %s/n", txt);	if (parse_headers(env_L->msg, HDR_EOH_F, 0) == -1)	{		LM_ERR("error while parsing message/n");		return 0;	}	hf = env_L->msg->last_header;	len = strlen(txt);	hdr = (char*)pkg_malloc(len);	if(hdr==NULL)	{		LM_ERR("no pkg memory left/n");		return 0;	}	memcpy(hdr, txt, len);	anchor = anchor_lump(env_L->msg,				hf->name.s + hf->len - env_L->msg->buf, 0, 0);	if(anchor==NULL)	{		LM_ERR("unable to get the anchor/n");		pkg_free(hdr);		return 0;	}	if(insert_new_lump_before(anchor, hdr, len, 0) == 0)	{		LM_ERR("can't insert lump/n");		pkg_free(hdr);		return 0;	}	return 0;}

static int lua_sr_pv_get (lua_State *L){	str pvn;	pv_spec_t *pvs;	pv_value_t val;	sr_lua_env_t *env_L;	int pl;	env_L = sr_lua_env_get();	pvn.s = (char*)lua_tostring(L, -1);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv get: %s/n", pvn.s);	pl = pv_locate_name(&pvn);	if(pl != pvn.len)	{		LM_ERR("invalid pv [%s] (%d/%d)/n", pvn.s, pl, pvn.len);		return 0;	}	pvs = pv_cache_get(&pvn);	if(pvs==NULL)	{		LM_ERR("cannot get pv spec for [%s]/n", pvn.s);		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	if(pv_get_spec_value(env_L->msg, pvs, &val) != 0)	{		LM_ERR("unable to get pv value for [%s]/n", pvn.s);		return 0;	}	if(val.flags&PV_VAL_NULL)	{		return 0;	}	if(val.flags&PV_TYPE_INT)	{		lua_pushinteger(L, val.ri);		return 1;	}	lua_pushlstring(L, val.rs.s, val.rs.len);	return 1;}

/** * puts a table with the list of keys of the xavp */static int lua_sr_xavp_get_keys (lua_State *L){	str xavp_name;	int indx = 0;	sr_lua_env_t *env_L;	sr_xavp_t *avp;	struct str_list *keys, *k;	env_L = sr_lua_env_get();	if(lua_gettop(L)<2)	{		LM_ERR("to few parameters [%d]/n",lua_gettop(L));		return 0;	}	if(!lua_isnumber(L, -1))	{		LM_ERR("invalid int parameter/n");		return 0;	}	indx = lua_tointeger(L, -1);	xavp_name.s = (char*)lua_tostring(L, -2);	if(xavp_name.s==NULL || env_L->msg==NULL)		return 0;	xavp_name.len = strlen(xavp_name.s);	avp = xavp_get_by_index(&xavp_name, indx, NULL);	if(avp==NULL){		LM_ERR("can't get xavp:%.*s index:%d/n", xavp_name.len, xavp_name.s, indx);		lua_pushnil(L);		return 1;	}	keys = xavp_get_list_key_names(avp);	lua_sr_push_str_list_table(L, keys);	// free list	while(keys!=NULL){		k = keys;		keys = k->next;		pkg_free(k);	}	return 1;}

static int lua_sr_pv_is_null (lua_State *L){	str pvn;	pv_spec_t *pvs;	pv_value_t val;	sr_lua_env_t *env_L;	int pl;	env_L = sr_lua_env_get();	pvn.s = (char*)lua_tostring(L, -1);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv is null test: %s/n", pvn.s);	pl = pv_locate_name(&pvn);	if(pl != pvn.len)	{		LM_ERR("invalid pv [%s] (%d/%d)/n", pvn.s, pl, pvn.len);		return 0;	}	pvs = pv_cache_get(&pvn);	if(pvs==NULL)	{		LM_ERR("cannot get pv spec for [%s]/n", pvn.s);		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	if(pv_get_spec_value(env_L->msg, pvs, &val) != 0)	{		LM_NOTICE("unable to get pv value for [%s]/n", pvn.s);		lua_pushboolean(L, 1);		return 1;	}	if(val.flags&PV_VAL_NULL)	{		lua_pushboolean(L, 1);	} else {		lua_pushboolean(L, 0);	}	return 1;}

static int lua_sr_pv_unset (lua_State *L){	str pvn;	pv_spec_t *pvs;	pv_value_t val;	sr_lua_env_t *env_L;	int pl;	env_L = sr_lua_env_get();	pvn.s = (char*)lua_tostring(L, -1);	if(pvn.s==NULL || env_L->msg==NULL)		return 0;	pvn.len = strlen(pvn.s);	LM_DBG("pv unset: %s/n", pvn.s);	pl = pv_locate_name(&pvn);	if(pl != pvn.len)	{		LM_ERR("invalid pv [%s] (%d/%d)/n", pvn.s, pl, pvn.len);		return 0;	}	pvs = pv_cache_get(&pvn);	if(pvs==NULL)	{		LM_ERR("cannot get pv spec for [%s]/n", pvn.s);		return 0;	}	memset(&val, 0, sizeof(pv_value_t));	val.flags |= PV_VAL_NULL;	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)	{		LM_ERR("unable to unset pv [%s]/n", pvn.s);		return 0;	}	return 0;}

static int lua_sr_hdr_append_to_reply (lua_State *L){	char *txt;	int len;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	txt = (char*)lua_tostring(L, -1);	if(txt==NULL || env_L->msg==NULL)		return 0;	LM_DBG("append to reply: %s/n", txt);	len = strlen(txt);	if(add_lump_rpl(env_L->msg, txt, len, LUMP_RPL_HDR)==0)	{		LM_ERR("unable to add reply lump/n");		return 0;	}	return 0;}

static int lua_sr_hdr_remove (lua_State *L){	struct lump* anchor;	struct hdr_field *hf;	char *txt;	str hname;	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	txt = (char*)lua_tostring(L, -1);	if(txt==NULL || env_L->msg==NULL)		return 0;	LM_DBG("remove hf: %s/n", txt);	if (parse_headers(env_L->msg, HDR_EOH_F, 0) == -1) {		LM_ERR("error while parsing message/n");		return 0;	}	hname.s = txt;	hname.len = strlen(txt);	for (hf=env_L->msg->headers; hf; hf=hf->next)	{		if (cmp_hdrname_str(&hf->name, &hname)==0)		{			anchor=del_lump(env_L->msg,					hf->name.s - env_L->msg->buf, hf->len, 0);			if (anchor==0)			{				LM_ERR("cannot remove hdr %s/n", txt);				return 0;			}		}	}	return 0;}

static int lua_sr_modf (lua_State *L){	int ret;	char *luav[MAX_ACTIONS];	char *argv[MAX_ACTIONS];	int argc;	int i;	int mod_type;	struct run_act_ctx ra_ctx;	unsigned modver;	struct action *act;	sr31_cmd_export_t* expf;	sr_lua_env_t *env_L;	ret = 1;	act = NULL;	argc = 0;	memset(luav, 0, MAX_ACTIONS*sizeof(char*));	memset(argv, 0, MAX_ACTIONS*sizeof(char*));	env_L = sr_lua_env_get();	if(env_L->msg==NULL)		goto error;#if 0	app_lua_dump_stack(L);#endif	argc = lua_gettop(L);	if(argc==0)	{		LM_ERR("name of module function not provided/n");		goto error;	}	if(argc>=MAX_ACTIONS)	{		LM_ERR("too many parameters/n");		goto error;	}	/* first is function name, then parameters */	for(i=1; i<=argc; i++)	{		if (!lua_isstring(L, i))		{			LM_ERR("invalid parameter type (%d)/n", i);			goto error;		}		luav[i-1] = (char*)lua_tostring(L, i);	}	/* pkg copy only parameters */	for(i=1; i<MAX_ACTIONS; i++)	{		if(luav[i]!=NULL)		{			argv[i] = (char*)pkg_malloc(strlen(luav[i])+1);			if(argv[i]==NULL)			{				LM_ERR("no more pkg/n");				goto error;			}			strcpy(argv[i], luav[i]);		}	}	expf = find_export_record(luav[0], argc-1, 0, &modver);	if (expf==NULL) {		LM_ERR("function '%s' is not available/n", luav[0]);		goto error;	}	/* check fixups */	if (expf->fixup!=NULL && expf->free_fixup==NULL) {		LM_ERR("function '%s' has fixup - cannot be used/n", luav[0]);		goto error;	}	switch(expf->param_no) {		case 0:			mod_type = MODULE0_T;			break;		case 1:			mod_type = MODULE1_T;			break;		case 2:			mod_type = MODULE2_T;			break;		case 3:			mod_type = MODULE3_T;			break;		case 4:			mod_type = MODULE4_T;			break;		case 5:			mod_type = MODULE5_T;			break;		case 6:			mod_type = MODULE6_T;			break;		case VAR_PARAM_NO:			mod_type = MODULEX_T;			break;		default:			LM_ERR("unknown/bad definition for function '%s' (%d params)/n",					luav[0], expf->param_no);//.........这里部分代码省略.........

/** * puts a table with content of a xavp */static int lua_sr_xavp_get(lua_State *L){	str xavp_name;	int indx = 0;	sr_lua_env_t *env_L;	sr_xavp_t *avp;	int num_param = 0;	int param = -1;	int all_flag = 0;	int simple_flag = 0;	lua_Number elem = 1;	int xavp_size = 0;	env_L = sr_lua_env_get();	num_param = lua_gettop(L);	if(num_param<2 && num_param>3)	{		LM_ERR("wrong number of parameters [%d]/n", num_param);		return 0;	}	if(num_param==3)	{		if(!lua_isnumber(L, param))		{			LM_ERR("invalid int parameter/n");			return 0;		}		simple_flag = lua_tointeger(L, param);		param = param - 1;	}	if(!lua_isnumber(L, param))	{		if(lua_isnil(L, param))		{			all_flag = 1;		}		else		{			LM_ERR("invalid parameter, must be int or nil/n");			return 0;		}	}	else	{		indx = lua_tointeger(L, param);	}	param = param - 1;	xavp_name.s = (char*)lua_tostring(L, param);	if(xavp_name.s==NULL || env_L->msg==NULL)	{		LM_ERR("No xavp name in %d param/n", param);		return 0;	}	xavp_name.len = strlen(xavp_name.s);	if(all_flag>0) {		indx = 0;		lua_newtable(L);	}	xavp_size = xavp_count(&xavp_name, NULL);	if(indx<0)	{		if((indx*-1)>xavp_size)		{			LM_ERR("can't get xavp:%.*s index:%d/n", xavp_name.len, xavp_name.s, indx);			lua_pushnil(L);			return 1;		}		indx = xavp_size + indx;	}	avp = xavp_get_by_index(&xavp_name, indx, NULL);	do	{		if(avp==NULL){			LM_ERR("can't get xavp:%.*s index:%d/n", xavp_name.len, xavp_name.s, indx);			lua_pushnil(L);			return 1;		}		if(all_flag!=0) {			lua_pushnumber(L, elem);			elem = elem + 1;		}		lua_sr_push_xavp_table(L, avp, simple_flag);		if(all_flag!=0) {			lua_rawset(L, -3);			indx = indx + 1;			avp = xavp_get_by_index(&xavp_name, indx, NULL);		}		else return 1;	}while(avp!=NULL);	return 1;}

int sr_kemi_exec_func(lua_State* L, str *mname, int midx, str *fname){	int i;	int pdelta;	int argc;	int ret;	sr_kemi_t *ket = NULL;	sr_kemi_val_t vps[SR_KEMI_PARAMS_MAX];	sr_lua_env_t *env_L;	env_L = sr_lua_env_get();	if(env_L==NULL || env_L->msg==NULL) {		LM_ERR("invalid Lua environment attributes/n");		return app_lua_return_false(L);	}	ket = sr_kemi_lookup(mname, midx, fname);	if(ket==NULL) {		return app_lua_return_false(L);	}	if(mname->len<=0) {		pdelta = 1;	} else {		pdelta = 3;	}	argc = lua_gettop(L);	if(argc==pdelta && ket->ptypes[0]==SR_KEMIP_NONE) {		ret = ((sr_kemi_fm_f)(ket->func))(env_L->msg);		return sr_kemi_return(L, ket, ret);	}	if(argc==pdelta && ket->ptypes[0]!=SR_KEMIP_NONE) {		LM_ERR("invalid number of parameters for: %.*s/n",				fname->len, fname->s);		return app_lua_return_false(L);	}	if(argc>=SR_KEMI_PARAMS_MAX+pdelta) {		LM_ERR("too many parameters for: %.*s/n",				fname->len, fname->s);		return app_lua_return_false(L);	}	memset(vps, 0, SR_KEMI_PARAMS_MAX*sizeof(sr_kemi_val_t));	for(i=0; i<SR_KEMI_PARAMS_MAX; i++) {		if(ket->ptypes[i]==SR_KEMIP_NONE) {			break;		} else if(ket->ptypes[i]==SR_KEMIP_STR) {			vps[i].s.s = (char*)lua_tostring(L, i+pdelta+1);			vps[i].s.len = strlen(vps[i].s.s);			LM_DBG("param[%d] for: %.*s is str: %.*s/n", i,				fname->len, fname->s, vps[i].s.len, vps[i].s.s);		} else if(ket->ptypes[i]==SR_KEMIP_INT) {			vps[i].n = lua_tointeger(L, i+pdelta+1);			LM_DBG("param[%d] for: %.*s is int: %d/n", i,				fname->len, fname->s, vps[i].n);		} else {			LM_ERR("unknown parameter type %d (%d)/n", ket->ptypes[i], i);			return app_lua_return_false(L);		}	}	switch(i) {		case 1:			if(ket->ptypes[0]==SR_KEMIP_INT) {				ret = ((sr_kemi_fmn_f)(ket->func))(env_L->msg, vps[0].n);				return sr_kemi_return(L, ket, ret);			} else if(ket->ptypes[0]==SR_KEMIP_STR) {				ret = ((sr_kemi_fms_f)(ket->func))(env_L->msg, &vps[0].s);				return sr_kemi_return(L, ket, ret);			} else {				LM_ERR("invalid parameters for: %.*s/n",						fname->len, fname->s);				return app_lua_return_false(L);			}		break;		case 2:			if(ket->ptypes[0]==SR_KEMIP_INT) {				if(ket->ptypes[1]==SR_KEMIP_INT) {					ret = ((sr_kemi_fmnn_f)(ket->func))(env_L->msg, vps[0].n, vps[1].n);					return sr_kemi_return(L, ket, ret);				} else if(ket->ptypes[1]==SR_KEMIP_STR) {					ret = ((sr_kemi_fmns_f)(ket->func))(env_L->msg, vps[0].n, &vps[1].s);					return sr_kemi_return(L, ket, ret);				} else {					LM_ERR("invalid parameters for: %.*s/n",							fname->len, fname->s);					return app_lua_return_false(L);				}			} else if(ket->ptypes[0]==SR_KEMIP_STR) {				if(ket->ptypes[1]==SR_KEMIP_INT) {					ret = ((sr_kemi_fmsn_f)(ket->func))(env_L->msg, &vps[0].s, vps[1].n);					return sr_kemi_return(L, ket, ret);				} else if(ket->ptypes[1]==SR_KEMIP_STR) {					ret = ((sr_kemi_fmss_f)(ket->func))(env_L->msg, &vps[0].s, &vps[1].s);					return sr_kemi_return(L, ket, ret);				} else {					LM_ERR("invalid parameters for: %.*s/n",							fname->len, fname->s);//.........这里部分代码省略.........