1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.nashorn.internal.objects;
27
28 import static jdk.nashorn.internal.lookup.Lookup.MH;
29 import static jdk.nashorn.internal.runtime.ECMAErrors.referenceError;
30 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
31 import static jdk.nashorn.internal.runtime.JSType.isString;
32 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
33
34 import java.io.IOException;
35 import java.io.PrintWriter;
36 import java.lang.invoke.MethodHandle;
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.dynalink.CallSiteDescriptor;
51 import jdk.dynalink.StandardOperation;
52 import jdk.dynalink.linker.GuardedInvocation;
53 import jdk.dynalink.linker.LinkRequest;
54 import jdk.nashorn.api.scripting.ClassFilter;
55 import jdk.nashorn.api.scripting.ScriptObjectMirror;
56 import jdk.nashorn.internal.lookup.Lookup;
57 import jdk.nashorn.internal.objects.annotations.Attribute;
58 import jdk.nashorn.internal.objects.annotations.Getter;
59 import jdk.nashorn.internal.objects.annotations.Property;
60 import jdk.nashorn.internal.objects.annotations.ScriptClass;
61 import jdk.nashorn.internal.objects.annotations.Setter;
62 import jdk.nashorn.internal.runtime.Context;
63 import jdk.nashorn.internal.runtime.ECMAErrors;
64 import jdk.nashorn.internal.runtime.FindProperty;
65 import jdk.nashorn.internal.runtime.GlobalConstants;
66 import jdk.nashorn.internal.runtime.GlobalFunctions;
67 import jdk.nashorn.internal.runtime.JSType;
68 import jdk.nashorn.internal.runtime.NativeJavaPackage;
69 import jdk.nashorn.internal.runtime.PropertyDescriptor;
70 import jdk.nashorn.internal.runtime.PropertyMap;
71 import jdk.nashorn.internal.runtime.Scope;
72 import jdk.nashorn.internal.runtime.ScriptEnvironment;
73 import jdk.nashorn.internal.runtime.ScriptFunction;
74 import jdk.nashorn.internal.runtime.ScriptObject;
75 import jdk.nashorn.internal.runtime.ScriptRuntime;
76 import jdk.nashorn.internal.runtime.ScriptingFunctions;
77 import jdk.nashorn.internal.runtime.Specialization;
78 import jdk.nashorn.internal.runtime.Symbol;
79 import jdk.nashorn.internal.runtime.arrays.ArrayData;
80 import jdk.nashorn.internal.runtime.linker.Bootstrap;
81 import jdk.nashorn.internal.runtime.linker.InvokeByName;
82 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
83 import jdk.nashorn.internal.runtime.regexp.RegExpResult;
84 import jdk.nashorn.internal.scripts.JD;
85 import jdk.nashorn.internal.scripts.JO;
86 import jdk.nashorn.tools.ShellFunctions;
87
88 /**
89 * Representation of global scope.
90 */
91 @ScriptClass("Global")
92 public final class Global extends Scope {
93 // This special value is used to flag a lazily initialized global property.
94 // This also serves as placeholder value used in place of a location property
95 // (__FILE__, __DIR__, __LINE__)
96 private static final Object LAZY_SENTINEL = new Object();
97
98 private InvokeByName TO_STRING;
99 private InvokeByName VALUE_OF;
100
101 /**
102 * Optimistic builtin names that require switchpoint invalidation
103 * upon assignment. Overly conservative, but works for now, to avoid
104 * any complicated scope checks and especially heavy weight guards
105 * like
106 *
107 * <pre>
108 * public boolean setterGuard(final Object receiver) {
109 * final Global global = Global.instance();
110 * final ScriptObject sobj = global.getFunctionPrototype();
111 * final Object apply = sobj.get("apply");
112 * return apply == receiver;
113 * }
114 * </pre>
115 *
116 * Naturally, checking for builtin classes like NativeFunction is cheaper,
117 * it's when you start adding property checks for said builtins you have
118 * problems with guard speed.
119 */
120
121 /** Nashorn extension: arguments array */
122 @Property(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_CONFIGURABLE)
123 public Object arguments;
124
125 /** ECMA 15.1.2.2 parseInt (string , radix) */
126 @Property(attributes = Attribute.NOT_ENUMERABLE)
127 public Object parseInt;
128
129 /** ECMA 15.1.2.3 parseFloat (string) */
130 @Property(attributes = Attribute.NOT_ENUMERABLE)
131 public Object parseFloat;
132
133 /** ECMA 15.1.2.4 isNaN (number) */
134 @Property(attributes = Attribute.NOT_ENUMERABLE)
135 public Object isNaN;
136
137 /** ECMA 15.1.2.5 isFinite (number) */
138 @Property(attributes = Attribute.NOT_ENUMERABLE)
139 public Object isFinite;
140
141 /** ECMA 15.1.3.3 encodeURI */
142 @Property(attributes = Attribute.NOT_ENUMERABLE)
143 public Object encodeURI;
144
145 /** ECMA 15.1.3.4 encodeURIComponent */
146 @Property(attributes = Attribute.NOT_ENUMERABLE)
147 public Object encodeURIComponent;
148
149 /** ECMA 15.1.3.1 decodeURI */
150 @Property(attributes = Attribute.NOT_ENUMERABLE)
151 public Object decodeURI;
152
153 /** ECMA 15.1.3.2 decodeURIComponent */
154 @Property(attributes = Attribute.NOT_ENUMERABLE)
155 public Object decodeURIComponent;
156
157 /** ECMA B.2.1 escape (string) */
158 @Property(attributes = Attribute.NOT_ENUMERABLE)
159 public Object escape;
160
161 /** ECMA B.2.2 unescape (string) */
162 @Property(attributes = Attribute.NOT_ENUMERABLE)
163 public Object unescape;
164
165 /** Nashorn extension: global.print */
166 @Property(attributes = Attribute.NOT_ENUMERABLE)
167 public Object print;
168
169 /** Nashorn extension: global.load */
170 @Property(attributes = Attribute.NOT_ENUMERABLE)
171 public Object load;
172
173 /** Nashorn extension: global.loadWithNewGlobal */
174 @Property(attributes = Attribute.NOT_ENUMERABLE)
175 public Object loadWithNewGlobal;
176
177 /** Nashorn extension: global.exit */
178 @Property(attributes = Attribute.NOT_ENUMERABLE)
179 public Object exit;
180
181 /** Nashorn extension: global.quit */
182 @Property(attributes = Attribute.NOT_ENUMERABLE)
183 public Object quit;
184
185 /** Value property NaN of the Global Object - ECMA 15.1.1.1 NaN */
186 @Property(attributes = Attribute.NON_ENUMERABLE_CONSTANT)
187 public static final double NaN = Double.NaN;
188
189 /** Value property Infinity of the Global Object - ECMA 15.1.1.2 Infinity */
190 @Property(attributes = Attribute.NON_ENUMERABLE_CONSTANT)
191 public static final double Infinity = Double.POSITIVE_INFINITY;
192
193 /** Value property Undefined of the Global Object - ECMA 15.1.1.3 Undefined */
194 @Property(attributes = Attribute.NON_ENUMERABLE_CONSTANT)
195 public static final Object undefined = UNDEFINED;
196
197 /** ECMA 15.1.2.1 eval(x) */
198 @Property(attributes = Attribute.NOT_ENUMERABLE)
199 public Object eval;
200
201 /** ECMA 15.1.4.1 Object constructor. */
202 @Property(name = "Object", attributes = Attribute.NOT_ENUMERABLE)
203 public volatile Object object;
204
205 /** ECMA 15.1.4.2 Function constructor. */
206 @Property(name = "Function", attributes = Attribute.NOT_ENUMERABLE)
207 public volatile Object function;
208
209 /** ECMA 15.1.4.3 Array constructor. */
210 @Property(name = "Array", attributes = Attribute.NOT_ENUMERABLE)
211 public volatile Object array;
212
213 /** ECMA 15.1.4.4 String constructor */
214 @Property(name = "String", attributes = Attribute.NOT_ENUMERABLE)
215 public volatile Object string;
216
217 /** ECMA 15.1.4.5 Boolean constructor */
218 @Property(name = "Boolean", attributes = Attribute.NOT_ENUMERABLE)
219 public volatile Object _boolean;
220
221 /** ECMA 15.1.4.6 - Number constructor */
222 @Property(name = "Number", attributes = Attribute.NOT_ENUMERABLE)
223 public volatile Object number;
224
225 /** ECMA 2016 19.4.1 - Symbol constructor */
226 @Property(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
227 public volatile Object symbol;
228
229 /**
230 * Getter for ECMA 15.1.4.7 Date property
231 *
232 * @param self self reference
233 * @return Date property value
234 */
235 @Getter(name = "Date", attributes = Attribute.NOT_ENUMERABLE)
236 public static Object getDate(final Object self) {
237 final Global global = Global.instanceFrom(self);
238 if (global.date == LAZY_SENTINEL) {
239 global.date = global.getBuiltinDate();
240 }
241 return global.date;
242 }
243
244 /**
245 * Setter for ECMA 15.1.4.7 Date property
246 *
247 * @param self self reference
248 * @param value value for the Date property
249 */
250 @Setter(name = "Date", attributes = Attribute.NOT_ENUMERABLE)
251 public static void setDate(final Object self, final Object value) {
252 final Global global = Global.instanceFrom(self);
253 global.date = value;
254 }
255
256 private volatile Object date = LAZY_SENTINEL;
257
258 /**
259 * Getter for ECMA 15.1.4.8 RegExp property
260 *
261 * @param self self reference
262 * @return RegExp property value
263 */
264 @Getter(name = "RegExp", attributes = Attribute.NOT_ENUMERABLE)
265 public static Object getRegExp(final Object self) {
266 final Global global = Global.instanceFrom(self);
267 if (global.regexp == LAZY_SENTINEL) {
268 global.regexp = global.getBuiltinRegExp();
269 }
270 return global.regexp;
271 }
272
273 /**
274 * Setter for ECMA 15.1.4.8 RegExp property
275 *
276 * @param self self reference
277 * @param value value for the RegExp property
278 */
279 @Setter(name = "RegExp", attributes = Attribute.NOT_ENUMERABLE)
280 public static void setRegExp(final Object self, final Object value) {
281 final Global global = Global.instanceFrom(self);
282 global.regexp = value;
283 }
284
285 private volatile Object regexp = LAZY_SENTINEL;
286
287 /**
288 * Getter for ECMA 15.12 - The JSON property
289 * @param self self reference
290 * @return the value of JSON property
291 */
292 @Getter(name = "JSON", attributes = Attribute.NOT_ENUMERABLE)
293 public static Object getJSON(final Object self) {
294 final Global global = Global.instanceFrom(self);
295 if (global.json == LAZY_SENTINEL) {
296 global.json = global.getBuiltinJSON();
297 }
298 return global.json;
299 }
300
301 /**
302 * Setter for ECMA 15.12 - The JSON property
303 * @param self self reference
304 * @param value value for the JSON property
305 */
306 @Setter(name = "JSON", attributes = Attribute.NOT_ENUMERABLE)
307 public static void setJSON(final Object self, final Object value) {
308 final Global global = Global.instanceFrom(self);
309 global.json = value;
310 }
311
312 private volatile Object json = LAZY_SENTINEL;
313
314 /**
315 * Getter for Nashorn extension: global.JSAdapter
316 * @param self self reference
317 * @return value of the JSAdapter property
318 */
319 @Getter(name = "JSAdapter", attributes = Attribute.NOT_ENUMERABLE)
320 public static Object getJSAdapter(final Object self) {
321 final Global global = Global.instanceFrom(self);
322 if (global.jsadapter == LAZY_SENTINEL) {
323 global.jsadapter = global.getBuiltinJSAdapter();
324 }
325 return global.jsadapter;
326 }
327
328 /**
329 * Setter for Nashorn extension: global.JSAdapter
330 * @param self self reference
331 * @param value value for the JSAdapter property
332 */
333 @Setter(name = "JSAdapter", attributes = Attribute.NOT_ENUMERABLE)
334 public static void setJSAdapter(final Object self, final Object value) {
335 final Global global = Global.instanceFrom(self);
336 global.jsadapter = value;
337 }
338
339 private volatile Object jsadapter = LAZY_SENTINEL;
340
341 /** ECMA 15.8 - The Math object */
342 @Property(name = "Math", attributes = Attribute.NOT_ENUMERABLE)
343 public volatile Object math;
344
345 /** Error object */
346 @Property(name = "Error", attributes = Attribute.NOT_ENUMERABLE)
347 public volatile Object error;
348
349 /**
350 * Getter for the EvalError property
351 * @param self self reference
352 * @return the value of EvalError property
353 */
354 @Getter(name = "EvalError", attributes = Attribute.NOT_ENUMERABLE)
355 public static Object getEvalError(final Object self) {
356 final Global global = Global.instanceFrom(self);
357 if (global.evalError == LAZY_SENTINEL) {
358 global.evalError = global.getBuiltinEvalError();
359 }
360 return global.evalError;
361 }
362
363 /**
364 * Setter for the EvalError property
365 * @param self self reference
366 * @param value value of the EvalError property
367 */
368 @Setter(name = "EvalError", attributes = Attribute.NOT_ENUMERABLE)
369 public static void setEvalError(final Object self, final Object value) {
370 final Global global = Global.instanceFrom(self);
371 global.evalError = value;
372 }
373
374 private volatile Object evalError = LAZY_SENTINEL;
375
376 /**
377 * Getter for the RangeError property.
378 * @param self self reference
379 * @return the value of RangeError property
380 */
381 @Getter(name = "RangeError", attributes = Attribute.NOT_ENUMERABLE)
382 public static Object getRangeError(final Object self) {
383 final Global global = Global.instanceFrom(self);
384 if (global.rangeError == LAZY_SENTINEL) {
385 global.rangeError = global.getBuiltinRangeError();
386 }
387 return global.rangeError;
388 }
389
390
391 /**
392 * Setter for the RangeError property.
393 * @param self self reference
394 * @param value value for the RangeError property
395 */
396 @Setter(name = "RangeError", attributes = Attribute.NOT_ENUMERABLE)
397 public static void setRangeError(final Object self, final Object value) {
398 final Global global = Global.instanceFrom(self);
399 global.rangeError = value;
400 }
401
402 private volatile Object rangeError = LAZY_SENTINEL;
403
404 /** ReferenceError object */
405 @Property(name = "ReferenceError", attributes = Attribute.NOT_ENUMERABLE)
406 public volatile Object referenceError;
407
408 /** SyntaxError object */
409 @Property(name = "SyntaxError", attributes = Attribute.NOT_ENUMERABLE)
410 public volatile Object syntaxError;
411
412 /** TypeError object */
413 @Property(name = "TypeError", attributes = Attribute.NOT_ENUMERABLE)
414 public volatile Object typeError;
415
416 /**
417 * Getter for the URIError property.
418 * @param self self reference
419 * @return the value of URIError property
420 */
421 @Getter(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
422 public static Object getURIError(final Object self) {
423 final Global global = Global.instanceFrom(self);
424 if (global.uriError == LAZY_SENTINEL) {
425 global.uriError = global.getBuiltinURIError();
426 }
427 return global.uriError;
428 }
429
430 /**
431 * Setter for the URIError property.
432 * @param self self reference
433 * @param value value for the URIError property
434 */
435 @Setter(name = "URIError", attributes = Attribute.NOT_ENUMERABLE)
436 public static void setURIError(final Object self, final Object value) {
437 final Global global = Global.instanceFrom(self);
438 global.uriError = value;
439 }
440
441 private volatile Object uriError = LAZY_SENTINEL;
442
443 /**
444 * Getter for the ArrayBuffer property.
445 * @param self self reference
446 * @return the value of the ArrayBuffer property
447 */
448 @Getter(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
449 public static Object getArrayBuffer(final Object self) {
450 final Global global = Global.instanceFrom(self);
451 if (global.arrayBuffer == LAZY_SENTINEL) {
452 global.arrayBuffer = global.getBuiltinArrayBuffer();
453 }
454 return global.arrayBuffer;
455 }
456
457 /**
458 * Setter for the ArrayBuffer property.
459 * @param self self reference
460 * @param value value of the ArrayBuffer property
461 */
462 @Setter(name = "ArrayBuffer", attributes = Attribute.NOT_ENUMERABLE)
463 public static void setArrayBuffer(final Object self, final Object value) {
464 final Global global = Global.instanceFrom(self);
465 global.arrayBuffer = value;
466 }
467
468 private volatile Object arrayBuffer;
469
470 /**
471 * Getter for the DataView property.
472 * @param self self reference
473 * @return the value of the DataView property
474 */
475 @Getter(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
476 public static Object getDataView(final Object self) {
477 final Global global = Global.instanceFrom(self);
478 if (global.dataView == LAZY_SENTINEL) {
479 global.dataView = global.getBuiltinDataView();
480 }
481 return global.dataView;
482 }
483
484
485 /**
486 * Setter for the DataView property.
487 * @param self self reference
488 * @param value value of the DataView property
489 */
490 @Setter(name = "DataView", attributes = Attribute.NOT_ENUMERABLE)
491 public static void setDataView(final Object self, final Object value) {
492 final Global global = Global.instanceFrom(self);
493 global.dataView = value;
494 }
495
496 private volatile Object dataView;
497
498 /**
499 * Getter for the Int8Array property.
500 * @param self self reference
501 * @return the value of the Int8Array property.
502 */
503 @Getter(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
504 public static Object getInt8Array(final Object self) {
505 final Global global = Global.instanceFrom(self);
506 if (global.int8Array == LAZY_SENTINEL) {
507 global.int8Array = global.getBuiltinInt8Array();
508 }
509 return global.int8Array;
510 }
511
512 /**
513 * Setter for the Int8Array property.
514 * @param self self reference
515 * @param value value of the Int8Array property
516 */
517 @Setter(name = "Int8Array", attributes = Attribute.NOT_ENUMERABLE)
518 public static void setInt8Array(final Object self, final Object value) {
519 final Global global = Global.instanceFrom(self);
520 global.int8Array = value;
521 }
522
523 private volatile Object int8Array;
524
525 /**
526 * Getter for the Uin8Array property.
527 * @param self self reference
528 * @return the value of the Uint8Array property
529 */
530 @Getter(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
531 public static Object getUint8Array(final Object self) {
532 final Global global = Global.instanceFrom(self);
533 if (global.uint8Array == LAZY_SENTINEL) {
534 global.uint8Array = global.getBuiltinUint8Array();
535 }
536 return global.uint8Array;
537 }
538
539 /**
540 * Setter for the Uin8Array property.
541 * @param self self reference
542 * @param value value of the Uin8Array property
543 */
544 @Setter(name = "Uint8Array", attributes = Attribute.NOT_ENUMERABLE)
545 public static void setUint8Array(final Object self, final Object value) {
546 final Global global = Global.instanceFrom(self);
547 global.uint8Array = value;
548 }
549
550 private volatile Object uint8Array;
551
552 /**
553 * Getter for the Uint8ClampedArray property.
554 * @param self self reference
555 * @return the value of the Uint8ClampedArray property
556 */
557 @Getter(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
558 public static Object getUint8ClampedArray(final Object self) {
559 final Global global = Global.instanceFrom(self);
560 if (global.uint8ClampedArray == LAZY_SENTINEL) {
561 global.uint8ClampedArray = global.getBuiltinUint8ClampedArray();
562 }
563 return global.uint8ClampedArray;
564 }
565
566 /**
567 * Setter for the Uint8ClampedArray property.
568 * @param self self reference
569 * @param value value of the Uint8ClampedArray property
570 */
571 @Setter(name = "Uint8ClampedArray", attributes = Attribute.NOT_ENUMERABLE)
572 public static void setUint8ClampedArray(final Object self, final Object value) {
573 final Global global = Global.instanceFrom(self);
574 global.uint8ClampedArray = value;
575 }
576
577 private volatile Object uint8ClampedArray;
578
579 /**
580 * Getter for the Int16Array property.
581 * @param self self reference
582 * @return the value of the Int16Array property
583 */
584 @Getter(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
585 public static Object getInt16Array(final Object self) {
586 final Global global = Global.instanceFrom(self);
587 if (global.int16Array == LAZY_SENTINEL) {
588 global.int16Array = global.getBuiltinInt16Array();
589 }
590 return global.int16Array;
591 }
592
593 /**
594 * Setter for the Int16Array property.
595 * @param self self reference
596 * @param value value of the Int16Array property
597 */
598 @Setter(name = "Int16Array", attributes = Attribute.NOT_ENUMERABLE)
599 public static void setInt16Array(final Object self, final Object value) {
600 final Global global = Global.instanceFrom(self);
601 global.int16Array = value;
602 }
603
604 private volatile Object int16Array;
605
606 /**
607 * Getter for the Uint16Array property.
608 * @param self self reference
609 * @return the value of the Uint16Array property
610 */
611 @Getter(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
612 public static Object getUint16Array(final Object self) {
613 final Global global = Global.instanceFrom(self);
614 if (global.uint16Array == LAZY_SENTINEL) {
615 global.uint16Array = global.getBuiltinUint16Array();
616 }
617 return global.uint16Array;
618 }
619
620 /**
621 * Setter for the Uint16Array property.
622 * @param self self reference
623 * @param value value of the Uint16Array property
624 */
625 @Setter(name = "Uint16Array", attributes = Attribute.NOT_ENUMERABLE)
626 public static void setUint16Array(final Object self, final Object value) {
627 final Global global = Global.instanceFrom(self);
628 global.uint16Array = value;
629 }
630
631 private volatile Object uint16Array;
632
633 /**
634 * Getter for the Int32Array property.
635 *
636 * @param self self reference
637 * @return the value of the Int32Array property
638 */
639 @Getter(name = "Int32Array", attributes = Attribute.NOT_ENUMERABLE)
640 public static Object getInt32Array(final Object self) {
641 final Global global = Global.instanceFrom(self);
642 if (global.int32Array == LAZY_SENTINEL) {
643 global.int32Array = global.getBuiltinInt32Array();
644 }
645 return global.int32Array;
646 }
647
648
649 /**
650 * Setter for the Int32Array property.
651 *
652 * @param self self reference
653 * @param value value of the Int32Array property
654 */
655 @Setter(name = "Int32Array", attributes = Attribute.NOT_ENUMERABLE)
656 public static void setInt32Array(final Object self, final Object value) {
657 final Global global = Global.instanceFrom(self);
658 global.int32Array = value;
659 }
660
661 private volatile Object int32Array;
662
663 /**
664 * Getter of the Uint32Array property.
665 *
666 * @param self self reference
667 * @return the value of the Uint32Array property
668 */
669 @Getter(name = "Uint32Array", attributes = Attribute.NOT_ENUMERABLE)
670 public static Object getUint32Array(final Object self) {
671 final Global global = Global.instanceFrom(self);
672 if (global.uint32Array == LAZY_SENTINEL) {
673 global.uint32Array = global.getBuiltinUint32Array();
674 }
675 return global.uint32Array;
676 }
677
678
679 /**
680 * Setter of the Uint32Array property.
681 *
682 * @param self self reference
683 * @param value value of the Uint32Array property
684 */
685 @Setter(name = "Uint32Array", attributes = Attribute.NOT_ENUMERABLE)
686 public static void setUint32Array(final Object self, final Object value) {
687 final Global global = Global.instanceFrom(self);
688 global.uint32Array = value;
689 }
690
691 private volatile Object uint32Array;
692
693 /**
694 * Getter for the Float32Array property.
695 *
696 * @param self self reference
697 * @return the value of the Float32Array property
698 */
699 @Getter(name = "Float32Array", attributes = Attribute.NOT_ENUMERABLE)
700 public static Object getFloat32Array(final Object self) {
701 final Global global = Global.instanceFrom(self);
702 if (global.float32Array == LAZY_SENTINEL) {
703 global.float32Array = global.getBuiltinFloat32Array();
704 }
705 return global.float32Array;
706 }
707
708 /**
709 * Setter for the Float32Array property.
710 *
711 * @param self self reference
712 * @param value value of the Float32Array property
713 */
714 @Setter(name = "Float32Array", attributes = Attribute.NOT_ENUMERABLE)
715 public static void setFloat32Array(final Object self, final Object value) {
716 final Global global = Global.instanceFrom(self);
717 global.float32Array = value;
718 }
719
720 private volatile Object float32Array;
721
722 /**
723 * Getter for the Float64Array property.
724 *
725 * @param self self reference
726 * @return the value of the Float64Array property
727 */
728 @Getter(name = "Float64Array", attributes = Attribute.NOT_ENUMERABLE)
729 public static Object getFloat64Array(final Object self) {
730 final Global global = Global.instanceFrom(self);
731 if (global.float64Array == LAZY_SENTINEL) {
732 global.float64Array = global.getBuiltinFloat64Array();
733 }
734 return global.float64Array;
735 }
736
737 /**
738 * Setter for the Float64Array property.
739 *
740 * @param self self reference
741 * @param value value of the Float64Array property
742 */
743 @Setter(name = "Float64Array", attributes = Attribute.NOT_ENUMERABLE)
744 public static void setFloat64Array(final Object self, final Object value) {
745 final Global global = Global.instanceFrom(self);
746 global.float64Array = value;
747 }
748
749 private volatile Object float64Array;
750
751 /** Nashorn extension: Java access - global.Packages */
752 @Property(name = "Packages", attributes = Attribute.NOT_ENUMERABLE)
753 public volatile Object packages;
754
755 /** Nashorn extension: Java access - global.com */
756 @Property(attributes = Attribute.NOT_ENUMERABLE)
757 public volatile Object com;
758
759 /** Nashorn extension: Java access - global.edu */
760 @Property(attributes = Attribute.NOT_ENUMERABLE)
761 public volatile Object edu;
762
763 /** Nashorn extension: Java access - global.java */
764 @Property(attributes = Attribute.NOT_ENUMERABLE)
765 public volatile Object java;
766
767 /** Nashorn extension: Java access - global.javafx */
768 @Property(attributes = Attribute.NOT_ENUMERABLE)
769 public volatile Object javafx;
770
771 /** Nashorn extension: Java access - global.javax */
772 @Property(attributes = Attribute.NOT_ENUMERABLE)
773 public volatile Object javax;
774
775 /** Nashorn extension: Java access - global.org */
776 @Property(attributes = Attribute.NOT_ENUMERABLE)
777 public volatile Object org;
778
779 /**
780 * Getter for the Nashorn extension: Java access - global.javaImporter.
781 *
782 * @param self self reference
783 * @return the value of the JavaImporter property
784 */
785 @Getter(name = "JavaImporter", attributes = Attribute.NOT_ENUMERABLE)
786 public static Object getJavaImporter(final Object self) {
787 final Global global = Global.instanceFrom(self);
788 if (global.javaImporter == LAZY_SENTINEL) {
789 global.javaImporter = global.getBuiltinJavaImporter();
790 }
791 return global.javaImporter;
792 }
793
794 /**
795 * Setter for the Nashorn extension: Java access - global.javaImporter.
796 *
797 * @param self self reference
798 * @param value value of the JavaImporter property
799 */
800 @Setter(name = "JavaImporter", attributes = Attribute.NOT_ENUMERABLE)
801 public static void setJavaImporter(final Object self, final Object value) {
802 final Global global = Global.instanceFrom(self);
803 global.javaImporter = value;
804 }
805
806 private volatile Object javaImporter;
807
808 /**
809 * Getter for the Nashorn extension: global.Java property.
810 *
811 * @param self self reference
812 * @return the value of the Java property
813 */
814 @Getter(name = "Java", attributes = Attribute.NOT_ENUMERABLE)
815 public static Object getJavaApi(final Object self) {
816 final Global global = Global.instanceFrom(self);
817 if (global.javaApi == LAZY_SENTINEL) {
818 global.javaApi = global.getBuiltinJavaApi();
819 }
820 return global.javaApi;
821 }
822
823 /**
824 * Setter for the Nashorn extension: global.Java property.
825 *
826 * @param self self reference
827 * @param value value of the Java property
828 */
829 @Setter(name = "Java", attributes = Attribute.NOT_ENUMERABLE)
830 public static void setJavaApi(final Object self, final Object value) {
831 final Global global = Global.instanceFrom(self);
832 global.javaApi = value;
833 }
834
835 private volatile Object javaApi;
836
837 /** Nashorn extension: current script's file name */
838 @Property(name = "__FILE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
839 public static final Object __FILE__ = LAZY_SENTINEL;
840
841 /** Nashorn extension: current script's directory */
842 @Property(name = "__DIR__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
843 public static final Object __DIR__ = LAZY_SENTINEL;
844
845 /** Nashorn extension: current source line number being executed */
846 @Property(name = "__LINE__", attributes = Attribute.NON_ENUMERABLE_CONSTANT)
847 public static final Object __LINE__ = LAZY_SENTINEL;
848
849 private volatile NativeDate DEFAULT_DATE;
850
851 /** Used as Date.prototype's default value */
852 NativeDate getDefaultDate() {
853 return DEFAULT_DATE;
854 }
855
856 private volatile NativeRegExp DEFAULT_REGEXP;
857
858 /** Used as RegExp.prototype's default value */
859 NativeRegExp getDefaultRegExp() {
860 return DEFAULT_REGEXP;
861 }
862
863 /*
864 * Built-in constructor objects: Even if user changes dynamic values of
865 * "Object", "Array" etc., we still want to keep original values of these
866 * constructors here. For example, we need to be able to create array,
867 * regexp literals even after user overwrites global "Array" or "RegExp"
868 * constructor - see also ECMA 262 spec. Annex D.
869 */
870 private ScriptFunction builtinFunction;
871 private ScriptFunction builtinObject;
872 private ScriptFunction builtinArray;
873 private ScriptFunction builtinBoolean;
874 private ScriptFunction builtinDate;
875 private ScriptObject builtinJSON;
876 private ScriptFunction builtinJSAdapter;
877 private ScriptObject builtinMath;
878 private ScriptFunction builtinNumber;
879 private ScriptFunction builtinRegExp;
880 private ScriptFunction builtinString;
881 private ScriptFunction builtinError;
882 private ScriptFunction builtinEval;
883 private ScriptFunction builtinEvalError;
884 private ScriptFunction builtinRangeError;
885 private ScriptFunction builtinReferenceError;
886 private ScriptFunction builtinSyntaxError;
887 private ScriptFunction builtinTypeError;
888 private ScriptFunction builtinURIError;
889 private ScriptObject builtinPackages;
890 private ScriptObject builtinCom;
891 private ScriptObject builtinEdu;
892 private ScriptObject builtinJava;
893 private ScriptObject builtinJavafx;
894 private ScriptObject builtinJavax;
895 private ScriptObject builtinOrg;
896 private ScriptFunction builtinJavaImporter;
897 private ScriptObject builtinJavaApi;
898 private ScriptFunction builtinArrayBuffer;
899 private ScriptFunction builtinDataView;
900 private ScriptFunction builtinInt8Array;
901 private ScriptFunction builtinUint8Array;
902 private ScriptFunction builtinUint8ClampedArray;
903 private ScriptFunction builtinInt16Array;
904 private ScriptFunction builtinUint16Array;
905 private ScriptFunction builtinInt32Array;
906 private ScriptFunction builtinUint32Array;
907 private ScriptFunction builtinFloat32Array;
908 private ScriptFunction builtinFloat64Array;
909 private ScriptFunction builtinSymbol;
910
911 /*
912 * ECMA section 13.2.3 The [[ThrowTypeError]] Function Object
913 */
914 private ScriptFunction typeErrorThrower;
915
916 // Used to store the last RegExp result to support deprecated RegExp constructor properties
917 private RegExpResult lastRegExpResult;
918
919 private static final MethodHandle EVAL = findOwnMH_S("eval", Object.class, Object.class, Object.class);
920 private static final MethodHandle NO_SUCH_PROPERTY = findOwnMH_S(NO_SUCH_PROPERTY_NAME, Object.class, Object.class, Object.class);
921 private static final MethodHandle PRINT = findOwnMH_S("print", Object.class, Object.class, Object[].class);
922 private static final MethodHandle PRINTLN = findOwnMH_S("println", Object.class, Object.class, Object[].class);
923 private static final MethodHandle LOAD = findOwnMH_S("load", Object.class, Object.class, Object.class);
924 private static final MethodHandle LOAD_WITH_NEW_GLOBAL = findOwnMH_S("loadWithNewGlobal", Object.class, Object.class, Object[].class);
925 private static final MethodHandle EXIT = findOwnMH_S("exit", Object.class, Object.class, Object.class);
926 private static final MethodHandle LEXICAL_SCOPE_FILTER = findOwnMH_S("lexicalScopeFilter", Object.class, Object.class);
927
928 // initialized by nasgen
929 private static PropertyMap $nasgenmap$;
930
931 // context to which this global belongs to
932 private final Context context;
933
934 // current ScriptContext to use - can be null.
935 private ThreadLocal<ScriptContext> scontext;
936 // current ScriptEngine associated - can be null.
937 private ScriptEngine engine;
938
939 // ES6 global lexical scope.
940 private final LexicalScope lexicalScope;
941
942 // Switchpoint for non-constant global callsites in the presence of ES6 lexical scope.
943 private SwitchPoint lexicalScopeSwitchPoint;
944
945 /**
946 * Set the current script context
947 * @param ctxt script context
948 */
949 public void setScriptContext(final ScriptContext ctxt) {
950 assert scontext != null;
951 scontext.set(ctxt);
952 }
953
954 /**
955 * Get the current script context
956 * @return current script context
957 */
958 public ScriptContext getScriptContext() {
959 assert scontext != null;
960 return scontext.get();
961 }
962
963 private ScriptContext currentContext() {
964 final ScriptContext sc = scontext != null? scontext.get() : null;
965 return (sc != null)? sc : (engine != null? engine.getContext() : null);
966 }
967
968 @Override
969 protected Context getContext() {
970 return context;
971 }
972
973 @Override
974 protected boolean useDualFields() {
975 return context.useDualFields();
976 }
977
978 // performs initialization checks for Global constructor and returns the
979 // PropertyMap, if everything is fine.
980 private static PropertyMap checkAndGetMap(final Context context) {
981 // security check first
982 final SecurityManager sm = System.getSecurityManager();
983 if (sm != null) {
984 sm.checkPermission(new RuntimePermission(Context.NASHORN_CREATE_GLOBAL));
985 }
986
987 Objects.requireNonNull(context);
988
989 return $nasgenmap$;
990 }
991
992 /**
993 * Constructor
994 *
995 * @param context the context
996 */
997 public Global(final Context context) {
998 super(checkAndGetMap(context));
999 this.context = context;
1000 this.lexicalScope = context.getEnv()._es6 ? new LexicalScope(this) : null;
1001 }
1002
1003 /**
1004 * Script access to "current" Global instance
1005 *
1006 * @return the global singleton
1007 */
1008 public static Global instance() {
1009 return Objects.requireNonNull(Context.getGlobal());
1010 }
1011
1012 private static Global instanceFrom(final Object self) {
1013 return self instanceof Global? (Global)self : instance();
1014 }
1015
1016 /**
1017 * Check if we have a Global instance
1018 * @return true if one exists
1019 */
1020 public static boolean hasInstance() {
1021 return Context.getGlobal() != null;
1022 }
1023
1024 /**
1025 * Script access to {@link ScriptEnvironment}
1026 *
1027 * @return the script environment
1028 */
1029 static ScriptEnvironment getEnv() {
1030 return instance().getContext().getEnv();
1031 }
1032
1033 /**
1034 * Script access to {@link Context}
1035 *
1036 * @return the context
1037 */
1038 static Context getThisContext() {
1039 return instance().getContext();
1040 }
1041
1042 // Runtime interface to Global
1043
1044 /**
1045 * Is there a class filter in the current Context?
1046 * @return class filter
1047 */
1048 public ClassFilter getClassFilter() {
1049 return context.getClassFilter();
1050 }
1051
1052 /**
1053 * Is this global of the given Context?
1054 * @param ctxt the context
1055 * @return true if this global belongs to the given Context
1056 */
1057 public boolean isOfContext(final Context ctxt) {
1058 return this.context == ctxt;
1059 }
1060
1061 /**
1062 * Does this global belong to a strict Context?
1063 * @return true if this global belongs to a strict Context
1064 */
1065 public boolean isStrictContext() {
1066 return context.getEnv()._strict;
1067 }
1068
1069 /**
1070 * Initialize standard builtin objects like "Object", "Array", "Function" etc.
1071 * as well as our extension builtin objects like "Java", "JSAdapter" as properties
1072 * of the global scope object.
1073 *
1074 * @param eng ScriptEngine to initialize
1075 */
1076 public void initBuiltinObjects(final ScriptEngine eng) {
1077 if (this.builtinObject != null) {
1078 // already initialized, just return
1079 return;
1080 }
1081
1082 TO_STRING = new InvokeByName("toString", ScriptObject.class);
1083 VALUE_OF = new InvokeByName("valueOf", ScriptObject.class);
1084
1085 this.engine = eng;
1086 if (this.engine != null) {
1087 this.scontext = new ThreadLocal<>();
1088 }
1089 init(eng);
1090 }
1091
1092 /**
1093 * Wrap a Java object as corresponding script object
1094 *
1095 * @param obj object to wrap
1096 * @return wrapped object
1097 */
1098 public Object wrapAsObject(final Object obj) {
1099 if (obj instanceof Boolean) {
1100 return new NativeBoolean((Boolean)obj, this);
1101 } else if (obj instanceof Number) {
1102 return new NativeNumber(((Number)obj).doubleValue(), this);
1103 } else if (isString(obj)) {
1104 return new NativeString((CharSequence)obj, this);
1105 } else if (obj instanceof Object[]) { // extension
1106 return new NativeArray(ArrayData.allocate((Object[])obj), this);
1107 } else if (obj instanceof double[]) { // extension
1108 return new NativeArray(ArrayData.allocate((double[])obj), this);
1109 } else if (obj instanceof int[]) {
1110 return new NativeArray(ArrayData.allocate((int[]) obj), this);
1111 } else if (obj instanceof ArrayData) {
1112 return new NativeArray((ArrayData) obj, this);
1113 } else if (obj instanceof Symbol) {
1114 return new NativeSymbol((Symbol) obj, this);
1115 } else {
1116 // FIXME: more special cases? Map? List?
1117 return obj;
1118 }
1119 }
1120
1121 /**
1122 * Lookup helper for JS primitive types
1123 *
1124 * @param request the link request for the dynamic call site.
1125 * @param self self reference
1126 *
1127 * @return guarded invocation
1128 */
1129 public static GuardedInvocation primitiveLookup(final LinkRequest request, final Object self) {
1130 if (isString(self)) {
1131 return NativeString.lookupPrimitive(request, self);
1132 } else if (self instanceof Number) {
1133 return NativeNumber.lookupPrimitive(request, self);
1134 } else if (self instanceof Boolean) {
1135 return NativeBoolean.lookupPrimitive(request, self);
1136 }
1137 throw new IllegalArgumentException("Unsupported primitive: " + self);
1138 }
1139
1140 /**
1141 * Returns a method handle that creates a wrapper object for a JS primitive value.
1142 *
1143 * @param self receiver object
1144 * @return method handle to create wrapper objects for primitive receiver
1145 */
1146 public static MethodHandle getPrimitiveWrapFilter(final Object self) {
1147 if (isString(self)) {
1148 return NativeString.WRAPFILTER;
1149 } else if (self instanceof Number) {
1150 return NativeNumber.WRAPFILTER;
1151 } else if (self instanceof Boolean) {
1152 return NativeBoolean.WRAPFILTER;
1153 }
1154 throw new IllegalArgumentException("Unsupported primitive: " + self);
1155 }
1156
1157
1158 /**
1159 * Create a new empty script object
1160 *
1161 * @return the new ScriptObject
1162 */
1163 public ScriptObject newObject() {
1164 return useDualFields() ? new JD(getObjectPrototype()) : new JO(getObjectPrototype());
1165 }
1166
1167 /**
1168 * Default value of given type
1169 *
1170 * @param sobj script object
1171 * @param typeHint type hint
1172 *
1173 * @return default value
1174 */
1175 public Object getDefaultValue(final ScriptObject sobj, final Class<?> typeHint) {
1176 // When the [[DefaultValue]] internal method of O is called with no hint,
1177 // then it behaves as if the hint were Number, unless O is a Date object
1178 // in which case it behaves as if the hint were String.
1179 Class<?> hint = typeHint;
1180 if (hint == null) {
1181 hint = Number.class;
1182 }
1183
1184 try {
1185 if (hint == String.class) {
1186
1187 final Object toString = TO_STRING.getGetter().invokeExact(sobj);
1188
1189 if (Bootstrap.isCallable(toString)) {
1190 final Object value = TO_STRING.getInvoker().invokeExact(toString, sobj);
1191 if (JSType.isPrimitive(value)) {
1192 return value;
1193 }
1194 }
1195
1196 final Object valueOf = VALUE_OF.getGetter().invokeExact(sobj);
1197 if (Bootstrap.isCallable(valueOf)) {
1198 final Object value = VALUE_OF.getInvoker().invokeExact(valueOf, sobj);
1199 if (JSType.isPrimitive(value)) {
1200 return value;
1201 }
1202 }
1203 throw typeError(this, "cannot.get.default.string");
1204 }
1205
1206 if (hint == Number.class) {
1207 final Object valueOf = VALUE_OF.getGetter().invokeExact(sobj);
1208 if (Bootstrap.isCallable(valueOf)) {
1209 final Object value = VALUE_OF.getInvoker().invokeExact(valueOf, sobj);
1210 if (JSType.isPrimitive(value)) {
1211 return value;
1212 }
1213 }
1214
1215 final Object toString = TO_STRING.getGetter().invokeExact(sobj);
1216 if (Bootstrap.isCallable(toString)) {
1217 final Object value = TO_STRING.getInvoker().invokeExact(toString, sobj);
1218 if (JSType.isPrimitive(value)) {
1219 return value;
1220 }
1221 }
1222
1223 throw typeError(this, "cannot.get.default.number");
1224 }
1225 } catch (final RuntimeException | Error e) {
1226 throw e;
1227 } catch (final Throwable t) {
1228 throw new RuntimeException(t);
1229 }
1230
1231 return UNDEFINED;
1232 }
1233
1234 /**
1235 * Is the given ScriptObject an ECMAScript Error object?
1236 *
1237 * @param sobj the object being checked
1238 * @return true if sobj is an Error object
1239 */
1240 public boolean isError(final ScriptObject sobj) {
1241 final ScriptObject errorProto = getErrorPrototype();
1242 ScriptObject proto = sobj.getProto();
1243 while (proto != null) {
1244 if (proto == errorProto) {
1245 return true;
1246 }
1247 proto = proto.getProto();
1248 }
1249 return false;
1250 }
1251
1252 /**
1253 * Create a new ECMAScript Error object.
1254 *
1255 * @param msg error message
1256 * @return newly created Error object
1257 */
1258 public ScriptObject newError(final String msg) {
1259 return new NativeError(msg, this);
1260 }
1261
1262 /**
1263 * Create a new ECMAScript EvalError object.
1264 *
1265 * @param msg error message
1266 * @return newly created EvalError object
1267 */
1268 public ScriptObject newEvalError(final String msg) {
1269 return new NativeEvalError(msg, this);
1270 }
1271
1272 /**
1273 * Create a new ECMAScript RangeError object.
1274 *
1275 * @param msg error message
1276 * @return newly created RangeError object
1277 */
1278 public ScriptObject newRangeError(final String msg) {
1279 return new NativeRangeError(msg, this);
1280 }
1281
1282 /**
1283 * Create a new ECMAScript ReferenceError object.
1284 *
1285 * @param msg error message
1286 * @return newly created ReferenceError object
1287 */
1288 public ScriptObject newReferenceError(final String msg) {
1289 return new NativeReferenceError(msg, this);
1290 }
1291
1292 /**
1293 * Create a new ECMAScript SyntaxError object.
1294 *
1295 * @param msg error message
1296 * @return newly created SyntaxError object
1297 */
1298 public ScriptObject newSyntaxError(final String msg) {
1299 return new NativeSyntaxError(msg, this);
1300 }
1301
1302 /**
1303 * Create a new ECMAScript TypeError object.
1304 *
1305 * @param msg error message
1306 * @return newly created TypeError object
1307 */
1308 public ScriptObject newTypeError(final String msg) {
1309 return new NativeTypeError(msg, this);
1310 }
1311
1312 /**
1313 * Create a new ECMAScript URIError object.
1314 *
1315 * @param msg error message
1316 * @return newly created URIError object
1317 */
1318 public ScriptObject newURIError(final String msg) {
1319 return new NativeURIError(msg, this);
1320 }
1321
1322 /**
1323 * Create a new ECMAScript GenericDescriptor object.
1324 *
1325 * @param configurable is the property configurable?
1326 * @param enumerable is the property enumerable?
1327 * @return newly created GenericDescriptor object
1328 */
1329 public PropertyDescriptor newGenericDescriptor(final boolean configurable, final boolean enumerable) {
1330 return new GenericPropertyDescriptor(configurable, enumerable, this);
1331 }
1332
1333 /**
1334 * Create a new ECMAScript DatePropertyDescriptor object.
1335 *
1336 * @param value of the data property
1337 * @param configurable is the property configurable?
1338 * @param enumerable is the property enumerable?
1339 * @param writable is the property writable?
1340 * @return newly created DataPropertyDescriptor object
1341 */
1342 public PropertyDescriptor newDataDescriptor(final Object value, final boolean configurable, final boolean enumerable, final boolean writable) {
1343 return new DataPropertyDescriptor(configurable, enumerable, writable, value, this);
1344 }
1345
1346 /**
1347 * Create a new ECMAScript AccessorPropertyDescriptor object.
1348 *
1349 * @param get getter function of the user accessor property
1350 * @param set setter function of the user accessor property
1351 * @param configurable is the property configurable?
1352 * @param enumerable is the property enumerable?
1353 * @return newly created AccessorPropertyDescriptor object
1354 */
1355 public PropertyDescriptor newAccessorDescriptor(final Object get, final Object set, final boolean configurable, final boolean enumerable) {
1356 final AccessorPropertyDescriptor desc = new AccessorPropertyDescriptor(configurable, enumerable, get == null ? UNDEFINED : get, set == null ? UNDEFINED : set, this);
1357
1358 if (get == null) {
1359 desc.delete(PropertyDescriptor.GET, false);
1360 }
1361
1362 if (set == null) {
1363 desc.delete(PropertyDescriptor.SET, false);
1364 }
1365
1366 return desc;
1367 }
1368
1369 private <T> T getLazilyCreatedValue(final Object key, final Callable<T> creator, final Map<Object, T> map) {
1370 final T obj = map.get(key);
1371 if (obj != null) {
1372 return obj;
1373 }
1374
1375 final Global oldGlobal = Context.getGlobal();
1376 final boolean differentGlobal = oldGlobal != this;
1377 try {
1378 if (differentGlobal) {
1379 Context.setGlobal(this);
1380 }
1381 final T newObj = creator.call();
1382 final T existingObj = map.putIfAbsent(key, newObj);
1383 return existingObj != null ? existingObj : newObj;
1384 } catch (final Exception exp) {
1385 throw new RuntimeException(exp);
1386 } finally {
1387 if (differentGlobal) {
1388 Context.setGlobal(oldGlobal);
1389 }
1390 }
1391 }
1392
1393 private final Map<Object, InvokeByName> namedInvokers = new ConcurrentHashMap<>();
1394
1395
1396 /**
1397 * Get cached InvokeByName object for the given key
1398 * @param key key to be associated with InvokeByName object
1399 * @param creator if InvokeByName is absent 'creator' is called to make one (lazy init)
1400 * @return InvokeByName object associated with the key.
1401 */
1402 public InvokeByName getInvokeByName(final Object key, final Callable<InvokeByName> creator) {
1403 return getLazilyCreatedValue(key, creator, namedInvokers);
1404 }
1405
1406 private final Map<Object, MethodHandle> dynamicInvokers = new ConcurrentHashMap<>();
1407
1408 /**
1409 * Get cached dynamic method handle for the given key
1410 * @param key key to be associated with dynamic method handle
1411 * @param creator if method handle is absent 'creator' is called to make one (lazy init)
1412 * @return dynamic method handle associated with the key.
1413 */
1414 public MethodHandle getDynamicInvoker(final Object key, final Callable<MethodHandle> creator) {
1415 return getLazilyCreatedValue(key, creator, dynamicInvokers);
1416 }
1417
1418 /**
1419 * Hook to search missing variables in ScriptContext if available
1420 * @param self used to detect if scope call or not (this function is 'strict')
1421 * @param name name of the variable missing
1422 * @return value of the missing variable or undefined (or TypeError for scope search)
1423 */
1424 public static Object __noSuchProperty__(final Object self, final Object name) {
1425 final Global global = Global.instance();
1426 final ScriptContext sctxt = global.currentContext();
1427 final String nameStr = name.toString();
1428
1429 if (sctxt != null) {
1430 final int scope = sctxt.getAttributesScope(nameStr);
1431 if (scope != -1) {
1432 return ScriptObjectMirror.unwrap(sctxt.getAttribute(nameStr, scope), global);
1433 }
1434 }
1435
1436 switch (nameStr) {
1437 case "context":
1438 return sctxt;
1439 case "engine":
1440 return global.engine;
1441 default:
1442 break;
1443 }
1444
1445 if (self == UNDEFINED) {
1446 // scope access and so throw ReferenceError
1447 throw referenceError(global, "not.defined", nameStr);
1448 }
1449
1450 return UNDEFINED;
1451 }
1452
1453 /**
1454 * This is the eval used when 'indirect' eval call is made.
1455 *
1456 * var global = this;
1457 * global.eval("print('hello')");
1458 *
1459 * @param self eval scope
1460 * @param str eval string
1461 *
1462 * @return the result of eval
1463 */
1464 public static Object eval(final Object self, final Object str) {
1465 return directEval(self, str, Global.instanceFrom(self), UNDEFINED, false);
1466 }
1467
1468 /**
1469 * Direct eval
1470 *
1471 * @param self The scope of eval passed as 'self'
1472 * @param str Evaluated code
1473 * @param callThis "this" to be passed to the evaluated code
1474 * @param location location of the eval call
1475 * @param strict is eval called from a strict mode code?
1476 *
1477 * @return the return value of the eval
1478 *
1479 * This is directly invoked from generated when eval(code) is called in user code
1480 */
1481 public static Object directEval(final Object self, final Object str, final Object callThis, final Object location, final boolean strict) {
1482 if (!isString(str)) {
1483 return str;
1484 }
1485 final Global global = Global.instanceFrom(self);
1486 final ScriptObject scope = self instanceof ScriptObject && ((ScriptObject)self).isScope() ? (ScriptObject)self : global;
1487
1488 return global.getContext().eval(scope, str.toString(), callThis, location, strict, true);
1489 }
1490
1491 /**
1492 * Global print implementation - Nashorn extension
1493 *
1494 * @param self scope
1495 * @param objects arguments to print
1496 *
1497 * @return result of print (undefined)
1498 */
1499 public static Object print(final Object self, final Object... objects) {
1500 return Global.instanceFrom(self).printImpl(false, objects);
1501 }
1502
1503 /**
1504 * Global println implementation - Nashorn extension
1505 *
1506 * @param self scope
1507 * @param objects arguments to print
1508 *
1509 * @return result of println (undefined)
1510 */
1511 public static Object println(final Object self, final Object... objects) {
1512 return Global.instanceFrom(self).printImpl(true, objects);
1513 }
1514
1515 /**
1516 * Global load implementation - Nashorn extension.
1517 *
1518 * <p>
1519 * load builtin loads the given script. Script source can be a URL or a File
1520 * or a script object with name and script properties. Evaluated code gets
1521 * global object "this" and uses global object as scope for evaluation.
1522 * </p>
1523 * <p>
1524 * If self is undefined or null or global, then global object is used
1525 * as scope as well as "this" for the evaluated code. If self is any other
1526 * object, then it is indirect load call. With indirect load call, the
1527 * properties of scope are available to evaluated script as variables. Also,
1528 * global scope properties are accessible. Any var, function definition in
1529 * evaluated script goes into an object that is not accessible to user scripts.
1530 * </p>
1531 * Thus the indirect load call is equivalent to the following:
1532 * <pre>
1533 * <code>
1534 * (function (scope, source) {
1535 * with(scope) {
1536 * eval(<script_from_source>);
1537 * }
1538 * })(self, source);
1539 * </code>
1540 * </pre>
1541 *
1542 * @param self scope to use for the script evaluation
1543 * @param source script source
1544 *
1545 * @return result of load (may be undefined)
1546 *
1547 * @throws IOException if source could not be read
1548 */
1549 public static Object load(final Object self, final Object source) throws IOException {
1550 final Global global = Global.instanceFrom(self);
1551 return global.getContext().load(self, source);
1552 }
1553
1554 /**
1555 * Global loadWithNewGlobal implementation - Nashorn extension.
1556 *
1557 * loadWithNewGlobal builtin loads the given script from a URL or a File
1558 * or a script object with name and script properties. Evaluated code gets
1559 * new global object "this" and uses that new global object as scope for evaluation.
1560 *
1561 * @param self self This value is ignored by this function
1562 * @param args optional arguments to be passed to the loaded script
1563 *
1564 * @return result of load (may be undefined)
1565 *
1566 * @throws IOException if source could not be read
1567 */
1568 public static Object loadWithNewGlobal(final Object self, final Object...args) throws IOException {
1569 final Global global = Global.instanceFrom(self);
1570 final int length = args.length;
1571 final boolean hasArgs = 0 < length;
1572 final Object from = hasArgs ? args[0] : UNDEFINED;
1573 final Object[] arguments = hasArgs ? Arrays.copyOfRange(args, 1, length) : args;
1574
1575 return global.getContext().loadWithNewGlobal(from, arguments);
1576 }
1577
1578 /**
1579 * Global exit and quit implementation - Nashorn extension: perform a {@code System.exit} call from the script
1580 *
1581 * @param self self reference
1582 * @param code exit code
1583 *
1584 * @return undefined (will never be reached)
1585 */
1586 public static Object exit(final Object self, final Object code) {
1587 System.exit(JSType.toInt32(code));
1588 return UNDEFINED;
1589 }
1590
1591 // builtin prototype accessors
1592
1593 /**
1594 * Get the builtin Object prototype.
1595 * @return the Object prototype.
1596 */
1597 public ScriptObject getObjectPrototype() {
1598 return ScriptFunction.getPrototype(builtinObject);
1599 }
1600
1601 /**
1602 * Get the builtin Function prototype.
1603 * @return the Function prototype.
1604 */
1605 public ScriptObject getFunctionPrototype() {
1606 return ScriptFunction.getPrototype(builtinFunction);
1607 }
1608
1609 /**
1610 * Get the builtin Array prototype.
1611 * @return the Array prototype
1612 */
1613 public ScriptObject getArrayPrototype() {
1614 return ScriptFunction.getPrototype(builtinArray);
1615 }
1616
1617 ScriptObject getBooleanPrototype() {
1618 return ScriptFunction.getPrototype(builtinBoolean);
1619 }
1620
1621 ScriptObject getNumberPrototype() {
1622 return ScriptFunction.getPrototype(builtinNumber);
1623 }
1624
1625 ScriptObject getDatePrototype() {
1626 return ScriptFunction.getPrototype(getBuiltinDate());
1627 }
1628
1629 ScriptObject getRegExpPrototype() {
1630 return ScriptFunction.getPrototype(getBuiltinRegExp());
1631 }
1632
1633 ScriptObject getStringPrototype() {
1634 return ScriptFunction.getPrototype(builtinString);
1635 }
1636
1637 ScriptObject getErrorPrototype() {
1638 return ScriptFunction.getPrototype(builtinError);
1639 }
1640
1641 ScriptObject getEvalErrorPrototype() {
1642 return ScriptFunction.getPrototype(getBuiltinEvalError());
1643 }
1644
1645 ScriptObject getRangeErrorPrototype() {
1646 return ScriptFunction.getPrototype(getBuiltinRangeError());
1647 }
1648
1649 ScriptObject getReferenceErrorPrototype() {
1650 return ScriptFunction.getPrototype(builtinReferenceError);
1651 }
1652
1653 ScriptObject getSyntaxErrorPrototype() {
1654 return ScriptFunction.getPrototype(builtinSyntaxError);
1655 }
1656
1657 ScriptObject getTypeErrorPrototype() {
1658 return ScriptFunction.getPrototype(builtinTypeError);
1659 }
1660
1661 ScriptObject getURIErrorPrototype() {
1662 return ScriptFunction.getPrototype(getBuiltinURIError());
1663 }
1664
1665 ScriptObject getJavaImporterPrototype() {
1666 return ScriptFunction.getPrototype(getBuiltinJavaImporter());
1667 }
1668
1669 ScriptObject getJSAdapterPrototype() {
1670 return ScriptFunction.getPrototype(getBuiltinJSAdapter());
1671 }
1672
1673 ScriptObject getSymbolPrototype() {
1674 return ScriptFunction.getPrototype(builtinSymbol);
1675 }
1676
1677 private synchronized ScriptFunction getBuiltinArrayBuffer() {
1678 if (this.builtinArrayBuffer == null) {
1679 this.builtinArrayBuffer = initConstructorAndSwitchPoint("ArrayBuffer", ScriptFunction.class);
1680 }
1681 return this.builtinArrayBuffer;
1682 }
1683
1684 ScriptObject getArrayBufferPrototype() {
1685 return ScriptFunction.getPrototype(getBuiltinArrayBuffer());
1686 }
1687
1688 private synchronized ScriptFunction getBuiltinDataView() {
1689 if (this.builtinDataView == null) {
1690 this.builtinDataView = initConstructorAndSwitchPoint("DataView", ScriptFunction.class);
1691 }
1692 return this.builtinDataView;
1693 }
1694
1695 ScriptObject getDataViewPrototype() {
1696 return ScriptFunction.getPrototype(getBuiltinDataView());
1697 }
1698
1699 private synchronized ScriptFunction getBuiltinInt8Array() {
1700 if (this.builtinInt8Array == null) {
1701 this.builtinInt8Array = initConstructorAndSwitchPoint("Int8Array", ScriptFunction.class);
1702 }
1703 return this.builtinInt8Array;
1704 }
1705
1706 ScriptObject getInt8ArrayPrototype() {
1707 return ScriptFunction.getPrototype(getBuiltinInt8Array());
1708 }
1709
1710 private synchronized ScriptFunction getBuiltinUint8Array() {
1711 if (this.builtinUint8Array == null) {
1712 this.builtinUint8Array = initConstructorAndSwitchPoint("Uint8Array", ScriptFunction.class);
1713 }
1714 return this.builtinUint8Array;
1715 }
1716
1717 ScriptObject getUint8ArrayPrototype() {
1718 return ScriptFunction.getPrototype(getBuiltinUint8Array());
1719 }
1720
1721 private synchronized ScriptFunction getBuiltinUint8ClampedArray() {
1722 if (this.builtinUint8ClampedArray == null) {
1723 this.builtinUint8ClampedArray = initConstructorAndSwitchPoint("Uint8ClampedArray", ScriptFunction.class);
1724 }
1725 return this.builtinUint8ClampedArray;
1726 }
1727
1728 ScriptObject getUint8ClampedArrayPrototype() {
1729 return ScriptFunction.getPrototype(getBuiltinUint8ClampedArray());
1730 }
1731
1732 private synchronized ScriptFunction getBuiltinInt16Array() {
1733 if (this.builtinInt16Array == null) {
1734 this.builtinInt16Array = initConstructorAndSwitchPoint("Int16Array", ScriptFunction.class);
1735 }
1736 return this.builtinInt16Array;
1737 }
1738
1739 ScriptObject getInt16ArrayPrototype() {
1740 return ScriptFunction.getPrototype(getBuiltinInt16Array());
1741 }
1742
1743 private synchronized ScriptFunction getBuiltinUint16Array() {
1744 if (this.builtinUint16Array == null) {
1745 this.builtinUint16Array = initConstructorAndSwitchPoint("Uint16Array", ScriptFunction.class);
1746 }
1747 return this.builtinUint16Array;
1748 }
1749
1750 ScriptObject getUint16ArrayPrototype() {
1751 return ScriptFunction.getPrototype(getBuiltinUint16Array());
1752 }
1753
1754 private synchronized ScriptFunction getBuiltinInt32Array() {
1755 if (this.builtinInt32Array == null) {
1756 this.builtinInt32Array = initConstructorAndSwitchPoint("Int32Array", ScriptFunction.class);
1757 }
1758 return this.builtinInt32Array;
1759 }
1760
1761 ScriptObject getInt32ArrayPrototype() {
1762 return ScriptFunction.getPrototype(getBuiltinInt32Array());
1763 }
1764
1765 private synchronized ScriptFunction getBuiltinUint32Array() {
1766 if (this.builtinUint32Array == null) {
1767 this.builtinUint32Array = initConstructorAndSwitchPoint("Uint32Array", ScriptFunction.class);
1768 }
1769 return this.builtinUint32Array;
1770 }
1771
1772 ScriptObject getUint32ArrayPrototype() {
1773 return ScriptFunction.getPrototype(getBuiltinUint32Array());
1774 }
1775
1776 private synchronized ScriptFunction getBuiltinFloat32Array() {
1777 if (this.builtinFloat32Array == null) {
1778 this.builtinFloat32Array = initConstructorAndSwitchPoint("Float32Array", ScriptFunction.class);
1779 }
1780 return this.builtinFloat32Array;
1781 }
1782
1783 ScriptObject getFloat32ArrayPrototype() {
1784 return ScriptFunction.getPrototype(getBuiltinFloat32Array());
1785 }
1786
1787 private synchronized ScriptFunction getBuiltinFloat64Array() {
1788 if (this.builtinFloat64Array == null) {
1789 this.builtinFloat64Array = initConstructorAndSwitchPoint("Float64Array", ScriptFunction.class);
1790 }
1791 return this.builtinFloat64Array;
1792 }
1793
1794 ScriptObject getFloat64ArrayPrototype() {
1795 return ScriptFunction.getPrototype(getBuiltinFloat64Array());
1796 }
1797
1798 /**
1799 * Return the function that throws TypeError unconditionally. Used as "poison" methods for certain Function properties.
1800 *
1801 * @return the TypeError throwing function
1802 */
1803 public ScriptFunction getTypeErrorThrower() {
1804 return typeErrorThrower;
1805 }
1806
1807 private synchronized ScriptFunction getBuiltinDate() {
1808 if (this.builtinDate == null) {
1809 this.builtinDate = initConstructorAndSwitchPoint("Date", ScriptFunction.class);
1810 final ScriptObject dateProto = ScriptFunction.getPrototype(builtinDate);
1811 // initialize default date
1812 this.DEFAULT_DATE = new NativeDate(NaN, dateProto);
1813 }
1814 return this.builtinDate;
1815 }
1816
1817 private synchronized ScriptFunction getBuiltinEvalError() {
1818 if (this.builtinEvalError == null) {
1819 this.builtinEvalError = initErrorSubtype("EvalError", getErrorPrototype());
1820 }
1821 return this.builtinEvalError;
1822 }
1823
1824 private ScriptFunction getBuiltinFunction() {
1825 return builtinFunction;
1826 }
1827
1828 /**
1829 * Get the switchpoint used to check property changes for Function.prototype.apply
1830 * @return the switchpoint guarding apply (same as guarding call, and everything else in function)
1831 */
1832 public static SwitchPoint getBuiltinFunctionApplySwitchPoint() {
1833 return ScriptFunction.getPrototype(Global.instance().getBuiltinFunction()).getProperty("apply").getBuiltinSwitchPoint();
1834 }
1835
1836 private static boolean isBuiltinFunctionProperty(final String name) {
1837 final Global instance = Global.instance();
1838 final ScriptFunction builtinFunction = instance.getBuiltinFunction();
1839 if (builtinFunction == null) {
1840 return false; //conservative for compile-only mode
1841 }
1842 final boolean isBuiltinFunction = instance.function == builtinFunction;
1843 return isBuiltinFunction && ScriptFunction.getPrototype(builtinFunction).getProperty(name).isBuiltin();
1844 }
1845
1846 /**
1847 * Check if the Function.prototype.apply has not been replaced
1848 * @return true if Function.prototype.apply has been replaced
1849 */
1850 public static boolean isBuiltinFunctionPrototypeApply() {
1851 return isBuiltinFunctionProperty("apply");
1852 }
1853
1854 /**
1855 * Check if the Function.prototype.apply has not been replaced
1856 * @return true if Function.prototype.call has been replaced
1857 */
1858 public static boolean isBuiltinFunctionPrototypeCall() {
1859 return isBuiltinFunctionProperty("call");
1860 }
1861
1862 private synchronized ScriptFunction getBuiltinJSAdapter() {
1863 if (this.builtinJSAdapter == null) {
1864 this.builtinJSAdapter = initConstructorAndSwitchPoint("JSAdapter", ScriptFunction.class);
1865 }
1866 return builtinJSAdapter;
1867 }
1868
1869 private synchronized ScriptObject getBuiltinJSON() {
1870 if (this.builtinJSON == null) {
1871 this.builtinJSON = initConstructorAndSwitchPoint("JSON", ScriptObject.class);
1872 }
1873 return this.builtinJSON;
1874 }
1875
1876 private synchronized ScriptFunction getBuiltinJavaImporter() {
1877 if (this.builtinJavaImporter == null) {
1878 this.builtinJavaImporter = initConstructor("JavaImporter", ScriptFunction.class);
1879 }
1880 return this.builtinJavaImporter;
1881 }
1882
1883 private synchronized ScriptObject getBuiltinJavaApi() {
1884 if (this.builtinJavaApi == null) {
1885 this.builtinJavaApi = initConstructor("Java", ScriptObject.class);
1886 }
1887 return this.builtinJavaApi;
1888 }
1889
1890 private synchronized ScriptFunction getBuiltinRangeError() {
1891 if (this.builtinRangeError == null) {
1892 this.builtinRangeError = initErrorSubtype("RangeError", getErrorPrototype());
1893 }
1894 return builtinRangeError;
1895 }
1896
1897 private synchronized ScriptFunction getBuiltinRegExp() {
1898 if (this.builtinRegExp == null) {
1899 this.builtinRegExp = initConstructorAndSwitchPoint("RegExp", ScriptFunction.class);
1900 final ScriptObject regExpProto = ScriptFunction.getPrototype(builtinRegExp);
1901 // initialize default regexp object
1902 this.DEFAULT_REGEXP = new NativeRegExp("(?:)", "", this, regExpProto);
1903 // RegExp.prototype should behave like a RegExp object. So copy the
1904 // properties.
1905 regExpProto.addBoundProperties(DEFAULT_REGEXP);
1906 }
1907 return builtinRegExp;
1908 }
1909
1910 private synchronized ScriptFunction getBuiltinURIError() {
1911 if (this.builtinURIError == null) {
1912 this.builtinURIError = initErrorSubtype("URIError", getErrorPrototype());
1913 }
1914 return this.builtinURIError;
1915 }
1916
1917 @Override
1918 public String getClassName() {
1919 return "global";
1920 }
1921
1922 /**
1923 * Copy function used to clone NativeRegExp objects.
1924 *
1925 * @param regexp a NativeRegExp to clone
1926 *
1927 * @return copy of the given regexp object
1928 */
1929 public static Object regExpCopy(final Object regexp) {
1930 return new NativeRegExp((NativeRegExp)regexp);
1931 }
1932
1933 /**
1934 * Convert given object to NativeRegExp type.
1935 *
1936 * @param obj object to be converted
1937 * @return NativeRegExp instance
1938 */
1939 public static NativeRegExp toRegExp(final Object obj) {
1940 if (obj instanceof NativeRegExp) {
1941 return (NativeRegExp)obj;
1942 }
1943 return new NativeRegExp(JSType.toString(obj));
1944 }
1945
1946 /**
1947 * ECMA 9.9 ToObject implementation
1948 *
1949 * @param obj an item for which to run ToObject
1950 * @return ToObject version of given item
1951 */
1952 public static Object toObject(final Object obj) {
1953 if (obj == null || obj == UNDEFINED) {
1954 throw typeError("not.an.object", ScriptRuntime.safeToString(obj));
1955 }
1956
1957 if (obj instanceof ScriptObject) {
1958 return obj;
1959 }
1960
1961 return instance().wrapAsObject(obj);
1962 }
1963
1964 /**
1965 * Allocate a new object array.
1966 *
1967 * @param initial object values.
1968 * @return the new array
1969 */
1970 public static NativeArray allocate(final Object[] initial) {
1971 ArrayData arrayData = ArrayData.allocate(initial);
1972
1973 for (int index = 0; index < initial.length; index++) {
1974 final Object value = initial[index];
1975
1976 if (value == ScriptRuntime.EMPTY) {
1977 arrayData = arrayData.delete(index);
1978 }
1979 }
1980
1981 return new NativeArray(arrayData);
1982 }
1983
1984 /**
1985 * Allocate a new number array.
1986 *
1987 * @param initial number values.
1988 * @return the new array
1989 */
1990 public static NativeArray allocate(final double[] initial) {
1991 return new NativeArray(ArrayData.allocate(initial));
1992 }
1993
1994 /**
1995 * Allocate a new integer array.
1996 *
1997 * @param initial number values.
1998 * @return the new array
1999 */
2000 public static NativeArray allocate(final int[] initial) {
2001 return new NativeArray(ArrayData.allocate(initial));
2002 }
2003
2004 /**
2005 * Allocate a new object array for arguments.
2006 *
2007 * @param arguments initial arguments passed.
2008 * @param callee reference to the function that uses arguments object
2009 * @param numParams actual number of declared parameters
2010 *
2011 * @return the new array
2012 */
2013 public static ScriptObject allocateArguments(final Object[] arguments, final Object callee, final int numParams) {
2014 return NativeArguments.allocate(arguments, (ScriptFunction)callee, numParams);
2015 }
2016
2017 /**
2018 * Called from generated to check if given function is the builtin 'eval'. If
2019 * eval is used in a script, a lot of optimizations and assumptions cannot be done.
2020 *
2021 * @param fn function object that is checked
2022 * @return true if fn is the builtin eval
2023 */
2024 public static boolean isEval(final Object fn) {
2025 return fn == Global.instance().builtinEval;
2026 }
2027
2028 /**
2029 * Called from generated to replace a location property placeholder with the actual location property value.
2030 *
2031 * @param placeholder the value tested for being a placeholder for a location property
2032 * @param locationProperty the actual value for the location property
2033 * @return locationProperty if placeholder is indeed a placeholder for a location property, the placeholder otherwise
2034 */
2035 public static Object replaceLocationPropertyPlaceholder(final Object placeholder, final Object locationProperty) {
2036 return isLocationPropertyPlaceholder(placeholder) ? locationProperty : placeholder;
2037 }
2038
2039 /**
2040 * Called from runtime internals to check if the passed value is a location property placeholder.
2041 * @param placeholder the value tested for being a placeholder for a location property
2042 * @return true if the value is a placeholder, false otherwise.
2043 */
2044 public static boolean isLocationPropertyPlaceholder(final Object placeholder) {
2045 return placeholder == LAZY_SENTINEL;
2046 }
2047
2048 /**
2049 * Create a new RegExp object.
2050 *
2051 * @param expression Regular expression.
2052 * @param options Search options.
2053 *
2054 * @return New RegExp object.
2055 */
2056 public static Object newRegExp(final String expression, final String options) {
2057 if (options == null) {
2058 return new NativeRegExp(expression);
2059 }
2060 return new NativeRegExp(expression, options);
2061 }
2062
2063 /**
2064 * Get the object prototype
2065 *
2066 * @return the object prototype
2067 */
2068 public static ScriptObject objectPrototype() {
2069 return Global.instance().getObjectPrototype();
2070 }
2071
2072 /**
2073 * Create a new empty object instance.
2074 *
2075 * @return New empty object.
2076 */
2077 public static ScriptObject newEmptyInstance() {
2078 return Global.instance().newObject();
2079 }
2080
2081 /**
2082 * Check if a given object is a ScriptObject, raises an exception if this is
2083 * not the case
2084 *
2085 * @param obj and object to check
2086 * @return the script object
2087 */
2088 public static ScriptObject checkObject(final Object obj) {
2089 if (!(obj instanceof ScriptObject)) {
2090 throw typeError("not.an.object", ScriptRuntime.safeToString(obj));
2091 }
2092 return (ScriptObject)obj;
2093 }
2094
2095 /**
2096 * ECMA 9.10 - implementation of CheckObjectCoercible, i.e. raise an exception
2097 * if this object is null or undefined.
2098 *
2099 * @param obj an object to check
2100 */
2101 public static void checkObjectCoercible(final Object obj) {
2102 if (obj == null || obj == UNDEFINED) {
2103 throw typeError("not.an.object", ScriptRuntime.safeToString(obj));
2104 }
2105 }
2106
2107 /**
2108 * Return the ES6 global scope for lexically declared bindings.
2109 * @return the ES6 lexical global scope.
2110 */
2111 public final ScriptObject getLexicalScope() {
2112 assert context.getEnv()._es6;
2113 return lexicalScope;
2114 }
2115
2116 @Override
2117 public void addBoundProperties(final ScriptObject source, final jdk.nashorn.internal.runtime.Property[] properties) {
2118 PropertyMap ownMap = getMap();
2119 LexicalScope lexScope = null;
2120 PropertyMap lexicalMap = null;
2121 boolean hasLexicalDefinitions = false;
2122
2123 if (context.getEnv()._es6) {
2124 lexScope = (LexicalScope) getLexicalScope();
2125 lexicalMap = lexScope.getMap();
2126
2127 for (final jdk.nashorn.internal.runtime.Property property : properties) {
2128 if (property.isLexicalBinding()) {
2129 hasLexicalDefinitions = true;
2130 }
2131 // ES6 15.1.8 steps 6. and 7.
2132 final jdk.nashorn.internal.runtime.Property globalProperty = ownMap.findProperty(property.getKey());
2133 if (globalProperty != null && !globalProperty.isConfigurable() && property.isLexicalBinding()) {
2134 throw ECMAErrors.syntaxError("redeclare.variable", property.getKey().toString());
2135 }
2136 final jdk.nashorn.internal.runtime.Property lexicalProperty = lexicalMap.findProperty(property.getKey());
2137 if (lexicalProperty != null && !property.isConfigurable()) {
2138 throw ECMAErrors.syntaxError("redeclare.variable", property.getKey().toString());
2139 }
2140 }
2141 }
2142
2143 final boolean extensible = isExtensible();
2144 for (final jdk.nashorn.internal.runtime.Property property : properties) {
2145 if (property.isLexicalBinding()) {
2146 assert lexScope != null;
2147 lexicalMap = lexScope.addBoundProperty(lexicalMap, source, property, true);
2148
2149 if (ownMap.findProperty(property.getKey()) != null) {
2150 // If property exists in the global object invalidate any global constant call sites.
2151 invalidateGlobalConstant(property.getKey());
2152 }
2153 } else {
2154 ownMap = addBoundProperty(ownMap, source, property, extensible);
2155 }
2156 }
2157
2158 setMap(ownMap);
2159
2160 if (hasLexicalDefinitions) {
2161 assert lexScope != null;
2162 lexScope.setMap(lexicalMap);
2163 invalidateLexicalSwitchPoint();
2164 }
2165 }
2166
2167 @Override
2168 public GuardedInvocation findGetMethod(final CallSiteDescriptor desc, final LinkRequest request, final StandardOperation operation) {
2169 final String name = NashornCallSiteDescriptor.getOperand(desc);
2170 final boolean isScope = NashornCallSiteDescriptor.isScope(desc);
2171
2172 if (lexicalScope != null && isScope && !NashornCallSiteDescriptor.isApplyToCall(desc)) {
2173 if (lexicalScope.hasOwnProperty(name)) {
2174 return lexicalScope.findGetMethod(desc, request, operation);
2175 }
2176 }
2177
2178 final GuardedInvocation invocation = super.findGetMethod(desc, request, operation);
2179
2180 // We want to avoid adding our generic lexical scope switchpoint to global constant invocations,
2181 // because those are invalidated per-key in the addBoundProperties method above.
2182 // We therefore check if the invocation does already have a switchpoint and the property is non-inherited,
2183 // assuming this only applies to global constants. If other non-inherited properties will
2184 // start using switchpoints some time in the future we'll have to revisit this.
2185 if (isScope && context.getEnv()._es6 && (invocation.getSwitchPoints() == null || !hasOwnProperty(name))) {
2186 return invocation.addSwitchPoint(getLexicalScopeSwitchPoint());
2187 }
2188
2189 return invocation;
2190 }
2191
2192 @Override
2193 protected FindProperty findProperty(final Object key, final boolean deep, final ScriptObject start) {
2194 if (lexicalScope != null && start != this && start.isScope()) {
2195 final FindProperty find = lexicalScope.findProperty(key, false);
2196 if (find != null) {
2197 return find;
2198 }
2199 }
2200 return super.findProperty(key, deep, start);
2201 }
2202
2203 @Override
2204 public GuardedInvocation findSetMethod(final CallSiteDescriptor desc, final LinkRequest request) {
2205 final boolean isScope = NashornCallSiteDescriptor.isScope(desc);
2206
2207 if (lexicalScope != null && isScope) {
2208 final String name = NashornCallSiteDescriptor.getOperand(desc);
2209 if (lexicalScope.hasOwnProperty(name)) {
2210 return lexicalScope.findSetMethod(desc, request);
2211 }
2212 }
2213
2214 final GuardedInvocation invocation = super.findSetMethod(desc, request);
2215
2216 if (isScope && context.getEnv()._es6) {
2217 return invocation.addSwitchPoint(getLexicalScopeSwitchPoint());
2218 }
2219
2220 return invocation;
2221 }
2222
2223 /**
2224 * Adds jjs shell interactive mode builtin functions to global scope.
2225 */
2226 public void addShellBuiltins() {
2227 Object value = ScriptFunction.createBuiltin("input", ShellFunctions.INPUT);
2228 addOwnProperty("input", Attribute.NOT_ENUMERABLE, value);
2229
2230 value = ScriptFunction.createBuiltin("evalinput", ShellFunctions.EVALINPUT);
2231 addOwnProperty("evalinput", Attribute.NOT_ENUMERABLE, value);
2232 }
2233
2234 private synchronized SwitchPoint getLexicalScopeSwitchPoint() {
2235 SwitchPoint switchPoint = lexicalScopeSwitchPoint;
2236 if (switchPoint == null || switchPoint.hasBeenInvalidated()) {
2237 switchPoint = lexicalScopeSwitchPoint = new SwitchPoint();
2238 }
2239 return switchPoint;
2240 }
2241
2242 private synchronized void invalidateLexicalSwitchPoint() {
2243 if (lexicalScopeSwitchPoint != null) {
2244 context.getLogger(GlobalConstants.class).info("Invalidating non-constant globals on lexical scope update");
2245 SwitchPoint.invalidateAll(new SwitchPoint[]{ lexicalScopeSwitchPoint });
2246 }
2247 }
2248
2249
2250 @SuppressWarnings("unused")
2251 private static Object lexicalScopeFilter(final Object self) {
2252 if (self instanceof Global) {
2253 return ((Global) self).getLexicalScope();
2254 }
2255 return self;
2256 }
2257
2258 private <T extends ScriptObject> T initConstructorAndSwitchPoint(final String name, final Class<T> clazz) {
2259 final T func = initConstructor(name, clazz);
2260 tagBuiltinProperties(name, func);
2261 return func;
2262 }
2263
2264 private void init(final ScriptEngine eng) {
2265 assert Context.getGlobal() == this : "this global is not set as current";
2266
2267 final ScriptEnvironment env = getContext().getEnv();
2268
2269 // initialize Function and Object constructor
2270 initFunctionAndObject();
2271
2272 // Now fix Global's own proto.
2273 this.setInitialProto(getObjectPrototype());
2274
2275 // initialize global function properties
2276 this.eval = this.builtinEval = ScriptFunction.createBuiltin("eval", EVAL);
2277
2278 this.parseInt = ScriptFunction.createBuiltin("parseInt", GlobalFunctions.PARSEINT,
2279 new Specialization[] {
2280 new Specialization(GlobalFunctions.PARSEINT_Z),
2281 new Specialization(GlobalFunctions.PARSEINT_I),
2282 new Specialization(GlobalFunctions.PARSEINT_OI),
2283 new Specialization(GlobalFunctions.PARSEINT_O) });
2284 this.parseFloat = ScriptFunction.createBuiltin("parseFloat", GlobalFunctions.PARSEFLOAT);
2285 this.isNaN = ScriptFunction.createBuiltin("isNaN", GlobalFunctions.IS_NAN,
2286 new Specialization[] {
2287 new Specialization(GlobalFunctions.IS_NAN_I),
2288 new Specialization(GlobalFunctions.IS_NAN_J),
2289 new Specialization(GlobalFunctions.IS_NAN_D) });
2290 this.parseFloat = ScriptFunction.createBuiltin("parseFloat", GlobalFunctions.PARSEFLOAT);
2291 this.isNaN = ScriptFunction.createBuiltin("isNaN", GlobalFunctions.IS_NAN);
2292 this.isFinite = ScriptFunction.createBuiltin("isFinite", GlobalFunctions.IS_FINITE);
2293 this.encodeURI = ScriptFunction.createBuiltin("encodeURI", GlobalFunctions.ENCODE_URI);
2294 this.encodeURIComponent = ScriptFunction.createBuiltin("encodeURIComponent", GlobalFunctions.ENCODE_URICOMPONENT);
2295 this.decodeURI = ScriptFunction.createBuiltin("decodeURI", GlobalFunctions.DECODE_URI);
2296 this.decodeURIComponent = ScriptFunction.createBuiltin("decodeURIComponent", GlobalFunctions.DECODE_URICOMPONENT);
2297 this.escape = ScriptFunction.createBuiltin("escape", GlobalFunctions.ESCAPE);
2298 this.unescape = ScriptFunction.createBuiltin("unescape", GlobalFunctions.UNESCAPE);
2299 this.print = ScriptFunction.createBuiltin("print", env._print_no_newline ? PRINT : PRINTLN);
2300 this.load = ScriptFunction.createBuiltin("load", LOAD);
2301 this.loadWithNewGlobal = ScriptFunction.createBuiltin("loadWithNewGlobal", LOAD_WITH_NEW_GLOBAL);
2302 this.exit = ScriptFunction.createBuiltin("exit", EXIT);
2303 this.quit = ScriptFunction.createBuiltin("quit", EXIT);
2304
2305 // built-in constructors
2306 this.builtinArray = initConstructorAndSwitchPoint("Array", ScriptFunction.class);
2307 this.builtinBoolean = initConstructorAndSwitchPoint("Boolean", ScriptFunction.class);
2308 this.builtinNumber = initConstructorAndSwitchPoint("Number", ScriptFunction.class);
2309 this.builtinString = initConstructorAndSwitchPoint("String", ScriptFunction.class);
2310 this.builtinMath = initConstructorAndSwitchPoint("Math", ScriptObject.class);
2311
2312 if (env._es6) {
2313 this.builtinSymbol = initConstructorAndSwitchPoint("Symbol", ScriptFunction.class);
2314 } else {
2315 // We need to manually delete nasgen-generated properties we don't want
2316 this.delete("Symbol", false);
2317 this.builtinObject.delete("getOwnPropertySymbols", false);
2318 }
2319
2320 // initialize String.prototype.length to 0
2321 // add String.prototype.length
2322 final ScriptObject stringPrototype = getStringPrototype();
2323 stringPrototype.addOwnProperty("length", Attribute.NON_ENUMERABLE_CONSTANT, 0.0);
2324
2325 // set isArray flag on Array.prototype
2326 final ScriptObject arrayPrototype = getArrayPrototype();
2327 arrayPrototype.setIsArray();
2328
2329 // Error stuff
2330 initErrorObjects();
2331
2332 // java access
2333 if (! env._no_java) {
2334 this.javaApi = LAZY_SENTINEL;
2335 this.javaImporter = LAZY_SENTINEL;
2336 initJavaAccess();
2337 }
2338
2339 if (! env._no_typed_arrays) {
2340 this.arrayBuffer = LAZY_SENTINEL;
2341 this.dataView = LAZY_SENTINEL;
2342 this.int8Array = LAZY_SENTINEL;
2343 this.uint8Array = LAZY_SENTINEL;
2344 this.uint8ClampedArray = LAZY_SENTINEL;
2345 this.int16Array = LAZY_SENTINEL;
2346 this.uint16Array = LAZY_SENTINEL;
2347 this.int32Array = LAZY_SENTINEL;
2348 this.uint32Array = LAZY_SENTINEL;
2349 this.float32Array = LAZY_SENTINEL;
2350 this.float64Array = LAZY_SENTINEL;
2351 }
2352
2353 if (env._scripting) {
2354 initScripting(env);
2355 }
2356
2357 if (Context.DEBUG) {
2358 boolean debugOkay;
2359 final SecurityManager sm = System.getSecurityManager();
2360 if (sm != null) {
2361 try {
2362 sm.checkPermission(new RuntimePermission(Context.NASHORN_DEBUG_MODE));
2363 debugOkay = true;
2364 } catch (final SecurityException ignored) {
2365 // if no permission, don't initialize Debug object
2366 debugOkay = false;
2367 }
2368
2369 } else {
2370 debugOkay = true;
2371 }
2372
2373 if (debugOkay) {
2374 initDebug();
2375 }
2376 }
2377
2378 copyBuiltins();
2379
2380 // expose script (command line) arguments as "arguments" property of global
2381 arguments = wrapAsObject(env.getArguments().toArray());
2382 if (env._scripting) {
2383 // synonym for "arguments" in scripting mode
2384 addOwnProperty("$ARG", Attribute.NOT_ENUMERABLE, arguments);
2385 }
2386
2387 if (eng != null) {
2388 // default file name
2389 addOwnProperty(ScriptEngine.FILENAME, Attribute.NOT_ENUMERABLE, null);
2390 // __noSuchProperty__ hook for ScriptContext search of missing variables
2391 final ScriptFunction noSuchProp = ScriptFunction.createStrictBuiltin(NO_SUCH_PROPERTY_NAME, NO_SUCH_PROPERTY);
2392 addOwnProperty(NO_SUCH_PROPERTY_NAME, Attribute.NOT_ENUMERABLE, noSuchProp);
2393 }
2394 }
2395
2396 private void initErrorObjects() {
2397 // Error objects
2398 this.builtinError = initConstructor("Error", ScriptFunction.class);
2399 final ScriptObject errorProto = getErrorPrototype();
2400
2401 // Nashorn specific accessors on Error.prototype - stack, lineNumber, columnNumber and fileName
2402 final ScriptFunction getStack = ScriptFunction.createBuiltin("getStack", NativeError.GET_STACK);
2403 final ScriptFunction setStack = ScriptFunction.createBuiltin("setStack", NativeError.SET_STACK);
2404 errorProto.addOwnProperty("stack", Attribute.NOT_ENUMERABLE, getStack, setStack);
2405 final ScriptFunction getLineNumber = ScriptFunction.createBuiltin("getLineNumber", NativeError.GET_LINENUMBER);
2406 final ScriptFunction setLineNumber = ScriptFunction.createBuiltin("setLineNumber", NativeError.SET_LINENUMBER);
2407 errorProto.addOwnProperty("lineNumber", Attribute.NOT_ENUMERABLE, getLineNumber, setLineNumber);
2408 final ScriptFunction getColumnNumber = ScriptFunction.createBuiltin("getColumnNumber", NativeError.GET_COLUMNNUMBER);
2409 final ScriptFunction setColumnNumber = ScriptFunction.createBuiltin("setColumnNumber", NativeError.SET_COLUMNNUMBER);
2410 errorProto.addOwnProperty("columnNumber", Attribute.NOT_ENUMERABLE, getColumnNumber, setColumnNumber);
2411 final ScriptFunction getFileName = ScriptFunction.createBuiltin("getFileName", NativeError.GET_FILENAME);
2412 final ScriptFunction setFileName = ScriptFunction.createBuiltin("setFileName", NativeError.SET_FILENAME);
2413 errorProto.addOwnProperty("fileName", Attribute.NOT_ENUMERABLE, getFileName, setFileName);
2414
2415 // ECMA 15.11.4.2 Error.prototype.name
2416 // Error.prototype.name = "Error";
2417 errorProto.set(NativeError.NAME, "Error", 0);
2418 // ECMA 15.11.4.3 Error.prototype.message
2419 // Error.prototype.message = "";
2420 errorProto.set(NativeError.MESSAGE, "", 0);
2421
2422 tagBuiltinProperties("Error", builtinError);
2423
2424 this.builtinReferenceError = initErrorSubtype("ReferenceError", errorProto);
2425 this.builtinSyntaxError = initErrorSubtype("SyntaxError", errorProto);
2426 this.builtinTypeError = initErrorSubtype("TypeError", errorProto);
2427 }
2428
2429 private ScriptFunction initErrorSubtype(final String name, final ScriptObject errorProto) {
2430 final ScriptFunction cons = initConstructor(name, ScriptFunction.class);
2431 final ScriptObject prototype = ScriptFunction.getPrototype(cons);
2432 prototype.set(NativeError.NAME, name, 0);
2433 prototype.set(NativeError.MESSAGE, "", 0);
2434 prototype.setInitialProto(errorProto);
2435 tagBuiltinProperties(name, cons);
2436 return cons;
2437 }
2438
2439 private void initJavaAccess() {
2440 final ScriptObject objectProto = getObjectPrototype();
2441 this.builtinPackages = new NativeJavaPackage("", objectProto);
2442 this.builtinCom = new NativeJavaPackage("com", objectProto);
2443 this.builtinEdu = new NativeJavaPackage("edu", objectProto);
2444 this.builtinJava = new NativeJavaPackage("java", objectProto);
2445 this.builtinJavafx = new NativeJavaPackage("javafx", objectProto);
2446 this.builtinJavax = new NativeJavaPackage("javax", objectProto);
2447 this.builtinOrg = new NativeJavaPackage("org", objectProto);
2448 }
2449
2450 private void initScripting(final ScriptEnvironment scriptEnv) {
2451 ScriptObject value;
2452 value = ScriptFunction.createBuiltin("readLine", ScriptingFunctions.READLINE);
2453 addOwnProperty("readLine", Attribute.NOT_ENUMERABLE, value);
2454
2455 value = ScriptFunction.createBuiltin("readFully", ScriptingFunctions.READFULLY);
2456 addOwnProperty("readFully", Attribute.NOT_ENUMERABLE, value);
2457
2458 final String execName = ScriptingFunctions.EXEC_NAME;
2459 value = ScriptFunction.createBuiltin(execName, ScriptingFunctions.EXEC);
2460 value.addOwnProperty(ScriptingFunctions.THROW_ON_ERROR_NAME, Attribute.NOT_ENUMERABLE, false);
2461
2462 addOwnProperty(execName, Attribute.NOT_ENUMERABLE, value);
2463
2464 // Nashorn extension: global.echo (scripting-mode-only)
2465 // alias for "print"
2466 value = (ScriptObject)get("print");
2467 addOwnProperty("echo", Attribute.NOT_ENUMERABLE, value);
2468
2469 // Nashorn extension: global.$OPTIONS (scripting-mode-only)
2470 final ScriptObject options = newObject();
2471 copyOptions(options, scriptEnv);
2472 addOwnProperty("$OPTIONS", Attribute.NOT_ENUMERABLE, options);
2473
2474 // Nashorn extension: global.$ENV (scripting-mode-only)
2475 if (System.getSecurityManager() == null) {
2476 // do not fill $ENV if we have a security manager around
2477 // Retrieve current state of ENV variables.
2478 final ScriptObject env = newObject();
2479 env.putAll(System.getenv(), scriptEnv._strict);
2480
2481 // Some platforms, e.g., Windows, do not define the PWD environment
2482 // variable, so that the $ENV.PWD property needs to be explicitly
2483 // set.
2484 if (!env.containsKey(ScriptingFunctions.PWD_NAME)) {
2485 env.put(ScriptingFunctions.PWD_NAME, System.getProperty("user.dir"), scriptEnv._strict);
2486 }
2487
2488 addOwnProperty(ScriptingFunctions.ENV_NAME, Attribute.NOT_ENUMERABLE, env);
2489 } else {
2490 addOwnProperty(ScriptingFunctions.ENV_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2491 }
2492
2493 // add other special properties for exec support
2494 addOwnProperty(ScriptingFunctions.OUT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2495 addOwnProperty(ScriptingFunctions.ERR_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2496 addOwnProperty(ScriptingFunctions.EXIT_NAME, Attribute.NOT_ENUMERABLE, UNDEFINED);
2497 }
2498
2499 private static void copyOptions(final ScriptObject options, final ScriptEnvironment scriptEnv) {
2500 for (final Field f : scriptEnv.getClass().getFields()) {
2501 try {
2502 options.set(f.getName(), f.get(scriptEnv), 0);
2503 } catch (final IllegalArgumentException | IllegalAccessException exp) {
2504 throw new RuntimeException(exp);
2505 }
2506 }
2507 }
2508
2509 private void copyBuiltins() {
2510 this.array = this.builtinArray;
2511 this._boolean = this.builtinBoolean;
2512 this.error = this.builtinError;
2513 this.function = this.builtinFunction;
2514 this.com = this.builtinCom;
2515 this.edu = this.builtinEdu;
2516 this.java = this.builtinJava;
2517 this.javafx = this.builtinJavafx;
2518 this.javax = this.builtinJavax;
2519 this.org = this.builtinOrg;
2520 this.math = this.builtinMath;
2521 this.number = this.builtinNumber;
2522 this.object = this.builtinObject;
2523 this.packages = this.builtinPackages;
2524 this.referenceError = this.builtinReferenceError;
2525 this.string = this.builtinString;
2526 this.syntaxError = this.builtinSyntaxError;
2527 this.typeError = this.builtinTypeError;
2528 this.symbol = this.builtinSymbol;
2529 }
2530
2531 private void initDebug() {
2532 this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug", ScriptObject.class));
2533 }
2534
2535 private Object printImpl(final boolean newLine, final Object... objects) {
2536 final ScriptContext sc = currentContext();
2537 @SuppressWarnings("resource")
2538 final PrintWriter out = sc != null? new PrintWriter(sc.getWriter()) : getContext().getEnv().getOut();
2539 final StringBuilder sb = new StringBuilder();
2540
2541 for (final Object obj : objects) {
2542 if (sb.length() != 0) {
2543 sb.append(' ');
2544 }
2545
2546 sb.append(JSType.toString(obj));
2547 }
2548
2549 // Print all at once to ensure thread friendly result.
2550 if (newLine) {
2551 out.println(sb.toString());
2552 } else {
2553 out.print(sb.toString());
2554 }
2555
2556 out.flush();
2557
2558 return UNDEFINED;
2559 }
2560
2561 private <T extends ScriptObject> T initConstructor(final String name, final Class<T> clazz) {
2562 try {
2563 // Assuming class name pattern for built-in JS constructors.
2564 final StringBuilder sb = new StringBuilder("jdk.nashorn.internal.objects.");
2565
2566 sb.append("Native");
2567 sb.append(name);
2568 sb.append("$Constructor");
2569
2570 final Class<?> funcClass = Class.forName(sb.toString());
2571 final T res = clazz.cast(funcClass.newInstance());
2572
2573 if (res instanceof ScriptFunction) {
2574 // All global constructor prototypes are not-writable,
2575 // not-enumerable and not-configurable.
2576 final ScriptFunction func = (ScriptFunction)res;
2577 func.modifyOwnProperty(func.getProperty("prototype"), Attribute.NON_ENUMERABLE_CONSTANT);
2578 }
2579
2580 if (res.getProto() == null) {
2581 res.setInitialProto(getObjectPrototype());
2582 }
2583
2584 res.setIsBuiltin();
2585
2586 return res;
2587 } catch (final ClassNotFoundException | InstantiationException | IllegalAccessException e) {
2588 throw new RuntimeException(e);
2589 }
2590 }
2591
2592 private List<jdk.nashorn.internal.runtime.Property> extractBuiltinProperties(final String name, final ScriptObject func) {
2593 final List<jdk.nashorn.internal.runtime.Property> list = new ArrayList<>();
2594
2595 list.addAll(Arrays.asList(func.getMap().getProperties()));
2596
2597 if (func instanceof ScriptFunction) {
2598 final ScriptObject proto = ScriptFunction.getPrototype((ScriptFunction)func);
2599 if (proto != null) {
2600 list.addAll(Arrays.asList(proto.getMap().getProperties()));
2601 }
2602 }
2603
2604 final jdk.nashorn.internal.runtime.Property prop = getProperty(name);
2605 if (prop != null) {
2606 list.add(prop);
2607 }
2608
2609 return list;
2610 }
2611
2612 /**
2613 * Given a builtin object, traverse its properties recursively and associate them with a name that
2614 * will be a key to their invalidation switchpoint.
2615 * @param name name for key
2616 * @param func builtin script object
2617 */
2618 private void tagBuiltinProperties(final String name, final ScriptObject func) {
2619 SwitchPoint sp = context.getBuiltinSwitchPoint(name);
2620 if (sp == null) {
2621 sp = context.newBuiltinSwitchPoint(name);
2622 }
2623
2624 //get all builtin properties in this builtin object and register switchpoints keyed on the propery name,
2625 //one overwrite destroys all for now, e.g. Function.prototype.apply = 17; also destroys Function.prototype.call etc
2626 for (final jdk.nashorn.internal.runtime.Property prop : extractBuiltinProperties(name, func)) {
2627 prop.setBuiltinSwitchPoint(sp);
2628 }
2629 }
2630
2631 // Function and Object constructors are inter-dependent. Also,
2632 // Function.prototype
2633 // functions are not properly initialized. We fix the references here.
2634 // NOTE: be careful if you want to re-order the operations here. You may
2635 // have
2636 // to play with object references carefully!!
2637 private void initFunctionAndObject() {
2638 // First-n-foremost is Function
2639
2640 this.builtinFunction = initConstructor("Function", ScriptFunction.class);
2641
2642 // create global anonymous function
2643 final ScriptFunction anon = ScriptFunction.createAnonymous();
2644 // need to copy over members of Function.prototype to anon function
2645 anon.addBoundProperties(getFunctionPrototype());
2646
2647 // Function.prototype === Object.getPrototypeOf(Function) ===
2648 // <anon-function>
2649 builtinFunction.setInitialProto(anon);
2650 builtinFunction.setPrototype(anon);
2651 anon.set("constructor", builtinFunction, 0);
2652 anon.deleteOwnProperty(anon.getMap().findProperty("prototype"));
2653
2654 // use "getter" so that [[ThrowTypeError]] function's arity is 0 - as specified in step 10 of section 13.2.3
2655 this.typeErrorThrower = ScriptFunction.createBuiltin("TypeErrorThrower", Lookup.TYPE_ERROR_THROWER_GETTER);
2656 typeErrorThrower.preventExtensions();
2657
2658 // now initialize Object
2659 this.builtinObject = initConstructor("Object", ScriptFunction.class);
2660 final ScriptObject ObjectPrototype = getObjectPrototype();
2661 // Object.getPrototypeOf(Function.prototype) === Object.prototype
2662 anon.setInitialProto(ObjectPrototype);
2663
2664 // ES6 draft compliant __proto__ property of Object.prototype
2665 // accessors on Object.prototype for "__proto__"
2666 final ScriptFunction getProto = ScriptFunction.createBuiltin("getProto", NativeObject.GET__PROTO__);
2667 final ScriptFunction setProto = ScriptFunction.createBuiltin("setProto", NativeObject.SET__PROTO__);
2668 ObjectPrototype.addOwnProperty("__proto__", Attribute.NOT_ENUMERABLE, getProto, setProto);
2669
2670 // Function valued properties of Function.prototype were not properly
2671 // initialized. Because, these were created before global.function and
2672 // global.object were not initialized.
2673 jdk.nashorn.internal.runtime.Property[] properties = getFunctionPrototype().getMap().getProperties();
2674 for (final jdk.nashorn.internal.runtime.Property property : properties) {
2675 final Object key = property.getKey();
2676 final Object value = builtinFunction.get(key);
2677
2678 if (value instanceof ScriptFunction && value != anon) {
2679 final ScriptFunction func = (ScriptFunction)value;
2680 func.setInitialProto(getFunctionPrototype());
2681 final ScriptObject prototype = ScriptFunction.getPrototype(func);
2682 if (prototype != null) {
2683 prototype.setInitialProto(ObjectPrototype);
2684 }
2685 }
2686 }
2687
2688 // For function valued properties of Object and Object.prototype, make
2689 // sure prototype's proto chain ends with Object.prototype
2690 for (final jdk.nashorn.internal.runtime.Property property : builtinObject.getMap().getProperties()) {
2691 final Object key = property.getKey();
2692 final Object value = builtinObject.get(key);
2693
2694 if (value instanceof ScriptFunction) {
2695 final ScriptFunction func = (ScriptFunction)value;
2696 final ScriptObject prototype = ScriptFunction.getPrototype(func);
2697 if (prototype != null) {
2698 prototype.setInitialProto(ObjectPrototype);
2699 }
2700 }
2701 }
2702
2703 properties = getObjectPrototype().getMap().getProperties();
2704
2705 for (final jdk.nashorn.internal.runtime.Property property : properties) {
2706 final Object key = property.getKey();
2707 if (key.equals("constructor")) {
2708 continue;
2709 }
2710
2711 final Object value = ObjectPrototype.get(key);
2712 if (value instanceof ScriptFunction) {
2713 final ScriptFunction func = (ScriptFunction)value;
2714 final ScriptObject prototype = ScriptFunction.getPrototype(func);
2715 if (prototype != null) {
2716 prototype.setInitialProto(ObjectPrototype);
2717 }
2718 }
2719 }
2720
2721 tagBuiltinProperties("Object", builtinObject);
2722 tagBuiltinProperties("Function", builtinFunction);
2723 tagBuiltinProperties("Function", anon);
2724 }
2725
2726 private static MethodHandle findOwnMH_S(final String name, final Class<?> rtype, final Class<?>... types) {
2727 return MH.findStatic(MethodHandles.lookup(), Global.class, name, MH.type(rtype, types));
2728 }
2729
2730 RegExpResult getLastRegExpResult() {
2731 return lastRegExpResult;
2732 }
2733
2734 void setLastRegExpResult(final RegExpResult regExpResult) {
2735 this.lastRegExpResult = regExpResult;
2736 }
2737
2738 @Override
2739 protected boolean isGlobal() {
2740 return true;
2741 }
2742
2743 /**
2744 * A class representing the ES6 global lexical scope.
2745 */
2746 private static class LexicalScope extends ScriptObject {
2747
2748 LexicalScope(final Global global) {
2749 super(global, PropertyMap.newMap());
2750 }
2751
2752 @Override
2753 protected GuardedInvocation findGetMethod(final CallSiteDescriptor desc, final LinkRequest request, final StandardOperation operation) {
2754 return filterInvocation(super.findGetMethod(desc, request, operation));
2755 }
2756
2757 @Override
2758 protected GuardedInvocation findSetMethod(final CallSiteDescriptor desc, final LinkRequest request) {
2759 return filterInvocation(super.findSetMethod(desc, request));
2760 }
2761
2762 @Override
2763 protected PropertyMap addBoundProperty(final PropertyMap propMap, final ScriptObject source, final jdk.nashorn.internal.runtime.Property property, final boolean extensible) {
2764 // We override this method just to make it callable by Global
2765 return super.addBoundProperty(propMap, source, property, extensible);
2766 }
2767
2768 private static GuardedInvocation filterInvocation(final GuardedInvocation invocation) {
2769 final MethodType type = invocation.getInvocation().type();
2770 return invocation.asType(type.changeParameterType(0, Object.class)).filterArguments(0, LEXICAL_SCOPE_FILTER);
2771 }
2772 }
2773
2774 }