public BlockScope(ScriptObject parent, String name, int scopeId) : base(parent){ this.scopeId = scopeId; JSField field = (JSField)this.parent.GetField(name+":"+this.scopeId, BindingFlags.Public); this.name_table[name] = field; this.field_table.Add(field); }
internal NumberObject(ScriptObject parent, Object value, bool implicitWrapper) : base(parent, Typeob.NumberObject) { this.baseType = value.GetType(); this.value = value; this.noExpando = implicitWrapper; this.implicitWrapper = implicitWrapper; }
public Closure(FunctionObject func) : this(func, null) { if (func.enclosing_scope is Microsoft.JScript.StackFrame) { this.enclosing_scope = func.enclosing_scope; } }
internal LenientErrorPrototype(LenientFunctionPrototype funcprot, ScriptObject parent, string name) : base(parent, name) { base.noExpando = false; this.name = name; Type type = typeof(ErrorPrototype); this.toString = new BuiltinFunction("toString", this, type.GetMethod("toString"), funcprot); }
internal ArrayObject(ScriptObject prototype, Type subType) : base(prototype, subType) { this.len = 0; this.denseArray = null; this.denseArrayLength = 0; this.noExpando = false; }
private void AddNameTo(ScriptObject enclosingScope) { while (enclosingScope is WithObject) { enclosingScope = enclosingScope.GetParent(); } if (((IActivationObject) enclosingScope).GetLocalField(this.name) == null) { FieldInfo info; if (enclosingScope is ActivationObject) { if (enclosingScope is FunctionScope) { info = ((ActivationObject) enclosingScope).AddNewField(this.name, null, FieldAttributes.Public); } else { info = ((ActivationObject) enclosingScope).AddNewField(this.name, null, FieldAttributes.Static | FieldAttributes.Public); } } else { info = ((StackFrame) enclosingScope).AddNewField(this.name, null, FieldAttributes.Public); } JSLocalField field = info as JSLocalField; if (field != null) { field.debugOn = base.context.document.debugOn; field.isDefined = true; } this.field = (JSVariableField) info; } }
protected NumberObject(ScriptObject parent, Object value) : base(parent) { this.baseType = value.GetType(); this.value = value; this.noExpando = false; this.implicitWrapper = false; }
internal FunctionScope(ScriptObject parent, bool isMethod) : base(parent) { base.isKnownAtCompileTime = true; this.isMethod = isMethod; this.mustSaveStackLocals = false; if ((parent != null) && (parent is ActivationObject)) { base.fast = ((ActivationObject) parent).fast; } else { base.fast = false; } this.returnVar = null; this.owner = null; this.isStatic = false; this.nested_functions = null; this.fields_for_nested_functions = null; if (parent is FunctionScope) { this.ProvidesOuterScopeLocals = new SimpleHashtable(0x10); } else { this.ProvidesOuterScopeLocals = null; } this.closuresMightEscape = false; }
internal DateObject(ScriptObject parent, double value) : base(parent) { this.value = value != value || value > Int64.MaxValue || value < Int64.MinValue ? Double.NaN : System.Math.Round(value); this.noExpando = false; }
internal NumberObject(ScriptObject parent, object value, bool implicitWrapper) : base(parent, typeof(NumberObject)) { this.baseType = Globals.TypeRefs.ToReferenceContext(value.GetType()); this.value = value; base.noExpando = implicitWrapper; this.implicitWrapper = implicitWrapper; }
protected NumberObject(ScriptObject parent, object value) : base(parent) { this.baseType = Globals.TypeRefs.ToReferenceContext(value.GetType()); this.value = value; base.noExpando = false; this.implicitWrapper = false; }
internal FunctionObject(string name, ParameterDeclaration[] parameter_declarations, TypeExpression return_type_expr, Block body, FunctionScope own_scope, ScriptObject enclosing_scope, Context funcContext, MethodAttributes attributes, CustomAttributeList customAttributes, bool isMethod) : base(body.Globals.globalObject.originalFunction.originalPrototype, name, parameter_declarations.Length) { this.parameter_declarations = parameter_declarations; int length = parameter_declarations.Length; this.formal_parameters = new string[length]; for (int i = 0; i < length; i++) { this.formal_parameters[i] = parameter_declarations[i].identifier; } this.argumentsSlotNumber = 0; this.return_type_expr = return_type_expr; if (this.return_type_expr != null) { own_scope.AddReturnValueField(); } this.body = body; this.method = null; this.parameterInfos = null; this.funcContext = funcContext; this.own_scope = own_scope; this.own_scope.owner = this; if ((!(enclosing_scope is ActivationObject) || !((ActivationObject) enclosing_scope).fast) && !isMethod) { this.argumentsSlotNumber = this.own_scope.GetNextSlotNumber(); JSLocalField field = (JSLocalField) this.own_scope.AddNewField("arguments", null, FieldAttributes.PrivateScope); field.type = new TypeExpression(new ConstantWrapper(Typeob.Object, funcContext)); field.isDefined = true; this.hasArgumentsObject = true; } else { this.hasArgumentsObject = false; } this.implementedIface = null; this.implementedIfaceMethod = null; this.isMethod = isMethod; this.isExpandoMethod = (customAttributes != null) && customAttributes.ContainsExpandoAttribute(); this.isStatic = this.own_scope.isStatic = (attributes & MethodAttributes.Static) != MethodAttributes.PrivateScope; this.suppressIL = false; this.noVersionSafeAttributeSpecified = true; this.fields = this.own_scope.GetLocalFields(); this.enclosing_scope = enclosing_scope; this.must_save_stack_locals = false; this.text = null; this.mb = null; this.cb = null; this.attributes = attributes; if (!this.isStatic) { this.attributes |= MethodAttributes.HideBySig; } this.globals = body.Globals; this.superConstructor = null; this.superConstructorCall = null; this.customAttributes = customAttributes; base.noExpando = false; this.clsCompliance = CLSComplianceSpec.NotAttributed; this.engineLocal = null; this.partiallyEvaluated = false; }
internal FunctionObject(Type t, string name, string method_name, string[] formal_parameters, JSLocalField[] fields, bool must_save_stack_locals, bool hasArgumentsObject, string text, VsaEngine engine) : base(engine.Globals.globalObject.originalFunction.originalPrototype, name, formal_parameters.Length) { base.engine = engine; this.formal_parameters = formal_parameters; this.argumentsSlotNumber = 0; this.body = null; this.method = TypeReflector.GetTypeReflectorFor(Globals.TypeRefs.ToReferenceContext(t)).GetMethod(method_name, BindingFlags.Public | BindingFlags.Static); this.parameterInfos = this.method.GetParameters(); if (!Microsoft.JScript.CustomAttribute.IsDefined(this.method, typeof(JSFunctionAttribute), false)) { this.isMethod = true; } else { JSFunctionAttributeEnum attributeValue = ((JSFunctionAttribute) Microsoft.JScript.CustomAttribute.GetCustomAttributes(this.method, typeof(JSFunctionAttribute), false)[0]).attributeValue; this.isExpandoMethod = (attributeValue & JSFunctionAttributeEnum.IsExpandoMethod) != JSFunctionAttributeEnum.None; } this.funcContext = null; this.own_scope = null; this.fields = fields; this.must_save_stack_locals = must_save_stack_locals; this.hasArgumentsObject = hasArgumentsObject; this.text = text; this.attributes = MethodAttributes.Public; this.globals = engine.Globals; this.superConstructor = null; this.superConstructorCall = null; this.enclosing_scope = this.globals.ScopeStack.Peek(); base.noExpando = false; this.clsCompliance = CLSComplianceSpec.NotAttributed; }
public PackageScope(ScriptObject parent) : base(parent) { this.fast = true; this.name = null; this.owner = null; this.isKnownAtCompileTime = true; }
internal BlockScope(ScriptObject parent) : base(parent){ this.scopeId = BlockScope.counter++; this.isKnownAtCompileTime = true; this.fast = parent is ActivationObject ? ((ActivationObject)parent).fast : true; this.localFieldsForDebugInfo = new ArrayList(); }
// Constructor. public BuiltinFunction(ScriptObject prototype, String name, MethodInfo method) : base(prototype, name) { this.method = method; Object[] attrs = method.GetCustomAttributes (typeof(JSFunctionAttribute), false); if(attrs == null || attrs.Length == 0) { this.flags = (JSFunctionAttributeEnum)0; } else { this.flags = ((JSFunctionAttribute)(attrs[0])) .GetAttributeValue(); } requiredParameters = method.GetParameters().Length; lengthValue = requiredParameters; if((flags & JSFunctionAttributeEnum.HasThisObject) != 0) { --lengthValue; } if((flags & JSFunctionAttributeEnum.HasEngine) != 0) { --lengthValue; } if((flags & JSFunctionAttributeEnum.HasVarArgs) != 0) { --lengthValue; } }
// Constructor. internal FunctionObject(FunctionPrototype parent, JFunction defn, ScriptObject declaringScope) : base(parent, defn.name, Support.ExprListLength(defn.fparams)) { this.defn = defn; this.declaringScope = declaringScope; }
internal LenientErrorPrototype(LenientFunctionPrototype funcprot, ScriptObject parent, String name) : base(parent, name) { this.noExpando = false; //this.constructor is given a value by the constructor class this.name = name; Type super = typeof(ErrorPrototype); this.toString = new BuiltinFunction("toString", this, super.GetMethod("toString"), funcprot); }
public VsaEngine engine; //This is only really useful for ScriptFunctions, IActivation objects and prototype objects. It lives here for the sake of simplicity. //Prototype objects do not need the scope stack, so in fast mode, all prototype objects can share a common engine. internal ScriptObject(ScriptObject parent){ this.parent = parent; this.wrappedMemberCache = null; if (this.parent != null) this.engine = parent.engine; else this.engine = null; }
internal WithObject(ScriptObject parent, Object contained_object, bool isSuperType) : base(parent) { this.contained_object = contained_object; this.isKnownAtCompileTime = contained_object is Type || (contained_object is ClassScope && ((ClassScope)contained_object).noExpando) || (contained_object is JSObject && ((JSObject)contained_object).noExpando); this.isSuperType = isSuperType; }
internal VsaNamedItemScope(Object hostObject, ScriptObject parent, VsaEngine engine) : base(parent){ this.namedItem = hostObject; if ((this.reflectObj = hostObject as IReflect) == null) this.reflectObj = hostObject.GetType(); this.recursive = false; this.engine = engine; }
internal LenientFunctionPrototype(ScriptObject parent) : base(parent) { base.noExpando = false; Type type = typeof(FunctionPrototype); this.apply = new BuiltinFunction("apply", this, type.GetMethod("apply"), this); this.call = new BuiltinFunction("call", this, type.GetMethod("call"), this); this.toString = new BuiltinFunction("toString", this, type.GetMethod("toString"), this); }
internal LenientFunctionPrototype(ScriptObject parent) : base(parent) { this.noExpando = false; //this.constructor is given a value by ObjectConstructor Type super = typeof(FunctionPrototype); this.apply = new BuiltinFunction("apply", this, super.GetMethod("apply"), this); this.call = new BuiltinFunction("call", this, super.GetMethod("call"), this); this.toString = new BuiltinFunction("toString", this, super.GetMethod("toString"), this); }
internal ArgumentsObject(ScriptObject parent, Object[] arguments, FunctionObject function, Closure callee, ScriptObject scope, ArgumentsObject caller) : base(parent) { this.arguments = arguments; this.formal_names = function.formal_parameters; this.scope = scope; this.callee = callee; this.caller = caller; this.length = arguments.Length; this.noExpando = false; }
internal VsaNamedItemScope(object hostObject, ScriptObject parent, VsaEngine engine) : base(parent) { this.namedItem = hostObject; this.reflectObj = hostObject as IReflect; if (this.reflectObj == null) { this.reflectObj = Globals.TypeRefs.ToReferenceContext(hostObject.GetType()); } this.recursive = false; base.engine = engine; }
internal ArrayWrapper(ScriptObject prototype, Array value, bool implicitWrapper) : base(prototype, typeof(ArrayWrapper)) { this.value = value; this.implicitWrapper = implicitWrapper; if (value != null){ if (value.Rank != 1) throw new JScriptException(JSError.TypeMismatch); this.len = (uint) value.Length; }else this.len = 0; }
static internal ClassScope ScopeOfClassMemberInitializer(ScriptObject scope) { while (scope != null) { if (scope is FunctionScope) return null; ClassScope cscope = scope as ClassScope; if (cscope != null) return cscope; scope = scope.GetParent(); } return null; }
// Constructor. internal ScriptObject(ScriptObject parent) { this.parent = parent; if(parent != null) { this.engine = parent.engine; } else { this.engine = null; } }
internal JSObject(ScriptObject parent, Type subType) : base(parent) { this.memberCache = null; this.isASubClass = false; this.subClassIR = null; Debug.Assert(subType == this.GetType() || this.GetType() == typeof(BuiltinFunction)); if (subType != Typeob.JSObject){ this.isASubClass = true; this.subClassIR = TypeReflector.GetTypeReflectorFor(subType); } this.noExpando = this.isASubClass; this.name_table = null; this.field_table = null; }
internal StackFrame(ScriptObject parent, JSLocalField[] fields, Object[] local_vars, Object thisObject) : base(parent) { this.caller_arguments = null; this.fields = fields; this.localVars = local_vars; this.nestedFunctionScope = null; this.thisObject = thisObject; if (parent is StackFrame) this.closureInstance = ((StackFrame)parent).closureInstance; else if (parent is JSObject) this.closureInstance = parent; else this.closureInstance = null; }
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); } } }
private MemberInfo[] GetMember(String name, BindingFlags bindingAttr, bool calledFromParent) { if (this.recursive) { return(new MemberInfo[0]); } MemberInfo[] result = null; if (!this.isComponentScope) { //Look for an expando MemberInfo[] members = base.GetMember(name, bindingAttr | BindingFlags.DeclaredOnly); if (members.Length > 0) { return(members); } if (this.componentScopes != null) { for (int i = 0, n = this.componentScopes.Count; i < n; i++) { GlobalScope sc = (GlobalScope)this.componentScopes[i]; result = sc.GetMember(name, bindingAttr | BindingFlags.DeclaredOnly, true); if (result.Length > 0) { return(result); } } } if (this.globalObject != null) { result = this.globalObjectTR.GetMember(name, bindingAttr & ~BindingFlags.NonPublic | BindingFlags.Static); } if (result != null && result.Length > 0) { return(ScriptObject.WrapMembers(result, this.globalObject)); } } else { //Look for global variables represented as static fields on subclass of GlobalScope. I.e. the script block case. result = this.typeReflector.GetMember(name, bindingAttr & ~BindingFlags.NonPublic | BindingFlags.Static); int n = result.Length; if (n > 0) { int toBeHidden = 0; MemberInfo[] newResult = new MemberInfo[n]; for (int i = 0; i < n; i++) { MemberInfo mem = newResult[i] = result[i]; if (mem.DeclaringType.IsAssignableFrom(Typeob.GlobalScope)) { newResult[i] = null; toBeHidden++; } else if (mem is FieldInfo) { FieldInfo field = (FieldInfo)mem; if (field.IsStatic && field.FieldType == Typeob.Type) { Type t = (Type)field.GetValue(null); if (t != null) { newResult[i] = t; } } } } if (toBeHidden == 0) { return(result); } if (toBeHidden == n) { return(new MemberInfo[0]); } MemberInfo[] remainingMembers = new MemberInfo[n - toBeHidden]; int j = 0; foreach (MemberInfo mem in newResult) { if (mem != null) { remainingMembers[j++] = mem; } } return(remainingMembers); } } if (this.parent != null && !calledFromParent && ((bindingAttr & BindingFlags.DeclaredOnly) == 0 || this.isComponentScope)) { this.recursive = true; try{ result = ((ScriptObject)this.parent).GetMember(name, bindingAttr); }finally{ this.recursive = false; } if (result != null && result.Length > 0) { return(result); } } return(new MemberInfo[0]); }
// internal constructor internal MathObject(ScriptObject parent) : base(parent) { EngineInstance inst = EngineInstance.GetEngineInstance(engine); Put("E", E, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("LN10", LN10, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("LN2", LN2, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("LOG2E", LOG2E, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("LOG10E", LOG10E, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("PI", PI, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("SQRT1_2", SQRT1_2, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); Put("SQRT2", SQRT2, PropertyAttributes.DontEnum | PropertyAttributes.DontDelete | PropertyAttributes.ReadOnly); AddBuiltin(inst, "abs"); AddBuiltin(inst, "acos"); AddBuiltin(inst, "asin"); AddBuiltin(inst, "atan"); AddBuiltin(inst, "atan2"); AddBuiltin(inst, "ceil"); AddBuiltin(inst, "exp"); AddBuiltin(inst, "floor"); AddBuiltin(inst, "log"); AddBuiltin(inst, "max"); AddBuiltin(inst, "min"); AddBuiltin(inst, "pow"); AddBuiltin(inst, "random"); AddBuiltin(inst, "round"); AddBuiltin(inst, "sin"); AddBuiltin(inst, "sqrt"); AddBuiltin(inst, "tan"); }
internal virtual Object Call(Object[] args, Object thisob, ScriptObject enclosing_scope, Closure calleeClosure, Binder binder, CultureInfo culture) { return(this.Call(args, thisob)); }
internal override AST PartiallyEvaluate() { this.BindName(); if (this.members == null || this.members.Length == 0) { //Give a warning, unless inside a with statement ScriptObject scope = Globals.ScopeStack.Peek(); while (scope is FunctionScope) { scope = scope.GetParent(); } if (!(scope is WithObject) || this.isFullyResolved) { this.context.HandleError(JSError.UndeclaredVariable, this.isFullyResolved && this.Engine.doFast); } } else { this.ResolveRHValue(); MemberInfo member = this.member; if (member is FieldInfo) { FieldInfo field = (FieldInfo)member; if (field is JSLocalField && !((JSLocalField)field).isDefined) { ((JSLocalField)field).isUsedBeforeDefinition = true; this.context.HandleError(JSError.VariableMightBeUnitialized); } if (field.IsLiteral) { Object val = field is JSVariableField ? ((JSVariableField)field).value : field.GetValue(null); if (val is AST) { AST pval = ((AST)val).PartiallyEvaluate(); if (pval is ConstantWrapper && this.isFullyResolved) { return(pval); } val = null; } if (!(val is FunctionObject) && this.isFullyResolved) { return(new ConstantWrapper(val, this.context)); } } else if (field.IsInitOnly && field.IsStatic && field.DeclaringType == Typeob.GlobalObject && this.isFullyResolved) { return(new ConstantWrapper(field.GetValue(null), this.context)); } } else if (member is PropertyInfo) { PropertyInfo prop = (PropertyInfo)member; if (!prop.CanWrite && !(prop is JSProperty) && prop.DeclaringType == Typeob.GlobalObject && this.isFullyResolved) { return(new ConstantWrapper(prop.GetValue(null, null), this.context)); } } if (member is Type && this.isFullyResolved) { return(new ConstantWrapper(member, this.context)); } } return(this); }
public override MemberInfo[] GetMember(String name, BindingFlags bindingAttr) { MemberInfoList mems = new MemberInfoList(); FieldInfo field = (FieldInfo)(this.name_table[name]); if (field != null) { if (field.IsPublic) { if ((bindingAttr & BindingFlags.Public) == 0) { goto parent; } } else { if ((bindingAttr & BindingFlags.NonPublic) == 0) { goto parent; } } if (field.IsLiteral) { Object val = ((JSMemberField)field).value; if (val is FunctionObject) { FunctionObject func = (FunctionObject)val; if (func.isConstructor) { return(new MemberInfo[0]); //Suppress constructors, they are awkward to handle. The compiler always obtains them via GetConstructor } if (func.isExpandoMethod) { if ((bindingAttr & BindingFlags.Instance) == 0) { goto parent; } mems.Add(field); } else { ((JSMemberField)field).AddOverloadedMembers(mems, this, bindingAttr | BindingFlags.DeclaredOnly); } goto parent; } else if (val is JSProperty) { JSProperty prop = (JSProperty)val; MethodInfo getterOrSetter = prop.getter != null ? prop.getter : prop.setter; if (getterOrSetter.IsStatic) { if ((bindingAttr & BindingFlags.Static) == 0) { goto parent; } } else { if ((bindingAttr & BindingFlags.Instance) == 0) { goto parent; } } mems.Add(prop); goto parent; } else if (val is ClassScope) { if ((bindingAttr & BindingFlags.Instance) != 0) { if (!((ClassScope)val).owner.isStatic) { mems.Add(field); goto parent; } } } } if (field.IsStatic) { if ((bindingAttr & BindingFlags.Static) == 0) { goto parent; } } else { if ((bindingAttr & BindingFlags.Instance) == 0) { goto parent; } } mems.Add(field); } parent: if (this.owner != null && this.owner.isInterface && ((bindingAttr & BindingFlags.DeclaredOnly) == 0)) { return(this.owner.GetInterfaceMember(name)); } if (this.parent != null && ((bindingAttr & BindingFlags.DeclaredOnly) == 0)) //Add any members found on the superclass { MemberInfo[] supMembers = this.parent.GetMember(name, bindingAttr); if (supMembers != null) { foreach (MemberInfo mem in supMembers) { if (mem.MemberType == MemberTypes.Field) { field = (FieldInfo)mem; if (!field.IsStatic && !field.IsLiteral && !(field is JSWrappedField)) { field = new JSWrappedField(field, this.parent); } mems.Add(field); } else { mems.Add(ScriptObject.WrapMember(mem, this.parent)); } } } } return(mems.ToArray()); }
internal ErrorPrototype(ScriptObject parent, String name) : base(parent) { this.name = name; //this.constructor is given a value by the constructor class }
// Initialize the prototype value from a subclass. internal void InitPrototype(ScriptObject parent) { this.prototypeValue = new JSPrototypeObject(parent.GetParent(), this); }
internal JSGlobalField(ScriptObject obj, string name, object value, FieldAttributes attributeFlags) : base(name, obj, attributeFlags) { base.value = value; this.ILField = null; }
internal FunctionScope(ScriptObject parent) : this(parent, false) { }
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)); }
internal JSObject(ScriptObject parent) : this(parent, true) { }
internal override AST PartiallyEvaluate() { this.BindName(); if ((base.members == null) || (base.members.Length == 0)) { ScriptObject parent = base.Globals.ScopeStack.Peek(); while (parent is FunctionScope) { parent = parent.GetParent(); } if (!(parent is WithObject) || base.isFullyResolved) { base.context.HandleError(JSError.UndeclaredVariable, base.isFullyResolved && base.Engine.doFast); } } else { base.ResolveRHValue(); MemberInfo member = base.member; if (member is FieldInfo) { FieldInfo field = (FieldInfo)member; if ((field is JSLocalField) && !((JSLocalField)field).isDefined) { ((JSLocalField)field).isUsedBeforeDefinition = true; base.context.HandleError(JSError.VariableMightBeUnitialized); } if (!field.IsLiteral) { if ((field.IsInitOnly && field.IsStatic) && ((field.DeclaringType == Typeob.GlobalObject) && base.isFullyResolved)) { return(new ConstantWrapper(field.GetValue(null), base.context)); } } else { object obj3 = (field is JSVariableField) ? ((JSVariableField)field).value : TypeReferences.GetConstantValue(field); if (obj3 is AST) { AST ast = ((AST)obj3).PartiallyEvaluate(); if ((ast is ConstantWrapper) && base.isFullyResolved) { return(ast); } obj3 = null; } if (!(obj3 is FunctionObject) && base.isFullyResolved) { return(new ConstantWrapper(obj3, base.context)); } } } else if (member is PropertyInfo) { PropertyInfo info3 = (PropertyInfo)member; if ((!info3.CanWrite && !(info3 is JSProperty)) && ((info3.DeclaringType == Typeob.GlobalObject) && base.isFullyResolved)) { return(new ConstantWrapper(info3.GetValue(null, null), base.context)); } } if ((member is Type) && base.isFullyResolved) { return(new ConstantWrapper(member, base.context)); } } return(this); }
internal MathObject(ScriptObject parent) : base(parent) { }
private void BindName() { int num = 0; int num2 = 0; ScriptObject parent = base.Globals.ScopeStack.Peek(); BindingFlags bindingAttr = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly; bool flag = false; bool flag2 = false; while (parent != null) { MemberInfo[] member = null; WithObject obj3 = parent as WithObject; if ((obj3 != null) && flag2) { member = obj3.GetMember(base.name, bindingAttr, false); } else { member = parent.GetMember(base.name, bindingAttr); } base.members = member; if (member.Length > 0) { break; } if (parent is WithObject) { base.isFullyResolved = base.isFullyResolved && ((WithObject)parent).isKnownAtCompileTime; num++; } else if (parent is ActivationObject) { base.isFullyResolved = base.isFullyResolved && ((ActivationObject)parent).isKnownAtCompileTime; if ((parent is BlockScope) || ((parent is FunctionScope) && ((FunctionScope)parent).mustSaveStackLocals)) { num++; } if (parent is ClassScope) { if (flag) { flag2 = true; } if (((ClassScope)parent).owner.isStatic) { bindingAttr &= ~BindingFlags.Instance; flag = true; } } } else if (parent is StackFrame) { num++; } num2++; parent = parent.GetParent(); } if (base.members.Length > 0) { this.lexLevel = num; this.evalLexLevel = num2; } }
internal DateObject(ScriptObject parent, double value) : base(parent) { this.value = (((value != value) || (value > 9.2233720368547758E+18)) || (value < -9.2233720368547758E+18)) ? double.NaN : Math.Round(value); base.noExpando = false; }
// Constructor. public GlobalField(FieldAttributes attributes, String name, ScriptObject obj, Object value) : base(attributes, name, obj, value) { // Nothing to do here. }
internal FunctionPrototype(ScriptObject parent) : base(parent) { }
internal WithObject(ScriptObject parent, Object contained_object) : this(parent, contained_object, false) { }
internal JSPrototypeObject(ScriptObject parent, ScriptFunction constructor) : base(parent, typeof(JSPrototypeObject)) { this.constructor = constructor; this.noExpando = false; }
internal VariableDeclaration(Context context, Lookup identifier, TypeExpression type, AST initializer, FieldAttributes attributes, CustomAttributeList customAttributes) : base(context) { if (initializer != null) { this.context.UpdateWith(initializer.context); } else if (type != null) { this.context.UpdateWith(type.context); } this.identifier = identifier; this.type = type; this.initializer = initializer; ScriptObject current_scope = (ScriptObject)Globals.ScopeStack.Peek(); while (current_scope is WithObject) //Can only happen at run time and only if there is an eval { current_scope = current_scope.GetParent(); } String name = this.identifier.ToString(); if (current_scope is ClassScope) { if (name == ((ClassScope)current_scope).name) { identifier.context.HandleError(JSError.CannotUseNameOfClass); name = name + " var"; } } else { if (attributes != (FieldAttributes)0) { this.context.HandleError(JSError.NotInsideClass); attributes = FieldAttributes.Public; } else { attributes |= FieldAttributes.Public; } } FieldInfo field = ((IActivationObject)current_scope).GetLocalField(name); if (field != null) { if (field.IsLiteral || current_scope is ClassScope || type != null) { identifier.context.HandleError(JSError.DuplicateName, true); } this.type = type = null; } if (current_scope is ActivationObject) { if (field == null || field is JSVariableField) { this.field = ((ActivationObject)current_scope).AddFieldOrUseExistingField(this.identifier.ToString(), Missing.Value, attributes); } else { this.field = ((ActivationObject)current_scope).AddNewField(this.identifier.ToString(), null, attributes); } } else { this.field = ((StackFrame)current_scope).AddNewField(this.identifier.ToString(), null, attributes | FieldAttributes.Static); } this.field.type = type; this.field.customAttributes = customAttributes; this.field.originalContext = context; if (this.field is JSLocalField) { // emit debug info for the local only if this block of code is in a section that has debug set ((JSLocalField)this.field).debugOn = this.identifier.context.document.debugOn; } this.completion = new Completion(); }
internal ActivationObject(ScriptObject parent) : base(parent) { this.name_table = new SimpleHashtable(32); this.field_table = new ArrayList(); }
protected override void TranslateToILObject(ILGenerator il, Type obType, bool noValue) { this.thereIsAnObjectOnTheStack = true; if (this.member is IWrappedMember) { Object obj = ((IWrappedMember)this.member).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, CompilerGlobals.stackFrameClass); 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, CompilerGlobals.stackFrameClass); 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(); } } }
// Constructor. internal JSPrototypeObject(ScriptObject parent, Object constructor) : base(parent) { this.constructor = constructor; }
internal override void TranslateToIL(ILGenerator il, Type rtype) { //This assumes that rtype == Void.class. bool savedInsideProtectedRegion = compilerGlobals.InsideProtectedRegion; compilerGlobals.InsideProtectedRegion = true; compilerGlobals.BreakLabelStack.Push(compilerGlobals.BreakLabelStack.Peek(0)); compilerGlobals.ContinueLabelStack.Push(compilerGlobals.ContinueLabelStack.Peek(0)); il.BeginExceptionBlock(); if (this.finally_block != null) { if (this.finallyHasControlFlowOutOfIt) { il.BeginExceptionBlock(); } if (this.handler != null) { il.BeginExceptionBlock(); } } this.body.TranslateToIL(il, Typeob.Void); if (this.tryEndContext != null) { this.tryEndContext.EmitLineInfo(il); } if (this.handler != null) { if (this.type == null) { il.BeginCatchBlock(Typeob.Exception); this.handler.context.EmitLineInfo(il); this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.jScriptExceptionValueMethod); } else { Type filterType = this.type.ToType(); if (Typeob.Exception.IsAssignableFrom(filterType)) { il.BeginCatchBlock(filterType); this.handler.context.EmitLineInfo(il); } else { il.BeginExceptFilterBlock(); this.handler.context.EmitLineInfo(il); this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.jScriptExceptionValueMethod); il.Emit(OpCodes.Isinst, filterType); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Cgt_Un); il.BeginCatchBlock(null); this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.jScriptExceptionValueMethod); Convert.Emit(this, il, Typeob.Object, filterType); } } Object tok = this.field is JSVariableField ? ((JSVariableField)this.field).GetMetaData() : this.field; if (tok is LocalBuilder) { il.Emit(OpCodes.Stloc, (LocalBuilder)tok); } else if (tok is FieldInfo) { il.Emit(OpCodes.Stsfld, (FieldInfo)tok); } else { Convert.EmitLdarg(il, (short)tok); } if (this.handler_scope != null) { if (!this.handler_scope.isKnownAtCompileTime) //I.e. eval or nested func { this.EmitILToLoadEngine(il); il.Emit(OpCodes.Ldstr, this.fieldName); ConstantWrapper.TranslateToILInt(il, this.handler_scope.scopeId); il.Emit(OpCodes.Call, Typeob.Try.GetMethod("PushHandlerScope")); Globals.ScopeStack.Push(this.handler_scope); il.BeginExceptionBlock(); } il.BeginScope(); // so that we can emit local scoped information for the handler variable if (this.context.document.debugOn) { this.handler_scope.EmitLocalInfoForFields(il); } } this.handler.TranslateToIL(il, Typeob.Void); if (this.handler_scope != null) { il.EndScope(); if (!this.handler_scope.isKnownAtCompileTime) //I.e. eval or nested func { il.BeginFinallyBlock(); this.EmitILToLoadEngine(il); il.Emit(OpCodes.Call, CompilerGlobals.popScriptObjectMethod); il.Emit(OpCodes.Pop); Globals.ScopeStack.Pop(); il.EndExceptionBlock(); } } il.EndExceptionBlock(); } if (this.finally_block != null) { bool savedInsideFinally = compilerGlobals.InsideFinally; int savedFinallyStackTop = compilerGlobals.FinallyStackTop; compilerGlobals.InsideFinally = true; compilerGlobals.FinallyStackTop = compilerGlobals.BreakLabelStack.Size(); il.BeginFinallyBlock(); this.finally_block.TranslateToIL(il, Typeob.Void); il.EndExceptionBlock(); compilerGlobals.InsideFinally = savedInsideFinally; compilerGlobals.FinallyStackTop = savedFinallyStackTop; if (this.finallyHasControlFlowOutOfIt) { il.BeginCatchBlock(Typeob.BreakOutOfFinally); il.Emit(OpCodes.Ldfld, Typeob.BreakOutOfFinally.GetField("target")); // don't need to go to 0 in the loop because 0 is the outmost block (i.e. function body) // and that would generate a JIT assert because the jump is sometimes outside the function for (int i = compilerGlobals.BreakLabelStack.Size() - 1, n = i; i > 0; i--) { il.Emit(OpCodes.Dup); ConstantWrapper.TranslateToILInt(il, i); Label lab = il.DefineLabel(); il.Emit(OpCodes.Blt_S, lab); il.Emit(OpCodes.Pop); if (savedInsideFinally && i < savedFinallyStackTop) { il.Emit(OpCodes.Rethrow); } else { il.Emit(OpCodes.Leave, (Label)compilerGlobals.BreakLabelStack.Peek(n - i)); } il.MarkLabel(lab); } il.Emit(OpCodes.Pop); il.BeginCatchBlock(Typeob.ContinueOutOfFinally); il.Emit(OpCodes.Ldfld, Typeob.ContinueOutOfFinally.GetField("target")); // don't need to go to 0 in the loop because 0 is the outmost block (i.e. function body) for (int i = compilerGlobals.ContinueLabelStack.Size() - 1, n = i; i > 0; i--) { il.Emit(OpCodes.Dup); ConstantWrapper.TranslateToILInt(il, i); Label lab = il.DefineLabel(); il.Emit(OpCodes.Blt_S, lab); il.Emit(OpCodes.Pop); if (savedInsideFinally && i < savedFinallyStackTop) { il.Emit(OpCodes.Rethrow); } else { il.Emit(OpCodes.Leave, (Label)compilerGlobals.ContinueLabelStack.Peek(n - i)); } il.MarkLabel(lab); } il.Emit(OpCodes.Pop); ScriptObject scope = Globals.ScopeStack.Peek(); while (scope != null && !(scope is FunctionScope)) { scope = scope.GetParent(); } if (scope != null && !savedInsideFinally) { il.BeginCatchBlock(Typeob.ReturnOutOfFinally); il.Emit(OpCodes.Pop); il.Emit(OpCodes.Leave, ((FunctionScope)scope).owner.returnLabel); } il.EndExceptionBlock(); } } compilerGlobals.InsideProtectedRegion = savedInsideProtectedRegion; compilerGlobals.BreakLabelStack.Pop(); compilerGlobals.ContinueLabelStack.Pop(); }
private void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo locale, ScriptObject scope) { if (this.IsStatic || this.IsLiteral) { if ((this.IsLiteral || this.IsInitOnly) && !(this.value is Missing)) { throw new JScriptException(JSError.AssignmentToReadOnly); } goto setValue; } if (this.obj != obj) { if (obj is JSObject) { FieldInfo field = ((JSObject)obj).GetField(this.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (field != null) { field.SetValue(obj, value, invokeAttr, binder, locale); return; } } throw new TargetException(); } if (!this.IsPublic && (scope == null || !this.IsAccessibleFrom(scope))) { if (((JSObject)this.obj).noExpando) { throw new JScriptException(JSError.NotAccessible, new Context(new DocumentContext("", null), this.Name)); } else { this.expandoValue = value; } return; } setValue: if (this.type != null) { this.value = Convert.Coerce(value, this.type); } else { this.value = value; } }
protected BooleanObject(ScriptObject prototype, Type subType) { throw new NotImplementedException(); }
internal bool IsAccessibleFrom(ScriptObject scope) { return(((JSMemberField)this.field).IsAccessibleFrom(scope)); }
private MemberInfo[] GetLocalMember(string name, BindingFlags bindingAttr, bool wrapMembers) { MemberInfo[] members = null; FieldInfo info = (this.name_table == null) ? null : ((FieldInfo)this.name_table[name]); if ((info == null) && this.isASubClass) { if (this.memberCache != null) { members = (MemberInfo[])this.memberCache[name]; if (members != null) { return(members); } } bindingAttr &= ~BindingFlags.NonPublic; members = this.subClassIR.GetMember(name, bindingAttr); if (members.Length == 0) { members = this.subClassIR.GetMember(name, (bindingAttr & ~BindingFlags.Instance) | BindingFlags.Static); } int length = members.Length; if (length > 0) { int num2 = 0; foreach (MemberInfo info2 in members) { if (IsHiddenMember(info2)) { num2++; } } if ((num2 > 0) && (((length != 1) || !(this is ObjectPrototype)) || (name != "ToString"))) { MemberInfo[] infoArray2 = new MemberInfo[length - num2]; int num3 = 0; foreach (MemberInfo info3 in members) { if (!IsHiddenMember(info3)) { infoArray2[num3++] = info3; } } members = infoArray2; } } if (((members == null) || (members.Length == 0)) && (((bindingAttr & BindingFlags.Public) != BindingFlags.Default) && ((bindingAttr & BindingFlags.Instance) != BindingFlags.Default))) { BindingFlags flags = ((bindingAttr & BindingFlags.IgnoreCase) | BindingFlags.Public) | BindingFlags.Instance; if (this is StringObject) { members = TypeReflector.GetTypeReflectorFor(Typeob.String).GetMember(name, flags); } else if (this is NumberObject) { members = TypeReflector.GetTypeReflectorFor(((NumberObject)this).baseType).GetMember(name, flags); } else if (this is BooleanObject) { members = TypeReflector.GetTypeReflectorFor(Typeob.Boolean).GetMember(name, flags); } else if (this is StringConstructor) { members = TypeReflector.GetTypeReflectorFor(Typeob.String).GetMember(name, (flags | BindingFlags.Static) & ~BindingFlags.Instance); } else if (this is BooleanConstructor) { members = TypeReflector.GetTypeReflectorFor(Typeob.Boolean).GetMember(name, (flags | BindingFlags.Static) & ~BindingFlags.Instance); } else if (this is ArrayWrapper) { members = TypeReflector.GetTypeReflectorFor(Typeob.Array).GetMember(name, flags); } } if ((members != null) && (members.Length > 0)) { if (wrapMembers) { members = ScriptObject.WrapMembers(members, this); } if (this.memberCache == null) { this.memberCache = new SimpleHashtable(0x20); } this.memberCache[name] = members; return(members); } } if (((bindingAttr & BindingFlags.IgnoreCase) != BindingFlags.Default) && ((members == null) || (members.Length == 0))) { members = null; IDictionaryEnumerator enumerator = this.name_table.GetEnumerator(); while (enumerator.MoveNext()) { if (string.Compare(enumerator.Key.ToString(), name, StringComparison.OrdinalIgnoreCase) == 0) { info = (FieldInfo)enumerator.Value; break; } } } if (info != null) { return(new MemberInfo[] { info }); } if (members == null) { members = new MemberInfo[0]; } return(members); }
internal NumberObject(ScriptObject parent, Type baseType) : base(parent) { this.baseType = baseType; this.value = 0.0; base.noExpando = false; }