public GetMember ( String name, BindingFlags bindingAttr ) : System.Reflection.MemberInfo[] | ||
name | String | |
bindingAttr | BindingFlags | |
return | System.Reflection.MemberInfo[] |
//Adds a list of classes to result. Superclasses always follow derived classes. internal void AddClassesExcluding(ClassScope excludedClass, String name, ArrayList result) { ArrayList eligibleClasses = new ArrayList(); foreach (MemberInfo member in this.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) { if (member is JSVariableField && ((JSVariableField)member).IsLiteral) { Object val = ((JSVariableField)member).value; if (val is ClassScope) { ClassScope csc = (ClassScope)val; if (csc.name != member.Name) { continue; } if (excludedClass == null || !excludedClass.IsSameOrDerivedFrom(csc)) { if (csc.GetMember(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly).Length > 0) { eligibleClasses.Add(csc); } } } } } if (eligibleClasses.Count == 0) { return; } ClassScope[] classes = new ClassScope[eligibleClasses.Count]; eligibleClasses.CopyTo(classes); Array.Sort(classes); result.AddRange(classes); }
internal object EvaluateAsType() { object memberValue = this.rootObject.EvaluateAsWrappedNamespace(false).GetMemberValue(base.name); if ((memberValue != null) && !(memberValue is Microsoft.JScript.Missing)) { return(memberValue); } object obj3 = null; Member rootObject = this.rootObject as Member; if (rootObject == null) { Lookup lookup = this.rootObject as Lookup; if (lookup == null) { return(null); } ConstantWrapper wrapper = lookup.PartiallyEvaluate() as ConstantWrapper; if (wrapper == null) { JSGlobalField member = lookup.member as JSGlobalField; if ((member == null) || !member.IsLiteral) { return(null); } obj3 = member.value; } else { obj3 = wrapper.value; } } else { obj3 = rootObject.EvaluateAsType(); } ClassScope scope = obj3 as ClassScope; if (scope != null) { MemberInfo[] infoArray = scope.GetMember(base.name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance); if (infoArray.Length != 0) { JSMemberField field2 = infoArray[0] as JSMemberField; if (((field2 != null) && field2.IsLiteral) && ((field2.value is ClassScope) && (field2.IsPublic || field2.IsAccessibleFrom(base.Engine.ScriptObjectStackTop())))) { return(field2.value); } } return(null); } Type type = obj3 as Type; if (type != null) { return(type.GetNestedType(base.name)); } return(null); }
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; } }
internal Object EvaluateAsType() { WrappedNamespace ns = this.rootObject.EvaluateAsWrappedNamespace(false); Object result = ns.GetMemberValue(this.name); if (result != null && !(result is Missing)) { return(result); } Object ob = null; Member root = this.rootObject as Member; if (root == null) { Lookup lookup = this.rootObject as Lookup; if (lookup == null) { return(null); } ob = lookup.PartiallyEvaluate(); ConstantWrapper cw = ob as ConstantWrapper; if (cw != null) { ob = cw.value; } else { JSGlobalField f = lookup.member as JSGlobalField; if (f != null && f.IsLiteral) { ob = f.value; } else { return(null); } } } else { ob = root.EvaluateAsType(); } ClassScope csc = ob as ClassScope; if (csc != null) { MemberInfo[] members = csc.GetMember(this.name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); if (members.Length == 0) { return(null); } JSMemberField field = members[0] as JSMemberField; if (field == null || !field.IsLiteral || !(field.value is ClassScope) || !field.IsPublic && !field.IsAccessibleFrom(this.Engine.ScriptObjectStackTop())) { return(null); } return(field.value); } Type t = ob as Type; if (t != null) { return(t.GetNestedType(this.name)); } return(null); }
internal void AddClassesExcluding(ClassScope excludedClass, string name, ArrayList result) { ArrayList list = new ArrayList(); foreach (MemberInfo info in this.GetMembers(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)) { if ((info is JSVariableField) && ((JSVariableField)info).IsLiteral) { object obj2 = ((JSVariableField)info).value; if (obj2 is ClassScope) { ClassScope other = (ClassScope)obj2; if (((other.name == info.Name) && ((excludedClass == null) || !excludedClass.IsSameOrDerivedFrom(other))) && (other.GetMember(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Length > 0)) { list.Add(other); } } } } if (list.Count != 0) { ClassScope[] array = new ClassScope[list.Count]; list.CopyTo(array); Array.Sort <ClassScope>(array); result.AddRange(array); } }
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; } } } } } }