The Labs \ Source Viewer \ SSCLI \ Microsoft.JScript \ LenientGlobalObject

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. namespace Microsoft.JScript
  16. {
  17.    
  18.     using Microsoft.JScript.Vsa;
  19.     using System;
  20.     using System.Reflection;
  21.     using System.Collections;
  22.    
  23.     public sealed class LenientGlobalObject : GlobalObject
  24.     {
  25.         // properties
  26.         public new object Infinity;
  27.         private object MathField;
  28.         public new object NaN;
  29.         public new object undefined;
  30.         // backing fields for constructor properties
  31.         private object ActiveXObjectField;
  32.         private object ArrayField;
  33.         private object BooleanField;
  34.         private object DateField;
  35.         private object EnumeratorField;
  36.         private object ErrorField;
  37.         private object EvalErrorField;
  38.         private object FunctionField;
  39.         private object NumberField;
  40.         private object ObjectField;
  41.         private object RangeErrorField;
  42.         private object ReferenceErrorField;
  43.         private object RegExpField;
  44.         private object StringField;
  45.         private object SyntaxErrorField;
  46.         private object TypeErrorField;
  47.         private object VBArrayField;
  48.         private object URIErrorField;
  49.        
  50.         // function properties
  51.         public new object decodeURI;
  52.         public new object decodeURIComponent;
  53.         public new object encodeURI;
  54.         public new object encodeURIComponent;
  55.         [NotRecommended("escape")]
  56.         public new object escape;
  57.         public new object eval;
  58.         public new object isNaN;
  59.         public new object isFinite;
  60.         public new object parseInt;
  61.         public new object parseFloat;
  62.         public new object GetObject;
  63.         public new object ScriptEngine;
  64.         public new object ScriptEngineBuildVersion;
  65.         public new object ScriptEngineMajorVersion;
  66.         public new object ScriptEngineMinorVersion;
  67.         [NotRecommended("unescape")]
  68.         public new object unescape;
  69.         // built-in types
  70.         public new object boolean;
  71.         public new object @byte;
  72.         public new object @char;
  73.         public new object @decimal;
  74.         public new object @double;
  75.         public new object @float;
  76.         public new object @int;
  77.         public new object @long;
  78.         public new object @sbyte;
  79.         public new object @short;
  80.         public new object @void;
  81.         public new object @uint;
  82.         public new object @ulong;
  83.         public new object @ushort;
  84.        
  85.         //backing fields for private properties used to initialize orignalXXX properties
  86.         private LenientArrayPrototype arrayPrototypeField;
  87.         private LenientFunctionPrototype functionPrototypeField;
  88.         private LenientObjectPrototype objectPrototypeField;
  89.         private VsaEngine engine;
  90.        
  91.         internal LenientGlobalObject(VsaEngine engine)
  92.         {
  93.             this.engine = engine;
  94.            
  95.             this.Infinity = Double.PositiveInfinity;
  96.             this.NaN = Double.NaN;
  97.             this.undefined = null;
  98.            
  99.             this.ActiveXObjectField = Missing.Value;
  100.             this.ArrayField = Missing.Value;
  101.             this.BooleanField = Missing.Value;
  102.             this.DateField = Missing.Value;
  103.             this.EnumeratorField = Missing.Value;
  104.             this.ErrorField = Missing.Value;
  105.             this.EvalErrorField = Missing.Value;
  106.             this.FunctionField = Missing.Value;
  107.             this.MathField = Missing.Value;
  108.             this.NumberField = Missing.Value;
  109.             this.ObjectField = Missing.Value;
  110.             this.RangeErrorField = Missing.Value;
  111.             this.ReferenceErrorField = Missing.Value;
  112.             this.RegExpField = Missing.Value;
  113.             this.StringField = Missing.Value;
  114.             this.SyntaxErrorField = Missing.Value;
  115.             this.TypeErrorField = Missing.Value;
  116.             this.VBArrayField = Missing.Value;
  117.             this.URIErrorField = Missing.Value;
  118.            
  119.             Type super = typeof(GlobalObject);
  120.             LenientFunctionPrototype fprot = this.functionPrototype;
  121.             this.decodeURI = new BuiltinFunction("decodeURI", this, super.GetMethod("decodeURI"), fprot);
  122.             this.decodeURIComponent = new BuiltinFunction("decodeURIComponent", this, super.GetMethod("decodeURIComponent"), fprot);
  123.             this.encodeURI = new BuiltinFunction("encodeURI", this, super.GetMethod("encodeURI"), fprot);
  124.             this.encodeURIComponent = new BuiltinFunction("encodeURIComponent", this, super.GetMethod("encodeURIComponent"), fprot);
  125.             this.escape = new BuiltinFunction("escape", this, super.GetMethod("escape"), fprot);
  126.             this.eval = new BuiltinFunction("eval", this, super.GetMethod("eval"), fprot);
  127.             this.isNaN = new BuiltinFunction("isNaN", this, super.GetMethod("isNaN"), fprot);
  128.             this.isFinite = new BuiltinFunction("isFinite", this, super.GetMethod("isFinite"), fprot);
  129.             this.parseInt = new BuiltinFunction("parseInt", this, super.GetMethod("parseInt"), fprot);
  130.             this.GetObject = new BuiltinFunction("GetObject", this, super.GetMethod("GetObject"), fprot);
  131.             this.parseFloat = new BuiltinFunction("parseFloat", this, super.GetMethod("parseFloat"), fprot);
  132.             this.ScriptEngine = new BuiltinFunction("ScriptEngine", this, super.GetMethod("ScriptEngine"), fprot);
  133.             this.ScriptEngineBuildVersion = new BuiltinFunction("ScriptEngineBuildVersion", this, super.GetMethod("ScriptEngineBuildVersion"), fprot);
  134.             this.ScriptEngineMajorVersion = new BuiltinFunction("ScriptEngineMajorVersion", this, super.GetMethod("ScriptEngineMajorVersion"), fprot);
  135.             this.ScriptEngineMinorVersion = new BuiltinFunction("ScriptEngineMinorVersion", this, super.GetMethod("ScriptEngineMinorVersion"), fprot);
  136.             this.unescape = new BuiltinFunction("unescape", this, super.GetMethod("unescape"), fprot);
  137.            
  138.             this.boolean = Typeob.Boolean;
  139.             this.@byte = Typeob.Byte;
  140.             this.@char = Typeob.Char;
  141.             this.@decimal = Typeob.Decimal;
  142.             this.@double = Typeob.Double;
  143.             this.@float = Typeob.Single;
  144.             this.@int = Typeob.Int32;
  145.             this.@long = Typeob.Int64;
  146.             this.@sbyte = Typeob.SByte;
  147.             this.@short = Typeob.Int16;
  148.             this.@void = Typeob.Void;
  149.             this.@uint = Typeob.UInt32;
  150.             this.@ulong = Typeob.UInt64;
  151.             this.@ushort = Typeob.UInt16;
  152.         }
  153.        
  154.         private LenientArrayPrototype arrayPrototype {
  155.             get {
  156.                 if (this.arrayPrototypeField == null)
  157.                     this.arrayPrototypeField = new LenientArrayPrototype(this.functionPrototype, this.objectPrototype);
  158.                 return this.arrayPrototypeField;
  159.             }
  160.         }
  161.        
  162.         private LenientFunctionPrototype functionPrototype {
  163.             get {
  164.                 if (this.functionPrototypeField == null) {
  165.                     object junk = this.objectPrototype;
  166.                     //initialize functionPrototypeField indiretly because of circularity
  167.                 }
  168.                 return this.functionPrototypeField;
  169.             }
  170.         }
  171.        
  172.         private LenientObjectPrototype objectPrototype {
  173.             get {
  174.                 if (this.objectPrototypeField == null) {
  175.                     LenientObjectPrototype prototype = this.objectPrototypeField = new LenientObjectPrototype(this.engine);
  176.                     LenientFunctionPrototype fprot = this.functionPrototypeField = new LenientFunctionPrototype(prototype);
  177.                     prototype.Initialize(fprot);
  178.                     JSObject prot = new JSObject(prototype, false);
  179.                     prot.AddField("constructor").SetValue(prot, fprot);
  180.                     fprot.proto = prot;
  181.                 }
  182.                 return this.objectPrototypeField;
  183.             }
  184.         }
  185.        
  186.         internal override ActiveXObjectConstructor originalActiveXObject {
  187.             get {
  188.                 if (this.originalActiveXObjectField == null)
  189.                     this.originalActiveXObjectField = new ActiveXObjectConstructor(this.functionPrototype);
  190.                 return this.originalActiveXObjectField;
  191.             }
  192.         }
  193.        
  194.         internal override ArrayConstructor originalArray {
  195.             get {
  196.                 if (this.originalArrayField == null)
  197.                     this.originalArrayField = new ArrayConstructor(this.functionPrototype, this.arrayPrototype);
  198.                 return this.originalArrayField;
  199.             }
  200.         }
  201.        
  202.         internal override BooleanConstructor originalBoolean {
  203.             get {
  204.                 if (this.originalBooleanField == null)
  205.                     this.originalBooleanField = new BooleanConstructor(this.functionPrototype, new LenientBooleanPrototype(this.functionPrototype, this.objectPrototype));
  206.                 return this.originalBooleanField;
  207.             }
  208.         }
  209.        
  210.         internal override DateConstructor originalDate {
  211.             get {
  212.                 if (this.originalDateField == null)
  213.                     this.originalDateField = new LenientDateConstructor(this.functionPrototype, new LenientDatePrototype(this.functionPrototype, this.objectPrototype));
  214.                 return this.originalDateField;
  215.             }
  216.         }
  217.        
  218.         internal override ErrorConstructor originalError {
  219.             get {
  220.                 if (this.originalErrorField == null)
  221.                     this.originalErrorField = new ErrorConstructor(this.functionPrototype, new LenientErrorPrototype(this.functionPrototype, this.objectPrototype, "Error"), this);
  222.                 return this.originalErrorField;
  223.             }
  224.         }
  225.        
  226.         internal override EnumeratorConstructor originalEnumerator {
  227.             get {
  228.                 if (this.originalEnumeratorField == null)
  229.                     this.originalEnumeratorField = new EnumeratorConstructor(this.functionPrototype, new LenientEnumeratorPrototype(this.functionPrototype, this.objectPrototype));
  230.                 return this.originalEnumeratorField;
  231.             }
  232.         }
  233.        
  234.         internal override ErrorConstructor originalEvalError {
  235.             get {
  236.                 if (this.originalEvalErrorField == null)
  237.                     this.originalEvalErrorField = new ErrorConstructor("EvalError", ErrorType.EvalError, this.originalError, this);
  238.                 return this.originalEvalErrorField;
  239.             }
  240.         }
  241.        
  242.         internal override FunctionConstructor originalFunction {
  243.             get {
  244.                 if (this.originalFunctionField == null)
  245.                     this.originalFunctionField = new FunctionConstructor(this.functionPrototype);
  246.                 return this.originalFunctionField;
  247.             }
  248.         }
  249.        
  250.         internal override NumberConstructor originalNumber {
  251.             get {
  252.                 if (this.originalNumberField == null)
  253.                     this.originalNumberField = new NumberConstructor(this.functionPrototype, new LenientNumberPrototype(this.functionPrototype, this.objectPrototype));
  254.                 return this.originalNumberField;
  255.             }
  256.         }
  257.        
  258.         internal override ObjectConstructor originalObject {
  259.             get {
  260.                 if (this.originalObjectField == null)
  261.                     this.originalObjectField = new ObjectConstructor(this.functionPrototype, this.objectPrototype);
  262.                 return this.originalObjectField;
  263.             }
  264.         }
  265.        
  266.         internal override ObjectPrototype originalObjectPrototype {
  267.             get {
  268.                 if (this.originalObjectPrototypeField == null)
  269.                     this.originalObjectPrototypeField = ObjectPrototype.ob;
  270.                 return this.originalObjectPrototypeField;
  271.             }
  272.         }
  273.        
  274.         internal override ErrorConstructor originalRangeError {
  275.             get {
  276.                 if (this.originalRangeErrorField == null)
  277.                     this.originalRangeErrorField = new ErrorConstructor("RangeError", ErrorType.RangeError, this.originalError, this);
  278.                 return this.originalRangeErrorField;
  279.             }
  280.         }
  281.        
  282.         internal override ErrorConstructor originalReferenceError {
  283.             get {
  284.                 if (this.originalReferenceErrorField == null)
  285.                     this.originalReferenceErrorField = new ErrorConstructor("ReferenceError", ErrorType.ReferenceError, this.originalError, this);
  286.                 return this.originalReferenceErrorField;
  287.             }
  288.         }
  289.        
  290.         internal override RegExpConstructor originalRegExp {
  291.             get {
  292.                 if (this.originalRegExpField == null)
  293.                     this.originalRegExpField = new RegExpConstructor(this.functionPrototype, new LenientRegExpPrototype(this.functionPrototype, this.objectPrototype), this.arrayPrototype);
  294.                 return this.originalRegExpField;
  295.             }
  296.         }
  297.        
  298.         internal override StringConstructor originalString {
  299.             get {
  300.                 if (this.originalStringField == null)
  301.                     this.originalStringField = new LenientStringConstructor(this.functionPrototype, new LenientStringPrototype(this.functionPrototype, this.objectPrototype));
  302.                 return this.originalStringField;
  303.             }
  304.         }
  305.        
  306.         internal override ErrorConstructor originalSyntaxError {
  307.             get {
  308.                 if (this.originalSyntaxErrorField == null)
  309.                     this.originalSyntaxErrorField = new ErrorConstructor("SyntaxError", ErrorType.SyntaxError, this.originalError, this);
  310.                 return this.originalSyntaxErrorField;
  311.             }
  312.         }
  313.        
  314.         internal override ErrorConstructor originalTypeError {
  315.             get {
  316.                 if (this.originalTypeErrorField == null)
  317.                     this.originalTypeErrorField = new ErrorConstructor("TypeError", ErrorType.TypeError, this.originalError, this);
  318.                 return this.originalTypeErrorField;
  319.             }
  320.         }
  321.        
  322.         internal override ErrorConstructor originalURIError {
  323.             get {
  324.                 if (this.originalURIErrorField == null)
  325.                     this.originalURIErrorField = new ErrorConstructor("URIError", ErrorType.URIError, this.originalError, this);
  326.                 return this.originalURIErrorField;
  327.             }
  328.         }
  329.        
  330.         internal override VBArrayConstructor originalVBArray {
  331.             get {
  332.                 if (this.originalVBArrayField == null)
  333.                     this.originalVBArrayField = new VBArrayConstructor(this.functionPrototype, new LenientVBArrayPrototype(this.functionPrototype, this.objectPrototype));
  334.                 return this.originalVBArrayField;
  335.             }
  336.         }
  337.        
  338.         public new object ActiveXObject {
  339.             get {
  340.                 if (this.ActiveXObjectField is Missing)
  341.                     this.ActiveXObjectField = this.originalActiveXObject;
  342.                 return this.ActiveXObjectField;
  343.             }
  344.             set { this.ActiveXObjectField = value; }
  345.         }
  346.        
  347.         public new object Array {
  348.             get {
  349.                 if (this.ArrayField is Missing)
  350.                     this.ArrayField = this.originalArray;
  351.                 return this.ArrayField;
  352.             }
  353.             set { this.ArrayField = value; }
  354.         }
  355.        
  356.         public new object Boolean {
  357.             get {
  358.                 if (this.BooleanField is Missing)
  359.                     this.BooleanField = this.originalBoolean;
  360.                 return this.BooleanField;
  361.             }
  362.             set { this.BooleanField = value; }
  363.         }
  364.        
  365.         public new object Date {
  366.             get {
  367.                 if (this.DateField is Missing)
  368.                     this.DateField = this.originalDate;
  369.                 return this.DateField;
  370.             }
  371.             set { this.DateField = value; }
  372.         }
  373.        
  374.         public new object Enumerator {
  375.             get {
  376.                 if (this.EnumeratorField is Missing)
  377.                     this.EnumeratorField = this.originalEnumerator;
  378.                 return this.EnumeratorField;
  379.             }
  380.             set { this.EnumeratorField = value; }
  381.         }
  382.        
  383.         public new object Error {
  384.             get {
  385.                 if (this.ErrorField is Missing)
  386.                     this.ErrorField = this.originalError;
  387.                 return this.ErrorField;
  388.             }
  389.             set { this.ErrorField = value; }
  390.         }
  391.        
  392.         public new object EvalError {
  393.             get {
  394.                 if (this.EvalErrorField is Missing)
  395.                     this.EvalErrorField = this.originalEvalError;
  396.                 return this.EvalErrorField;
  397.             }
  398.             set { this.EvalErrorField = value; }
  399.         }
  400.        
  401.         public new object Function {
  402.             get {
  403.                 if (this.FunctionField is Missing)
  404.                     this.FunctionField = this.originalFunction;
  405.                 return this.FunctionField;
  406.             }
  407.             set { this.FunctionField = value; }
  408.         }
  409.        
  410.         public new object Math {
  411.             get {
  412.                 if (this.MathField is Missing)
  413.                     this.MathField = new LenientMathObject(this.objectPrototype, this.functionPrototype);
  414.                 return this.MathField;
  415.             }
  416.             set { this.MathField = value; }
  417.         }
  418.        
  419.         public new object Number {
  420.             get {
  421.                 if (this.NumberField is Missing)
  422.                     this.NumberField = this.originalNumber;
  423.                 return this.NumberField;
  424.             }
  425.             set { this.NumberField = value; }
  426.         }
  427.        
  428.         public new object Object {
  429.             get {
  430.                 if (this.ObjectField is Missing)
  431.                     this.ObjectField = this.originalObject;
  432.                 return this.ObjectField;
  433.             }
  434.             set { this.ObjectField = value; }
  435.         }
  436.        
  437.         public new object RangeError {
  438.             get {
  439.                 if (this.RangeErrorField is Missing)
  440.                     this.RangeErrorField = this.originalRangeError;
  441.                 return this.RangeErrorField;
  442.             }
  443.             set { this.RangeErrorField = value; }
  444.         }
  445.        
  446.         public new object ReferenceError {
  447.             get {
  448.                 if (this.ReferenceErrorField is Missing)
  449.                     this.ReferenceErrorField = this.originalReferenceError;
  450.                 return this.ReferenceErrorField;
  451.             }
  452.             set { this.ReferenceErrorField = value; }
  453.         }
  454.        
  455.         public new object RegExp {
  456.             get {
  457.                 if (this.RegExpField is Missing)
  458.                     this.RegExpField = this.originalRegExp;
  459.                 return this.RegExpField;
  460.             }
  461.             set { this.RegExpField = value; }
  462.         }
  463.        
  464.         public new object String {
  465.             get {
  466.                 if (this.StringField is Missing)
  467.                     this.StringField = this.originalString;
  468.                 return this.StringField;
  469.             }
  470.             set { this.StringField = value; }
  471.         }
  472.        
  473.         public new object SyntaxError {
  474.             get {
  475.                 if (this.SyntaxErrorField is Missing)
  476.                     this.SyntaxErrorField = this.originalSyntaxError;
  477.                 return this.SyntaxErrorField;
  478.             }
  479.             set { this.SyntaxErrorField = value; }
  480.         }
  481.        
  482.         public new object TypeError {
  483.             get {
  484.                 if (this.TypeErrorField is Missing)
  485.                     this.TypeErrorField = this.originalTypeError;
  486.                 return this.TypeErrorField;
  487.             }
  488.             set { this.TypeErrorField = value; }
  489.         }
  490.        
  491.         public new object URIError {
  492.             get {
  493.                 if (this.URIErrorField is Missing)
  494.                     this.URIErrorField = this.originalURIError;
  495.                 return this.URIErrorField;
  496.             }
  497.             set { this.URIErrorField = value; }
  498.         }
  499.        
  500.         public new object VBArray {
  501.             get {
  502.                 if (this.VBArrayField is Missing)
  503.                     this.VBArrayField = this.originalVBArray;
  504.                 return this.VBArrayField;
  505.             }
  506.             set { this.VBArrayField = value; }
  507.         }
  508.     }
  509. }

Developer Fusion