lua实例教程_lua教程网

    "cmd": ["lua","$file"],  
    "file_regex":"^(...*?):([0-9]*):?([0-9]*)",  
    "selector":"source.lua"  

typedef struct Proto { 

CommonHeader;
// 固定参数的数量
lu_byte numparams;  /* number of fixed parameters */
// 是否有可变参数
lu_byte is_vararg;
// 该函数需要的栈大小
lu_byte maxstacksize;  /* number of registers needed by this function */
// upvalues数量
int sizeupvalues;  /* size of 'upvalues' */
// 常量数量
int sizek;  /* size of 'k' */
// 指令数量
int sizecode;
// 行信息数量
int sizelineinfo;
// 内嵌原型数量
int sizep;  /* size of 'p' */
// 本地变量的数量
int sizelocvars;
// 函数进入的行
int linedefined;  /* debug information  */
// 函数返回的行
int lastlinedefined;  /* debug information  */
// 常量数量
TValue *k;  /* constants used by the function */
// 指令数组
Instruction *code;  /* opcodes */
// 内嵌函数原型
struct Proto **p;  /* functions defined inside the function */
// 行信息
int *lineinfo;  /* map from opcodes to source lines (debug information) */
// 本地变量信息
LocVar *locvars;  /* information about local variables (debug information) */
// Upvalue信息
Upvaldesc *upvalues;  /* upvalue information */
// 使用该原型创建的最后闭包(缓存)
struct LClosure *cache;  /* last-created closure with this prototype */
// 源代码文件
TString  *source;  /* used for debug information */
// 灰对象列表，最后由g->gray串连起来
GCObject *gclist;
} Proto;

local function fun()
--ok true这些就是常量，Lua把所有的值都统一为TValue，常量也不例外，由TValue *k;保存。
local x = 1
local s = "ok"
local b = true
--而且常量只能是数字，布尔值，字符串，和nil这些基本类型，其他GC对象不可以是常量。由于常量不可变，所以直接保存在原型对象上就可以了。
end

//  本地变量的信息
typedef struct LocVar { 

// 本地变量名
TString *varname;   
int startpc;  /* first point where variable is active */
int endpc;    /* first point where variable is dead */
} LocVar;

function func()
local function sf1()
end
local function sf2()
end
end

typedef struct Upvaldesc { 

// 名字
TString *name;  /* upvalue name (for debug information) */
lu_byte instack;  /* whether it is in stack (register) */
lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
} Upvaldesc;

local x = 1
local function func()
local function innerfunc()
return x + 1
end
end

typedef union Closure { 

CClosure c;
LClosure l;
} Closure;

// nupvalues upvalue数量
// gclist为灰对象列表，最后由g->gray串连起来
#define ClosureHeader \
CommonHeader; lu_byte nupvalues; GCObject *gclist
// C闭包
typedef struct CClosure { 

ClosureHeader;
lua_CFunction f;    // C函数指针
TValue upvalue[1];  /* list of upvalues */    // update数组
} CClosure;
因为C函数相应简单，没有外层函数，所以upvalue其实就是保存在CClosure中的一个TValue数组。一个CClosure的实际大小通过sizeLclosure计算出，其内存布局如下：
| CClosure | TValue[0] | .. | TValue[nupvalues-1] |
因为CClosure的upvalue数组包含了一个元素，所以后面跟着的长度为nupvalues-1。通过luaF_newCclosure生成一个新的C闭包，实际应用中一般用lua_pushcclosure向栈顶压入一个新的C闭包，同时栈顶要装备好upvalue。函数实现如下：
// 生成一个C闭包并压入栈顶, n表示当前栈顶有多少个upvalue要与闭包关联
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { 

lua_lock(L);
if (n == 0) { 

// 没有upvalue，它是轻量级C函数
setfvalue(L->top, fn);
api_incr_top(L);
}
else { 

// 有upvalue，它是一个C闭包
CClosure *cl;
api_checknelems(L, n);
api_check(L, n <= MAXUPVAL, "upvalue index too large");
// 新建C闭包
cl = luaF_newCclosure(L, n);
cl->f = fn;
L->top -= n;
// 保存upvalue
while (n--) { 

setobj2n(L, &cl->upvalue[n], L->top + n);
/* does not need barrier because closure is white */
}
setclCvalue(L, L->top, cl);
api_incr_top(L);
luaC_checkGC(L);
}
lua_unlock(L);
}

// Lua闭包
typedef struct LClosure { 

ClosureHeader;
struct Proto *p;    // 函数原型
UpVal *upvals[1];  /* list of upvalues */   // upvalue列表
} LClosure;
通过sizeLclosure宏可获得Lua闭包的大小，其内存布局如下：
| LClosure | UpVal* | .. | UpVal* |
UpVal是对upvalue的间接引用，它的结构这样：
struct UpVal { 

// 引用的值，该值可能在栈上(open)，也可能是下面的TValue(close)
TValue *v;  /* points to stack or to its own value */
// 引用计数
lu_mem refcount;  /* reference counter */
union { 

// 当v指向栈上时，open有用，next指向下一个，挂在L->openupval上
struct { 
  /* (when open) */
UpVal *next;  /* linked list */
int touched;  /* mark to avoid cycles with dead threads */
} open;
// 当v指向自己时，这个值就在这里
TValue value;  /* the value (when closed) */
} u;
};

function add (x)
return function (y)
return x+y
end
end
local add2 = add(2)
print(add2(5))

// 查找栈上的uv。
UpVal *luaF_findupval (lua_State *L, StkId level) { 

UpVal **pp = &L->openupval;
UpVal *p;
UpVal *uv;
lua_assert(isintwups(L) || L->openupval == NULL);
// 查找open的uv, open的uv由L->openupval串起来一个链表
while (*pp != NULL && (p = *pp)->v >= level) { 

lua_assert(upisopen(p));
if (p->v == level)  /* found a corresponding upvalue? */
return p;  /* return it */
pp = &p->u.open.next;
}
/* not found: create a new upvalue */
// 如果未找到，创建一个新的加入链表
uv = luaM_new(L, UpVal);
uv->refcount = 0;
uv->u.open.next = *pp;  /* link it to list of open upvalues */
uv->u.open.touched = 1;
*pp = uv;
uv->v = level;  /* current value lives in the stack */
if (!isintwups(L)) { 
  /* thread not in list of threads with upvalues? */
L->twups = G(L)->twups;  /* link it to the list */
G(L)->twups = L;
}
return uv;
}

local x = 1
local y = 2
local z = 3
local function f1()
return x + 1
end
local function f2()
return x + 2
end

vmcase(OP_RETURN) { 

int b = GETARG_B(i);
if (cl->p->sizep > 0) luaF_close(L, base);
...
// 关闭栈中的upvalues，从level往后的upvalue，如果引用计数为0释放之，否则拷贝到UpVal自己身上
void luaF_close (lua_State *L, StkId level) { 

UpVal *uv;
while (L->openupval != NULL && (uv = L->openupval)->v >= level) { 

lua_assert(upisopen(uv));
L->openupval = uv->u.open.next;  /* remove from 'open' list */
if (uv->refcount == 0)  /* no references? */
luaM_free(L, uv);  /* free upvalue */
else { 

setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
uv->v = &uv->u.value;  /* now current value lives here */
luaC_upvalbarrier(L, uv);
}
}
}

function fn()
local i = 0
return function()     -- 注意这里是返回函数的地址，不是执行
i = i + 1
return i
end
end
c1 = fn()                      -- 接收函数返回的地址
print(c1())                    --> 1          --c1()才表示执行
--local i = 0的意思是重新创建一个新的变量，这里没有创建新的？
print(c1())                    --> 2
--再次调用fn，将创建一个新的局部变量i
c2 = fn()
print(c2())  -->1
print(c1())  -->3
print(c2())  -->2

function Closure()
local ival = 10           	--upvalue
function InnerFun1()     	--内嵌函数
print(ival)
end
function InnerFun2()
print("Before",ival)
ival = ival + 10
print("After", ival)
end
return InnerFun1, InnerFun2
end
--将函数赋值给变量，此时变量a绑定了函数InnerFun1,b绑定了函数InnerFun2
local a, b = Closure()
--调用a
a()
--调用b
b()

local testData = CS.LuaCallCSUtils.GetTestData()  --为一个字典
local iter = testData:GetEnumerator()
local list = { 
}
while iter:MoveNext() do
--数组或list直接获取Current
--local v = iter.Current
local k = iter.Current.Key
local v = iter.Current.Value
list[k] = v  --转为table
print(k, v)
end

local t = obj.array:ToTable()
for i = 1, #t do
print("table:"..t[i])
end

print("*****************Lua调用C#数组******************");
local Lesson3=CS.Lesson3();
--Lua使用C#数组相关知识
--长度 userdata
--C#怎么用 lua就怎么用
print(Lesson3.testArray.Length);
--访问元素
print(Lesson3.testArray[0]);
--遍历要注意 虽然lua中索引从1开始
--但是数组是C#那不得规则 所以 还是要按照C#来
--注意最大值 一定要减1 lua中是可以取到最后一个值得 nil
for i=0,Lesson3.testArray.Length-1 do
print(Lesson3.testArray[i]);
end
--Lua创建一个C#得数组 lua中表示数组和List可以用表
--但是创建C#中的数组，使用Array类中的静态方法即可
local Array2 = CS.System.Array.CreateInstance(typeof(CS.System.Int32),10);
print(Array2.Length);
print("修改前"..Array2[0]);
Array2[0]=100;
print("修改后"..Array2[0]);
print("*****************Lua调用C# List******************");
Lesson3.testList:Add(1);
Lesson3.testList:Add(2);
--长度
print(Lesson3.testList.Count);
--遍历
for i=1,Lesson3.testList.Count-1 do
print(Lesson3.testList[i])
end
print(Lesson3.testList);
--Lua创建一个List对象
--老版本
local list2 = CS.System.Collections.Generic["List`1[System.String]"](); print(list2); list2:Add("老版本创建List"); print(list2[0]); --新版本>V2.1.12 local List_StringTemp = CS.System.Collections.Generic.List(CS.System.String); local list3 = List_StringTemp(); list3:Add("新版本创建List"); print(list3[0]); print("*****************Lua调用C#数组、List、字典相关知识点******************");
Lesson3.testDic:Add(1,"123");
print(Lesson3.testDic[1]);
--遍历
for k,v in pairs(Lesson3.testDic) do
print(k,v)
end
--Lua中创建一个字典对象（新版本）
local Dic_String_Vectory3 = CS.System.Collections.Generic.Dictionary(CS.System.String,CS.UnityEngine.Vector3);
local dic2 = Dic_String_Vectory3();
dic2:Add("123",CS.UnityEngine.Vector3.right);
--lua中创建的字典，key是string时，通过中括号是获取不到值的
print(dic2["123"]);--nil
--使用TryGetValue 两个返回值 第一个返回值为是否获取到 第二个为获取到的值
print(dic2:TryGetValue("123"));
--如果要通过健来获取值 通过固定方法
print(dic2:get_Item("123"));
--修改也是固定
dic2:set_Item("123",nil);
print(dic2:get_Item("123"));