static private GetGetMethod ( |
||
prop | ||
nonPublic | bool | |
return |
public override String ToString() { Type t = this.members[0].DeclaringType; MethodInfo meth = (t == null ? null : t.GetMethod(this.name + " source")); if (meth == null) { StringBuilder result = new StringBuilder(); bool firstTime = true; foreach (MemberInfo mem in this.members) { if (mem is MethodInfo || (mem is PropertyInfo && JSProperty.GetGetMethod((PropertyInfo)mem, false) != null)) { if (!firstTime) { result.Append("\n"); } else { firstTime = false; } result.Append(mem.ToString()); } } if (result.Length > 0) { return(result.ToString()); } return("function " + this.name + "() {\n [native code]\n}"); } return((String)meth.Invoke(null, null)); }
public override string ToString() { Type declaringType = this.members[0].DeclaringType; MethodInfo info = (declaringType == null) ? null : declaringType.GetMethod(base.name + " source"); if (info != null) { return((string)info.Invoke(null, null)); } StringBuilder builder = new StringBuilder(); bool flag = true; foreach (MemberInfo info2 in this.members) { if ((info2 is MethodInfo) || ((info2 is PropertyInfo) && (JSProperty.GetGetMethod((PropertyInfo)info2, false) != null))) { if (!flag) { builder.Append("\n"); } else { flag = false; } builder.Append(info2.ToString()); } } if (builder.Length > 0) { return(builder.ToString()); } return("function " + base.name + "() {\n [native code]\n}"); }
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); }
internal static MethodInfo GetGetMethod(PropertyInfo prop, bool nonPublic) { if (prop != null) { JSProperty property = prop as JSProperty; if (property != null) { return(property.GetGetMethod(nonPublic)); } MethodInfo getMethod = prop.GetGetMethod(nonPublic); if (getMethod != null) { return(getMethod); } Type declaringType = prop.DeclaringType; if (declaringType == null) { return(null); } Type baseType = declaringType.BaseType; if (baseType == null) { return(null); } getMethod = prop.GetGetMethod(nonPublic); if (getMethod == null) { return(null); } BindingFlags @public = BindingFlags.Public; if (getMethod.IsStatic) { @public |= BindingFlags.FlattenHierarchy | BindingFlags.Static; } else { @public |= BindingFlags.Instance; } if (nonPublic) { @public |= BindingFlags.NonPublic; } string name = prop.Name; prop = null; try { prop = baseType.GetProperty(name, @public, null, null, new Type[0], null); } catch (AmbiguousMatchException) { } if (prop != null) { return(GetGetMethod(prop, nonPublic)); } } return(null); }
public override MethodInfo GetGetMethod(bool nonPublic) { MethodInfo meth = JSProperty.GetGetMethod(this.property, nonPublic); if (meth == null) { return(null); } return(new JSWrappedMethod(meth, this.obj)); }
internal static MemberInfo WrapMember(MemberInfo member, Object obj) { switch (member.MemberType) { case MemberTypes.Field: FieldInfo field = (FieldInfo)member; if (field.IsStatic || field.IsLiteral) { return(field); } else if (!(field is JSWrappedField)) { return(new JSWrappedField(field, obj)); } else { return(field); } case MemberTypes.Method: MethodInfo method = (MethodInfo)member; if (method.IsStatic) { return(method); } else if (!(method is JSWrappedMethod)) { return(new JSWrappedMethod(method, obj)); } else { return(method); } case MemberTypes.Property: PropertyInfo property = (PropertyInfo)member; if (property is JSWrappedProperty) { return(property); } MethodInfo getMethod = JSProperty.GetGetMethod(property, true); MethodInfo setMethod = JSProperty.GetSetMethod(property, true); if ((getMethod == null || getMethod.IsStatic) && (setMethod == null || setMethod.IsStatic)) { return(property); } else { return(new JSWrappedProperty(property, obj)); } default: return(member); } }
internal static MemberInfo WrapMember(MemberInfo member, object obj) { MemberTypes memberType = member.MemberType; if (memberType != MemberTypes.Field) { if (memberType != MemberTypes.Method) { if (memberType != MemberTypes.Property) { return(member); } PropertyInfo prop = (PropertyInfo)member; if (prop is JSWrappedProperty) { return(prop); } MethodInfo getMethod = JSProperty.GetGetMethod(prop, true); MethodInfo setMethod = JSProperty.GetSetMethod(prop, true); if (((getMethod == null) || getMethod.IsStatic) && ((setMethod == null) || setMethod.IsStatic)) { return(prop); } return(new JSWrappedProperty(prop, obj)); } } else { FieldInfo field = (FieldInfo)member; if (field.IsStatic || field.IsLiteral) { return(field); } if (field is JSWrappedField) { return(field); } return(new JSWrappedField(field, obj)); } MethodInfo method = (MethodInfo)member; if (method.IsStatic) { return(method); } if (method is JSWrappedMethod) { return(method); } return(new JSWrappedMethod(method, obj)); }
internal override object GetMemberValue(string name) { FieldInfo field = (FieldInfo)this.NameTable[name]; if ((field == null) && this.isASubClass) { field = this.subClassIR.GetField(name, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance); if (field != null) { if (field.DeclaringType == Typeob.ScriptObject) { return(Microsoft.JScript.Missing.Value); } } else { PropertyInfo property = this.subClassIR.GetProperty(name, BindingFlags.Public | BindingFlags.Instance); if ((property != null) && !property.DeclaringType.IsAssignableFrom(Typeob.JSObject)) { return(JSProperty.GetGetMethod(property, false).Invoke(this, BindingFlags.SuppressChangeType, null, null, null)); } try { MethodInfo method = this.subClassIR.GetMethod(name, BindingFlags.Public | BindingFlags.Static); if (method != null) { Type declaringType = method.DeclaringType; if (((declaringType != Typeob.JSObject) && (declaringType != Typeob.ScriptObject)) && (declaringType != Typeob.Object)) { return(new BuiltinFunction(this, method)); } } } catch (AmbiguousMatchException) { } } } if (field != null) { return(field.GetValue(this)); } if (base.parent != null) { return(base.parent.GetMemberValue(name)); } return(Microsoft.JScript.Missing.Value); }
internal override void CheckIfOKToUseInSuperConstructorCall() { FieldInfo member = base.member as FieldInfo; if (member != null) { if (!member.IsStatic) { base.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } } else { MethodInfo getMethod = base.member as MethodInfo; if (getMethod != null) { if (!getMethod.IsStatic) { base.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } } else { PropertyInfo prop = base.member as PropertyInfo; if (prop != null) { getMethod = JSProperty.GetGetMethod(prop, true); if ((getMethod != null) && !getMethod.IsStatic) { base.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } else { getMethod = JSProperty.GetSetMethod(prop, true); if ((getMethod != null) && !getMethod.IsStatic) { base.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } } } } } }
internal override void CheckIfOKToUseInSuperConstructorCall() { FieldInfo f = this.member as FieldInfo; if (f != null) { if (!f.IsStatic) { this.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } return; } MethodInfo m = this.member as MethodInfo; if (m != null) { if (!m.IsStatic) { this.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } return; } PropertyInfo p = this.member as PropertyInfo; if (p != null) { m = JSProperty.GetGetMethod(p, true); if (m != null && !m.IsStatic) { this.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } else { m = JSProperty.GetSetMethod(p, true); if (m != null && !m.IsStatic) { this.context.HandleError(JSError.NotAllowedInSuperConstructorCall); } } } }
internal static Object GetValue(PropertyInfo prop, Object obj, Object[] index) { JSProperty jsprop = prop as JSProperty; if (jsprop != null) { return(jsprop.GetValue(obj, BindingFlags.ExactBinding, null, index, null)); } JSWrappedProperty jswrappedprop = prop as JSWrappedProperty; if (jswrappedprop != null) { return(jswrappedprop.GetValue(obj, BindingFlags.ExactBinding, null, index, null)); } MethodInfo meth = JSProperty.GetGetMethod(prop, false); if (meth != null) { return(meth.Invoke(obj, BindingFlags.ExactBinding, null, index, null)); } throw new MissingMethodException(); }
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); }
public override MemberInfo[] GetMember(string name, BindingFlags bindingAttr) { FieldInfo info = (FieldInfo)base.name_table[name]; if (info != null) { return(new MemberInfo[] { info }); } bool flag = false; ScriptObject parent = base.parent; while (parent is FunctionScope) { FunctionScope scope = (FunctionScope)parent; flag = scope.isMethod && !scope.isStatic; JSLocalField field = (JSLocalField)scope.name_table[name]; if (field == null) { parent = parent.GetParent(); } else { if (field.IsLiteral && !(field.value is FunctionObject)) { return(new MemberInfo[] { field }); } JSLocalField field2 = new JSLocalField(field.Name, this, base.field_table.Count, Microsoft.JScript.Missing.Value) { outerField = field, debugOn = field.debugOn }; if ((!field2.debugOn && this.owner.funcContext.document.debugOn) && scope.owner.funcContext.document.debugOn) { field2.debugOn = Array.IndexOf <string>(scope.owner.formal_parameters, field.Name) >= 0; } field2.isDefined = field.isDefined; field2.debuggerName = "outer." + field2.Name; if (field.IsLiteral) { field2.attributeFlags |= FieldAttributes.Literal; field2.value = field.value; } this.AddOuterScopeField(name, field2); if (this.ProvidesOuterScopeLocals[parent] == null) { this.ProvidesOuterScopeLocals[parent] = parent; } ((FunctionScope)parent).mustSaveStackLocals = true; return(new MemberInfo[] { field2 }); } } if ((parent is ClassScope) && flag) { MemberInfo[] member = parent.GetMember(name, bindingAttr & ~BindingFlags.DeclaredOnly); int length = member.Length; bool flag2 = false; for (int i = 0; i < length; i++) { MethodInfo info3; PropertyInfo info4; MemberInfo info2 = member[i]; MemberTypes memberType = info2.MemberType; if (memberType != MemberTypes.Field) { if (memberType == MemberTypes.Method) { goto Label_029E; } if (memberType == MemberTypes.Property) { goto Label_02C7; } } else { info = (FieldInfo)info2; if (info.IsLiteral) { JSMemberField field3 = info as JSMemberField; if (((field3 != null) && (field3.value is ClassScope)) && !((ClassScope)field3.value).owner.IsStatic) { flag2 = true; } } if (!info.IsStatic && !info.IsLiteral) { member[i] = new JSClosureField(info); flag2 = true; } } continue; Label_029E: info3 = (MethodInfo)info2; if (!info3.IsStatic) { member[i] = new JSClosureMethod(info3); flag2 = true; } continue; Label_02C7: info4 = (PropertyInfo)info2; MethodInfo getMethod = JSProperty.GetGetMethod(info4, (bindingAttr & BindingFlags.NonPublic) != BindingFlags.Default); MethodInfo setMethod = JSProperty.GetSetMethod(info4, (bindingAttr & BindingFlags.NonPublic) != BindingFlags.Default); bool flag3 = false; if ((getMethod != null) && !getMethod.IsStatic) { flag3 = true; getMethod = new JSClosureMethod(getMethod); } if ((setMethod != null) && !setMethod.IsStatic) { flag3 = true; setMethod = new JSClosureMethod(setMethod); } if (flag3) { member[i] = new JSClosureProperty(info4, getMethod, setMethod); flag2 = true; } } if (flag2) { this.GiveOuterFunctionsTheBadNews(); } if (length > 0) { return(member); } } if ((bindingAttr & BindingFlags.DeclaredOnly) != BindingFlags.Default) { return(new MemberInfo[0]); } return(parent.GetMember(name, bindingAttr)); }
public override MemberInfo[] GetMember(String name, BindingFlags bindingAttr) { FieldInfo field = (FieldInfo)(this.name_table[name]); if (field != null) { return new MemberInfo[] { field } } ; bool nestedInInstanceMethod = false; ScriptObject parent = this.parent; //Treat locals of outer functions as if they were locals of this function while (parent is FunctionScope) { FunctionScope fscope = (FunctionScope)parent; nestedInInstanceMethod = fscope.isMethod && !fscope.isStatic; JSLocalField lfield = (JSLocalField)fscope.name_table[name]; if (lfield == null) { parent = parent.GetParent(); continue; } if (lfield.IsLiteral && !(lfield.value is FunctionObject)) { return new MemberInfo[] { lfield } } ; JSLocalField f = new JSLocalField(lfield.Name, this, this.field_table.Count, Missing.Value); f.outerField = lfield; f.debugOn = lfield.debugOn; if (!f.debugOn && this.owner.funcContext.document.debugOn && fscope.owner.funcContext.document.debugOn) { //Check to see it is off because outer field is a parameter f.debugOn = Array.IndexOf(fscope.owner.formal_parameters, lfield.Name) >= 0; } f.isDefined = lfield.isDefined; f.debuggerName = "outer" + "." + f.Name; if (lfield.IsLiteral) { f.attributeFlags |= FieldAttributes.Literal; f.value = lfield.value; } this.AddOuterScopeField(name, f); if (this.ProvidesOuterScopeLocals[parent] == null) { this.ProvidesOuterScopeLocals[parent] = parent; } ((FunctionScope)parent).mustSaveStackLocals = true; return(new MemberInfo[] { f }); } if (parent is ClassScope && nestedInInstanceMethod) { //return class members as if they were local to the function. It is more convenient to wrap up instance members //at this stage than it is to figure out later that a special case is involved. MemberInfo[] members = parent.GetMember(name, bindingAttr & ~BindingFlags.DeclaredOnly); int n = members.Length; bool giveBadNews = false; for (int i = 0; i < n; i++) { MemberInfo member = members[i]; switch (member.MemberType) { case MemberTypes.Field: field = (FieldInfo)member; if (field.IsLiteral) { JSMemberField mfield = field as JSMemberField; if (mfield != null && mfield.value is ClassScope && !((ClassScope)mfield.value).owner.IsStatic) { giveBadNews = true; } } if (!field.IsStatic && !field.IsLiteral) { members[i] = new JSClosureField(field); giveBadNews = true; } break; case MemberTypes.Method: MethodInfo meth = (MethodInfo)member; if (!meth.IsStatic) { members[i] = new JSClosureMethod(meth); giveBadNews = true; } break; case MemberTypes.Property: PropertyInfo prop = (PropertyInfo)member; MethodInfo getMeth = JSProperty.GetGetMethod(prop, (bindingAttr & BindingFlags.NonPublic) != 0); MethodInfo setMeth = JSProperty.GetSetMethod(prop, (bindingAttr & BindingFlags.NonPublic) != 0); bool nonStatic = false; if (getMeth != null && !getMeth.IsStatic) { nonStatic = true; getMeth = new JSClosureMethod(getMeth); } if (setMeth != null && !setMeth.IsStatic) { nonStatic = true; setMeth = new JSClosureMethod(setMeth); } if (nonStatic) { members[i] = new JSClosureProperty(prop, getMeth, setMeth); giveBadNews = true; } break; } } if (giveBadNews) { this.GiveOuterFunctionsTheBadNews(); //They have to create explicit stack frames } if (n > 0) { return(members); } } if ((bindingAttr & BindingFlags.DeclaredOnly) != 0) { return(new MemberInfo[0]); } return(parent.GetMember(name, bindingAttr)); }