using System;

using System.Collections;

using System.Reflection;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

class ReferenceEqualsComparer : IEqualityComparer<object>

{

public new bool Equals(object o1, object o2)

{

return object.ReferenceEquals(o1, o2);

}

public int GetHashCode(object obj)

{

return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);

}

}

#pragma warning disable 414

public class MonoPInvokeCallbackAttribute : System.Attribute

{

private Type type;

public MonoPInvokeCallbackAttribute(Type t) { type = t; }

}

#pragma warning restore 414

public enum LuaTypes

{

LUA_TNONE = -1,

LUA_TNIL = 0,

LUA_TNUMBER = 3,

LUA_TSTRING = 4,

LUA_TBOOLEAN = 1,

LUA_TTABLE = 5,

LUA_TFUNCTION = 6,

LUA_TUSERDATA = 7,

LUA_TTHREAD = 8,

LUA_TLIGHTUSERDATA = 2

}

public enum LuaGCOptions

{

LUA_GCSTOP = 0,

LUA_GCRESTART = 1,

LUA_GCCOLLECT = 2,

LUA_GCCOUNT = 3,

LUA_GCCOUNTB = 4,

LUA_GCSTEP = 5,

LUA_GCSETPAUSE = 6,

LUA_GCSETSTEPMUL = 7,

}

public enum LuaThreadStatus

{

LUA_RESUME_ERROR = -1,

LUA_OK = 0,

LUA_YIELD = 1,

LUA_ERRRUN = 2,

LUA_ERRSYNTAX = 3,

LUA_ERRMEM = 4,

LUA_ERRERR = 5,

}

sealed class LuaIndexes

{

public static int LUA_REGISTRYINDEX

{

get

{

return InternalGlobals.LUA_REGISTRYINDEX;

}

set

{

InternalGlobals.LUA_REGISTRYINDEX = value;

}

}

}

#if GEN_CODE_MINIMIZE

public delegate int CSharpWrapper(IntPtr L, int top);

#endif

public partial class ObjectTranslator

{

internal MethodWrapsCache methodWrapsCache;

internal ObjectCheckers objectCheckers;

internal ObjectCasters objectCasters;

internal readonly ObjectPool objects = new ObjectPool();

internal readonly Dictionary<object, int> reverseMap = new Dictionary<object, int>(new ReferenceEqualsComparer());

internal LuaEnv luaEnv;

internal StaticLuaCallbacks metaFunctions;

internal List<Assembly> assemblies;

private LuaCSFunction importTypeFunction,loadAssemblyFunction, castFunction;

//延迟加载

private readonly Dictionary<Type, Action<RealStatePtr>> delayWrap = new Dictionary<Type, Action<RealStatePtr>>();

private readonly Dictionary<Type, Func<int, LuaEnv, LuaBase>> interfaceBridgeCreators = new Dictionary<Type, Func<int, LuaEnv, LuaBase>>();

//无法访问的类，比如声明成internal，可以用其接口、基类的生成代码来访问

private readonly Dictionary<Type, Type> aliasCfg = new Dictionary<Type, Type>();

public void DelayWrapLoader(Type type, Action<RealStatePtr> loader)

{

delayWrap[type] = loader;

}

public void AddInterfaceBridgeCreator(Type type, Func<int, LuaEnv, LuaBase> creator)

{

interfaceBridgeCreators.Add(type, creator);

}

Dictionary<Type, bool> loaded_types = new Dictionary<Type, bool>();

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<RealStatePtr> loader;

int top = LuaAPI.lua_gettop(L);

if (delayWrap.TryGetValue(type, out loader))

{

delayWrap.Remove(type);

loader(L);

}

else

{

#if !GEN_CODE_MINIMIZE && !ENABLE_IL2CPP && (UNITY_EDITOR || XLUA_GENERAL) && !FORCE_REFLECTION

if (!DelegateBridge.Gen_Flag && !type.IsEnum() && !typeof(Delegate).IsAssignableFrom(type) && Utils.IsPublic(type))

{

Type wrap = ce.EmitTypeWrap(type);

MethodInfo method = wrap.GetMethod("__Register", BindingFlags.Static | BindingFlags.Public);

method.Invoke(null, new object[] { L });

}

else

{

Utils.ReflectionWrap(L, type);

}

#else

Utils.ReflectionWrap(L, type);

#endif

#if NOT_GEN_WARNING

#if !XLUA_GENERAL

UnityEngine.Debug.LogWarning(string.Format("{0} not gen, using reflection instead", type));

#else

System.Console.WriteLine(string.Format("Warning: {0} not gen, using reflection instead", type));

#endif

#endif

}

if (top != LuaAPI.lua_gettop(L))

{

throw new Exception("top change, before:" + top + ", after:" + LuaAPI.lua_gettop(L));

}

foreach (var nested_type in type.GetNestedTypes(BindingFlags.Public))

{

if (nested_type.IsGenericTypeDefinition())

{

continue;

}

TryDelayWrapLoader(L, nested_type);

}

return true;

}

public void Alias(Type type, string alias)

{

Type alias_type = FindType(alias);

if (alias_type == null)

{

throw new ArgumentException("Can not find " + alias);

}

aliasCfg[alias_type] = type;

}

public int cacheRef;

void addAssemblieByName(IEnumerable<Assembly> assemblies_usorted, string name)

{

foreach(var assemblie in assemblies_usorted)

{

if (assemblie.FullName.StartsWith(name) && !assemblies.Contains(assemblie))

{

assemblies.Add(assemblie);

break;

}

}

}

public ObjectTranslator(LuaEnv luaenv,RealStatePtr L)

{

#if XLUA_GENERAL || (UNITY_WSA && !UNITY_EDITOR)

var dumb_field = typeof(ObjectTranslator).GetField("s_gen_reg_dumb_obj", BindingFlags.Static| BindingFlags.DeclaredOnly | BindingFlags.NonPublic);

if (dumb_field != null)

{

dumb_field.GetValue(null);

}

#endif

assemblies = new List<Assembly>();

#if UNITY_WSA && !UNITY_EDITOR

var assemblies_usorted = Utils.GetAssemblies();

#else

assemblies.Add(Assembly.GetExecutingAssembly());

var assemblies_usorted = AppDomain.CurrentDomain.GetAssemblies();

#endif

addAssemblieByName(assemblies_usorted, "mscorlib,");

addAssemblieByName(assemblies_usorted, "System,");

addAssemblieByName(assemblies_usorted, "System.Core,");

foreach (Assembly assembly in assemblies_usorted)

{

if (!assemblies.Contains(assembly))

{

assemblies.Add(assembly);

}

}

this.luaEnv=luaenv;

objectCasters = new ObjectCasters(this);

objectCheckers = new ObjectCheckers(this);

methodWrapsCache = new MethodWrapsCache(this, objectCheckers, objectCasters);

metaFunctions=new StaticLuaCallbacks();

importTypeFunction = new LuaCSFunction(StaticLuaCallbacks.ImportType);

loadAssemblyFunction = new LuaCSFunction(StaticLuaCallbacks.LoadAssembly);

castFunction = new LuaCSFunction(StaticLuaCallbacks.Cast);

LuaAPI.lua_newtable(L);

LuaAPI.lua_newtable(L);

LuaAPI.xlua_pushasciistring(L, "__mode");

LuaAPI.xlua_pushasciistring(L, "v");

LuaAPI.lua_rawset(L, -3);

LuaAPI.lua_setmetatable(L, -2);

cacheRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

initCSharpCallLua();

}

internal enum LOGLEVEL{

NO,

INFO,

WARN,

ERROR

}

Type delegate_birdge_type;

#if UNITY_EDITOR || XLUA_GENERAL

class CompareByArgRet : IEqualityComparer<MethodInfo>

{

public bool Equals(MethodInfo x, MethodInfo y)

{

return Utils.IsParamsMatch(x, y);

}

public int GetHashCode(MethodInfo method)

{

int hc = 0;

hc += method.ReturnType.GetHashCode();

foreach (var pi in method.GetParameters())

{

hc += pi.ParameterType.GetHashCode();

}

return hc;

}

}

#endif

void initCSharpCallLua()

{

delegate_birdge_type = typeof(DelegateBridge);

#if UNITY_EDITOR || XLUA_GENERAL

if (!DelegateBridge.Gen_Flag)

{

List<Type> cs_call_lua = new List<Type>();

foreach (var type in Utils.GetAllTypes())

{

if(type.IsDefined(typeof(CSharpCallLuaAttribute), false))

{

cs_call_lua.Add(type);

}

if (!type.IsAbstract || !type.IsSealed) continue;

var fields = type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

for (int i = 0; i < fields.Length; i++)

{

var field = fields[i];

if (field.IsDefined(typeof(CSharpCallLuaAttribute), false) && (typeof(IEnumerable<Type>)).IsAssignableFrom(field.FieldType))

{

cs_call_lua.AddRange(field.GetValue(null) as IEnumerable<Type>);

}

}

var props = type.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

for (int i = 0; i < props.Length; i++)

{

var prop = props[i];

if (prop.IsDefined(typeof(CSharpCallLuaAttribute), false) && (typeof(IEnumerable<Type>)).IsAssignableFrom(prop.PropertyType))

{

cs_call_lua.AddRange(prop.GetValue(null, null) as IEnumerable<Type>);

}

}

}

IEnumerable<IGrouping<MethodInfo, Type>> groups = (from type in cs_call_lua

where typeof(Delegate).IsAssignableFrom(type) && type != typeof(Delegate) && type != typeof(MulticastDelegate)

where !type.GetMethod("Invoke").GetParameters().Any(paramInfo => paramInfo.ParameterType.IsGenericParameter)

select type).GroupBy(t => t.GetMethod("Invoke"), new CompareByArgRet());

ce.SetGenInterfaces(cs_call_lua.Where(type=>type.IsInterface()).ToList());

delegate_birdge_type = ce.EmitDelegateImpl(groups);

}

#endif

}

#if UNITY_EDITOR || XLUA_GENERAL

CodeEmit ce = new CodeEmit();

#endif

Delegate getDelegate(DelegateBridgeBase bridge, Type delegateType)

{

Delegate ret = bridge.GetDelegateByType(delegateType);

if (ret != null)

{

return ret;

}

if (delegateType == typeof(Delegate) || delegateType == typeof(MulticastDelegate))

{

return null;

}

// get by parameters

MethodInfo delegateMethod = delegateType.GetMethod("Invoke");

var methods = bridge.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

for (int i = 0; i < methods.Length; i++)

{

if (!methods[i].IsConstructor && Utils.IsParamsMatch(delegateMethod, methods[i]))

{

#if !UNITY_WSA || UNITY_EDITOR

return Delegate.CreateDelegate(delegateType, bridge, methods[i]);

#else

return methods[i].CreateDelegate(delegateType, bridge);

#endif

}

}

throw new InvalidCastException("This type must add to CSharpCallLua: " + delegateType);

}

Dictionary<int, WeakReference> delegate_bridges = new Dictionary<int, WeakReference>();

public object CreateDelegateBridge(RealStatePtr L, Type delegateType, int idx)

{

LuaAPI.lua_pushvalue(L, idx);

LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);

if (!LuaAPI.lua_isnil(L, -1))

{

int referenced = LuaAPI.xlua_tointeger(L, -1);

LuaAPI.lua_pop(L, 1);

if (delegate_bridges[referenced].IsAlive)

{

if (delegateType == null)

{

return delegate_bridges[referenced].Target;

}

DelegateBridgeBase exist_bridge = delegate_bridges[referenced].Target as DelegateBridgeBase;

Delegate exist_delegate;

if (exist_bridge.TryGetDelegate(delegateType, out exist_delegate))

{

return exist_delegate;

}

else

{

exist_delegate = getDelegate(exist_bridge, delegateType);

exist_bridge.AddDelegate(delegateType, exist_delegate);

return exist_delegate;

}

}

}

else

{

LuaAPI.lua_pop(L, 1);

}

LuaAPI.lua_pushvalue(L, idx);

int reference = LuaAPI.luaL_ref(L);

LuaAPI.lua_pushvalue(L, idx);

LuaAPI.lua_pushnumber(L, reference);

LuaAPI.lua_rawset(L, LuaIndexes.LUA_REGISTRYINDEX);

DelegateBridgeBase bridge;

try

{

#if UNITY_EDITOR || XLUA_GENERAL

if (!DelegateBridge.Gen_Flag)

{

bridge = Activator.CreateInstance(delegate_birdge_type, new object[] { reference, luaEnv }) as DelegateBridgeBase;

}

else

#endif

{

bridge = new DelegateBridge(reference, luaEnv);

}

}

catch(Exception e)

{

LuaAPI.lua_pushvalue(L, idx);

LuaAPI.lua_pushnil(L);

LuaAPI.lua_rawset(L, LuaIndexes.LUA_REGISTRYINDEX);

LuaAPI.lua_pushnil(L);

LuaAPI.xlua_rawseti(L, LuaIndexes.LUA_REGISTRYINDEX, reference);

throw e;

}

if (delegateType == null)

{

delegate_bridges[reference] = new WeakReference(bridge);

return bridge;

}

try {

var ret = getDelegate(bridge, delegateType);

bridge.AddDelegate(delegateType, ret);

delegate_bridges[reference] = new WeakReference(bridge);

return ret;

}

catch(Exception e)

{

bridge.Dispose();

throw e;

}

}

public bool AllDelegateBridgeReleased()

{

foreach (var kv in delegate_bridges)

{

if (kv.Value.IsAlive)

{

return false;

}

}

return true;

}

public void ReleaseLuaBase(RealStatePtr L, int reference, bool is_delegate)

{

if(is_delegate)

{

LuaAPI.xlua_rawgeti(L, LuaIndexes.LUA_REGISTRYINDEX, reference);

if (LuaAPI.lua_isnil(L, -1))

{

LuaAPI.lua_pop(L, 1);

}

else

{

LuaAPI.lua_pushvalue(L, -1);

LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);

if (LuaAPI.lua_type(L, -1) == LuaTypes.LUA_TNUMBER && LuaAPI.xlua_tointeger(L, -1) == reference) //

{

//UnityEngine.Debug.LogWarning("release delegate ref = " + luaReference);

LuaAPI.lua_pop(L, 1);// pop LUA_REGISTRYINDEX[func]

LuaAPI.lua_pushnil(L);

LuaAPI.lua_rawset(L, LuaIndexes.LUA_REGISTRYINDEX); // LUA_REGISTRYINDEX[func] = nil

}

else //another Delegate ref the function before the GC tick

{

LuaAPI.lua_pop(L, 2); // pop LUA_REGISTRYINDEX[func] & func

}

}

LuaAPI.lua_unref(L, reference);

delegate_bridges.Remove(reference);

}

else

{

LuaAPI.lua_unref(L, reference);

}

}

public object CreateInterfaceBridge(RealStatePtr L, Type interfaceType, int idx)

{

Func<int, LuaEnv, LuaBase> creator;

if (!interfaceBridgeCreators.TryGetValue(interfaceType, out creator))

{

#if UNITY_EDITOR || XLUA_GENERAL

var bridgeType = ce.EmitInterfaceImpl(interfaceType);

creator = (int reference, LuaEnv luaenv) =>

{

return Activator.CreateInstance(bridgeType, new object[] { reference, luaEnv }) as LuaBase;

};

interfaceBridgeCreators.Add(interfaceType, creator);

#else

throw new InvalidCastException("This type must add to CSharpCallLua: " + interfaceType);

#endif

}

LuaAPI.lua_pushvalue(L, idx);

return creator(LuaAPI.luaL_ref(L), luaEnv);

}

int common_array_meta = -1;

public void CreateArrayMetatable(RealStatePtr L)

{

Utils.BeginObjectRegister(null, L, this, 0, 0, 1, 0, common_array_meta);

Utils.RegisterFunc(L, Utils.GETTER_IDX, "Length", StaticLuaCallbacks.ArrayLength);

Utils.EndObjectRegister(null, L, this, null, null,

typeof(System.Array), StaticLuaCallbacks.ArrayIndexer, StaticLuaCallbacks.ArrayNewIndexer);

}

int common_delegate_meta = -1;

public void CreateDelegateMetatable(RealStatePtr L)

{

Utils.BeginObjectRegister(null, L, this, 3, 0, 0, 0, common_delegate_meta);

Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__call", StaticLuaCallbacks.DelegateCall);

Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", StaticLuaCallbacks.DelegateCombine);

Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", StaticLuaCallbacks.DelegateRemove);

Utils.EndObjectRegister(null, L, this, null, null,

typeof(System.MulticastDelegate), null, null);

}

int enumerable_pairs_func = -1;

internal void CreateEnumerablePairs(RealStatePtr L)

{

LuaFunction func = luaEnv.DoString(@"

")[0] as LuaFunction;

func.push(L);

enumerable_pairs_func = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

func.Dispose();

}

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);

LuaAPI.xlua_pushasciistring(L, "cast");

LuaAPI.lua_pushstdcallcfunction(L, castFunction);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "load_assembly");

LuaAPI.lua_pushstdcallcfunction(L,loadAssemblyFunction);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "access");

LuaAPI.lua_pushstdcallcfunction(L, StaticLuaCallbacks.XLuaAccess);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "private_accessible");

LuaAPI.lua_pushstdcallcfunction(L, StaticLuaCallbacks.XLuaPrivateAccessible);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "metatable_operation");

LuaAPI.lua_pushstdcallcfunction(L, StaticLuaCallbacks.XLuaMetatableOperation);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "tofunction");

LuaAPI.lua_pushstdcallcfunction(L, StaticLuaCallbacks.ToFunction);

LuaAPI.lua_rawset(L, -3);

LuaAPI.xlua_pushasciistring(L, "release");

LuaAPI.lua_pushstdcallcfunction(L, StaticLuaCallbacks.ReleaseCsObject);

LuaAPI.lua_rawset(L, -3);

LuaAPI.lua_pop(L, 1);

LuaAPI.lua_createtable(L, 1, 4); // 4 for __gc, __tostring, __index, __newindex

common_array_meta = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

LuaAPI.lua_createtable(L, 1, 4); // 4 for __gc, __tostring, __index, __newindex

common_delegate_meta = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

}

internal void createFunctionMetatable(RealStatePtr L)

{

LuaAPI.lua_newtable(L);

LuaAPI.xlua_pushasciistring(L,"__gc");

LuaAPI.lua_pushstdcallcfunction(L,metaFunctions.GcMeta);

LuaAPI.lua_rawset(L,-3);

LuaAPI.lua_pushlightuserdata(L, LuaAPI.xlua_tag());

LuaAPI.lua_pushnumber(L, 1);

LuaAPI.lua_rawset(L, -3);

LuaAPI.lua_pushvalue(L, -1);

int 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);

typeIdMap.Add(typeof(LuaCSFunction), type_id);

}

internal Type FindType(string className, bool isQualifiedName = false)

{

foreach (Assembly assembly in assemblies)

{

Type klass = assembly.GetType(className);

if (klass!=null)

{

return klass;

}

}

int p1 = className.IndexOf('[');

if (p1 > 0 && !isQualifiedName)

{

string qualified_name = className.Substring(0, p1 + 1);

string[] generic_params = className.Substring(p1 + 1, className.Length - qualified_name.Length - 1).Split(',');

for(int i = 0; i < generic_params.Length; i++)

{

Type generic_param = FindType(generic_params[i].Trim());

if (generic_param == null)

{

return null;

}

if (i != 0 )

{

qualified_name += ", ";

}

qualified_name = qualified_name + "[" + generic_param.AssemblyQualifiedName + "]";

}

qualified_name += "]";

return FindType(qualified_name, true);

}

return null;

}

bool hasMethod(Type type, string methodName)

{

foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))

{

if (method.Name == methodName)

{

return true;

}

}

return false;

}

internal void collectObject(int obj_index_to_collect)

{

object o;

if (objects.TryGetValue(obj_index_to_collect, out o))

{

objects.Remove(obj_index_to_collect);

if (o != null)

{

int obj_index;

//lua gc是先把weak table移除后再调用__gc，这期间同一个对象可能再次push到lua，关联到新的index

bool is_enum = o.GetType().IsEnum();

if ((is_enum ? enumMap.TryGetValue(o, out obj_index) : reverseMap.TryGetValue(o, out obj_index))

&& obj_index == obj_index_to_collect)

{

if (is_enum)

{

enumMap.Remove(o);

}

else

{

reverseMap.Remove(o);

}

}

}

}

}

int addObject(object obj, bool is_valuetype, bool is_enum)

{

int index = objects.Add(obj);

if (is_enum)

{

enumMap[obj] = index;

}

else if (!is_valuetype)

{

reverseMap[obj] = index;

}

return index;

}

internal object GetObject(RealStatePtr L,int index)

{

return (objectCasters.GetCaster(typeof(object))(L, index, null));

}

public Type GetTypeOf(RealStatePtr L, int idx)

{

Type type = null;

int type_id = LuaAPI.xlua_gettypeid(L, idx);

if (type_id != -1)

{

typeMap.TryGetValue(type_id, out type);

}

return type;

}

public bool Assignable<T>(RealStatePtr L, int index)

{

return Assignable(L, index, typeof(T));

}

public bool Assignable(RealStatePtr L, int index, Type type)

{

if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) // 快路径

{

int udata = LuaAPI.xlua_tocsobj_safe(L, index);

object obj;

if (udata != -1 && objects.TryGetValue(udata, out obj))

{

RawObject rawObject = obj as RawObject;

if (rawObject != null)

{

obj = rawObject.Target;

}

return type.IsAssignableFrom(obj.GetType());

}

int type_id = LuaAPI.xlua_gettypeid(L, index);

Type type_of_struct;

if (type_id != -1 && typeMap.TryGetValue(type_id, out type_of_struct)) // is struct

{

return type.IsAssignableFrom(type_of_struct);

}

}

return objectCheckers.GetChecker(type)(L, index);

}

public object GetObject(RealStatePtr L, int index, Type type)

{

int udata = LuaAPI.xlua_tocsobj_safe(L, index);

if (udata != -1)

{

object obj = objects.Get(udata);

RawObject rawObject = obj as RawObject;

return rawObject == null ? obj : rawObject.Target;

}

else

{

if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)