Example #1
0
 public static int DelegateConstructor(RealStatePtr L)
 {
     try
     {
         ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
         Type             type       = getType(L, translator, 1);
         if (type == null || !typeof(Delegate).IsAssignableFrom(type))
         {
             return(LuaAPI.luaL_error(L, "delegate constructor: #1 argument must be a Delegate's type"));
         }
         translator.PushAny(L, translator.CreateDelegateBridge(L, type, 2, true));
         return(1);
     }
     catch (Exception e)
     {
         return(LuaAPI.luaL_error(L, "c# exception in delegate constructor: " + e));
     }
 }
Example #2
0
        private ObjectCast genCaster(Type type)
        {
            ObjectCast fixTypeGetter = (RealStatePtr L, int idx, object target) =>
            {
                if (LuaAPI.lua_type(L, idx) == LuaTypes.LUA_TUSERDATA)
                {
                    object obj = translator.SafeGetCSObj(L, idx);
                    return((obj != null && type.IsAssignableFrom(obj.GetType())) ? obj : null);
                }
                return(null);
            };

            if (typeof(Delegate).IsAssignableFrom(type))
            {
                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_isfunction(L, idx))
                    {
                        return null;
                    }

                    return translator.CreateDelegateBridge(L, type, idx);
                });
            }
            else if (type.IsInterface)
            {
                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_istable(L, idx))
                    {
                        return null;
                    }
                    return translator.CreateInterfaceBridge(L, type, idx);
                });
            }
            else if (type.IsEnum)
            {
                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    LuaTypes lua_type = LuaAPI.lua_type(L, idx);
                    if (lua_type == LuaTypes.LUA_TSTRING)
                    {
                        return Enum.Parse(type, LuaAPI.lua_tostring(L, idx));
                    }
                    else if (lua_type == LuaTypes.LUA_TNUMBER)
                    {
                        return Enum.ToObject(type, LuaAPI.xlua_tointeger(L, idx));
                    }
                    throw new InvalidCastException("invalid value for enum " + type);
                });
            }
            else if (type.IsArray)
            {
                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_istable(L, idx))
                    {
                        return null;
                    }

                    uint len = LuaAPI.xlua_objlen(L, idx);
                    int n = LuaAPI.lua_gettop(L);
                    idx = idx > 0 ? idx : LuaAPI.lua_gettop(L) + idx + 1;// abs of index
                    Type et = type.GetElementType();
                    ObjectCast elementCaster = GetCaster(et);
                    Array ary = target == null?Array.CreateInstance(et, len) : target as Array;

                    if (!LuaAPI.lua_checkstack(L, 1))
                    {
                        throw new Exception("stack overflow while cast to Array");
                    }
                    for (int i = 0; i < len; ++i)
                    {
                        LuaAPI.lua_pushnumber(L, i + 1);
                        LuaAPI.lua_rawget(L, idx);
                        if (et.IsPrimitive)
                        {
                            if (!StaticLuaCallbacks.TryPrimitiveArraySet(type, L, ary, i, n + 1))
                            {
                                ary.SetValue(elementCaster(L, n + 1, null), i);
                            }
                        }
                        else
                        {
                            if (StaticLuaCallbacks.GenTryArraySetPtr == null ||
                                !StaticLuaCallbacks.GenTryArraySetPtr(type, L, translator, ary, i, n + 1))
                            {
                                ary.SetValue(elementCaster(L, n + 1, null), i);
                            }
                        }
                        LuaAPI.lua_pop(L, 1);
                    }
                    return ary;
                });
            }
            else if (typeof(IList).IsAssignableFrom(type) && type.IsGenericType)
            {
                ObjectCast elementCaster = GetCaster(type.GetGenericArguments()[0]);

                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_istable(L, idx))
                    {
                        return null;
                    }

                    obj = target == null?Activator.CreateInstance(type) : target;

                    int n = LuaAPI.lua_gettop(L);
                    idx = idx > 0 ? idx : LuaAPI.lua_gettop(L) + idx + 1;// abs of index
                    IList list = obj as IList;


                    uint len = LuaAPI.xlua_objlen(L, n);
                    if (!LuaAPI.lua_checkstack(L, 1))
                    {
                        throw new Exception("stack overflow while cast to IList");
                    }
                    for (int i = 0; i < len; ++i)
                    {
                        LuaAPI.lua_pushnumber(L, i + 1);
                        LuaAPI.lua_rawget(L, idx);
                        if (i < list.Count && target != null)
                        {
                            var item = elementCaster(L, n + 1, list[i]);
                            if (item != null)
                            {
                                list[i] = item;
                            }
                        }
                        else
                        {
                            var item = elementCaster(L, n + 1, null);
                            if (item != null)
                            {
                                list.Add(item);
                            }
                        }
                        LuaAPI.lua_pop(L, 1);
                    }
                    return obj;
                });
            }
            else if (typeof(IDictionary).IsAssignableFrom(type) && type.IsGenericType)
            {
                ObjectCast keyCaster   = GetCaster(type.GetGenericArguments()[0]);
                ObjectCast valueCaster = GetCaster(type.GetGenericArguments()[1]);

                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_istable(L, idx))
                    {
                        return null;
                    }

                    IDictionary dic = (target == null ? Activator.CreateInstance(type) : target) as IDictionary;
                    int n = LuaAPI.lua_gettop(L);
                    idx = idx > 0 ? idx : LuaAPI.lua_gettop(L) + idx + 1;// abs of index

                    LuaAPI.lua_pushnil(L);
                    if (!LuaAPI.lua_checkstack(L, 1))
                    {
                        throw new Exception("stack overflow while cast to IDictionary");
                    }
                    while (LuaAPI.lua_next(L, idx) != 0)
                    {
                        object k = keyCaster(L, n + 1, null); // -2:key
                        if (k != null)
                        {
                            object v = valueCaster(L, n + 2, !dic.Contains(k) ? null : dic[k]);
                            if (v != null)
                            {
                                dic[k] = v; // -1:value
                            }
                        }
                        LuaAPI.lua_pop(L, 1); // removes value, keeps key for next iteration
                    }
                    return dic;
                });
            }
            else if ((type.IsClass && type.GetConstructor(System.Type.EmptyTypes) != null) || (type.IsValueType && !type.IsEnum)) //class has default construtor
            {
                return((RealStatePtr L, int idx, object target) =>
                {
                    object obj = fixTypeGetter(L, idx, target);
                    if (obj != null)
                    {
                        return obj;
                    }

                    if (!LuaAPI.lua_istable(L, idx))
                    {
                        return null;
                    }

                    obj = target == null?Activator.CreateInstance(type) : target;

                    int n = LuaAPI.lua_gettop(L);
                    idx = idx > 0 ? idx : LuaAPI.lua_gettop(L) + idx + 1;// abs of index
                    if (!LuaAPI.lua_checkstack(L, 1))
                    {
                        throw new Exception("stack overflow while cast to " + type);
                    }

                    /*foreach (PropertyInfo prop in type.GetProperties())
                     * {
                     *  LuaAPI.xlua_pushasciistring(L, prop.Name);
                     *  LuaAPI.lua_rawget(L, idx);
                     *  if (!LuaAPI.lua_isnil(L, -1))
                     *  {
                     *      try
                     *      {
                     *          prop.SetValue(obj, GetCaster(prop.PropertyType)(L, n + 1,
                     *              target == null || prop.PropertyType.IsPrimitive || prop.PropertyType == typeof(string) ? null : prop.GetValue(obj, null)), null);
                     *      }
                     *      catch (Exception e)
                     *      {
                     *          throw new Exception("exception in tran " + prop.Name + ", msg=" + e.Message);
                     *      }
                     *  }
                     *  LuaAPI.lua_pop(L, 1);
                     * }*/
                    foreach (FieldInfo field in type.GetFields())
                    {
                        LuaAPI.xlua_pushasciistring(L, field.Name);
                        LuaAPI.lua_rawget(L, idx);
                        if (!LuaAPI.lua_isnil(L, -1))
                        {
                            try
                            {
                                field.SetValue(obj, GetCaster(field.FieldType)(L, n + 1,
                                                                               target == null || field.FieldType.IsPrimitive || field.FieldType == typeof(string) ? null : field.GetValue(obj)));
                            }
                            catch (Exception e)
                            {
                                throw new Exception("exception in tran " + field.Name + ", msg=" + e.Message);
                            }
                        }
                        LuaAPI.lua_pop(L, 1);
                    }

                    return obj;
                });
            }
            else
            {
                return(fixTypeGetter);
            }
        }
        public LuaCSFunction GetEventWrap(Type type, string eventName)
        {
            if (!methodsCache.ContainsKey(type))
            {
                methodsCache[type] = new Dictionary <string, LuaCSFunction>();
            }

            var methodsOfType = methodsCache[type];

            if (!methodsOfType.ContainsKey(eventName))
            {
                {
                    EventInfo eventInfo = type.GetEvent(eventName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static);
                    if (eventInfo == null)
                    {
                        throw new Exception(type.Name + " has no event named: " + eventName);
                    }
                    int start_idx = 0;

                    MethodInfo add    = eventInfo.GetAddMethod();
                    MethodInfo remove = eventInfo.GetRemoveMethod();

                    bool is_static = add != null ? add.IsStatic : remove.IsStatic;
                    if (!is_static)
                    {
                        start_idx = 1;
                    }

                    methodsOfType[eventName] = (L) =>
                    {
                        object obj = null;

                        if (!is_static)
                        {
                            obj = translator.GetObject(L, 1, type);
                            if (obj == null)
                            {
                                return(LuaAPI.luaL_error(L, "invalid #1, needed:" + type));
                            }
                        }

                        try
                        {
                            Delegate handlerDelegate = translator.CreateDelegateBridge(L, eventInfo.EventHandlerType, start_idx + 2);
                            if (handlerDelegate == null)
                            {
                                return(LuaAPI.luaL_error(L, "invalid #" + (start_idx + 2) + ", needed:" + eventInfo.EventHandlerType));
                            }
                            switch (LuaAPI.lua_tostring(L, start_idx + 1))
                            {
                            case "+":
                                if (add == null)
                                {
                                    return(LuaAPI.luaL_error(L, "no add for event " + eventName));
                                }
                                add.Invoke(obj, new object[] { handlerDelegate });
                                break;

                            case "-":
                                if (remove == null)
                                {
                                    return(LuaAPI.luaL_error(L, "no remove for event " + eventName));
                                }
                                remove.Invoke(obj, new object[] { handlerDelegate });
                                break;

                            default:
                                return(LuaAPI.luaL_error(L, "invalid #" + (start_idx + 1) + ", needed: '+' or '-'" + eventInfo.EventHandlerType));
                            }
                        }
                        catch (System.Exception e)
                        {
                            return(LuaAPI.luaL_error(L, "c# exception:" + e + ",stack:" + e.StackTrace));
                        }

                        return(0);
                    };
                }
            }
            return(methodsOfType[eventName]);
        }