lua52 C API测试代码

//这是一篇lua与C++交互的情景测试

#include <lua.hpp>
#include <lauxlib.h>
#include <lualib.h>
#include <string.h>
#include <limits.h>

#pragma region not_importent_
static void stackDump (lua_State *L)
{
int i;
int top = lua_gettop(L);
for(i=1;i<=top;i++){
/*repeatforeachlevel*/
int t = lua_type(L, i);
switch (t) {
case LUA_TSTRING:
/* strings */
printf("`%s'", lua_tostring(L, i));
break;
case LUA_TBOOLEAN:
/* booleans */
printf(lua_toboolean(L, i) ? "true" : "false");
break;
case LUA_TNUMBER:
/* numbers */
printf("%g", lua_tonumber(L, i));
break;
default:
/* other values */
printf("%s", lua_typename(L, t));
break;
}
printf(" ");
/* put a separator */
}
printf("\n");
/* end the listing */
}

void error (lua_State *L, const char *fmt, const char *str) {
printf(fmt, str);
}
//待Lua调用的C注册函数。
static int add2(lua_State* L)
{
//检查栈中的参数是否合法，1表示Lua调用时的第一个参数(从左到右)，依此类推。
//如果Lua代码在调用时传递的参数不为number，该函数将报错并终止程序的执行。
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
//将函数的结果压入栈中。如果有多个返回值，可以在这里多次压入栈中。
lua_pushnumber(L,op1 + op2);
//返回值用于提示该C函数的返回值数量，即压入栈中的返回值数量。
return 1;
}
static int sub2(lua_State* L)
{
double op1 = luaL_checknumber(L,1);
double op2 = luaL_checknumber(L,2);
lua_pushnumber(L,op1 - op2);
return 1;
}
#pragma endregion

//////////////////////////////////////////////////////////////////////////
void test_c_call_lua_fun_noParam()
{
const char* buff = "print(\"hello\")";
int err;

//init
lua_State* L = luaL_newstate();
luaL_openlibs(L);

//load buff
err = luaL_loadbuffer(L,buff,strlen(buff),"line") ;
err += lua_pcall(L,0,0,0);
int s = lua_gettop(L);
if(err){
fprintf(stderr,"%s",lua_tostring(L,-1));
lua_pop(L,1);
}

//close
lua_close(L);

}
//////////////////////////////////////////////////////////////////////////
void test_c_call_lua_fun_withParam()
{
lua_State *L = luaL_newstate();
luaL_openlibs(L);
if (luaL_loadfile(L, "luafile2.lua") || lua_pcall(L, 0, 0, 0))
{
error(L, "cannot run configuration file: %s",lua_tostring(L, -1));
return;
}
lua_getglobal(L, "do_lua_kk");
lua_getglobal(L, "a");
lua_getglobal(L, "do_lua_error");
lua_getglobal(L, "b");
lua_getglobal(L, "do_c_one");
lua_getglobal(L, "do_c");
lua_getglobal(L, "width");
lua_getglobal(L, "height");
// lua_getglobal(L, "do_c_two");
stackDump(L); //打印结果：function `lua_str_a' function `lua_str_b' function function 999 300
int k = 100;

k = lua_pcall(L, 2, 1, 1);
stackDump(L); //打印结果：function `lua_str_a' function `lua_str_b' function 8888
/*lua 执行栈上最上面的函数,使用栈上2个参数，向栈压入3个返回值
使用栈上第1位置的函数do_lua_kk作为错误处理回调函数，输出：
-------->do_c
999--add--300-->--2222
*/
k = lua_pcall(L, 1, 0, 0);
stackDump(L);

lua_close(L);
}
//////////////////////////////////////////////////////////////////////////
void test_c_call_lua_fun_withParam2()
{
lua_State* L = luaL_newstate();

//luaL_dostring 等同于luaL_loadstring() || lua_pcall()
//注意：在能够调用Lua函数之前必须执行Lua脚本，否则在后面实际调用Lua函数时会报错，
//错误信息为:"attempt to call a nil value."
const char* lua_function_code = "function add(x,y) return x + y end";
if (luaL_dostring(L,lua_function_code)) {
printf("Failed to run lua code.\n");
return;
}
double x = 1.0, y = 2.3;
lua_getglobal(L,"add");
lua_pushnumber(L,x);
lua_pushnumber(L,y);
//下面的第二个参数表示带调用的lua函数存在两个参数。
//第三个参数表示即使带调用的函数存在多个返回值，那么也只有一个在执行后会被压入栈中。
//lua_pcall调用后，虚拟栈中的函数参数和函数名均被弹出。
if (lua_pcall(L,2,1,0)) {
printf("error is %s.\n",lua_tostring(L,-1));
return;
}
//此时结果已经被压入栈中。
if (!lua_isnumber(L,-1)) {
printf("function 'add' must return a number.\n");
return;
}
double ret = lua_tonumber(L,-1);
lua_pop(L,-1); //弹出返回值。
printf("The result of call function is %f.\n",ret);
lua_close(L);

}
//////////////////////////////////////////////////////////////////////////
void test_c_use_lua_variant()
{
const char* luascript = "width=111 ; height=222";
lua_State* L = luaL_newstate();
int w,h;
//luaL_loadfile的作用是编译lua文件为一个chunk
//把这个chunk当作一个匿名函数压在栈上
//lua_pcall的作用是执行这个匿名函数，然后才能取得栈上的值
if(luaL_loadstring(L,luascript) || lua_pcall(L,0,0,0)){
printf("Error msg is %s.\n",lua_tostring(L,-1));
return;
}
lua_getglobal(L,"width"); //调用次函数，则把全局变量压栈
lua_getglobal(L,"height");//这里压栈次序决定了后面取值的索引
if(!lua_isnumber(L,-2)){
printf("width must be number\n");
return;
}
if(!lua_isnumber(L,-1)){
printf("height must be number\n");
return ;
}
w = lua_tointeger(L,-2);
h = lua_tointeger(L,-1);

printf("width = %d height = %d\n",w,h);
lua_close(L);
}
//////////////////////////////////////////////////////////////////////////
void test_c_use_lua_table()
{
lua_State* L = luaL_newstate();
if (luaL_loadstring(L,"background = { r = 0.30, g = 0.10, b = 0 }")
|| lua_pcall(L,0,0,0)) {
printf("Error Msg is %s.\n",lua_tostring(L,-1));
return;
}
lua_getglobal(L,"background");
if (!lua_istable(L,-1)) {
printf("'background' is not a table.\n" );
return;
}
//下面取栈上的table内容
lua_getfield(L,-1,"r");
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int r = (int)(lua_tonumber(L,-1) * 255);
lua_pop(L,1);//出栈

lua_getfield(L,-1,"g");
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int g = (int)(lua_tonumber(L,-1) * 255);
lua_pop(L,1);

lua_pushnumber(L,0.4);//入栈，栈顶位置-1的值是0.4
lua_setfield(L,-2,"b");//设置background["b"]=0.4，注意-2这个位置表示table的位置！！
lua_getfield(L,-1,"b");//取table值
stackDump(L);
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int b = (int)(lua_tonumber(L,-1) * 255);
printf("r = %d, g = %d, b = %d\n",r,g,b);
lua_pop(L,1);
stackDump(L);
lua_pop(L,1); //栈被清空了

lua_close(L);
}
//////////////////////////////////////////////////////////////////////////
void test_c_new_lua_table()
{
lua_State* L = luaL_newstate();
lua_newtable(L);//Lua会生成一个新的table对象并将其压入栈中。
lua_pushnumber(L,0.3);
stackDump(L);//table 0.3
lua_setfield(L,-2,"r");//设置table["r"]=0.3完了把0.3弹出
stackDump(L);//table

lua_pushnumber(L,0.1);
lua_setfield(L,-2,"g");

lua_pushnumber(L,0.4);
lua_setfield(L,-2,"b");

stackDump(L);//table
lua_setglobal(L,"background");//栈顶元素出栈
stackDump(L);//nil
//调用该宏后，Lua会将当前栈顶的值赋值给第二个参数指定的全局变量名。
//该宏在执行成功后，会将刚刚赋值的值从栈顶弹出。

lua_getglobal(L,"background");//把background压栈
stackDump(L);//table
if (!lua_istable(L,-1)) {
printf("'background' is not a table.\n" );
return;
}
lua_getfield(L,-1,"r");//table["r"]压栈
stackDump(L);//table 0.3
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int r = (int)(lua_tonumber(L,-1) * 255);
lua_pop(L,1);//table

lua_getfield(L,-1,"g");//table 0.1
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int g = (int)(lua_tonumber(L,-1) * 255);
lua_pop(L,1);//table

lua_getfield(L,-1,"b");//table 0.4
if (!lua_isnumber(L,-1)) {
printf("Invalid component in background color.\n");
return;
}
int b = (int)(lua_tonumber(L,-1) * 255);
printf("r = %d, g = %d, b = %d\n",r,g,b);
lua_pop(L,1);//table
lua_pop(L,1);//nil

lua_close(L);
}
//////////////////////////////////////////////////////////////////////////
void test_lua_call_c_fun()
{
const char* testfunc = "print(add2(1.0,2.0)) print(sub2(20.1,19))";
lua_State* L = luaL_newstate();
luaL_openlibs(L);
//将指定的函数注册为Lua的全局函数变量，其中第一个字符串参数为Lua代码在调用C函数时使用的全局函数名
//，第二个参数为实际C函数的指针。
lua_register(L, "add2", add2);
lua_register(L, "sub2", sub2);
//在注册完所有的C函数之后，即可在Lua的代码块中使用这些已经注册的C函数了。
if (luaL_dostring(L,testfunc))
printf("Failed to invoke.\n");
lua_close(L);
}
//////////////////////////////////////////////////////////////////////////
//lua文件里的print被C调用时，是可以打印到终端的！！！
void test_lua_call_c_dll_fun()
{
lua_State* L = luaL_newstate();
luaL_openlibs(L);
if(luaL_dofile(L,"lua_call_c.lua"))
printf("load lua_call_c.lua failed\n");;
lua_close(L);
}

#define BITS_PER_WORD (CHAR_BIT * sizeof(int))
#define I_WORD(i)     ((unsigned int)(i))/BITS_PER_WORD
#define I_BIT(i)      (1 << ((unsigned int)(i)%BITS_PER_WORD))

typedef struct NumArray {
int size;
unsigned int values[1];
} NumArray;

extern "C" int newArray(lua_State* L)
{
//1. 检查第一个参数是否为整型。以及该参数的值是否大于等于1.
int n = luaL_checkint(L,1);
luaL_argcheck(L, n >= 1, 1, "invalid size.");
size_t nbytes = sizeof(NumArray) + I_WORD(n - 1) * sizeof(int);
//2. 参数表示Lua为userdata分配的字节数。同时将分配后的userdata对象压入栈中。
NumArray* a = (NumArray*)lua_newuserdata(L,nbytes);
a->size = n;
for (int i = 0; i < I_WORD(n - 1); ++i)
a->values[i] = 0;
//获取注册表变量myarray，该key的值为metatable。
luaL_getmetatable(L,"myarray");
//将userdata的元表设置为和myarray关联的table。同时将栈顶元素弹出。
lua_setmetatable(L,-2);
return 1;
}

extern "C" int setArray(lua_State* L)
{
//1. Lua传给该函数的第一个参数必须是userdata，该对象的元表也必须是注册表中和myarray关联的table。
//否则该函数报错并终止程序。
NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");
int index = luaL_checkint(L,2) - 1;
//2. 由于任何类型的数据都可以成为布尔值，因此这里使用any只是为了确保有3个参数。
luaL_checkany(L,3);
luaL_argcheck(L,a != NULL,1,"'array' expected.");
luaL_argcheck(L,0 <= index && index < a->size,2,"index out of range.");
if (lua_toboolean(L,3))
a->values[I_WORD(index)] |= I_BIT(index);
else
a->values[I_WORD(index)] &= ~I_BIT(index);
return 0;
}

extern "C" int getArray(lua_State* L)
{
NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");
int index = luaL_checkint(L,2) - 1;
luaL_argcheck(L, a != NULL, 1, "'array' expected.");
luaL_argcheck(L, 0 <= index && index < a->size,2,"index out of range");
lua_pushboolean(L,a->values[I_WORD(index)] & I_BIT(index));
return 1;
}

extern "C" int getSize(lua_State* L)
{
NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");
luaL_argcheck(L,a != NULL,1,"'array' expected.");
lua_pushinteger(L,a->size);
return 1;
}

extern "C" int array2string(lua_State* L)
{
NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");
lua_pushfstring(L,"array(%d)",a->size);
return 1;
}

static luaL_Reg arraylib_f [] = {
{"new", newArray},
{NULL, NULL}
};

static luaL_Reg arraylib_m [] = {
{"set", setArray},
{"get", getArray},
{"size", getSize},
{"__tostring", array2string}, //print(a)时Lua会调用该元方法。
{NULL, NULL}
};

int luaopen_testuserdata(lua_State* L)
{
//1. 创建元表，并将该元表指定给newArray函数新创建的userdata。在Lua中userdata也是以table的身份表现的。
//这样在调用对象函数时，可以通过验证其metatable的名称来确定参数userdata是否合法。
luaL_newmetatable(L,"myarray");
lua_pushvalue(L,-1);
//2. 为了实现面对对象的调用方式，需要将元表的__index字段指向自身，同时再将arraylib_m数组中的函数注册到
//元表中，之后基于这些注册函数的调用就可以以面向对象的形式调用了。
//lua_setfield在执行后会将栈顶的table弹出。
lua_setfield(L,-2,"__index");
//将这些成员函数注册给元表，以保证Lua在寻找方法时可以定位。NULL参数表示将用栈顶的table代替第二个参数。
luaL_newlib(L,arraylib_m);
//这里只注册的工厂方法。
luaL_newlib(L,arraylib_f);
return 1;
}
int main()
{
test_c_call_lua_fun_noParam();
test_c_call_lua_fun_withParam();
test_c_call_lua_fun_withParam2();
test_c_use_lua_variant();
test_c_use_lua_table();
test_c_new_lua_table();
test_lua_call_c_fun();
test_lua_call_c_dll_fun();
getchar();
return 0;
}