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