tolua源码分析（三）C#访谒lua变量的机制实现

loeken

上一节我们讨论了C#是如何获取并调用到lua定义的函数，这一节我们更进一步，来看看如何让C#可以访谒lua定义的变量的。依旧从一个例子看起，此次是tolua自带的example04，主要代码如下：

1. new LuaResLoader();
2. LuaState lua = new LuaState();
3. lua.Start();
4. lua[”Objs2Spawn”] = 5;
6. string script =
7. @”
8.     print('Objs2Spawn is: '..Objs2Spawn)
9.     var2read = 42
10.     varTable = {1,2,3,4,5}
11.     varTable.default = 1
12.     varTable.map = {}
13.     varTable.map.name = 'map'
15.     meta = {name = 'meta'}
16.     setmetatable(varTable, meta)
18.     function TestFunc(strs)
19.         print('get func by variable')
20.     end
21. ”;
23. lua.DoString(script);
25. Debugger.Log(”Read var from lua: {0}”, lua[”var2read”]);
26. Debugger.Log(”Read table var from lua: {0}”, lua[”varTable.default”]);  
28. LuaFunction func = lua[”TestFunc”] as LuaFunction;
29. func.Call();
30. func.Dispose();
32. LuaTable table = lua.GetTable(”varTable”);
33. Debugger.Log(”Read varTable from lua, default: {0} name: {1}”, table[”default”], table[”map.name”]);
34. table[”map.name”] = ”new”;
35. Debugger.Log(”Modify varTable name: {0}”, table[”map.name”]);
37. table.AddTable(”newmap”);
38. LuaTable table1 = (LuaTable)table[”newmap”];
39. table1[”name”] = ”table1”;
40. Debugger.Log(”varTable.newmap name: {0}”, table1[”name”]);
41. table1.Dispose();
43. table1 = table.GetMetaTable();
45. if (table1 != null)
46. {
47.     Debugger.Log(”varTable metatable name: {0}”, table1[”name”]);
48. }
50. object[] list = table.ToArray();
52. for (int i = 0; i < list.Length; i++)
53. {
54.     Debugger.Log(”varTable[{0}], is {1}”, i, list[i]);
55. }
57. table.Dispose();                        
58. lua.CheckTop();
59. lua.Dispose();

复制代码

第1-3行对lua虚拟机进行了初始化，这块内容我们在第一节里已经详细展开过，这里就不再赘述。通过第4行，可以发现C#的LuaState类重载了下标访谒的操作符，使其扮演了lua中_G的角色，可以直接往lua层写入一个名为Objs2Spawn的变量，它的值为5。这一点在接下来执行的lua代码可以得到验证：



tolua源码分析（三） C#写入lua变量

下面就来看看下标访谒操作符的具体实现，这里用到的是set，那么就先忽略掉get相关的实现：

1. public object this[string fullPath]
2. {
3.     get
4.     {
5.         ...
6.     }
8.     set
9.     {
10.         int oldTop = LuaGetTop();
11.         int pos = fullPath.LastIndexOf(&#39;.&#39;);
13.         if (pos > 0)
14.         {
15.             string tableName = fullPath.Substring(0, pos);
16.             IntPtr p = LuaFindTable(LuaIndexes.LUA_GLOBALSINDEX, tableName);
18.             if (p == IntPtr.Zero)
19.             {
20.                 string name = fullPath.Substring(pos + 1);
21.                 LuaPushString(name);
22.                 PushVariant(value);
23.                 LuaSetTable(-3);
24.             }
25.             else
26.             {
27.                 LuaSetTop(oldTop);
28.                 int len = LuaDLL.tolua_strlen(p);
29.                 string str = LuaDLL.lua_ptrtostring(p, len);
30.                 throw new LuaException(string.Format(”{0} not a Lua table”, str));
31.             }
32.         }
33.         else
34.         {
35.             PushVariant(value);
36.             LuaSetGlobal(fullPath);                    
37.         }
39.         LuaSetTop(oldTop);
40.     }
41. }

复制代码

第10-11行就是判断是直接往lua的_G里赋值，还是往_G中的某个table里赋值。如果是往某个table中赋值，那么首先需要在lua层找到这个table，也就是这里的LuaFindTable，它的实现就是简单地调用lua的API函数luaL_findtable，值得一提的是如果查找的table不存在，则该函数会去创建对应name的table，这样大大简化了在C#层创建table的操作。如果函数执行成功，返回的是NULL。对应到第20-23行，此时lua栈顶是获取或创建的table，我们只需将key和value都压入栈，调用lua_settable设置即可。当然，如果是直接往_G里赋值，那直接调用lua_setglobal就行了。
这里我们稍微看一下PushVariant，它会调用到ToLua.Push上，这个方式就是按照C# object的类型，调用分歧的push将object压入lua栈中。由于我们的参数是5，直接当作lua的number类型措置：

1. public static void Push(IntPtr L, object obj)
2. {
3.     if (obj == null || obj.Equals(null))
4.     {
5.         LuaDLL.lua_pushnil(L);
6.         return;
7.     }
9.     Type t = obj.GetType();
11.     if (t.IsValueType)
12.     {
13.         if (TypeChecker.IsNullable(t))
14.         {
15.             Type[] ts = t.GetGenericArguments();
16.             t = ts[0];
17.         }
19.         if (t.IsPrimitive)
20.         {
21.             double d = LuaMisc.ToDouble(obj);
22.             LuaDLL.lua_pushnumber(L, d);
23.         }
25.         ...
26.     }
27.     else
28.     {
29.         ...
30.     }
31. }

复制代码

看完了set，我们回到例子中，第25-30行就用到了下标访谒操作符的get了，相关输出如下：



tolua源码分析（三） C#访谒lua变量

get的实现与set非常相似：

1. public object this[string fullPath]
2. {
3.     get
4.     {
5.         int oldTop = LuaGetTop();
6.         int pos = fullPath.LastIndexOf(&#39;.&#39;);
7.         object obj = null;
9.         if (pos > 0)
10.         {
11.             string tableName = fullPath.Substring(0, pos);
13.             if (PushLuaTable(tableName))
14.             {
15.                 string name = fullPath.Substring(pos + 1);
16.                 LuaPushString(name);
17.                 LuaRawGet(-2);
18.                 obj = ToVariant(-1);
19.             }   
20.             else
21.             {
22.                 LuaSetTop(oldTop);
23.                 return null;
24.             }
25.         }
26.         else
27.         {
28.             LuaGetGlobal(fullPath);
29.             obj = ToVariant(-1);
30.         }
32.         LuaSetTop(oldTop);
33.         return obj;
34.     }
36.     set
37.     {
38.         ...
39.     }
40. }

复制代码

一个区别就是这里使用的是PushLuaTable，该函数的感化就是将C#指定的table压入到lua栈中，但是如果该table不存在，并不会新建，而是会返回false。

1. bool PushLuaTable(string fullPath, bool checkMap = true)
2. {
3.     if (checkMap)
4.     {
5.         WeakReference weak = null;
7.         if (funcMap.TryGetValue(fullPath, out weak))
8.         {
9.             if (weak.IsAlive)
10.             {
11.                 LuaTable table = weak.Target as LuaTable;
12.                 CheckNull(table, ”{0} not a lua table”, fullPath);
13.                 Push(table);
14.                 return true;
15.             }
16.             else
17.             {
18.                 funcMap.Remove(fullPath);
19.             }
20.         }
21.     }
23.     if (!LuaDLL.tolua_pushluatable(L, fullPath))
24.     {               
25.         return false;
26.     }
28.     return true;
29. }

复制代码

这个函数和上一节里说的PushLuaFunction类似，会先去查找C#缓存，如果缓存中存在，就直接通过缓存中记录的reference，调用lua_getref拿到对应的table，从而避免了每次要去解析字符串，递归查找table的过程。拿到table之后，再将key压入栈，就能得到value了。
同样地，这里有一个ToVariant，会按照lua栈上object的类型，调用分歧的转换函数得到C#的object。例子中value的类型为number和function，对于number来说，直接调用lua_tonumber即可，而对于function来说，则稍微复杂一些：

1. public static object ToVarObject(IntPtr L, int stackPos)
2. {
3.     LuaTypes type = LuaDLL.lua_type(L, stackPos);
5.     switch (type)
6.     {
7.         case LuaTypes.LUA_TNUMBER:                    
8.             return LuaDLL.lua_tonumber(L, stackPos);
9.         case LuaTypes.LUA_TFUNCTION:
10.             return ToLuaFunction(L, stackPos);
11.         ...
12.         default:
13.             return null;
14.     }
15. }
16. public static LuaFunction ToLuaFunction(IntPtr L, int stackPos)
17. {
18.     LuaTypes type = LuaDLL.lua_type(L, stackPos);
20.     if (type == LuaTypes.LUA_TNIL)
21.     {
22.         return null;
23.     }
25.     stackPos = LuaDLL.abs_index(L, stackPos);
26.     LuaDLL.lua_pushvalue(L, stackPos);
27.     int reference = LuaDLL.toluaL_ref(L);
28.     return LuaStatic.GetFunction(L, reference);
29. }

复制代码

通过这种方式，从lua栈上获取lua函数时，需要在lua层和C#层都进行缓存，因为这个函数相当于同时被lua层和C#层引用了。上一节中我们提到，lua层缓存的方式走的是toluaL_ref，得到reference后返回给C#层。然后，C#层会测验考试先从缓存中查找reference，如果找到会增加其引用计数，找不到就将reference绑定到一个新的LuaFunction对象上：

1. LuaBaseRef TryGetLuaRef(int reference)
2. {            
3.     WeakReference weak = null;
5.     if (funcRefMap.TryGetValue(reference, out weak))
6.     {
7.         if (weak.IsAlive)
8.         {
9.             LuaBaseRef luaRef = (LuaBaseRef)weak.Target;
11.             if (luaRef.IsAlive)
12.             {
13.                 luaRef.AddRef();
14.                 return luaRef;
15.             }
16.         }               
18.         funcRefMap.Remove(reference);               
19.     }
21.     return null;
22. }
24. public LuaFunction GetFunction(int reference)
25. {
26.     LuaFunction func = TryGetLuaRef(reference) as LuaFunction;
28.     if (func == null)
29.     {               
30.         func = new LuaFunction(reference, this);
31.         funcRefMap.Add(reference, new WeakReference(func));
32.         if (LogGC) Debugger.Log(”Alloc LuaFunction name , id {0}”, reference);      
33.     }
35.     RemoveFromGCList(reference);
36.     return func;
37. }

复制代码

下面一种方式，lua.GetTable是将lua层的table取出，C#层进行缓存的方式。注意它跟前面调用的PushLuaTable的区别。PushLuaTable这个函数不会增加缓存，也不会增加引用，这是因为它对应的table只是个临时发生的变量；而这里的GetTable并分歧，因此获取的LuaTable会在lua层和C#层都进行一遍缓存，缓存的机制和前面类似，就不展开了。

1. public LuaTable GetTable(string fullPath, bool beLogMiss = true)
2. {
3.     WeakReference weak = null;
5.     if (funcMap.TryGetValue(fullPath, out weak))
6.     {
7.         if (weak.IsAlive)
8.         {
9.             LuaTable table = weak.Target as LuaTable;
10.             CheckNull(table, ”{0} not a lua table”, fullPath);
12.             if (table.IsAlive)
13.             {
14.                 table.AddRef();
15.                 RemoveFromGCList(table.GetReference());
16.                 return table;
17.             }
18.         }
20.         funcMap.Remove(fullPath);
21.     }
23.     if (PushLuaTable(fullPath, false))
24.     {
25.         int reference = ToLuaRef();
26.         LuaTable table = null;
28.         if (funcRefMap.TryGetValue(reference, out weak))
29.         {
30.             if (weak.IsAlive)
31.             {
32.                 table = weak.Target as LuaTable;
33.                 CheckNull(table, ”{0} not a lua table”, fullPath);
35.                 if (table.IsAlive)
36.                 {
37.                     funcMap.Add(fullPath, weak);
38.                     table.AddRef();
39.                     RemoveFromGCList(reference);
40.                     return table;
41.                 }
42.             }
44.             funcRefMap.Remove(reference);
45.         }
47.         table = new LuaTable(reference, this);
48.         table.name = fullPath;
49.         funcMap.Add(fullPath, new WeakReference(table));
50.         funcRefMap.Add(reference, new WeakReference(table));
51.         if (LogGC) Debugger.Log(”Alloc LuaTable name {0}, id {1}”, fullPath, reference);     
52.         RemoveFromGCList(reference);
53.         return table;
54.     }
56.     if (beLogMiss)
57.     {
58.         Debugger.LogWarning(”Lua table {0} not exists”, fullPath);
59.     }
61.     return null;
62. }

复制代码

C#层的LuaTable，具有和lua层的table类似的操作，第33-35行展示了操作下标访谒，对lua层的table读取和写入：



tolua源码分析（三） C#的LuaTable

LuaTable类的下标访谒操作符key的类型只撑持string和int，不外对于绝大部门情况已经完全够用。string类型和int类型的实现大同小异，这里以例子顶用到的string为例，来看看具体的实现：

1. public object this[string key]
2. {
3.     get
4.     {
5.         int top = luaState.LuaGetTop();
7.         try
8.         {
9.             luaState.Push(this);
10.             luaState.Push(key);
11.             luaState.LuaGetTable(top + 1);
12.             object ret = luaState.ToVariant(top + 2);
13.             luaState.LuaSetTop(top);
14.             return ret;
15.         }
16.         catch (Exception e)
17.         {
18.             luaState.LuaSetTop(top);
19.             throw e;                    
20.         }               
21.     }
23.     set
24.     {
25.         int top = luaState.LuaGetTop();
27.         try
28.         {
29.             luaState.Push(this);
30.             luaState.Push(key);
31.             luaState.PushVariant(value);
32.             luaState.LuaSetTable(top + 1);
33.             luaState.LuaSetTop(top);
34.         }
35.         catch (Exception e)
36.         {
37.             luaState.LuaSetTop(top);
38.             throw e;
39.         }
40.     }
41. }

复制代码

这个实现就是在C#层模拟了一遍对lua栈的操作，值得一提的是对LuaTable进行push，实际上等价于将lua层对应的table，push到lua栈顶，而不是真的push了一个C#对象到lua栈顶。因此，这里需要把LuaTable记录的reference取出，然后调用lua_getref到lua层取出真正的table：

1. public void Push(LuaBaseRef lbr)
2. {
3.     if (lbr == null)
4.     {               
5.         LuaPushNil();
6.     }
7.     else
8.     {
9.         LuaGetRef(lbr.GetReference());
10.     }
11. }

复制代码

接着看例子的第37-41行，它展示了如安在C#层新建一个table。



tolua源码分析（三） C#层新建table

重点就在这个AddTable上，这个函数做的事情，其实也就是在C#层，模拟在lua栈上创建table的操作：

1. public void AddTable(string name)
2. {
3.     int oldTop = luaState.LuaGetTop();
5.     try
6.     {
7.         luaState.Push(this);
8.         luaState.Push(name);
9.         luaState.LuaCreateTable();               
10.         luaState.LuaRawSet(oldTop + 1);
11.         luaState.LuaSetTop(oldTop);
12.     }
13.     catch (Exception e)
14.     {
15.         luaState.LuaSetTop(oldTop);
16.         throw e;
17.     }
18. }

复制代码

由于我们还需要把lua层新建的table转换成C#对应的LuaTable返回，因此这里还会用到之前提到的ToVarObject函数，在lua层生成reference，然后返回给C#层，查找对应的C#缓存，如果不存在就新建一个LuaTable对象。

1. public static object ToVarObject(IntPtr L, int stackPos)
2. {
3.     LuaTypes type = LuaDLL.lua_type(L, stackPos);
5.     switch (type)
6.     {
7.         case LuaTypes.LUA_TTABLE:
8.             return ToVarTable(L, stackPos);
10.         ...
12.         default:
13.             return null;
14.     }
15. }

复制代码

接着看例子，下一个是在C#层去访谒lua层设置的metatable。实现方式与前面所说的类似，还是C#层直接调用lua的API，模拟栈操作。



tolua源码分析（三） C#层访谒metatable

例子的最后，演示了LuaTable.ToArray方式。通过这个方式，可以便利地将lua层的table转换为C#的数组。



tolua源码分析（三） LuaTable.ToArray

类似地，该方式的实现，就是在C#层，调用lua的lua_objlen函数，得到当前table的长度，然后在C#层对该table进行遍历，把成果塞到C#的数组中：

1. public object[] ToArray()
2. {
3.     int oldTop = luaState.LuaGetTop();
5.     try
6.     {
7.         luaState.Push(this);
8.         int len = luaState.LuaObjLen(-1);
9.         List<object> list = new List<object>(len + 1);
10.         int index = 1;
11.         object obj = null;
13.         while(index <= len)
14.         {
15.             luaState.LuaRawGetI(-1, index++);
16.             obj = luaState.ToVariant(-1);
17.             luaState.LuaPop(1);
18.             list.Add(obj);
19.         }               
21.         luaState.LuaSetTop(oldTop);
22.         return list.ToArray();
23.     }
24.     catch (Exception e)
25.     {
26.         luaState.LuaSetTop(oldTop);
27.         throw e;
28.     }
29. }

复制代码

下一节我们将揭开lua层如何调用C#方式的面纱，先从C#的数组开始。
如果你感觉我的文章有辅佐，欢迎存眷我的微信公众号我是真的想做游戏啊

Reference
[1] Learning Lua: 5 - Document for luaL_findtable() function