src/jdk/nashorn/internal/objects/Global.java

Print this page




 209     /** ReferenceError object */
 210     @Property(name = "ReferenceError", attributes = Attribute.NOT_ENUMERABLE)
 211     public volatile Object referenceError;
 212 
 213     /** SyntaxError object */
 214     @Property(name = "SyntaxError", attributes = Attribute.NOT_ENUMERABLE)
 215     public volatile Object syntaxError;
 216 
 217     /** TypeError object */
 218     @Property(name = "TypeError", attributes = Attribute.NOT_ENUMERABLE)
 219     public volatile Object typeError;
 220 
 221     /** URIError object */
 222     @Property(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
 223     public volatile Object uriError;
 224 
 225     /** ArrayBuffer object */
 226     @Property(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
 227     public volatile Object arrayBuffer;
 228 




 229     /** TypedArray (int8) */
 230     @Property(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
 231     public volatile Object int8Array;
 232 
 233     /** TypedArray (uint8) */
 234     @Property(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
 235     public volatile Object uint8Array;
 236 
 237     /** TypedArray (uint8) - Clamped */
 238     @Property(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
 239     public volatile Object uint8ClampedArray;
 240 
 241     /** TypedArray (int16) */
 242     @Property(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
 243     public volatile Object int16Array;
 244 
 245     /** TypedArray (uint16) */
 246     @Property(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
 247     public volatile Object uint16Array;
 248 


 335     private ScriptFunction builtinRegExp;
 336     private ScriptFunction builtinString;
 337     private ScriptFunction builtinError;
 338     private ScriptFunction builtinEval;
 339     private ScriptFunction builtinEvalError;
 340     private ScriptFunction builtinRangeError;
 341     private ScriptFunction builtinReferenceError;
 342     private ScriptFunction builtinSyntaxError;
 343     private ScriptFunction builtinTypeError;
 344     private ScriptFunction builtinURIError;
 345     private ScriptObject   builtinPackages;
 346     private ScriptObject   builtinCom;
 347     private ScriptObject   builtinEdu;
 348     private ScriptObject   builtinJava;
 349     private ScriptObject   builtinJavafx;
 350     private ScriptObject   builtinJavax;
 351     private ScriptObject   builtinOrg;
 352     private ScriptObject   builtinJavaImporter;
 353     private ScriptObject   builtinJavaApi;
 354     private ScriptObject   builtinArrayBuffer;

 355     private ScriptObject   builtinInt8Array;
 356     private ScriptObject   builtinUint8Array;
 357     private ScriptObject   builtinUint8ClampedArray;
 358     private ScriptObject   builtinInt16Array;
 359     private ScriptObject   builtinUint16Array;
 360     private ScriptObject   builtinInt32Array;
 361     private ScriptObject   builtinUint32Array;
 362     private ScriptObject   builtinFloat32Array;
 363     private ScriptObject   builtinFloat64Array;
 364 
 365     /*
 366      * ECMA section 13.2.3 The [[ThrowTypeError]] Function Object
 367      */
 368     private ScriptFunction typeErrorThrower;
 369 
 370     // Flag to indicate that a split method issued a return statement
 371     private int splitState = -1;
 372 
 373     // Used to store the last RegExp result to support deprecated RegExp constructor properties
 374     private RegExpResult lastRegExpResult;


 849     ScriptObject getTypeErrorPrototype() {
 850         return ScriptFunction.getPrototype(builtinTypeError);
 851     }
 852 
 853     ScriptObject getURIErrorPrototype() {
 854         return ScriptFunction.getPrototype(builtinURIError);
 855     }
 856 
 857     ScriptObject getJavaImporterPrototype() {
 858         return ScriptFunction.getPrototype(builtinJavaImporter);
 859     }
 860 
 861     ScriptObject getJSAdapterPrototype() {
 862         return ScriptFunction.getPrototype(builtinJSAdapter);
 863     }
 864 
 865     ScriptObject getArrayBufferPrototype() {
 866         return ScriptFunction.getPrototype(builtinArrayBuffer);
 867     }
 868 




 869     ScriptObject getInt8ArrayPrototype() {
 870         return ScriptFunction.getPrototype(builtinInt8Array);
 871     }
 872 
 873     ScriptObject getUint8ArrayPrototype() {
 874         return ScriptFunction.getPrototype(builtinUint8Array);
 875     }
 876 
 877     ScriptObject getUint8ClampedArrayPrototype() {
 878         return ScriptFunction.getPrototype(builtinUint8ClampedArray);
 879     }
 880 
 881     ScriptObject getInt16ArrayPrototype() {
 882         return ScriptFunction.getPrototype(builtinInt16Array);
 883     }
 884 
 885     ScriptObject getUint16ArrayPrototype() {
 886         return ScriptFunction.getPrototype(builtinUint16Array);
 887     }
 888 


1617         }
1618 
1619         // add other special properties for exec support
1620         addOwnProperty(ScriptingFunctions.OUT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1621         addOwnProperty(ScriptingFunctions.ERR_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1622         addOwnProperty(ScriptingFunctions.EXIT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1623     }
1624 
1625     private static void copyOptions(final ScriptObject options, final ScriptEnvironment scriptEnv) {
1626         for (Field f : scriptEnv.getClass().getFields()) {
1627             try {
1628                 options.set(f.getName(), f.get(scriptEnv), false);
1629             } catch (final IllegalArgumentException | IllegalAccessException exp) {
1630                 throw new RuntimeException(exp);
1631             }
1632         }
1633     }
1634 
1635     private void initTypedArray() {
1636         this.builtinArrayBuffer       = initConstructor("ArrayBuffer");

1637         this.builtinInt8Array         = initConstructor("Int8Array");
1638         this.builtinUint8Array        = initConstructor("Uint8Array");
1639         this.builtinUint8ClampedArray = initConstructor("Uint8ClampedArray");
1640         this.builtinInt16Array        = initConstructor("Int16Array");
1641         this.builtinUint16Array       = initConstructor("Uint16Array");
1642         this.builtinInt32Array        = initConstructor("Int32Array");
1643         this.builtinUint32Array       = initConstructor("Uint32Array");
1644         this.builtinFloat32Array      = initConstructor("Float32Array");
1645         this.builtinFloat64Array      = initConstructor("Float64Array");
1646     }
1647 
1648     private void copyBuiltins() {
1649         this.array             = this.builtinArray;
1650         this._boolean          = this.builtinBoolean;
1651         this.date              = this.builtinDate;
1652         this.error             = this.builtinError;
1653         this.evalError         = this.builtinEvalError;
1654         this.function          = this.builtinFunction;
1655         this.jsadapter         = this.builtinJSAdapter;
1656         this.json              = this.builtinJSON;
1657         this.com               = this.builtinCom;
1658         this.edu               = this.builtinEdu;
1659         this.java              = this.builtinJava;
1660         this.javafx            = this.builtinJavafx;
1661         this.javax             = this.builtinJavax;
1662         this.org               = this.builtinOrg;
1663         this.javaImporter      = this.builtinJavaImporter;
1664         this.javaApi           = this.builtinJavaApi;
1665         this.math              = this.builtinMath;
1666         this.number            = this.builtinNumber;
1667         this.object            = this.builtinObject;
1668         this.packages          = this.builtinPackages;
1669         this.rangeError        = this.builtinRangeError;
1670         this.referenceError    = this.builtinReferenceError;
1671         this.regexp            = this.builtinRegExp;
1672         this.string            = this.builtinString;
1673         this.syntaxError       = this.builtinSyntaxError;
1674         this.typeError         = this.builtinTypeError;
1675         this.uriError          = this.builtinURIError;
1676         this.arrayBuffer       = this.builtinArrayBuffer;

1677         this.int8Array         = this.builtinInt8Array;
1678         this.uint8Array        = this.builtinUint8Array;
1679         this.uint8ClampedArray = this.builtinUint8ClampedArray;
1680         this.int16Array        = this.builtinInt16Array;
1681         this.uint16Array       = this.builtinUint16Array;
1682         this.int32Array        = this.builtinInt32Array;
1683         this.uint32Array       = this.builtinUint32Array;
1684         this.float32Array      = this.builtinFloat32Array;
1685         this.float64Array      = this.builtinFloat64Array;
1686     }
1687 
1688     private void initDebug() {
1689         this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug"));
1690     }
1691 
1692     @SuppressWarnings("resource")
1693     private static Object printImpl(final boolean newLine, final Object... objects) {
1694         final PrintWriter out = Global.getEnv().getOut();
1695         final StringBuilder sb = new StringBuilder();
1696 




 209     /** ReferenceError object */
 210     @Property(name = "ReferenceError", attributes = Attribute.NOT_ENUMERABLE)
 211     public volatile Object referenceError;
 212 
 213     /** SyntaxError object */
 214     @Property(name = "SyntaxError", attributes = Attribute.NOT_ENUMERABLE)
 215     public volatile Object syntaxError;
 216 
 217     /** TypeError object */
 218     @Property(name = "TypeError", attributes = Attribute.NOT_ENUMERABLE)
 219     public volatile Object typeError;
 220 
 221     /** URIError object */
 222     @Property(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
 223     public volatile Object uriError;
 224 
 225     /** ArrayBuffer object */
 226     @Property(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
 227     public volatile Object arrayBuffer;
 228 
 229     /** DataView object */
 230     @Property(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
 231     public volatile Object dataView;
 232 
 233     /** TypedArray (int8) */
 234     @Property(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
 235     public volatile Object int8Array;
 236 
 237     /** TypedArray (uint8) */
 238     @Property(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
 239     public volatile Object uint8Array;
 240 
 241     /** TypedArray (uint8) - Clamped */
 242     @Property(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
 243     public volatile Object uint8ClampedArray;
 244 
 245     /** TypedArray (int16) */
 246     @Property(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
 247     public volatile Object int16Array;
 248 
 249     /** TypedArray (uint16) */
 250     @Property(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
 251     public volatile Object uint16Array;
 252 


 339     private ScriptFunction builtinRegExp;
 340     private ScriptFunction builtinString;
 341     private ScriptFunction builtinError;
 342     private ScriptFunction builtinEval;
 343     private ScriptFunction builtinEvalError;
 344     private ScriptFunction builtinRangeError;
 345     private ScriptFunction builtinReferenceError;
 346     private ScriptFunction builtinSyntaxError;
 347     private ScriptFunction builtinTypeError;
 348     private ScriptFunction builtinURIError;
 349     private ScriptObject   builtinPackages;
 350     private ScriptObject   builtinCom;
 351     private ScriptObject   builtinEdu;
 352     private ScriptObject   builtinJava;
 353     private ScriptObject   builtinJavafx;
 354     private ScriptObject   builtinJavax;
 355     private ScriptObject   builtinOrg;
 356     private ScriptObject   builtinJavaImporter;
 357     private ScriptObject   builtinJavaApi;
 358     private ScriptObject   builtinArrayBuffer;
 359     private ScriptObject   builtinDataView;
 360     private ScriptObject   builtinInt8Array;
 361     private ScriptObject   builtinUint8Array;
 362     private ScriptObject   builtinUint8ClampedArray;
 363     private ScriptObject   builtinInt16Array;
 364     private ScriptObject   builtinUint16Array;
 365     private ScriptObject   builtinInt32Array;
 366     private ScriptObject   builtinUint32Array;
 367     private ScriptObject   builtinFloat32Array;
 368     private ScriptObject   builtinFloat64Array;
 369 
 370     /*
 371      * ECMA section 13.2.3 The [[ThrowTypeError]] Function Object
 372      */
 373     private ScriptFunction typeErrorThrower;
 374 
 375     // Flag to indicate that a split method issued a return statement
 376     private int splitState = -1;
 377 
 378     // Used to store the last RegExp result to support deprecated RegExp constructor properties
 379     private RegExpResult lastRegExpResult;


 854     ScriptObject getTypeErrorPrototype() {
 855         return ScriptFunction.getPrototype(builtinTypeError);
 856     }
 857 
 858     ScriptObject getURIErrorPrototype() {
 859         return ScriptFunction.getPrototype(builtinURIError);
 860     }
 861 
 862     ScriptObject getJavaImporterPrototype() {
 863         return ScriptFunction.getPrototype(builtinJavaImporter);
 864     }
 865 
 866     ScriptObject getJSAdapterPrototype() {
 867         return ScriptFunction.getPrototype(builtinJSAdapter);
 868     }
 869 
 870     ScriptObject getArrayBufferPrototype() {
 871         return ScriptFunction.getPrototype(builtinArrayBuffer);
 872     }
 873 
 874     ScriptObject getDataViewPrototype() {
 875         return ScriptFunction.getPrototype(builtinDataView);
 876     }
 877 
 878     ScriptObject getInt8ArrayPrototype() {
 879         return ScriptFunction.getPrototype(builtinInt8Array);
 880     }
 881 
 882     ScriptObject getUint8ArrayPrototype() {
 883         return ScriptFunction.getPrototype(builtinUint8Array);
 884     }
 885 
 886     ScriptObject getUint8ClampedArrayPrototype() {
 887         return ScriptFunction.getPrototype(builtinUint8ClampedArray);
 888     }
 889 
 890     ScriptObject getInt16ArrayPrototype() {
 891         return ScriptFunction.getPrototype(builtinInt16Array);
 892     }
 893 
 894     ScriptObject getUint16ArrayPrototype() {
 895         return ScriptFunction.getPrototype(builtinUint16Array);
 896     }
 897 


1626         }
1627 
1628         // add other special properties for exec support
1629         addOwnProperty(ScriptingFunctions.OUT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1630         addOwnProperty(ScriptingFunctions.ERR_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1631         addOwnProperty(ScriptingFunctions.EXIT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
1632     }
1633 
1634     private static void copyOptions(final ScriptObject options, final ScriptEnvironment scriptEnv) {
1635         for (Field f : scriptEnv.getClass().getFields()) {
1636             try {
1637                 options.set(f.getName(), f.get(scriptEnv), false);
1638             } catch (final IllegalArgumentException | IllegalAccessException exp) {
1639                 throw new RuntimeException(exp);
1640             }
1641         }
1642     }
1643 
1644     private void initTypedArray() {
1645         this.builtinArrayBuffer       = initConstructor("ArrayBuffer");
1646         this.builtinDataView          = initConstructor("DataView");
1647         this.builtinInt8Array         = initConstructor("Int8Array");
1648         this.builtinUint8Array        = initConstructor("Uint8Array");
1649         this.builtinUint8ClampedArray = initConstructor("Uint8ClampedArray");
1650         this.builtinInt16Array        = initConstructor("Int16Array");
1651         this.builtinUint16Array       = initConstructor("Uint16Array");
1652         this.builtinInt32Array        = initConstructor("Int32Array");
1653         this.builtinUint32Array       = initConstructor("Uint32Array");
1654         this.builtinFloat32Array      = initConstructor("Float32Array");
1655         this.builtinFloat64Array      = initConstructor("Float64Array");
1656     }
1657 
1658     private void copyBuiltins() {
1659         this.array             = this.builtinArray;
1660         this._boolean          = this.builtinBoolean;
1661         this.date              = this.builtinDate;
1662         this.error             = this.builtinError;
1663         this.evalError         = this.builtinEvalError;
1664         this.function          = this.builtinFunction;
1665         this.jsadapter         = this.builtinJSAdapter;
1666         this.json              = this.builtinJSON;
1667         this.com               = this.builtinCom;
1668         this.edu               = this.builtinEdu;
1669         this.java              = this.builtinJava;
1670         this.javafx            = this.builtinJavafx;
1671         this.javax             = this.builtinJavax;
1672         this.org               = this.builtinOrg;
1673         this.javaImporter      = this.builtinJavaImporter;
1674         this.javaApi           = this.builtinJavaApi;
1675         this.math              = this.builtinMath;
1676         this.number            = this.builtinNumber;
1677         this.object            = this.builtinObject;
1678         this.packages          = this.builtinPackages;
1679         this.rangeError        = this.builtinRangeError;
1680         this.referenceError    = this.builtinReferenceError;
1681         this.regexp            = this.builtinRegExp;
1682         this.string            = this.builtinString;
1683         this.syntaxError       = this.builtinSyntaxError;
1684         this.typeError         = this.builtinTypeError;
1685         this.uriError          = this.builtinURIError;
1686         this.arrayBuffer       = this.builtinArrayBuffer;
1687         this.dataView          = this.builtinDataView;
1688         this.int8Array         = this.builtinInt8Array;
1689         this.uint8Array        = this.builtinUint8Array;
1690         this.uint8ClampedArray = this.builtinUint8ClampedArray;
1691         this.int16Array        = this.builtinInt16Array;
1692         this.uint16Array       = this.builtinUint16Array;
1693         this.int32Array        = this.builtinInt32Array;
1694         this.uint32Array       = this.builtinUint32Array;
1695         this.float32Array      = this.builtinFloat32Array;
1696         this.float64Array      = this.builtinFloat64Array;
1697     }
1698 
1699     private void initDebug() {
1700         this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug"));
1701     }
1702 
1703     @SuppressWarnings("resource")
1704     private static Object printImpl(final boolean newLine, final Object... objects) {
1705         final PrintWriter out = Global.getEnv().getOut();
1706         final StringBuilder sb = new StringBuilder();
1707