XLua 源码学习原理(一)

@https://zhuanlan.zhihu.com/p/68406928

 

刚刚初学XLua的源码,作为一个记录。

• XLua调用C#代码

在XLua中可以直接使用Lua代码来调用C#中的代码。

CS.UnityEngine.Debug.Log('hello world')

接下来就是记录XLua是如何实现其调用的.

• XLua中的CS变量的功能

CS是一个全局的Table，所以CS.UnityEngine可以当做是在一个名为CS的Table表中查询名为UnityEngine的值。获取其值是通过CS的元方法__index来实现的。其逻辑代码在创建LuaEnv时候调用下面的代码，进行CS表的初始化。

DoString(init_xlua, "Init");

下面代码是截取了部分的init_xlua代码。

这部分描述的是_index元方法的实现。元方法__index就是CS表中访问不存在的元素时候进行的操作。比如CS={'A='a','B'='b'}，那么在Lua中直接访问CS.A就会返回a。但是如果访问C就会因为原来表中不存在这个记录,那么而调用__index这个方法。

代码实现注释如下

inti_xlua.lua
local metatable = {}
local rawget = rawget
local setmetatable = setmetatable
local import_type = xlua.import_type
local import_generic_type = xlua.import_generic_type
local load_assembly = xlua.load_assembly
function metatable:__index(key)
    --查询自己Key为'.fqn'的值,并且不触发__index元方法
    local fqn = rawget(self,'.fqn')
    --拼接'.fqn'的值和本次调用的key
    fqn = ((fqn and fqn .. '.') or '') .. key
    --尝试查询CS类型.
    local obj = import_type(fqn)
    if obj == nil then
        -- It might be an assembly, so we load it too
     --如果为空,有可能这个字段还是类名的一部分,那么创建一个table记录,然后缓存返回.
        obj = { ['.fqn'] = fqn }
        setmetatable(obj, metatable)
    elseif obj == true then
        return rawget(self, key)
    end
    -- Cache this lookup
    rawset(self, key, obj)
    return obj
end
CS = CS or {}
setmetatable(CS, metatable)

• Lua中获取C#类对应的Table表

XLua中有两种方式来实现Lua调用CS中的方法,一种是反射来调用,一种是生成适配的代码。

在获取对应类的Lua表时候,使用的是import_type方法，也是在创建LuaEnv实例时候进行注册的代码如下。

ObjectTranslator.cs
public void OpenLib(RealStatePtr L) {
    if (0 != LuaAPI.xlua_getglobal(L, "xlua")){  throw new Exception("call xlua_getglobal fail!" + LuaAPI.lua_tostring(L, -1));} 
    LuaAPI.xlua_pushasciistring(L, "import_type");
    LuaAPI.lua_pushstdcallcfunction(L,importTypeFunction);
    LuaAPI.lua_rawset(L, -3); 
    ...
}

上面代码中的importTypeFunction是一个C#委托当Lua中是调用import_type时候Lua会调用对应的C方法(Lua调用CFunction的原理,请查找Lua手册)，最后会调用到对应的C#委托上来。

其中xlua全局table是在C中设置的代码如下:

XLua.c
LUA_API void luaopen_xlua(lua_State *L) {
   luaL_openlibs(L);
#if LUA_VERSION_NUM == 503
   luaL_newlib(L, xlualib);
   lua_setglobal(L, "xlua");
#else
   luaL_register(L, "xlua", xlualib);
    lua_pop(L, 1);
#endif
}

代码很简单，luaopen_xlua是一个c函数，属于xlua.dll在创建LuaEnv时候会调用。调用后会设置一个全局变量xlua，也就是ObjectTranslator类中获取的xlua变量。然后将键值对"import_type"=C#委托，压入xlua表中。这样就能在inti_xlua.lua中调用import_type方法了。

• C#中查找指定Type对应的Lua表的实现

在C#的ImportType方法中会尝试在缓存中获取对应的Type。如果Type为空，那么说明是第一次尝试引用对应的Type，代码就会判断是时使用生成适配代码还是反射模式，来生成对应的表。

代码如下

省略部分代码
ObjectTranslator.cs
public static int ImportType(RealStatePtr L)
{
    try
    {
        ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
        //需要查询的类名
        string className = LuaAPI.lua_tostring(L, 1);
        //查找C#对应的Type(此处还没去查找对应Lua的表)
        Type type = translator.FindType(className);
        if (type != null)
        {
            //这句查找Lua中Type对应的表
            if (translator.GetTypeId(L, type) >= 0)
            {
                LuaAPI.lua_pushboolean(L, true);
            }
            else
            {
                return LuaAPI.luaL_error(L, "can not load type " + type);
            }
        }
        else
        {
            LuaAPI.lua_pushnil(L);
        }
        return 1;
    }
}

internal int getTypeId(RealStatePtr L, Type type, out bool is_first, LOGLEVEL log_level = LOGLEVEL.WARN)
{
    int type_id;
    is_first = false;
    //查询是否缓存中有Type对应的Lua表,有就直接返回
    if (!typeIdMap.TryGetValue(type, out type_id)) // no reference
    {
        ...
        is_first = true;
        Type alias_type = null;
        aliasCfg.TryGetValue(type, out alias_type);
        LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
        if (LuaAPI.lua_isnil(L, -1)) //no meta yet, try to use reflection meta
        {
            LuaAPI.lua_pop(L, 1);
            //此处会去检查是使用反射还是生成适配代码的逻辑
            if (TryDelayWrapLoader(L, alias_type == null ? type : alias_type))
            {
                LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
            }
            else
            {
                throw new Exception("Fatal: can not load metatable of type:" + type);
            }
        }
        //循环依赖，自身依赖自己的class，比如有个自身类型的静态readonly对象。
        if (typeIdMap.TryGetValue(type, out type_id))
        {
            LuaAPI.lua_pop(L, 1);
        }
        else
        {
            ...
            LuaAPI.lua_pushvalue(L, -1);
            type_id = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
            LuaAPI.lua_pushnumber(L, type_id);
            LuaAPI.xlua_rawseti(L, -2, 1);
            LuaAPI.lua_pop(L, 1);
            ...
            //缓存type与其对应到lua中的表
            typeIdMap.Add(type, type_id);
        }
    }
    return type_id;
}

public bool TryDelayWrapLoader(RealStatePtr L, Type type)
{
            if (loaded_types.ContainsKey(type)) return true;
            loaded_types.Add(type, true);
            LuaAPI.luaL_newmetatable(L, type.FullName); //先建一个metatable，因为加载过程可能会需要用到
            LuaAPI.lua_pop(L, 1);
            Action loader;
            int top = LuaAPI.lua_gettop(L);
            //此处如果已经缓存,那么就是生成适配代码注册,
            //这边的逻辑也是为了用的时候才实例化对应的.
            //这个delayWrap是个字典,他的键值对在XLua_Gen_Initer_Register__类实例化时候自动填充
            if (delayWrap.TryGetValue(type, out loader))
            {
                delayWrap.Remove(type);
                //将类方法,字段,成员等加载上来
                loader(L);
            }
            //那么这里就是反射的逻辑了
            else
            {
                 ...
                //用反射将类方法,字段,成员等加载上来
                Utils.ReflectionWrap(L, type, privateAccessibleFlags.Contains(type));
                ...
            }
            ...
            ...
            return true;
}

在生成完Type对应的Lua表后还需要设置到Lua上去

下面的代码简单来说就是用前面代码生成的table表设置到CS.UnityEngine[Debug]中

//loader(L)和Utils.ReflectionWrap(L, type, privateAccessibleFlags.Contains(type));中都会调用此函数来设置CS.UnityEngine[Debug]
public static void SetCSTable(RealStatePtr L, Type type, int cls_table)
{
   int oldTop = LuaAPI.lua_gettop(L);
   cls_table = abs_idx(oldTop, cls_table);
   LuaAPI.xlua_pushasciistring(L, LuaEnv.CSHARP_NAMESPACE);
   LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
   List path = getPathOfType(type);
   for (int i = 0; i < path.Count - 1; ++i)
   {
      LuaAPI.xlua_pushasciistring(L, path[i]);
      if (0 != LuaAPI.xlua_pgettable(L, -2))
      {
         LuaAPI.lua_settop(L, oldTop);
         throw new Exception("SetCSTable for [" + type + "] error: " + LuaAPI.lua_tostring(L, -1));
      }
      if (LuaAPI.lua_isnil(L, -1))
      {
         LuaAPI.lua_pop(L, 1);
         LuaAPI.lua_createtable(L, 0, 0);
         LuaAPI.xlua_pushasciistring(L, path[i]);
         LuaAPI.lua_pushvalue(L, -2);
         LuaAPI.lua_rawset(L, -4);
      }
      else if (!LuaAPI.lua_istable(L, -1))
      {
         LuaAPI.lua_settop(L, oldTop);
         throw new Exception("SetCSTable for [" + type + "] error: ancestors is not a table!");
      }
      LuaAPI.lua_remove(L, -2);
   }
   LuaAPI.xlua_pushasciistring(L, path[path.Count - 1]);
   LuaAPI.lua_pushvalue(L, cls_table);
   LuaAPI.lua_rawset(L, -3);
   LuaAPI.lua_pop(L, 1);
   LuaAPI.xlua_pushasciistring(L, LuaEnv.CSHARP_NAMESPACE);
   LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
   ObjectTranslatorPool.Instance.Find(L).PushAny(L, type);
   LuaAPI.lua_pushvalue(L, cls_table);
   LuaAPI.lua_rawset(L, -3);
   LuaAPI.lua_pop(L, 1);
}

现在可以看到在调用到CS.UnityEngine.Debug时候，我们在Lua中已经获取到了这个类对应Lua Table了，那么接下来调用CS.UnityEngine.Debug.Log("hello world")，大提上与之前的获取Type类是一致的。不过要注意的是调用static的方法字段和对象的方法字段使用的是不同的table。这次文章都讨论的是静态方法的调用.

• 调用指定的C#方法

上面的已经提到XLua中有两种方式来实现Lua调用CS中的方法,一种是反射来调用,一种是生成适配的代码.

使用生成适配代码调用

在XLua中生成适配代码后会在Gen目录生成代码如下

UnityEngineDebugWrap.cs
public class UnityEngineDebugWrap
{
     public static void __Register(RealStatePtr L)
     {
          ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
          System.Type type = typeof(UnityEngine.Debug);
          //注册成员方法等
          Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
          Utils.EndObjectRegister(type, L, translator, null, null,null, null, null);
          //注册类方法等即Static
          Utils.BeginClassRegister(type, L, __CreateInstance, 17, 3, 1);
          ...
          //注册一个名为Log的回调
          Utils.CLS_IDX(L, Utils.CLS_IDX, "Log", _m_Log_xlua_st_);
          ...
          Utils.EndClassRegister(type, L, translator);
     }



    [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
    static int _m_Log_xlua_st_(RealStatePtr L)
    {
        //根据Log方法的参数数量来生成各种调用
       try {
          ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
          int gen_param_count = LuaAPI.lua_gettop(L);
          if(gen_param_count == 1&& translator.Assignable