internal void AddClassesFromInheritanceChain(string name, ArrayList result) { IReflect superType = this; bool flag = true; while (superType is ClassScope) { if (superType.GetMember(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Length > 0) { result.Add(superType); flag = false; } if (superType is ClassScope) { superType = ((ClassScope)superType).GetSuperType(); } else { superType = ((Type)superType).BaseType; } } if ((flag && (superType is Type)) && (superType.GetMember(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Length > 0)) { result.Add(superType); } }
internal void AddClassesFromInheritanceChain(String name, ArrayList result) { IReflect ir = this; bool noMatch = true; while (ir is ClassScope) { if (ir.GetMember(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly).Length > 0) { result.Add(ir); noMatch = false; } if (ir is ClassScope) { ir = ((ClassScope)ir).GetSuperType(); } else { ir = ((Type)ir).BaseType; } } if (noMatch && ir is Type && ir.GetMember(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Length > 0) { result.Add(ir); } }
private static MemberInfo[] GetDefaultMembers(Type typ, IReflect objIReflect, ref string DefaultName) { MemberInfo[] nonGenericMembers; if (typ == objIReflect) { do { object[] customAttributes = typ.GetCustomAttributes(typeof(DefaultMemberAttribute), false); if ((customAttributes != null) && (customAttributes.Length != 0)) { DefaultName = ((DefaultMemberAttribute)customAttributes[0]).MemberName; nonGenericMembers = GetNonGenericMembers(typ.GetMember(DefaultName, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase)); if ((nonGenericMembers != null) && (nonGenericMembers.Length != 0)) { return(nonGenericMembers); } DefaultName = ""; return(null); } typ = typ.BaseType; }while (typ != null); DefaultName = ""; return(null); } nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember("", BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase)); if ((nonGenericMembers == null) || (nonGenericMembers.Length == 0)) { DefaultName = ""; return(null); } DefaultName = nonGenericMembers[0].Name; return(nonGenericMembers); }
private static MemberInfo[] GetAndWrapMember(IReflect reflect, Object namedItem, String name, BindingFlags bindingAttr) { PropertyInfo property = reflect.GetProperty(name, bindingAttr); if (property != null) { MethodInfo getMethod = JSProperty.GetGetMethod(property, false); MethodInfo setMethod = JSProperty.GetSetMethod(property, false); if ((getMethod != null && !getMethod.IsStatic) || (setMethod != null && !setMethod.IsStatic)) { MethodInfo method = reflect.GetMethod(name, bindingAttr); if (method != null && !method.IsStatic) { MemberInfo[] propMethods = new MemberInfo[1]; propMethods[0] = new JSWrappedPropertyAndMethod(property, method, namedItem); return(propMethods); } } } MemberInfo[] members = reflect.GetMember(name, bindingAttr); if (members != null && members.Length > 0) { return(ScriptObject.WrapMembers(members, namedItem)); } return(null); }
private bool trySetMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { detailMessage = null; if (LuaDLL.lua_type(luaState, 2) != LuaTypes.LUA_TSTRING) { detailMessage = "property names must be strings"; return(false); } string text = LuaDLL.lua_tostring(luaState, 2); if (text == null || text.get_Length() < 1 || (!char.IsLetter(text.get_Chars(0)) && text.get_Chars(0) != '_')) { detailMessage = "invalid property name"; return(false); } MemberInfo memberInfo = (MemberInfo)this.checkMemberCache(this.memberCache, targetType, text); if (memberInfo == null) { MemberInfo[] member = targetType.GetMember(text, bindingType | 16 | 1); if (member.Length <= 0) { detailMessage = "field or property '" + text + "' does not exist"; return(false); } memberInfo = member[0]; this.setMemberCache(this.memberCache, targetType, text, memberInfo); } if (memberInfo.get_MemberType() == 4) { FieldInfo fieldInfo = (FieldInfo)memberInfo; object asType = this.translator.getAsType(luaState, 3, fieldInfo.get_FieldType()); try { fieldInfo.SetValue(target, asType); } catch (Exception e) { this.ThrowError(luaState, e); } return(true); } if (memberInfo.get_MemberType() == 16) { PropertyInfo propertyInfo = (PropertyInfo)memberInfo; object asType2 = this.translator.getAsType(luaState, 3, propertyInfo.get_PropertyType()); try { propertyInfo.SetValue(target, asType2, null); } catch (Exception e2) { this.ThrowError(luaState, e2); } return(true); } detailMessage = "'" + text + "' is not a .net field or property"; return(false); }
private bool trySetMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { detailMessage = null; if (LuaDLL.lua_type(luaState, 2) != LuaTypes.LUA_TSTRING) { detailMessage = "property names must be strings"; return(false); } string memberName = LuaDLL.lua_tostring(luaState, 2); if (((memberName == null) || (memberName.Length < 1)) || (!char.IsLetter(memberName[0]) && (memberName[0] != '_'))) { detailMessage = "invalid property name"; return(false); } MemberInfo member = (MemberInfo)this.checkMemberCache(this.memberCache, targetType, memberName); if (member == null) { MemberInfo[] infoArray = targetType.GetMember(memberName, (bindingType | BindingFlags.Public) | BindingFlags.IgnoreCase); if (infoArray.Length <= 0) { detailMessage = "field or property '" + memberName + "' does not exist"; return(false); } member = infoArray[0]; this.setMemberCache(this.memberCache, targetType, memberName, member); } if (member.MemberType == MemberTypes.Field) { FieldInfo info2 = (FieldInfo)member; object obj2 = this.translator.getAsType(luaState, 3, info2.FieldType); try { info2.SetValue(target, obj2); } catch (Exception exception) { this.ThrowError(luaState, exception); } return(true); } if (member.MemberType == MemberTypes.Property) { PropertyInfo info3 = (PropertyInfo)member; object obj3 = this.translator.getAsType(luaState, 3, info3.PropertyType); try { info3.SetValue(target, obj3, null); } catch (Exception exception2) { this.ThrowError(luaState, exception2); } return(true); } detailMessage = "'" + memberName + "' is not a .net field or property"; return(false); }
private static MemberInfo[] GetMembersByName(IReflect objIReflect, string name, BindingFlags flags) { MemberInfo[] nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember(name, flags)); if ((nonGenericMembers != null) && (nonGenericMembers.Length == 0)) { return(null); } return(nonGenericMembers); }
/* * Writes to fields or properties, either static or instance. Throws an error * if the operation is invalid. */ private int setMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType) { string fieldName = LuaDLL.lua_tostring(luaState, 2); if (fieldName == null) { translator.throwError(luaState, "field or property does not exist"); return(0); } MemberInfo member = (MemberInfo)checkMemberCache(memberCache, targetType, fieldName); if (member == null) { MemberInfo[] members = targetType.GetMember(fieldName, bindingType | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField); if (members.Length > 0) { member = members[0]; setMemberCache(memberCache, targetType, fieldName, member); } else { translator.throwError(luaState, "field or property does not exist"); return(0); } } if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; object val = translator.getAsType(luaState, 3, field.FieldType); try { field.SetValue(target, val); } catch (Exception e) { translator.throwError(luaState, e); } return(0); } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; object val = translator.getAsType(luaState, 3, property.PropertyType); try { property.SetValue(target, val, null); } catch (Exception e) { translator.throwError(luaState, e); } return(0); } translator.throwError(luaState, "field or property does not exist"); return(0); }
private bool isMemberPresent(IReflect objType, string methodName) { object obj = this.checkMemberCache(this.memberCache, objType, methodName); if (obj != null) { return(true); } MemberInfo[] member = objType.GetMember(methodName, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public); return(member.Length > 0); }
internal void AddOverloadedMembers(MemberInfoList mems, ClassScope scope, BindingFlags attrs) { JSMemberField field = this; while (field != null) { MethodInfo meth = ((JSMemberField)field).GetAsMethod(scope); if (meth.IsStatic) { if ((attrs & BindingFlags.Static) == 0) { goto next; } } else { if ((attrs & BindingFlags.Instance) == 0) { goto next; } } if (meth.IsPublic) { if ((attrs & BindingFlags.Public) == 0) { goto next; } } else { if ((attrs & BindingFlags.NonPublic) == 0) { goto next; } } mems.Add(meth); next: field = field.nextOverload; } if ((attrs & BindingFlags.DeclaredOnly) != 0 && (attrs & BindingFlags.FlattenHierarchy) == 0) { return; } IReflect superClass = scope.GetSuperType(); MemberInfo[] supMembers = superClass.GetMember(this.Name, attrs & ~BindingFlags.DeclaredOnly); foreach (MemberInfo supMember in supMembers) { if (supMember.MemberType == MemberTypes.Method) { mems.Add(supMember); } } }
private bool isMemberPresent(IReflect objType, string methodName) { object obj = this.checkMemberCache(this.memberCache, objType, methodName); if (obj != null) { return(true); } MemberInfo[] member = objType.GetMember(methodName, 29); return(member.Length > 0); }
/// <summary> /// Does this method exist as either an instance or static? /// </summary> /// <param name="objType"></param> /// <param name="methodName"></param> /// <returns></returns> bool isMemberPresent(IReflect objType, string methodName) { object cachedMember = checkMemberCache(memberCache, objType, methodName); if (cachedMember != null) { return(true); } MemberInfo[] members = objType.GetMember(methodName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return(members.Length > 0); }
/// <summary>Does this method exist as either an instance or static?</summary><exception cref="ArgumentNullException">All arguments are required.</exception> bool isMemberPresent(IReflect objType, string methodName) { Debug.Assert(objType != null && methodName != null); object cachedMember = checkMemberCache(objType, methodName); if (cachedMember != null) { return(true); } MemberInfo[] members = objType.GetMember(methodName, BindingFlags.Static | BindingFlags.Instance | luanet.LuaBindingFlags); return(members.Length != 0); }
/// <summary> /// Does this method exist as either an instance or static? /// </summary> /// <param name="objType"></param> /// <param name="methodName"></param> /// <returns></returns> bool isMemberPresent(IReflect objType, string methodName) { object cachedMember = checkMemberCache(memberCache, objType, methodName); if (!cachedMember.IsNull()) { return(true); } //CP: Removed NonPublic binding search var members = objType.GetMember(methodName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase); return(members.Length > 0); }
/// <summary> /// Gets the value of the member from an object using the member name /// </summary> /// <param name="type"></param> /// <param name="memberName">Name of the member</param> /// <param name="obj">Object to get the member value from</param> /// <returns></returns> private static object GetMemberValue(this IReflect type, string memberName, object obj) { var memberInfo = type.GetMember(memberName, DEFAULT_BINDING_FLAGS).FirstOrDefault(); if (memberInfo is PropertyInfo) { return(type.GetProperty(memberName, DEFAULT_BINDING_FLAGS).GetValue(obj)); } if (memberInfo is FieldInfo) { return(type.GetField(memberName, DEFAULT_BINDING_FLAGS).GetValue(obj)); } return(null); }
private static MemberInfo GetMostDerivedMemberInfo(IReflect objIReflect, string name, BindingFlags flags) { MemberInfo[] nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember(name, flags)); if ((nonGenericMembers == null) || (nonGenericMembers.Length == 0)) { return(null); } MemberInfo info2 = nonGenericMembers[0]; int upperBound = nonGenericMembers.GetUpperBound(0); for (int i = 1; i <= upperBound; i++) { if (nonGenericMembers[i].DeclaringType.IsSubclassOf(info2.DeclaringType)) { info2 = nonGenericMembers[i]; } } return(info2); }
private static MemberInfo[] GetAndWrapMember(IReflect reflect, Object namedItem, String name, BindingFlags bindingAttr){ PropertyInfo property = reflect.GetProperty(name, bindingAttr); if (property != null){ MethodInfo getMethod = JSProperty.GetGetMethod(property, false); MethodInfo setMethod = JSProperty.GetSetMethod(property, false); if ((getMethod != null && !getMethod.IsStatic) || (setMethod != null && !setMethod.IsStatic)){ MethodInfo method = reflect.GetMethod(name, bindingAttr); if (method != null && !method.IsStatic){ MemberInfo[] propMethods = new MemberInfo[1]; propMethods[0] = new JSWrappedPropertyAndMethod(property, method, namedItem); return propMethods; } } } MemberInfo[] members = reflect.GetMember(name, bindingAttr); if (members != null && members.Length > 0) return ScriptObject.WrapMembers(members, namedItem); return null; }
private static MemberInfo[] GetAndWrapMember(IReflect reflect, object namedItem, string name, BindingFlags bindingAttr) { PropertyInfo property = reflect.GetProperty(name, bindingAttr); if (property != null) { MethodInfo getMethod = JSProperty.GetGetMethod(property, false); MethodInfo setMethod = JSProperty.GetSetMethod(property, false); if (((getMethod != null) && !getMethod.IsStatic) || ((setMethod != null) && !setMethod.IsStatic)) { MethodInfo method = reflect.GetMethod(name, bindingAttr); if ((method != null) && !method.IsStatic) { return new MemberInfo[] { new JSWrappedPropertyAndMethod(property, method, namedItem) }; } } } MemberInfo[] member = reflect.GetMember(name, bindingAttr); if ((member != null) && (member.Length > 0)) { return ScriptObject.WrapMembers(member, namedItem); } return null; }
private static MemberInfo[] GetAndWrapMember(IReflect reflect, object namedItem, string name, BindingFlags bindingAttr) { PropertyInfo property = reflect.GetProperty(name, bindingAttr); if (property != null) { MethodInfo getMethod = JSProperty.GetGetMethod(property, false); MethodInfo setMethod = JSProperty.GetSetMethod(property, false); if (((getMethod != null) && !getMethod.IsStatic) || ((setMethod != null) && !setMethod.IsStatic)) { MethodInfo method = reflect.GetMethod(name, bindingAttr); if ((method != null) && !method.IsStatic) { return(new MemberInfo[] { new JSWrappedPropertyAndMethod(property, method, namedItem) }); } } } MemberInfo[] member = reflect.GetMember(name, bindingAttr); if ((member != null) && (member.Length > 0)) { return(ScriptObject.WrapMembers(member, namedItem)); } return(null); }
/// <summary>[-0, +2, e] /// Returns to Lua the value of a member or a delegate to call it, depending on the type of the member. /// Works with static or instance members. Uses reflection to find members, /// and stores the reflected MemberInfo object in a cache (indexed by <paramref name="objType"/> and <paramref name="methodName"/>). /// </summary> /// <exception cref="ArgumentNullException"><paramref name="objType"/> and <paramref name="methodName"/> are required</exception> int getMember(lua.State L, IReflect objType, object obj, string methodName, BindingFlags bindingType) { Debug.Assert(interpreter.IsSameLua(L)); Debug.Assert(objType != null && methodName != null); Debug.Assert((obj == null) == (objType is ProxyType)); Debug.Assert((obj == null) != (objType is Type)); Debug.Assert((obj == null) == ((bindingType & BindingFlags.Static) == BindingFlags.Static)); Debug.Assert((obj == null) != ((bindingType & BindingFlags.Instance) == BindingFlags.Instance)); MemberInfo member = null; object cachedMember = checkMemberCache(objType, methodName); if (cachedMember != null) { var cachedMethod = cachedMember as lua.CFunction; if (cachedMethod != null) { luaclr.pushcfunction(L, cachedMethod); lua.pushboolean(L, true); return(2); } Debug.Assert(cachedMember is MemberInfo); member = (MemberInfo)cachedMember; } else { MemberInfo[] members = objType.GetMember(methodName, bindingType | luanet.LuaBindingFlags); if (members.Length != 0) { member = members[0]; #if DEBUG if (!(members.Length == 1 || member is MethodBase)) // todo { return(luaL.error(L, "Overloads for members other than methods are not implemented.")); } #endif } } object value = null; switch (member == null ? MemberTypes.All : member.MemberType) { default: // not found or found a constructor // kevinh - we want to throw an error because merely returning 'nil' in this case // is not sufficient. valid data members may return nil and therefore there must be some // way to know the member just doesn't exist. return(luaL.error(L, string.Format("'{0}' does not contain a definition for '{1}'", objType.UnderlyingSystemType.FullName, methodName))); case MemberTypes.Method: var wrapper = new lua.CFunction((new LuaMethodWrapper(translator, objType, methodName, bindingType)).call); if (cachedMember == null) { setMemberCache(objType, methodName, wrapper); } luaclr.pushcfunction(L, wrapper); lua.pushboolean(L, true); return(2); case MemberTypes.Field: if (!translator.memberIsAllowed(member)) { return(luaL.error(L, "field read failed (access denied)")); } try { value = ((FieldInfo)member).GetValue(obj); } catch { goto default; } translator.push(L, value); break; case MemberTypes.Property: // todo: support indexed properties if (!translator.memberIsAllowed(member)) { return(luaL.error(L, "property call failed (access denied)")); } try { value = ((PropertyInfo)member).GetValue(obj, null); } catch (TargetInvocationException ex) { return(translator.throwError(L, luaclr.verifyex(ex.InnerException))); } catch { goto default; } translator.push(L, value); break; case MemberTypes.Event: if (!translator.memberIsAllowed(member)) { return(luaL.error(L, "event read failed (access denied)")); } value = new RegisterEventHandler(translator.pendingEvents, obj, (EventInfo)member); translator.push(L, value); break; case MemberTypes.NestedType: var nestedType = (Type)member; if (translator.FindType(nestedType)) // don't hand out class references unless loaded/whitelisted { ObjectTranslator.pushType(L, nestedType); } else { lua.pushnil(L); } break; } if (cachedMember == null) { setMemberCache(objType, methodName, member); } // push false because we are NOT returning a function (see luaIndexFunction) lua.pushboolean(L, false); return(2); }
private int getMember(IntPtr luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType) { bool flag = false; MemberInfo member = null; object obj2 = this.checkMemberCache(this.memberCache, objType, methodName); if (obj2 is LuaCSFunction) { this.translator.pushFunction(luaState, (LuaCSFunction) obj2); this.translator.push(luaState, true); return 2; } if (obj2 != null) { member = (MemberInfo) obj2; } else { MemberInfo[] infoArray = objType.GetMember(methodName, (bindingType | BindingFlags.Public) | BindingFlags.IgnoreCase); if (infoArray.Length > 0) { member = infoArray[0]; } else { infoArray = objType.GetMember(methodName, ((bindingType | BindingFlags.Static) | BindingFlags.Public) | BindingFlags.IgnoreCase); if (infoArray.Length > 0) { member = infoArray[0]; flag = true; } } } if (member != null) { if (member.MemberType == MemberTypes.Field) { FieldInfo info2 = (FieldInfo) member; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, member); } try { this.translator.push(luaState, info2.GetValue(obj)); } catch { LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Property) { PropertyInfo info3 = (PropertyInfo) member; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, member); } try { object o = info3.GetValue(obj, null); this.translator.push(luaState, o); } catch (ArgumentException) { if ((objType is Type) && (((Type) objType) != typeof(object))) { return this.getMember(luaState, ((Type) objType).BaseType, obj, methodName, bindingType); } LuaDLL.lua_pushnil(luaState); } catch (TargetInvocationException exception) { this.ThrowError(luaState, exception); LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Event) { EventInfo eventInfo = (EventInfo) member; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, member); } this.translator.push(luaState, new RegisterEventHandler(this.translator.pendingEvents, obj, eventInfo)); } else if (!flag) { if (member.MemberType != MemberTypes.NestedType) { LuaCSFunction function = new LuaCSFunction(new LuaMethodWrapper(this.translator, objType, methodName, bindingType).call); if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, function); } this.translator.pushFunction(luaState, function); this.translator.push(luaState, true); return 2; } if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, member); } string name = member.Name; string className = member.DeclaringType.FullName + "+" + name; Type t = this.translator.FindType(className); this.translator.pushType(luaState, t); } else { this.translator.throwError(luaState, "can't pass instance to static method " + methodName); LuaDLL.lua_pushnil(luaState); } } else { this.translator.throwError(luaState, "unknown member name " + methodName); LuaDLL.lua_pushnil(luaState); } this.translator.push(luaState, false); return 2; }
/* * Writes to fields or properties, either static or instance. Throws an error * if the operation is invalid. */ private int setMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType) { string fieldName = LuaDLL.lua_tostring(luaState, 2); if (fieldName == null) { translator.throwError(luaState, "field or property does not exist"); return 0; } MemberInfo member = (MemberInfo)checkMemberCache(memberCache, targetType, fieldName); if (member == null) { MemberInfo[] members = targetType.GetMember(fieldName, bindingType | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) { member = members[0]; setMemberCache(memberCache, targetType, fieldName, member); } else { translator.throwError(luaState, "field or property does not exist"); return 0; } } if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; object val = translator.getAsType(luaState, 3, field.FieldType); try { field.SetValue(target, val); } catch (Exception e) { translator.throwError(luaState, e); } return 0; } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; object val = translator.getAsType(luaState, 3, property.PropertyType); try { property.SetValue(target, val, null); } catch (Exception e) { translator.throwError(luaState, e); } return 0; } translator.throwError(luaState, "field or property does not exist"); return 0; }
/// <summary> /// Does this method exist as either an instance or static? /// </summary> /// <param name="objType"></param> /// <param name="methodName"></param> /// <returns></returns> bool isMemberPresent(IReflect objType, string methodName) { object cachedMember = checkMemberCache(memberCache, objType, methodName); if (cachedMember != null) return true; MemberInfo[] members = objType.GetMember(methodName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return (members.Length > 0); }
/* * Pushes the value of a member or a delegate to call it, depending on the type of * the member. Works with static or instance members. * Uses reflection to find members, and stores the reflected MemberInfo object in * a cache (indexed by the type of the object and the name of the member). */ private int getMember(KopiLua.Lua.lua_State luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType) { bool implicitStatic = false; MemberInfo member = null; object cachedMember = checkMemberCache(memberCache, objType, methodName); //object cachedMember=null; if (cachedMember is KopiLua.Lua.lua_CFunction) { translator.pushFunction(luaState, (KopiLua.Lua.lua_CFunction)cachedMember); translator.push(luaState, true); return(2); } else if (cachedMember != null) { member = (MemberInfo)cachedMember; } else { MemberInfo[] members = objType.GetMember(methodName, bindingType | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) { member = members[0]; } else { // If we can't find any suitable instance members, try to find them as statics - but we only want to allow implicit static // lookups for fields/properties/events -kevinh members = objType.GetMember(methodName, bindingType | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) { member = members[0]; implicitStatic = true; } } } if (member != null) { if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; if (cachedMember == null) { setMemberCache(memberCache, objType, methodName, member); } try { translator.push(luaState, field.GetValue(obj)); } catch { LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; if (cachedMember == null) { setMemberCache(memberCache, objType, methodName, member); } try { object val = property.GetValue(obj, null); translator.push(luaState, val); } catch (ArgumentException) { // If we can't find the getter in our class, recurse up to the base class and see // if they can help. if (objType is Type && !(((Type)objType) == typeof(object))) { return(getMember(luaState, ((Type)objType).BaseType, obj, methodName, bindingType)); } else { LuaDLL.lua_pushnil(luaState); } } catch (TargetInvocationException e) // Convert this exception into a Lua error { ThrowError(luaState, e); LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Event) { EventInfo eventInfo = (EventInfo)member; if (cachedMember == null) { setMemberCache(memberCache, objType, methodName, member); } translator.push(luaState, new RegisterEventHandler(translator.pendingEvents, obj, eventInfo)); } else if (!implicitStatic) { if (member.MemberType == MemberTypes.NestedType) { // kevinh - added support for finding nested types // cache us if (cachedMember == null) { setMemberCache(memberCache, objType, methodName, member); } // Find the name of our class string name = member.Name; Type dectype = member.DeclaringType; // Build a new long name and try to find the type by name string longname = dectype.FullName + "+" + name; Type nestedType = translator.FindType(longname); translator.pushType(luaState, nestedType); } else { // Member type must be 'method' KopiLua.Lua.lua_CFunction wrapper = new KopiLua.Lua.lua_CFunction((new LuaMethodWrapper(translator, objType, methodName, bindingType)).call); if (cachedMember == null) { setMemberCache(memberCache, objType, methodName, wrapper); } translator.pushFunction(luaState, wrapper); translator.push(luaState, true); return(2); } } else { // If we reach this point we found a static method, but can't use it in this context because the user passed in an instance translator.throwError(luaState, "can't pass instance to static method " + methodName); LuaDLL.lua_pushnil(luaState); } } else { // kevinh - we want to throw an exception because meerly returning 'nil' in this case // is not sufficient. valid data members may return nil and therefore there must be some // way to know the member just doesn't exist. translator.throwError(luaState, "unknown member name " + methodName); LuaDLL.lua_pushnil(luaState); } // push false because we are NOT returning a function (see luaIndexFunction) translator.push(luaState, false); return(2); }
MemberInfo[] IReflect.GetMember(string name, BindingFlags bindingAttr) => publicIReflect.GetMember(name, bindingAttr);
MemberInfo[] IReflect.GetMember(string name, BindingFlags bindingAttr) { return(publicIReflect.GetMember(name, bindingAttr)); }
private MethodBase[] GetMethodsByName(Type objType, IReflect objIReflect, string name, BindingFlags invokeAttr) { int num3; MemberInfo[] nonGenericMembers = LateBinding.GetNonGenericMembers(objIReflect.GetMember(name, invokeAttr)); if (nonGenericMembers == null) { return null; } int upperBound = nonGenericMembers.GetUpperBound(0); for (int i = 0; i <= upperBound; i++) { MemberInfo info = nonGenericMembers[i]; if (info != null) { Type declaringType; if (info.MemberType == MemberTypes.Field) { declaringType = info.DeclaringType; int num12 = nonGenericMembers.GetUpperBound(0); for (int k = 0; k <= num12; k++) { if (((i != k) && (nonGenericMembers[k] != null)) && declaringType.IsSubclassOf(nonGenericMembers[k].DeclaringType)) { nonGenericMembers[k] = null; num3++; } } } else { MethodInfo getMethod; if (info.MemberType == MemberTypes.Method) { getMethod = (MethodInfo) info; if (!getMethod.IsHideBySig && ((!getMethod.IsVirtual || (getMethod.IsVirtual && ((getMethod.Attributes & MethodAttributes.NewSlot) != MethodAttributes.PrivateScope))) || (getMethod.IsVirtual && ((getMethod.GetBaseDefinition().Attributes & MethodAttributes.NewSlot) != MethodAttributes.PrivateScope)))) { declaringType = info.DeclaringType; int num13 = nonGenericMembers.GetUpperBound(0); for (int m = 0; m <= num13; m++) { if (((i != m) && (nonGenericMembers[m] != null)) && declaringType.IsSubclassOf(nonGenericMembers[m].DeclaringType)) { nonGenericMembers[m] = null; num3++; } } } } else if (info.MemberType == MemberTypes.Property) { PropertyInfo info3 = (PropertyInfo) info; int num7 = 1; do { if (num7 == 1) { getMethod = info3.GetGetMethod(); } else { getMethod = info3.GetSetMethod(); } if (((getMethod != null) && !getMethod.IsHideBySig) && (!getMethod.IsVirtual || (getMethod.IsVirtual && ((getMethod.Attributes & MethodAttributes.NewSlot) != MethodAttributes.PrivateScope)))) { declaringType = info.DeclaringType; int num14 = nonGenericMembers.GetUpperBound(0); for (int n = 0; n <= num14; n++) { if (((i != n) && (nonGenericMembers[n] != null)) && declaringType.IsSubclassOf(nonGenericMembers[n].DeclaringType)) { nonGenericMembers[n] = null; num3++; } } } num7++; } while (num7 <= 2); if ((invokeAttr & BindingFlags.GetProperty) != BindingFlags.Default) { getMethod = info3.GetGetMethod(); } else if ((invokeAttr & BindingFlags.SetProperty) != BindingFlags.Default) { getMethod = info3.GetSetMethod(); } else { getMethod = null; } if (getMethod == null) { num3++; } nonGenericMembers[i] = getMethod; } else if (info.MemberType == MemberTypes.NestedType) { declaringType = info.DeclaringType; int num15 = nonGenericMembers.GetUpperBound(0); for (int num9 = 0; num9 <= num15; num9++) { if (((i != num9) && (nonGenericMembers[num9] != null)) && declaringType.IsSubclassOf(nonGenericMembers[num9].DeclaringType)) { nonGenericMembers[num9] = null; num3++; } } if (num3 == (nonGenericMembers.Length - 1)) { throw new ArgumentException(Utils.GetResourceString("Argument_IllegalNestedType2", new string[] { name, Utils.VBFriendlyName(objType) })); } nonGenericMembers[i] = null; num3++; } } } } int num2 = nonGenericMembers.Length - num3; MethodBase[] baseArray2 = new MethodBase[(num2 - 1) + 1]; int index = 0; int num16 = nonGenericMembers.Length - 1; for (int j = 0; j <= num16; j++) { if (nonGenericMembers[j] != null) { baseArray2[index] = (MethodBase) nonGenericMembers[j]; index++; } } return baseArray2; }
private static MemberInfo[] GetDefaultMembers(Type typ, IReflect objIReflect, ref string DefaultName) { MemberInfo[] nonGenericMembers; if (typ == objIReflect) { do { object[] customAttributes = typ.GetCustomAttributes(typeof(DefaultMemberAttribute), false); if ((customAttributes != null) && (customAttributes.Length != 0)) { DefaultName = ((DefaultMemberAttribute) customAttributes[0]).MemberName; nonGenericMembers = GetNonGenericMembers(typ.GetMember(DefaultName, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase)); if ((nonGenericMembers != null) && (nonGenericMembers.Length != 0)) { return nonGenericMembers; } DefaultName = ""; return null; } typ = typ.BaseType; } while (typ != null); DefaultName = ""; return null; } nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember("", BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase)); if ((nonGenericMembers == null) || (nonGenericMembers.Length == 0)) { DefaultName = ""; return null; } DefaultName = nonGenericMembers[0].Name; return nonGenericMembers; }
private int getMember(IntPtr luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType) { bool flag = false; MemberInfo memberInfo = null; object obj2 = this.checkMemberCache(this.memberCache, objType, methodName); if (obj2 is LuaCSFunction) { this.translator.pushFunction(luaState, (LuaCSFunction)obj2); this.translator.push(luaState, true); return(2); } if (obj2 != null) { memberInfo = (MemberInfo)obj2; } else { MemberInfo[] member = objType.GetMember(methodName, bindingType | 16 | 1); if (member.Length > 0) { memberInfo = member[0]; } else { member = objType.GetMember(methodName, bindingType | 8 | 16 | 1); if (member.Length > 0) { memberInfo = member[0]; flag = true; } } } if (memberInfo != null) { if (memberInfo.get_MemberType() == 4) { FieldInfo fieldInfo = (FieldInfo)memberInfo; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, memberInfo); } try { this.translator.push(luaState, fieldInfo.GetValue(obj)); } catch { LuaDLL.lua_pushnil(luaState); } } else if (memberInfo.get_MemberType() == 16) { PropertyInfo propertyInfo = (PropertyInfo)memberInfo; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, memberInfo); } try { object o = propertyInfo.GetGetMethod().Invoke(obj, null); this.translator.push(luaState, o); } catch (ArgumentException) { if (objType is Type && (Type)objType != typeof(object)) { return(this.getMember(luaState, ((Type)objType).get_BaseType(), obj, methodName, bindingType)); } LuaDLL.lua_pushnil(luaState); } catch (TargetInvocationException e) { this.ThrowError(luaState, e); LuaDLL.lua_pushnil(luaState); } } else if (memberInfo.get_MemberType() == 2) { EventInfo eventInfo = (EventInfo)memberInfo; if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, memberInfo); } this.translator.push(luaState, new RegisterEventHandler(this.translator.pendingEvents, obj, eventInfo)); } else if (!flag) { if (memberInfo.get_MemberType() != 128) { LuaCSFunction luaCSFunction = new LuaCSFunction(new LuaMethodWrapper(this.translator, objType, methodName, bindingType).call); if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, luaCSFunction); } this.translator.pushFunction(luaState, luaCSFunction); this.translator.push(luaState, true); return(2); } if (obj2 == null) { this.setMemberCache(this.memberCache, objType, methodName, memberInfo); } string name = memberInfo.get_Name(); Type declaringType = memberInfo.get_DeclaringType(); string className = declaringType.get_FullName() + "+" + name; Type t = this.translator.FindType(className); this.translator.pushType(luaState, t); } else { this.translator.throwError(luaState, "can't pass instance to static method " + methodName); LuaDLL.lua_pushnil(luaState); } } else { this.translator.throwError(luaState, "unknown member name " + methodName); LuaDLL.lua_pushnil(luaState); } this.translator.push(luaState, false); return(2); }
private bool isMemberPresent(IReflect objType, string methodName) { return((this.checkMemberCache(this.memberCache, objType, methodName) != null) || (objType.GetMember(methodName, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase).Length > 0)); }
MemberInfo[] IReflect.GetMember(string name, BindingFlags bindingAttr) { var ret = typeIReflectImplementation.GetMember(name, bindingAttr); return(ret); }
private bool trySetMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { detailMessage = null; if (LuaDLL.lua_type(luaState, 2) != LuaTypes.LUA_TSTRING) { detailMessage = "property names must be strings"; return false; } string memberName = LuaDLL.lua_tostring(luaState, 2); if (((memberName == null) || (memberName.Length < 1)) || (!char.IsLetter(memberName[0]) && (memberName[0] != '_'))) { detailMessage = "invalid property name"; return false; } MemberInfo member = (MemberInfo) this.checkMemberCache(this.memberCache, targetType, memberName); if (member == null) { MemberInfo[] infoArray = targetType.GetMember(memberName, (bindingType | BindingFlags.Public) | BindingFlags.IgnoreCase); if (infoArray.Length <= 0) { detailMessage = "field or property '" + memberName + "' does not exist"; return false; } member = infoArray[0]; this.setMemberCache(this.memberCache, targetType, memberName, member); } if (member.MemberType == MemberTypes.Field) { FieldInfo info2 = (FieldInfo) member; object obj2 = this.translator.getAsType(luaState, 3, info2.FieldType); try { info2.SetValue(target, obj2); } catch (Exception exception) { this.ThrowError(luaState, exception); } return true; } if (member.MemberType == MemberTypes.Property) { PropertyInfo info3 = (PropertyInfo) member; object obj3 = this.translator.getAsType(luaState, 3, info3.PropertyType); try { info3.SetValue(target, obj3, null); } catch (Exception exception2) { this.ThrowError(luaState, exception2); } return true; } detailMessage = "'" + memberName + "' is not a .net field or property"; return false; }
private bool isMemberPresent(IReflect objType, string methodName) { return ((this.checkMemberCache(this.memberCache, objType, methodName) != null) || (objType.GetMember(methodName, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase).Length > 0)); }
/// <summary>[-0, +0, e] /// Tries to set a named property or field. /// Returns false if unable to find the named member, true for success /// </summary> /// <exception cref="ArgumentNullException"><paramref name="targetType"/> is required</exception> bool trySetMember(lua.State L, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { Debug.Assert(interpreter.IsSameLua(L)); Debug.Assert(targetType != null); Debug.Assert((target == null) == ((bindingType & BindingFlags.Static) == BindingFlags.Static)); Debug.Assert((target == null) != ((bindingType & BindingFlags.Instance) == BindingFlags.Instance)); detailMessage = null; // No error yet // If not already a string just return - we don't want to call tostring - which has the side effect of // changing the lua typecode to string // Note: We don't use isstring because the standard lua C isstring considers either strings or numbers to // be true for isstring. if (lua.type(L, 2) != LUA.T.STRING) { detailMessage = "member names must be strings"; return(false); } // We only look up property names by string string fieldName = lua.tostring(L, 2); if (fieldName.Length == 0 || !(Char.IsLetter(fieldName[0]) || fieldName[0] == '_')) { detailMessage = "invalid member name"; return(false); } // Find our member via reflection or the cache MemberInfo member = checkMemberCache(targetType, fieldName) as MemberInfo; if (member == null) { MemberInfo[] members = targetType.GetMember(fieldName, bindingType | luanet.LuaBindingFlags); if (members.Length == 0) { detailMessage = "member '" + fieldName + "' does not exist"; return(false); } member = members[0]; if (!(member is MethodBase)) { Debug.Assert(members.Length == 1); // todo: support other overloads setMemberCache(targetType, fieldName, member); } } object val; switch (member.MemberType) { case MemberTypes.Field: if (!translator.memberIsAllowed(member)) { luaL.error(L, "field write failed (access denied)"); } var field = (FieldInfo)member; val = translator.getAsType(L, 3, field.FieldType); try { field.SetValue(target, val); return(true); } catch (Exception ex) { detailMessage = "field write failed (" + ex.Message + ")"; return(false); } case MemberTypes.Property: if (!translator.memberIsAllowed(member)) { luaL.error(L, "property setter call failed (access denied)"); } PropertyInfo property = (PropertyInfo)member; val = translator.getAsType(L, 3, property.PropertyType); try { property.SetValue(target, val, null); return(true); } catch (TargetInvocationException ex) { translator.throwError(L, luaclr.verifyex(ex.InnerException)); return(false); // never returns } catch (Exception ex) { detailMessage = "property setter call failed (" + ex.Message + ")"; return(false); } default: detailMessage = "'" + fieldName + "' is not a CLR field or property"; return(false); } }
private static MethodInfo GetToXXXXMethod(IReflect ir, Type desiredType, bool explicitOK){ if ((ir is TypeBuilder) || (ir is EnumBuilder)) return null; MemberInfo[] members = ir.GetMember(explicitOK ? "op_Explicit" : "op_Implicit", BindingFlags.Public|BindingFlags.Static); if (members != null) foreach(MemberInfo mem in members) if (mem is MethodInfo) if (((MethodInfo)mem).ReturnType == desiredType) return (MethodInfo)mem; return null; }
private static MemberInfo GetMostDerivedMemberInfo(IReflect objIReflect, string name, BindingFlags flags) { MemberInfo[] nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember(name, flags)); if ((nonGenericMembers == null) || (nonGenericMembers.Length == 0)) { return null; } MemberInfo info2 = nonGenericMembers[0]; int upperBound = nonGenericMembers.GetUpperBound(0); for (int i = 1; i <= upperBound; i++) { if (nonGenericMembers[i].DeclaringType.IsSubclassOf(info2.DeclaringType)) { info2 = nonGenericMembers[i]; } } return info2; }
/// <summary> /// Tries to set a named property or field /// </summary> /// <param name="luaState"></param> /// <param name="targetType"></param> /// <param name="target"></param> /// <param name="bindingType"></param> /// <returns>false if unable to find the named member, true for success</returns> private bool TrySetMember (LuaState luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { detailMessage = null; // No error yet // If not already a string just return - we don't want to call tostring - which has the side effect of // changing the lua typecode to string // Note: We don't use isstring because the standard lua C isstring considers either strings or numbers to // be true for isstring. if (LuaLib.LuaType (luaState, 2) != LuaTypes.String) { detailMessage = "property names must be strings"; return false; } // We only look up property names by string string fieldName = LuaLib.LuaToString (luaState, 2).ToString (); if (fieldName == null || fieldName.Length < 1 || !(char.IsLetter (fieldName [0]) || fieldName [0] == '_')) { detailMessage = "invalid property name"; return false; } // Find our member via reflection or the cache var member = (MemberInfo)CheckMemberCache (memberCache, targetType, fieldName); if (member == null) { var members = targetType.GetMember (fieldName, bindingType | BindingFlags.Public); if (members.Length > 0) { member = members [0]; SetMemberCache (memberCache, targetType, fieldName, member); } else { detailMessage = "field or property '" + fieldName + "' does not exist"; return false; } } if (member.MemberType == MemberTypes.Field) { var field = (FieldInfo)member; object val = translator.GetAsType (luaState, 3, field.FieldType); try { field.SetValue (target, val); } catch (Exception e) { ThrowError (luaState, e); } // We did a call return true; } else if (member.MemberType == MemberTypes.Property) { var property = (PropertyInfo)member; object val = translator.GetAsType (luaState, 3, property.PropertyType); try { property.SetValue (target, val, null); } catch (Exception e) { ThrowError (luaState, e); } // We did a call return true; } detailMessage = "'" + fieldName + "' is not a .net field or property"; return false; }
/// <summary> /// Does this method exist as either an instance or static? /// </summary> /// <param name="objType"></param> /// <param name="methodName"></param> /// <returns></returns> bool IsMemberPresent (IReflect objType, string methodName) { object cachedMember = CheckMemberCache (memberCache, objType, methodName); if (cachedMember != null) return true; //CP: Removed NonPublic binding search var members = objType.GetMember (methodName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase); return (members.Length > 0); }
/// <summary>Tries to set a named property or field</summary> /// <returns>false if unable to find the named member, true for success</returns> bool trySetMember(lua.State L, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { Debug.Assert(translator.interpreter.IsSameLua(L)); Debug.Assert(targetType != null); detailMessage = null; // No error yet // If not already a string just return - we don't want to call tostring - which has the side effect of // changing the lua typecode to string // Note: We don't use isstring because the standard lua C isstring considers either strings or numbers to // be true for isstring. if (lua.type(L, 2) != LUA.T.STRING) { detailMessage = "member names must be strings"; return(false); } // We only look up property names by string string fieldName = lua.tostring(L, 2); if (fieldName.Length == 0 || !(Char.IsLetter(fieldName[0]) || fieldName[0] == '_')) { detailMessage = "invalid member name"; return(false); } // Find our member via reflection or the cache MemberInfo member = checkMemberCache(targetType, fieldName) as MemberInfo; if (member == null) { MemberInfo[] members = targetType.GetMember(fieldName, bindingType | luanet.LuaBindingFlags); if (members.Length > 0) { member = members[0]; setMemberCache(targetType, fieldName, member); } else { detailMessage = "member '" + fieldName + "' does not exist"; return(false); } } object val; switch (member.MemberType) { case MemberTypes.Field: FieldInfo field = (FieldInfo)member; val = translator.getAsType(L, 3, field.FieldType); try { field.SetValue(target, val); } catch (Exception e) { ThrowError(L, e); } // We did a call return(true); case MemberTypes.Property: PropertyInfo property = (PropertyInfo)member; val = translator.getAsType(L, 3, property.PropertyType); try { property.SetValue(target, val, null); } catch (Exception e) { ThrowError(L, e); } // We did a call return(true); default: detailMessage = "'" + fieldName + "' is not a .net field or property"; return(false); } }
private void BindName(JSField inferenceTarget) { MemberInfo[] members = null; this.rootObject = this.rootObject.PartiallyEvaluate(); IReflect obType = this.rootObjectInferredType = this.rootObject.InferType(inferenceTarget); if (this.rootObject is ConstantWrapper) { Object ob = Convert.ToObject2(this.rootObject.Evaluate(), this.Engine); if (ob == null) { this.rootObject.context.HandleError(JSError.ObjectExpected); return; } ClassScope csc = ob as ClassScope; Type t = ob as Type; if (csc != null || t != null) { //object is a type. Look for static members on the type only. If none are found, look for instance members on type Type. if (csc != null) { this.members = members = csc.GetMember(this.name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly); } else { this.members = members = t.GetMember(this.name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly); } if (members.Length > 0) { return; //found a binding } //Look for instance members on type Type this.members = members = Typeob.Type.GetMember(this.name, BindingFlags.Public | BindingFlags.Instance); return; } Namespace ns = ob as Namespace; if (ns != null) { String fullname = ns.Name + "." + this.name; csc = this.Engine.GetClass(fullname); if (csc != null) { FieldAttributes attrs = FieldAttributes.Literal; if ((csc.owner.attributes & TypeAttributes.Public) == 0) { attrs |= FieldAttributes.Private; } this.members = new MemberInfo[] { new JSGlobalField(null, this.name, csc, attrs) }; return; } else { t = this.Engine.GetType(fullname); if (t != null) { this.members = new MemberInfo[] { t }; return; } } } else if (ob is MathObject || ob is ScriptFunction && !(ob is FunctionObject)) //It is a built in constructor function { obType = (IReflect)ob; } } obType = this.ProvideWrapperForPrototypeProperties(obType); //Give up and go late bound if not enough is known about the object at compile time. if (obType == Typeob.Object && !this.isNonVirtual) //The latter provides for super in classes that extend System.Object { this.members = new MemberInfo[0]; return; } Type ty = obType as Type; //Interfaces are weird, call a helper if (ty != null && ty.IsInterface) { this.members = JSBinder.GetInterfaceMembers(this.name, ty); return; } ClassScope cs = obType as ClassScope; if (cs != null && cs.owner.isInterface) { this.members = cs.owner.GetInterfaceMember(this.name); return; } //Now run up the inheritance chain until a member is found while (obType != null) { cs = obType as ClassScope; if (cs != null) { //The FlattenHierachy flag here tells ClassScope to add in any overloads found on base classes members = this.members = obType.GetMember(this.name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.FlattenHierarchy); if (members.Length > 0) { return; } obType = cs.GetSuperType(); continue; } ty = obType as Type; if (ty == null) //Dealing with the global scope via the this literal or with a built in object in fast mode { this.members = obType.GetMember(this.name, BindingFlags.Public | BindingFlags.Instance); return; } members = this.members = ty.GetMember(this.name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (members.Length > 0) { MemberInfo mem = LateBinding.SelectMember(members); if (mem == null) { //Found a method or methods. Need to add any overloads found in base classes. //Do another lookup, this time with the DeclaredOnly flag cleared and asking only for methods members = this.members = ty.GetMember(this.name, MemberTypes.Method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (members.Length == 0) //Dealing with an indexed property, ask again { this.members = ty.GetMember(this.name, MemberTypes.Property, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); } } return; } obType = ty.BaseType; } }
/// <summary> /// Tries to set a named property or field /// </summary> /// <param name="luaState"></param> /// <param name="targetType"></param> /// <param name="target"></param> /// <param name="bindingType"></param> /// <returns>false if unable to find the named member, true for success</returns> private bool trySetMember(KopiLua.Lua.lua_State luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) { detailMessage = null; // No error yet // If not already a string just return - we don't want to call tostring - which has the side effect of // changing the lua typecode to string // Note: We don't use isstring because the standard lua C isstring considers either strings or numbers to // be true for isstring. if (LuaDLL.lua_type(luaState, 2) != LuaTypes.LUA_TSTRING) { detailMessage = "property names must be strings"; return(false); } // We only look up property names by string string fieldName = LuaDLL.lua_tostring(luaState, 2); if (fieldName == null || fieldName.Length < 1 || !(char.IsLetter(fieldName[0]) || fieldName[0] == '_')) { detailMessage = "invalid property name"; return(false); } // Find our member via reflection or the cache MemberInfo member = (MemberInfo)checkMemberCache(memberCache, targetType, fieldName); if (member == null) { MemberInfo[] members = targetType.GetMember(fieldName, bindingType | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) { member = members[0]; setMemberCache(memberCache, targetType, fieldName, member); } else { detailMessage = "field or property '" + fieldName + "' does not exist"; return(false); } } if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; object val = translator.getAsType(luaState, 3, field.FieldType); try { field.SetValue(target, val); } catch (Exception e) { ThrowError(luaState, e); } // We did a call return(true); } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; object val = translator.getAsType(luaState, 3, property.PropertyType); try { property.SetValue(target, val, null); } catch (Exception e) { ThrowError(luaState, e); } // We did a call return(true); } detailMessage = "'" + fieldName + "' is not a .net field or property"; return(false); }
private static MemberInfo[] GetMembersByName(IReflect objIReflect, string name, BindingFlags flags) { MemberInfo[] nonGenericMembers = GetNonGenericMembers(objIReflect.GetMember(name, flags)); if ((nonGenericMembers != null) && (nonGenericMembers.Length == 0)) { return null; } return nonGenericMembers; }
/* * Pushes the value of a member or a delegate to call it, depending on the type of * the member. Works with static or instance members. * Uses reflection to find members, and stores the reflected MemberInfo object in * a cache (indexed by the type of the object and the name of the member). */ private int getMember(IntPtr luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType) { bool implicitStatic = false; MemberInfo member = null; object cachedMember = checkMemberCache(memberCache, objType, methodName); //object cachedMember=null; if (cachedMember is LuaCSFunction) { translator.pushFunction(luaState, (LuaCSFunction)cachedMember); translator.push(luaState, true); return 2; } else if (cachedMember != null) { member = (MemberInfo)cachedMember; } else { MemberInfo[] members = objType.GetMember(methodName, bindingType | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) member = members[0]; else { // If we can't find any suitable instance members, try to find them as statics - but we only want to allow implicit static // lookups for fields/properties/events -kevinh members = objType.GetMember(methodName, bindingType | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (members.Length > 0) { member = members[0]; implicitStatic = true; } } } if (member != null) { if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; if (cachedMember == null) setMemberCache(memberCache, objType, methodName, member); try { translator.push(luaState, field.GetValue(obj)); } catch { LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; if (cachedMember == null) setMemberCache(memberCache, objType, methodName, member); try { object val = property.GetValue(obj, null); translator.push(luaState, val); } catch (ArgumentException) { // If we can't find the getter in our class, recurse up to the base class and see // if they can help. if (objType is Type && !(((Type)objType) == typeof(object))) return getMember(luaState, ((Type)objType).BaseType, obj, methodName, bindingType); else LuaDLL.lua_pushnil(luaState); } catch { LuaDLL.lua_pushnil(luaState); } } else if (member.MemberType == MemberTypes.Event) { EventInfo eventInfo = (EventInfo)member; if (cachedMember == null) setMemberCache(memberCache, objType, methodName, member); translator.push(luaState, new RegisterEventHandler(translator.pendingEvents, obj, eventInfo)); } else if(!implicitStatic) { if (member.MemberType == MemberTypes.NestedType) { // kevinh - added support for finding nested types // cache us if (cachedMember == null) setMemberCache(memberCache, objType, methodName, member); // Find the name of our class string name = member.Name; Type dectype = member.DeclaringType; // Build a new long name and try to find the type by name string longname = dectype.FullName + "+" + name; Type nestedType = translator.FindType(longname); translator.pushType(luaState, nestedType); } else { // Member type must be 'method' LuaCSFunction wrapper = new LuaCSFunction((new LuaMethodWrapper(translator, objType, methodName, bindingType)).call); if (cachedMember == null) setMemberCache(memberCache, objType, methodName, wrapper); translator.pushFunction(luaState, wrapper); translator.push(luaState, true); return 2; } } else { // If we reach this point we found a static method, but can't use it in this context because the user passed in an instance translator.throwError(luaState, "can't pass instance to static method " + methodName); LuaDLL.lua_pushnil(luaState); } } else { // kevinh - we want to throw an exception because meerly returning 'nil' in this case // is not sufficient. valid data members may return nil and therefore there must be some // way to know the member just doesn't exist. translator.throwError(luaState, "unknown member name " + methodName); LuaDLL.lua_pushnil(luaState); } // push false because we are NOT returning a function (see luaIndexFunction) translator.push(luaState, false); return 2; }
private static MethodInfo GetToXXXXMethod(IReflect ir, Type desiredType, bool explicitOK) { if (!(ir is TypeBuilder) && !(ir is EnumBuilder)) { MemberInfo[] member = ir.GetMember(explicitOK ? "op_Explicit" : "op_Implicit", BindingFlags.Public | BindingFlags.Static); if (member != null) { foreach (MemberInfo info in member) { if ((info is MethodInfo) && (((MethodInfo) info).ReturnType == desiredType)) { return (MethodInfo) info; } } } } return null; }
System.Reflection.MemberInfo[] IReflect.GetMember(string name, System.Reflection.BindingFlags bindingAttr) { return(typeIReflectImplementation.GetMember(name, bindingAttr)); }
private void BindName(JSField inferenceTarget) { MemberInfo[] mems = null; this.rootObject = this.rootObject.PartiallyEvaluate(); IReflect obType = this.rootObjectInferredType = this.rootObject.InferType(inferenceTarget); if (this.rootObject is ConstantWrapper) { object obj2 = Microsoft.JScript.Convert.ToObject2(this.rootObject.Evaluate(), base.Engine); if (obj2 == null) { this.rootObject.context.HandleError(JSError.ObjectExpected); return; } ClassScope scope = obj2 as ClassScope; Type type = obj2 as Type; if ((scope != null) || (type != null)) { if (scope != null) { base.members = mems = scope.GetMember(base.name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly); } else { base.members = mems = type.GetMember(base.name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly); } if (mems.Length <= 0) { base.members = mems = Typeob.Type.GetMember(base.name, BindingFlags.Public | BindingFlags.Instance); } return; } Namespace namespace2 = obj2 as Namespace; if (namespace2 != null) { string className = namespace2.Name + "." + base.name; scope = base.Engine.GetClass(className); if (scope != null) { FieldAttributes literal = FieldAttributes.Literal; if ((scope.owner.attributes & TypeAttributes.Public) == TypeAttributes.AnsiClass) { literal |= FieldAttributes.Private; } base.members = new MemberInfo[] { new JSGlobalField(null, base.name, scope, literal) }; return; } type = base.Engine.GetType(className); if (type != null) { base.members = new MemberInfo[] { type }; return; } } else if ((obj2 is MathObject) || ((obj2 is ScriptFunction) && !(obj2 is FunctionObject))) { obType = (IReflect)obj2; } } obType = this.ProvideWrapperForPrototypeProperties(obType); if ((obType == Typeob.Object) && !base.isNonVirtual) { base.members = new MemberInfo[0]; } else { Type t = obType as Type; if ((t != null) && t.IsInterface) { base.members = JSBinder.GetInterfaceMembers(base.name, t); } else { ClassScope scope2 = obType as ClassScope; if ((scope2 != null) && scope2.owner.isInterface) { base.members = scope2.owner.GetInterfaceMember(base.name); } else { while (obType != null) { scope2 = obType as ClassScope; if (scope2 != null) { mems = base.members = obType.GetMember(base.name, BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (mems.Length > 0) { return; } obType = scope2.GetSuperType(); } else { t = obType as Type; if (t == null) { base.members = obType.GetMember(base.name, BindingFlags.Public | BindingFlags.Instance); return; } mems = base.members = t.GetMember(base.name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (mems.Length > 0) { if (LateBinding.SelectMember(mems) == null) { mems = base.members = t.GetMember(base.name, MemberTypes.Method, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); if (mems.Length == 0) { base.members = t.GetMember(base.name, MemberTypes.Property, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); } } return; } obType = t.BaseType; } } } } } }