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); }
internal JSExpandoIndexerMethod(ClassScope classScope, bool isGetter) : base(null) { this.isGetter = isGetter; this.classScope = classScope; this.GetterParams = new ParameterInfo[] { new ParameterDeclaration(Typeob.String, "field") }; this.SetterParams = new ParameterInfo[] { new ParameterDeclaration(Typeob.String, "field"), new ParameterDeclaration(Typeob.Object, "value") }; }
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); } }
internal JSExpandoIndexerMethod(ClassScope classScope, bool isGetter) : base(null){ //The object is never used, but it is convenient to have the field on JSMethod. this.isGetter = isGetter; this.classScope = classScope; this.GetterParams= new ParameterInfo[]{new ParameterDeclaration(Typeob.String, "field")}; this.SetterParams = new ParameterInfo[]{new ParameterDeclaration(Typeob.String, "field"), new ParameterDeclaration(Typeob.Object, "value")}; }
internal void AddOverloadedMembers(MemberInfoList mems, ClassScope scope, BindingFlags attrs) { for (JSMemberField field = this; field != null; field = field.nextOverload) { MethodInfo asMethod = field.GetAsMethod(scope); if (asMethod.IsStatic) { if ((attrs & BindingFlags.Static) != BindingFlags.Default) { goto Label_0020; } continue; } if ((attrs & BindingFlags.Instance) == BindingFlags.Default) { continue; } Label_0020: if (asMethod.IsPublic) { if ((attrs & BindingFlags.Public) != BindingFlags.Default) { goto Label_0036; } continue; } if ((attrs & BindingFlags.NonPublic) == BindingFlags.Default) { continue; } Label_0036: mems.Add(asMethod); } if (((attrs & BindingFlags.DeclaredOnly) == BindingFlags.Default) || ((attrs & BindingFlags.FlattenHierarchy) != BindingFlags.Default)) { foreach (MemberInfo info2 in scope.GetSuperType().GetMember(this.Name, attrs & ~BindingFlags.DeclaredOnly)) { if (info2.MemberType == MemberTypes.Method) { mems.Add(info2); } } } }
internal void AddOverloadedMembers(MemberInfoList mems, ClassScope scope, BindingFlags attrs) { for (JSMemberField field = this; field != null; field = field.nextOverload) { MethodInfo asMethod = field.GetAsMethod(scope); if (asMethod.IsStatic) { if ((attrs & BindingFlags.Static) != BindingFlags.Default) { goto Label_0020; } continue; } if ((attrs & BindingFlags.Instance) == BindingFlags.Default) { continue; } Label_0020: if (asMethod.IsPublic) { if ((attrs & BindingFlags.Public) != BindingFlags.Default) { goto Label_0036; } continue; } if ((attrs & BindingFlags.NonPublic) == BindingFlags.Default) { continue; } Label_0036: mems.Add(asMethod); } if (((attrs & BindingFlags.DeclaredOnly) == BindingFlags.Default) || ((attrs & BindingFlags.FlattenHierarchy) != BindingFlags.Default)) { foreach (MemberInfo info2 in scope.GetSuperType().GetMember(this.Name, attrs & ~BindingFlags.DeclaredOnly)) { if (info2.MemberType == MemberTypes.Method) { mems.Add(info2); } } } }
internal bool IsSameOrDerivedFrom(ClassScope other) { if (this == other) { return(true); } if (other.owner.isInterface) { return(this.ImplementsInterface(other)); } if (base.parent == null) { return(false); } this.owner.PartiallyEvaluate(); object obj2 = ((WithObject)base.parent).contained_object; return((obj2 is ClassScope) && ((ClassScope)obj2).IsSameOrDerivedFrom(other)); }
//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 override AST PartiallyEvaluate() { if (this.ifaceId != null) { this.ifaceId.PartiallyEvaluate(); this.func.implementedIface = this.ifaceId.ToIReflect(); Type t = this.func.implementedIface as Type; ClassScope csc = this.func.implementedIface as ClassScope; if (t != null && !t.IsInterface || csc != null && !csc.owner.isInterface) { this.ifaceId.context.HandleError(JSError.NeedInterface); this.func.implementedIface = null; } if ((this.func.attributes & MethodAttributes.Abstract) != 0) { this.func.funcContext.HandleError(JSError.AbstractCannotBePrivate); } } else if (this.declaringObject != null) { this.declaringObject.PartiallyEvaluateAsCallable(); } this.func.PartiallyEvaluate(); if (this.inFastScope && this.func.isExpandoMethod && this.field != null && this.field.type != null) { this.field.type.expression = new ConstantWrapper(Typeob.ScriptFunction, null); } if ((this.func.attributes & MethodAttributes.Abstract) != 0 && !((ClassScope)this.func.enclosing_scope).owner.isAbstract) { ((ClassScope)this.func.enclosing_scope).owner.attributes |= TypeAttributes.Abstract; ((ClassScope)this.func.enclosing_scope).owner.context.HandleError(JSError.CannotBeAbstract, this.name); } if (this.enclosingProperty != null) { if (!this.enclosingProperty.GetterAndSetterAreConsistent()) { this.context.HandleError(JSError.GetAndSetAreInconsistent); } } return(this); }
internal bool IsAccessibleFrom(ScriptObject scope) { while ((scope != null) && !(scope is ClassScope)) { scope = scope.GetParent(); } ClassScope other = (ClassScope)this.cons.enclosing_scope; if (base.IsPrivate) { if (scope == null) { return(false); } if (scope != other) { return(((ClassScope)scope).IsNestedIn(other, false)); } return(true); } if (base.IsFamily) { if (scope == null) { return(false); } if (!((ClassScope)scope).IsSameOrDerivedFrom(other)) { return(((ClassScope)scope).IsNestedIn(other, false)); } return(true); } if ((base.IsFamilyOrAssembly && (scope != null)) && (((ClassScope)scope).IsSameOrDerivedFrom(other) || ((ClassScope)scope).IsNestedIn(other, false))) { return(true); } if (scope == null) { return(other.GetPackage() == null); } return(other.GetPackage() == ((ClassScope)scope).GetPackage()); }
internal bool IsNestedIn(ClassScope other, bool isStatic) { if (this.parent == null) { return(false); } this.owner.PartiallyEvaluate(); if (this.owner.enclosingScope == other) { return(isStatic || !this.owner.isStatic); } else if (this.owner.enclosingScope is ClassScope) { return(((ClassScope)this.owner.enclosingScope).IsNestedIn(other, isStatic)); } else { return(false); } }
internal bool IsAccessibleFrom(ScriptObject scope) //Never call this if the member is public { while (scope != null && !(scope is ClassScope)) { scope = scope.GetParent(); } ClassScope thisScope = (ClassScope)this.cons.enclosing_scope; if (this.IsPrivate) { if (scope == null) { return(false); } else { return(scope == thisScope || ((ClassScope)scope).IsNestedIn(thisScope, false)); } } else if (this.IsFamily) { if (scope == null) { return(false); } else { return(((ClassScope)scope).IsSameOrDerivedFrom(thisScope) || ((ClassScope)scope).IsNestedIn(thisScope, false)); } } else //if (this.IsAssembly) if (scope == null) //Code is not in a class and hence it is in the default package { return(thisScope.GetPackage() == null); //null indicates default package } else { return(thisScope.GetPackage() == ((ClassScope)scope).GetPackage()); } }
public override String ToString() { Type elemType = this.elementType as Type; if (elemType != null) { return(elemType.FullName + TypedArray.ToRankString(this.rank)); } ClassScope csc = this.elementType as ClassScope; if (csc != null) { return(csc.GetFullName() + TypedArray.ToRankString(this.rank)); } TypedArray tarr = this.elementType as TypedArray; if (tarr != null) { return(tarr.ToString() + TypedArray.ToRankString(this.rank)); } return(Convert.ToType(this.elementType).FullName + TypedArray.ToRankString(this.rank)); }
internal override IReflect InferType(JSField inference_target) { Debug.Assert(Globals.TypeRefs.InReferenceContext(this.method)); if (this.method != null) { ParameterInfo[] pars = this.method.GetParameters(); if (pars == null || pars.Length == 0) { return(this.method.ReturnType); } else { return(pars[0].ParameterType); } } ScriptObject top = Globals.ScopeStack.Peek(); while (top is WithObject) { top = top.GetParent(); } if (top is GlobalScope) { return(top); } else if (top is FunctionScope && ((FunctionScope)top).isMethod) { ClassScope csc = (ClassScope)((FunctionScope)top).owner.enclosing_scope; if (this.isSuper) { return(csc.GetSuperType()); } else { return(csc); } } return(Typeob.Object); }
public override string ToString() { Type elementType = this.elementType as Type; if (elementType != null) { return(elementType.FullName + ToRankString(this.rank)); } ClassScope scope = this.elementType as ClassScope; if (scope != null) { return(scope.GetFullName() + ToRankString(this.rank)); } TypedArray array = this.elementType as TypedArray; if (array != null) { return(array.ToString() + ToRankString(this.rank)); } return(Microsoft.JScript.Convert.ToType(this.elementType).FullName + ToRankString(this.rank)); }
private void ConvertClassScopesAndEnumWrappers(ArrayList vals) { int num = 0; int count = vals.Count; while (num < count) { ClassScope scope = vals[num] as ClassScope; if (scope != null) { vals[num] = scope.GetTypeBuilder(); } else { EnumWrapper wrapper = vals[num] as EnumWrapper; if (wrapper != null) { vals[num] = wrapper.ToNumericValue(); } } num++; } }
internal void MergeWith(PackageScope p) { foreach (Object f in p.field_table) { JSGlobalField field = (JSGlobalField)f; ClassScope csc = field.value as ClassScope; if (this.name_table[field.Name] != null) { if (csc != null) { csc.owner.context.HandleError(JSError.DuplicateName, field.Name, true); csc.owner.name += p.GetHashCode().ToString(); } continue; } this.field_table.Add(field); this.name_table[field.Name] = field; if (csc != null) { csc.owner.enclosingScope = this; csc.package = this; } } }
internal bool IsSameOrDerivedFrom(ClassScope other){ if (this == other) return true; if (other.owner.isInterface) return this.ImplementsInterface(other); if (this.parent == null) return false; this.owner.PartiallyEvaluate(); Object supertype = ((WithObject)this.parent).contained_object; if (supertype is ClassScope) return ((ClassScope)supertype).IsSameOrDerivedFrom(other); else return false; }
internal bool IsNestedIn(ClassScope other, bool isStatic){ if (this.parent == null) return false; this.owner.PartiallyEvaluate(); if (this.owner.enclosingScope == other) return isStatic || !this.owner.isStatic; else if (this.owner.enclosingScope is ClassScope) return ((ClassScope)this.owner.enclosingScope).IsNestedIn(other, isStatic); else return false; }
internal override AST PartiallyEvaluate() { if (this.alreadyPartiallyEvaluated) { return(this); } this.alreadyPartiallyEvaluated = true; if (this.inBrackets && this.AllParamsAreMissing()) { if (this.isConstructor) { this.args.context.HandleError(JSError.TypeMismatch); } return(new ConstantWrapper(new TypedArray(((TypeExpression) new TypeExpression(this.func).PartiallyEvaluate()).ToIReflect(), this.args.count + 1), base.context)); } this.func = this.func.PartiallyEvaluateAsCallable(); this.args = (ASTList)this.args.PartiallyEvaluate(); IReflect[] argIRs = this.ArgIRs(); this.func.ResolveCall(this.args, argIRs, this.isConstructor, this.inBrackets); if ((!this.isConstructor && !this.inBrackets) && ((this.func is Binding) && (this.args.count == 1))) { Binding func = (Binding)this.func; if (func.member is Type) { Type member = (Type)func.member; ConstantWrapper wrapper = this.args[0] as ConstantWrapper; if (wrapper != null) { try { if ((wrapper.value == null) || (wrapper.value is DBNull)) { return(this); } if (wrapper.isNumericLiteral && (((member == Typeob.Decimal) || (member == Typeob.Int64)) || ((member == Typeob.UInt64) || (member == Typeob.Single)))) { return(new ConstantWrapper(Microsoft.JScript.Convert.CoerceT(wrapper.context.GetCode(), member, true), base.context)); } return(new ConstantWrapper(Microsoft.JScript.Convert.CoerceT(wrapper.Evaluate(), member, true), base.context)); } catch { wrapper.context.HandleError(JSError.TypeMismatch); goto Label_0354; } } if (!Binding.AssignmentCompatible(member, this.args[0], argIRs[0], false)) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } else if (func.member is JSVariableField) { JSVariableField field = (JSVariableField)func.member; if (field.IsLiteral) { if (field.value is ClassScope) { ClassScope scope = (ClassScope)field.value; IReflect underlyingTypeIfEnum = scope.GetUnderlyingTypeIfEnum(); if (underlyingTypeIfEnum != null) { if ((!Microsoft.JScript.Convert.IsPromotableTo(argIRs[0], underlyingTypeIfEnum) && !Microsoft.JScript.Convert.IsPromotableTo(underlyingTypeIfEnum, argIRs[0])) && ((argIRs[0] != Typeob.String) || (underlyingTypeIfEnum == scope))) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } else if (!Microsoft.JScript.Convert.IsPromotableTo(argIRs[0], scope) && !Microsoft.JScript.Convert.IsPromotableTo(scope, argIRs[0])) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } else if (field.value is TypedArray) { TypedArray array = (TypedArray)field.value; if (!Microsoft.JScript.Convert.IsPromotableTo(argIRs[0], array) && !Microsoft.JScript.Convert.IsPromotableTo(array, argIRs[0])) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } } } } Label_0354: return(this); }
internal JSExpandoIndexerMethod(ClassScope classScope, bool isGetter) : base(null) //The object is never used, but it is convenient to have the field on JSMethod. { this.isGetter = isGetter; this.classScope = classScope; }
internal Class(Context context, AST id, TypeExpression superTypeExpression, TypeExpression[] interfaces, Block body, FieldAttributes attributes, bool isAbstract, bool isFinal, bool isStatic, bool isInterface, CustomAttributeList customAttributes) : base(context) { this.name = id.ToString(); this.superTypeExpression = superTypeExpression; this.interfaces = interfaces; this.body = body; this.enclosingScope = (ScriptObject)Globals.ScopeStack.Peek(1); this.attributes = TypeAttributes.Class|TypeAttributes.Serializable; this.SetAccessibility(attributes); if (isAbstract) this.attributes |= TypeAttributes.Abstract; this.isAbstract = isAbstract || isInterface; this.isAlreadyPartiallyEvaluated = false; if (isFinal) this.attributes |= TypeAttributes.Sealed; if (isInterface) this.attributes |= TypeAttributes.Interface | TypeAttributes.Abstract; this.isCooked = false; this.cookedType = null; this.isExpando = false; this.isInterface = isInterface; this.isStatic = isStatic; this.needsEngine = !isInterface; this.validOn = (AttributeTargets)0; this.allowMultiple = true; this.classob = (ClassScope)Globals.ScopeStack.Peek(); this.classob.name = this.name; this.classob.owner = this; this.implicitDefaultConstructor = null; if (!isInterface && !(this is EnumDeclaration)) this.SetupConstructors(); this.EnterNameIntoEnclosingScopeAndGetOwnField(id, isStatic); this.fields = this.classob.GetMemberFields(); this.superClass = null; this.superIR = null; this.superMembers = null; this.firstIndex = null; this.fieldInitializer = null; this.customAttributes = customAttributes; this.clsCompliance = CLSComplianceSpec.NotAttributed; this.generateCodeForExpando = false; this.expandoItemProp = null; this.getHashTableMethod = null; this.getItem = null; this.setItem = null; }
internal DeclaredEnumValue(object value, string name, ClassScope classScope) { this._name = name; this._classScope = classScope; this._value = value; }
internal DeclaredEnumValue(Object value, String name, ClassScope classScope){ this._name = name; this._classScope = classScope; this._value = value; }
internal override AST PartiallyEvaluate() { if (this.alreadyPartiallyEvaluated) { return(this); } this.alreadyPartiallyEvaluated = true; if (this.inBrackets && this.AllParamsAreMissing()) { if (this.isConstructor) { this.args.context.HandleError(JSError.TypeMismatch); } IReflect ir = ((TypeExpression)(new TypeExpression(this.func)).PartiallyEvaluate()).ToIReflect(); return(new ConstantWrapper(new TypedArray(ir, this.args.count + 1), this.context)); } this.func = this.func.PartiallyEvaluateAsCallable(); this.args = (ASTList)this.args.PartiallyEvaluate(); IReflect[] argIRs = this.ArgIRs(); this.func.ResolveCall(this.args, argIRs, this.isConstructor, this.inBrackets); if (!this.isConstructor && !this.inBrackets && this.func is Binding && this.args.count == 1) { Binding b = (Binding)this.func; if (b.member is Type) { Type t = (Type)b.member; ConstantWrapper arg0 = this.args[0] as ConstantWrapper; if (arg0 != null) { try{ if (arg0.value == null || arg0.value is DBNull) { return(this); } else if (arg0.isNumericLiteral && (t == Typeob.Decimal || t == Typeob.Int64 || t == Typeob.UInt64 || t == Typeob.Single)) { return(new ConstantWrapper(Convert.CoerceT(arg0.context.GetCode(), t, true), this.context)); } else { return(new ConstantWrapper(Convert.CoerceT(arg0.Evaluate(), t, true), this.context)); } }catch { arg0.context.HandleError(JSError.TypeMismatch); } } else { if (!Binding.AssignmentCompatible(t, this.args[0], argIRs[0], false)) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } } else if (b.member is JSVariableField) { JSVariableField field = (JSVariableField)b.member; if (field.IsLiteral) { if (field.value is ClassScope) { ClassScope csc = (ClassScope)field.value; IReflect ut = csc.GetUnderlyingTypeIfEnum(); if (ut != null) { if (!Convert.IsPromotableTo(argIRs[0], ut) && !Convert.IsPromotableTo(ut, argIRs[0]) && (argIRs[0] != Typeob.String || ut == csc)) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } else { if (!Convert.IsPromotableTo(argIRs[0], csc) && !Convert.IsPromotableTo(csc, argIRs[0])) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } } else if (field.value is TypedArray) { TypedArray ta = (TypedArray)field.value; if (!Convert.IsPromotableTo(argIRs[0], ta) && !Convert.IsPromotableTo(ta, argIRs[0])) { this.args[0].context.HandleError(JSError.ImpossibleConversion); } } } } } return(this); }
private void TranslateToILObjectForMember(ILGenerator il, Type obType, bool noValue, MemberInfo mem) { this.thereIsAnObjectOnTheStack = true; if (mem is IWrappedMember) { object wrappedObject = ((IWrappedMember)mem).GetWrappedObject(); if (wrappedObject is LenientGlobalObject) { base.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.getLenientGlobalObjectMethod); } else if ((wrappedObject is Type) || (wrappedObject is ClassScope)) { if (obType.IsAssignableFrom(Typeob.Type)) { new ConstantWrapper(wrappedObject, null).TranslateToIL(il, Typeob.Type); } else { ScriptObject parent = base.Globals.ScopeStack.Peek(); while ((parent is WithObject) || (parent is BlockScope)) { parent = parent.GetParent(); } if (parent is FunctionScope) { if (((FunctionScope)parent).owner.isMethod) { il.Emit(OpCodes.Ldarg_0); } else { base.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod); parent = base.Globals.ScopeStack.Peek(); while ((parent is WithObject) || (parent is BlockScope)) { il.Emit(OpCodes.Call, CompilerGlobals.getParentMethod); parent = parent.GetParent(); } il.Emit(OpCodes.Castclass, Typeob.StackFrame); il.Emit(OpCodes.Ldfld, CompilerGlobals.closureInstanceField); } } else if (parent is ClassScope) { il.Emit(OpCodes.Ldarg_0); } for (parent = base.Globals.ScopeStack.Peek(); parent != null; parent = parent.GetParent()) { ClassScope scope = parent as ClassScope; if (scope != null) { if (scope.IsSameOrDerivedFrom(obType)) { return; } il.Emit(OpCodes.Ldfld, scope.outerClassField); } } } } else { this.TranslateToILDefaultThisObject(il, this.lexLevel); Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, obType); } } else { ScriptObject obj5 = base.Globals.ScopeStack.Peek(); while ((obj5 is WithObject) || (obj5 is BlockScope)) { obj5 = obj5.GetParent(); } if (!(obj5 is FunctionScope) || ((FunctionScope)obj5).owner.isMethod) { il.Emit(OpCodes.Ldarg_0); while (obj5 != null) { if (obj5 is ClassScope) { ClassScope scope3 = (ClassScope)obj5; if (scope3.IsSameOrDerivedFrom(obType)) { return; } il.Emit(OpCodes.Ldfld, scope3.outerClassField); } obj5 = obj5.GetParent(); } } else { base.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod); obj5 = base.Globals.ScopeStack.Peek(); while ((obj5 is WithObject) || (obj5 is BlockScope)) { il.Emit(OpCodes.Call, CompilerGlobals.getParentMethod); obj5 = obj5.GetParent(); } il.Emit(OpCodes.Castclass, Typeob.StackFrame); il.Emit(OpCodes.Ldfld, CompilerGlobals.closureInstanceField); while (obj5 != null) { if (obj5 is ClassScope) { ClassScope scope2 = (ClassScope)obj5; if (scope2.IsSameOrDerivedFrom(obType)) { break; } il.Emit(OpCodes.Castclass, scope2.GetTypeBuilder()); il.Emit(OpCodes.Ldfld, scope2.outerClassField); } obj5 = obj5.GetParent(); } il.Emit(OpCodes.Castclass, obType); } } }
internal JSExpandoIndexerMethod(ClassScope classScope, bool isGetter) : base(null){ //The object is never used, but it is convenient to have the field on JSMethod. this.isGetter = isGetter; this.classScope = classScope; }
internal JSMemberField(ClassScope obj, String name, Object value, FieldAttributes attributeFlags) : base(name, obj, attributeFlags) { this.value = value; this.nextOverload = null; }
internal bool IsSameOrDerivedFrom(ClassScope other) { if (this == other) { return true; } if (other.owner.isInterface) { return this.ImplementsInterface(other); } if (base.parent == null) { return false; } this.owner.PartiallyEvaluate(); object obj2 = ((WithObject) base.parent).contained_object; return ((obj2 is ClassScope) && ((ClassScope) obj2).IsSameOrDerivedFrom(other)); }
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 JSMemberField(ClassScope obj, String name, Object value, FieldAttributes attributeFlags) : base(name, obj, attributeFlags) { this.value = value; this.nextOverload = 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 EnumWrapper(Object value, String name, ClassScope type){ this.name = name; this.type = type; this.value = value; }
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; } } } } } }
internal EnumWrapper(Object value, String name, ClassScope type) { this.name = name; this.type = type; this.value = value; }
private void TranslateToILObjectForMember(ILGenerator il, Type obType, bool noValue, MemberInfo mem) { this.thereIsAnObjectOnTheStack = true; if (mem is IWrappedMember) { Object obj = ((IWrappedMember)mem).GetWrappedObject(); if (obj is LenientGlobalObject) { this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.getLenientGlobalObjectMethod); } else if (obj is Type || obj is ClassScope) { if (obType.IsAssignableFrom(Typeob.Type)) { (new ConstantWrapper(obj, null)).TranslateToIL(il, Typeob.Type); return; } //this.name is the name of an instance member of the superclass of the class (or an outer class) in which this expression appears //get class instance on stack ScriptObject scope = Globals.ScopeStack.Peek(); while (scope is WithObject || scope is BlockScope) { scope = scope.GetParent(); } if (scope is FunctionScope) { FunctionObject func = ((FunctionScope)scope).owner; if (func.isMethod) { il.Emit(OpCodes.Ldarg_0); } else //Need to get the StackFrame.closureInstance on the stack { this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod); scope = this.Globals.ScopeStack.Peek(); while (scope is WithObject || scope is BlockScope) { il.Emit(OpCodes.Call, CompilerGlobals.getParentMethod); scope = scope.GetParent(); } il.Emit(OpCodes.Castclass, Typeob.StackFrame); il.Emit(OpCodes.Ldfld, CompilerGlobals.closureInstanceField); } } else if (scope is ClassScope) { il.Emit(OpCodes.Ldarg_0); //Inside instance initializer } //If dealing with a member of an outer class, get the outer class instance on the stack scope = Globals.ScopeStack.Peek(); while (scope != null) { ClassScope csc = scope as ClassScope; if (csc != null) //Might be dealing with a reference from within a nested class to an instance member of an outer class { if (csc.IsSameOrDerivedFrom(obType)) { break; } il.Emit(OpCodes.Ldfld, csc.outerClassField); } scope = scope.GetParent(); } } else { this.TranslateToILDefaultThisObject(il, this.lexLevel); Convert.Emit(this, il, Typeob.Object, obType); } } else { ScriptObject scope = Globals.ScopeStack.Peek(); while (scope is WithObject || scope is BlockScope) { scope = scope.GetParent(); } if (scope is FunctionScope) { FunctionObject func = ((FunctionScope)scope).owner; if (!func.isMethod) //Need to get the StackFrame.closureInstance on the stack { this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod); scope = this.Globals.ScopeStack.Peek(); while (scope is WithObject || scope is BlockScope) { il.Emit(OpCodes.Call, CompilerGlobals.getParentMethod); scope = scope.GetParent(); } il.Emit(OpCodes.Castclass, Typeob.StackFrame); il.Emit(OpCodes.Ldfld, CompilerGlobals.closureInstanceField); while (scope != null) { if (scope is ClassScope) //Might be dealing with a reference from within a nested class to an instance member of an outer class { ClassScope csc = (ClassScope)scope; if (csc.IsSameOrDerivedFrom(obType)) { break; } il.Emit(OpCodes.Castclass, csc.GetTypeBuilder()); il.Emit(OpCodes.Ldfld, csc.outerClassField); } scope = scope.GetParent(); } il.Emit(OpCodes.Castclass, obType); return; } } il.Emit(OpCodes.Ldarg_0); while (scope != null) { if (scope is ClassScope) //Might be dealing with a reference from within a nested class to an instance member of an outer class { ClassScope csc = (ClassScope)scope; if (csc.IsSameOrDerivedFrom(obType)) { break; } il.Emit(OpCodes.Ldfld, csc.outerClassField); } scope = scope.GetParent(); } } }
internal bool IsNestedIn(ClassScope other, bool isStatic) { if (base.parent == null) { return false; } this.owner.PartiallyEvaluate(); if (this.owner.enclosingScope == other) { if (!isStatic) { return !this.owner.isStatic; } return true; } return ((this.owner.enclosingScope is ClassScope) && ((ClassScope) this.owner.enclosingScope).IsNestedIn(other, isStatic)); }