-
Notifications
You must be signed in to change notification settings - Fork 2
/
Copy pathpseudocode.grammar
1598 lines (1473 loc) · 75.1 KB
/
pseudocode.grammar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# ecmaspeak-py/pseudocode.grammar:
# A grammar for the various kinds of pseudocode.
#
# Copyright (C) 2018-22 J. Michael Dyck <[email protected]>
{START} :
{ENTRY_POINT}{_eos_}
{ENTRY_POINT} :
{_early_error_rule_}{EARLY_ERROR_RULE}
{_emu_alg_body_}{EMU_ALG_BODY}
{_emu_eqn_def_}{EMU_EQN_DEF}
{_field_value_type_}{FIELD_VALUE_TYPE}
{_for_phrase_}{FOR_PHRASE}
{_h1_body_}{H1_BODY}
{_inline_sdo_rule_}{INLINE_SDO_RULE}
{_one_line_alg_}{ONE_LINE_ALG}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{EARLY_ERROR_RULE} :
{EE_RULE}
{_indent_}{nlai}{EE_RULE}{_outdent_}{nlai}
{EE_RULE} :
<p>It is a Syntax Error if {CONDITION_1} and the following algorithm returns {BOOL_LITERAL}:</p>{nlai}{h_emu_alg}
<p>{_indent_}{nlai}It is a Syntax Error if {LOCAL_REF} is<br>{nlai}{h_emu_grammar}<br>{nlai}and {LOCAL_REF} ultimately derives a phrase that, if used in place of {LOCAL_REF}, would produce a Syntax Error according to these rules. This rule is recursively applied.{_outdent_}{nlai}</p>
For each {nonterminal} {DEFVAR} in {NAMED_OPERATION_INVOCATION}: It is a Syntax Error if {CONDITION}.
If {CONDITION}, it is a Syntax Error if {CONDITION}.
If {CONDITION}, the Early Error rules for {h_emu_grammar} are applied.
If {CONDITION}, {LOCAL_REF} must cover an? {nonterminal}.
It is a Syntax Error if {CONDITION_1}<ins>, unless {CONDITION_1} and {CONDITION_1}</ins>.
It is a Syntax Error if {CONDITION}.
It is a Syntax Error if {CONDITION}. Additional early error rules for {G_SYM} in direct eval are defined in {h_emu_xref}.
It is a Syntax Error if {CONDITION}. Additional early error rules for {G_SYM} within direct eval are defined in {h_emu_xref}.
It is a Syntax Error if {CONDITION}. This rule is not applied if {CONDITION}.
It is an early Syntax Error if {CONDITION}.
{LOCAL_REF} must cover an? {nonterminal}.
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{EMU_ALG_BODY} :
{IND_COMMANDS}{nlai}
{IND_COMMANDS} :
{_indent_}{COMMANDS}{_outdent_}
{COMMANDS} :
{COMMANDS}{_NL_N} {COMMAND}
{_NL_N} {COMMAND}
{_NL_N} :
{nlai}{dec_int_lit}.
{nlai}{dec_int_lit}. {step_attribute}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{EMU_EQN_DEF} :
{CONSTANT_DEF}
# --------------------------
{CONSTANT_DEF} :
{CONSTANT_NAME} = {dec_int_lit}
{CONSTANT_NAME} = {starred_int_lit}{h_sub_fancy_f}
{CONSTANT_NAME} = {starred_int_lit}{h_sub_fancy_f} = {EXPR}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{FIELD_VALUE_TYPE} :
{VALUE_DESCRIPTION}
{_indent_}{nlai}{VALUE_DESCRIPTION}{_outdent_}{nlai}
{_indent_}{nlai}{VALUE_DESCRIPTION} (default value is {LITERAL}){_outdent_}{nlai}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{FOR_PHRASE} :
{VAL_DESC}
{VAL_DESC} {var}
{VAL_DESC} {var} (when the method is present)
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{H1_BODY} :
{WHICH_SEMANTICS}{OP_NAME} ( ): {VALUE_DESCRIPTION}
{_indent_}{nlai}{WHICH_SEMANTICS}{OP_NAME} ({_indent_}{PARAMETER_DECLS}{_outdent_}{nlai}): {VALUE_DESCRIPTION}{_outdent_}{nlai}
{WHICH_SEMANTICS} :
Runtime Semantics:
Static Semantics:
{EPSILON}
{OP_NAME} :
ForIn/OfBodyEvaluation
ForIn/OfHeadEvaluation
msFromTime
{cap_word}
{cap_word}::{low_word}
{dsb_word}
{PARAMETER_DECLS} :
{PARAMETER_DECL}
{PARAMETER_DECLS}{PARAMETER_DECL}
{PARAMETER_DECL} :
{nlai}{OPTIONALITY}{var}: {VALUE_DESCRIPTION},
{OPTIONALITY} :
{EPSILON}
optional
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{INLINE_SDO_RULE} :
{_indent_}{nlai}{ISDO_RULE}{_outdent_}{nlai}
{ISDO_RULE} :
The {cap_word} {OF_PRODUCTIONS} is {EXPR}.
{OF_PRODUCTIONS} :
of {h_emu_grammar}
of {h_emu_grammar} or of {h_emu_grammar}
of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar}
of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar}
of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar} or of {h_emu_grammar}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{ONE_LINE_ALG} :
{_indent_}{nlai}{COMMAND}{_outdent_}{nlai}
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{COMMAND} :
? OperationName().
? {var}.OperationName().
Add {var} to {var}.
Append to {var} the elements of {var}.
Append {EX} and {EX} to {EX}.
Append {EX} to the end of {EX}.
Append {EX} to {EX}.
Assert: If {CONDITION}, then {CONDITION}.
Assert: If {CONDITION}, {CONDITION}.
Assert: {CONDITION_1} if and only if {CONDITION_1}.
Assert: {CONDITION_1} if {CONDITION_1}; otherwise, {CONDITION_1}.
Assert: {CONDITION_1}, since {CONDITION_1}.
Assert: {CONDITION}.
Attempt to parse {var} using {var} as the goal symbol, and analyse the parse result for any early error conditions. Parsing and early error detection may be interleaved in an implementation-defined manner.
Change its bound value to {var}.
Choose any such {var}.
Create a mutable binding in {var} for {var} and record that it is uninitialized. If {var} is *true*, record that the newly created binding may be deleted by a subsequent DeleteBinding call.
Create an immutable binding in {var} for {var} and record that it is uninitialized. If {var} is *true*, record that the newly created binding is a strict binding.
Create an immutable indirect binding in {var} for {var} that references {var} and {var} as its target binding and record that the binding is initialized.
Create an own {PROPERTY_KIND} property named {var} of object {var} whose {dsb_word}, {dsb_word}, {dsb_word}, and {dsb_word} attributes are set to the value of the corresponding field in {var} if {var} has that field, or to the attribute's {h_emu_xref} otherwise.
Create any host-defined global object properties on {var}.
Create own properties of {var} corresponding to the definitions in {h_emu_xref}.
Discard all resources associated with the current execution context.
Find a finite time value {DEFVAR} such that {CONDITION}; but if this is not possible (because some argument is out of range), return {LITERAL}.
For each {EACH_THING}, do{IND_COMMANDS}
For each {EACH_THING}, {SMALL_COMMAND}.
IfAbruptCloseIterator({var}, {var}).
IfAbruptRejectPromise({var}, {var}).
Insert {var} as the first element of {var}.
Leave the critical section for {var}.
Let {DEFVAR} and {DEFVAR} be integers such that {CONDITION} and for which {NUM_EXPR} is as close to zero as possible. If there are two such sets of {var} and {var}, pick the {var} and {var} for which {PRODUCT} is larger.
Let {DEFVAR} and {DEFVAR} be the indirection values provided when this binding for {var} was created.
Let {DEFVAR} be an integer for which {NUM_EXPR} is as close to zero as possible. If there are two such {var}, pick the larger {var}.
Let {DEFVAR} be {EXPR}.
Let {DEFVAR} be {EXPR}. (However, if {var} = 10 and {var} contains more than 20 significant digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation; and if {var} is not one of 2, 4, 8, 10, 16, or 32, then {var} may be an implementation-approximated integer representing the integer value denoted by {var} in radix-{var} notation.)
Let {DEFVAR} be {EXPR}. (It may be evaluated repeatedly.)
Let {DEFVAR} be {MULTILINE_EXPR}
Let {DEFVAR}, {DEFVAR}, and {DEFVAR} be integers such that {CONDITION}. If there are multiple possibilities for {var}, choose the value of {var} for which {EX} is closest in value to {EX}. If there are two such possible values of {var}, choose the one that is even.
Let {DEFVAR}, {DEFVAR}, and {DEFVAR} be integers such that {CONDITION}. If there are multiple possibilities for {var}, choose the value of {var} for which {EX} is closest in value to {EX}. If there are two such possible values of {var}, choose the one that is even. Note that {var} is the number of digits in the representation of {var} using radix {var} and that {var} is not divisible by {var}.
Let {DEFVAR}, {DEFVAR}, and {DEFVAR} be integers such that {CONDITION}. Note that the decimal representation of {var} has {SUM} digits, {var} is not divisible by 10, and the least significant digit of {var} is not necessarily uniquely determined by these criteria.
Let {DEFVAR}, {DEFVAR}, and {DEFVAR} be integers such that {CONDITION}. Note that {var} is the number of digits in the representation of {var} using radix {var}, that {var} is not divisible by {var}, and that the least significant digit of {var} is not necessarily uniquely determined by these criteria.
Optionally, {SMALL_COMMAND}.
Perform an implementation-defined debugging action.
Perform any necessary implementation-defined initialization of {var}.
Perform the following steps:{IND_COMMANDS}
Perform the following substeps in an implementation-defined order, possibly interleaving parsing and error detection:{IND_COMMANDS}
Perform {PP_NAMED_OPERATION_INVOCATION} and suspend the surrounding agent until the time is {DOTTING}, performing the combined operation in such a way that a notification that arrives after the critical section is exited but before the suspension takes effect is not lost. The surrounding agent can only wake from suspension due to a timeout or due to another agent calling NotifyWaiter with arguments {var} and {var} (i.e. via a call to `Atomics.notify`).
Perform {PP_NAMED_OPERATION_INVOCATION}.
Perform {PP_NAMED_OPERATION_INVOCATION}. {note}
Prepend {var} to {var}.
Push {var} onto the execution context stack; {var} is now the running execution context.
Remove from {var} all characters corresponding to a code point on the right-hand side of the {nonterminal} production.
Remove the binding for {var} from {var}.
Remove the first element from {SETTABLE}.
Remove the first {var} elements of {SETTABLE}.
Remove the last element of {SETTABLE}.
Remove the own property with name {var} from {var}.
Remove {var} from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
Remove {var} from the execution context stack and restore {var} as the running execution context.
Remove {var} from the execution context stack.
Remove {var} from {DOTTING}.
Remove {var} from {var}.
Repeat, until {CONDITION},{IND_COMMANDS}
Repeat, while {CONDITION},{IND_COMMANDS}
Repeat,{IND_COMMANDS}
Replace the element of {SETTABLE} whose value is {var} with an element whose value is {LITERAL}.
Replace the property named {var} of object {var} with an? {PROPERTY_KIND} property whose {dsb_word} and {dsb_word} attributes are set to {var} and {var}, respectively, and whose {dsb_word} and {dsb_word} attributes are set to the value of the corresponding field in {var} if {var} has that field, or to the attribute's {h_emu_xref} otherwise.
Replace {var} in {var} with {var}.
Resume the context that is now on the top of the execution context stack as the running execution context.
Resume {var} passing {EX}. If {var} is ever resumed again, let {DEFVAR} be the Completion Record with which it is resumed.
Return {EXPR}.
Return {EXPR}. This may be of type Reference.
Return {MULTILINE_EXPR}
ReturnIfAbrupt({EX}).
Set all of the bytes of {var} to 0.
Set fields of {DOTTING} with the values listed in {h_emu_xref}. {the_field_names_are_the_names_listed_etc}
Set {DOTTING} as described in {h_emu_xref}.
Set {DOTTING} as specified in {h_emu_xref}.
Set {DOTTING} to the definition specified in {h_emu_xref}.
Set {SETTABLE} such that when evaluation is resumed for that execution context, {var} will be called with no arguments.
Set {SETTABLE} to {EXPR}.
Set {SETTABLE} to {MULTILINE_EXPR}
Set {var}'s essential internal methods to the default ordinary object definitions specified in {h_emu_xref}.
Set {var}'s essential internal methods to the definitions specified in {h_emu_xref}.
Set {var}'s essential internal methods, except for {DSBN} and {DSBN}, to the definitions specified in {h_emu_xref}.
Sort {var} according to the lexicographic order of their {dsb_word} field, treating the value of each such field as a sequence of UTF-16 code unit values. {note}
Sort {var} using an implementation-defined sequence of {h_emu_meta_start}calls to {var}{h_emu_meta_end}. If any such call returns an abrupt completion, stop before performing any further calls to {var} and return that Completion Record.
Store the individual bytes of {var} into {var}, starting at {var}[{var}].
Suspend the running execution context.
Suspend {var} and remove it from the execution context stack.
Suspend {var}.
The code points `/` or any {nonterminal} occurring in the pattern shall be escaped in {var} as necessary to ensure that the string-concatenation of {EX}, {EX}, {EX}, and {EX} can be parsed (in an appropriate lexical context) as a {nonterminal} that behaves identically to the constructed regular expression. For example, if {var} is {STR_LITERAL}, then {var} could be {STR_LITERAL} or {STR_LITERAL}, among other possibilities, but not {STR_LITERAL}, because `///` followed by {var} would be parsed as a {nonterminal} rather than a {nonterminal}. If {var} is the empty String, this specification can be met by letting {var} be {STR_LITERAL}.
Throw a {ERROR_TYPE} exception.
Wait until no agent is in the critical section for {var}, then enter the critical section for {var} (without allowing any other agent to enter).
Wake the agent whose signifier is {DOTTING} from suspension.
When the {nonterminal} {var} is evaluated, perform the following steps in place of the {nonterminal} Evaluation algorithm provided in {h_emu_xref}:{IND_COMMANDS}
While {CONDITION}, an implementation may perform the following steps:{IND_COMMANDS}
{IF_CLOSED}
{IF_OTHER}
{h_emu_meta_start}Resume the suspended evaluation of {var}{h_emu_meta_end} using {EX} as the result of the operation that suspended it.
{h_emu_meta_start}Resume the suspended evaluation of {var}{h_emu_meta_end} using {EX} as the result of the operation that suspended it. Let {DEFVAR} be the Completion Record returned by the resumed computation.
{h_emu_meta_start}Resume the suspended evaluation of {var}{h_emu_meta_end} using {EX} as the result of the operation that suspended it. Let {DEFVAR} be the value returned by the resumed computation.
{h_emu_meta_start}Resume the suspended evaluation of {var}{h_emu_meta_end}. Let {DEFVAR} be the value returned by the resumed computation.
{h_emu_not_ref_Record} that the binding for {var} in {var} has been initialized.
{note}
# ----------------------------------------------
{IF_CLOSED} :
If {CONDITION}, {SMALL_COMMAND}. Otherwise {SMALL_COMMAND}.
If {CONDITION}, {SMALL_COMMAND}. Otherwise, {SMALL_COMMAND}.
If {CONDITION}, {SMALL_COMMAND}; else if {CONDITION}, {SMALL_COMMAND}; else {SMALL_COMMAND}.
If {CONDITION}, {SMALL_COMMAND}; else {SMALL_COMMAND}.
If {CONDITION}, {SMALL_COMMAND}; otherwise {SMALL_COMMAND}.
If {CONDITION}, {SMALL_COMMAND}; otherwise, {SMALL_COMMAND}.
{IF_OTHER} :
{IF_OPEN}{IF_TAIL}
{IF_OPEN} :
If {CONDITION}, then{IND_COMMANDS}
If {CONDITION}, {SMALL_COMMAND}.
{IF_TAIL} :
{EPSILON}
{_NL_N} {ELSEIF_PART}{IF_TAIL}
{_NL_N} {ELSE_PART}
{ELSEIF_PART} :
Else if {CONDITION}, then{IND_COMMANDS}
Else if {CONDITION}, {SMALL_COMMAND}.
{ELSE_PART} :
Else, {SMALL_COMMAND}.
Else,{IND_COMMANDS}
Otherwise, {SMALL_COMMAND}.
# ----------------------------------------------
{SMALL_COMMAND} :
add {var} to {var}
append {EX} to {SETTABLE}
let {DEFVAR} be {EXPR}
perform any host-defined steps for reporting the error
perform {PP_NAMED_OPERATION_INVOCATION}
return {EXPR}
reverse the order of the elements of {var}
set the corresponding attribute of the property named {var} of object {var} to the value of the field
set {SETTABLE} to {EXPR}
suspend {var}
throw a {ERROR_TYPE} exception
throw a {ERROR_TYPE} exception because the structure is cyclical
# ------------------------------------------------------
{EACH_THING} :
CharSetElement {DEFVAR} in {var} containing more than 1 character, iterating in descending order of length
child node {DEFVAR} of this Parse Node
code point {DEFVAR} in {var}, iterating backwards from its second-to-last code point
element {DEFVAR} of {EX}
element {DEFVAR} of {var}, in reverse List order
field of {var}
index {DEFVAR} of {var}
integer {DEFVAR} in {INTERVAL}
own property key {DEFVAR} of {var} such that {CONDITION}, in ascending chronological order of property creation
own property key {DEFVAR} of {var} such that {CONDITION}, in ascending numeric index order
own property key {DEFVAR} of {var} such that {CONDITION}, in descending numeric index order
property of the Global Object specified in clause {h_emu_xref}
single code point {DEFVAR} in {var}
{ITEM_NATURE} {DEFVAR} of {EX}
{ITEM_NATURE} {DEFVAR} of {EX} such that {CONDITION}
{ITEM_NATURE} {DEFVAR} of {EX}, iterating backwards from its second-to-last element
{ITEM_NATURE} {DEFVAR} such that {CONDITION}
{ITEM_NATURE} {DEFVAR} such that {CONDITION}, in ascending order
{ITEM_NATURE} {DEFVAR} such that {CONDITION}, in descending order
{nonterminal} {DEFVAR} that is directly contained in the {nonterminal} of any {nonterminal}, {nonterminal}, or {nonterminal} {var} such that {CONDITION}
{nonterminal} {DEFVAR} that {var} contains
{ITEM_NATURE} :
Agent Events Record
CharSetElement
Cyclic Module Record
ExportEntry Record
FinalizationRegistry
ImportAttribute Record
ImportEntry Record
LoadedModuleRequest Record
Matcher
ModuleRequest Record
Parse Node
Private Name
PrivateElement
ReadSharedMemory or ReadModifyWriteSharedMemory event
Record { {DSBN}, {DSBN} }
Record { {DSBN}, {DSBN}, {DSBN} }
String
WeakMap
WeakRef
WeakSet
code point
code unit
event
integer
{nonterminal}
# ------------------------------------------------------
{I_BULLETS} :
{_indent_}{BULLETS}{_outdent_}
{BULLETS} :
{BULLETS}{BULLET_LINE}
{BULLET_LINE}
{BULLET_LINE} :
{B} the code unit of the most significant digit of the decimal representation of {var}
{B} the code unit of the single digit of {var}
{B} the code units of the decimal representation of abs({var} - 1)
{B} the code units of the most significant {var} digits of the representation of {var} using radix {var}
{B} the code units of the remaining {NUM_EXPR} digits of the decimal representation of {var}
{B} the code units of the remaining {NUM_EXPR} digits of the representation of {var} using radix {var}
{B} the code units of the {var} digits of the representation of {var} using radix {var}
{B} {EX} occurrences of {code_unit_lit}
{B} {LITERAL}
{B} {var}
{B} :
{nlai}*
# ----------------------------------------------------------------------------------------
{CONDITION} :
({NUM_COMPARISON} or {NUM_COMPARISON}) and ({NUM_COMPARISON} or {NUM_COMPARISON})
either {CONDITION_1} and {CONDITION_1}, or {CONDITION_1} and {CONDITION_1}
it is not the case that both {CONDITION_1} and {CONDITION_1}
{CONDITION_1}
{CONDITION_1} and {CONDITION_1}
{CONDITION_1} and {CONDITION_1}, or if {CONDITION_1} and {CONDITION_1}
{CONDITION_1} and {CONDITION_1}, or {CONDITION_1} and {CONDITION_1}
{CONDITION_1} or {CONDITION_1}
{CONDITION_1} or {CONDITION_1} <ins>and {CONDITION_1}</ins>
{CONDITION_1} unless {CONDITION_1}
{CONDITION_1} unless {CONDITION_1} and {CONDITION_1}
{CONDITION_1}, or if {CONDITION_1}
{CONDITION_1}, or if {CONDITION_1} and {CONDITION_1}
{CONDITION_1}, unless {CONDITION_1}
{CONDITION_1}, {CONDITION_1}, and {CONDITION_1}
{CONDITION_1}, {CONDITION_1}, or {CONDITION_1}
{CONDITION_1}, {CONDITION_1}, {CONDITION_1}, and {CONDITION_1}
{CONDITION_1}, {CONDITION_1}, {CONDITION_1}, or {CONDITION_1}
{CONDITION_1} :
A `default` export was not explicitly defined by this module
All elements of {var} have their {dsb_word} field set to {VAL_DESC}, {dsb_word} field set to {LITERAL}, and {dsb_word} field set to {LITERAL}
All named exports from {var} are resolvable
Every CharSetElement of {var} consists of a single character
Exactly one element of {var} is a Private Name whose {dsb_word} is {var}
Exactly one element of {var} meets this criterion
The GlobalSymbolRegistry List does not currently contain an entry for {var}
LoadRequestedModules has completed successfully on {var} prior to invoking this abstract operation
The current execution context will not subsequently be used for the evaluation of any ECMAScript code or built-in functions. The invocation of Call subsequent to the invocation of this abstract operation will create and push a new execution context before performing any such evaluation
The execution context stack has at least two elements
The execution context stack is not empty
The following Set will succeed, since formal parameters mapped by arguments objects are always writable
The following loop will terminate
The length of {var} is {EX}
The mathematical value of {var}'s {starred_str} property is {EX}
The next step never returns an abrupt completion because {CONDITION_1}
The surrounding agent is in the critical section for {var}
The surrounding agent is not in the critical section for any WaiterList Record
There are sufficient bytes in {var} starting at {var} to represent a value of {var}
There is more than one `*` import that includes the requested name
There is no Waiter Record in {DOTTING} whose {dsb_word} field is {EX} and whose {dsb_word} field is {EX}
This call to Evaluate is not happening at the same time as another call to Evaluate within the surrounding agent
This is a circular import request
This is an attempt to change the value of an immutable binding
This is only possible for getter/setter pairs
We've reached the starting point of an `export *` circularity
When we reach this step, {var} has already been removed from the execution context stack and {var} is the currently running execution context
When we return here, {var} has already been removed from the execution context stack and {var} is the currently running execution context
When {SETTABLE} is instantiated, it will have a direct binding for {var}
an implementation-defined debugging facility is available and enabled
any code point in {EX} is also contained in {EX}
any element of {NAMED_OPERATION_INVOCATION} also occurs in {NAMED_OPERATION_INVOCATION}
any element of {NAMED_OPERATION_INVOCATION} does not also occur in either {NAMED_OPERATION_INVOCATION}, or {NAMED_OPERATION_INVOCATION}
any source text is matched by this production
control reaches here
either {DOTTING} or {DOTTING} is {LITERAL}
every CharSetElement of {var} consists of a single character (including if {var} is empty)
it is impossible to create a new Shared Data Block value consisting of {var} bytes
it is not possible to create a Data Block {var} consisting of {var} bytes
it must be in the Object Environment Record
no such execution context exists
only one argument was passed
replacing the {nonterminal} {var} with a {nonterminal} that has {var} as a {nonterminal} would not produce any Early Errors for {var}
the <sub>[Tagged]</sub> parameter was not set
the Directive Prologue of {PROD_REF} contains a Use Strict Directive
the async function either threw an exception or performed an implicit or explicit return; all awaiting is done
the async generator either threw an exception or performed either an implicit or explicit return
the binding exists
the binding for {var} in {var} cannot be deleted
the binding for {var} in {var} has not yet been initialized
the binding for {var} in {var} is a mutable binding
the binding for {var} in {var} is a strict binding
the binding for {var} in {var} is an uninitialized binding
the binding for {var} is an indirect binding
the caller will not be overriding all of {var}'s {DSBN}, {DSBN}, and {DSBN} essential internal methods
the caller will not be overriding both {var}'s {DSBN} and {DSBN} essential internal methods
the character {EX} is matched by {nonterminal}
the decimal representation of {var} has 20 or fewer significant digits
the duplicate entries are only bound by {cap_word}
the execution context stack is empty
the file {h_a} of the Unicode Character Database provides a simple or common case folding mapping for {var}
the first two code units of {var} are either {STR_LITERAL} or {STR_LITERAL}
the generator either threw an exception or performed either an implicit or explicit return
the goal symbol of the syntactic grammar is {nonterminal}
the host is a web browser
the host requires that the `this` binding in {var}'s global scope return an object other than the global object
the host requires use of an exotic object to serve as {var}'s global object
the implementation does not include local political rules for any time zones
the implementation only supports the UTC time zone
the name is used once for a getter and once for a setter and in no other entries, and the getter and setter are either both static or both non-static
the parse succeeded and no early errors were found
the source text containing {G_SYM} is eval code that is being processed by a direct eval
the source text matched by {PROD_REF} is not a Unicode property value or property value alias for the General_Category (gc) property listed in {h_a}, nor a binary property or binary property alias listed in the “Property name and aliases” column of {h_emu_xref}, nor a binary property of strings listed in the “Property name” column of {h_emu_xref}
the source text matched by {PROD_REF} is not a property value or property value alias for the Unicode property or property alias given by the source text matched by {PROD_REF} listed in {h_a}
the source text matched by {var} is strict mode code
the syntactic goal symbol is not {nonterminal}
the {var}<sup>th</sup> capture of {var} was defined with a {nonterminal}
there exists a CharSetElement in {var} containing exactly one character {DEFVAR} such that {CONDITION_1}
there exists a WriteSharedMemory or ReadModifyWriteSharedMemory event {DEFVAR} that has {var} in its range such that {CONDITION_1} and {CONDITION_1}
there exists an event {DEFVAR} such that {CONDITION}
there exists an integer {DEFVAR} in {INTERVAL} such that {CONDITION_1}
we return here
{DOTTING} exists and has been initialized
{DOTTING} is not the ordinary object internal method defined in {h_emu_xref}
{EX} and {EX} are both empty
{EX} and {EX} are both {LITERAL}
{EX} and {EX} are both {LITERAL} or both {LITERAL}
{EX} and {EX} are distinct values
{EX} and {EX} are valid byte offsets within the memory of {var}
{EX} contains a Record {DEFVAR} such that {CONDITION_1}
{EX} contains a code unit that is not a radix-{var} digit
{EX} contains a formal parameter mapping for {var}
{EX} contains a {nonterminal}
{EX} contains an? {h_emu_grammar} Parse Node such that {CONDITION}
{EX} contains an? {nonterminal} Parse Node
{EX} contains any code point more than once
{EX} contains any code points other than {backticked_word}, {backticked_word}, {backticked_word}, {backticked_word}, {backticked_word}, {backticked_word}, {backticked_word}, or {backticked_word}
{EX} contains any code unit more than once
{EX} contains any code unit other than *"d"*, *"g"*, *"i"*, *"m"*, *"s"*, *"u"*, *"v"*, or *"y"*
{EX} contains any duplicate elements
{EX} contains any duplicate entries
{EX} contains any duplicate entries for {starred_str} and at least two of those entries were obtained from productions of the form {h_emu_grammar}
{EX} contains any {nonterminal}
{EX} contains any {nonterminal}s
{EX} contains more than one occurrence of {starred_str}
{EX} contains no duplicate entries
{EX} contains only single code points
{EX} contains the same code point more than once
{EX} contains two distinct {nonterminal}s {DEFVAR} and {DEFVAR} such that {CONDITION_1} and such that {CONDITION_1}
{EX} contains {EX}
{EX} contains {VAL_DESC} {DEFVAR} such that {CONDITION_1}
{EX} does not contain {EX}
{EX} does not contain {VAL_DESC} {DEFVAR} such that {CONDITION_1}
{EX} is also {VAL_DESC}
{EX} is empty
{EX} is listed in the “Code Point” column of {h_emu_xref}
{EX} is neither {VAL_DESC} nor {VAL_DESC}
{EX} is neither {VAL_DESC} nor {VAL_DESC} nor {VAL_DESC}
{EX} is never {VAL_DESC}
{EX} is not empty
{EX} is not {PREFIX_PAREN}
{EX} is not {SETTABLE}
{EX} is not {VALUE_DESCRIPTION}
{EX} is the same Parse Node as {EX}
{EX} is {NAMED_OPERATION_INVOCATION}
{EX} is {SETTABLE}
{EX} is {VALUE_DESCRIPTION}
{LOCAL_REF} Contains {G_SYM}
{LOCAL_REF} is not nested, directly or indirectly (but not crossing function or `static` initialization block boundaries), within an {nonterminal}
{LOCAL_REF} is not nested, directly or indirectly (but not crossing function or `static` initialization block boundaries), within an {nonterminal} or a {nonterminal}
{LOCAL_REF} is not present
{LOCAL_REF} is present
{LOCAL_REF} is {h_emu_grammar}
{LOCAL_REF} is {h_emu_grammar}, {h_emu_grammar}, {h_emu_grammar}, {h_emu_grammar}, or {h_emu_grammar}
{NAMED_OPERATION_INVOCATION} has two different entries {DEFVAR} and {DEFVAR} such that {CONDITION}
{NAMED_OPERATION_INVOCATION} is not matched by the {nonterminal} lexical grammar production
{NAMED_OPERATION_INVOCATION} is not some Unicode code point matched by the {nonterminal} lexical grammar production
{NAMED_OPERATION_INVOCATION} is not the numeric value of some code point matched by the {nonterminal} lexical grammar production
{NAMED_OPERATION_INVOCATION} is the StringValue of any |ReservedWord| except for `yield` or `await`
{NUM_COMPARISON}
{NUM_COMPARISON} (ignoring potential non-monotonicity of time values)
{PROD_REF} does not have an? <sub>[{cap_word}]</sub> parameter
{PROD_REF} has an? <sub>[{cap_word}]</sub> parameter
{PROD_REF} is `export` {nonterminal}
{PROD_REF} is contained within a {nonterminal} that is being evaluated for ParseJSON (see step {h_emu_xref} of ParseJSON)
{PROD_REF} is contained within a {nonterminal} that is being parsed for ParseJSON (see step {h_emu_xref} of ParseJSON)
{PROD_REF} is the token `false`
{PROD_REF} is the token `true`
{SETTABLE} and {SETTABLE} are not the same Environment Record
{SETTABLE} and {SETTABLE} are not the same Module Record
{SETTABLE} and {SETTABLE} are not the same Realm Record
{SETTABLE} and {SETTABLE} are not the same Shared Data Block event
{SETTABLE} and {SETTABLE} are the same Completion Record
{SETTABLE} and {SETTABLE} are the same Environment Record
{SETTABLE} and {SETTABLE} are the same Module Record
{SETTABLE} has an? {DSBN} field
{SETTABLE} ≠ {SETTABLE} for some integer {DEFVAR} in {INTERVAL}
{var} also has a {DSBN} internal slot
{var} and {var} are both WriteSharedMemory or ReadModifyWriteSharedMemory events
{var} and {var} are both finite
{var} and {var} are finite
{var} and {var} are finite and non-zero
{var} and {var} are in a {h_emu_xref} in {var}
{var} and {var} do not have disjoint ranges
{var} and {var} do not have the same number of elements
{var} and {var} each contain exactly one character
{var} and {var} have equal ranges
{var} and {var} have no elements in common
{var} and {var} have overlapping ranges
{var} and {var} have the same enclosing {nonterminal}
{var} and {var} have the same length and the same code units in the same positions
{var} and {var} have the same number of elements
{var} binds a single name
{var} corresponds with a year that cannot be represented in the {h_emu_xref}
{var} does not already have a binding for {var}
{var} does not contain a rest parameter, any binding patterns, or any initializers. It may contain duplicate identifiers
{var} does not contain a valid UTF-8 encoding of a Unicode code point
{var} does not contain an? {nonterminal} Parse Node
{var} does not contain exactly one character
{var} does not contain two {nonterminal} Parse Nodes
{var} does not currently have a property {var}
{var} does not have a Generator component
{var} does not have a binding for {var}
{var} does not have an own property with key {var}
{var} does not have an? {DSBN} field
{var} does not have an? {DSBN} internal slot
{var} does not have an? {var} internal slot
{var} does not have any fields
{var} does not have either a {DSBN} or an {DSBN} internal slot
{var} does not include the element {LITERAL}
{var} does not provide the direct binding for this export
{var} happens-before {var} in {var}
{var} has a binding for {var}
{var} has a numeric value less than {code_unit_lit}
{var} has all of the internal slots of a For-In Iterator instance ({h_emu_xref})
{var} has an? {DSBN} internal method
{var} has an? {DSBN} internal slot
{var} has an? {DSBN} internal slot whose value is an Object
{var} has an? {DSBN} or {DSBN} internal slot
{var} has any duplicate entries
{var} has any elements
{var} has attribute values { {DSBN}: *true*, {DSBN}: *true* }
{var} has been linked and declarations in its module environment have been instantiated
{var} has exactly one element
{var} has no duplicate entries
{var} has no elements
{var} has the same numeric value as a leading surrogate or trailing surrogate
{var} has {DSBN} and {DSBN} internal slots
{var} has {EX} elements
{var} has {var} in its range
{var} imports a specific binding for this export
{var} is a normal completion with a value of {LITERAL}. The possible sources of this value are Await or, if the async function doesn't await anything, step {h_emu_xref} above
{var} is as small as possible
{var} is contained within {PROD_REF}
{var} is even
{var} is finite
{var} is finite and is neither {NUMBER_LITERAL} nor {NUMBER_LITERAL}
{var} is in {INTERVAL}
{var} is matched by either {nonterminal} or {nonterminal}
{var} is matched by {nonterminal}
{var} is not already suspended
{var} is not contained within an? {nonterminal}, an? {nonterminal}, or an? {nonterminal}
{var} is not finite
{var} is not in {INTERVAL}
{var} is not in {PREFIX_PAREN}
{var} is now an empty List
{var} is now the running execution context
{var} is a code point listed in the “Code Point” column of {h_emu_xref}
{var} is the running execution context again
{var} is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the {DSBN} value of an object
{var} must have an uninitialized binding for {var}
{var} occurs exactly once in {var}
{var} or {var} is {LITERAL}
{var} provides the direct binding for this export
{var} reads-from {var} in {var}
{var} starts with {STR_LITERAL}
{var} starts with {STR_LITERAL} followed by {EX} or more decimal digits
{var}, {var}, and {var} have the same number of elements
{PROPERTY_KIND} :
accessor
data
{NUM_COMPARISON} :
{NUM_COMPARAND} {NUM_COMPARATOR} {NUM_COMPARAND}
{NUM_COMPARAND} {NUM_COMPARATOR} {NUM_COMPARAND} {NUM_COMPARATOR} {NUM_COMPARAND}
{NUM_COMPARAND} :
the length of {var}
the number of elements in {NAMED_OPERATION_INVOCATION}
the number of elements in {var}
the numeric value of {var}
{FACTOR}
{PRODUCT}
{SUM}
{NUM_COMPARATOR} :
<
=
>
is at least
is greater than or equal to
is strictly greater than
≠
≤
≥
# ---------------------------------------------------------------
{MULTILINE_EXPR} :
a new {CLOSURE_KIND} with {CLOSURE_PARAMETERS} that captures {CLOSURE_CAPTURES} and performs the following {CLOSURE_STEPS} when called:{IND_COMMANDS}
the string-concatenation of:{I_BULLETS}
the {TABLE_RESULT_TYPE} associated with {var} in the following table:{_indent_}{nlai}{h_figure}{_outdent_}
{CLOSURE_KIND} :
Abstract Closure
Job Abstract Closure
Matcher
MatcherContinuation
read-modify-write modification function
{CLOSURE_PARAMETERS} :
no parameters
parameters ({DEFVAR})
parameters ({DEFVAR}, {DEFVAR})
{CLOSURE_CAPTURES} :
nothing
{var}
{var} and {var}
{var}, {var}, and {var}
{var}, {var}, {var}, and {var}
{var}, {var}, {var}, {var}, {var}, {var}, {var}, and {var}
{CLOSURE_STEPS} :
steps
steps atomically
{TABLE_RESULT_TYPE} :
abstract operation
sequence of Unicode code points
# ---------------------------------------------------------------
{EXPR} :
a List consisting of each {EACH_THING}
a List consisting of the sequence of code units that are the elements of {var}
a List containing one or more {ERROR_TYPE} objects
a List containing the names of all the internal slots that {h_emu_xref} requires for the built-in function object that is about to be created
a List of length {var} whose elements are nondeterministically chosen byte values
a List of length {var} whose elements are the sequence of {var} bytes starting with {var}[{var}]
a List of one or more {ERROR_TYPE} objects representing the parsing errors and/or early errors. If more than one parsing error or early error is present, the number and ordering of error objects in the list is implementation-defined, but at least one must be present
a List of the integers in {INTERVAL}, in ascending order
a List of the integers in {INTERVAL}, in descending order
a List of {EX} {LITERAL} values, indexed 1 through {EX}
a List whose elements are bytes from {var} at indices in {INTERVAL}
a List whose elements are the 2 bytes that are the result of converting {var} to IEEE 754-2019 binary16 format using roundTiesToEven mode. The bytes are arranged in little endian order. If {var} is *NaN*, {var} may be set to any implementation chosen IEEE 754-2019 binary16 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable *NaN* value
a List whose elements are the 4 bytes that are the result of converting {var} to IEEE 754-2019 binary32 format using roundTiesToEven mode. The bytes are arranged in little endian order. If {var} is *NaN*, {var} may be set to any implementation chosen IEEE 754-2019 binary32 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable *NaN* value
a List whose elements are the 8 bytes that are the IEEE 754-2019 binary64 format encoding of {var}. The bytes are arranged in little endian order. If {var} is *NaN*, {var} may be set to any implementation chosen IEEE 754-2019 binary64 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable *NaN* value
a List whose elements are the code units that are the elements of {var}
a List whose elements are the elements of {var}
a List whose elements are the elements of {var}, sorted according to lexicographic code unit order
a List whose elements are the elements of {var}, sorted by their {dsb_word} field in ascending order
a List whose elements are the first {var} elements of {EX}
a List whose elements are the {var}-byte binary encoding of {var}. The bytes are ordered in little endian order
a List whose elements are the {var}-byte binary two's complement encoding of {var}. The bytes are ordered in little endian order
a List whose sole element is {EX}
a String in the form of a {var} equivalent to {var} interpreted as UTF-16 encoded Unicode code points ({h_emu_xref}), in which certain code points are escaped as described below. {var} may or may not differ from {var}; however, the Abstract Closure that would result from evaluating {var} as a {var} must behave identically to the Abstract Closure given by the constructed object's {DSBN} internal slot. Multiple calls to this abstract operation using the same values for {var} and {var} must produce identical results
a String representation of {var} in the {h_emu_xref} on the UTC time scale, including all format elements and the UTC offset representation *"Z"*
a copy of the List {var}
a copy of {EX}
a new Data Block value consisting of {var} bytes. If it is impossible to create such a Data Block, throw a {ERROR_TYPE} exception
a new ECMAScript code execution context
a new Private Name whose {dsb_word} is {var}
a new Property Descriptor that initially has no fields
a new Realm Record
a new Record
a new Shared Data Block value consisting of {var} bytes. If it is impossible to create such a Shared Data Block, throw a {ERROR_TYPE} exception
a new Symbol whose {DSBN} is {var}
a new Synchronize event
a new built-in function object that, when called, performs the action described by {var} using the provided arguments as the values of the corresponding parameters specified by {var}. The new function object has internal slots whose names are the elements of {var}, and an {DSBN} internal slot
a new empty CharSet
a new empty List
a new execution context
a new implementation-defined Completion Record
a new {ENVIRONMENT_RECORD_KIND} Environment Record
a new {ENVIRONMENT_RECORD_KIND} Environment Record containing no bindings
a new {cap_word} object whose {dsb_word} internal slot is set to {var}. See {h_emu_xref} for a description of {cap_word} objects
a newly created Property Descriptor with no fields
a newly created object with an internal slot for each name in {var}
a one-element CharSet containing {EX}
an empty List of Matchers
an empty Set
an empty sequence of characters
an implementation-approximated Number value representing {EXPR}
an implementation-defined String source code representation of {var}. The representation must have the syntax of a {nonterminal}
an implementation-defined String source code representation of {var}. The representation must have the syntax of a {nonterminal}. Additionally, if {var} has an {DSBN} internal slot and {DOTTING} is a String, the portion of the returned String that would be matched by {nonterminal} {nonterminal} must be the value of {DOTTING}
an implementation-defined choice of either {var} or {var}
an implementation-defined non-negative mathematical value
an implementation-defined string that is either {EX} or {EXPR}
an instance of the production {h_emu_grammar}
an iterator object whose `next` method iterates over all the String-valued keys of enumerable properties of {var}. The iterator object is never directly accessible to ECMAScript code. The mechanics and order of enumerating the properties is not specified but must conform to the rules specified below
reads-bytes-from({var}) in {var}
such an object created in a host-defined manner
the 32-bit two's complement bit string representing {EX}
the Agent Events Record of {DOTTING} whose {DSBN} is {PP_NAMED_OPERATION_INVOCATION}
the Agent Record of the surrounding agent
the BigInt value that corresponds to {var}
the CharSet containing all CharSetElements whose character database definition includes the property {var} with value “True”
the CharSet containing all Unicode code points whose character database definition includes the property {var} with value {var}
the CharSet containing all Unicode code points whose character database definition includes the property “General_Category” with value {var}
the CharSet containing all Unicode code points {DEFVAR} that do not have a {h_a} mapping (that is, scf({var})={var})
the CharSet containing all characters corresponding to a code point on the right-hand side of the {nonterminal} or {nonterminal} productions
the CharSet containing all characters with a character value in the inclusive interval from {var} to {var}
the CharSet containing all characters {DEFVAR} such that {var} is not in {var} but {NAMED_OPERATION_INVOCATION} is in {var}
the CharSet containing all code point values
the CharSet containing all code unit values
the CharSet containing every CharSetElement of {var} that consists of a single character
the CharSet containing every character in {STR_LITERAL}
the CharSet containing the CharSetElements of {var} which are not also CharSetElements of {var}
the CharSet containing the character matched by {PROD_REF}
the CharSet containing the one string {var}
the CharSet containing the single character {code_point_lit}
the CharSet containing the single character {var}
the Completion Record that is {h_emu_meta_start}the result of evaluating{h_emu_meta_end} {var} in a manner that conforms to the specification of {var}. If {CONDITION}, the *this* value is uninitialized; otherwise, {var} provides the *this* value. {var} provides the named parameters. {var} provides the NewTarget value
the ECMAScript Number value corresponding to {var}
the Element Size value specified in {h_emu_xref} for Element Type {var}
the Element Size value specified in {h_emu_xref} for {EX}
the Element Type value specified in {h_emu_xref} for {EX}
the List of Unicode code points {var}
the List of arguments that was passed to this function by {dsb_word} or {dsb_word}
the List of octets resulting by applying the UTF-8 transformation to {DOTTING}
the List of unique available named time zone identifiers, sorted according to lexicographic code unit order
the List of {nonterminal} items in {PROD_REF}, in source text order
the Name of the entry in {h_emu_xref} with the Number {PP_NAMED_OPERATION_INVOCATION}
the Number value that corresponds to {var}
the Parse Node (an instance of {var}) at the root of the parse tree resulting from the parse
the Private Name in {var} whose {dsb_word} is {var}
the String representation of {EX}, formatted as a decimal number
the String representation of {EX}, formatted as a lowercase hexadecimal number
the String representation of {EX}, formatted as an uppercase hexadecimal number
the String representing the host environment's current time zone, either a primary time zone identifier or an offset time zone identifier
the String value consisting of repeated concatenations of {EX} truncated to length {var}
the String value consisting of the representation of {var} using radix {var}
the String value consisting of {EX}
the String value consisting solely of {code_unit_lit}
the String value containing {var} occurrences of {code_unit_lit}
the String value formed by concatenating all the element Strings of {var} with each adjacent pair of Strings separated with {code_unit_lit}. A comma is not inserted either before the first String or after the last String
the String value formed by concatenating all the element Strings of {var} with each adjacent pair of Strings separated with {var}. The {var} String is not inserted either before the first String or after the last String
the String value of the Constructor Name value specified in {h_emu_xref} for this <var>TypedArray</var> constructor
the String value of the property name
the String value that is a copy of {var} with both leading and trailing white space removed
the String value that is a copy of {var} with leading white space removed
the String value that is a copy of {var} with trailing white space removed
the String value that is made from {var} copies of {var} appended together
the String value that is the result of normalizing {var} into the normalization form named by {var} as specified in {h_a}
the String value that is the same as {var} except that each occurrence of {code_unit_lit} in {var} has been replaced with the six code unit sequence {STR_LITERAL}
the String value whose code units are the elements of the List {var}. If {var} has no elements, the empty String is returned
the String value {SETTABLE}
the WaiterList Record that is referenced by the pair ({var}, {var})
the abstract operation named in the Conversion Operation column in {h_emu_xref} for Element Type {var}
the algorithm steps defined in {h_emu_xref}
the bitwise complement of {var}. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string
the byte elements of {var} concatenated and interpreted as a bit string encoding of a binary little-endian two's complement number of bit length {PRODUCT}
the byte elements of {var} concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number
the byte elements of {var} concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary16 value
the byte elements of {var} concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary32 value
the byte elements of {var} concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary64 value
the canonical property value of {var} as given in the “Canonical property value” column of the corresponding row
the canonical {h_emu_not_ref_property_name} of {var} as given in the “Canonical {h_emu_not_ref_property_name}” column of the corresponding row
the character matched by {PROD_REF}
the character represented by {PROD_REF}
the character value of character {var}
the character whose character value is {var}
the code point obtained by applying the UTF-8 transformation to {var}, that is, from a List of octets into a 21-bit value
the code point whose numeric value is {EX}
the code point {var}
the concatenation of {var} and {var}
the element of {EX} whose {DSBN} field is {var}
the element of {EX} whose {DSBN} is {EX}
the empty CharSet
the empty sequence of Unicode code points
the extended mathematical value of {var}
the first element of {SETTABLE}
the fully populated data Property Descriptor for the property, containing the specified attributes for the property. For properties listed in {h_emu_xref}, {h_emu_xref}, or {h_emu_xref} the value of the {DSBN} attribute is the corresponding intrinsic object from {var}
the grammar symbol {nonterminal}
the greatest (closest to +∞) integral Number value that is not greater than {var}
the implementation-defined list-separator String value appropriate for the host environment's current locale (such as {STR_LITERAL})
the index into {var} of the character that was obtained from element {EX} of {var}
the index within {var} of the first such code unit
the integer value that is represented by {var} in radix-{var} notation, using the letters <b>A</b> through <b>Z</b> and <b>a</b> through <b>z</b> for digits with values 10 through 35
the integral Number closest to {var}, preferring the Number closer to +∞ in the case of a tie
the integral Number nearest {var} in the direction of *+0*{h_sub_fancy_f}
the intersection of CharSets {var} and {var}
the intrinsic function {percent_word}
the intrinsic object associated with the constructor name {DOTTING} in {h_emu_xref}
the largest integral Number {DEFVAR} (closest to +∞) such that {CONDITION_1}
the last Matcher in {var}
the last element of {var}
the list-concatenation of {EX} and {EX}
the list-concatenation of {EX}, {EX}, and {EX}
the longest prefix of {var} that satisfies the syntax of a {nonterminal}, which might be {var} itself. If there is no such prefix, return {NUMBER_LITERAL}
the mathematical value denoted by the result of replacing each significant digit in the decimal representation of {var} after the 20th with a 0 digit
the mathematical value denoted by the result of replacing each significant digit in the decimal representation of {var} after the 20th with a 0 digit and then incrementing it at the 20th position (with carrying as necessary)
the negation of {var}; that is, compute a Number with the same magnitude but opposite sign
the negative of {EX}
the number of bytes in {var}
the number of elements in the List {var}
the number of leading 1 bits in {var}
the number of leading zero bits in the unsigned 32-bit binary representation of {var}
the number of non-optional parameters of the function definition in {h_emu_xref}
the number of {h_emu_grammar} Parse Nodes contained within {var}
the number of {h_emu_grammar} Parse Nodes contained within {var} that either occur before {var} or contain {var}
the numeric value according to {h_emu_xref}
the one character in CharSet {var}
the other {EX} code units of {var}
the parse of some source text
the primary time zone identifier associated with {var}
the result of applying that mapping to {var}
the result of applying the bitwise AND operation to {var} and {var}
the result of applying the bitwise exclusive OR (XOR) operation to {var} and {var}
the result of applying the bitwise inclusive OR operation to {var} and {var}
the result of clamping {var} between 0 and {EX}
the result of converting {var} to IEEE 754-2019 binary16 format using roundTiesToEven mode
the result of converting {var} to IEEE 754-2019 binary32 format using roundTiesToEven mode
the result of converting {var} to IEEE 754-2019 binary64 format
the result of interpreting each of {var}'s 16-bit elements as a Unicode BMP code point. UTF-16 decoding is not applied to the elements
the result of parsing {var} as a date, in exactly the same manner as for the `parse` method ({h_emu_xref})
the result of performing a sign-extending right shift of {var} by {var} bits. The most significant bit is propagated. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string
the result of performing a zero-filling right shift of {var} by {var} bits. Vacated bits are filled with zero. The mathematical value of the result is exactly representable as a 32-bit unsigned bit string
the result of raising {EX} to the {EX} power
the result of {PP_NAMED_OPERATION_INVOCATION}
the running execution context
the second to top element of the execution context stack
the sequence of characters that is the single CharSetElement of {var}
the sequence of code points resulting from interpreting each of the 16-bit elements of {var} as a Unicode BMP code point. UTF-16 decoding is not applied to the elements
the smallest (closest to -∞) integral Number value that is not less than {var}
the sole element of {PP_NAMED_OPERATION_INVOCATION}
the sole element of {var}
the source text that was recognized as {PROD_REF}
the square root of the sum of squares of the mathematical values of the elements of {var}
the string-concatenation of {EX} and {EX}
the string-concatenation of {EX}, {EX}, and {EX}
the string-concatenation of {EX}, {EX}, {EX}, and {EX}
the string-concatenation of {EX}, {EX}, {EX}, {EX}, and {EX}
the string-concatenation of {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, and {EX}
the string-concatenation of {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, and {EX}
the string-concatenation of {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, {EX}, and {EX}
the surrounding agent's Agent Record
the ten-element CharSet containing the characters `0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, and `9`
the time value (UTC) identifying the current time
the topmost execution context on the execution context stack whose ScriptOrModule component is not {LITERAL}
the union of CharSets {var} and {var}
the union of CharSets {var}, {var} and {var}
the union of {var} and {var}
the value currently bound to {var} in {var}
the value that {var} corresponds to in {h_emu_xref}
the {nonterminal} that is covered by {LOCAL_REF}
the {nonterminal}, {nonterminal}, or {nonterminal} that most closely contains {var}
toLowercase({var}), according to the Unicode Default Case Conversion algorithm
toUppercase(« {var} »), according to the Unicode Default Case Conversion algorithm
{EX}
{EX} if {CONDITION}. Otherwise, it is {EXPR}
{EX}, where {DEFVAR} is {EX}
{EX}, where {DEFVAR} is {EX} and {DEFVAR} is {EX}
{EX}, where {DEFVAR} is {EX}, and {DEFVAR} is {EX}
{var}'s intrinsic object named {var}
{var}'s own property whose key is {var}
{var}'s single code unit element
{var}'s {DSBN} value
{var}<sup>th</sup> element of {EX}
{EX} :
! {var}
({EX})
*this* value
? {DOTTING}
? {var}
NewTarget
The number of elements in {var}
The remainder of dividing {EX} by {EX}
The value of {SETTABLE}
a newly created {ERROR_TYPE} object
a nondeterministically chosen byte value
an implementation-defined timezone name
the *this* value
the BigInt value for {EX}
the GlobalSymbolRegistry List
the Number value for {EX}
the String {var}
the character {SETTABLE}
the code point matched by {PROD_REF}
the code unit at index {EX} within {EX}
the code unit whose numeric value is determined by {PROD_REF} according to {h_emu_xref}
the code unit whose numeric value is {EX}
the current Realm Record
the digits of the decimal representation of {var} (in order, with no leading zeroes)
the empty sequence of characters
the escape sequence for {var} as specified in the “Escape Sequence” column of the corresponding row
the first code unit of {var}
the first {SUM} code units of {var}
the integer represented by the 32-bit two's complement bit string {var}
the internal slots listed in {h_emu_xref}
the largest integral Number < {var} for which {CONDITION_1} (i.e., {var} represents the last local time before the transition)
the last code point of {var}
the length of {var}
the number of code points in {PROD_REF}
the number of code points in {PROD_REF}, excluding all occurrences of {nonterminal}
the number of elements in {EX}
the numeric value of {EX}
the remainder of dividing {EX} by {EX}
the remaining {EX} code units of {var}
the result of left shifting {var} by {var} bits. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string
the single code point matched by this production
the source text matched by {PROD_REF}
the string in the “ControlEscape” column of the row whose “Code Point” column contains {var}
the substring of {var} from index {dec_int_lit}
the substring of {var} from {EX}
the substring of {var} from {EX} to {EX}
the value of {SETTABLE}
the {MATH_FUNC} of {EX}
{CONSTANT_NAME}
{DSBN}
{EX} occurrences of {code_unit_lit}
{LITERAL_ISH}
{LITERAL}
{LOCAL_REF}
{NUM_EXPR}
{PAIR}
{PP_NAMED_OPERATION_INVOCATION}
{RECORD_CONSTRUCTOR}
{h_code_quote}
« {EXLIST} »
« »
{MATH_FUNC} :
base 10 logarithm
base 2 logarithm
cosine
cube root
exponential function
hyperbolic cosine
hyperbolic sine
hyperbolic tangent
inverse cosine
inverse hyperbolic cosine
inverse hyperbolic sine
inverse hyperbolic tangent
inverse sine
inverse tangent
natural logarithm
sine