chuanzhanServer/server_battle/ServerLib/LuaState.cs

// The MIT License (MIT)

// Copyright 2015 Siney/Pangweiwei siney@yeah.net
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//#define LUA_DEBUG



namespace SLua
{
    using System;
    using System.Collections.Generic;
    using System.Collections;
    using System.Text;
#if LUA_DEBUG
    using System.Security.Cryptography;
#endif
#if !SLUA_STANDALONE
    using UnityEngine;
#else
    using System.IO;
#endif

    abstract public class LuaVar : IDisposable
    {
        protected LuaState state = null;
        protected int valueref = 0;



        public IntPtr L
        {
            get
            {
                return state.L;
            }
        }

        public int Ref
        {
            get
            {
                return valueref;
            }
        }

        public LuaVar()
        {
            state = null;
        }

        public LuaVar(LuaState l, int r)
        {
            state = l;
            valueref = r;
        }

        public LuaVar(IntPtr l, int r)
        {
            state = LuaState.get(l);
            valueref = r;
        }

        ~LuaVar()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        static void unref(IntPtr l, int r)
        {
            LuaDLL.lua_unref(l, r);
        }

        public virtual void Dispose(bool disposeManagedResources)
        {
            if (valueref != 0)
            {
                state.gcRef(unref, valueref);
                valueref = 0;
            }
        }

        public void push(IntPtr l)
        {
            LuaDLL.lua_getref(l, valueref);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is LuaVar)
            {
                return this == (LuaVar)obj;
            }
            return false;
        }

        public static bool operator ==(LuaVar x, LuaVar y)
        {
            if ((object)x == null || (object)y == null)
                return (object)x == (object)y;

            return Equals(x, y) == 1;
        }

        public static bool operator !=(LuaVar x, LuaVar y)
        {
            if ((object)x == null || (object)y == null)
                return (object)x != (object)y;

            return Equals(x, y) != 1;
        }

        static int Equals(LuaVar x, LuaVar y)
        {
            x.push(x.L);
            y.push(x.L);
            int ok = LuaDLL.lua_equal(x.L, -1, -2);
            LuaDLL.lua_pop(x.L, 2);
            return ok;
        }
    }

    public class LuaThread : LuaVar
    {
        public LuaThread(IntPtr l, int r)
            : base(l, r)
        { }
    }

    public class LuaDelegate : LuaFunction
    {
        public object d;

        public LuaDelegate(IntPtr l, int r)
            : base(l, r)
        {
        }

        static void unref(IntPtr l, int r)
        {
            LuaObject.removeDelgate(l, r);
            LuaDLL.lua_unref(l, r);
        }

        public override void Dispose(bool disposeManagedResources)
        {
            if (valueref != 0)
            {
                state.gcRef(unref, valueref);
                valueref = 0;
            }

        }
    }

    public class LuaFunction : LuaVar
    {
        public LuaFunction(LuaState l, int r)
            : base(l, r)
        {
        }

        public LuaFunction(IntPtr l, int r)
            : base(l, r)
        {
        }

        public bool pcall(int nArgs, int errfunc)
        {

            if (!state.isMainThread())
            {
                Logger.LogError("Can't call lua function in bg thread");
                return false;
            }

            LuaDLL.lua_getref(L, valueref);

            if (!LuaDLL.lua_isfunction(L, -1))
            {
                LuaDLL.lua_pop(L, 1);
                throw new Exception("Call invalid function.");
            }

            LuaDLL.lua_insert(L, -nArgs - 1);
            if (LuaDLL.lua_pcall(L, nArgs, -1, errfunc) != 0)
            {
                LuaDLL.lua_pop(L, 1);
                return false;
            }
            return true;
        }

        bool innerCall(int nArgs, int errfunc)
        {
            bool ret = pcall(nArgs, errfunc);
            LuaDLL.lua_remove(L, errfunc);
            return ret;
        }


        public object call()
        {
            int error = LuaObject.pushTry(state.L);
            if (innerCall(0, error))
            {
                return state.topObjects(error - 1);
            }
            return null;
        }

        public object call(params object[] args)
        {
            int error = LuaObject.pushTry(state.L);

            for (int n = 0; args != null && n < args.Length; n++)
            {
                LuaObject.pushVar(L, args[n]);
            }

            if (innerCall(args != null ? args.Length : 0, error))
            {
                return state.topObjects(error - 1);
            }

            return null;
        }

        public bool TryCall(out object ret, params object[] args)
        {
            int error = LuaObject.pushTry(state.L);

            for (int n = 0; args != null && n < args.Length; n++)
            {
                LuaObject.pushVar(L, args[n]);
            }

            if (innerCall(args != null ? args.Length : 0, error))
            {
                ret = state.topObjects(error - 1);
                return true;
            }
            ret = null;
            return false;
        }

        public object call(LuaTable self, params object[] args)
        {
            int error = LuaObject.pushTry(state.L);

            LuaObject.pushVar(L, self);

            for (int n = 0; args != null && n < args.Length; n++)
            {
                LuaObject.pushVar(L, args[n]);
            }

            if (innerCall((args != null ? args.Length : 0) + 1, error))
            {
                return state.topObjects(error - 1);
            }

            return null;
        }

        public T cast<T>() where T : class
        {
            return LuaObject.delegateCast(this, typeof(T)) as T;
        }
    }

    public class LuaTable : LuaVar, IEnumerable<LuaTable.TablePair>
    {


        public struct TablePair
        {
            public object key;
            public object value;
        }
        public LuaTable(IntPtr l, int r)
            : base(l, r)
        {
        }

        public LuaTable(LuaState l, int r)
            : base(l, r)
        {
        }

        public LuaTable(LuaState state)
            : base(state, 0)
        {

            LuaDLL.lua_newtable(L);
            valueref = LuaDLL.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
        }

        // if wholekey is true, don't split key by '.'
        public object get(string key, bool wholekey = false, bool rawget = false)
        {
            return state.getObject(valueref, key, wholekey, rawget);
        }

        // if wholekey is true, don't split key by '.'
        public void set(string key, object v, bool wholekey = false, bool rawset = false)
        {
            state.setObject(valueref, key, v, wholekey, rawset);
        }

        public object this[string key]
        {
            get
            {
                return state.getObject(valueref, key);
            }

            set
            {
                state.setObject(valueref, key, value);
            }
        }

        public object this[int index]
        {
            get
            {
                return state.getObject(valueref, index);
            }

            set
            {
                state.setObject(valueref, index, value);
            }
        }

        public object invoke(string func, params object[] args)
        {
            using (LuaFunction f = (LuaFunction)this[func])
            {
                if (f != null)
                {
                    return f.call(args);
                }
            }
            throw new Exception(string.Format("Can't find {0} function", func));
        }

        public int length()
        {
            int n = LuaDLL.lua_gettop(L);
            push(L);
            int l = LuaDLL.lua_rawlen(L, -1);
            LuaDLL.lua_settop(L, n);
            return l;
        }

        public bool IsEmpty
        {
            get
            {
                int top = LuaDLL.lua_gettop(L);
                LuaDLL.lua_getref(L, this.Ref);
                LuaDLL.lua_pushnil(L);
                bool ret = LuaDLL.lua_next(L, -2) > 0;
                LuaDLL.lua_settop(L, top);
                return !ret;
            }
        }

        public int GetInt(string key)
        {
            var rtn = this[key].ToString();
            int r = 0;
            int.TryParse(rtn, out r);
            return r;
        }

        public string GetString(string key)
        {
            return (this[key].ToString());
        }

        public class Enumerator : IEnumerator<TablePair>, IDisposable
        {
            LuaTable t;
            int indext = -1;
            TablePair current = new TablePair();
            int iterPhase = 0;

            public Enumerator(LuaTable table)
            {
                t = table;
                Reset();
            }

            public bool MoveNext()
            {
                if (indext < 0)
                    return false;

                if (iterPhase == 0)
                {
                    LuaDLL.lua_pushnil(t.L);
                    iterPhase = 1;
                }
                else
                    LuaDLL.lua_pop(t.L, 1);

                //var ty = LuaDLL.lua_type(t.L, -1);
                bool ret = LuaDLL.lua_next(t.L, indext) > 0;
                if (!ret) iterPhase = 2;

                return ret;
            }

            public void Reset()
            {
                LuaDLL.lua_getref(t.L, t.Ref);
                indext = LuaDLL.lua_gettop(t.L);
            }

            public void Dispose()
            {
                if (iterPhase == 1)
                    LuaDLL.lua_pop(t.L, 2);

                LuaDLL.lua_remove(t.L, indext);
            }

            public TablePair Current
            {
                get
                {
                    current.key = LuaObject.checkVar(t.L, -2);
                    current.value = LuaObject.checkVar(t.L, -1);
                    return current;
                }
            }

            object IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }
        }

        public IEnumerator<TablePair> GetEnumerator()
        {
            return new LuaTable.Enumerator(this);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }





    public class LuaState : IDisposable
    {
        IntPtr l_;
        int mainThread = 0;
        internal WeakDictionary<int, LuaDelegate> delgateMap = new WeakDictionary<int, LuaDelegate>();
#if LUA_DEBUG
        static Dictionary<string, string> debugStringMap = new Dictionary<string, string>();
#endif
        public int cachedDelegateCount
        {
            get
            {
                return this.delgateMap.AliveCount;
            }
        }

        public IntPtr L
        {
            get
            {

                if (!isMainThread())
                {
                    Logger.LogError("Can't access lua in bg thread");
                    throw new Exception("Can't access lua in bg thread");
                }

                if (l_ == IntPtr.Zero)
                {
                    Logger.LogError("LuaState had been destroyed, can't used yet");
                    throw new Exception("LuaState had been destroyed, can't used yet");
                }

                return l_;
            }
            set
            {
                l_ = value;
            }
        }

        public IntPtr handle
        {
            get
            {
                return L;
            }
        }

        public int Top { get { return LuaDLL.lua_gettop(L); } }

        public delegate byte[] LoaderDelegate(string fn, ref string absoluteFn);
        public delegate void OutputDelegate(string msg);
        public delegate void PushVarDelegate(IntPtr l, object o);

        public LoaderDelegate loaderDelegate;
        public OutputDelegate logDelegate;
        public OutputDelegate errorDelegate;
        public OutputDelegate warnDelegate;


        public delegate void UnRefAction(IntPtr l, int r);
        struct UnrefPair
        {
            public UnRefAction act;
            public int r;
        }
        Queue<UnrefPair> refQueue;
        public int PCallCSFunctionRef = 0;
        Dictionary<Type, PushVarDelegate> typePushMap = new Dictionary<Type, PushVarDelegate>();

        public static Dictionary<IntPtr, LuaState> statemap = new Dictionary<IntPtr, LuaState>();
        static IntPtr oldptr = IntPtr.Zero;
        static LuaState oldstate = null;
        static public LuaCSFunction errorFunc = new LuaCSFunction(errorReport);
        int errorRef = 0;

        internal LuaFunction newindex_func;
        internal LuaFunction index_func;
        const string DelgateTable = "__LuaDelegate";
        bool openedSluaLib = false;

        LuaFunction dumpstack;

        public bool isMainThread()
        {
            return System.Threading.Thread.CurrentThread.ManagedThreadId == mainThread;
        }

#if !SLUA_STANDALONE
        internal LuaSvrGameObject lgo;
#endif

        static public LuaState get(IntPtr l)
        {
            if (l == oldptr)
                return oldstate;

            LuaState ls;
            if (statemap.TryGetValue(l, out ls))
            {
                oldptr = l;
                oldstate = ls;
                return ls;
            }

            LuaDLL.lua_getglobal(l, "__main_state");
            if (LuaDLL.lua_isnil(l, -1))
            {
                LuaDLL.lua_pop(l, 1);
                return null;
            }

            IntPtr nl = LuaDLL.lua_touserdata(l, -1);
            LuaDLL.lua_pop(l, 1);
            if (nl != l)
                return get(nl);
            return null;
        }



        public void openSluaLib()
        {

            LuaArray.init(L);
            LuaVarObject.init(L);

            LuaDLL.lua_newtable(L);
            LuaDLL.lua_setglobal(L, DelgateTable);

#if !SLUA_STANDALONE
            LuaTimer.reg(L);
            LuaCoroutine.reg(L, lgo);
#endif
            Lua_SLua_ByteArray.reg(L);
            Helper.reg(L);

            openedSluaLib = true;
        }

        public void openExtLib()
        {
            LuaDLL.luaS_openextlibs(L);
            LuaSocketMini.reg(L);
        }

        public void bindUnity()
        {
            if (!openedSluaLib)
                openSluaLib();

            LuaSvr.doBind(L);
            LuaValueType.reg(L);
        }

        public IEnumerator bindUnity(Action<int> _tick, Action complete)
        {
            if (!openedSluaLib)
                openSluaLib();

            yield return LuaSvr.doBind(L, _tick, complete);
            LuaValueType.reg(L);
        }

        static public LuaState main
        {
            get
            {
                return LuaSvr.mainState;
            }
        }

        public string Name
        {
            get;
            set;
        }

        public LuaState()
        {
            if (mainThread == 0)
                mainThread = System.Threading.Thread.CurrentThread.ManagedThreadId;

            L = LuaDLL.luaL_newstate();
            statemap[L] = this;



            refQueue = new Queue<UnrefPair>();
            ObjectCache.make(L);

            LuaDLL.lua_atpanic(L, panicCallback);

            LuaDLL.luaL_openlibs(L);

            string PCallCSFunction = @"
local assert = assert
local function check(ok,...)
	assert(ok, ...)
	return ...
end
return function(cs_func)
	return function(...)
		return check(cs_func(...))
	end
end
";

            LuaDLL.lua_dostring(L, PCallCSFunction);
            PCallCSFunctionRef = LuaDLL.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

            string newindexfun = @"

local getmetatable=getmetatable
local rawget=rawget
local error=error
local type=type
local function newindex(ud,k,v)
    local t=getmetatable(ud)
    repeat
        local h=rawget(t,k)
        if h then
            if h[2] then
                h[2](ud,v)
                return
            else
                error('property '..k..' is read only')
            end
        end
        t=rawget(t,'__parent')
    until t==nil
    error('can not find '..k)
end

return newindex
";

            string indexfun = @"
local type=type
local error=error
local rawget=rawget
local getmetatable=getmetatable
local function index(ud,k)
    local t=getmetatable(ud)
    repeat
        local fun=rawget(t,k)
        local tp=type(fun)
        if tp=='function' then
            return fun
        elseif tp=='table' then
            local f=fun[1]
            if f then
                return f(ud)
            else
                error('property '..k..' is write only')
            end
        end
        t = rawget(t,'__parent')
    until t==nil
    error('Can not find '..k)
end

return index
";

            newindex_func = (LuaFunction)doString(newindexfun);
            index_func = (LuaFunction)doString(indexfun);

            setupPushVar();

            pcall(L, init);

            createGameObject();
        }

        void createGameObject()
        {
#if !SLUA_STANDALONE
            if (lgo == null
#if UNITY_EDITOR
                && UnityEditor.EditorApplication.isPlaying
#endif
            )
            {
                GameObject go = new GameObject("LuaSvrProxy");
                lgo = go.AddComponent<LuaSvrGameObject>();
                GameObject.DontDestroyOnLoad(go);
                lgo.onUpdate = this.tick;
                lgo.state = this;
            }
#endif
        }

        void destroyGameObject()
        {
#if !SLUA_STANDALONE
#if UNITY_EDITOR
            if (UnityEditor.EditorApplication.isPlaying)
#endif
            {
                if (lgo != null)
                {
                    GameObject go = lgo.gameObject;
                    GameObject.Destroy(lgo);
                    GameObject.Destroy(go);
                }
            }
#endif
        }

        virtual protected void tick()
        {
            checkRef();
        }


        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int init(IntPtr L)
        {
            LuaDLL.lua_pushlightuserdata(L, L);
            LuaDLL.lua_setglobal(L, "__main_state");

            LuaDLL.lua_pushcfunction(L, print);
            LuaDLL.lua_setglobal(L, "print");

            LuaDLL.lua_pushcfunction(L, printerror);
            LuaDLL.lua_setglobal(L, "printerror");

            LuaDLL.lua_pushcfunction(L, warn);
            LuaDLL.lua_setglobal(L, "warn");

#if LUA_DEBUG
            LuaDLL.lua_pushcfunction(L, getStringFromMD5); 
            LuaDLL.lua_setglobal(L, "getStringFromMD5");
#endif

            pushcsfunction(L, import);
            LuaDLL.lua_setglobal(L, "import");


            string resumefunc = @"
local resume = coroutine.resume
local function check(co, ok, err, ...)
	if not ok then UnityEngine.Debug.LogError(debug.traceback(co,err)) end
	return ok, err, ...
end
coroutine.resume=function(co,...)
	return check(co, resume(co,...))
end
";

            // overload resume function for report error
            var state = LuaState.get(L);
            state.doString(resumefunc);

            // https://github.com/pkulchenko/MobDebug/blob/master/src/mobdebug.lua#L290
            // Dump only 3 stacks, or it will return null (I don't know why)
            string dumpstackfunc = @"
local dumpstack=function()
  function vars(f)
    local dump = """"
    local func = debug.getinfo(f, ""f"").func
    local i = 1
    local locals = {}
    -- get locals
    while true do
      local name, value = debug.getlocal(f, i)
      if not name then break end
      if string.sub(name, 1, 1) ~= '(' then 
        dump = dump ..  ""    "" .. name .. ""="" .. tostring(value) .. ""\n"" 
      end
      i = i + 1
    end
    -- get varargs (these use negative indices)
    i = 1
    while true do
      local name, value = debug.getlocal(f, -i)
      -- `not name` should be enough, but LuaJIT 2.0.0 incorrectly reports `(*temporary)` names here
      if not name or name ~= ""(*vararg)"" then break end
      dump = dump ..  ""    "" .. name .. ""="" .. tostring(value) .. ""\n""
      i = i + 1
    end
    -- get upvalues
    i = 1
    while func do -- check for func as it may be nil for tail calls
      local name, value = debug.getupvalue(func, i)
      if not name then break end
      dump = dump ..  ""    "" .. name .. ""="" .. tostring(value) .. ""\n""
      i = i + 1
    end
    return dump
  end
  local dump = """"
  for i = 3, 100 do
    local source = debug.getinfo(i, ""S"")
    if not source then break end
    dump = dump .. ""- stack"" .. tostring(i-2) .. ""\n""
    dump = dump .. vars(i+1)
    if source.what == 'main' then break end
  end
  return dump
end
return dumpstack
";

            state.dumpstack = state.doString(dumpstackfunc) as LuaFunction;

#if UNITY_ANDROID
            // fix android performance drop with JIT on according to luajit mailist post
            state.doString("if jit then require('jit.opt').start('sizemcode=256','maxmcode=256') for i=1,1000 do end end");
#endif

            pushcsfunction(L, dofile);
            LuaDLL.lua_setglobal(L, "dofile");

            pushcsfunction(L, loadfile);
            LuaDLL.lua_setglobal(L, "loadfile");

            pushcsfunction(L, loadfile_env);
            LuaDLL.lua_setglobal(L, "loadfile_env");

            pushcsfunction(L, loader);
            int loaderFunc = LuaDLL.lua_gettop(L);

            LuaDLL.lua_getglobal(L, "package");
#if LUA_5_3
            LuaDLL.lua_getfield(L, -1, "searchers");
#else
            LuaDLL.lua_getfield(L, -1, "loaders");
#endif
            int loaderTable = LuaDLL.lua_gettop(L);

            // Shift table elements right
            for (int e = LuaDLL.lua_rawlen(L, loaderTable) + 1; e > 2; e--)
            {
                LuaDLL.lua_rawgeti(L, loaderTable, e - 1);
                LuaDLL.lua_rawseti(L, loaderTable, e);
            }
            LuaDLL.lua_pushvalue(L, loaderFunc);
            LuaDLL.lua_rawseti(L, loaderTable, 2);
            LuaDLL.lua_settop(L, 0);
            return 0;
        }

        void Close()
        {
            destroyGameObject();
            LuaTimer.DeleteAll(L);

            if (L != IntPtr.Zero)
            {
                Logger.Log("Finalizing Lua State.");
                // be careful, if you close lua vm, make sure you don't use lua state again,
                // comment this line as default for avoid unexpected crash.
                LuaDLL.lua_close(L);

                ObjectCache.del(L);
                ObjectCache.clear();

                statemap.Remove(L);

                oldptr = IntPtr.Zero;
                oldstate = null;
                L = IntPtr.Zero;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            System.GC.Collect();
            System.GC.WaitForPendingFinalizers();
        }

        public virtual void Dispose(bool dispose)
        {
            if (dispose)
            {
                Close();
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        public static int errorReport(IntPtr L)
        {
            s.Length = 0;
            LuaDLL.lua_getglobal(L, "debug");
            LuaDLL.lua_getfield(L, -1, "traceback");
            LuaDLL.lua_pushvalue(L, 1);
            LuaDLL.lua_pushnumber(L, 2);
            LuaDLL.lua_call(L, 2, 1);
            LuaDLL.lua_remove(L, -2);
            s.Append(LuaDLL.lua_tostring(L, -1));
            LuaDLL.lua_pop(L, 1);

            LuaState state = LuaState.get(L);
            state.dumpstack.push(L);
            LuaDLL.lua_call(L, 0, 1);
            s.Append("\n");
            s.Append(LuaDLL.lua_tostring(L, -1));
            LuaDLL.lua_pop(L, 1);

            string str = s.ToString();
            Logger.LogError(str, true);
            if (state.errorDelegate != null)
            {
                state.errorDelegate(str);
            }

            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int import(IntPtr l)
        {
            try
            {
                LuaDLL.luaL_checktype(l, 1, LuaTypes.LUA_TSTRING);
                string str = LuaDLL.lua_tostring(l, 1);

                string[] ns = str.Split('.');

                LuaDLL.lua_pushglobaltable(l);

                for (int n = 0; n < ns.Length; n++)
                {
                    LuaDLL.lua_getfield(l, -1, ns[n]);
                    if (!LuaDLL.lua_istable(l, -1))
                    {
                        return LuaObject.error(l, "expect {0} is type table", ns);
                    }
                    LuaDLL.lua_remove(l, -2);
                }

                LuaDLL.lua_pushnil(l);
                while (LuaDLL.lua_next(l, -2) != 0)
                {
                    string key = LuaDLL.lua_tostring(l, -2);
                    LuaDLL.lua_getglobal(l, key);
                    if (!LuaDLL.lua_isnil(l, -1))
                    {
                        LuaDLL.lua_pop(l, 1);
                        return LuaObject.error(l, "{0} had existed, import can't overload it.", key);
                    }
                    LuaDLL.lua_pop(l, 1);
                    LuaDLL.lua_setglobal(l, key);
                }

                LuaDLL.lua_pop(l, 1);

                LuaObject.pushValue(l, true);
                return 1;
            }
            catch (Exception e)
            {
                return LuaObject.error(l, e);
            }
        }

        internal static void pcall(IntPtr l, LuaCSFunction f)
        {
            int err = LuaObject.pushTry(l);
            LuaDLL.lua_pushcfunction(l, f);
            if (LuaDLL.lua_pcall(l, 0, 0, err) != 0)
            {
                LuaDLL.lua_pop(l, 1);
            }
            LuaDLL.lua_remove(l, err);
        }



        static public bool printTrace = true;
        private static StringBuilder s = new StringBuilder();

        static string stackString(IntPtr L, int n)
        {
            s.Length = 0;

            LuaDLL.lua_getglobal(L, "tostring");

            for (int i = 1; i <= n; i++)
            {
                if (i > 1)
                {
                    s.Append("    ");
                }

                LuaDLL.lua_pushvalue(L, -1);
                LuaDLL.lua_pushvalue(L, i);

                LuaDLL.lua_call(L, 1, 1);
                s.Append(LuaDLL.lua_tostring(L, -1));
                LuaDLL.lua_pop(L, 1);
            }

            if (printTrace
#if UNITY_EDITOR
                 && SLuaSetting.Instance.PrintTrace
#endif
               )
            {
                LuaDLL.lua_getglobal(L, "debug");
                LuaDLL.lua_getfield(L, -1, "traceback");
                LuaDLL.lua_call(L, 0, 1);
                s.Append("\n");
                s.Append(LuaDLL.lua_tostring(L, -1));
            }

            return s.ToString();
        }


        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int print(IntPtr L)
        {
#if SOV_RELEASE
            return 0;
#endif

            int n = LuaDLL.lua_gettop(L);
            string str = stackString(L, n);
            Logger.Log(str, true);

            LuaState state = LuaState.get(L);
            if (state.logDelegate != null)
            {
                state.logDelegate(s.ToString());
            }

            LuaDLL.lua_settop(L, n);

            return 0;
        }

        // copy from print()
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int printerror(IntPtr L)
        {
            int n = LuaDLL.lua_gettop(L);
            string str = stackString(L, n);
            Logger.LogError(str, true);

            LuaState state = LuaState.get(L);
            if (state.errorDelegate != null)
            {
                state.errorDelegate(s.ToString());
            }

            LuaDLL.lua_settop(L, n);

            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int warn(IntPtr L)
        {
            int n = LuaDLL.lua_gettop(L);
            string str = stackString(L, n);
            Logger.LogWarning(str);
            LuaState state = LuaState.get(L);
            if (state.warnDelegate != null)
            {
                state.warnDelegate(s.ToString());
            }

            LuaDLL.lua_settop(L, n);
            return 0;
        }



        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int loadfile(IntPtr L)
        {
            loader(L);

            if (LuaDLL.lua_isnil(L, -1))
            {
                string fileName = LuaDLL.lua_tostring(L, 1);
                return LuaObject.error(L, "Can't find {0}", fileName);
            }
            return 2;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int loadfile_env(IntPtr L)
        {
            LuaState state = LuaState.get(L);
            string fileName = LuaDLL.lua_tostring(L, 1);
            LuaDLL.luaL_checktype(L, 2, LuaTypes.LUA_TTABLE);
            string absoluteFn = "";
            byte[] bytes = state.loadFile(fileName, ref absoluteFn);
            if (bytes != null)
            {
                if (LuaDLL.luaL_loadbuffer(L, bytes, bytes.Length, "@" + fileName) == 0)
                {
                    LuaDLL.lua_pushvalue(L, 2);
                    LuaDLL.lua_setupvalue(L, -2, 1);
                    LuaObject.pushValue(L, true);
                    LuaDLL.lua_insert(L, -2);
                    return 2;
                }
                else
                {
                    string errstr = LuaDLL.lua_tostring(L, -1);
                    return LuaObject.error(L, errstr);
                }
            }
            else
            {
                LuaObject.pushValue(L, true);
                LuaDLL.lua_pushnil(L);
                return LuaObject.error(L, "Can't find {0}", fileName);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int dofile(IntPtr L)
        {
            int n = LuaDLL.lua_gettop(L);

            loader(L);
            if (!LuaDLL.lua_toboolean(L, -2))
            {
                return 2;
            }
            else
            {
                if (LuaDLL.lua_isnil(L, -1))
                {
                    string fileName = LuaDLL.lua_tostring(L, 1);
                    return LuaObject.error(L, "Can't find {0}", fileName);
                }
                int k = LuaDLL.lua_gettop(L);
                LuaDLL.lua_call(L, 0, LuaDLL.LUA_MULTRET);
                k = LuaDLL.lua_gettop(L);
                return k - n;
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static public int panicCallback(IntPtr l)
        {
            string reason = string.Format("unprotected error in call to Lua API ({0})", LuaDLL.lua_tostring(l, -1));
            throw new Exception(reason);
        }

        static public void pushcsfunction(IntPtr L, LuaCSFunction function)
        {
            LuaDLL.lua_getref(L, get(L).PCallCSFunctionRef);
            LuaDLL.lua_pushcclosure(L, function, 0);
            LuaDLL.lua_call(L, 1, 1);
        }
#if LUA_DEBUG
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static public int getStringFromMD5(IntPtr L) {
			string str = LuaDLL.lua_tostring(L, -1);
            string destString = "";

            if (debugStringMap.ContainsKey(str))
            {
                destString = debugStringMap[str];
            }
            LuaObject.pushValue(L, destString);
            return 1;
        }

        static public string getStringMD5(string str)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] bytes = System.Text.Encoding.UTF8.GetBytes(str);
            byte[] md5Data = md5.ComputeHash(bytes, 0, bytes.Length);
            md5.Clear();

            string destString = "";
            for (int i = 0; i < md5Data.Length; i++)
            {
                destString += System.Convert.ToString(md5Data[i], 16).PadLeft(2, '0');
            }
            destString = destString.PadLeft(32, '0');
            return destString;
        }
#endif

        public object doString(string str)
        {
#if LUA_DEBUG
            //get str's md5 string
            string stringMd5 = getStringMD5(str);
            debugStringMap.Add(stringMd5, str);
            return doString(str, stringMd5);
#else
            return doString(str, "temp buffer");
#endif
        }

        public object doString(string str, string chunkname)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(str);

            object obj;
            if (doBuffer(bytes, chunkname, out obj))
                return obj;
            return null; ;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        internal static int loader(IntPtr L)
        {
            LuaState state = LuaState.get(L);
            string fileName = LuaDLL.lua_tostring(L, 1);
            string absoluteFn = "";
            byte[] bytes = state.loadFile(fileName, ref absoluteFn);
            if (bytes != null)
            {
                bytes = CleanUTF8Bom(bytes);
#if LUA_DEBUG
				if (absoluteFn != "") {
					fileName = absoluteFn;
				}
#endif
                if (LuaDLL.luaL_loadbuffer(L, bytes, bytes.Length, "@" + fileName) == 0)
                {
                    LuaObject.pushValue(L, true);
                    LuaDLL.lua_insert(L, -2);
                    return 2;
                }
                else
                {
                    string errstr = LuaDLL.lua_tostring(L, -1);
                    return LuaObject.error(L, errstr);
                }
            }
            LuaObject.pushValue(L, true);
            LuaDLL.lua_pushnil(L);
            return 2;
        }

        public object doFile(string fn)
        {
            string absoluteFn = "";
            byte[] bytes = loadFile(fn, ref absoluteFn);
            if (bytes == null)
            {
                Logger.LogError(string.Format("Can't find {0}", fn));
                return null;
            }

#if LUA_DEBUG
			if (absoluteFn != "") {
				fn = absoluteFn;
			}
#endif
            object obj;
            if (doBuffer(bytes, "@" + fn, out obj))
                return obj;
            return null;
        }

        /// <summary>
        /// Ensure remove BOM from bytes
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static byte[] CleanUTF8Bom(byte[] bytes)
        {
            if (bytes.Length > 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF)
            {
                var oldBytes = bytes;
                bytes = new byte[bytes.Length - 3];
                Array.Copy(oldBytes, 3, bytes, 0, bytes.Length);
            }
            return bytes;
        }

        public bool doBuffer(byte[] bytes, string fn, out object ret)
        {
            // ensure no utf-8 bom, LuaJIT can read BOM, but Lua cannot!
            bytes = CleanUTF8Bom(bytes);
            ret = null;
            int errfunc = LuaObject.pushTry(L);
            if (LuaDLL.luaL_loadbuffer(L, bytes, bytes.Length, fn) == 0)
            {
                if (LuaDLL.lua_pcall(L, 0, LuaDLL.LUA_MULTRET, errfunc) != 0)
                {
                    LuaDLL.lua_pop(L, 2);
                    return false;
                }
                LuaDLL.lua_remove(L, errfunc); // pop error function
                ret = topObjects(errfunc - 1);
                return true;
            }
            string err = LuaDLL.lua_tostring(L, -1);
            LuaDLL.lua_pop(L, 2);
            throw new Exception(err);
        }

#if UNITY_EDITOR
        static TextAsset loadAsset(string fn)
        {
            TextAsset asset;
#if UNITY_5
			asset = UnityEditor.AssetDatabase.LoadAssetAtPath<TextAsset> (fn);
#else
            asset = (TextAsset)UnityEditor.AssetDatabase.LoadAssetAtPath(fn, typeof(TextAsset));
#endif
            return asset;
        }
#endif

        internal byte[] loadFile(string fn, ref string absoluteFn)
        {
            try
            {
                byte[] bytes;
                if (loaderDelegate != null)
                    bytes = loaderDelegate(fn, ref absoluteFn);
                else
                {
#if !SLUA_STANDALONE
                    fn = fn.Replace(".", "/");

                    TextAsset asset = null;

#if UNITY_EDITOR


                    if (SLuaSetting.Instance.jitType == JITBUILDTYPE.none)
                    {
                        asset = (TextAsset)Resources.Load(fn);
                    }
                    else if (SLuaSetting.Instance.jitType == JITBUILDTYPE.X86)
                    {
                        asset = loadAsset("Assets/Slua/jit/jitx86/" + fn + ".bytes");
                    }
                    else if (SLuaSetting.Instance.jitType == JITBUILDTYPE.X64)
                    {
                        asset = loadAsset("Assets/Slua/jit/jitx64/" + fn + ".bytes");
                    }
                    else if (SLuaSetting.Instance.jitType == JITBUILDTYPE.GC64)
                    {
                        asset = loadAsset("Assets/Slua/jit/jitgc64/" + fn + ".bytes");
                    }

#if LUA_DEBUG
					//get asset's absolute path
					string assetFn = UnityEditor.AssetDatabase.GetAssetPath(asset);
					if (assetFn != ""){
						//find out asset path, remove assetFn's first "Asset/"
						int idx = assetFn.IndexOf("/");
						if(idx > 0){
							absoluteFn = Application.dataPath + assetFn.Substring(idx);
						}
					}
#endif
#else
					asset = (TextAsset)Resources.Load(fn);
#endif

                    if (asset == null)
                        return null;
                    bytes = asset.bytes;
#else
					bytes = File.ReadAllBytes(fn);
#endif
                }
                return bytes;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }


        internal object getObject(string key, bool wholekey = false, bool rawget = false)
        {
            LuaDLL.lua_pushglobaltable(L);
            object o;
            if (wholekey)
                o = getObject(new string[] { key }, rawget);
            else
                o = getObject(key.Split(new char[] { '.' }), rawget);
            LuaDLL.lua_pop(L, 1);
            return o;
        }

        internal void setObject(string key, object v, bool wholekey = false, bool rawset = false)
        {
            LuaDLL.lua_pushglobaltable(L);
            if (wholekey)
                setObject(new string[] { key }, v, rawset);
            else
                setObject(key.Split(new char[] { '.' }), v, rawset);
            LuaDLL.lua_pop(L, 1);
        }

        internal object getObject(string[] remainingPath, bool rawget = false)
        {
            object returnValue = null;
            for (int i = 0; i < remainingPath.Length; i++)
            {
                LuaDLL.lua_pushstring(L, remainingPath[i]);
                if (rawget)
                    LuaDLL.lua_rawget(L, -2);
                else
                    LuaDLL.lua_gettable(L, -2);
                returnValue = this.getObject(L, -1);
                LuaDLL.lua_remove(L, -2);
                if (returnValue == null) break;
            }
            return returnValue;
        }


        internal object getObject(int reference, string field, bool wholekey = false, bool rawget = false)
        {
            int oldTop = LuaDLL.lua_gettop(L);
            LuaDLL.lua_getref(L, reference);
            object returnValue;
            if (wholekey)
                returnValue = getObject(new string[] { field }, rawget);
            else
                returnValue = getObject(field.Split(new char[] { '.' }), rawget);
            LuaDLL.lua_settop(L, oldTop);
            return returnValue;
        }

        internal object getObject(int reference, int index, bool rawget = false)
        {
            if (index >= 1)
            {
                LuaDLL.lua_getref(L, reference);
                if (rawget)
                    LuaDLL.lua_rawgeti(L, -1, index);
                else
                {
                    LuaDLL.lua_pushinteger(L, index);
                    LuaDLL.lua_gettable(L, -2);
                }
                object returnValue = getObject(L, -1);
                LuaDLL.lua_pop(L, 2);
                return returnValue;
            }
            else
            {
                LuaDLL.lua_getref(L, reference);
                LuaDLL.lua_pushinteger(L, index);
                LuaDLL.lua_gettable(L, -2);
                object returnValue = getObject(L, -1);
                LuaDLL.lua_pop(L, 2);
                return returnValue;
            }
        }

        internal object getObject(int reference, object field, bool rawget = false)
        {
            int oldTop = LuaDLL.lua_gettop(L);
            LuaDLL.lua_getref(L, reference);
            LuaObject.pushObject(L, field);
            if (rawget)
                LuaDLL.lua_rawget(L, -2);
            else
                LuaDLL.lua_gettable(L, -2);
            object returnValue = getObject(L, -1);
            LuaDLL.lua_settop(L, oldTop);
            return returnValue;
        }

        internal void setObject(string[] remainingPath, object o, bool rawset = false)
        {
            int top = LuaDLL.lua_gettop(L);
            for (int i = 0; i < remainingPath.Length - 1; i++)
            {
                LuaDLL.lua_pushstring(L, remainingPath[i]);
                if (rawset)
                    LuaDLL.lua_rawget(L, -2);
                else
                    LuaDLL.lua_gettable(L, -2);
            }
            LuaDLL.lua_pushstring(L, remainingPath[remainingPath.Length - 1]);
            LuaObject.pushVar(L, o);
            if (rawset)
                LuaDLL.lua_rawset(L, -3);
            else
                LuaDLL.lua_settable(L, -3);
            LuaDLL.lua_settop(L, top);
        }


        internal void setObject(int reference, string field, object o, bool wholekey = false, bool rawset = false)
        {
            int oldTop = LuaDLL.lua_gettop(L);
            LuaDLL.lua_getref(L, reference);
            if (wholekey)
                setObject(new string[] { field }, o, rawset);
            else
                setObject(field.Split(new char[] { '.' }), o, rawset);
            LuaDLL.lua_settop(L, oldTop);
        }

        internal void setObject(int reference, int index, object o, bool rawset = false)
        {
            if (index >= 1)
            {
                LuaDLL.lua_getref(L, reference);

                if (rawset)
                {
                    LuaObject.pushVar(L, o);
                    LuaDLL.lua_rawseti(L, -2, index);
                }
                else
                {
                    LuaDLL.lua_pushinteger(L, index);
                    LuaObject.pushVar(L, o);
                    LuaDLL.lua_settable(L, -3);
                }
                LuaDLL.lua_pop(L, 1);
            }
            else
            {
                LuaDLL.lua_getref(L, reference);
                LuaDLL.lua_pushinteger(L, index);
                LuaObject.pushVar(L, o);
                if (rawset)
                    LuaDLL.lua_rawset(L, -3);
                else
                    LuaDLL.lua_settable(L, -3);
                LuaDLL.lua_pop(L, 1);
            }
        }

        internal void setObject(int reference, object field, object o, bool rawset)
        {
            int oldTop = LuaDLL.lua_gettop(L);
            LuaDLL.lua_getref(L, reference);
            LuaObject.pushObject(L, field);
            LuaObject.pushObject(L, o);
            LuaDLL.lua_settable(L, -3);
            LuaDLL.lua_settop(L, oldTop);
        }

        internal object topObjects(int from)
        {
            int top = LuaDLL.lua_gettop(L);
            int nArgs = top - from;
            if (nArgs == 0)
                return null;
            else if (nArgs == 1)
            {
                object o = LuaObject.checkVar(L, top);
                LuaDLL.lua_pop(L, 1);
                return o;
            }
            else
            {
                object[] o = new object[nArgs];
                for (int n = 1; n <= nArgs; n++)
                {
                    o[n - 1] = LuaObject.checkVar(L, from + n);

                }
                LuaDLL.lua_settop(L, from);
                return o;
            }
        }

        object getObject(IntPtr l, int p)
        {
            p = LuaDLL.lua_absindex(l, p);
            return LuaObject.checkVar(l, p);
        }

        public LuaFunction getFunction(string key)
        {
            return (LuaFunction)this[key];
        }

        public LuaTable getTable(string key)
        {
            return (LuaTable)this[key];
        }


        public object this[string path]
        {
            get
            {
                return this.getObject(path);
            }
            set
            {
                this.setObject(path, value);
            }
        }

        public void gcRef(UnRefAction act, int r)
        {
            UnrefPair u = new UnrefPair();
            u.act = act;
            u.r = r;
            lock (refQueue)
            {
                refQueue.Enqueue(u);
            }
        }

        public void checkRef()
        {
            int cnt = 0;
            // fix il2cpp lock issue on iOS
            lock (refQueue)
            {
                cnt = refQueue.Count;
            }

            var l = L;
            for (int n = 0; n < cnt; n++)
            {
                UnrefPair u;
                lock (refQueue)
                {
                    u = refQueue.Dequeue();
                }
                u.act(l, u.r);
            }
        }

        public void regPushVar(Type t, PushVarDelegate d) { typePushMap[t] = d; }
        public bool tryGetTypePusher(Type t, out PushVarDelegate d) { return typePushMap.TryGetValue(t, out d); }

        void setupPushVar()
        {
            typePushMap[typeof(float)] = (IntPtr L, object o) =>
            {
                LuaDLL.lua_pushnumber(L, (float)o);
            };
            typePushMap[typeof(double)] = (IntPtr L, object o) =>
            {
                LuaDLL.lua_pushnumber(L, (double)o);
            };

            typePushMap[typeof(int)] =
                (IntPtr L, object o) =>
                {
                    LuaDLL.lua_pushinteger(L, (int)o);
                };

            typePushMap[typeof(uint)] =
                (IntPtr L, object o) =>
                {
                    LuaDLL.lua_pushnumber(L, Convert.ToUInt32(o));
                };

            typePushMap[typeof(short)] =
                (IntPtr L, object o) =>
                {
                    LuaDLL.lua_pushinteger(L, (short)o);
                };

            typePushMap[typeof(ushort)] =
               (IntPtr L, object o) =>
               {
                   LuaDLL.lua_pushinteger(L, (ushort)o);
               };

            typePushMap[typeof(sbyte)] =
               (IntPtr L, object o) =>
               {
                   LuaDLL.lua_pushinteger(L, (sbyte)o);
               };

            typePushMap[typeof(byte)] =
               (IntPtr L, object o) =>
               {
                   LuaDLL.lua_pushinteger(L, (byte)o);
               };


            typePushMap[typeof(Int64)] =
                typePushMap[typeof(UInt64)] =
                (IntPtr L, object o) =>
                {
#if LUA_5_3
                    LuaDLL.lua_pushinteger(L, System.Convert.ToInt64(o));
#else
                    LuaDLL.lua_pushnumber(L, System.Convert.ToDouble(o));
#endif
                };

            typePushMap[typeof(string)] = (IntPtr L, object o) =>
            {
                LuaDLL.lua_pushstring(L, (string)o);
            };

            typePushMap[typeof(bool)] = (IntPtr L, object o) =>
            {
                LuaDLL.lua_pushboolean(L, (bool)o);
            };

            typePushMap[typeof(LuaTable)] =
                typePushMap[typeof(LuaFunction)] =
                typePushMap[typeof(LuaThread)] =
                (IntPtr L, object o) =>
                {
                    ((LuaVar)o).push(L);
                };

            typePushMap[typeof(LuaCSFunction)] = (IntPtr L, object o) =>
            {
                LuaObject.pushValue(L, (LuaCSFunction)o);
            };

#if !SLUA_STANDALONE
            regPushVar(typeof(UnityEngine.Vector2), (IntPtr L, object o) => { LuaObject.pushValue(L, (UnityEngine.Vector2)o); });
            regPushVar(typeof(UnityEngine.Vector3), (IntPtr L, object o) => { LuaObject.pushValue(L, (UnityEngine.Vector3)o); });
            regPushVar(typeof(UnityEngine.Vector4), (IntPtr L, object o) => { LuaObject.pushValue(L, (UnityEngine.Vector4)o); });
            regPushVar(typeof(UnityEngine.Quaternion), (IntPtr L, object o) => { LuaObject.pushValue(L, (UnityEngine.Quaternion)o); });
            regPushVar(typeof(UnityEngine.Color), (IntPtr L, object o) => { LuaObject.pushValue(L, (UnityEngine.Color)o); });
#endif
        }

        public int pushTry(IntPtr L)
        {
            if (errorRef == 0)
            {
                LuaDLL.lua_pushcfunction(L, LuaState.errorFunc);
                LuaDLL.lua_pushvalue(L, -1);
                errorRef = LuaDLL.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
            }
            else
            {
                LuaDLL.lua_getref(L, errorRef);
            }
            return LuaDLL.lua_gettop(L);
        }

        public object run(string entry)
        {
            using (LuaFunction func = getFunction(entry))
            {
                if (func != null)
                    return func.call();
            }
            return null;
        }
    }
}