每天早晨叫醒你的不是闹钟,而是梦想

  1 #include <lua.hpp>   
  2 #include <lauxlib.h>   
  3 #include <lualib.h>   
  4 #include <limits.h>   
  5    
  6 #define BITS_PER_WORD (CHAR_BIT * sizeof(int))   
  7 #define I_WORD(i)     ((unsigned int)(i))/BITS_PER_WORD   
  8 #define I_BIT(i)      (1 << ((unsigned int)(i)%BITS_PER_WORD))   
  9   
  10 typedef struct NumArray {  
  11     int size;  12     unsigned int values[1];  
  13 } NumArray;  
  14   
  15 extern "C" int newArray(lua_State* L)  
  16 {  
  17     //1. 检查第一个参数是否为整型。以及该参数的值是否大于等于1.  
  18     int n = luaL_checkint(L,1);  
  19     luaL_argcheck(L, n >= 1, 1, "invalid size.");  
  20     size_t nbytes = sizeof(NumArray) + I_WORD(n - 1) * sizeof(int);  
  21     //2. 参数表示Lua为userdata分配的字节数。同时将分配后的userdata对象压入栈中。  
  22     NumArray* a = (NumArray*)lua_newuserdata(L,nbytes);  
  23     a->size = n;  
  24     for (int i = 0; i < I_WORD(n - 1); ++i)  
  25         a->values[i] = 0;  
  26     //获取注册表变量myarray，该key的值为metatable。  
  27     luaL_getmetatable(L,"myarray");  
  28     //将userdata的元表设置为和myarray关联的table。同时将栈顶元素弹出。  
  29     lua_setmetatable(L,-2);  
  30     return 1;  
  31 }  
  32   
  33 extern "C" int setArray(lua_State* L)  
  34 {  
  35     //1. Lua传给该函数的第一个参数必须是userdata，该对象的元表也必须是注册表中和myarray关联的table。  
  36     //否则该函数报错并终止程序。  
  37     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  38     int index = luaL_checkint(L,2) - 1;  
  39     //2. 由于任何类型的数据都可以成为布尔值，因此这里使用any只是为了确保有3个参数。  
  40     luaL_checkany(L,3);  
  41     luaL_argcheck(L,a != NULL,1,"'array' expected.");  
  42     luaL_argcheck(L,0 <= index && index < a->size,2,"index out of range.");  
  43     if (lua_toboolean(L,3))  
  44         a->values[I_WORD(index)] |= I_BIT(index);  
  45     else  
  46         a->values[I_WORD(index)] &= ~I_BIT(index);  
  47     return 0;  
  48 }  
  49   
  50 extern "C" int getArray(lua_State* L)  
  51 {  
  52     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  53     int index = luaL_checkint(L,2) - 1;  
  54     luaL_argcheck(L, a != NULL, 1, "'array' expected.");  
  55     luaL_argcheck(L, 0 <= index && index < a->size,2,"index out of range");  
  56     lua_pushboolean(L,a->values[I_WORD(index)] & I_BIT(index));  
  57     return 1;  
  58 }  
  59   
  60 extern "C" int getSize(lua_State* L)  
  61 {  
  62     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  63     luaL_argcheck(L,a != NULL,1,"'array' expected.");  
  64     lua_pushinteger(L,a->size);  
  65     return 1;  
  66 }  
  67   
  68 extern "C" int array2string(lua_State* L)  
  69 {  
  70     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  71     lua_pushfstring(L,"array(%d)",a->size);  
  72     return 1;  
  73 }  
  74   
  75 static luaL_Reg arraylib_f [] = {   
  76     {"new", newArray},  
  77     {NULL, NULL}   
  78 };   
  79   
  80 static luaL_Reg arraylib_m [] = {  
  81     {"set", setArray},  
  82     {"get", getArray},  
  83     {"size", getSize},  
  84     {"__tostring", array2string}, //print(a)时Lua会调用该元方法。  
  85     {NULL, NULL}   
  86 };  
  87   
  88 extern "C" __declspec(dllexport)  
  89 int luaopen_testuserdata(lua_State* L)  
  90 {  
  91     //1. 创建元表，并将该元表指定给newArray函数新创建的userdata。在Lua中userdata也是以table的身份表现的。  
  92     //这样在调用对象函数时，可以通过验证其metatable的名称来确定参数userdata是否合法。  
  93     luaL_newmetatable(L,"myarray");  
  94     lua_pushvalue(L,-1); 
  95     //2. 为了实现面对对象的调用方式，需要将元表的__index字段指向自身，同时再将arraylib_m数组中的函数注册到  
  96     //元表中，之后基于这些注册函数的调用就可以以面向对象的形式调用了。  
  97     //lua_setfield在执行后会将栈顶的table弹出。  
  98     lua_setfield(L,-2,"__index");  
  99     //将这些成员函数注册给元表，以保证Lua在寻找方法时可以定位。NULL参数表示将用栈顶的table代替第二个参数。   
  100    luaL_register(L,NULL,arraylib_m); 
  101     //这里只注册的工厂方法。 
  102     luaL_register(L,"testuserdata",arraylib_f); 
  103     return 1; 
  104 }

1 #include <stdio.h>  
2 #include <string.h>  
3 #include <lua.hpp>  
4 #include <lauxlib.h>  
5 #include <lualib.h>  
6   
7 //待Lua调用的C注册函数。  
8 static int add2(lua_State* L)  
9 { 
10     //检查栈中的参数是否合法，1表示Lua调用时的第一个参数(从左到右)，依此类推。 
11     //如果Lua代码在调用时传递的参数不为number，该函数将报错并终止程序的执行。 
12     double op1 = luaL_checknumber(L,1); 
13     double op2 = luaL_checknumber(L,2); 
14     //将函数的结果压入栈中。如果有多个返回值，可以在这里多次压入栈中。 
15     lua_pushnumber(L,op1 + op2); 
16     //返回值用于提示该C函数的返回值数量，即压入栈中的返回值数量。 
17     return 1; 
18 } 
19  
20 //另一个待Lua调用的C注册函数。 
21 static int sub2(lua_State* L) 
22 { 
23     double op1 = luaL_checknumber(L,1); 
24     double op2 = luaL_checknumber(L,2); 
25     lua_pushnumber(L,op1 - op2); 
26     return 1; 
27 } 
28  
29 const char* testfunc = "print(add2(1.0,2.0)) print(sub2(20.1,19))"; 
30  
31 int main() 
32 { 
33     lua_State* L = luaL_newstate(); 
34     luaL_openlibs(L); 
35     //将指定的函数注册为Lua的全局函数变量，其中第一个字符串参数为Lua代码 
36     //在调用C函数时使用的全局函数名，第二个参数为实际C函数的指针。 
37     lua_register(L, "add2", add2); 
38     lua_register(L, "sub2", sub2); 
39     //在注册完所有的C函数之后，即可在Lua的代码块中使用这些已经注册的C函数了。 
40     if (luaL_dostring(L,testfunc)) 
41         printf("Failed to invoke.\n"); 
42     lua_close(L); 43     return 0; 44 }

1 #include <stdio.h>  
2 #include <string.h>  
3 #include <lua.hpp>  
4 #include <lauxlib.h>  
5 #include <lualib.h>  
6   
7 //待注册的C函数，该函数的声明形式在上面的例子中已经给出。  
8 //需要说明的是，该函数必须以C的形式被导出，因此extern "C"是必须的。  
9 //函数代码和上例相同，这里不再赘述。 
10 extern "C" int add(lua_State* L)  
11 { 12     double op1 = luaL_checknumber(L,1); 
13     double op2 = luaL_checknumber(L,2); 
14     lua_pushnumber(L,op1 + op2); 
15     return 1; 
16 } 
17  
18 extern "C" int sub(lua_State* L) 
19 { 
20     double op1 = luaL_checknumber(L,1);
21     double op2 = luaL_checknumber(L,2); 
22     lua_pushnumber(L,op1 - op2); 
23     return 1; 
24 } 
25  
26 //luaL_Reg结构体的第一个字段为字符串，在注册时用于通知Lua该函数的名字。 
27 //第一个字段为C函数指针。 
28 //结构体数组中的最后一个元素的两个字段均为NULL，用于提示Lua注册函数已经到达数组的末尾。 
29 static luaL_Reg mylibs[] = {  
30     {"add", add}, 
31     {"sub", sub}, 
32     {NULL, NULL}  
33 };  
34  
35 //该C库的唯一入口函数。其函数签名等同于上面的注册函数。见如下几点说明： 
36 //1. 我们可以将该函数简单的理解为模块的工厂函数。 
37 //2. 其函数名必须为luaopen_xxx，其中xxx表示library名称。Lua代码require "xxx"需要与之对应。 
38 //3. 在luaL_register的调用中，其第一个字符串参数为模块名"xxx"，第二个参数为待注册函数的数组。 
39 //4. 需要强调的是，所有需要用到"xxx"的代码，不论C还是Lua，都必须保持一致，这是Lua的约定， 
40 //   否则将无法调用。 
41 extern "C" __declspec(dllexport) 
42 int luaopen_mytestlib(lua_State* L)  
43 { 
44     const char* libName = "mytestlib"; 
45     luaL_register(L,libName,mylibs); 
46     return 1; 
47 }

1 require "mytestlib"  --指定包名称 
2  
3 --在调用时，必须是package.function 
4 print(mytestlib.add(1.0,2.0)) 
5 print(mytestlib.sub(20.1,19))

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <lua.hpp>
 4 #include <lauxlib.h>
 5 #include <lualib.h>
 6 
 7 int main(void)
 8 {
 9     const char* buff = "print(\"hello\")";
10     int error;
11     lua_State* L = luaL_newstate();
12     luaL_openlibs(L);
13 
14     error = luaL_loadbuffer(L,buff,strlen(buff),"line") || lua_pcall(L,0,0,0);
15     int s = lua_gettop(L);
16     if (error) {
17         fprintf(stderr,"%s",lua_tostring(L,-1));
18         lua_pop(L,1);
19     }
20     lua_close(L);
21     return 0;
22 }

 1 static void stackDump(lua_State* L) 
 2 {
 3     int top = lua_gettop(L);
 4     for (int i = 1; i <= top; ++i) {
 5         int t = lua_type(L,i);
 6         switch(t) {
 7         case LUA_TSTRING:
 8             printf("'%s'",lua_tostring(L,i));
 9             break;
10         case LUA_TBOOLEAN:
11             printf(lua_toboolean(L,i) ? "true" : "false");
12             break;
13         case LUA_TNUMBER:
14             printf("%g",lua_tonumber(L,i));
15             break;
16         default:
17             printf("%s",lua_typename(L,t));
18             break;
19         }
20         printf("");
21     }
22     printf("\n");
23 }

 1 int main()
 2 {
 3     lua_State* L = luaL_newstate();
 4     lua_pushboolean(L,1);
 5     lua_pushnumber(L,10);
 6     lua_pushnil(L);
 7     lua_pushstring(L,"hello");
 8     stackDump(L); //true 10 nil 'hello'
 9 
10     lua_pushvalue(L,-4);
11     stackDump(L); //true 10 nil 'hello' true
12 
13     lua_replace(L,3);
14     stackDump(L); //true 10 true 'hello'
15 
16     lua_settop(L,6);
17     stackDump(L); //true 10 true 'hello' nil nil
18 
19     lua_remove(L,-3);
20     stackDump(L); //true 10 true nil nil
21 
22     lua_settop(L,-5);
23     stackDump(L); //true
24 
25     lua_close(L);
26     return 0;
27 }

1 for count = 1,math.huge do
2     local line = io.read("*line")  --如果不传参数，缺省值也是"*line"
3     if line == nil then 
4         break
5     end
6     io.write(string.format("%6d  ",count),line,"\n")
7 end

1 local lines = {}
2 for line in io.lines() do   --通过迭代器访问每一个数据
3     lines[#lines + 1] = line
4 end
5 table.sort(lines)  --排序，Lua标准库的table库提供的函数。
6 for _,l in ipairs(lines) do
7     io.write(l,"\n")
8 end

 1 --[[
 2     6.0  -3.23   1000
 3     ... ...
 4     下面的代码读取注释中的数字
 5 --]]
 6 while true do
 7     local n1,n2,n3 = io.read("*number","*number","*number")
 8     if not n1 then
 9         break
10     end
11     print(math.max(n1,n2,n3))
12 end

1 while true do
2     local block = io.read(2^13)
3     if not block then
4         break
5     end
6     io.write(block)
7 end

1 local f = assert(io.open(filename,"r"))
2 local t = f:read("*all")  --对于read而言，其参数完全等同于简单模型下read的参数。
3 f:close()

1 local temp = io.input()   --将当前文件句柄保存
2 io.input("newInputfile")  --打开新的输入文件
3 io.input():close()        --关闭当前文件
4 io.input(temp)            --恢复原来的输入文件

 1 local BUFSIZE = 8192
 2 local f = io.input(arg[1])  --打开输入文件
 3 local cc, lc, wc, = 0, 0, 0  --分别计数字符、行和单词    
 4 while true do
 5     local lines,rest = f:read(BUFSIZE,"*line")
 6     if not lines then
 7         break
 8     end
 9     if rest then
10         lines = lines .. rest .. "\n"
11     end
12     cc = cc + #lines
13     --计算单词数量
14     local _, t = string.gsub(lines."%S+","")
15     wc = wc + t
16     --计算行数
17     _,t = string.gsub(line,"\n","\n")
18     lc = lc + t
19 end
20 print(lc,wc,cc)

1 function fsize(file)
2     local current = file:seek()   --获取当前位置
3     local size = file:seek("end") --获取文件大小
4     file:seek("set",current)      --恢复原有的当前位置
5     return size
6 end

 1 dd = os.date("*t",os.time())  --如果格式化字符串为"*t"，函数将返回table形式的日期对象。如果为"!*t"，则表示为UTC时间格式。
 2 print("year = " .. dd.year)
 3 print("month = " .. dd.month)
 4 print("day = " .. dd.day)
 5 print("weekday = " .. dd.wday)  --一个星期中的第几天，周日是第一天
 6 print("yearday = " .. dd.yday)  --一年中的第几天，1月1日是第一天
 7 print("hour = " .. dd.hour)
 8 print("min = " .. dd.min)
 9 print("sec = " .. dd.sec)
10     
11 --[[
12 year = 2012
13 month = 4
14 day = 5
15 weekday = 5
16 yearday = 96
17 hour = 11
18 min = 13
19 sec = 44
20 --]]

1 local x = os.clock()
2 local s = 0
3 for i = 1, 10000000 do 
4     s = s + i 
5 end
6 print(string.format("elapsed time: %.2f\n", os.clock() - x))
7 
8 --输出结果为：
9 --elapsed time: 0.21