Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Dev Asset 开发资源大全 › 学术研究 Scholarly › tolua源码分析（三）C#访谒lua变量的机制实现 ...
返回列表 发新帖
查看: 167|回复: 0

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

[复制链接]
loeken
发表于 2024-7-15 18:37 | 显示全部楼层 |阅读模式
上一节我们讨论了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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-11-21 21:31 , Processed in 0.100936 second(s), 28 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表