37 import java.lang.invoke.MethodHandles;
38 import java.lang.invoke.MethodType;
39 import java.lang.invoke.SwitchPoint;
40 import java.lang.reflect.Field;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.List;
44 import java.util.Map;
45 import java.util.Objects;
46 import java.util.concurrent.Callable;
47 import java.util.concurrent.ConcurrentHashMap;
48 import javax.script.ScriptContext;
49 import javax.script.ScriptEngine;
50 import jdk.internal.dynalink.CallSiteDescriptor;
51 import jdk.internal.dynalink.linker.GuardedInvocation;
52 import jdk.internal.dynalink.linker.LinkRequest;
53 import jdk.nashorn.api.scripting.ClassFilter;
54 import jdk.nashorn.api.scripting.ScriptObjectMirror;
55 import jdk.nashorn.internal.lookup.Lookup;
56 import jdk.nashorn.internal.objects.annotations.Attribute;
57 import jdk.nashorn.internal.objects.annotations.Property;
58 import jdk.nashorn.internal.objects.annotations.ScriptClass;
59 import jdk.nashorn.internal.runtime.Context;
60 import jdk.nashorn.internal.runtime.ECMAErrors;
61 import jdk.nashorn.internal.runtime.GlobalConstants;
62 import jdk.nashorn.internal.runtime.GlobalFunctions;
63 import jdk.nashorn.internal.runtime.JSType;
64 import jdk.nashorn.internal.runtime.NativeJavaPackage;
65 import jdk.nashorn.internal.runtime.PropertyDescriptor;
66 import jdk.nashorn.internal.runtime.PropertyMap;
67 import jdk.nashorn.internal.runtime.Scope;
68 import jdk.nashorn.internal.runtime.ScriptEnvironment;
69 import jdk.nashorn.internal.runtime.ScriptFunction;
70 import jdk.nashorn.internal.runtime.ScriptObject;
71 import jdk.nashorn.internal.runtime.ScriptRuntime;
72 import jdk.nashorn.internal.runtime.ScriptingFunctions;
73 import jdk.nashorn.internal.runtime.Specialization;
74 import jdk.nashorn.internal.runtime.arrays.ArrayData;
75 import jdk.nashorn.internal.runtime.linker.Bootstrap;
76 import jdk.nashorn.internal.runtime.linker.InvokeByName;
77 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
78 import jdk.nashorn.internal.runtime.regexp.RegExpResult;
79 import jdk.nashorn.internal.scripts.JO;
80 import jdk.nashorn.tools.ShellFunctions;
81
82 /**
83 * Representation of global scope.
84 */
85 @ScriptClass("Global")
86 public final class Global extends ScriptObject implements Scope {
87 // Placeholder value used in place of a location property (__FILE__, __DIR__, __LINE__)
88 private static final Object LOCATION_PROPERTY_PLACEHOLDER = new Object();
89 private final InvokeByName TO_STRING = new InvokeByName("toString", ScriptObject.class);
90 private final InvokeByName VALUE_OF = new InvokeByName("valueOf", ScriptObject.class);
91
92 /**
93 * Optimistic builtin names that require switchpoint invalidation
94 * upon assignment. Overly conservative, but works for now, to avoid
95 * any complicated scope checks and especially heavy weight guards
96 * like
97 *
98 * <pre>
99 * public boolean setterGuard(final Object receiver) {
100 * final Global global = Global.instance();
101 * final ScriptObject sobj = global.getFunctionPrototype();
102 * final Object apply = sobj.get("apply");
103 * return apply == receiver;
104 * }
105 * </pre>
106 *
107 * Naturally, checking for builtin classes like NativeFunction is cheaper,
108 * it's when you start adding property checks for said builtins you have
109 * problems with guard speed.
110 */
111
197 @Property(name = "Function", attributes = Attribute.NOT_ENUMERABLE)
198 public volatile Object function;
199
200 /** ECMA 15.1.4.3 Array constructor. */
201 @Property(name = "Array", attributes = Attribute.NOT_ENUMERABLE)
202 public volatile Object array;
203
204 /** ECMA 15.1.4.4 String constructor */
205 @Property(name = "String", attributes = Attribute.NOT_ENUMERABLE)
206 public volatile Object string;
207
208 /** ECMA 15.1.4.5 Boolean constructor */
209 @Property(name = "Boolean", attributes = Attribute.NOT_ENUMERABLE)
210 public volatile Object _boolean;
211
212 /** ECMA 15.1.4.6 - Number constructor */
213 @Property(name = "Number", attributes = Attribute.NOT_ENUMERABLE)
214 public volatile Object number;
215
216 /** ECMA 15.1.4.7 Date constructor */
217 @Property(name = "Date", attributes = Attribute.NOT_ENUMERABLE)
218 public volatile Object date;
219
220 /** ECMA 15.1.4.8 RegExp constructor */
221 @Property(name = "RegExp", attributes = Attribute.NOT_ENUMERABLE)
222 public volatile Object regexp;
223
224 /** ECMA 15.12 - The JSON object */
225 @Property(name = "JSON", attributes = Attribute.NOT_ENUMERABLE)
226 public volatile Object json;
227
228 /** Nashorn extension: global.JSAdapter */
229 @Property(name = "JSAdapter", attributes = Attribute.NOT_ENUMERABLE)
230 public volatile Object jsadapter;
231
232 /** ECMA 15.8 - The Math object */
233 @Property(name = "Math", attributes = Attribute.NOT_ENUMERABLE)
234 public volatile Object math;
235
236 /** Error object */
237 @Property(name = "Error", attributes = Attribute.NOT_ENUMERABLE)
238 public volatile Object error;
239
240 /** EvalError object */
241 @Property(name = "EvalError", attributes = Attribute.NOT_ENUMERABLE)
242 public volatile Object evalError;
243
244 /** RangeError object */
245 @Property(name = "RangeError", attributes = Attribute.NOT_ENUMERABLE)
246 public volatile Object rangeError;
247
248 /** ReferenceError object */
249 @Property(name = "ReferenceError", attributes = Attribute.NOT_ENUMERABLE)
250 public volatile Object referenceError;
251
252 /** SyntaxError object */
253 @Property(name = "SyntaxError", attributes = Attribute.NOT_ENUMERABLE)
254 public volatile Object syntaxError;
255
256 /** TypeError object */
257 @Property(name = "TypeError", attributes = Attribute.NOT_ENUMERABLE)
258 public volatile Object typeError;
259
260 /** URIError object */
261 @Property(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
262 public volatile Object uriError;
263
264 /** ArrayBuffer object */
265 @Property(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
266 public volatile Object arrayBuffer;
267
268 /** DataView object */
269 @Property(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
270 public volatile Object dataView;
271
272 /** TypedArray (int8) */
273 @Property(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
274 public volatile Object int8Array;
275
276 /** TypedArray (uint8) */
277 @Property(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
278 public volatile Object uint8Array;
279
280 /** TypedArray (uint8) - Clamped */
281 @Property(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
282 public volatile Object uint8ClampedArray;
283
284 /** TypedArray (int16) */
285 @Property(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
286 public volatile Object int16Array;
287
288 /** TypedArray (uint16) */
289 @Property(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
290 public volatile Object uint16Array;
291
292 /** TypedArray (int32) */
293 @Property(name = "Int32Array", attributes = Attribute.NOT_ENUMERABLE)
294 public volatile Object int32Array;
295
296 /** TypedArray (uint32) */
297 @Property(name = "Uint32Array", attributes = Attribute.NOT_ENUMERABLE)
298 public volatile Object uint32Array;
299
300 /** TypedArray (float32) */
301 @Property(name = "Float32Array", attributes = Attribute.NOT_ENUMERABLE)
302 public volatile Object float32Array;
303
304 /** TypedArray (float64) */
305 @Property(name = "Float64Array", attributes = Attribute.NOT_ENUMERABLE)
306 public volatile Object float64Array;
307
308 /** Nashorn extension: Java access - global.Packages */
309 @Property(name = "Packages", attributes = Attribute.NOT_ENUMERABLE)
310 public volatile Object packages;
311
312 /** Nashorn extension: Java access - global.com */
313 @Property(attributes = Attribute.NOT_ENUMERABLE)
314 public volatile Object com;
315
316 /** Nashorn extension: Java access - global.edu */
317 @Property(attributes = Attribute.NOT_ENUMERABLE)
318 public volatile Object edu;
319
320 /** Nashorn extension: Java access - global.java */
321 @Property(attributes = Attribute.NOT_ENUMERABLE)
322 public volatile Object java;
323
324 /** Nashorn extension: Java access - global.javafx */
325 @Property(attributes = Attribute.NOT_ENUMERABLE)
326 public volatile Object javafx;
327
328 /** Nashorn extension: Java access - global.javax */
329 @Property(attributes = Attribute.NOT_ENUMERABLE)
330 public volatile Object javax;
331
332 /** Nashorn extension: Java access - global.org */
333 @Property(attributes = Attribute.NOT_ENUMERABLE)
334 public volatile Object org;
335
336 /** Nashorn extension: Java access - global.javaImporter */
337 @Property(name = "JavaImporter", attributes = Attribute.NOT_ENUMERABLE)
338 public volatile Object javaImporter;
339
340 /** Nashorn extension: global.Java Object constructor. */
341 @Property(name = "Java", attributes = Attribute.NOT_ENUMERABLE)
342 public volatile Object javaApi;
343
344 /** Nashorn extension: current script's file name */
345 @Property(name = "__FILE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
346 public final Object __FILE__ = LOCATION_PROPERTY_PLACEHOLDER;
347
348 /** Nashorn extension: current script's directory */
349 @Property(name = "__DIR__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
350 public final Object __DIR__ = LOCATION_PROPERTY_PLACEHOLDER;
351
352 /** Nashorn extension: current source line number being executed */
353 @Property(name = "__LINE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
354 public final Object __LINE__ = LOCATION_PROPERTY_PLACEHOLDER;
355
356 /** Used as Date.prototype's default value */
357 public NativeDate DEFAULT_DATE;
358
359 /** Used as RegExp.prototype's default value */
360 public NativeRegExp DEFAULT_REGEXP;
361
362 /*
363 * Built-in constructor objects: Even if user changes dynamic values of
364 * "Object", "Array" etc., we still want to keep original values of these
365 * constructors here. For example, we need to be able to create array,
366 * regexp literals even after user overwrites global "Array" or "RegExp"
367 * constructor - see also ECMA 262 spec. Annex D.
368 */
369 private ScriptFunction builtinFunction;
370 private ScriptFunction builtinObject;
371 private ScriptFunction builtinArray;
372 private ScriptFunction builtinBoolean;
373 private ScriptFunction builtinDate;
374 private ScriptObject builtinJSON;
375 private ScriptFunction builtinJSAdapter;
376 private ScriptObject builtinMath;
377 private ScriptFunction builtinNumber;
378 private ScriptFunction builtinRegExp;
379 private ScriptFunction builtinString;
380 private ScriptFunction builtinError;
1040 return ScriptFunction.getPrototype(builtinObject);
1041 }
1042
1043 ScriptObject getFunctionPrototype() {
1044 return ScriptFunction.getPrototype(builtinFunction);
1045 }
1046
1047 ScriptObject getArrayPrototype() {
1048 return ScriptFunction.getPrototype(builtinArray);
1049 }
1050
1051 ScriptObject getBooleanPrototype() {
1052 return ScriptFunction.getPrototype(builtinBoolean);
1053 }
1054
1055 ScriptObject getNumberPrototype() {
1056 return ScriptFunction.getPrototype(builtinNumber);
1057 }
1058
1059 ScriptObject getDatePrototype() {
1060 return ScriptFunction.getPrototype(builtinDate);
1061 }
1062
1063 ScriptObject getRegExpPrototype() {
1064 return ScriptFunction.getPrototype(builtinRegExp);
1065 }
1066
1067 ScriptObject getStringPrototype() {
1068 return ScriptFunction.getPrototype(builtinString);
1069 }
1070
1071 ScriptObject getErrorPrototype() {
1072 return ScriptFunction.getPrototype(builtinError);
1073 }
1074
1075 ScriptObject getEvalErrorPrototype() {
1076 return ScriptFunction.getPrototype(builtinEvalError);
1077 }
1078
1079 ScriptObject getRangeErrorPrototype() {
1080 return ScriptFunction.getPrototype(builtinRangeError);
1081 }
1082
1083 ScriptObject getReferenceErrorPrototype() {
1084 return ScriptFunction.getPrototype(builtinReferenceError);
1085 }
1086
1087 ScriptObject getSyntaxErrorPrototype() {
1088 return ScriptFunction.getPrototype(builtinSyntaxError);
1089 }
1090
1091 ScriptObject getTypeErrorPrototype() {
1092 return ScriptFunction.getPrototype(builtinTypeError);
1093 }
1094
1095 ScriptObject getURIErrorPrototype() {
1096 return ScriptFunction.getPrototype(builtinURIError);
1097 }
1098
1099 ScriptObject getJavaImporterPrototype() {
1100 return ScriptFunction.getPrototype(builtinJavaImporter);
1101 }
1102
1103 ScriptObject getJSAdapterPrototype() {
1104 return ScriptFunction.getPrototype(builtinJSAdapter);
1105 }
1106
1107 ScriptObject getArrayBufferPrototype() {
1108 return ScriptFunction.getPrototype(builtinArrayBuffer);
1109 }
1110
1111 ScriptObject getDataViewPrototype() {
1112 return ScriptFunction.getPrototype(builtinDataView);
1113 }
1114
1115 ScriptObject getInt8ArrayPrototype() {
1116 return ScriptFunction.getPrototype(builtinInt8Array);
1117 }
1118
1119 ScriptObject getUint8ArrayPrototype() {
1120 return ScriptFunction.getPrototype(builtinUint8Array);
1121 }
1122
1123 ScriptObject getUint8ClampedArrayPrototype() {
1124 return ScriptFunction.getPrototype(builtinUint8ClampedArray);
1125 }
1126
1127 ScriptObject getInt16ArrayPrototype() {
1128 return ScriptFunction.getPrototype(builtinInt16Array);
1129 }
1130
1131 ScriptObject getUint16ArrayPrototype() {
1132 return ScriptFunction.getPrototype(builtinUint16Array);
1133 }
1134
1135 ScriptObject getInt32ArrayPrototype() {
1136 return ScriptFunction.getPrototype(builtinInt32Array);
1137 }
1138
1139 ScriptObject getUint32ArrayPrototype() {
1140 return ScriptFunction.getPrototype(builtinUint32Array);
1141 }
1142
1143 ScriptObject getFloat32ArrayPrototype() {
1144 return ScriptFunction.getPrototype(builtinFloat32Array);
1145 }
1146
1147 ScriptObject getFloat64ArrayPrototype() {
1148 return ScriptFunction.getPrototype(builtinFloat64Array);
1149 }
1150
1151 private ScriptFunction getBuiltinArray() {
1152 return builtinArray;
1153 }
1154
1155 ScriptFunction getTypeErrorThrower() {
1156 return typeErrorThrower;
1157 }
1158
1159 /**
1160 * Called from compiled script code to test if builtin has been overridden
1161 *
1162 * @return true if builtin array has not been overridden
1163 */
1164 public static boolean isBuiltinArray() {
1165 final Global instance = Global.instance();
1166 return instance.array == instance.getBuiltinArray();
1167 }
1168
1169 private ScriptFunction getBuiltinBoolean() {
1170 return builtinBoolean;
1171 }
1172
1173 /**
1174 * Called from compiled script code to test if builtin has been overridden
1175 *
1176 * @return true if builtin boolean has not been overridden
1177 */
1178 public static boolean isBuiltinBoolean() {
1179 final Global instance = Global.instance();
1180 return instance._boolean == instance.getBuiltinBoolean();
1181 }
1182
1183 private ScriptFunction getBuiltinDate() {
1184 return builtinDate;
1185 }
1186
1187 /**
1188 * Called from compiled script code to test if builtin has been overridden
1189 *
1190 * @return true if builtin date has not been overridden
1191 */
1192 public static boolean isBuiltinDate() {
1193 final Global instance = Global.instance();
1194 return instance.date == instance.getBuiltinDate();
1195 }
1196
1197 private ScriptFunction getBuiltinError() {
1198 return builtinError;
1199 }
1200
1201 /**
1202 * Called from compiled script code to test if builtin has been overridden
1203 *
1204 * @return true if builtin error has not been overridden
1205 */
1206 public static boolean isBuiltinError() {
1207 final Global instance = Global.instance();
1208 return instance.error == instance.getBuiltinError();
1209 }
1210
1211 private ScriptFunction getBuiltinEvalError() {
1212 return builtinEvalError;
1213 }
1214
1215 /**
1216 * Called from compiled script code to test if builtin has been overridden
1217 *
1218 * @return true if builtin eval error has not been overridden
1219 */
1220 public static boolean isBuiltinEvalError() {
1221 final Global instance = Global.instance();
1222 return instance.evalError == instance.getBuiltinEvalError();
1223 }
1224
1225 private ScriptFunction getBuiltinFunction() {
1226 return builtinFunction;
1227 }
1228
1229 /**
1230 * Called from compiled script code to test if builtin has been overridden
1231 *
1232 * @return true if builtin function has not been overridden
1233 */
1234 public static boolean isBuiltinFunction() {
1235 final Global instance = Global.instance();
1236 return instance.function == instance.getBuiltinFunction();
1237 }
1238
1239 /**
1240 * Get the switchpoint used to check property changes for Function.prototype.apply
1241 * @return the switchpoint guarding apply (same as guarding call, and everything else in function)
1242 */
1253 final boolean isBuiltinFunction = instance.function == builtinFunction;
1254 return isBuiltinFunction && ScriptFunction.getPrototype(builtinFunction).getProperty(name).isBuiltin();
1255 }
1256
1257 /**
1258 * Check if the Function.prototype.apply has not been replaced
1259 * @return true if Function.prototype.apply has been replaced
1260 */
1261 public static boolean isBuiltinFunctionPrototypeApply() {
1262 return isBuiltinFunctionProperty("apply");
1263 }
1264
1265 /**
1266 * Check if the Function.prototype.apply has not been replaced
1267 * @return true if Function.prototype.call has been replaced
1268 */
1269 public static boolean isBuiltinFunctionPrototypeCall() {
1270 return isBuiltinFunctionProperty("call");
1271 }
1272
1273 private ScriptFunction getBuiltinJSAdapter() {
1274 return builtinJSAdapter;
1275 }
1276
1277 /**
1278 * Called from compiled script code to test if builtin has been overridden
1279 *
1280 * @return true if builtin JSAdapter has not been overridden
1281 */
1282 public static boolean isBuiltinJSAdapter() {
1283 final Global instance = Global.instance();
1284 return instance.jsadapter == instance.getBuiltinJSAdapter();
1285 }
1286
1287 private ScriptObject getBuiltinJSON() {
1288 return builtinJSON;
1289 }
1290
1291 /**
1292 * Called from compiled script code to test if builtin has been overridden
1293 *
1294 * @return true if builtin JSON has has not been overridden
1295 */
1296 public static boolean isBuiltinJSON() {
1297 final Global instance = Global.instance();
1298 return instance.json == instance.getBuiltinJSON();
1299 }
1300
1301 private ScriptObject getBuiltinJava() {
1302 return builtinJava;
1303 }
1304
1305 /**
1306 * Called from compiled script code to test if builtin has been overridden
1307 *
1308 * @return true if builtin Java has not been overridden
1309 */
1310 public static boolean isBuiltinJava() {
1311 final Global instance = Global.instance();
1312 return instance.java == instance.getBuiltinJava();
1313 }
1314
1315 private ScriptObject getBuiltinJavax() {
1316 return builtinJavax;
1317 }
1318
1319 /**
1320 * Called from compiled script code to test if builtin has been overridden
1321 *
1322 * @return true if builtin Javax has not been overridden
1323 */
1324 public static boolean isBuiltinJavax() {
1325 final Global instance = Global.instance();
1326 return instance.javax == instance.getBuiltinJavax();
1327 }
1328
1329 private ScriptObject getBuiltinJavaImporter() {
1330 return builtinJavaImporter;
1331 }
1332
1333 /**
1334 * Called from compiled script code to test if builtin has been overridden
1335 *
1336 * @return true if builtin Java importer has not been overridden
1337 */
1338 public static boolean isBuiltinJavaImporter() {
1339 final Global instance = Global.instance();
1340 return instance.javaImporter == instance.getBuiltinJavaImporter();
1341 }
1342
1343 private ScriptObject getBuiltinMath() {
1344 return builtinMath;
1345 }
1346
1347 /**
1348 * Called from compiled script code to test if builtin has been overridden
1349 *
1350 * @return true if builtin math has not been overridden
1351 */
1352 public static boolean isBuiltinMath() {
1353 final Global instance = Global.instance();
1354 return instance.math == instance.getBuiltinMath();
1355 }
1356
1357 private ScriptFunction getBuiltinNumber() {
1358 return builtinNumber;
1359 }
1360
1361 /**
1362 * Called from compiled script code to test if builtin has been overridden
1363 *
1364 * @return true if builtin number has not been overridden
1365 */
1366 public static boolean isBuiltinNumber() {
1367 final Global instance = Global.instance();
1368 return instance.number == instance.getBuiltinNumber();
1369 }
1370
1371 private ScriptFunction getBuiltinObject() {
1372 return builtinObject;
1373 }
1374
1379 */
1380 public static boolean isBuiltinObject() {
1381 final Global instance = Global.instance();
1382 return instance.object == instance.getBuiltinObject();
1383 }
1384
1385 private ScriptObject getBuiltinPackages() {
1386 return builtinPackages;
1387 }
1388
1389 /**
1390 * Called from compiled script code to test if builtin has been overridden
1391 *
1392 * @return true if builtin package has not been overridden
1393 */
1394 public static boolean isBuiltinPackages() {
1395 final Global instance = Global.instance();
1396 return instance.packages == instance.getBuiltinPackages();
1397 }
1398
1399 private ScriptFunction getBuiltinRangeError() {
1400 return builtinRangeError;
1401 }
1402
1403 /**
1404 * Called from compiled script code to test if builtin has been overridden
1405 *
1406 * @return true if builtin range error has not been overridden
1407 */
1408 public static boolean isBuiltinRangeError() {
1409 final Global instance = Global.instance();
1410 return instance.rangeError == instance.getBuiltinRangeError();
1411 }
1412
1413 private ScriptFunction getBuiltinReferenceError() {
1414 return builtinReferenceError;
1415 }
1416
1417 /**
1418 * Called from compiled script code to test if builtin has been overridden
1419 *
1420 * @return true if builtin reference error has not been overridden
1421 */
1422 public static boolean isBuiltinReferenceError() {
1423 final Global instance = Global.instance();
1424 return instance.referenceError == instance.getBuiltinReferenceError();
1425 }
1426
1427 private ScriptFunction getBuiltinRegExp() {
1428 return builtinRegExp;
1429 }
1430
1431 /**
1432 * Called from compiled script code to test if builtin has been overridden
1433 *
1434 * @return true if builtin regexp has not been overridden
1435 */
1436 public static boolean isBuiltinRegExp() {
1437 final Global instance = Global.instance();
1438 return instance.regexp == instance.getBuiltinRegExp();
1439 }
1440
1441 private ScriptFunction getBuiltinString() {
1442 return builtinString;
1443 }
1444
1445 /**
1446 * Called from compiled script code to test if builtin has been overridden
1447 *
1448 * @return true if builtin Java has not been overridden
1449 */
1450 public static boolean isBuiltinString() {
1451 final Global instance = Global.instance();
1452 return instance.string == instance.getBuiltinString();
1453 }
1454
1455 private ScriptFunction getBuiltinSyntaxError() {
1456 return builtinSyntaxError;
1457 }
1458
1463 */
1464 public static boolean isBuiltinSyntaxError() {
1465 final Global instance = Global.instance();
1466 return instance.syntaxError == instance.getBuiltinSyntaxError();
1467 }
1468
1469 private ScriptFunction getBuiltinTypeError() {
1470 return builtinTypeError;
1471 }
1472
1473 /**
1474 * Called from compiled script code to test if builtin has been overridden
1475 *
1476 * @return true if builtin type error has not been overridden
1477 */
1478 public static boolean isBuiltinTypeError() {
1479 final Global instance = Global.instance();
1480 return instance.typeError == instance.getBuiltinTypeError();
1481 }
1482
1483 private ScriptFunction getBuiltinURIError() {
1484 return builtinURIError;
1485 }
1486
1487 /**
1488 * Called from compiled script code to test if builtin has been overridden
1489 *
1490 * @return true if builtin URI error has not been overridden
1491 */
1492 public static boolean isBuiltinURIError() {
1493 final Global instance = Global.instance();
1494 return instance.uriError == instance.getBuiltinURIError();
1495 }
1496
1497 @Override
1498 public String getClassName() {
1499 return "global";
1500 }
1501
1502 /**
1503 * Copy function used to clone NativeRegExp objects.
1504 *
1505 * @param regexp a NativeRegExp to clone
1506 *
1507 * @return copy of the given regexp object
1508 */
1509 public static Object regExpCopy(final Object regexp) {
1510 return new NativeRegExp((NativeRegExp)regexp);
1511 }
1512
1513 /**
1514 * Convert given object to NativeRegExp type.
1886 new Specialization(GlobalFunctions.IS_NAN_J),
1887 new Specialization(GlobalFunctions.IS_NAN_D) });
1888 this.parseFloat = ScriptFunctionImpl.makeFunction("parseFloat", GlobalFunctions.PARSEFLOAT);
1889 this.isNaN = ScriptFunctionImpl.makeFunction("isNaN", GlobalFunctions.IS_NAN);
1890 this.isFinite = ScriptFunctionImpl.makeFunction("isFinite", GlobalFunctions.IS_FINITE);
1891 this.encodeURI = ScriptFunctionImpl.makeFunction("encodeURI", GlobalFunctions.ENCODE_URI);
1892 this.encodeURIComponent = ScriptFunctionImpl.makeFunction("encodeURIComponent", GlobalFunctions.ENCODE_URICOMPONENT);
1893 this.decodeURI = ScriptFunctionImpl.makeFunction("decodeURI", GlobalFunctions.DECODE_URI);
1894 this.decodeURIComponent = ScriptFunctionImpl.makeFunction("decodeURIComponent", GlobalFunctions.DECODE_URICOMPONENT);
1895 this.escape = ScriptFunctionImpl.makeFunction("escape", GlobalFunctions.ESCAPE);
1896 this.unescape = ScriptFunctionImpl.makeFunction("unescape", GlobalFunctions.UNESCAPE);
1897 this.print = ScriptFunctionImpl.makeFunction("print", env._print_no_newline ? PRINT : PRINTLN);
1898 this.load = ScriptFunctionImpl.makeFunction("load", LOAD);
1899 this.loadWithNewGlobal = ScriptFunctionImpl.makeFunction("loadWithNewGlobal", LOAD_WITH_NEW_GLOBAL);
1900 this.exit = ScriptFunctionImpl.makeFunction("exit", EXIT);
1901 this.quit = ScriptFunctionImpl.makeFunction("quit", EXIT);
1902
1903 // built-in constructors
1904 this.builtinArray = initConstructorAndSwitchPoint("Array", ScriptFunction.class);
1905 this.builtinBoolean = initConstructorAndSwitchPoint("Boolean", ScriptFunction.class);
1906 this.builtinDate = initConstructorAndSwitchPoint("Date", ScriptFunction.class);
1907 this.builtinJSON = initConstructorAndSwitchPoint("JSON", ScriptObject.class);
1908 this.builtinJSAdapter = initConstructorAndSwitchPoint("JSAdapter", ScriptFunction.class);
1909 this.builtinMath = initConstructorAndSwitchPoint("Math", ScriptObject.class);
1910 this.builtinNumber = initConstructorAndSwitchPoint("Number", ScriptFunction.class);
1911 this.builtinRegExp = initConstructorAndSwitchPoint("RegExp", ScriptFunction.class);
1912 this.builtinString = initConstructorAndSwitchPoint("String", ScriptFunction.class);
1913
1914 // initialize String.prototype.length to 0
1915 // add String.prototype.length
1916 final ScriptObject stringPrototype = getStringPrototype();
1917 stringPrototype.addOwnProperty("length", Attribute.NON_ENUMERABLE_CONSTANT, 0.0);
1918
1919 // set isArray flag on Array.prototype
1920 final ScriptObject arrayPrototype = getArrayPrototype();
1921 arrayPrototype.setIsArray();
1922
1923 this.DEFAULT_DATE = new NativeDate(Double.NaN, this);
1924
1925 // initialize default regexp object
1926 this.DEFAULT_REGEXP = new NativeRegExp("(?:)", this);
1927
1928 // RegExp.prototype should behave like a RegExp object. So copy the
1929 // properties.
1930 final ScriptObject regExpProto = getRegExpPrototype();
1931 regExpProto.addBoundProperties(DEFAULT_REGEXP);
1932
1933 // Error stuff
1934 initErrorObjects();
1935
1936 // java access
1937 if (! env._no_java) {
1938 initJavaAccess();
1939 }
1940
1941 if (! env._no_typed_arrays) {
1942 initTypedArray();
1943 }
1944
1945 if (env._scripting) {
1946 initScripting(env);
1947 }
1948
1949 if (Context.DEBUG) {
1950 boolean debugOkay;
1951 final SecurityManager sm = System.getSecurityManager();
1952 if (sm != null) {
1953 try {
1954 sm.checkPermission(new RuntimePermission(Context.NASHORN_DEBUG_MODE));
1955 debugOkay = true;
1956 } catch (final SecurityException ignored) {
1957 // if no permission, don't initialize Debug object
1958 debugOkay = false;
1959 }
1960
1961 } else {
1962 debugOkay = true;
1996 errorProto.addOwnProperty("stack", Attribute.NOT_ENUMERABLE, getStack, setStack);
1997 final ScriptFunction getLineNumber = ScriptFunctionImpl.makeFunction("getLineNumber", NativeError.GET_LINENUMBER);
1998 final ScriptFunction setLineNumber = ScriptFunctionImpl.makeFunction("setLineNumber", NativeError.SET_LINENUMBER);
1999 errorProto.addOwnProperty("lineNumber", Attribute.NOT_ENUMERABLE, getLineNumber, setLineNumber);
2000 final ScriptFunction getColumnNumber = ScriptFunctionImpl.makeFunction("getColumnNumber", NativeError.GET_COLUMNNUMBER);
2001 final ScriptFunction setColumnNumber = ScriptFunctionImpl.makeFunction("setColumnNumber", NativeError.SET_COLUMNNUMBER);
2002 errorProto.addOwnProperty("columnNumber", Attribute.NOT_ENUMERABLE, getColumnNumber, setColumnNumber);
2003 final ScriptFunction getFileName = ScriptFunctionImpl.makeFunction("getFileName", NativeError.GET_FILENAME);
2004 final ScriptFunction setFileName = ScriptFunctionImpl.makeFunction("setFileName", NativeError.SET_FILENAME);
2005 errorProto.addOwnProperty("fileName", Attribute.NOT_ENUMERABLE, getFileName, setFileName);
2006
2007 // ECMA 15.11.4.2 Error.prototype.name
2008 // Error.prototype.name = "Error";
2009 errorProto.set(NativeError.NAME, "Error", 0);
2010 // ECMA 15.11.4.3 Error.prototype.message
2011 // Error.prototype.message = "";
2012 errorProto.set(NativeError.MESSAGE, "", 0);
2013
2014 tagBuiltinProperties("Error", builtinError);
2015
2016 this.builtinEvalError = initErrorSubtype("EvalError", errorProto);
2017 this.builtinRangeError = initErrorSubtype("RangeError", errorProto);
2018 this.builtinReferenceError = initErrorSubtype("ReferenceError", errorProto);
2019 this.builtinSyntaxError = initErrorSubtype("SyntaxError", errorProto);
2020 this.builtinTypeError = initErrorSubtype("TypeError", errorProto);
2021 this.builtinURIError = initErrorSubtype("URIError", errorProto);
2022 }
2023
2024 private ScriptFunction initErrorSubtype(final String name, final ScriptObject errorProto) {
2025 final ScriptFunction cons = initConstructor(name, ScriptFunction.class);
2026 final ScriptObject prototype = ScriptFunction.getPrototype(cons);
2027 prototype.set(NativeError.NAME, name, 0);
2028 prototype.set(NativeError.MESSAGE, "", 0);
2029 prototype.setInitialProto(errorProto);
2030 tagBuiltinProperties(name, cons);
2031 return cons;
2032 }
2033
2034 private void initJavaAccess() {
2035 final ScriptObject objectProto = getObjectPrototype();
2036 this.builtinPackages = new NativeJavaPackage("", objectProto);
2037 this.builtinCom = new NativeJavaPackage("com", objectProto);
2038 this.builtinEdu = new NativeJavaPackage("edu", objectProto);
2039 this.builtinJava = new NativeJavaPackage("java", objectProto);
2040 this.builtinJavafx = new NativeJavaPackage("javafx", objectProto);
2041 this.builtinJavax = new NativeJavaPackage("javax", objectProto);
2042 this.builtinOrg = new NativeJavaPackage("org", objectProto);
2043 this.builtinJavaImporter = initConstructor("JavaImporter", ScriptFunction.class);
2044 this.builtinJavaApi = initConstructor("Java", ScriptObject.class);
2045 }
2046
2047 private void initScripting(final ScriptEnvironment scriptEnv) {
2048 Object value;
2049 value = ScriptFunctionImpl.makeFunction("readLine", ScriptingFunctions.READLINE);
2050 addOwnProperty("readLine", Attribute.NOT_ENUMERABLE, value);
2051
2052 value = ScriptFunctionImpl.makeFunction("readFully", ScriptingFunctions.READFULLY);
2053 addOwnProperty("readFully", Attribute.NOT_ENUMERABLE, value);
2054
2055 final String execName = ScriptingFunctions.EXEC_NAME;
2056 value = ScriptFunctionImpl.makeFunction(execName, ScriptingFunctions.EXEC);
2057 addOwnProperty(execName, Attribute.NOT_ENUMERABLE, value);
2058
2059 // Nashorn extension: global.echo (scripting-mode-only)
2060 // alias for "print"
2061 value = get("print");
2062 addOwnProperty("echo", Attribute.NOT_ENUMERABLE, value);
2063
2064 // Nashorn extension: global.$OPTIONS (scripting-mode-only)
2076 } else {
2077 addOwnProperty(ScriptingFunctions.ENV_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2078 }
2079
2080 // add other special properties for exec support
2081 addOwnProperty(ScriptingFunctions.OUT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2082 addOwnProperty(ScriptingFunctions.ERR_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2083 addOwnProperty(ScriptingFunctions.EXIT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2084 }
2085
2086 private static void copyOptions(final ScriptObject options, final ScriptEnvironment scriptEnv) {
2087 for (final Field f : scriptEnv.getClass().getFields()) {
2088 try {
2089 options.set(f.getName(), f.get(scriptEnv), 0);
2090 } catch (final IllegalArgumentException | IllegalAccessException exp) {
2091 throw new RuntimeException(exp);
2092 }
2093 }
2094 }
2095
2096 private void initTypedArray() {
2097 this.builtinArrayBuffer = initConstructorAndSwitchPoint("ArrayBuffer", ScriptFunction.class);
2098 this.builtinDataView = initConstructorAndSwitchPoint("DataView", ScriptFunction.class);
2099 this.builtinInt8Array = initConstructorAndSwitchPoint("Int8Array", ScriptFunction.class);
2100 this.builtinUint8Array = initConstructorAndSwitchPoint("Uint8Array", ScriptFunction.class);
2101 this.builtinUint8ClampedArray = initConstructorAndSwitchPoint("Uint8ClampedArray", ScriptFunction.class);
2102 this.builtinInt16Array = initConstructorAndSwitchPoint("Int16Array", ScriptFunction.class);
2103 this.builtinUint16Array = initConstructorAndSwitchPoint("Uint16Array", ScriptFunction.class);
2104 this.builtinInt32Array = initConstructorAndSwitchPoint("Int32Array", ScriptFunction.class);
2105 this.builtinUint32Array = initConstructorAndSwitchPoint("Uint32Array", ScriptFunction.class);
2106 this.builtinFloat32Array = initConstructorAndSwitchPoint("Float32Array", ScriptFunction.class);
2107 this.builtinFloat64Array = initConstructorAndSwitchPoint("Float64Array", ScriptFunction.class);
2108
2109 }
2110
2111 private void copyBuiltins() {
2112 this.array = this.builtinArray;
2113 this._boolean = this.builtinBoolean;
2114 this.date = this.builtinDate;
2115 this.error = this.builtinError;
2116 this.evalError = this.builtinEvalError;
2117 this.function = this.builtinFunction;
2118 this.jsadapter = this.builtinJSAdapter;
2119 this.json = this.builtinJSON;
2120 this.com = this.builtinCom;
2121 this.edu = this.builtinEdu;
2122 this.java = this.builtinJava;
2123 this.javafx = this.builtinJavafx;
2124 this.javax = this.builtinJavax;
2125 this.org = this.builtinOrg;
2126 this.javaImporter = this.builtinJavaImporter;
2127 this.javaApi = this.builtinJavaApi;
2128 this.math = this.builtinMath;
2129 this.number = this.builtinNumber;
2130 this.object = this.builtinObject;
2131 this.packages = this.builtinPackages;
2132 this.rangeError = this.builtinRangeError;
2133 this.referenceError = this.builtinReferenceError;
2134 this.regexp = this.builtinRegExp;
2135 this.string = this.builtinString;
2136 this.syntaxError = this.builtinSyntaxError;
2137 this.typeError = this.builtinTypeError;
2138 this.uriError = this.builtinURIError;
2139 this.arrayBuffer = this.builtinArrayBuffer;
2140 this.dataView = this.builtinDataView;
2141 this.int8Array = this.builtinInt8Array;
2142 this.uint8Array = this.builtinUint8Array;
2143 this.uint8ClampedArray = this.builtinUint8ClampedArray;
2144 this.int16Array = this.builtinInt16Array;
2145 this.uint16Array = this.builtinUint16Array;
2146 this.int32Array = this.builtinInt32Array;
2147 this.uint32Array = this.builtinUint32Array;
2148 this.float32Array = this.builtinFloat32Array;
2149 this.float64Array = this.builtinFloat64Array;
2150 }
2151
2152 private void initDebug() {
2153 this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug", ScriptObject.class));
2154 }
2155
2156 private Object printImpl(final boolean newLine, final Object... objects) {
2157 @SuppressWarnings("resource")
2158 final PrintWriter out = scontext != null? new PrintWriter(scontext.getWriter()) : getContext().getEnv().getOut();
2159 final StringBuilder sb = new StringBuilder();
2160
2161 for (final Object obj : objects) {
2162 if (sb.length() != 0) {
2163 sb.append(' ');
2164 }
2165
2166 sb.append(JSType.toString(obj));
2167 }
2168
2169 // Print all at once to ensure thread friendly result.
|
37 import java.lang.invoke.MethodHandles;
38 import java.lang.invoke.MethodType;
39 import java.lang.invoke.SwitchPoint;
40 import java.lang.reflect.Field;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.List;
44 import java.util.Map;
45 import java.util.Objects;
46 import java.util.concurrent.Callable;
47 import java.util.concurrent.ConcurrentHashMap;
48 import javax.script.ScriptContext;
49 import javax.script.ScriptEngine;
50 import jdk.internal.dynalink.CallSiteDescriptor;
51 import jdk.internal.dynalink.linker.GuardedInvocation;
52 import jdk.internal.dynalink.linker.LinkRequest;
53 import jdk.nashorn.api.scripting.ClassFilter;
54 import jdk.nashorn.api.scripting.ScriptObjectMirror;
55 import jdk.nashorn.internal.lookup.Lookup;
56 import jdk.nashorn.internal.objects.annotations.Attribute;
57 import jdk.nashorn.internal.objects.annotations.Getter;
58 import jdk.nashorn.internal.objects.annotations.Property;
59 import jdk.nashorn.internal.objects.annotations.ScriptClass;
60 import jdk.nashorn.internal.objects.annotations.Setter;
61 import jdk.nashorn.internal.runtime.Context;
62 import jdk.nashorn.internal.runtime.ECMAErrors;
63 import jdk.nashorn.internal.runtime.GlobalConstants;
64 import jdk.nashorn.internal.runtime.GlobalFunctions;
65 import jdk.nashorn.internal.runtime.JSType;
66 import jdk.nashorn.internal.runtime.NativeJavaPackage;
67 import jdk.nashorn.internal.runtime.PropertyDescriptor;
68 import jdk.nashorn.internal.runtime.PropertyMap;
69 import jdk.nashorn.internal.runtime.Scope;
70 import jdk.nashorn.internal.runtime.ScriptEnvironment;
71 import jdk.nashorn.internal.runtime.ScriptFunction;
72 import jdk.nashorn.internal.runtime.ScriptObject;
73 import jdk.nashorn.internal.runtime.ScriptRuntime;
74 import jdk.nashorn.internal.runtime.ScriptingFunctions;
75 import jdk.nashorn.internal.runtime.Specialization;
76 import jdk.nashorn.internal.runtime.arrays.ArrayData;
77 import jdk.nashorn.internal.runtime.linker.Bootstrap;
78 import jdk.nashorn.internal.runtime.linker.InvokeByName;
79 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
80 import jdk.nashorn.internal.runtime.regexp.RegExpResult;
81 import jdk.nashorn.internal.scripts.JO;
82 import jdk.nashorn.tools.ShellFunctions;
83
84 /**
85 * Representation of global scope.
86 */
87 @ScriptClass("Global")
88 public final class Global extends ScriptObject implements Scope {
89 // Placeholder value used in place of a location property (__FILE__, __DIR__, __LINE__)
90 private static final Object LOCATION_PROPERTY_PLACEHOLDER = new Object();
91 private final InvokeByName TO_STRING = new InvokeByName("toString", ScriptObject.class);
92 private final InvokeByName VALUE_OF = new InvokeByName("valueOf", ScriptObject.class);
93
94 // placeholder value for lazily initialized global objects
95 private static final Object LAZY_SENTINEL = new Object();
96
97 /**
98 * Optimistic builtin names that require switchpoint invalidation
99 * upon assignment. Overly conservative, but works for now, to avoid
100 * any complicated scope checks and especially heavy weight guards
101 * like
102 *
103 * <pre>
104 * public boolean setterGuard(final Object receiver) {
105 * final Global global = Global.instance();
106 * final ScriptObject sobj = global.getFunctionPrototype();
107 * final Object apply = sobj.get("apply");
108 * return apply == receiver;
109 * }
110 * </pre>
111 *
112 * Naturally, checking for builtin classes like NativeFunction is cheaper,
113 * it's when you start adding property checks for said builtins you have
114 * problems with guard speed.
115 */
116
202 @Property(name = "Function", attributes = Attribute.NOT_ENUMERABLE)
203 public volatile Object function;
204
205 /** ECMA 15.1.4.3 Array constructor. */
206 @Property(name = "Array", attributes = Attribute.NOT_ENUMERABLE)
207 public volatile Object array;
208
209 /** ECMA 15.1.4.4 String constructor */
210 @Property(name = "String", attributes = Attribute.NOT_ENUMERABLE)
211 public volatile Object string;
212
213 /** ECMA 15.1.4.5 Boolean constructor */
214 @Property(name = "Boolean", attributes = Attribute.NOT_ENUMERABLE)
215 public volatile Object _boolean;
216
217 /** ECMA 15.1.4.6 - Number constructor */
218 @Property(name = "Number", attributes = Attribute.NOT_ENUMERABLE)
219 public volatile Object number;
220
221 /** ECMA 15.1.4.7 Date constructor */
222 @Getter(name = "Date", attributes = Attribute.NOT_ENUMERABLE)
223 public static Object getDate(final Object self) {
224 final Global global = Global.instanceFrom(self);
225 if (global.date == LAZY_SENTINEL) {
226 global.date = global.getBuiltinDate();
227 }
228 return global.date;
229 }
230
231 @Setter(name = "Date", attributes = Attribute.NOT_ENUMERABLE)
232 public static void setDate(final Object self, final Object value) {
233 final Global global = Global.instanceFrom(self);
234 global.date = value;
235 }
236
237 private volatile Object date = LAZY_SENTINEL;
238
239 /** ECMA 15.1.4.8 RegExp constructor */
240 @Getter(name = "RegExp", attributes = Attribute.NOT_ENUMERABLE)
241 public static Object getRegExp(final Object self) {
242 final Global global = Global.instanceFrom(self);
243 if (global.regexp == LAZY_SENTINEL) {
244 global.regexp = global.getBuiltinRegExp();
245 }
246 return global.regexp;
247 }
248
249 @Setter(name = "RegExp", attributes = Attribute.NOT_ENUMERABLE)
250 public static void setRegExp(final Object self, final Object value) {
251 final Global global = Global.instanceFrom(self);
252 global.regexp = value;
253 }
254
255 private volatile Object regexp = LAZY_SENTINEL;
256
257 /** ECMA 15.12 - The JSON object */
258 @Getter(name = "JSON", attributes = Attribute.NOT_ENUMERABLE)
259 public static Object getJSON(final Object self) {
260 final Global global = Global.instanceFrom(self);
261 if (global.json == LAZY_SENTINEL) {
262 global.json = global.getBuiltinJSON();
263 }
264 return global.json;
265 }
266
267 @Setter(name = "JSON", attributes = Attribute.NOT_ENUMERABLE)
268 public static void setJSON(final Object self, final Object value) {
269 final Global global = Global.instanceFrom(self);
270 global.json = value;
271 }
272
273 private volatile Object json = LAZY_SENTINEL;
274
275 /** Nashorn extension: global.JSAdapter */
276 @Getter(name = "JSAdapter", attributes = Attribute.NOT_ENUMERABLE)
277 public static Object getJSAdapter(final Object self) {
278 final Global global = Global.instanceFrom(self);
279 if (global.jsadapter == LAZY_SENTINEL) {
280 global.jsadapter = global.getBuiltinJSAdapter();
281 }
282 return global.jsadapter;
283 }
284
285 @Setter(name = "JSAdapter", attributes = Attribute.NOT_ENUMERABLE)
286 public static void setJSAdapter(final Object self, final Object value) {
287 final Global global = Global.instanceFrom(self);
288 global.jsadapter = value;
289 }
290
291 private volatile Object jsadapter = LAZY_SENTINEL;
292
293 /** ECMA 15.8 - The Math object */
294 @Getter(name = "Math", attributes = Attribute.NOT_ENUMERABLE)
295 public static Object getMath(final Object self) {
296 final Global global = Global.instanceFrom(self);
297 if (global.math == LAZY_SENTINEL) {
298 global.math = global.getBuiltinMath();
299 }
300 return global.math;
301 }
302
303 @Setter(name = "Math", attributes = Attribute.NOT_ENUMERABLE)
304 public static void setMath(final Object self, final Object value) {
305 final Global global = Global.instanceFrom(self);
306 global.math = value;
307 }
308
309 private volatile Object math = LAZY_SENTINEL;
310
311 /** Error object */
312 @Property(name = "Error", attributes = Attribute.NOT_ENUMERABLE)
313 public volatile Object error;
314
315 /** EvalError object */
316 @Getter(name = "EvalError", attributes = Attribute.NOT_ENUMERABLE)
317 public static Object getEvalError(final Object self) {
318 final Global global = Global.instanceFrom(self);
319 if (global.evalError == LAZY_SENTINEL) {
320 global.evalError = global.getBuiltinEvalError();
321 }
322 return global.evalError;
323 }
324
325 @Setter(name = "EvalError", attributes = Attribute.NOT_ENUMERABLE)
326 public static void setEvalError(final Object self, final Object value) {
327 final Global global = Global.instanceFrom(self);
328 global.evalError = value;
329 }
330
331 private volatile Object evalError = LAZY_SENTINEL;
332
333 /** RangeError object */
334 @Getter(name = "RangeError", attributes = Attribute.NOT_ENUMERABLE)
335 public static Object getRangeError(final Object self) {
336 final Global global = Global.instanceFrom(self);
337 if (global.rangeError == LAZY_SENTINEL) {
338 global.rangeError = global.getBuiltinRangeError();
339 }
340 return global.rangeError;
341 }
342
343 @Setter(name = "RangeError", attributes = Attribute.NOT_ENUMERABLE)
344 public static void setRangeError(final Object self, final Object value) {
345 final Global global = Global.instanceFrom(self);
346 global.rangeError = value;
347 }
348
349 private volatile Object rangeError = LAZY_SENTINEL;
350
351 /** ReferenceError object */
352 @Property(name = "ReferenceError", attributes = Attribute.NOT_ENUMERABLE)
353 public volatile Object referenceError;
354
355 /** SyntaxError object */
356 @Property(name = "SyntaxError", attributes = Attribute.NOT_ENUMERABLE)
357 public volatile Object syntaxError;
358
359 /** TypeError object */
360 @Property(name = "TypeError", attributes = Attribute.NOT_ENUMERABLE)
361 public volatile Object typeError;
362
363 /** URIError object */
364 @Getter(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
365 public static Object getURIError(final Object self) {
366 final Global global = Global.instanceFrom(self);
367 if (global.uriError == LAZY_SENTINEL) {
368 global.uriError = global.getBuiltinURIError();
369 }
370 return global.uriError;
371 }
372
373 @Setter(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
374 public static void setURIError(final Object self, final Object value) {
375 final Global global = Global.instanceFrom(self);
376 global.uriError = value;
377 }
378
379 private volatile Object uriError = LAZY_SENTINEL;
380
381 /** ArrayBuffer object */
382 @Getter(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
383 public static Object getArrayBuffer(final Object self) {
384 final Global global = Global.instanceFrom(self);
385 if (global.arrayBuffer == LAZY_SENTINEL) {
386 global.arrayBuffer = global.getBuiltinArrayBuffer();
387 }
388 return global.arrayBuffer;
389 }
390
391 @Setter(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
392 public static void setArrayBuffer(final Object self, final Object value) {
393 final Global global = Global.instanceFrom(self);
394 global.arrayBuffer = value;
395 }
396
397 private volatile Object arrayBuffer;
398
399 /** DataView object */
400 @Getter(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
401 public static Object getDataView(final Object self) {
402 final Global global = Global.instanceFrom(self);
403 if (global.dataView == LAZY_SENTINEL) {
404 global.dataView = global.getBuiltinDataView();
405 }
406 return global.dataView;
407 }
408
409 @Setter(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
410 public static void setDataView(final Object self, final Object value) {
411 final Global global = Global.instanceFrom(self);
412 global.dataView = value;
413 }
414
415 private volatile Object dataView;
416
417 /** TypedArray (int8) */
418 @Getter(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
419 public static Object getInt8Array(final Object self) {
420 final Global global = Global.instanceFrom(self);
421 if (global.int8Array == LAZY_SENTINEL) {
422 global.int8Array = global.getBuiltinInt8Array();
423 }
424 return global.int8Array;
425 }
426
427 @Setter(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
428 public static void setInt8Array(final Object self, final Object value) {
429 final Global global = Global.instanceFrom(self);
430 global.int8Array = value;
431 }
432
433 private volatile Object int8Array;
434
435 /** TypedArray (uint8) */
436 @Getter(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
437 public static Object getUint8Array(final Object self) {
438 final Global global = Global.instanceFrom(self);
439 if (global.uint8Array == LAZY_SENTINEL) {
440 global.uint8Array = global.getBuiltinUint8Array();
441 }
442 return global.uint8Array;
443 }
444
445 @Setter(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
446 public static void setUint8Array(final Object self, final Object value) {
447 final Global global = Global.instanceFrom(self);
448 global.uint8Array = value;
449 }
450
451 private volatile Object uint8Array;
452
453 /** TypedArray (uint8) - Clamped */
454 @Getter(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
455 public static Object getUint8ClampedArray(final Object self) {
456 final Global global = Global.instanceFrom(self);
457 if (global.uint8ClampedArray == LAZY_SENTINEL) {
458 global.uint8ClampedArray = global.getBuiltinUint8ClampedArray();
459 }
460 return global.uint8ClampedArray;
461 }
462
463 @Setter(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
464 public static void setUint8ClampedArray(final Object self, final Object value) {
465 final Global global = Global.instanceFrom(self);
466 global.uint8ClampedArray = value;
467 }
468
469 private volatile Object uint8ClampedArray;
470
471 /** TypedArray (int16) */
472 @Getter(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
473 public static Object getInt16Array(final Object self) {
474 final Global global = Global.instanceFrom(self);
475 if (global.int16Array == LAZY_SENTINEL) {
476 global.int16Array = global.getBuiltinInt16Array();
477 }
478 return global.int16Array;
479 }
480
481 @Setter(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
482 public static void setInt16Array(final Object self, final Object value) {
483 final Global global = Global.instanceFrom(self);
484 global.int16Array = value;
485 }
486
487 private volatile Object int16Array;
488
489 /** TypedArray (uint16) */
490 @Getter(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
491 public static Object getUint16Array(final Object self) {
492 final Global global = Global.instanceFrom(self);
493 if (global.uint16Array == LAZY_SENTINEL) {
494 global.uint16Array = global.getBuiltinUint16Array();
495 }
496 return global.uint16Array;
497 }
498
499 @Setter(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
500 public static void setUint16Array(final Object self, final Object value) {
501 final Global global = Global.instanceFrom(self);
502 global.uint16Array = value;
503 }
504
505 private volatile Object uint16Array;
506
507 /** TypedArray (int32) */
508 @Getter(name = "Int32Array", attributes = Attribute.NOT_ENUMERABLE)
509 public static Object getInt32Array(final Object self) {
510 final Global global = Global.instanceFrom(self);
511 if (global.int32Array == LAZY_SENTINEL) {
512 global.int32Array = global.getBuiltinInt32Array();
513 }
514 return global.int32Array;
515 }
516
517 @Setter(name = "Int32Array", attributes = Attribute.NOT_ENUMERABLE)
518 public static void setInt32Array(final Object self, final Object value) {
519 final Global global = Global.instanceFrom(self);
520 global.int32Array = value;
521 }
522
523 private volatile Object int32Array;
524
525 /** TypedArray (uint32) */
526 @Getter(name = "Uint32Array", attributes = Attribute.NOT_ENUMERABLE)
527 public static Object getUint32Array(final Object self) {
528 final Global global = Global.instanceFrom(self);
529 if (global.uint32Array == LAZY_SENTINEL) {
530 global.uint32Array = global.getBuiltinUint32Array();
531 }
532 return global.uint32Array;
533 }
534
535 @Setter(name = "Uint32Array", attributes = Attribute.NOT_ENUMERABLE)
536 public static void setUint32Array(final Object self, final Object value) {
537 final Global global = Global.instanceFrom(self);
538 global.uint32Array = value;
539 }
540
541 private volatile Object uint32Array;
542
543 /** TypedArray (float32) */
544 @Getter(name = "Float32Array", attributes = Attribute.NOT_ENUMERABLE)
545 public static Object getFloat32Array(final Object self) {
546 final Global global = Global.instanceFrom(self);
547 if (global.float32Array == LAZY_SENTINEL) {
548 global.float32Array = global.getBuiltinFloat32Array();
549 }
550 return global.float32Array;
551 }
552
553 @Setter(name = "Float32Array", attributes = Attribute.NOT_ENUMERABLE)
554 public static void setFloat32Array(final Object self, final Object value) {
555 final Global global = Global.instanceFrom(self);
556 global.float32Array = value;
557 }
558
559 private volatile Object float32Array;
560
561 /** TypedArray (float64) */
562 @Getter(name = "Float64Array", attributes = Attribute.NOT_ENUMERABLE)
563 public static Object getFloat64Array(final Object self) {
564 final Global global = Global.instanceFrom(self);
565 if (global.float64Array == LAZY_SENTINEL) {
566 global.float64Array = global.getBuiltinFloat64Array();
567 }
568 return global.float64Array;
569 }
570
571 @Setter(name = "Float64Array", attributes = Attribute.NOT_ENUMERABLE)
572 public static void setFloat64Array(final Object self, final Object value) {
573 final Global global = Global.instanceFrom(self);
574 global.float64Array = value;
575 }
576
577 private volatile Object float64Array;
578
579 /** Nashorn extension: Java access - global.Packages */
580 @Property(name = "Packages", attributes = Attribute.NOT_ENUMERABLE)
581 public volatile Object packages;
582
583 /** Nashorn extension: Java access - global.com */
584 @Property(attributes = Attribute.NOT_ENUMERABLE)
585 public volatile Object com;
586
587 /** Nashorn extension: Java access - global.edu */
588 @Property(attributes = Attribute.NOT_ENUMERABLE)
589 public volatile Object edu;
590
591 /** Nashorn extension: Java access - global.java */
592 @Property(attributes = Attribute.NOT_ENUMERABLE)
593 public volatile Object java;
594
595 /** Nashorn extension: Java access - global.javafx */
596 @Property(attributes = Attribute.NOT_ENUMERABLE)
597 public volatile Object javafx;
598
599 /** Nashorn extension: Java access - global.javax */
600 @Property(attributes = Attribute.NOT_ENUMERABLE)
601 public volatile Object javax;
602
603 /** Nashorn extension: Java access - global.org */
604 @Property(attributes = Attribute.NOT_ENUMERABLE)
605 public volatile Object org;
606
607 /** Nashorn extension: Java access - global.javaImporter */
608 @Getter(name = "JavaImporter", attributes = Attribute.NOT_ENUMERABLE)
609 public static Object getJavaImporter(final Object self) {
610 final Global global = Global.instanceFrom(self);
611 if (global.javaImporter == LAZY_SENTINEL) {
612 global.javaImporter = global.getBuiltinJavaImporter();
613 }
614 return global.javaImporter;
615 }
616
617 @Setter(name = "JavaImporter", attributes = Attribute.NOT_ENUMERABLE)
618 public static void setJavaImporter(final Object self, final Object value) {
619 final Global global = Global.instanceFrom(self);
620 global.javaImporter = value;
621 }
622
623 private volatile Object javaImporter;
624
625 /** Nashorn extension: global.Java Object constructor. */
626 @Getter(name = "Java", attributes = Attribute.NOT_ENUMERABLE)
627 public static Object getJavaApi(final Object self) {
628 final Global global = Global.instanceFrom(self);
629 if (global.javaApi == LAZY_SENTINEL) {
630 global.javaApi = global.getBuiltinJavaApi();
631 }
632 return global.javaApi;
633 }
634
635 @Setter(name = "Java", attributes = Attribute.NOT_ENUMERABLE)
636 public static void setJavaApi(final Object self, final Object value) {
637 final Global global = Global.instanceFrom(self);
638 global.javaApi = value;
639 }
640
641 private volatile Object javaApi;
642
643 /** Nashorn extension: current script's file name */
644 @Property(name = "__FILE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
645 public final Object __FILE__ = LOCATION_PROPERTY_PLACEHOLDER;
646
647 /** Nashorn extension: current script's directory */
648 @Property(name = "__DIR__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
649 public final Object __DIR__ = LOCATION_PROPERTY_PLACEHOLDER;
650
651 /** Nashorn extension: current source line number being executed */
652 @Property(name = "__LINE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
653 public final Object __LINE__ = LOCATION_PROPERTY_PLACEHOLDER;
654
655 private volatile NativeDate DEFAULT_DATE;
656
657 /** Used as Date.prototype's default value */
658 NativeDate getDefaultDate() {
659 return DEFAULT_DATE;
660 }
661
662 private volatile NativeRegExp DEFAULT_REGEXP;
663
664 /** Used as RegExp.prototype's default value */
665 NativeRegExp getDefaultRegExp() {
666 return DEFAULT_REGEXP;
667 }
668
669 /*
670 * Built-in constructor objects: Even if user changes dynamic values of
671 * "Object", "Array" etc., we still want to keep original values of these
672 * constructors here. For example, we need to be able to create array,
673 * regexp literals even after user overwrites global "Array" or "RegExp"
674 * constructor - see also ECMA 262 spec. Annex D.
675 */
676 private ScriptFunction builtinFunction;
677 private ScriptFunction builtinObject;
678 private ScriptFunction builtinArray;
679 private ScriptFunction builtinBoolean;
680 private ScriptFunction builtinDate;
681 private ScriptObject builtinJSON;
682 private ScriptFunction builtinJSAdapter;
683 private ScriptObject builtinMath;
684 private ScriptFunction builtinNumber;
685 private ScriptFunction builtinRegExp;
686 private ScriptFunction builtinString;
687 private ScriptFunction builtinError;
1347 return ScriptFunction.getPrototype(builtinObject);
1348 }
1349
1350 ScriptObject getFunctionPrototype() {
1351 return ScriptFunction.getPrototype(builtinFunction);
1352 }
1353
1354 ScriptObject getArrayPrototype() {
1355 return ScriptFunction.getPrototype(builtinArray);
1356 }
1357
1358 ScriptObject getBooleanPrototype() {
1359 return ScriptFunction.getPrototype(builtinBoolean);
1360 }
1361
1362 ScriptObject getNumberPrototype() {
1363 return ScriptFunction.getPrototype(builtinNumber);
1364 }
1365
1366 ScriptObject getDatePrototype() {
1367 return ScriptFunction.getPrototype(getBuiltinDate());
1368 }
1369
1370 ScriptObject getRegExpPrototype() {
1371 return ScriptFunction.getPrototype(getBuiltinRegExp());
1372 }
1373
1374 ScriptObject getStringPrototype() {
1375 return ScriptFunction.getPrototype(builtinString);
1376 }
1377
1378 ScriptObject getErrorPrototype() {
1379 return ScriptFunction.getPrototype(builtinError);
1380 }
1381
1382 ScriptObject getEvalErrorPrototype() {
1383 return ScriptFunction.getPrototype(getBuiltinEvalError());
1384 }
1385
1386 ScriptObject getRangeErrorPrototype() {
1387 return ScriptFunction.getPrototype(getBuiltinRangeError());
1388 }
1389
1390 ScriptObject getReferenceErrorPrototype() {
1391 return ScriptFunction.getPrototype(builtinReferenceError);
1392 }
1393
1394 ScriptObject getSyntaxErrorPrototype() {
1395 return ScriptFunction.getPrototype(builtinSyntaxError);
1396 }
1397
1398 ScriptObject getTypeErrorPrototype() {
1399 return ScriptFunction.getPrototype(builtinTypeError);
1400 }
1401
1402 ScriptObject getURIErrorPrototype() {
1403 return ScriptFunction.getPrototype(getBuiltinURIError());
1404 }
1405
1406 ScriptObject getJavaImporterPrototype() {
1407 return ScriptFunction.getPrototype(getBuiltinJavaImporter());
1408 }
1409
1410 ScriptObject getJSAdapterPrototype() {
1411 return ScriptFunction.getPrototype(getBuiltinJSAdapter());
1412 }
1413
1414 private synchronized ScriptFunction getBuiltinArrayBuffer() {
1415 if (this.builtinArrayBuffer == null) {
1416 this.builtinArrayBuffer = initConstructorAndSwitchPoint("ArrayBuffer", ScriptFunction.class);
1417 }
1418 return this.builtinArrayBuffer;
1419 }
1420
1421 ScriptObject getArrayBufferPrototype() {
1422 return ScriptFunction.getPrototype(getBuiltinArrayBuffer());
1423 }
1424
1425 private synchronized ScriptFunction getBuiltinDataView() {
1426 if (this.builtinDataView == null) {
1427 this.builtinDataView = initConstructorAndSwitchPoint("DataView", ScriptFunction.class);
1428 }
1429 return this.builtinDataView;
1430 }
1431
1432 ScriptObject getDataViewPrototype() {
1433 return ScriptFunction.getPrototype(getBuiltinDataView());
1434 }
1435
1436 private synchronized ScriptFunction getBuiltinInt8Array() {
1437 if (this.builtinInt8Array == null) {
1438 this.builtinInt8Array = initConstructorAndSwitchPoint("Int8Array", ScriptFunction.class);
1439 }
1440 return this.builtinInt8Array;
1441 }
1442
1443 ScriptObject getInt8ArrayPrototype() {
1444 return ScriptFunction.getPrototype(getBuiltinInt8Array());
1445 }
1446
1447 private synchronized ScriptFunction getBuiltinUint8Array() {
1448 if (this.builtinUint8Array == null) {
1449 this.builtinUint8Array = initConstructorAndSwitchPoint("Uint8Array", ScriptFunction.class);
1450 }
1451 return this.builtinUint8Array;
1452 }
1453
1454 ScriptObject getUint8ArrayPrototype() {
1455 return ScriptFunction.getPrototype(getBuiltinUint8Array());
1456 }
1457
1458 private synchronized ScriptFunction getBuiltinUint8ClampedArray() {
1459 if (this.builtinUint8ClampedArray == null) {
1460 this.builtinUint8ClampedArray = initConstructorAndSwitchPoint("Uint8ClampedArray", ScriptFunction.class);
1461 }
1462 return this.builtinUint8ClampedArray;
1463 }
1464
1465 ScriptObject getUint8ClampedArrayPrototype() {
1466 return ScriptFunction.getPrototype(getBuiltinUint8ClampedArray());
1467 }
1468
1469 private synchronized ScriptFunction getBuiltinInt16Array() {
1470 if (this.builtinInt16Array == null) {
1471 this.builtinInt16Array = initConstructorAndSwitchPoint("Int16Array", ScriptFunction.class);
1472 }
1473 return this.builtinInt16Array;
1474 }
1475
1476 ScriptObject getInt16ArrayPrototype() {
1477 return ScriptFunction.getPrototype(getBuiltinInt16Array());
1478 }
1479
1480 private synchronized ScriptFunction getBuiltinUint16Array() {
1481 if (this.builtinUint16Array == null) {
1482 this.builtinUint16Array = initConstructorAndSwitchPoint("Uint16Array", ScriptFunction.class);
1483 }
1484 return this.builtinUint16Array;
1485 }
1486
1487 ScriptObject getUint16ArrayPrototype() {
1488 return ScriptFunction.getPrototype(getBuiltinUint16Array());
1489 }
1490
1491 private synchronized ScriptFunction getBuiltinInt32Array() {
1492 if (this.builtinInt32Array == null) {
1493 this.builtinInt32Array = initConstructorAndSwitchPoint("Int32Array", ScriptFunction.class);
1494 }
1495 return this.builtinInt32Array;
1496 }
1497
1498 ScriptObject getInt32ArrayPrototype() {
1499 return ScriptFunction.getPrototype(getBuiltinInt32Array());
1500 }
1501
1502 private synchronized ScriptFunction getBuiltinUint32Array() {
1503 if (this.builtinUint32Array == null) {
1504 this.builtinUint32Array = initConstructorAndSwitchPoint("Uint32Array", ScriptFunction.class);
1505 }
1506 return this.builtinUint32Array;
1507 }
1508
1509 ScriptObject getUint32ArrayPrototype() {
1510 return ScriptFunction.getPrototype(getBuiltinUint32Array());
1511 }
1512
1513 private synchronized ScriptFunction getBuiltinFloat32Array() {
1514 if (this.builtinFloat32Array == null) {
1515 this.builtinFloat32Array = initConstructorAndSwitchPoint("Float32Array", ScriptFunction.class);
1516 }
1517 return this.builtinFloat32Array;
1518 }
1519
1520 ScriptObject getFloat32ArrayPrototype() {
1521 return ScriptFunction.getPrototype(getBuiltinFloat32Array());
1522 }
1523
1524 private synchronized ScriptFunction getBuiltinFloat64Array() {
1525 if (this.builtinFloat64Array == null) {
1526 this.builtinFloat64Array = initConstructorAndSwitchPoint("Float64Array", ScriptFunction.class);
1527 }
1528 return this.builtinFloat64Array;
1529 }
1530
1531 ScriptObject getFloat64ArrayPrototype() {
1532 return ScriptFunction.getPrototype(getBuiltinFloat64Array());
1533 }
1534
1535 private ScriptFunction getBuiltinArray() {
1536 return builtinArray;
1537 }
1538
1539 ScriptFunction getTypeErrorThrower() {
1540 return typeErrorThrower;
1541 }
1542
1543 /**
1544 * Called from compiled script code to test if builtin has been overridden
1545 *
1546 * @return true if builtin array has not been overridden
1547 */
1548 public static boolean isBuiltinArray() {
1549 final Global instance = Global.instance();
1550 return instance.array == instance.getBuiltinArray();
1551 }
1552
1553 private ScriptFunction getBuiltinBoolean() {
1554 return builtinBoolean;
1555 }
1556
1557 /**
1558 * Called from compiled script code to test if builtin has been overridden
1559 *
1560 * @return true if builtin boolean has not been overridden
1561 */
1562 public static boolean isBuiltinBoolean() {
1563 final Global instance = Global.instance();
1564 return instance._boolean == instance.getBuiltinBoolean();
1565 }
1566
1567 private synchronized ScriptFunction getBuiltinDate() {
1568 if (this.builtinDate == null) {
1569 this.builtinDate = initConstructorAndSwitchPoint("Date", ScriptFunction.class);
1570 final ScriptObject dateProto = ScriptFunction.getPrototype(builtinDate);
1571 // initialize default date
1572 this.DEFAULT_DATE = new NativeDate(NaN, dateProto);
1573 }
1574 return this.builtinDate;
1575 }
1576
1577 /**
1578 * Called from compiled script code to test if builtin has been overridden
1579 *
1580 * @return true if builtin date has not been overridden
1581 */
1582 public static boolean isBuiltinDate() {
1583 final Global instance = Global.instance();
1584 return instance.date == LAZY_SENTINEL || instance.date == instance.getBuiltinDate();
1585 }
1586
1587 private ScriptFunction getBuiltinError() {
1588 return builtinError;
1589 }
1590
1591 /**
1592 * Called from compiled script code to test if builtin has been overridden
1593 *
1594 * @return true if builtin error has not been overridden
1595 */
1596 public static boolean isBuiltinError() {
1597 final Global instance = Global.instance();
1598 return instance.error == instance.getBuiltinError();
1599 }
1600
1601 private synchronized ScriptFunction getBuiltinEvalError() {
1602 if (this.builtinEvalError == null) {
1603 this.builtinEvalError = initErrorSubtype("EvalError", getErrorPrototype());
1604 }
1605 return this.builtinEvalError;
1606 }
1607
1608 /**
1609 * Called from compiled script code to test if builtin has been overridden
1610 *
1611 * @return true if builtin eval error has not been overridden
1612 */
1613 public static boolean isBuiltinEvalError() {
1614 final Global instance = Global.instance();
1615 return instance.evalError == LAZY_SENTINEL || instance.evalError == instance.getBuiltinEvalError();
1616 }
1617
1618 private ScriptFunction getBuiltinFunction() {
1619 return builtinFunction;
1620 }
1621
1622 /**
1623 * Called from compiled script code to test if builtin has been overridden
1624 *
1625 * @return true if builtin function has not been overridden
1626 */
1627 public static boolean isBuiltinFunction() {
1628 final Global instance = Global.instance();
1629 return instance.function == instance.getBuiltinFunction();
1630 }
1631
1632 /**
1633 * Get the switchpoint used to check property changes for Function.prototype.apply
1634 * @return the switchpoint guarding apply (same as guarding call, and everything else in function)
1635 */
1646 final boolean isBuiltinFunction = instance.function == builtinFunction;
1647 return isBuiltinFunction && ScriptFunction.getPrototype(builtinFunction).getProperty(name).isBuiltin();
1648 }
1649
1650 /**
1651 * Check if the Function.prototype.apply has not been replaced
1652 * @return true if Function.prototype.apply has been replaced
1653 */
1654 public static boolean isBuiltinFunctionPrototypeApply() {
1655 return isBuiltinFunctionProperty("apply");
1656 }
1657
1658 /**
1659 * Check if the Function.prototype.apply has not been replaced
1660 * @return true if Function.prototype.call has been replaced
1661 */
1662 public static boolean isBuiltinFunctionPrototypeCall() {
1663 return isBuiltinFunctionProperty("call");
1664 }
1665
1666 private synchronized ScriptFunction getBuiltinJSAdapter() {
1667 if (this.builtinJSAdapter == null) {
1668 this.builtinJSAdapter = initConstructorAndSwitchPoint("JSAdapter", ScriptFunction.class);
1669 }
1670 return builtinJSAdapter;
1671 }
1672
1673 /**
1674 * Called from compiled script code to test if builtin has been overridden
1675 *
1676 * @return true if builtin JSAdapter has not been overridden
1677 */
1678 public static boolean isBuiltinJSAdapter() {
1679 final Global instance = Global.instance();
1680 return instance.jsadapter == LAZY_SENTINEL || instance.jsadapter == instance.getBuiltinJSAdapter();
1681 }
1682
1683 private synchronized ScriptObject getBuiltinJSON() {
1684 if (this.builtinJSON == null) {
1685 this.builtinJSON = initConstructorAndSwitchPoint("JSON", ScriptObject.class);
1686 }
1687 return this.builtinJSON;
1688 }
1689
1690 /**
1691 * Called from compiled script code to test if builtin has been overridden
1692 *
1693 * @return true if builtin JSON has has not been overridden
1694 */
1695 public static boolean isBuiltinJSON() {
1696 final Global instance = Global.instance();
1697 return instance.json == LAZY_SENTINEL || instance.json == instance.getBuiltinJSON();
1698 }
1699
1700 private ScriptObject getBuiltinJava() {
1701 return builtinJava;
1702 }
1703
1704 /**
1705 * Called from compiled script code to test if builtin has been overridden
1706 *
1707 * @return true if builtin Java has not been overridden
1708 */
1709 public static boolean isBuiltinJava() {
1710 final Global instance = Global.instance();
1711 return instance.java == instance.getBuiltinJava();
1712 }
1713
1714 private ScriptObject getBuiltinJavax() {
1715 return builtinJavax;
1716 }
1717
1718 /**
1719 * Called from compiled script code to test if builtin has been overridden
1720 *
1721 * @return true if builtin Javax has not been overridden
1722 */
1723 public static boolean isBuiltinJavax() {
1724 final Global instance = Global.instance();
1725 return instance.javax == instance.getBuiltinJavax();
1726 }
1727
1728 private synchronized ScriptFunction getBuiltinJavaImporter() {
1729 if (this.builtinJavaImporter == null) {
1730 this.builtinJavaImporter = initConstructor("JavaImporter", ScriptFunction.class);
1731 }
1732 return this.builtinJavaImporter;
1733 }
1734
1735 private synchronized ScriptObject getBuiltinJavaApi() {
1736 if (this.builtinJavaApi == null) {
1737 this.builtinJavaApi = initConstructor("Java", ScriptObject.class);
1738 }
1739 return this.builtinJavaApi;
1740 }
1741
1742 /**
1743 * Called from compiled script code to test if builtin has been overridden
1744 *
1745 * @return true if builtin Java importer has not been overridden
1746 */
1747 public static boolean isBuiltinJavaImporter() {
1748 final Global instance = Global.instance();
1749 return instance.javaImporter == LAZY_SENTINEL || instance.javaImporter == instance.getBuiltinJavaImporter();
1750 }
1751
1752 private synchronized ScriptObject getBuiltinMath() {
1753 if (this.builtinMath == null) {
1754 this.builtinMath = initConstructorAndSwitchPoint("Math", ScriptObject.class);
1755 }
1756 return this.builtinMath;
1757 }
1758
1759 /**
1760 * Called from compiled script code to test if builtin has been overridden
1761 *
1762 * @return true if builtin math has not been overridden
1763 */
1764 public static boolean isBuiltinMath() {
1765 final Global instance = Global.instance();
1766 return instance.math == LAZY_SENTINEL || instance.math == instance.getBuiltinMath();
1767 }
1768
1769 private ScriptFunction getBuiltinNumber() {
1770 return builtinNumber;
1771 }
1772
1773 /**
1774 * Called from compiled script code to test if builtin has been overridden
1775 *
1776 * @return true if builtin number has not been overridden
1777 */
1778 public static boolean isBuiltinNumber() {
1779 final Global instance = Global.instance();
1780 return instance.number == instance.getBuiltinNumber();
1781 }
1782
1783 private ScriptFunction getBuiltinObject() {
1784 return builtinObject;
1785 }
1786
1791 */
1792 public static boolean isBuiltinObject() {
1793 final Global instance = Global.instance();
1794 return instance.object == instance.getBuiltinObject();
1795 }
1796
1797 private ScriptObject getBuiltinPackages() {
1798 return builtinPackages;
1799 }
1800
1801 /**
1802 * Called from compiled script code to test if builtin has been overridden
1803 *
1804 * @return true if builtin package has not been overridden
1805 */
1806 public static boolean isBuiltinPackages() {
1807 final Global instance = Global.instance();
1808 return instance.packages == instance.getBuiltinPackages();
1809 }
1810
1811 private synchronized ScriptFunction getBuiltinRangeError() {
1812 if (this.builtinRangeError == null) {
1813 this.builtinRangeError = initErrorSubtype("RangeError", getErrorPrototype());
1814 }
1815 return builtinRangeError;
1816 }
1817
1818 /**
1819 * Called from compiled script code to test if builtin has been overridden
1820 *
1821 * @return true if builtin range error has not been overridden
1822 */
1823 public static boolean isBuiltinRangeError() {
1824 final Global instance = Global.instance();
1825 return instance.rangeError == LAZY_SENTINEL || instance.rangeError == instance.getBuiltinRangeError();
1826 }
1827
1828 private synchronized ScriptFunction getBuiltinReferenceError() {
1829 return builtinReferenceError;
1830 }
1831
1832 /**
1833 * Called from compiled script code to test if builtin has been overridden
1834 *
1835 * @return true if builtin reference error has not been overridden
1836 */
1837 public static boolean isBuiltinReferenceError() {
1838 final Global instance = Global.instance();
1839 return instance.referenceError == instance.getBuiltinReferenceError();
1840 }
1841
1842 private synchronized ScriptFunction getBuiltinRegExp() {
1843 if (this.builtinRegExp == null) {
1844 this.builtinRegExp = initConstructorAndSwitchPoint("RegExp", ScriptFunction.class);
1845 final ScriptObject regExpProto = ScriptFunction.getPrototype(builtinRegExp);
1846 // initialize default regexp object
1847 this.DEFAULT_REGEXP = new NativeRegExp("(?:)", "", this, regExpProto);
1848 // RegExp.prototype should behave like a RegExp object. So copy the
1849 // properties.
1850 regExpProto.addBoundProperties(DEFAULT_REGEXP);
1851 }
1852 return builtinRegExp;
1853 }
1854
1855 /**
1856 * Called from compiled script code to test if builtin has been overridden
1857 *
1858 * @return true if builtin regexp has not been overridden
1859 */
1860 public static boolean isBuiltinRegExp() {
1861 final Global instance = Global.instance();
1862 return instance.regexp == LAZY_SENTINEL || instance.regexp == instance.getBuiltinRegExp();
1863 }
1864
1865 private ScriptFunction getBuiltinString() {
1866 return builtinString;
1867 }
1868
1869 /**
1870 * Called from compiled script code to test if builtin has been overridden
1871 *
1872 * @return true if builtin Java has not been overridden
1873 */
1874 public static boolean isBuiltinString() {
1875 final Global instance = Global.instance();
1876 return instance.string == instance.getBuiltinString();
1877 }
1878
1879 private ScriptFunction getBuiltinSyntaxError() {
1880 return builtinSyntaxError;
1881 }
1882
1887 */
1888 public static boolean isBuiltinSyntaxError() {
1889 final Global instance = Global.instance();
1890 return instance.syntaxError == instance.getBuiltinSyntaxError();
1891 }
1892
1893 private ScriptFunction getBuiltinTypeError() {
1894 return builtinTypeError;
1895 }
1896
1897 /**
1898 * Called from compiled script code to test if builtin has been overridden
1899 *
1900 * @return true if builtin type error has not been overridden
1901 */
1902 public static boolean isBuiltinTypeError() {
1903 final Global instance = Global.instance();
1904 return instance.typeError == instance.getBuiltinTypeError();
1905 }
1906
1907 private synchronized ScriptFunction getBuiltinURIError() {
1908 if (this.builtinURIError == null) {
1909 this.builtinURIError = initErrorSubtype("URIError", getErrorPrototype());
1910 }
1911 return this.builtinURIError;
1912 }
1913
1914 /**
1915 * Called from compiled script code to test if builtin has been overridden
1916 *
1917 * @return true if builtin URI error has not been overridden
1918 */
1919 public static boolean isBuiltinURIError() {
1920 final Global instance = Global.instance();
1921 return instance.uriError == LAZY_SENTINEL || instance.uriError == instance.getBuiltinURIError();
1922 }
1923
1924 @Override
1925 public String getClassName() {
1926 return "global";
1927 }
1928
1929 /**
1930 * Copy function used to clone NativeRegExp objects.
1931 *
1932 * @param regexp a NativeRegExp to clone
1933 *
1934 * @return copy of the given regexp object
1935 */
1936 public static Object regExpCopy(final Object regexp) {
1937 return new NativeRegExp((NativeRegExp)regexp);
1938 }
1939
1940 /**
1941 * Convert given object to NativeRegExp type.
2313 new Specialization(GlobalFunctions.IS_NAN_J),
2314 new Specialization(GlobalFunctions.IS_NAN_D) });
2315 this.parseFloat = ScriptFunctionImpl.makeFunction("parseFloat", GlobalFunctions.PARSEFLOAT);
2316 this.isNaN = ScriptFunctionImpl.makeFunction("isNaN", GlobalFunctions.IS_NAN);
2317 this.isFinite = ScriptFunctionImpl.makeFunction("isFinite", GlobalFunctions.IS_FINITE);
2318 this.encodeURI = ScriptFunctionImpl.makeFunction("encodeURI", GlobalFunctions.ENCODE_URI);
2319 this.encodeURIComponent = ScriptFunctionImpl.makeFunction("encodeURIComponent", GlobalFunctions.ENCODE_URICOMPONENT);
2320 this.decodeURI = ScriptFunctionImpl.makeFunction("decodeURI", GlobalFunctions.DECODE_URI);
2321 this.decodeURIComponent = ScriptFunctionImpl.makeFunction("decodeURIComponent", GlobalFunctions.DECODE_URICOMPONENT);
2322 this.escape = ScriptFunctionImpl.makeFunction("escape", GlobalFunctions.ESCAPE);
2323 this.unescape = ScriptFunctionImpl.makeFunction("unescape", GlobalFunctions.UNESCAPE);
2324 this.print = ScriptFunctionImpl.makeFunction("print", env._print_no_newline ? PRINT : PRINTLN);
2325 this.load = ScriptFunctionImpl.makeFunction("load", LOAD);
2326 this.loadWithNewGlobal = ScriptFunctionImpl.makeFunction("loadWithNewGlobal", LOAD_WITH_NEW_GLOBAL);
2327 this.exit = ScriptFunctionImpl.makeFunction("exit", EXIT);
2328 this.quit = ScriptFunctionImpl.makeFunction("quit", EXIT);
2329
2330 // built-in constructors
2331 this.builtinArray = initConstructorAndSwitchPoint("Array", ScriptFunction.class);
2332 this.builtinBoolean = initConstructorAndSwitchPoint("Boolean", ScriptFunction.class);
2333 this.builtinNumber = initConstructorAndSwitchPoint("Number", ScriptFunction.class);
2334 this.builtinString = initConstructorAndSwitchPoint("String", ScriptFunction.class);
2335
2336 // initialize String.prototype.length to 0
2337 // add String.prototype.length
2338 final ScriptObject stringPrototype = getStringPrototype();
2339 stringPrototype.addOwnProperty("length", Attribute.NON_ENUMERABLE_CONSTANT, 0.0);
2340
2341 // set isArray flag on Array.prototype
2342 final ScriptObject arrayPrototype = getArrayPrototype();
2343 arrayPrototype.setIsArray();
2344
2345 // Error stuff
2346 initErrorObjects();
2347
2348 // java access
2349 if (! env._no_java) {
2350 this.javaApi = LAZY_SENTINEL;
2351 this.javaImporter = LAZY_SENTINEL;
2352 initJavaAccess();
2353 }
2354
2355 if (! env._no_typed_arrays) {
2356 this.arrayBuffer = LAZY_SENTINEL;
2357 this.dataView = LAZY_SENTINEL;
2358 this.int8Array = LAZY_SENTINEL;
2359 this.uint8Array = LAZY_SENTINEL;
2360 this.uint8ClampedArray = LAZY_SENTINEL;
2361 this.int16Array = LAZY_SENTINEL;
2362 this.uint16Array = LAZY_SENTINEL;
2363 this.int32Array = LAZY_SENTINEL;
2364 this.uint32Array = LAZY_SENTINEL;
2365 this.float32Array = LAZY_SENTINEL;
2366 this.float64Array = LAZY_SENTINEL;
2367 }
2368
2369 if (env._scripting) {
2370 initScripting(env);
2371 }
2372
2373 if (Context.DEBUG) {
2374 boolean debugOkay;
2375 final SecurityManager sm = System.getSecurityManager();
2376 if (sm != null) {
2377 try {
2378 sm.checkPermission(new RuntimePermission(Context.NASHORN_DEBUG_MODE));
2379 debugOkay = true;
2380 } catch (final SecurityException ignored) {
2381 // if no permission, don't initialize Debug object
2382 debugOkay = false;
2383 }
2384
2385 } else {
2386 debugOkay = true;
2420 errorProto.addOwnProperty("stack", Attribute.NOT_ENUMERABLE, getStack, setStack);
2421 final ScriptFunction getLineNumber = ScriptFunctionImpl.makeFunction("getLineNumber", NativeError.GET_LINENUMBER);
2422 final ScriptFunction setLineNumber = ScriptFunctionImpl.makeFunction("setLineNumber", NativeError.SET_LINENUMBER);
2423 errorProto.addOwnProperty("lineNumber", Attribute.NOT_ENUMERABLE, getLineNumber, setLineNumber);
2424 final ScriptFunction getColumnNumber = ScriptFunctionImpl.makeFunction("getColumnNumber", NativeError.GET_COLUMNNUMBER);
2425 final ScriptFunction setColumnNumber = ScriptFunctionImpl.makeFunction("setColumnNumber", NativeError.SET_COLUMNNUMBER);
2426 errorProto.addOwnProperty("columnNumber", Attribute.NOT_ENUMERABLE, getColumnNumber, setColumnNumber);
2427 final ScriptFunction getFileName = ScriptFunctionImpl.makeFunction("getFileName", NativeError.GET_FILENAME);
2428 final ScriptFunction setFileName = ScriptFunctionImpl.makeFunction("setFileName", NativeError.SET_FILENAME);
2429 errorProto.addOwnProperty("fileName", Attribute.NOT_ENUMERABLE, getFileName, setFileName);
2430
2431 // ECMA 15.11.4.2 Error.prototype.name
2432 // Error.prototype.name = "Error";
2433 errorProto.set(NativeError.NAME, "Error", 0);
2434 // ECMA 15.11.4.3 Error.prototype.message
2435 // Error.prototype.message = "";
2436 errorProto.set(NativeError.MESSAGE, "", 0);
2437
2438 tagBuiltinProperties("Error", builtinError);
2439
2440 this.builtinReferenceError = initErrorSubtype("ReferenceError", errorProto);
2441 this.builtinSyntaxError = initErrorSubtype("SyntaxError", errorProto);
2442 this.builtinTypeError = initErrorSubtype("TypeError", errorProto);
2443 }
2444
2445 private ScriptFunction initErrorSubtype(final String name, final ScriptObject errorProto) {
2446 final ScriptFunction cons = initConstructor(name, ScriptFunction.class);
2447 final ScriptObject prototype = ScriptFunction.getPrototype(cons);
2448 prototype.set(NativeError.NAME, name, 0);
2449 prototype.set(NativeError.MESSAGE, "", 0);
2450 prototype.setInitialProto(errorProto);
2451 tagBuiltinProperties(name, cons);
2452 return cons;
2453 }
2454
2455 private void initJavaAccess() {
2456 final ScriptObject objectProto = getObjectPrototype();
2457 this.builtinPackages = new NativeJavaPackage("", objectProto);
2458 this.builtinCom = new NativeJavaPackage("com", objectProto);
2459 this.builtinEdu = new NativeJavaPackage("edu", objectProto);
2460 this.builtinJava = new NativeJavaPackage("java", objectProto);
2461 this.builtinJavafx = new NativeJavaPackage("javafx", objectProto);
2462 this.builtinJavax = new NativeJavaPackage("javax", objectProto);
2463 this.builtinOrg = new NativeJavaPackage("org", objectProto);
2464 }
2465
2466 private void initScripting(final ScriptEnvironment scriptEnv) {
2467 Object value;
2468 value = ScriptFunctionImpl.makeFunction("readLine", ScriptingFunctions.READLINE);
2469 addOwnProperty("readLine", Attribute.NOT_ENUMERABLE, value);
2470
2471 value = ScriptFunctionImpl.makeFunction("readFully", ScriptingFunctions.READFULLY);
2472 addOwnProperty("readFully", Attribute.NOT_ENUMERABLE, value);
2473
2474 final String execName = ScriptingFunctions.EXEC_NAME;
2475 value = ScriptFunctionImpl.makeFunction(execName, ScriptingFunctions.EXEC);
2476 addOwnProperty(execName, Attribute.NOT_ENUMERABLE, value);
2477
2478 // Nashorn extension: global.echo (scripting-mode-only)
2479 // alias for "print"
2480 value = get("print");
2481 addOwnProperty("echo", Attribute.NOT_ENUMERABLE, value);
2482
2483 // Nashorn extension: global.$OPTIONS (scripting-mode-only)
2495 } else {
2496 addOwnProperty(ScriptingFunctions.ENV_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2497 }
2498
2499 // add other special properties for exec support
2500 addOwnProperty(ScriptingFunctions.OUT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2501 addOwnProperty(ScriptingFunctions.ERR_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2502 addOwnProperty(ScriptingFunctions.EXIT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2503 }
2504
2505 private static void copyOptions(final ScriptObject options, final ScriptEnvironment scriptEnv) {
2506 for (final Field f : scriptEnv.getClass().getFields()) {
2507 try {
2508 options.set(f.getName(), f.get(scriptEnv), 0);
2509 } catch (final IllegalArgumentException | IllegalAccessException exp) {
2510 throw new RuntimeException(exp);
2511 }
2512 }
2513 }
2514
2515 private void copyBuiltins() {
2516 this.array = this.builtinArray;
2517 this._boolean = this.builtinBoolean;
2518 this.error = this.builtinError;
2519 this.function = this.builtinFunction;
2520 this.com = this.builtinCom;
2521 this.edu = this.builtinEdu;
2522 this.java = this.builtinJava;
2523 this.javafx = this.builtinJavafx;
2524 this.javax = this.builtinJavax;
2525 this.org = this.builtinOrg;
2526 this.number = this.builtinNumber;
2527 this.object = this.builtinObject;
2528 this.packages = this.builtinPackages;
2529 this.referenceError = this.builtinReferenceError;
2530 this.string = this.builtinString;
2531 this.syntaxError = this.builtinSyntaxError;
2532 this.typeError = this.builtinTypeError;
2533 }
2534
2535 private void initDebug() {
2536 this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug", ScriptObject.class));
2537 }
2538
2539 private Object printImpl(final boolean newLine, final Object... objects) {
2540 @SuppressWarnings("resource")
2541 final PrintWriter out = scontext != null? new PrintWriter(scontext.getWriter()) : getContext().getEnv().getOut();
2542 final StringBuilder sb = new StringBuilder();
2543
2544 for (final Object obj : objects) {
2545 if (sb.length() != 0) {
2546 sb.append(' ');
2547 }
2548
2549 sb.append(JSType.toString(obj));
2550 }
2551
2552 // Print all at once to ensure thread friendly result.
|