每天早晨叫醒你的不是鬧鐘,而是夢想

  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 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    

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