Mozilla

Just like in ECMAScript Edition 3, an identifier evaluates to an internal data structure called a reference. However, ECMAScript 4 references can be qualified by a qualifier, which, in the general syntax, is a ParenExpression that evaluates to a namespace. For convenience, if the ParenExpression consists of a single identifier, the parentheses may be omitted: (a)::m may be written as a::m.

The reserved words public and private may also be used as qualifiers. public evaluates to the public namespace. internal (which is not a reserved word) evaluates to the containing package’s anonymous namespace. private can only be used inside a class and evaluates to the containing class’s anonymous namespace.

See the name lookup section for more information on the :: operator.

Primary Expressions

PrimaryExpression

null

| true

| false

| Number

| String

| this

| RegularExpression

ReservedNamespace

public

| private

ParenExpression ( AssignmentExpression^allowIn )

ParenListExpression

ParenExpression

| ( ListExpression^allowIn , AssignmentExpression^allowIn )

public evaluates to the public namespace. private can be used only inside a class and evaluates to that class’s private namespace.

this may only be used in methods, constructors, or functions with the prototype attribute set.

Function Expressions

FunctionExpression

function FunctionCommon

| function Identifier FunctionCommon

A FunctionExpression creates and returns an anonymous function.

Object Literals

ObjectLiteral { FieldList }

FieldList

«empty»

| NonemptyFieldList

NonemptyFieldList

LiteralField

| LiteralField , NonemptyFieldList

LiteralField FieldName : AssignmentExpression^allowIn

FieldName

| String

| Number

| ParenExpression

The ParenExpression is evaluated at run time and its result coerced to a qualified name.

Array Literals

ArrayLiteral [ ElementList ]

ElementList

«empty»

| LiteralElement

| , ElementList

| LiteralElement , ElementList

LiteralElement AssignmentExpression^allowIn

Super Expressions

SuperExpression

super

| super ParenExpression

super, which may only be used inside a class C, can be applied to a subexpression that evaluates to an instance v of C. That subexpression can be either a ParenExpression or omitted, in which case it defaults to this.

As specified in the grammar below, the SuperExpression must be embedded as the left operand of a . (property lookup) or [] (indexing) operator. super changes the behavior of the operator in which it is embedded by limiting its property search to definitions inherited from class C’s superclass. See property lookup.

Postfix Expressions

PostfixExpression

| FullPostfixExpression

AttributeExpression

| AttributeExpression PropertyOperator

| AttributeExpression Arguments

FullPostfixExpression

| PostfixExpression [no line break] ++

| PostfixExpression [no line break] --

FullNewExpression new FullNewSubexpression Arguments

FullNewSubexpression

| QualifiedIdentifier

| FullNewSubexpression PropertyOperator

ShortNewExpression new ShortNewSubexpression

ShortNewSubexpression

FullNewSubexpression

A SimpleQualifiedIdentifier or ExpressionQualifiedIdentifier expression id resolves to the binding of id in the innermost enclosing scope that has a visible binding of id. If a qualifier q is present before the id, then the QualifiedIdentifier expression resolves to the binding of id in the innermost enclosing scope that has a visible binding of id in the namespace q.

Property Operators

PropertyOperator

. QualifiedIdentifier

| Brackets

Brackets

[ ]

| [ ListExpression^allowIn ]

| [ ExpressionsWithRest ]

Arguments

( )

| ( ExpressionsWithRest )

ExpressionsWithRest

RestExpression

| ListExpression^allowIn , RestExpression

RestExpression ... AssignmentExpression^allowIn

The . operator accepts a QualifiedIdentifier as the second operand and performs a property lookup.

The grammar allows the [] operator to take multiple arguments. However, all built-in objects take at most one argument. Implementation-defined host objects may take more arguments.

For most objects other than arrays and some host objects, the expression o[m] explicitly coerces m to a qualified name q and returns the result of o.q. See property lookup.

An argument list may contain a final argument preceded by .... That argument must be an Array and cannot be null. The elements of that array become additional arguments to the function, following the arguments preceding the ..., if any; the array itself is not passed as an argument. The array must not contain holes.

Unary Operators

UnaryExpression

| delete PostfixExpression

| void UnaryExpression

| typeof UnaryExpression

| ++ PostfixExpression

| -- PostfixExpression

| + UnaryExpression

| - UnaryExpression

| - NegatedMinLong

| ~ UnaryExpression

| ! UnaryExpression

The typeof operator returns a string as in ECMAScript 3. There is no way to query the most specific class of an object — all one can ask is whether an object is a member of a specific class.

Multiplicative Operators

MultiplicativeExpression

| MultiplicativeExpression * UnaryExpression

| MultiplicativeExpression / UnaryExpression

| MultiplicativeExpression % UnaryExpression

Additive Operators

AdditiveExpression

| AdditiveExpression + MultiplicativeExpression

| AdditiveExpression - MultiplicativeExpression

Bitwise Shift Operators

ShiftExpression

| ShiftExpression << AdditiveExpression

| ShiftExpression >> AdditiveExpression

| ShiftExpression >>> AdditiveExpression

Relational Operators

RelationalExpression^allowIn

| RelationalExpression^allowIn < ShiftExpression

| RelationalExpression^allowIn > ShiftExpression

| RelationalExpression^allowIn <= ShiftExpression

| RelationalExpression^allowIn >= ShiftExpression

| RelationalExpression^allowIn is ShiftExpression

| RelationalExpression^allowIn as ShiftExpression

| RelationalExpression^allowIn in ShiftExpression

| RelationalExpression^allowIn instanceof ShiftExpression

RelationalExpression^noIn

| RelationalExpression^noIn < ShiftExpression

| RelationalExpression^noIn > ShiftExpression

| RelationalExpression^noIn <= ShiftExpression

| RelationalExpression^noIn >= ShiftExpression

| RelationalExpression^noIn is ShiftExpression

| RelationalExpression^noIn as ShiftExpression

| RelationalExpression^noIn instanceof ShiftExpression

The expression a is b takes an expression that must evaluate to a type as its second operand b. When a is not null, the expression a is b returns true if a is a member of type b and false otherwise; this is equivalent to testing whether a can be stored in a variable of type b without coercion. When a is null, a is b behaves analogously to method dispatch and returns true if b is either Object or Null and false otherwise. As a special case, when a is –0.0 and b is sbyte, byte, short, ushort, int, or uint, a is b returns true.

The expression a as b returns a if a is a member of type b. Otherwise, if a can be implicitly coerced to type b, then the result is the result of that implicit coercion. Otherwise, a as b returns null if null is a member of type b or throws an exception otherwise. In any case b must evaluate to a type.

The instanceof operator behaves in the same way as in ECMAScript 3 — a instanceof b follows a’s prototype chain.

Equality Operators

EqualityExpression

| EqualityExpression == RelationalExpression

| EqualityExpression != RelationalExpression

| EqualityExpression === RelationalExpression

| EqualityExpression !== RelationalExpression

Binary Bitwise Operators

BitwiseAndExpression

| BitwiseAndExpression & EqualityExpression

BitwiseXorExpression

| BitwiseXorExpression ^ BitwiseAndExpression

BitwiseOrExpression

| BitwiseOrExpression | BitwiseXorExpression

Binary Logical Operators

LogicalAndExpression

| LogicalAndExpression && BitwiseOrExpression

LogicalXorExpression

LogicalAndExpression

| LogicalXorExpression ^^ LogicalAndExpression

The ^^ operator is a logical exclusive-or operator. It evaluates both operands. If they both convert to true or both convert to false, then ^^ returns false; otherwise ^^ returns the unconverted value of whichever argument converted to true.

LogicalOrExpression

LogicalXorExpression

| LogicalOrExpression || LogicalXorExpression

Conditional Operator

ConditionalExpression

| LogicalOrExpression ? AssignmentExpression : AssignmentExpression

NonAssignmentExpression

| LogicalOrExpression ? NonAssignmentExpression : NonAssignmentExpression

Assignment Operators

AssignmentExpression

| PostfixExpression CompoundAssignment AssignmentExpression

| PostfixExpression LogicalAssignment AssignmentExpression

CompoundAssignment

*=

| /=

| %=

| +=

| -=

| <<=

| >>=

| >>>=

| &=

| ^=

| |=

LogicalAssignment

&&=

| ^^=

| ||=

Comma Expressions

ListExpression

| ListExpression , AssignmentExpression

Type Expressions

TypeExpression NonAssignmentExpression

Compile-Time Constant Expressions

A compile-time constant expression is an expression that either produces an error or evaluates to a value that can be determined at compile time.

The reason that a compile-time constant expression is not guaranteed to always evaluate successfully at run time is that global name lookup cannot be guaranteed to succeed. It is possible for a program to import a package P that defines a global constant P::A that can be accessed as A and then dynamically define another top-level variable Q::A that collides with A. It does not appear to be practical to restrict compile-time constant expressions to only qualified names to eliminate the possibility of such collisions.

A compile-time expression can consist of the following:

null, numeric, boolean, and string constants.
Uses of the operators + (unary and binary), - (unary and binary), ~, !, *, /, %, <<, >>, >>>, <, >, <=, >=, is, as, in, instanceof, ==, !=, ===, !==, &, ^, |, &&, ^^, ||, ?:, and , as long as they are used only on numbers, booleans, strings, null, or undefined.
References to compile-time constants, subject to the restrictions below. The references may be qualified, but the qualifiers themselves have to be compile-time constant expressions.
Lookup of properties of compile-time expressions.
Calls to pure functions using compile-time expressions as arguments.

A pure function cannot have any read or write side effects or create any objects. A pure function’s result depends only on its arguments. An ECMAScript host embedding may define some pure functions. Currently there is no way for a script to define any such functions, but a future language extension may permit that.

A reference R to a definition D of a compile-time constant is allowed inside a compile-time constant expression as long as the conditions below are met. If D was imported from another package, then the location of D is considered to be the location of the import directive. If D is visible to R by virtue of an intervening use directive U, then the conditions below have to be satisfied both with respect to D and R and with respect to U and R.

D is visible to R.
There does not exist any scope between D’s scope and R’s scope that contains any declarations that can shadow D.
D was not hidden or made inaccessible by a conflict arising from another use directive between D and R.

Some compile-time constant expressions only allow references to definitions that are textually prior to the point of the reference. Other compile-time constant expressions allow forward references to later compile-time constant definitions.

Restrictions

ECMAScript 4 imposes the following restrictions:

TypeExpressions must be compile-time constant expressions that evaluate to types. Except for the TypeExpression specifying the superclass of a class, these expressions can contain forward references.
Attributes must be compile-time constant expressions that evaluate to attributes. These expressions cannot contain forward references when used as attributes of statements or directives.
const definitions defining constants that are used in compile-time constant expressions must have initializers that are themselves compile-time constant expressions. These initializers cannot contain forward references.
Default parameter values must be compile-time constant expressions. These expressions can contain forward references.
Initializers for instance members must be compile-time constant expressions. These expressions can contain forward references.
Each live import, class, and namespace directive must dominate the end of the program or package. This restriction limits these statements to the top level of the program, a top-level block, or a top-level conditional whose condition is known at compile time.
Each live declaration of a class member must dominate the end of the class definition.

A statement A dominates statement B if any of the following conditions are met:

A and B are the same statement.
A and B are in the same block, with A before B and no case or default labels between them.
Statement B is enclosed inside statement C and A dominates C.
Statement A is enclosed inside a block C, C is not prefixed by an attribute that evaluates to false, and C dominates B.

Note that the above definition is conservative. If statement A dominates statement B, then it is guaranteed that, if B is executed then A must have been executed earlier; however, there may be some other statements A' that also are guaranteed to have been executed before B but which do not dominate B by the above definition.

A statement A is dead if any of the following conditions are met:

A is prefixed by an attribute that evaluates to false.
There exists a break, continue, return, or throw statement B such that statements A and B are in the same block with B before A and no case or default labels between them.
A is enclosed inside statement B and B is dead.

Note that the above definition is conservative. If a statement is dead, then it is guaranteed that it cannot be executed; however, there may be statements that cannot be executed that are not dead by the above definition.

A statement is live if it is not dead.

ECMAScript 4 Netscape Proposal

Core Language

Statements

Wednesday, June 4, 2003

Statements

Most of the behavior of statements is the same as in ECMAScript 3. Differences are highlighted below.

{abbrev, noShortIf, full}

Statement

ExpressionStatement Semicolon

| SuperStatement Semicolon

| Block

| LabeledStatement

| IfStatement

| SwitchStatement

| DoStatement Semicolon

| WhileStatement

| ForStatement

| WithStatement

| ContinueStatement Semicolon

| BreakStatement Semicolon

| ReturnStatement Semicolon

| ThrowStatement Semicolon

| TryStatement

Substatement

| Statement

| SimpleVariableDefinition Semicolon

| Attributes [no line break] { Substatements }

Substatements

«empty»

| SubstatementsPrefix Substatement^abbrev

SubstatementsPrefix

«empty»

| SubstatementsPrefix Substatement^full

Semicolon^abbrev

;

| VirtualSemicolon

| «empty»

Semicolon^noShortIf

;

| VirtualSemicolon

| «empty»

Semicolon^full

;

| VirtualSemicolon

A Substatement is a statement directly contained by one of the compound statements label:, if, switch, while, do while, for, or with (but not a block). A substatement cannot be a directive except that, in non-strict mode only, it can be a var definition without attributes or types.

A substatement can also consist of one or more attributes applied to a group of substatements enclosed in braces. The attributes must evaluate to either true or false. The braces do not form a scope in this case.

The Semicolon productions allow both grammatical and line-break semicolon insertion.

Empty Statement

EmptyStatement ;

Expression Statement

ExpressionStatement [lookahead{function, {}] ListExpression^allowIn

Super Statement

SuperStatement super Arguments

The super statement calls the superclass’s constructor. It can only be used inside a class’s constructor.

Block Statement

Block { Directives }

A block groups statements and forms a scope.

Labeled Statements

LabeledStatement Identifier : Substatement

If Statement

IfStatement^abbrev

if ParenListExpression Substatement^abbrev

| if ParenListExpression Substatement^noShortIf else Substatement^abbrev

IfStatement^full

if ParenListExpression Substatement^full

| if ParenListExpression Substatement^noShortIf else Substatement^full

IfStatement^noShortIf if ParenListExpression Substatement^noShortIf else Substatement^noShortIf

The semicolon is optional before the else.

Switch Statement

SwitchStatement switch ParenListExpression { CaseElements }

CaseElements

«empty»

| CaseLabel

| CaseLabel CaseElementsPrefix CaseElement^abbrev

CaseElementsPrefix

«empty»

| CaseElementsPrefix CaseElement^full

CaseElement

Directive

| CaseLabel

CaseLabel

case ListExpression^allowIn :

| default :

Do-While Statement

DoStatement do Substatement^abbrev while ParenListExpression

The semicolon is optional before the closing while.

While Statement

WhileStatement while ParenListExpression Substatement

For Statements

ForStatement

for ( ForInitializer ; OptionalExpression ; OptionalExpression ) Substatement

| for ( ForInBinding in ListExpression^allowIn ) Substatement

ForInitializer

«empty»

| ListExpression^noIn

| VariableDefinition^noIn

| Attributes [no line break] VariableDefinition^noIn

ForInBinding

| VariableDefinitionKind VariableBinding^noIn

| Attributes [no line break] VariableDefinitionKind VariableBinding^noIn

OptionalExpression

ListExpression^allowIn

| «empty»

A for statement forms a scope. Any definitions in it (including the ForInitializer and ForInBinding) are visible inside the for statement and its substatement, but not outside the for statement. However, a var definition inside a for statement may be hoisted to the nearest enclosing regional scope.

With Statement

WithStatement with ParenListExpression Substatement

Continue and Break Statements

ContinueStatement

continue

| continue [no line break] Identifier

BreakStatement

break

| break [no line break] Identifier

Return Statement

ReturnStatement

return

| return [no line break] ListExpression^allowIn

A return statement can only be used inside a function or constructor. The return statement cannot have an expression if used inside a constructor or a setter.

Throw Statement

ThrowStatement throw [no line break] ListExpression^allowIn

Try Statement

TryStatement

try Block CatchClauses

| try Block CatchClausesOpt finally Block

CatchClausesOpt

«empty»

| CatchClauses

CatchClauses

CatchClause

| CatchClauses CatchClause

CatchClause catch ( Parameter ) Block

Each CatchClause forms a scope. The Parameter, if any, is defined as a local variable visible only within the CatchClause.

The Blocks following try and finally are also scopes like other Block statements.

Directives

Directive

| Statement

| AnnotatableDirective

| Attributes [no line break] AnnotatableDirective

| Attributes [no line break] { Directives }

| Pragma Semicolon

AnnotatableDirective

VariableDefinition^allowIn Semicolon

| FunctionDefinition

| ClassDefinition

| NamespaceDefinition Semicolon

| ImportDirective Semicolon

| UseDirective Semicolon

Directives

«empty»

| DirectivesPrefix Directive^abbrev

DirectivesPrefix

«empty»

| DirectivesPrefix Directive^full

Attributes can be applied to a group of directives by following them by a {, the directives, and a }. The attributes apply to all of the enclosed directives. The attribute true is ignored. The attribute false causes all of the enclosed directives to be omitted. When used this way, the braces do not form a block or a scope.

Annotated groups are useful to define several items without having to repeat attributes for each one. For example,

class foo {
  var z:Integer;
  public var a;
  private var b;
  private function f() {}
  private function g(x:Integer):Boolean {}
}

is equivalent to:

class foo {
  var z:Integer;
  public var a;
  private {
    var b;
    function f() {}
    function g(x:Integer):Boolean {}
  }
}

Programs

Program

Directives

| PackageDefinition Program

ECMAScript 4 Netscape Proposal

Core Language

Definitions

Thursday, May 22, 2003

Introduction

Definitions are directives that introduce new constants, variables, functions, classes, namespaces, and packages. All definitions except those of packages can be preceded by zero or more attributes. In non-strict mode there must not be any line breaks between the attributes or after the last attribute.

Attributes

Attribute

AttributeCombination Attribute [no line break] Attributes

Attribute

| true

| false

An attribute is an expression (usually just an identifier) that modifies a definition’s meaning. Attributes can specify a definition’s scope, namespace, semantics, and other hints. An ECMAScript program may also define and subsequently use its own attributes. Attributes can be qualified identifiers (as long as they don’t start with a () and dotted and function call expressions, but they must be compile-time constants.

The table below summarizes the predefined attributes.

Category	Attributes	Behavior
Namespace	`private` `internal` `public`	Makes the definition visible only in the enclosing class’s private namespace (`private`), the enclosing package’s private namespace (`internal`), or anywhere (`public`).
Visibility Modifier	`enumerable`	This definition can be seen using a `for`-`in` statement.
Visibility Modifier	`explicit`	This top-level definition is not shared via an `import` directive.
Class Modifier	`final`	This class cannot be subclassed. Can be used only on classes.
Class Modifier	`dynamic`	Direct instances of this class can contain dynamic properties. Can be used only on classes.
Member Modifier	`static` `virtual` `final`	The definition creates a global member (`static`) or instance member (`virtual` or `final`) of the enclosing class. If defining an instance member, the definition can (`virtual`) or cannot (`final`) be overridden in subclasses. Can be used only on class members.
Member Modifier	`override` `override(true)` `override(false)` `override(undefined)`	Assertion that the definition overrides (`override` or `override(true)`), may override (`override(undefined)`), or does not override (`override(false)`) a member of a superclass. Can be used only on class members. Controls errors only.
Conditional	`true` `false`	The definition or directive is (`true`) or is not (`false`) processed.
Miscellaneous	`prototype`	Allows a function to access `this` and be used as a prototype-based constructor.
Miscellaneous	`unused`	Assertion that the definition is not used.

Multiple conflicting attributes cannot be used in the same definition, so virtual final private is an error. The attributes true and false do not conflict. Specifying an attribute more than once has the same effect as specifying it once.

Namespace Attributes

Namespace attributes control the definition’s visibility. User-defined attributes provide a finer grain of visibility control.

Every package P has a predefined, anonymous namespace PackageInternal_P. That namespace is attached to all definitions with the internal attribute in that package. Package P’s scope includes an implicit use namespace(PackageInternal_P) definition around the package that grants access to these definitions from within the package only.

Every class C has a predefined, anonymous namespace ClassInternal_C. That namespace is attached to all definitions with the private attribute in that class. Class C’s scope includes an implicit use namespace(ClassInternal_C) definition around the class that grants access to these definitions from within that class only. private can only be used inside a class.

Namespace attributes, including user-defined namespaces, are additive; if several are given for a definition, then that definition is put into each of the designated namespaces. Thus, a single definition may define a name in two or more namespaces namespace₁ and namespace₂ by listing the namespaces as attributes: namespace₁ namespace₂ var x. Such multiple definitions are aliases of each other; there is only one storage location x.

A definition of a name id is always put into the namespaces explicitly specified in the definition’s attributes. In addition, the definition may be placed in additional namespaces according to the rules below:

If the definition explicitly specifies one or more namespaces N:
- If the definition defines an instance member in a class C and one of C’s ancestors contains an instance member M with name id and at least one of the namespaces in N, then the definition will override M and be placed in all of M’s namespaces. It is an error if N contains another namespace that is not in M’s namespaces.
- Otherwise, the definition is put into each of the namespaces in N; however, to avoid confusion the override(false) or override(undefined) attribute is required on the definition if an inherited instance member with the name id is visible at the point of the definition. This restriction prevents one from accidentally defining a private instance member with the same name as a public instance member in a superclass (by the rules of member lookup, such a private member would be shadowed by the existing public member for all unqualified accesses).
If the definition does not explicitly specify any namespaces:
- If the definition is in a class C and one of C’s ancestors contains a visible member M with name id, then the definition will override M and be placed in all of M’s namespaces. It is an error to attempt to override two different members with one definition.
- Otherwise, the definition is put into the public namespace.

Visibility Modifier Attributes

Visibility modifier attributes control the definition’s visibility in several special cases.

`enumerable`

An enumerable definition can be seen by the for-in iteration statement. A non-enumerable definition cannot be seen by such a statement. enumerable only applies to public definitions.

The default for dynamic properties and class properties is enumerable. The default for instance properties is non-enumerable. There is no way to make a user-defined dynamic or class property non-enumerable.

`explicit`

explicit is used to add definitions to a package P without having them conflict with definitions in other packages that import package P. explicit prevents the definition from being accessed as a top-level variable when a package is imported. The definition can still be accessed as a property of an object. For example,

package My.P1 {
  const c1 = 5;
  explicit const c2 = 7;
}

package My.P2 {
  import P = My.P1;  // Imports My.P1 without qualification
  c1;                // OK; evaluates to 5
  c2;                // Error: c2 not defined because explicit variables are not shared
  P.c2;              // OK: explicit properties are visible
}

Class Modifier Attributes

Class modifier attributes apply to the definition of a class C itself. They may only be used on definitions of classes.

`final`

If a class C is defined using the final attribute, then any attempt to define a subclass of C signals an error.

Note that final is also a member modifier — when used on a class member, final makes that member nonoverridable. If final is used on a class member that is itself a class, then it acts like a class modifier instead of a member modifier — it prevents the inner class from being subclassed.

`dynamic`

Direct instances of a dynamic class C can contain dynamic properties. Other instances cannot contain dynamic properties. A class is dynamic if it has the dynamic attribute or it has a dynamic ancestor other than Object.

Member Modifier Attributes

Member modifier attributes modify a class member definition’s semantics with respect to a class hierarchy. They may only be used on a definition of a member M of a class C. They cannot be used on definitions that, for example, create local variables inside a function.

`static`, `virtual`, and `final`

The static attribute makes M be a global member of C.

The virtual and final attributes make M be an instance member of C.

The final attribute prevents subclasses from defining their own members with the name M (unless they can’t see this M, in which case they can define an independent M). virtual allows subclasses to override M.

The default setting for the definition of a member M of a class named C is:

Default Attribute	Kind of Member `M`
none — the function is treated specially as a class constructor	`function` `C`
`virtual`	`function` `F` where the name `F` differs from `C`
`final`	`var` and `const` definitions
none — `static` attribute must be specified explicitly	`class` and `namespace` definitions

These attributes may not be used on an export definition, since export reuses the original member’s setting.

Note that final is also a class modifier — when used on a class member M, final prevents M from being subclassed rather than making M be a nonoverridable instance member of C.

`override`

The override attribute reports errors; it has no other effect on the behavior of the program. The override attribute can only be used on definitions in a class and describes the programmer’s intent to either override or not override a member from a superclass. If the actual behavior, as defined by the namespace defaulting and overriding rules, differs, then an error is signaled.

The table below describes the behavior of when a definition of a member M with name id is placed in a class C:

	Override attribute given
	None	`override` or `override(true)`	`override(undefined)`	`override(false)`
`M` overrides a member in some superclass according to the namespace defaulting and overriding rules	Error	OK	OK	Error
`M` does not override anything but there exists an ancestor of `C` with a member with name `id` visible at the point of definition of `M`	Error	Error	OK	OK
`M` does not override anything and no ancestor of `C` has a member with name `id` visible at the point of definition of `M`	OK	Error	OK	OK

The middle case arises for example when an ancestor of a class C defines a public member named X and class C attempts to define a private member named X.

Conditional Attributes

An attribute whose value is true causes the definition or directive to be evaluated normally. An attribute whose value is false causes the definition or directive to be skipped; the remaining attributes and the body of the definition or directive are not evaluated. These are useful for turning definitions on and off based on configuration settings, such as:

const debug = true;
const nondebug = !debug;

debug var nCalls = 0;
debug function checkConsistency() {...}

Miscellaneous Attributes

`prototype`

The prototype attribute can only be used on a function. A function with this attribute treats this in the same manner as ECMAScript 3 and defines its own prototype-based class as in ECMAScript 3. By default, the prototype attribute is set on any unchecked function. It can be set explicitly on other functions as long as they are not getters, setters, or constructors.

`unused`

The unused attribute is a hint that the definition is not referenced anywhere. Referencing the definition will generate an error.

User-Defined Attributes

A user-defined attribute may be defined using a const definition or other definitions that define constants. All attributes must be compile-time constants. For example:

const ipriv = internal static;
explicit namespace Version1;
explicit namespace Version2;
internal const Version1and2 = Version1 Version2;

class C {
  ipriv var x;                          // Same as internal static var x;
  Version1and2 var simple;              // Same as Version1 Version2 var simple;
  Version2 var complicated;
  ipriv const a:Array = new Array(10);

  private var i;
  for (i = 0; i != 10; i++) a[i] = i;
}

Definition Scope

A definition applies to the innermost enclosing scope except when it is hoisted. If that scope is a class, the definition appears as a member of that class. If that scope is a package, the definition appears as a member of that package.

Scope Hoisting

For compatibility with ECMAScript 3, in some cases a definition’s scope is hoisted to the innermost regional scope R instead of the innermost scope S. This happens only when all of the conditions below are met:

The definition is a var definition.
The definition does not specify a type.
The definition has no attributes other than true.
The regional scope R is not a class.
Strict mode is not in effect.

When a definition of n is hosted, the effect is as though n were declared (but not initialized) at the top of the regional scope R.

Definitions not meeting the above criteria are not hoisted. However, an inner non-hoisted definition of name n in scope S within regional scope R prevents n from being referenced or defined in any scope within R but outside S; see definition conflicts.

Extent

A definition extends an activation frame with one or more bindings of qualified names to values. The bindings are generally visible from the activation frame’s scope. However, a definition may be invisible or partially invisible inside its scope either because it is shadowed by a more local definition or it uses a namespace that is not used. The name lookup rules specify the detailed behavior of accessing activation frame bindings.

Each definition or declaration D of a name n applies to some scope S using the rules above. Any of S’s activation frames will contain a binding for n as soon as S is entered. That binding starts in the following state:

In non-strict mode, a var n definition D without a type or attributes is initialized to the value undefined upon entry into S.
In non-strict mode, a function n definition D without types or attributes is initialized to its closure upon entry into S instead of at the time D is executed.
A class definition D of a name n in scope S binds n to an opaque value V of type Type upon entry into S. V may be used as a type to declare variables, but all other operations are prohibited. V becomes the actual class object at the time the definition is executed, after which point instances of V may be created and subclasses may be derived from V.
All other definitions produce bindings in the uninitialized state upon entry into the scope S. The bindings are initialized at the time the definition is executed.

Accessing an activation frame binding in the uninitialized state is an error. If this happens, implementations are encouraged to throw an exception, but may return a value V if they can prove that the definition would assign the value V to the binding.

Definition Conflicts

In general, it is not legal to rebind the same name in the same namespace within an activation frame A. There are a couple exceptions:

Multiple var definitions (which may be hoisted) are allowed in a regional scope as long as all such definitions have no type and no attributes and strict mode is not in effect.
A getter and a setter with the same name may be defined independently.

In addition, if a name n is defined in a scope S inside regional scope R, then it is not permitted to access a definition of n made outside of R from anywhere inside R. Also, two nested scopes S₁ and S₂ located inside the same regional scope R cannot both define n (S₁, S₂, and R may be the same scope). In either of these situations, n may be hoisted; if hoisting is not allowed, an error occurs. For example,

const b:Integer = 1;

function f(c:Boolean):Integer {
  const a = b;  // Error: b is defined inside the local scope below, which prevents accesses to global b
                // from anywhere inside the regional scope
  if (c) {
    const b:Integer = a + 10;  // OK to hide the global b from here.
    return b;
  }
  return a;
}

function g(c:Boolean):Integer {
  const b = 3;  // OK to hide the global b from here.
  if (c) {
    const b:Integer = 10;  // Error: can’t redefine b inside the same regional scope.
    return b;
  }
  return b;
}

function h(c:Boolean):Integer {
  if (c) {
    const b:Integer = 10;  // OK to hide the global b from here.
    return b;
  } else {
    const b:Integer = 42;  // OK: Two independent local definitions of b.
    return b;
  }
}

To help catch accidental redefinitions, binding a qualified name q::n in activation frame A when there is already a binding r::n in A causes an error if both namespaces q and r are used at the point of the definition of q::n and the bindings are not aliases of each other. This prevents the same name from being used for both public and private variables in the same class. Two bindings sharing the same name but with different namespaces may still be introduced into an activation frame, but only by code that does not use one or both of the namespaces.

Examples

In the example below the comments indicate the scope and namespace of each definition:

var a0;                  // Public global variable
internal const a1 = true;// Package-visible global variable
private var a2;          // Error: private can only be used inside a class
public var a3 = b1;      // Public global variable

if (a1) {
  var b0;                // Local to this block
  var b1;                // Hoisted to the global level because of the reference to b1 in the definition of a3
}

if (a1) {
  var b0;                // Local to this block
}

public function F() {    // Public global function
  var c0;                // Local to this function
  internal var c1;       // Local to this function (may generate a style warning)
  public var c2;         // Local to this function (may generate a style warning)
}

class C {                // Public global class
  var e0;                // Public class instance variable
  private var e1;        // Class-visible class instance variable
  internal var e2;       // Package-visible class instance variable
  public var e3;         // Public class instance variable
  static var e4;         // Public class-global variable
  private static var e5; // Class-visible class-global variable
  internal static var e6;// Package-visible class-global variable
  public static var e7;  // Public class-global variable

  if (a1) {
    var f0;              // Local to this block
    private var f1;      // Local to this block (may generate a style warning)
  }
  public function I() {} // Public class method
}

Discussion

Should we have a protected Attribute? It has been omitted for now to keep the language simple, but there does not appear to be any fundamental reason why it could not be supported. If we do support it, it might be better to choose the C++ protected concept (visible only in class and subclasses); the Java protected concept (visible in class, subclasses, and the original class’s package) could be represented as internal protected.

ECMAScript 4 Netscape Proposal

Core Language

Variables

Wednesday, June 4, 2003

Variable Definitions

VariableDefinition VariableDefinitionKind VariableBindingList

VariableDefinitionKind

var

| const

VariableBindingList

VariableBinding

| VariableBindingList , VariableBinding

VariableBinding TypedIdentifier VariableInitialisation

VariableInitialisation

«empty»

| = VariableInitializer

VariableInitializer

TypedIdentifier

Identifier

| Identifier : TypeExpression

A SimpleVariableDefinition represents the subset of VariableDefinition expansions that may be used when the variable definition is used as a Substatement instead of a Directive in non-strict mode. In strict mode variable definitions may not be used as substatements.

SimpleVariableDefinition var UntypedVariableBindingList

UntypedVariableBindingList

UntypedVariableBinding

| UntypedVariableBindingList , UntypedVariableBinding

UntypedVariableBinding Identifier VariableInitialisation^allowIn

A variable defined with var can be modified, while one defined with const is read-only after its value is set. Identifier is the name of the variable and TypeExpression is its type. Identifier can be any non-reserved identifier. TypeExpression must be a compile-time expression that evaluates to a type t other than Never. TypeExpression may contain forward references to compile-time constants defined later in the program.

If provided, AssignmentExpression gives the variable’s initial value v. If AssignmentExpression is not provided in a var definition, then undefined is assumed. If the variable being defined is not an instance member of a class, then the AssignmentExpression is evaluated at the time the variable definition is evaluated. The resulting value is then implicitly coerced to the variable’s type t and stored in the variable. If the variable is defined using var, any values subsequently assigned to the variable are also implicitly coerced to type t at the time of each such assignment. If the variable is an instance member of a class, then the AssignmentExpression is evaluated each time an instance of the class is constructed.

Reading or writing a variable before its definition is evaluated signals an error except when the variable definition has no attributes and no type and strict mode is not in effect; in that case, the variable may be read or written prior to its definition being evaluated and its initial value is undefined.

Multiple variables separated by commas can be defined in the same VariableDefinition. The values of earlier variables are available in the AssignmentExpressions of later variables.

If omitted, TypeExpression defaults to type Object. Thus, the definition

var a, b=3, c:Integer=7, d, e:Integer, f:Number=c;

is equivalent to:

var a:Object = undefined;
var b:Object = 3;
var c:Integer = 7;
var d:Object = undefined;
var e:Integer = undefined; // Implicitly coerced to NaN
var f:Number = c; // 7

The compiler might issue a warning for a VariableDefinition that contains an untyped variable prior to a typed variable to remind programmers that the type of d is Object rather than Integer in var d, e:Integer.

Constant Definitions

const means that assignments to Identifier are not allowed after the constant has been set. Once defined, a constant cannot be redefined in the same scope, even if the redefinition would be to the same value. If the VariableBinding in a const declaration does not contain an initializer, then the constant may be written once after it is defined. Any attempt to read the constant prior to writing its value will result in an error. For example:

function f(x) {return x+c}

f(3);           // Error: c’s value is not defined
const c = 5;
f(3);           // Returns 8
const c = 5;    // Error: redefining c

Just like any other definition, a constant may be rebound after leaving its scope. For example, the following is legal; j is local to the block, so a new j binding is created each time through the loop:

var k = 0;
for (var i = 0; i < 10; i++) {
  const j = i;
  k += j;
}

A const definition defines a compile-time constant if it has an initializer and that initializer is a compile-time constant expression which may contain forward references to other compile-time constants.

In order for the compiler to be able to distinguish const definitions that define run-time constants from ones that define compile-time constants, it must be able to resolve each variable referenced in a const initializer to a scope. Because of this, a const initializer may only refer to variables declared at compile time; referring to a dynamically created variable not declared at compile time results in a compile-time error. It is also an error to attempt to create a dynamic variable that changes the resolution of a variable in a const initializer. For example:

const a = 5; // OK: a is a compile-time constant with the value 5const b = a + c; // OK: b is a compile-time constant with the value 7const c = 2; // OK: c is a compile-time constant with the value 2const d = e; // OK: d is a run-time constant that starts as undefined var e = 2.718281828459045; f = "Run time"; const g = f; // Error: f is not declared at compile timeconst h = uint; // OK: h is a compile time constant that holds the type uint this.ulong = 15; // OK: creates the global property ulong that shadows the system ulong typethis.uint = 15; // Error: can’t create the global property uint because it would // change the resolution of uint in the definition of h

Inside a class, const preceded by final defines an instance member. Preceding it with virtual would also define an instance member, but is only useful if one wants subclasses to be able to override the constant. Precede it with static to define a global member. The default is final.

If const is declaring an instance member m of a class, then the initializer is evaluated each time an instance of the class is constructed. If absent, then the member’s property may be written exactly once, cannot be re-written after it has been written, and must be written before it can be read. For example:

class C {
  static const red = 0xFF0000;      // Defines static constant C.red
  static const green = 0x00FF00;    // Defines static constant C.green
  static const blue = 0x0000FF;     // Defines static constant C.blue
  static const infrared;            // Defines uninitialized static constant C.infrared

  const myColor;                    // Defines instance constant C::myColor with value set by the constructor
  final const yourColor;            // Defines instance constant C::yourColor with value set by the constructor
  const ourColor = 0;               // Defines instance constant C::ourColor that is always zero (not very useful)
  virtual const theirColor = 0;     // Defines instance constant C::theirColor that can be overridden by subclasses

  function C(x:int) {
    myColor = x;                    // Sets this instance’s myColor
    ourColor = x;                   // Error: ourColor is already set to 0
    myColor = x;                    // Error: myColor can be set only once
    var a = [x, this];
    a[1].yourColor = x;             // Sets this instance’s yourColor
  }
}

Getters and Setters

A definition var x:t = v internally creates a hidden variable and defines a getter and a setter to access that variable:

Evaluate t, which should evaluate to a type.
Create an anonymous variable .
Implicitly coerce undefined to type t (such a coercion must exist for every type) and assign the result to .
Define a getter function get x():t {return }.
Define a setter function set x(a:t):Void { = a}.
Evaluate v, implicitly coerce it to type t, and assign the result to .

A definition const x:t = v internally creates a hidden variable and defines a getter to access that variable:

Evaluate t, which should evaluate to a type.
Create an anonymous variable .
Define a getter function get x():t {return }.
Define a setter function set x(a:t):Never {throw ConstWriteError}.
Evaluate v, implicitly coerce it to type t, and assign the result to .

This relationship between a variable and its getter and setter is normally transparent but can be exploited occasionally. For instance, a variable can be declared that is private for writing but public for reading:

private var name:String;
public export get name;

A subclass may override a variable’s getter or setter. To do this, the original variable has to be declared non-final because variables are final by default:

class C {
  virtual var x:Integer;
  var y:Integer;
}

class D extends C {
  override function set x(a:Integer):Integer {y = a*2}
}

var c = new C;
c.x = 5;
c.x;       // Returns 5
c.y;       // Returns NaN (the default value for an Integer variable)
var d = new D;
d.x = 5;
d.x;       // Returns NaN
d.y;       // Returns 10

ECMAScript 4 Netscape Proposal

Core Language

Functions

Monday, April 28, 2003

Syntax

FunctionDefinition function FunctionName FunctionCommon

FunctionName

Identifier

| get [no line break] Identifier

| set [no line break] Identifier

FunctionCommon ( Parameters ) Result Block

Like other definitions, a function definition may be preceded by one or more attributes, which affect the function’s scope, namespace, and semantics. Every function (except a getter or a setter) is also a value and has type Function.

Unless a function f is defined with the prototype attribute (either explicitly or by default because f is unchecked), that function does not define a class, f’s name cannot be used in a new expression, and f cannot refer to this unless f is an instance method or constructor of a class.

A FunctionDefinition can specify a function, getter (if its name is preceded by get), or setter (if its name is preceded by set).

Parameters give the names and the types of the function’s parameters. Result gives the type of the function’s result. The Block contains the function body and is evaluated only when the function is called.

Parameter Declarations

A function may take zero or more parameters and an optional rest parameter. Optional parameters may follow but not precede required parameters (this condition is not in the grammar but is checked by the formal semantics).

Parameters

«empty»

NonemptyParameters

ParameterInit

Individual parameters have the forms:

Parameter ParameterAttributes TypedIdentifier^allowIn

ParameterAttributes

«empty»

| const

ParameterInit

Parameter

| Parameter = AssignmentExpression^allowIn

RestParameter

...

| ... ParameterAttributes Identifier

The TypeExpression gives the parameter’s type and defaults to type Object. The TypeExpression must evaluate to a type other than Never.

If a Parameter is followed by a =, then that parameter is optional. If a function call does not provide an argument for an optional parameter, then that parameter is set to the value of its AssignmentExpression, implicitly coerced to the parameter’s type if necessary. The AssignmentExpression must be a compile-time constant.

If a Parameter is prefixed with const, then the parameter is declared using const instead of var. The effect is that the parameter’s value cannot be changed from within the function. Without the const, the function can change the parameter’s value, which, however, has no effect on the argument.

If a function call does not provide an argument for a required Parameter, then an error occurs unless the function is unchecked, in which case the parameter gets the value undefined, implicitly coerced to the parameter’s type if necessary.

The parameters’ Identifiers are local variables with types given by the corresponding TypeExpressions inside the function’s Block. Code in the Block may read and write these variables. Arguments are passed by value, so writes to these variables do not affect the passed arguments’ values in the caller.

Attempting to define a function with two different parameters with the same name is an error.

Rest Parameter

If the ... is present, the function accepts arguments not matched by any of the other listed parameters. If a parameter is given after the ..., then that parameter’s identifier is bound to an array of all remaining arguments. That identifier is declared as a local var or const using the type Array. The remaining arguments are stored as elements of the rest array with numeric indices starting from 0.

Each unchecked function also has a predefined const arguments local variable which holds an array (of type Array) of all arguments passed to this function.

Result Type

Result

«empty»

| : TypeExpression^allowIn

The function’s result type is TypeExpression, which defaults to type Object if not given. The TypeExpression must evaluate to a type.

If the function does not return a useful value, it’s good practice to set TypeExpression to Void to document this fact. If the function cannot return at all (it either always falls into an infinite loop or throws an exception), then it’s good practice to set TypeExpression to Never to document this fact; this also lets the compiler know that code after a call to this function is unreachable, which can help cut down on spurious warnings.

Evaluation Order

A function’s parameter and result TypeExpressions are evaluated at the time the function definition or declaration is executed. These types are then saved for use in argument and result coercions at the time the function is called.

The static and dynamic extent of a parameter includes all subsequent parameters’ and the result type’s TypeExpressions and AssignmentExpressions. However, the case where a subsequent parameter’s or the result type’s TypeExpression or AssignmentExpression references a prior parameter is reserved for a future language extension. For now, an implementation should raise an error in this case:

const t = Integer;
function choice(a:Boolean, t:Type, c:t, d:t):t {
  return a ? c : d;
}

This definition of choice should (for now) be an error and not:

function choice(a:Boolean, t:Type, c:Integer, d:Integer):Integer {
  return a ? c : d;
}

The intent is that a future language extension might make the first definition of choice legal and permit calls to it like choice(true,String,"Be","Not Be"), which would return "Be".

When a function is called, the following list indicates the order of evaluation of the various expressions in a FunctionDefinition. These steps are taken only after all of the argument names and values have been evaluated.

If the function is unchecked, bind the arguments local variable to an array of all arguments and their names.
Get the saved type t that was the result of evaluating the first parameter’s TypeExpression at the time the function was defined.
If the first parameter is required and no argument has been supplied for it, then raise an error unless the function is unchecked, in which case let undefined be the first parameter’s value.
If the first parameter is optional and there is an argument remaining, use the value of the argument. If there are no remaining arguments, then evaluate the first parameter’s AssignmentExpression and let it be the first parameter’s value.
Implicitly coerce the argument (or default) value to type t and bind the parameter’s Identifier to the result.
Repeat steps 2-5 for each additional parameter.
If there is a RestParameter with an Identifier, bind that Identifier to an array of the remaining arguments using indices starting from 0.
If there is no RestParameter and any arguments remain, raise an error unless the function is unchecked.
Evaluate the body.
Get the saved type r that was the result of evaluating the result TypeExpression at the time the function was defined.
Implicitly coerce the result to type r and return it.

Getters and Setters

If a FunctionName contains the keyword get or set, then the defined function is a getter or a setter.

A getter must not take any parameters. Unlike an ordinary function, a getter is invoked by merely mentioning its name without an Arguments list in any expression except as the destination of an assignment. For example, the following code returns the string “<2,3,1>”:

var x:Integer = 0;
function get serialNumber():Integer {return ++x}

var y = serialNumber;
return "<" + serialNumber + "," + serialNumber + "," + y + ">";

A getter must either evaluate a return statement or throw an exception; it cannot fall off the end without returning a value.

A setter must take exactly one required parameter. Unlike an ordinary function, a setter is invoked by merely mentioning its name (without an Arguments list) on the left side of an assignment or as the target of a mutator such as ++ or --. The setter should not return a value and should be declared as returning type Void or Never. The result of an assignment expression is the argument passed to the setter. For example, the following code returns the string “<1,2,42,43>”:

var x:Integer = 0;
function get serialNumber():Integer {return ++x}
function set serialNumber(n:Integer):Void {x=n}

var s = "<" + serialNumber + "," + serialNumber;
s += "," + (serialNumber = 42);
return s + "," + serialNumber + ">";

A setter cannot return a value; it may invoke a return statement as long as that statement does not supply an expression.

A setter can have the same name as a getter in the same lexical scope. A getter or setter cannot be extracted from its variable, so the notion of the type of a getter or setter is vacuous; a getter or setter can only be called.

Contrast the following:

var x:Integer = 0;
function f():Integer {return ++x}
function g():Function {return f}
function get h():Function {return f}

f;     // Evaluates to function f
g;     // Evaluates to function g
h;     // Evaluates to function f (not h)
f();   // Evaluates to 1
g();   // Evaluates to function f
h();   // Evaluates to 2
g()(); // Evaluates to 3

Unchecked Functions

An unchecked function relaxes argument checking. Unchecked function definitions are provided for compatibility with ECMAScript 3.

A function definition is unchecked if all of the following are true:

strict mode is disabled at the point of the function definition;
the function is not a class member;
the function has no optional or rest parameters;
none of the function’s parameters has a declared type;
the function does not have a declared return type;
the function is not a getter or setter.

An unchecked function also has the prototype attribute set by default.

ECMAScript 4 Netscape Proposal

Core Language

Classes

Monday, April 28, 2003

Class Definitions

Classes are defined using the class keyword.

ClassDefinition class Identifier Inheritance Block

Inheritance

«empty»

| extends TypeExpression^allowIn

Like other definitions, a class definition may be preceded by one or more attributes, which affect the class’s scope, namespace, and semantics. Every class is also a value and has type Type.

A class definition may only be located at a scope that allows class definitions, defined as follows:

The global scope allows class definitions
A package scope allows class definitions
A class scope allows class definitions
If a scope X allows class definitions and a block B is directly inside scope X, then B’s scope also allows class definitions

According to these rules, a class may not be defined inside a function or a compound statement other than a block. If a class B is defined as a member of another class A, then B must be declared static.

Superclasses

A class may have a superclass specified by its extends clause. If omitted, the superclass defaults to Object. The superclass TypeExpression must be a compile-time constant expression without forward references.

A class is a subtype of its superclass.

Body

When a ClassDefinition is evaluated, the following steps take place:

Create a new type t and bind the class’s QualifiedIdentifier to the constant t.
The TypeExpression, if any, in the extends clause is evaluated, and t is made a subtype of its superclass. Any static members of t’s superclass are also defined as properties of the object t.
A new, anonymous namespace for holding the class’s private members is constructed and used for the lexical extent of the Block.
Block is evaluated using a new activation frame initialized with alias bindings for all most derived global members of the superclass. Any static and constructor members defined for Block’s activation frame are added as properties of the object t as they are being defined; these may hide static members inherited from superclasses.
If Block is evaluated successfully (without throwing out an exception), all instance members defined for Block’s top-level scope (along with those inherited from superclasses) are collected to make a template for creating instances of type t.

A ClassDefinition’s Block is evaluated just like any other Block, so it can contain expressions, statements, loops, etc. Such statements that do not contain declarations do not contribute members to the class being declared, but they are evaluated when the class is declared.

Instance Members

A class C’s instance member id becomes a separate property of each instance of C. If c is an instance of C, then such a property can be accessed using the expression c.id. Instance members are inherited from the superclass.

If present, an initializer for a var or const instance member must be a compile-time constant expression.

Methods

A function instance member is called a method. A method may use this to refer to the object on which it was called. The value of this will always be an instance of the class or one of its subclasses. A method may not change the value of this.

A method is not in itself a value and has no type. There is no way to extract an undispatched method from a class. The . operator produces a function (more specifically, a closure) that is already dispatched and has this bound to the left operand of the . operator.

A method is called by combining the . operator with a function call. For example:

class C { var x:Integer = 3; function m() {return x} function n(x) {return x+4} } var c = new C; c.m(); // returns 3 c.n(7); // returns 11 var f:Function = c.m; // f is a zero-argument function with this bound to c f(); // returns 3 c.x = 8; f(); // returns 8

Overriding

A class C may override a method m defined in its superclass s. To do this, C should define a method m' with the same name as m and use the override attribute in the definition of m'. Overriding a method without using the override attribute or using the override attribute when not overriding a method results in an error intended to catch misspelled method names.

The overriding method m' must have the same set of parameters that the overridden method m has.

Let p be any parameter. If m' does not specify a type for p, it inherits the type of p from m. If m' does specify a type for p, it must be the same type as that for p in m. If p is optional in m, then it must also be optional in m' with the same parameter name; however, the default value may differ.

If omitted, the return type of m' defaults to the return type of m. If supplied, the return type of m' must be the same as the return type of m.

A final method cannot be overridden (or further overridden) in the subclasses in which it is visible.

The overridden method m' is put in the same namespaces as method m.

Method m' may call method m using the super operator: either super.m(args) or super this.m(args).

A method may only override another method. An instance variable may only override another instance variable. A getter may override a getter or an instance variable. A setter may override a setter or an instance variable.

Static Members

A class C’s static member id becomes a property of the class object C. This member can be accessed using the expression C.id. static members are inherited from the superclass.

Inherited static variables have only one global value, not one value per subclass. For example, if class C has a static variable v and class D inherits from C, then v can be read or written either as C.v or as D.v; it’s the same variable rather than two separate variables.

Each instance member o named n of class C (other than members that are setters without a corresponding getter) also causes a global member g named n to be defined in C. That global member is currently inaccessible and reserved for a future language extension.

Constructors

A constructor is a function that creates a new instance of a class C. A constructor is defined as a method with the name C without any of the attributes static, virtual, or final. A constructor is invoked using the expression new C or new C(args).

A constructor can refer to its class’s instance variables via this. If a class C inherits from class B, then when B’s constructor is called while creating an instance of C, B’s constructor will be able to call virtual methods of class C on the partially constructed instance. Likewise, B’s constructor could store this into a global variable v and some other function could call a method of C on the partially constructed object v. Class C’s methods can be assured that they are only called on fully initialized instances of C only if neither C nor any of its ancestors contains a constructor that exhibits either of the behaviors above.

A constructor may invoke a return statement as long as that statement does not supply a value; a constructor cannot return a value. The newly created object is returned automatically. A constructor’s return type must be omitted. A constructor always returns a new instance.

A class named C must not define a static member with the name C in any namespace; such usage is reserved for a future extension.

If a class C does not define a constructor or a static function with the name C, a default constructor is automatically defined; that constructor takes the arguments that C’s superclass’s constructor takes, calls that superconstructor with those arguments, and initializes C’s new instance members to their default values.

Calling a Superconstructor

Let C be a class and B its superclass. C’s constructor must call B’s constructor before it accesses this or super or before it returns. The call can be either explicit or implicit; if C’s constructor does not contain any calls to B’s constructor, then a call to B’s constructor with no arguments is automatically inserted as the first statement of C’s constructor. C’s constructor does not have to call B’s constructor when it exits by throwing an exception. C’s constructor may not call B’s constructor again after it already called it.

C’s constructor calls B’s constructor using the statement super(args). This must be a complete statement; it means something different if it is a subexpression of a larger expression. It is not possible to skip class hierarchy levels while constructing an object — if C’s superclass is B and B’s superclass is A, then C’s constructor cannot directly call A’s constructor.

ECMAScript 4 Netscape Proposal

Core Language

Namespaces

Wednesday, September 4, 2002

Namespace Definition

NamespaceDefinition namespace Identifier

A namespace definition defines a new namespace named Identifier.

A namespace definition may only be located at a scope that allows class definitions. If a namespace is defined as a member of a class, then the namespace must be declared static.

Use Directive

UseDirective use namespace ParenListExpression

A use namespace directive makes the contents of each namespace in the comma-separated list ParenListExpression accessible without a qualifier.

use namespace directives are lexically scoped and their effect does not extend past the end of the enclosing block, directive group, or substatement group. A use namespace directive may be preceded by attributes; however, all such attributes must evaluate to either true or false.

Name Lookup

The following paragraphs describe what happens when a name is looked up. See also the description of how namespace attributes affect name definitions.

Properties

Conceptually, an instance x is a collection of properties. All properties have property names q::n_C, where q is a namespace, n is an identifier, and C is a class. There may be several aliases that refer to the same property (due to either multiple namespace attributes or aliases introduced with the export definition), but a property name q::n_C can refer to at most one property of an instance.

An instance x can have several properties q::n_C with the same namespace q and name n but different classes C. In the following descriptions, q::n denotes the most derived of these properties, which is the one with the most derived class C.

A property reference can be either unqualified or qualified and is looked up according to the table below. There are two entries in the table for each kind of lookup, depending on whether the left operand of the . operator is a SuperExpression or not. x is an expression that evaluates to an instance, is the set of all scopes enclosing the property reference, and Q is the set of all namespaces q that are used by the scopes in .

Qualified reference `x.q::n` where `q` is a namespace	Select `x`’s most derived property `q::n`. Signal an error if there is no such property.
Qualified reference `super` `x.q::n` where `q` is a namespace	This form may only be used for references in the scope of a class `C` other than `Object`. Let `S` be `C`’s superclass. Among all of `x`’s properties `q::n_A` select the one whose class `A` is most derived but still either `S` or an ancestor of `S`. Signal an error if there is no such property.
Unqualified reference `x.n`	Let `A` be the least derived (closest to `Object`) class such that `x` contains at least one property named `q::n_A` where `q` is any element of `Q`; signal an error if `x` has no such properties. Let `Q'` be the set of all namespaces `q` such that `q` is in `Q` and `x` contains the property named `q::n_A`. Let `P` be the set of all most derived properties `q::n` of `x` such that `q` is in `Q'`. If `P` has only one element `p` or if all of `P`’s elements are aliases of one property `p`, select `p`; otherwise signal an error.
Unqualified reference `super` `x.n`	This form may only be used for references in the scope of a class `C` other than `Object`. Let `S` be `C`’s superclass. Let `A` be the least derived (closest to `Object`) class such that `x` contains at least one property named `q::n_A` where `q` is any element of `Q`; signal an error if `x` has no such properties or if `A` is not `S` or an ancestor of `S`. Let `Q'` be the set of all namespaces `q` such that `q` is in `Q` and `x` contains the property named `q::n_A`. For each `q` in `Q'` let `B_q` be the most derived class such that `B_q` is `S` or an ancestor of `S` and `x` contains the property `q::n_Bq`; for each `q` in `Q'` let `p_q` be the property `q::n_Bq`. Let `P` be the set of all such properties `p_q`. If `P` has only one element `p` or if all of `P`’s elements are aliases of one property `p`, select `p`; otherwise signal an error.
Dynamic reference `x[s]`	Let `s` evaluate to a string `n`. Get the property `x.public::n`. Signal an error if there is no such property.
Dynamic reference `super` `x[s]`	Let `s` evaluate to a string `n`. Get the property `super` `x.public::n`. Signal an error if there is no such property.

Note that the only way to access an overridden method is to use super. This is by design to prevent security attacks.

Variables

Conceptually, all variables (which for the purpose of this section also include constants, functions, classes, and such) have qualified names q::n, where q is a namespace and n an identifier. There may be several aliases that refer to the same variable (due to either multiple namespace attributes or aliases introduced with the export definition), but there cannot be two different variables defined using the same qualified name in the same scope.

A variable reference can be either unqualified or qualified and is looked up as follows:

Qualified reference q::n where q is a namespace

Let be the set of all scopes enclosing the qualified reference q::n. Search the scopes in , starting from the innermost one and continuing outwards until a value is found or all scopes have been examined. If no binding has been found after all scopes have been examined, signal an error. For each scope S in , do the following:

If S’s activation frame currently has a binding for q::n, select the value to which q::n is bound.
Otherwise, if S is the scope of the definition of a class C and C or any of its ancestors contains a global member named q::n, then select C’s most derived property q::n. Signal an error if there is no such property.
Otherwise, if S is the top-level scope of a constructor or instance method defined in class C and C or any of its ancestors contains an instance member named q::n, then let this be the value of this corresponding to S’s activation frame and select this’s most derived property q::n. Signal an error if there is no such property.
Otherwise, if S is the scope of the definition of a class C and C or any of its ancestors contains an instance member named q::n, then signal an error.

Unqualified reference n

Let be the set of all scopes enclosing the unqualified reference n. Search the scopes in , starting from the innermost one and continuing outwards until a value is found or all scopes have been examined. If no binding has been found after all scopes have been examined, signal an error. For each scope S in , do the following:

If S’s activation frame A currently has a binding for a variable V, V has a name q::n for some namespace q that is used by a scope in , and that use includes n, then select the value to which q::n is bound in A. If A contains more than one such variable V (not counting aliases of the same variable), signal an error.
Otherwise, if S is the scope of the definition of a class C, C or any of its ancestors contains a global member named q::n for some namespace q that is used by a scope in , then select C’s most derived property q::n. Signal an error if there is no such property or if there are multiple such properties (not counting aliases of the same property) for different q’s.
Otherwise, if S is the top-level scope of a constructor or instance method defined in class C and C or any of its ancestors contains an instance member named q::n for some namespace q that is used by a scope in , then select this’s most derived property q::n using the value of this corresponding to S’s activation frame. Signal an error if there is no such property or if there are multiple such properties (not counting aliases of the same property) for different q’s.
Otherwise, if S is the scope of the definition of a class C, C or any of its ancestors contains an instance member named q::n for some namespace q that is used by a scope in , then signal an error.

ECMAScript 4 Netscape Proposal

Core Language

Packages

Wednesday, June 4, 2003

Packages were originally part of the ECMAScript Edition 4 proposal but have been removed due to time constraints. If implemented, packages and import directives might be defined as described below.

Defining Packages

Packages are an abstraction mechanism for grouping and distributing related code. Packages are designed to be linked at run time to allow a program to take advantage of packages written elsewhere or provided by the embedding environment. ECMAScript 4 offers a number of facilities to make packages robust for dynamic linking:

Selected package contents can be protected from outside reference.
Classes can maintain invariants that cannot be violated by code outside the class and/or package.
Function arguments and data structure references can be type-checked to limit the kinds of unexpected inputs the package’s code can experience.
Packages can export multiple namespaces, allowing graceful upgrades to packages without changing the code that uses them.

A package is defined using the following syntax:

PackageDefinition package PackageNameOpt Block

PackageNameOpt

«empty»

| PackageName

PackageName

String

| PackageIdentifiers

PackageIdentifiers

Identifier

| PackageIdentifiers . Identifier

When a package is defined, it may, but is not required to, be given a PackageName, which is either a string or a series of dot-separated identifiers. It is implementation-defined what the restrictions, if any, are on naming packages to avoid clashes with other packages that may be present.

The Block contains the body of a package P. The Block is evaluated at the time package P is loaded. Any public top-level definitions are available to other packages that import package P. Any public class member definitions are available to all other packages, regardless of whether they import package P. Top-level and class definitions defined by P in another namespace N are available to other packages only if they use namespace N or qualify the access with namespace N.

A package is loaded (its body is evaluated) when the package is first imported or invoked directly (if, for example, the package is on an HTML web page). Some standard packages are loaded when the ECMAScript engine first starts up. When a package is loaded, its statements are evaluated in order, which may cause other packages to be loaded along the way when import directives are encountered. Circularities are not allowed in the graph of package imports.

Two attempts to load the same package in the same environment result in sharing of that package. What constitutes an environment is necessarily application-dependent. However, if package P1 loads packages P2 and P3, both of which load package P4, then P4 is loaded only once and thereafter its code and data is shared by P2 and P3.

Javascript does not support package definition circularities (two packages A and B that each import the other), although an implementation may provide such a facility as an extension.

Importing Packages

A package P can reference another package Q via an import directive:

ImportDirective

import PackageName

| import Identifier = PackageName

An import directive may be preceded by attributes; however, all such attributes must evaluate to either true or false.

There are two ways an import directive can name a package to be imported:

The PackageName may be PackageIdentifiers. In this case, the system looks for a package with that exact PackageIdentifiers on its implementation-defined search path.
The PackageName may be a literal string. In this case, the system interprets the contents of the string in an implementation-defined manner in order to locate the package. Specific ECMAScript 4 embeddings should define the manner in which the contents of the string are interpreted. For example, a browser embedding may be defined to interpret the string as a URI and look for a package at the location given by that URI.

An import directive does the following:

Locate the target package specified by PackageName. If the package has not yet been loaded, then load it and wait until the target package’s Block is done evaluating. If loading the target package causes an import of the current package then throw a package circularity exception.
Let P be the target package object.
If Identifier is given, const-bind it to P in the current scope.
For each non-explicit top-level definition N::n (n in namespace N) in P, bind an alias N::n to P’s N::n in the global scope unless N::n is already defined in the global scope.

If package P has a top-level definition n and package Q imports P using import PkgP = P, then package Q can refer to n as either n or PkgP.n. The shorter form n is not available if it conflicts with some other n. If package P has an explicit top-level definition n and package Q imports P, then package Q can refer to that n only as PkgP.n.

ECMAScript 4 Netscape Proposal

Core Language

Pragmas

Tuesday, January 28, 2003

Pragmas allow a script writer to select program modes and options. Pragmas are lexically scoped and their effect does not extend past the end of the enclosing block, directive group, or substatement group.

Pragma use PragmaItems

PragmaItems

PragmaItem

| PragmaItems , PragmaItem

PragmaItem

PragmaExpr

| PragmaExpr ?

PragmaExpr

Identifier

| Identifier ( PragmaArgument )

PragmaArgument

true

| false

| Number

| - Number

| - NegatedMinLong

| String

The keyword use is followed by one or more PragmaItems, each of which consists of an identifier, an optional argument, and an optional ?.

The pragma identifiers below are currently defined. Implementations may define additional identifiers that have meaning as pragmas.

Identifier	Meaning
`ecmascript(n)`	Error if version `n` of ECMAScript is not supported; otherwise recommends but does not require that the implementation only support ECMAScript version `n` features.
`strict` `strict(true)`	Strict mode
`strict(false)`	Non-strict mode (default)

The pragma takes effect starting with the directive after the pragma and continues either until the end of the enclosing block or statement group or until overridden by another pragma in the same block or statement group, whichever comes first. If a pragma references the same identifier several times, the last reference takes precedence. The semicolon insertion rule changes implied by the strict pragma apply to the semicolon, if any, ending the use directive that contains that pragma.

If an implementation does not recognize a pragma identifier, then if the PragmaItem ends with a ? then that PragmaItem is ignored; if the PragmaItem does not end with a ? then an error occurs.

Strict Mode

Many parts of ECMAScript 4 are relaxed or unduly convoluted due to compatibility requirements with ECMAScript 3. Strict mode sacrifices some of this compatibility for simplicity and additional error checking. Strict mode is intended to be used in newly written ECMAScript 4 programs, although existing ECMAScript 3 programs may be retrofitted.

The opposite of strict mode is nonstrict mode, which is the default. A program can readily mix strict and nonstrict portions.

Strict mode has the following effects:

Line-break semicolon insertion is turned off. (Grammatical semicolon insertion remains turned on.)
[no line break] restrictions in grammar productions are ignored. Line breaks can be placed anywhere between input tokens.
Variables must be declared.
Definition scopes are not hoisted.
var and function declarations without attributes or types are initialized at the beginning of a scope.
FunctionDefinitions define constants rather than variables.
Calls to functions defined under strict mode are checked for the correct number of arguments except in functions that explicitly allow a variable number of arguments. (The mode of the call site does not matter.)
Implementations may choose to disable other compatibility extensions such as support for octal literals. These are not officially part of ECMAScript 4 but most implementations support these in nonstrict mode for compatibility with older programs.

An implementation does not have to implement strict mode; however, implementations are encouraged to do so.

Predefined Types

The following types are predefined in ECMAScript 4:

Type	Set of Values
`Never`	No values
`Void`	`undefined`
`Null`	`null`
`Boolean`	`true` and `false`
`Integer`	Double-precision IEEE floating-point numbers that are mathematical integers, including +0.0, –0.0, +, –, and NaN
`Number`	Double-precision IEEE floating-point numbers, including +0.0, –0.0, +, –, and NaN
`char`	Single 16-bit unicode characters
`String`	Immutable strings of unicode characters, including `null`
`Function`	All functions, including `null`
`Array`	`null` as well as all arrays
`Type`	All types, including `null`
`Object`	All values, including `null` and `undefined`

Unlike in ECMAScript 3, there is no distinction between objects and primitive values. All values can have methods. Values of some classes are sealed, which disallows addition of dynamic properties. User-defined classes can be made to behave like primitives by using the class modifier final.

The above type names are not reserved words. They can be used as names of local variables or class members. However, they are defined as constants in the global scope, so a package cannot use them to name global variables.

Object is the supertype of all types. Never is the subtype of all types. Never is useful to describe the return type of a function that cannot return normally because it either falls into an infinite loop or always throws an exception. Never cannot be used as the type of a variable or parameter. Void is useful to describe the return type of a function that can return but that does not produce a useful value. See rationale.

A literal number is a member of the type Number; if that literal has an integral value, then it is also a member of type Integer. A literal string is a member of the type String. There are no literals of type char; a char value can be constructed by an explicit or implicit conversion.

An object created with the expression new f where f is a function has the type Object.

User-Defined Types

Any class defined using the class declaration is also a type that denotes the set of all of its and its descendants’ instances. These include the predefined classes, so Object, Date, etc. are all types. null is an instance of a user-defined class. undefined is never an instance of a user-defined class.

Meaning of Types

Types are generally used to restrict the set of objects that can be held in a variable or passed as a function argument. For example, the declaration

var x:Integer;

restricts the values that can be held in variable x to be integers.

A type declaration does not affect the semantics of reading the variable or accessing one of its properties. Thus, as long as expression new MyType() returns a value of type MyType, the following two code snippets are equivalent:

var x:MyType = new MyType();
x.foo();

var x = new MyType();
x.foo();

This equivalence always holds, even if these snippets are inside the declaration of class MyType and foo is a private field of that class. As a corollary, adding true type annotations does not change the meaning of a program.

Type Expressions

The language cannot syntactically distinguish type expressions from value expressions, so a type expression can be any compile-time constant expression that evaluates to a type.

A type is also a value (whose type is Type) and can be used in expressions, assigned to variables, passed to functions, etc. For example, the code

const R:Type = Number;
function abs_val(x:R):R {
  return x<0 ? -x : x;
}

is equivalent to:

function abs_val(x:Number):Number {
  return x<0 ? -x : x;
}

Implicit Coercions

Implicit coercions can take place in the following situations:

Assigning a value v to a variable of type t
Declaring an uninitialized variable of type t, in which case undefined is implicitly coerced to type t
Passing an argument v to a function whose corresponding parameter has type t
Returning a result v from a function declared to return a value of type t

In any of these cases, if v t, then v is passed unchanged. If v t, then if t defines an implicit mapping for value v then that mapped v is used; otherwise an error occurs.

Explicit Coercions

An explicit coercion performs more aggressive transformations than an implicit coercion. To invoke an explicit coercion, use the type as a function, passing it the value as an argument:

type(value)

For example, Integer(258.1) returns the integer 258, and String(2+2==4) returns the string "true".

If value is already a member of type, the explicit coercion returns value unchanged. If value can be implicitly coerced to type, the explicit coercion returns the result of the implicit coercion. Otherwise, the explicit coercion uses type’s explicit mapping.

ECMAScript 4 Netscape Proposal

Libraries

Machine Types

Tuesday, March 4, 2003

Purpose

Machine types are low-level numeric types for use in ECMAScript 4 programs. These types provide Java-style integer operations that are useful for communicating between ECMAScript 4 and other programming languages. These types are not intended to replace Number and Integer for general-purpose scripting.

The following low-level numeric types are available:

Type	Suffix	Values
`sbyte`		`Integer` values between –128 and 127 inclusive, excluding –0.0
`byte`		`Integer` values between 0 and 255 inclusive, excluding –0.0
`short`		`Integer` values between –32768 and 32767 inclusive, excluding –0.0
`ushort`		`Integer` values between 0 and 65535 inclusive, excluding –0.0
`int`		`Integer` values between –2147483648 and 2147483647 inclusive, excluding –0.0
`uint`		`Integer` values between 0 and 4294967295 inclusive, excluding –0.0
`long`	`L`	Long integer values between –9223372036854775808 and 9223372036854775807 inclusive
`ulong`	`UL`	Long integer values between 0 and 18446744073709551615 inclusive
`float`	`F`	Single-precision IEEE floating-point numbers, including positive and negative zeroes, infinities, and NaN

The above type names are not reserved words.

8, 16, and 32-bit Integers

The first six types sbyte, byte, short, ushort, int, and uint are all proper subtypes of Integer, which is itself a subtype of Number. A particular number is a member of multiple types. For example, 3.0 is a member of sbyte, byte, short, ushort, int, uint, Integer, Number, and Object, while –2000.0 is a member of short, int, Integer, Number, and Object. ECMAScript does not distinguish between the literals 3 and 3.0 in any way.

All arithmetic operations and comparisons on sbyte, byte, short, ushort, int, and uint values treat them just like they would any other Number values — the operations are performed using full IEEE double-precision arithmetic.

Implicit Coercions

There are no predefined implicit coercions from values of type sbyte, byte, short, ushort, int, or uint other than the coercions predefined on the type Number. The following predefined implicit coercions are applicable when the destination type is sbyte, byte, short, ushort, int, or uint:

undefined +0.0
–0.0 +0.0
long and ulong values within range of the destination type T are converted to equivalent values of type T
finite integral float values within range of the destination type T are converted to equivalent values of type T

Note that there are no implicit coercions from +, –, or NaN to sbyte, byte, short, ushort, int, or uint.

Explicit Coercions

There are no predefined explicit coercions from values of type sbyte, byte, short, ushort, int, or uint other than the coercions predefined on the type Number. The predefined explicit coercions below are applicable when the destination type T is sbyte, byte, short, ushort, int, or uint. The notation |T| represents the range of the type T, where |sbyte| = |byte| = 256, |short| = |ushort| = 65536, and |int| = |uint| = 2³².

undefined +0.0
A long or ulong value x is converted to the one value y of type T that satisfies x = y (mod |T|)
float values are first converted to equivalent Number values and then converted as below
A Number value is first converted to an Integer value x by truncating towards zero if necessary. Then, if x is –0.0, +, –, or NaN, it is converted to +0.0; otherwise, x is converted to the one value y of type T that satisfies x = y (mod |T|)

64-bit Integers

The types long and ulong represent signed and unsigned 64-bit integers. long and ulong literals are written with the suffix L or UL and no exponent or decimal point. Literal values of type long are written as –9223372036854775808L through 9223372036854775807L. Literal values of type ulong are written as 0UL through 18446744073709551615UL.

The types long and ulong are disjoint from Number, so 5L and 5 are different objects, although they compare == and === to each other. 5L and 5UL are also different objects, although they compare == and === to each other.

Negation, addition, subtraction, and multiplication, and modulo (%) on long and ulong values is exact, and long and ulong values may be mixed in an expression. There are five possible cases depending on the mathematical result x:

If –9223372036854775808 x –1, then the result has type long.
If 0 x 9223372036854775807, then the result has type ulong if at least one operand has type ulong; otherwise, the result has type long.
If 9223372036854775808 x 18446744073709551615, then the result has type ulong.
Otherwise, the result is the closest representable Number using the IEEE round-to-nearest mode.

Division involving two long or ulong operands returns the most precise quotient available from among the possible long, ulong, and Number values. In some cases the quotient will be a long or ulong; in other cases the quotient will be a Number. See the semantics for the details.

Division and modulo on long and ulong values can produce the Number values positive or negative infinity or NaN when the divisor is zero.

Addition, subtraction, multiplication, division, and modulo mixing a long or ulong operand with a Number (or any subtype of Number) or float operand first checks whether the Number or float operand is an exact integer (including either +0.0 or –0.0 but not infinities or NaN). If it is, then the computation uses the integral semantics above. If not, then the long or ulong operand is coerced to a Number and the operation is done using Number arithmetic.

The bitwise operations &, |, and ^ are 64 bits wide if at least one operand is a long or ulong, in which case the other operand is truncated to an integer and treated modulo 2⁶⁴ if necessary. The result is a ulong if at least one operand is a ulong; otherwise, the result is a long.

The bitwise shifts <<, >>, and >>> are 64 bits wide if the first operand is a long or ulong. The result is a ulong if the first operand is a ulong; otherwise, the result is a long. >> copies the most significant bit and >>> shifts in zero bits regardless of whether the first operand is a long or ulong.

Comparisons mixing a long or ulong operand with a Number (or any subtype of Number) or float operand compare exact mathematical values without any coercions.

Implicit Coercions

The following predefined implicit coercions are applicable when the destination type is long:

undefined 0L
ulong values between 0UL and 9223372036854775807UL are converted to equivalent long values
Finite Integer values between –9223372036854775808 and 9223372036854775807 are converted to equivalent long values
Finite integral float values between –9223372036854775808F and 9223372036854775807F are converted to equivalent long values

The following predefined implicit coercions are applicable when the destination type is ulong:

undefined 0UL
long values between 0L and 9223372036854775807L are converted to equivalent ulong values
Finite Integer values between –0.0 and 18446744073709551615 are converted to equivalent ulong values
Finite integral float values between –0.0F and 18446744073709551615F are converted to equivalent ulong values

Note that there are no implicit coercions from NaN or positive or negative infinity to long or ulong.

A long or ulong value can be implicitly coerced to type Number, Integer, or float. The result is the closest representable Number or float value using the same rounding as when a string is converted to a number. If the source is 0L or 0UL then the result is +0.0 or +0.0F.

Explicit Coercions

The predefined explicit coercions below are applicable when the destination type T is long or ulong.

undefined 0L or 0UL
A long or ulong value x is converted to the one value y of type T that satisfies x = y (mod 2⁶⁴)
float values are first converted to equivalent Number values and then converted as below
A Number value is first converted to an Integer value x by truncating towards zero if necessary. Then, if x is –0.0, +, –, or NaN, it is converted to 0L or 0UL; otherwise, x is converted to the one value y of type T that satisfies x = y (mod 2⁶⁴).

A long or ulong value x can be explicitly coerced to type Number, Integer, float or String. Explicit coercions to Number, Integer, float are the same as the implicit coercions. Explicit coercions to type String produce the x as a string of decimal digits. Negative values have a minus sign prepended. Zero produces the string "0"; all other values produce strings starting with a non-zero digit.

Single-Precision Floats

The type float represents single-precision IEEE floating-point numbers. float literals are written with the suffix F. float infinities and NaN are separate from Number infinities and NaN.

The type float is disjoint from Number, so 5F and 5 are different objects, although they compare == to each other.

Negating a float value returns a float value. All other arithmetic first converts the float value to the corresponding Number value. The bitwise operations &, |, ^, <<, >>, and >>> coerce any float operands to type Number before proceeding.

Implicit Coercions

The following predefined implicit coercions are applicable when the destination type is float:

undefined float(NaN)
Number values (including NaN and the infinities) are converted to the closest representable float values using the IEEE round-to-nearest mode
long and ulong values are converted to the closest representable float values (excluding –0.0F)

A float value can be implicitly coerced to type Number. The result is the equivalent Number value.

ECMAScript 4 Netscape Proposal

Formal Description

Wednesday, August 14, 2002

Semantic Notation
Stages
Lexical Grammar Summary (also available as Word RTF)
Lexical Grammar and Semantics (Word RTF)
Regular Expression Grammar Summary (Word RTF)
Regular Expression Grammar and Semantics (Word RTF)
Syntactic Grammar Summary (Word RTF)
Syntactic Grammar and Semantics (Word RTF)

This chapter presents the formal syntax and semantics of ECMAScript 4. The syntax notation and semantic notation sections explain the notation used for this description. A simple metalanguage based on a typed lambda calculus is used to specify the semantics.

The syntax and semantic sections are available in both HTML 4.0 and Microsoft Word RTF formats. In the HTML versions each use of a grammar nonterminal or metalanguage value, type, or field is hyperlinked to its definition, making the HTML version preferred for browsing. On the other hand, the RTF version looks much better when printed. The fonts, colors, and other formatting of the various grammar and semantic elements are all encoded as CSS (in HTML) or Word (in RTF) styles and can be altered if desired.

The syntax and semantics sections are machine-generated from code supplied to a small engine that can type-check and execute the semantics directly. This engine is in the CVS tree at mozilla/js2/semantics; the input files are at mozilla/js2/semantics/JS20.

ECMAScript 4 Netscape Proposal

Formal Description

Semantic Notation

Friday, June 13, 2003

The semantics of ECMAScript 4 are written in Algol-like pseudocode. The following sections define the notation used to write the semantics’ concepts, expressions, procedures, and actions.

Operators

The table below summarizes operators used in expressions in this document. The operators are listed in groups in order from the highest precedence (tightest-binding) to the lowest precedence (loosest-binding). Other than the relational operators, operators in the same group have the same precedence and associate left-to-right, so, for example, 7–3+2–1 means ((7–3)+2)–1 instead of 7–(3+(2–1)) or (7–(3+2))–1. As is traditional in mathematics, the relational operators cascade, so

a = b c < d

means

a = b and b c and c < d

Parentheses are used to override precedences or clarify expressions.

Expressions used in describing algorithms may perform side effects. Except for and, or, and ?:, the operators compute all of their operands left-to-right, and if computation of any operand throws an exception e, then the operator immediately propagates e without computing any following operands.

Group	Operator	Description
Nonassociative	(`x`)	Return `x`. Parentheses are used to override operator precedence.
	{`x`₁, `x`₂, ... , `x_n`}	Set or semantic domain with the elements `x`₁, `x`₂, ... , `x_n`
	{`f`(`x`) \| `x` `A`} {`f`(`x`) \| `x` `A`such that `predicate`(`x`)}	Set comprehension
	[`x`₀, `x`₁, ... , `x`_n–1]	List with the elements `x`₀, `x`₁, ... , `x`_n–1
	[`f`(`x`) \| `x` `u`] [`f`(`x`) \| `x` `u` such that `predicate`(`x`)]	List comprehension
	`Namelabel`₁: `x`₁, ... , `label`_n: `x_n` `Name`	Tuple constructor
	\|`x`\|	Absolute value of a number `x`, cardinality of a set `x`, or length of a list `x`
	`x`	Floor of `x`
	`x`	Ceiling of `x`
	Action[nonterminal_i]	This notation is used inside an action for a grammar production that has nonterminal nonterminal on the production’s left or right side. Return the value of action Action invoked on the `i`^th instance of nonterminal nonterminal on the left or right side of . The subscript `i` can be omitted if it is 1 and there is only one instance of nonterminal nonterminal on ’s right side.
	nonterminal_i	This notation is used inside an action for a grammar production that has nonterminal nonterminal on the production’s left or right side. Furthermore, every complete expansion of grammar nonterminal nonterminal expands into a single character. Return the character to which the `i`^th instance of nonterminal nonterminal on the right side of expands. The subscript `i` can be omitted if there is only one instance of nonterminal nonterminal in . If the subscript is omitted and nonterminal nonterminal appears on the left side of , then this expression returns the single character to which this whole production expands.
Suffix	`i`_long	Convert integer `i` to a Long
	`i`_ulong	Convert integer `i` to a ULong
	`x`_f32	Convert real number `x` to the “closest” Float32 value by calling realToFloat32(`x`)
	`x`_f64	Convert real number `x` to the “closest” Float64 value by calling realToFloat64(`x`)
	`x^y`	`x` raised to the `y`^th power
	`u`[`i`]	`i`^th element of list `u`
	`u`[`i` ... `j`] `u`[`i` ...]	Slice of list `u`
	`u`[`i` \ `x`]	List element substitution
	`a`.`label`	Field named `label` of tuple or record `a`
	`T`{}	Semantic domain of all sets whose elements are members of semantic domain `T`
	`T`[]	Semantic domain of all lists whose elements are members of semantic domain `T`
	`f`(`x`₁, ..., `x_n`)	Procedure call
Prefix	new `Namelabel`₁: `x`₁, ... , `label`_n: `x_n`	Record constructor
	–`x`	Real number negation
	min `A`	Smallest element of a set
	max `A`	Largest element of a set
Factor	`x` `y`	Real number product
	`x` / `y`	Real number quotient (`y` must not be zero)
	`x` mod `y`	Real number remainder (`y` must not be zero)
	`A` `B`	Set intersection
	`T`₁ `T`₂ ... `T`_n `T` () `T` `T`₁ `T`₂ ... `T`_n () () ()	Semantic domain of procedures
Term	`x` + `y`	Real number addition
	`x` – `y`	Real number subtraction or set difference
	`u` `v`	List concatenation
	`A` `B`	Set union
Relational	`x` = `y` `x` `y`	Equality and inequality predicates on tags, real numbers, sets, booleans, characters, lists, strings, tuples, and records. Values of differing kinds (such as the boolean true and the character ‘`A`’) are always considered unequal.
	`x` < `y` `x` `y` `x` > `y` `x` `y`	Order predicates on real numbers, characters, and strings.
	`x` `A` `x` `A`	Set membership predicates
	`A` `B`	Subset predicate
	`A` `B`	Proper subset predicate
Negation	not `a`	Logical negation
Conjunction	`a` and `b`	Short-circuiting logical conjunction
Disjunction	`a` or `b`	Short-circuiting logical disjunction
Disjunction	`a` xor `b`	Logical exclusive or
Conditional	`a` ? `x` : `y`	Conditional
Conditional	some `x` `A` satisfies `predicate`(`x`) every `x` `A` satisfies `predicate`(`x`)	Set or list quantifiers

Semantic Domains

Semantic domains describe the possible values that a variable might take on in an algorithm. The algorithms are constructed in a way that ensures that these constraints are always met, regardless of any valid or invalid programmer or user input or actions.

A semantic domain can be intuitively thought of as a set of possible values, and, in fact, any set of values explicitly described in this document is also a semantic domain. Nevertheless, semantic domains have a more precise mathematical definition in domain theory (see for example [Schmidt86]) that allows one to define semantic domains recursively without encountering paradoxes such as trying to define a set A whose members include all functions mapping values from A to Integer. The problem with an ordinary definition of such a set A is that the cardinality of the set of all functions mapping A to Integer is always strictly greater than the cardinality of A, leading to a contradiction. Domain theory uses a least fixed point construction to allow A to be defined as a semantic domain without encountering problems.

Semantic domains have names in Capitalized Red Small Caps. Such a name is to be considered distinct from a tag or regular variable with the same name, so Undefined, undefined, and undefined are three different and independent entities.

A variable v is constrained using the notation

v: T

where T is a semantic domain. This constraint indicates that the value of v will always be a member of the semantic domain T. These declarations are informative (they may be dropped without affecting the semantics’ correctness) but useful in understanding the semantics. For example, when the semantics state that x: Integer then one does not have to worry about what happens when x has the value true or +_f64.

The constraints can be proven statically. The ECMAScript semantics have been machine-checked to ensure that every constraint holds.

Booleans

The tags true and false represent booleans. Boolean is the two-element semantic domain {true, false}.

Let a and b be booleans and x and y any values. In addition to = and , the following operations can be done on them:

Notation	Description
not `a`	true if `a` is false; false if `a` is true
`a` and `b`	If `a` is false, return false without computing `b`; if `a` is true, return the value of `b`
`a` or `b`	If `a` is false, return the value of `b`; if `a` is true, return true without computing `b`
`a` xor `b`	true if `a` is true and `b` is false or `a` is false and `b` is true; false otherwise. `a` xor `b` is equivalent to `a` `b`
`a` ? `x` : `y`	If `a` is true, compute and return the value of `x`; if `a` is false, compute and return the value of `y`

Note that the and, or, and ?: operators short-circuit. These are the only operators that do not always compute all of their operands.

Sets

A set is an unordered, possibly infinite collection of elements. Each element may occur at most once in a set. There must be an equivalence relation = defined on all pairs of the set’s elements. Elements of a set may themselves be sets.

A set is denoted by enclosing a comma-separated list of values inside braces:

{element₁, element₂, ... , element_n}

The empty set is written as {}. Any duplicate elements are included only once in the set.

For example, the set {3, 0, 10, 11, 12, 13, –5} contains seven integers.

Sets of either integers or characters can be abbreviated using the ... range operator, which generates inclusive ranges of integers or character code points. For example, the above set can also be written as {0, –5, 3 ... 3, 10 ... 13}.

If the beginning of the range is equal to the end of the range, then the range consists of only one element: {7 ... 7} is the same as {7}. If the end of the range is one less than the beginning, then the range contains no elements: {7 ... 6} is the same as {}. The end of the range is never more than one less than the beginning.

A set can also be written using the set comprehension notation

{f(x) | x A}

which denotes the set of the results of computing expression f on all elements x of set A. A predicate can be added:

{f(x) | x A such that predicate(x)}

denotes the set of the results of computing expression f on all elements x of set A that satisfy the predicate expression. There can also be more than one free variable x and set A, in which case all combinations of free variables’ values are considered. For example,

{x | x  Integer such that x² < 10} = {–3, –2, –1, 0, 1, 2, 3};
{x² | x  {–5, –1, 1, 2, 4}} = {1, 4, 16, 25};
{x10 + y | x  {1, 2, 4}, y  {3, 5}} = {13, 15, 23, 25, 43, 45}.

The same notation is used for operations on sets and on semantic domains. Let A and B be sets (or semantic domains) and x and y be values. The following operations can be done on them:

Notation	Description
`x` `A`	true if `x` is an element of `A` and false if not
`x` `A`	false if `x` is an element of `A` and true if not
\|`A`\|	The number of elements in `A` (only used on finite sets)
min `A`	The value `m` that satisfies both `m` `A` and for all elements `x` `A`, `x` `m` (only used on nonempty, finite sets whose elements have a well-defined order relation)
max `A`	The value `m` that satisfies both `m` `A` and for all elements `x` `A`, `x` `m` (only used on nonempty, finite sets whose elements have a well-defined order relation)
`A` `B`	The intersection of `A` and `B` (the set or semantic domain of all values that are present both in `A` and in `B`)
`A` `B`	The union of `A` and `B` (the set or semantic domain of all values that are present in at least one of `A` or `B`)
`A` – `B`	The difference of `A` and `B` (the set or semantic domain of all values that are present in `A` but not `B`)
`A` = `B`	true if `A` and `B` are equal and false otherwise. `A` and `B` are equal if every element of `A` is also in `B` and every element of `B` is also in `A`.
`A` `B`	false if `A` and `B` are equal and true otherwise
`A` `B`	true if `A` is a subset of `B` and false otherwise. `A` is a subset of `B` if every element of `A` is also in `B`. Every set is a subset of itself. The empty set {} is a subset of every set.
`A` `B`	true if `A` is a proper subset of `B` and false otherwise. `A` `B` is equivalent to `A` `B` and `A` `B`.

If T is a semantic domain, then T{} is the semantic domain of all sets whose elements are members of T. For example, if T = {1,2,3}, then T{} = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}. The empty set {} is a member of T{} for any semantic domain T.

In addition to the above, the some and every quantifiers can be used on sets (see also lists). The quantifier

some x A satisfies predicate(x)

returns true if there exists at least one element x in set A such that predicate(x) computes to true. If there is no such element x, then the some quantifier’s result is false. If the some quantifier returns true, then variable x is left bound to any element of A for which predicate(x) computes to true; if there is more than one such element x, then one of them is chosen arbitrarily. For example,

some x {3, 16, 19, 26} satisfies x mod 10 = 6

evaluates to true and leaves x set to either 16 or 26. Other examples include:

(some x  {3, 16, 19, 26} satisfies x mod 10 = 7) = false;
(some x  {} satisfies x mod 10 = 7) = false;
(some x  {“Hello”} satisfies true) = true and leaves x set to the string “Hello”;
(some x  {} satisfies true) = false.

The quantifier

every x A satisfies predicate(x)

returns true if there exists no element x in set A such that predicate(x) computes to false. If there is at least one such element x, then the every quantifier’s result is false. As a degenerate case, the every quantifier is always true if the set A is empty. For example,

(every x  {3, 16, 19, 26} satisfies x mod 10 = 6) = false;
(every x  {6, 26, 96, 106} satisfies x mod 10 = 6) = true;
(every x  {} satisfies x mod 10 = 6) = true.

Real Numbers

Numbers written in plain font are exact mathematical real numbers. Numbers can be written with or without a decimal point. Integers preceded with “0x” are hexadecimal (base 16). 4294967296, 4294967296.000, 0x100000000, and 2³² are all the same number. 0.1 is the exact value 1/10.

Integer is the semantic domain of all integers {... –3, –2, –1, 0, 1, 2, 3 ...}. 3.0, 3, 0xFF, and –10¹⁰⁰ are all integers.

Rational is the semantic domain of all rational numbers. Every integer is also a rational number: Integer Rational. 3, 1/3, 7.5, –12/7, and 2^–5 are examples of rational numbers.

Real is the semantic domain of all real numbers. Every rational number is also a real number: Rational Real. is an example of a real number slightly larger than 3.14.

Let x and y be real numbers. The following operations can be done on them and always produce exact results:

Notation	Description
–`x`	Negation
\|`x`\|	Absolute value
`x` + `y`	Sum
`x` – `y`	Difference
`x` `y`	Product
`x` / `y`	Quotient (`y` must not be zero)
`x^y`	`x` raised to the `y`^th power (used only when either `x`0 and `y` is an integer or `x` is any number and `y`>0)
`x`	Floor of `x`, which is the unique integer `i` such that `i` `x` < `i`+1. = 3, –3.5 = –4, and 7 = 7.
`x`	Ceiling of `x`, which is the unique integer `i` such that `i`–1 < `x` `i`. = 4, –3.5 = –3, and 7 = 7.
`x` mod `y`	`x` modulo `y`, which is defined as `x` – `yx`/`y`. `y` must not be zero. 10 mod 7 = 3, and –1 mod 7 = 6.
log₁₀(`x`)	The exact base-10 logarithm of `x` (`x` will always be greater than zero)

Real numbers can be compared using =, , <, , >, and . The result is either true or false.

Bitwise Integer Operators

The four procedures below perform bitwise operations on integers. The integers are treated as though they were written in infinite-precision two’s complement binary notation, with each 1 bit representing true and 0 bit representing false.

More precisely, any integer x can be represented as an infinite sequence of bits a_i where the index i ranges over the nonnegative integers and every a_i {0, 1}. The sequence is traditionally written in reverse order:

..., a₄, a₃, a₂, a₁, a₀

The unique sequence corresponding to an integer x is generated by the formula

a_i = x / 2ⁱ mod 2

If x is zero or positive, then its sequence will have infinitely many consecutive leading 0’s, while a negative integer x will generate a sequence with infinitely many consecutive leading 1’s. For example, 6 generates the sequence ...0...0000110, while –6 generates ...1...1111010.

The logical and, or, and xor operations below operate on corresponding elements of the sequences a_i and b_i generated by the two parameters x and y. The result is another infinite sequence of bits c_i. The result of the operation is the unique integer z that generates the sequence c_i. For example, anding corresponding elements of the sequences generated by 6 and –6 yields the sequence ...0...0000010, which is the sequence generated by the integer 2. Thus, bitwiseAnd(6, –6) = 2.

Procedure	Description
bitwiseAnd(`x`: Integer, `y`: Integer): Integer	The bitwise and of `x` and `y`
bitwiseOr(`x`: Integer, `y`: Integer): Integer	The bitwise or of `x` and `y`
bitwiseXor(`x`: Integer, `y`: Integer): Integer	The bitwise xor of `x` and `y`
bitwiseShift(`x`: Integer, `count`: Integer): Integer	Shift `x` to the left by `count` bits. If `count` is negative, shift `x` to the right by –`count` bits. Bits shifted out of the right end are lost; bit shifted in at the right end are zero. bitwiseShift(`x`, `count`) is exactly equivalent to `x` 2^count.

Characters

Characters enclosed in single quotes ‘ and ’ represent Unicode characters with code points ranging from 0000 to 10FFFF hexadecimal. Even though Unicode does not define characters for some of these code points, in this specification any of these 1114112 code points is considered to be a valid character. Examples of characters include ‘A’, ‘b’, ‘«LF»’, ‘«uFFFF»’, ‘«U00010000»’ and , ‘«U0010FFFF»’ (see also the notation for non-ASCII characters).

Unicode has the notion of code points, which are numerical indices of characters in the Unicode character table, as well as code units, which are numerical values for storing characters in a particular representation. ECMAScript is designed to make it appear that strings are represented in the UTF-16 representation, which means that a code unit is a 16-bit value (an implementation may store strings in other formats such as UTF-8, but it must make it appear for indexing and character extraction purposes as if strings were sequences of 16-bit code units). For convenience this specification does not distinguish between code units and code points in the range from 0000 to FFFF hexadecimal.

Char16 is the semantic domain of the 65536 Unicode characters in the set {‘«u0000»’ ... ‘«uFFFF»’}. These characters form Unicode’s Basic Multilingual Plane. These characters have code points between 0000 and FFFF hexadecimal. Code units are also represented by values in the Char16 semantic domain.

SupplementaryChar is the semantic domain of the 1048576 Unicode characters in the set {‘«U00010000»’ ... ‘«U0010FFFF»’}. These are Unicode’s supplementary characters with code points between 10000 and 10FFFF hexadecimal. Since these characters are not members of the Char16 domain, they cannot be stored directly in strings of Char16 code units. Instead, whereever necessary the semantic algorithms convert supplementary characters into pairs of surrogate code units before storing them into strings. The first surrogate code unit h is in the set {‘«uD800»’ ... ‘«uDBFF»’} and the second surrogate code unit l is in the set {‘«uDC00»’ ... ‘«uDFFF»’}; together they encode the supplementary character with the code point value 0x10000 + (char16ToInteger(h) – 0xD800)0x400 + char16ToInteger(l) – 0xDC00.

Char21 is the semantic domain of all 1114112 Unicode characters {‘«u0000»’ ... ‘«U0010FFFF»’}.

Char21 = Char16 SupplementaryChar

Characters can be compared using =, , <, , >, and . These operators compare code point values, so ‘A’ = ‘A’, ‘A’ < ‘B’, ‘A’ < ‘a’, and ‘«uFFFF»’ < ‘«U00010000»’ are all true.

Character Conversions

The following procedures convert between characters and integers:

Procedure	Description
char16ToInteger(`c`: Char16): {0 ... 0xFFFF}	The number of character `c`’s Unicode code point or code unit
char21ToInteger(`c`: Char21): {0 ... 0x10FFFF}	The number of character `c`’s Unicode code point
integerToChar16(`i`: {0 ... 0xFFFF}): Char16	The character whose Unicode code point or code unit number is `i`
integerToSupplementaryChar(`i`: {0x10000 ... 0x10FFFF}): SupplementaryChar	The character whose Unicode code point number is `i`
integerToChar21(`i`: {0 ... 0x10FFFF}): Char21	The character whose Unicode code point number is `i`

The procedure digitValue is defined as follows:

proc digitValue(c: {‘0’ ... ‘9’, ‘A’ ... ‘Z’, ‘a’ ... ‘z’}): {0 ... 35}

case c of

{‘0’ ... ‘9’} do return char16ToInteger(c) – char16ToInteger(‘0’);

{‘A’ ... ‘Z’} do return char16ToInteger(c) – char16ToInteger(‘A’) + 10;

{‘a’ ... ‘z’} do return char16ToInteger(c) – char16ToInteger(‘a’) + 10

end case

end proc;

Lists

A finite ordered list of zero or more elements is written by listing the elements inside bold brackets:

[element₀, element₁, ... , element_n–1]

For example, the following list contains four strings:

[“parsley”, “sage”, “rosemary”, “thyme”]

The empty list is written as [].

Unlike a set, the elements of a list are indexed by integers starting from 0. A list can contain duplicate elements.

A list can also be written using the list comprehension notation

[f(x) | x u]

which denotes the list [f(u[0]), f(u[1]), ... , f(u[|u|–1])] whose elements consist of the results of applying expression f to each corresponding element of list u. x is the name of the parameter in expression f. A predicate can be added:

[f(x) | x u such that predicate(x)]

denotes the list of the results of computing expression f on all elements x of list u that satisfy the predicate expression. The results are listed in the same order as the elements x of list u. For example,

[x² | x [–1, 1, 2, 3, 4, 2, 5]] = [1, 1, 4, 9, 16, 4, 25]
[x+1 | x [–1, 1, 2, 3, 4, 5, 3, 10] such that x mod 2 = 1] = [0, 2, 4, 6, 4]

Let u = [e₀, e₁, ... , e_n–1] and v = [f₀, f₁, ... , f_m–1] be lists, e be an element, i and j be integers, and x be a value. The operations below can be done on lists. The operations are meaningful only when their preconditions are met; the semantics never use the operations below without meeting their preconditions.

Notation	Precondition	Description
\|`u`\|		The length `n` of the list
`u`[`i`]	0 `i` < \|`u`\|	The `i`^th element `e_i`.
`u`[`i` ... `j`]	0 `i` `j`+1 \|`u`\|	The list slice [`e_i`, `e`_i+1, ... , `e_j`] consisting of all elements of `u` between the `i`^th and the `j`^th, inclusive. The result is the empty list [] if `j`=`i`–1.
`u`[`i` ...]	0 `i` \|`u`\|	The list slice [`e_i`, `e`_i+1, ... , `e`_n–1] consisting of all elements of `u` between the `i`^th and the end. The result is the empty list [] if `i`=`n`.
`u`[`i` \ `x`]	0 `i` < \|`u`\|	The list [`e`₀, ... , `e`_i–1, `x`, `e`_i+1, ... , `e`_n–1] with the `i`^th element replaced by the value `x` and the other elements unchanged
`u` `v`		The concatenated list [`e`₀, `e`₁, ... , `e`_n–1, `f`₀, `f`₁, ... , `f`_m–1]
repeat(`e`, `i`)	i 0	The list [`e`, `e`, ... , `e`] of length `i` containing `i` identical elements `e`
`u` = `v`		true if the lists `u` and `v` are equal and false otherwise. Lists `u` and `v` are equal if they have the same length and all of their corresponding elements are equal.
`u` `v`		false if the lists `u` and `v` are equal and true otherwise.

Lists are functional — there is no notation for modifying a list in place.

If T is a semantic domain, then T[] is the semantic domain of all lists whose elements are members of T. The empty list [] is a member of T[] for any semantic domain T.

In addition to the above, the some and every quantifiers can be used on lists just as on sets:

some x u satisfies predicate(x)
every x u satisfies predicate(x)

These quantifiers’ behavior on lists is analogous to that on sets, except that, if the some quantifier returns true then it leaves variable x set to the first element of list u that satisfies condition predicate(x). For example,

some x [3, 36, 19, 26] satisfies x mod 10 = 6

evaluates to true and leaves x set to 36.

Strings

A list of Char16 code units is called a string. In addition to the normal list notation, for notational convenience a string can also be written as zero or more characters enclosed in double quotes (see also the notation for non-ASCII characters). Thus,

“Wonder«LF»”

is equivalent to:

[‘W’, ‘o’, ‘n’, ‘d’, ‘e’, ‘r’, ‘«LF»’]

The empty string is written as “”.

A string holds code units, not code points. Supplementary Unicode characters are represented as pairs of surrogate code units when stored in strings.

In addition to all of the other list operations, <, , >, and are defined on strings. A string x is less than string y when y is not the empty string and either x is the empty string, the first code unit of x is less than the first code unit of y, or the first code unit of x is equal to the first code unit of y and the rest of string x is less than the rest of string y.

Note that these relations compare code units, not code points, which can produce unexpected effects if a string contains supplementary characters expanded into a pairs of surrogates. For example, even though ‘«uFFFF»’ < ‘«U00010000»’, the supplementary character ‘«U00010000»’ is represented in a string as “«uD800»«uDC00»”, and, by the above rules, “«uFFFF»” > “«uD800»«uDC00»”.

String is the semantic domain of all strings. String = Char16[].

Tuples

A tuple is an immutable aggregate of values comprised of a name and zero or more labeled fields.

The pseudocode defines each tuple and describes its fields. A tuple definition has the form

tuple Name

label₁: T₁,

... ,

label_n: T_n

end tuple;

and defines tuples with name Name to have n fields with semantic domains T₁ through T_n respectively. In the HTML version of the semantics, each use of a tuple’s Name is linked back to its definition.

After Name is defined, the notation

Namelabel₁: v₁, ... , label_n: v_n

represents a tuple with name Name and values v₁ through v_n for fields labeled label₁ through label_n respectively. Each value v_i is a member of the corresponding semantic domain T_i. When most of the fields are copied from an existing tuple a, this notation can be abbreviated as

Namelabel_i1: v_i1, ... , label_ik: v_ik, other fields from a

which represents a tuple with name Name and values v_i1 through v_ik for fields labeled label_i1 through label_ik respectively and the values of correspondingly labeled fields from a for all other fields.

If a is the tuple Namelabel₁: v₁, ... , label_n: v_n, then

a.label_i

returns the i^th field’s value v_i. Tuples are functional — there is no notation for modifying a tuple in place. In the HTML version of the semantics, each use of label_i is linked back to a’s type.

The equality operators = and may be used to compare tuples. Tuples are equal when they have the same name and their corresponding fields’ values are equal.

The notation

Name

represents the semantic domain of all tuples with name Name.

Records

A record is a mutable aggregate of values similar to a tuple but with different equality behavior.

A record is comprised of a name and an address. The address points to a mutable data structure comprised of zero or more labeled fields. The address acts as the record’s serial number — every record allocated by new (see below) gets a different address, including records created by identical expressions or even the same expression used twice.

The pseudocode defines each record and describes its fields. A record definition has the form

record Name

label₁: T₁,

... ,

label_n: T_n

end record;

and defines records with name Name to have n fields with semantic domains T₁ through T_n respectively. In the HTML version of the semantics, each use of a record’s Name is linked back to its definition.

After Name is defined, the expression

new Namelabel₁: v₁, ... , label_n: v_n

creates a record with name Name and a new address . The fields labeled label₁ through label_n at address are initialized with values v₁ through v_n respectively. Each value v_i is a member of the corresponding semantic domain T_i. A label_k: v_k pair may be omitted from a new expression, which indicates that the initial value of field label_k does not matter because the semantics will always explicitly write a value into that field before reading it.

When most of the fields are copied from an existing record a, the new expression can be abbreviated as

new Namelabel_i1: v_i1, ... , label_ik: v_ik, other fields from a

which represents a record b with name Name and a new address . The fields labeled label_i1 through label_ik at address are initialized with values v_i1 through v_ik respectively; the other fields at address are initialized with the values of correspondingly labeled fields from a’s address.

If a is a record with name Name and address , then

a.label_i

returns the current value v of the i^th field at address . That field may be set to a new value w, which must be a member of the semantic domain T_i, using the assignment

a.label_i w

after which a.label_i will evaluate to w. Any record with a different address is unaffected by the assignment. In the HTML version of the semantics, each use of label_i is linked back to a’s type.

The equality operators = and may be used to compare records. Records are equal if and only if they have the same address.

The notation

Name

represents the infinite semantic domain of all records that have name Name and all addresses.

ECMAScript Numeric Types

ECMAScript does not support exact real numbers as one of the programmer-visible data types. Instead, ECMAScript numbers have finite range and precision. The semantic domain of all programmer-visible numbers representable in ECMAScript is GeneralNumber, defined as the union of four basic numeric semantic domains Long, ULong, Float32, and Float64:

GeneralNumber = Long ULong Float32 Float64

The four basic numeric semantic domains are all disjoint from each other and from the semantic domains Integer, Rational, and Real.

The semantic domain FiniteGeneralNumber is the subtype of all finite values in GeneralNumber:

FiniteGeneralNumber = Long ULong FiniteFloat32 FiniteFloat64

Signed Long Integers

Programmer-visible signed 64-bit long integers are represented by the semantic domain Long. These are wrapped in a tuple to keep them disjoint from members of the semantic domains ULong, Float32, and Float64.

tuple Long

value: {–2⁶³ ... 2⁶³ – 1}

end tuple

Shorthand Notation

In this specification, when i is an integer between –2⁶³ and 2⁶³ – 1, the notation i_long indicates the result of Longvalue: i, which is the integer i wrapped in a Long tuple.

Unsigned Long Integers

Programmer-visible unsigned 64-bit long integers are represented by the semantic domain ULong. These are wrapped in a tuple to keep them disjoint from members of the semantic domains Long, Float32, and Float64.

tuple ULong

value: {0 ... 2⁶⁴ – 1}

end tuple

Shorthand Notation

In this specification, when i is an integer between 0 and 2⁶⁴ – 1, the notation i_ulong indicates the result of ULongvalue: i, which is the integer i wrapped in a ULong tuple.

Single-Precision Floating-Point Numbers

Float32 is the semantic domain of all representable single-precision floating-point IEEE 754 values, with all not-a-number values considered indistinguishable from each other. Float32 is the union of the following semantic domains:

Float32 = FiniteFloat32 {+_f32, –_f32, NaN_f32};

FiniteFloat32 = NonzeroFiniteFloat32 {+zero_f32, –zero_f32}

The non-zero finite values are wrapped in a tuple to keep them disjoint from members of the semantic domains Long, ULong, and Float64. The remaining values are the tags +zero_f32 (positive zero), –zero_f32 (negative zero), +_f32 (positive infinity), –_f32 (negative infinity), and NaN_f32 (not a number).

tuple NonzeroFiniteFloat32

value: NormalizedFloat32Values DenormalizedFloat32Values

end tuple

There are 4261412864 (that is, 2³²–2²⁵) normalized values:

NormalizedFloat32Values = {sm2^e | s {–1, 1}, m {2²³ ... 2²⁴–1}, e {–149 ... 104}}

m is called the significand.

There are also 16777214 (that is, 2²⁴–2) denormalized non-zero values:

DenormalizedFloat32Values = {sm2^–149 | s {–1, 1}, m {1 ... 2²³–1}}

m is called the significand.

Members of the semantic domain NonzeroFiniteFloat32 with value greater than zero are called positive finite. The remaining members of NonzeroFiniteFloat32 are called negative finite.

Since floating-point numbers are either tags or tuples wrapping rational numbers, the notation = and may be used to compare them. Note that = is false for different tags, so +zero_f32 –zero_f32 but NaN_f32 = NaN_f32. The ECMAScript x == y and x === y operators have different behavior for Float32 values, defined by isEqual and isStrictlyEqual.

Shorthand Notation

In this specification, when x is a real number, the notation x_f32 indicates the result of realToFloat32(x), which is the “closest” Float32 value as defined below. Thus, 3.4 is a Real number, while 3.4_f32 is a Float32 value (whose exact value is actually 3.400000095367431640625). The positive finite Float32 values range from 10^–45_f32 to (3.4028235 10³⁸)_f32.

Conversion

The procedure realToFloat32 converts a real number x into the applicable element of Float32 as follows:

proc realToFloat32(x: Real): Float32

s: Rational{} NormalizedFloat32Values DenormalizedFloat32Values {–2¹²⁸, 0, 2¹²⁸};

Let a: Rational be the element of s closest to x (i.e. such that |a–x| is as small as possible). If two elements of s are equally close, let a be the one with an even significand; for this purpose –2¹²⁸, 0, and 2¹²⁸ are considered to have even significands.

if a = 2¹²⁸ then return +_f32

elsif a = –2¹²⁸ then return –_f32

elsif a 0 then return NonzeroFiniteFloat32value: a

elsif x < 0 then return –zero_f32

else return +zero_f32

end if

end proc

This procedure corresponds exactly to the behavior of the IEEE 754 “round to nearest” mode.

The procedure truncateFiniteFloat32 truncates a FiniteFloat32 value to an integer, rounding towards zero:

proc truncateFiniteFloat32(x: FiniteFloat32): Integer

if x {+zero_f32, –zero_f32} then return 0 end if;

r: Rational x.value;

if r > 0 then return r else return r end if

end proc

Arithmetic

The following table defines negation of Float32 values using IEEE 754 rules. Note that expr_f32 indicates the result of realToFloat32(expr).

float32Negate(x: Float32): Float32

`x`	Result
–_f32	+_f32
negative finite	(–`x`.value)_f32
–zero_f32	+zero_f32
+zero_f32	–zero_f32
positive finite	(–`x`.value)_f32
+_f32	–_f32
NaN_f32	NaN_f32

Double-Precision Floating-Point Numbers

Float64 is the semantic domain of all representable double-precision floating-point IEEE 754 values, with all not-a-number values considered indistinguishable from each other. Float64 is the union of the following semantic domains:

Float64 = FiniteFloat64 {+_f64, –_f64, NaN_f64};

FiniteFloat64 = NonzeroFiniteFloat64 {+zero_f64, –zero_f64}

The non-zero finite values are wrapped in a tuple to keep them disjoint from members of the semantic domains Long, ULong, and Float32. The remaining values are the tags +zero_f64 (positive zero), –zero_f64 (negative zero), +_f64 (positive infinity), –_f64 (negative infinity), and NaN_f64 (not a number).

tuple NonzeroFiniteFloat64

value: NormalizedFloat64Values DenormalizedFloat64Values

end tuple

There are 18428729675200069632 (that is, 2⁶⁴–2⁵⁴) normalized values:

NormalizedFloat64Values = {sm2^e | s {–1, 1}, m {2⁵² ... 2⁵³–1}, e {–1074 ... 971}}

m is called the significand.

There are also 9007199254740990 (that is, 2⁵³–2) denormalized non-zero values:

DenormalizedFloat64Values = {sm2^–1074 | s {–1, 1}, m {1 ... 2⁵²–1}}

m is called the significand.

Members of the semantic domain NonzeroFiniteFloat64 with value greater than zero are called positive finite. The remaining members of NonzeroFiniteFloat64 are called negative finite.

Since floating-point numbers are either tags or tuples wrapping rational numbers, the notation = and may be used to compare them. Note that = is false for different tags, so +zero_f64 –zero_f64 but NaN_f64 = NaN_f64. The ECMAScript x == y and x === y operators have different behavior for Float64 values, defined by isEqual and isStrictlyEqual.

Shorthand Notation

In this specification, when x is a real number, the notation x_f64 indicates the result of realToFloat64(x), which is the “closest” Float64 value as defined below. Thus, 3.4 is a Real number, while 3.4_f64 is a Float64 value (whose exact value is actually 3.399999999999999911182158029987476766109466552734375). The positive finite Float64 values range from (5 10^–324)_f64 to (1.7976931348623157 10³⁰⁸)_f64.

Conversion

The procedure realToFloat64 converts a real number x into the applicable element of Float64 as follows:

proc realToFloat64(x: Real): Float64

s: Rational{} NormalizedFloat64Values DenormalizedFloat64Values {–2¹⁰²⁴, 0, 2¹⁰²⁴};

Let a: Rational be the element of s closest to x (i.e. such that |a–x| is as small as possible). If two elements of s are equally close, let a be the one with an even significand; for this purpose –2¹⁰²⁴, 0, and 2¹⁰²⁴ are considered to have even significands.

if a = 2¹⁰²⁴ then return +_f64

elsif a = –2¹⁰²⁴ then return –_f64

elsif a 0 then return NonzeroFiniteFloat64value: a

elsif x < 0 then return –zero_f64

else return +zero_f64

end if

end proc

This procedure corresponds exactly to the behavior of the IEEE 754 “round to nearest” mode.

The procedure float32ToFloat64 converts a Float32 number x into the corresponding Float64 number as defined by the following table:

proc float32ToFloat64(x: Float32): Float64

`x`	Result
–_f32	–_f64
–zero_f32	–zero_f64
+zero_f32	+zero_f64
+_f32	+_f64
NaN_f32	NaN_f64
Any NonzeroFiniteFloat32 value	NonzeroFiniteFloat64value: `x`.value

The procedure truncateFiniteFloat64 truncates a FiniteFloat64 value to an integer, rounding towards zero:

proc truncateFiniteFloat64(x: FiniteFloat64): Integer

if x {+zero_f64, –zero_f64} then return 0 end if;

r: Rational x.value;

if r > 0 then return r else return r end if

end proc

Arithmetic

The following tables define procedures that perform common arithmetic on Float64 values using IEEE 754 rules. Note that expr_f64 indicates the result of realToFloat64(expr).

float64Abs(x: Float64): Float64

`x`	Result
–_f64	+_f64
negative finite	(–`x`.value)_f64
–zero_f64	+zero_f64
+zero_f64	+zero_f64
positive finite	`x`
+_f64	+_f64
NaN_f64	NaN_f64

float64Negate(x: Float64): Float64

`x`	Result
–_f64	+_f64
negative finite	(–`x`.value)_f64
–zero_f64	+zero_f64
+zero_f64	–zero_f64
positive finite	(–`x`.value)_f64
+_f64	–_f64
NaN_f64	NaN_f64

float64Add(x: Float64, y: Float64): Float64

`x`	`y`
`x`	–_f64	negative finite	–zero_f64	+zero_f64	positive finite	+_f64	NaN_f64
–_f64	–_f64	–_f64	–_f64	–_f64	–_f64	NaN_f64	NaN_f64
negative finite	–_f64	(`x`.value + `y`.value)_f64	`x`	`x`	(`x`.value + `y`.value)_f64	+_f64	NaN_f64
–zero_f64	–_f64	`y`	–zero_f64	+zero_f64	`y`	+_f64	NaN_f64
+zero_f64	–_f64	`y`	+zero_f64	+zero_f64	`y`	+_f64	NaN_f64
positive finite	–_f64	(`x`.value + `y`.value)_f64	`x`	`x`	(`x`.value + `y`.value)_f64	+_f64	NaN_f64
+_f64	NaN_f64	+_f64	+_f64	+_f64	+_f64	+_f64	NaN_f64
NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64

float64Subtract(x: Float64, y: Float64): Float64

`x`	`y`
`x`	–_f64	negative finite	–zero_f64	+zero_f64	positive finite	+_f64	NaN_f64
–_f64	NaN_f64	–_f64	–_f64	–_f64	–_f64	–_f64	NaN_f64
negative finite	+_f64	(`x`.value – `y`.value)_f64	`x`	`x`	(`x`.value – `y`.value)_f64	–_f64	NaN_f64
–zero_f64	+_f64	(–`y`.value)_f64	+zero_f64	–zero_f64	(–`y`.value)_f64	–_f64	NaN_f64
+zero_f64	+_f64	(–`y`.value)_f64	+zero_f64	+zero_f64	(–`y`.value)_f64	–_f64	NaN_f64
positive finite	+_f64	(`x`.value – `y`.value)_f64	`x`	`x`	(`x`.value – `y`.value)_f64	–_f64	NaN_f64
+_f64	+_f64	+_f64	+_f64	+_f64	+_f64	NaN_f64	NaN_f64
NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64

float64Multiply(x: Float64, y: Float64): Float64

`x`	`y`
`x`	–_f64	negative finite	–zero_f64	+zero_f64	positive finite	+_f64	NaN_f64
–_f64	+_f64	+_f64	NaN_f64	NaN_f64	–_f64	–_f64	NaN_f64
negative finite	+_f64	(`x`.value `y`.value)_f64	+zero_f64	–zero_f64	(`x`.value `y`.value)_f64	–_f64	NaN_f64
–zero_f64	NaN_f64	+zero_f64	+zero_f64	–zero_f64	–zero_f64	NaN_f64	NaN_f64
+zero_f64	NaN_f64	–zero_f64	–zero_f64	+zero_f64	+zero_f64	NaN_f64	NaN_f64
positive finite	–_f64	(`x`.value `y`.value)_f64	–zero_f64	+zero_f64	(`x`.value `y`.value)_f64	+_f64	NaN_f64
+_f64	–_f64	–_f64	NaN_f64	NaN_f64	+_f64	+_f64	NaN_f64
NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64

float64Divide(x: Float64, y: Float64): Float64

`x`	`y`
`x`	–_f64	negative finite	–zero_f64	+zero_f64	positive finite	+_f64	NaN_f64
–_f64	NaN_f64	+_f64	+_f64	–_f64	–_f64	NaN_f64	NaN_f64
negative finite	+zero_f64	(`x`.value / `y`.value)_f64	+_f64	–_f64	(`x`.value / `y`.value)_f64	–zero_f64	NaN_f64
–zero_f64	+zero_f64	+zero_f64	NaN_f64	NaN_f64	–zero_f64	–zero_f64	NaN_f64
+zero_f64	–zero_f64	–zero_f64	NaN_f64	NaN_f64	+zero_f64	+zero_f64	NaN_f64
positive finite	–zero_f64	(`x`.value / `y`.value)_f64	–_f64	+_f64	(`x`.value / `y`.value)_f64	+zero_f64	NaN_f64
+_f64	NaN_f64	–_f64	–_f64	+_f64	+_f64	NaN_f64	NaN_f64
NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64

float64Remainder(x: Float64, y: Float64): Float64

`x`	`y`
`x`	–_f64, +_f64	positive or negative finite	–zero_f64, +zero_f64	NaN_f64
–_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64
negative finite	`x`	float64Negate(float64Remainder(float64Negate(`x`), `y`))	NaN_f64	NaN_f64
–zero_f64	–zero_f64	–zero_f64	NaN_f64	NaN_f64
+zero_f64	+zero_f64	+zero_f64	NaN_f64	NaN_f64
positive finite	`x`	(`x`.value – \|`y`.value\|`x`.value/\|`y`.value\|)_f64	NaN_f64	NaN_f64
+_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64
NaN_f64	NaN_f64	NaN_f64	NaN_f64	NaN_f64

Note that float64Remainder(float64Negate(x), y) always produces the same result as float64Negate(float64Remainder(x, y)). Also, float64Remainder(x, float64Negate(y)) always produces the same result as float64Remainder(x, y).

Procedures

A procedure is a function that receives zero or more arguments, performs computations, and optionally returns a result. Procedures may perform side effects. In this document the word procedure is used to refer to internal algorithms; the word function is used to refer to the programmer-visible function ECMAScript construct.

A procedure is denoted as:

proc f(param₁: T₁, ... , param_n: T_n): T

step₁;

step₂;

... ;

step_m

end proc;

If the procedure does not return a value, the : T on the first line is omitted.

f is the procedure’s name, param₁ through param_n are the procedure’s parameters, T₁ through T_n are the parameters’ respective semantic domains, T is the semantic domain of the procedure’s result, and step₁ through step_m describe the procedure’s computation steps, which may produce side effects and/or return a result. If T is omitted, the procedure does not return a result. When the procedure is called with argument values v₁ through v_n, the procedure’s steps are performed and the result, if any, returned to the caller.

A procedure’s steps can refer to the parameters param₁ through param_n; each reference to a parameter param_i evaluates to the corresponding argument value v_i. Procedure parameters are statically scoped. Arguments are passed by value.

Operations

The only operation done on a procedure f is calling it using the f(arg₁, ..., arg_n) syntax. f is computed first, followed by the argument expressions arg₁ through arg_n, in left-to-right order. If the result of computing f or any of the argument expressions throws an exception e, then the call immediately propagates e without computing any following argument expressions. Otherwise, f is invoked using the provided arguments and the resulting value, if any, returned to the caller.

Procedures are never compared using =, , or any of the other comparison operators.

Semantic Domains of Procedures

The semantic domain of procedures that take n parameters in semantic domains T₁ through T_n respectively and produce a result in semantic domain T is written as T₁ T₂ ... T_n T. If n = 0, this semantic domain is written as () T. If the procedure does not produce a result, the semantic domain of procedures is written either as T₁ T₂ ... T_n () or as () ().

Computation Steps

Computation steps in procedures are described using a mixture of English and formal notation. The various kinds of formal steps are described in this section. Multiple steps are separated by semicolons and performed in order unless an earlier step exits via a return or propagates an exception.

Informal steps state invariants and provide comments.

nothing

A nothing step performs no operation.

note Comment

A note step performs no operation. It provides an informative comment about the algorithm. If Comment is an expression, then the note step is an informative comment that asserts that the expression, if evaluated at this point, would be guaranteed to evaluate to true.

expression

A computation step may consist of an expression. The expression is computed and its value, if any, ignored.

v: T expression

v expression

An assignment step is indicated using the assignment operator . This step computes the value of expression and assigns the result to the temporary variable or mutable global v. If this is the first time the temporary variable is referenced in a procedure, the variable’s semantic domain T is listed; any value stored in v is guaranteed to be a member of the semantic domain T.

v: T

This step declares v to be a temporary variable with semantic domain T without assigning anything to the variable. v will not be read unless some other step first assigns a value to it.

Action[nonterminal_i] expression

Inside an action, the assignment operator can also be used to define the result of another action Action[nonterminal_i] applied to the current expansion of nonterminal_i, which must appear on the current production’s left or right side. Such an assignment is done only when the value of Action[nonterminal_i] is not defined explicitly via an action. The value of Action[nonterminal_i] is set at most once and never modified afterwards. If the same nonterminal is expanded several times while parsing a source program, all such expansions are treated independently.

Temporary variables are local to the procedures that define them (including any nested procedures). Each time a procedure is called it gets a new set of temporary variables.

a.label expression

This form of assignment sets the value of field label of record a to the value of expression.

if expression₁ then step; step; ...; step

elsif expression₂ then step; step; ...; step

...

elsif expression_n then step; step; ...; step

else step; step; ...; step

end if

An if step computes expression₁, which will evaluate to either true or false. If it is true, the first list of steps is performed. Otherwise, expression₂ is computed and tested, and so on. If no expression evaluates to true, the list of steps following the else is performed. The else clause may be omitted, in which case no action is taken when no expression evaluates to true.

case expression of

T₁ do step; step; ...; step;

T₂ do step; step; ...; step;

...;

T_n do step; step; ...; step

else step; step; ...; step

end case

A case step computes expression, which will evaluate to a value v. If v T₁, then the first list of steps is performed. Otherwise, if v T₂, then the second list of steps is performed, and so on. If v is not a member of any T_i, the list of steps following the else is performed. The else clause may be omitted, in which case v will always be a member of some T_i.

while expression do

step;

...;

step

end while

A while step computes expression, which will evaluate to either true or false. If it is false, no action is taken. If it is true, the list of steps is performed and then expression is computed and tested again. This repeats until expression returns true (or until the procedure exits via a return or an exception is propagated out).

for each x expression do

step;

...;

step

end for each

A for each step computes expression, which will evaluate to either a set or a list A. The list of steps is performed repeatedly with variable x bound to each element of A. If A is a list, x is bound to each of its elements in order; if A is a set, the order in which x is bound to its elements is arbitrary. The repetition ends after x has been bound to all elements of A (or when either the procedure exits via a return or an exception is propagated out).

return expression

A return step computes expression to obtain a value v and returns from the enclosing procedure with the result v. No further steps in the enclosing procedure are performed. The expression may be omitted, in which case the enclosing procedure returns with no result.

Exceptions

throw expression

A throw step computes expression to obtain a value v and begins propagating exception v outwards, exiting partially performed steps and procedure calls until the exception is caught by a catch step. Unless the enclosing procedure catches this exception, no further steps in the enclosing procedure are performed.

try

step;

...;

step

catch v: T do

step;

...;

step

end try

A try step performs the first list of steps. If they complete normally (or if they return), then the try step is done. If any of the steps propagates out an exception e, then if e T, then exception e stops propagating, variable v is bound to the value e, and the second list of steps is performed. If e T, then exception e keeps propagating out.

A try step does not intercept exceptions that may be propagated out of its second list of steps.

Nested Procedures

An inner proc may be nested as a step inside an outer proc. In this case the inner procedure is a closure and can access the parameters and temporaries of the outer procedure.

Semantic Actions

Semantic actions tie the grammar and the semantics together. A semantic action ascribes semantic meaning to a grammar production.

To illustrate the use of semantic actions, we shall look at an example, followed by a description of the notation for specifying semantic actions.

Example

Consider the following grammar, with the start nonterminal Numeral:

Digit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Digits

Digit

| Digits Digit

Numeral

Digits

| Digits # Digits

This grammar defines the syntax of an acceptable input: “37”, “33#4” and “30#2” are acceptable syntactically, while “1a” is not. However, the grammar does not indicate what these various inputs mean. That is the job of the semantics, which are defined in terms of actions on the parse tree of grammar rule expansions. Consider the following sample set of actions defined on this grammar, with a starting Numeral action called (in this example) Value:

tag syntaxError;

SemanticException = {syntaxError};

Value[Digit]: Integer = digitValue(Digit);

DecimalValue[Digits]: Integer;

DecimalValue[Digits Digit] = Value[Digit];

DecimalValue[Digits₀ Digits₁ Digit] = 10DecimalValue[Digits₁] + Value[Digit];

proc BaseValue[Digits] (base: Integer): Integer

[Digits Digit] do

d: Integer Value[Digit];

if d < base then return d else throw syntaxError end if;

[Digits₀ Digits₁ Digit] do

d: Integer Value[Digit];

if d < base then return baseBaseValue[Digits₁](base) + d

else throw syntaxError

end if

end proc;

Value[Numeral]: Integer;

Value[Numeral Digits] = DecimalValue[Digits];

Value[Numeral Digits₁ # Digits₂]

begin

base: Integer DecimalValue[Digits₂];

if base 2 and base 10 then return BaseValue[Digits₁](base)

else throw syntaxError

end if

end;

Action names are written in violet cursive type. The definition

Value[Numeral]: Integer;

states that the action Value can be applied to any expansion of the nonterminal Numeral, and the result is an Integer. This action either maps an input to an integer or throws an exception. The code above throws the exception syntaxError when presented with the input “30#2”.

There are two definitions of the Value action on Numeral, one for each grammar production that expands Numeral:

Value[Numeral Digits] = DecimalValue[Digits];

Value[Numeral Digits₁ # Digits₂]

begin

base: Integer DecimalValue[Digits₂];

if base 2 and base 10 then return BaseValue[Digits₁](base)

else throw syntaxError

end if

end;

Each definition of an action is allowed to perform actions on the terminals and nonterminals on the right side of the expansion. For example, Value applied to the first Numeral production (the one that expands Numeral into Digits) simply applies the DecimalValue action to the expansion of the nonterminal Digits and returns the result. On the other hand, Value applied to the second Numeral production (the one that expands Numeral into Digits # Digits) performs a computation using the results of the DecimalValue and BaseValue applied to the two expansions of the Digits nonterminals. In this case there are two identical nonterminals Digits on the right side of the expansion, so subscripts are used to indicate on which the actions DecimalValue and BaseValue are performed.

The definition

proc BaseValue[Digits] (base: Integer): Integer

[Digits Digit] do

d: Integer Value[Digit];

if d < base then return d else throw syntaxError end if;

[Digits₀ Digits₁ Digit] do

d: Integer Value[Digit];

if d < base then return baseBaseValue[Digits₁](base) + d

else throw syntaxError

end if

end proc;

states that the action BaseValue can be applied to any expansion of the nonterminal Digits, and the result is a procedure that takes one Integer argument base and returns an Integer. The procedure’s body is comprised of independent cases for each production that expands Digits. When the procedure is called, the case corresponding to the expansion of the nonterminal Digits is evaluated.

The Value action on Digit illustrates the direct use of a nonterminal in a semantic expression: digitValue(Digit). Using the nonterminal Digit in this way refers to the character into which the Digit grammar rule expands.

We can fully evaluate the semantics on our sample inputs to get the following results:

Input	Semantic Result
`37`	37
`33#4`	15
`30#2`	throw syntaxError

Abbreviated Actions

In some cases the all actions named A for a nonterminal N’s rule are repetitive, merely calling A on the nonterminals on the right side of the expansions of N in the grammar. In these cases the semantics of action A are abbreviated, as illustrated by the example below.

Given the grammar rule

Expression

Subexpression

| Expression * Subexpression

| Subexpression + Subexpression

| this

the notation

Validate[Expression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Expression.

is an abbreviation for the following:

proc Validate[Expression] (cxt: Context, env: Environment)

[Expression Subexpression] do Validate[Subexpression](cxt, env);

[Expression₀ Expression₁ * Subexpression] do

Validate[Expression₁](cxt, env);

Validate[Subexpression](cxt, env);

[Expression Subexpression₁ + Subexpression₂] do

Validate[Subexpression₁](cxt, env);

Validate[Subexpression₂](cxt, env);

[Expression this] do nothing

end proc;

Note that:

The expanded calls to Validate get the same arguments cxt and env passed in to the call to Validate on Expression.
When an expansion of Expression has more than one nonterminal on its right side, Validate is called on all of the nonterminals in left-to-right order.
When an expansion of Expression has no nonterminals on its right side, Validate does nothing.

The propagation notation is also used in when the actions return a value. In this case each expansion must have exactly one nonterminal. For example, given the grammar rule

SimpleId

| ComplexId

the notation

Eval[Id] (env: Environment, phase: Phase): Multiname propagates the call to Eval to nonterminals in the expansion of Id.

is an abbreviation for the following:

proc Eval[Id] (env: Environment, phase: Phase): Multiname

[Id SimpleId] do return Eval[SimpleId](env, phase);

[Id ComplexId] do return Eval[ComplexId](env, phase)

end proc;

Semantic Definition Summary

The following notation is used to define top-level semantic entities:

Name = expression;

This notation defines Name to be a shorthand for the semantic domain expression. In the HTML version of the semantics, each use of Name is linked back to this definition.

name: T = expression;

This notation defines name to be a constant value given by the result of computing expression. The value is guaranteed to be a member of the semantic domain T. In the HTML version of the semantics, each use of name is linked back to this definition.

name: T expression;

This notation defines name to be a mutable global value. Its initial value is the result of computing expression, but it may be subsequently altered using an assignment. The value is guaranteed to be a member of the semantic domain T. In the HTML version of the semantics, each use of name is linked back to this definition.

proc f(param₁: T₁, ... , param_n: T_n): T

step₁;

step₂;

... ;

step_m

end proc;

This notation defines f to be a procedure.

tag name;

This notation defines a tag.

tuple Name

label₁: T₁,

... ,

label_n: T_n

end tuple;

This notation defines a tuple.

record Name

label₁: T₁,

... ,

label_n: T_n

end record;

This notation defines a record.

Action[nonterminal]: T;

This notation states that action Action can be performed on nonterminal nonterminal and returns a value that is a member of the semantic domain T. The action’s value is either defined using the notation Action[nonterminal expansion] = expression below or set as a side effect of computing another action via an action assignment.

Action[nonterminal expansion] = expression;

This notation specifies the value that action Action on nonterminal nonterminal computes in the case where nonterminal nonterminal expands to the given expansion. expansion can contain zero or more terminals and nonterminals (as well as other notations allowed on the right side of a grammar production). Furthermore, the terminals and nonterminals of expansion can be subscripted to allow them to be unambiguously referenced by action references or nonterminal references inside expression.

Action[nonterminal expansion]: T = expression;

This notation combines the above two — it specifies the semantic domain of the action as well as its value.

Action[nonterminal expansion]

begin

step₁;

step₂;

... ;

step_m

end;

This notation is used when the computation of the action is too complex for an expression. Here the steps to compute the action are listed as step₁ through step_m. A return step produces the value of the action.

proc Action[nonterminal expansion] (param₁: T₁, ... , param_n: T_n): T

step₁;

step₂;

... ;

step_m

end proc;

This notation is used only when Action returns a procedure when applied to nonterminal nonterminal with a single expansion expansion. Here the steps of the procedure are listed as step₁ through step_m.

proc Action[nonterminal] (param₁: T₁, ... , param_n: T_n): T

[nonterminal expansion₁] do

step;

... ;

step;

[nonterminal expansion₂] do

step;

... ;

step;

...;

[nonterminal expansion_n] do

step;

... ;

step

end proc;

This notation is used only when Action returns a procedure when applied to nonterminal nonterminal with several expansions expansion₁ through expansion_n. The procedure is comprised of a series of cases, one for each expansion. Only the steps corresponding to the expansion found by the grammar parser used are evaluated.

Action[nonterminal] (param₁: T₁, ... , param_n: T_n) propagates the call to Action to every nonterminal in the expansion of nonterminal.

This notation is an abbreviation stating that calling Action on nonterminal causes Action to be called with the same arguments on every nonterminal on the right side of the appropriate expansion of nonterminal.

ECMAScript 4 Netscape Proposal

Formal Description

Stages

Tuesday, October 15, 2002

The source code is processed in the following stages:

If necessary, convert the source code into the Unicode UTF-16 format, normalized form C.
Remove any Unicode format control characters (category Cf) from the source code.
Simultaneously split the source code into input elements using the lexical grammar and semantics and parse it using the syntactic grammar to obtain a parse tree P.
Evaluate P using the syntactic semantics by computing the action Eval on it.

Lexing and Parsing

Processing stage 3 is done as follows:

Let inputElements be an empty array of input elements (syntactic grammar terminals and line breaks).
Let input be the input sequence of Unicode characters. Append a special placeholder End to the end of input.
Let state be a variable that holds one of the constants re, div, or num. Initialize it to re.
Apply the lexical grammar to parse the longest possible prefix of input. Use the start symbol NextInputElement^re, NextInputElement^div, or NextInputElement^num depending on whether state is re, div, or num, respectively. The result of the parse should be a lexical grammar parse tree T. If the parse failed, return a syntax error.
Compute the action InputElement on T to obtain an InputElement e.
If e is the endOfInput input element, go to step 15.
Remove the characters matched by T from input, leaving only the yet-unlexed suffix of input.
Interpret e as a syntactic grammar terminal or line break as follows:
- A lineBreak is interpreted as a line break, which is not a terminal itself but indicates one or more line breaks between two terminals. It prevents the syntactic grammar from matching any productions that have a [no line break] annotation in the place where the lineBreak occurred.
- An Identifier s is interpreted as the terminal Identifier. Applying the semantic action Name to the Identifier returns the String value s.name.
- A Keyword s is interpreted as the reserved word, future reserved word, or non-reserved word terminal corresponding to the Keyword’s String s.
- A Punctuator s is interpreted as the punctuation token or future punctuation token terminal corresponding to the Punctuator’s String s.
- A NumberToken x is interpreted as the terminal Number. Applying the semantic action Value to the Number returns the GeneralNumber value x.value.
- A negatedMinLong, which results from a numeric long token with the value 2⁶³, is interpreted as the terminal NegatedMinLong.
- A StringToken s is interpreted as the terminal String. Applying the semantic action Value to the String returns the String value s.value.
- A RegularExpression z is interpreted as the terminal RegularExpression.
Append the resulting terminal or line break to the end of the inputElements array.
If the inputElements array forms a valid prefix of the context-free language defined by the syntactic grammar, go to step 13.
If is not a lineBreak but the previous element of the inputElements array is a lineBreak, then insert a VirtualSemicolon terminal between that lineBreak and in the inputElements array.
If the inputElements array still does not form a valid prefix of the context-free language defined by the syntactic grammar, signal a syntax error and stop.
If is a Number or NegatedMinLong, then set state to num. Otherwise, if the inputElements array followed by the terminal / forms a valid prefix of the context-free language defined by the syntactic grammar, then set state to div; otherwise, set state to re.
Go to step 4.
If the inputElements array does not form a valid sentence of the context-free language defined by the syntactic grammar, signal a syntax error and stop.
Return the parse tree obtained by the syntactic grammar’s derivation of the sentence formed by the inputElements array.

ECMAScript 4 Netscape Proposal

Formal Description

Lexical Grammar

Monday, June 30, 2003

This LALR(1) grammar describes the lexical syntax of the ECMAScript 4 proposal. See also the description of the grammar notation.

This document is also available as a Word RTF file.

The lexer’s start symbols are: NextInputElement^num if the previous input element was a number; NextInputElement^re if the previous input element was not a number and a / should be interpreted as a regular expression; and NextInputElement^div if the previous input element was not a number and a / should be interpreted as a division or division-assignment operator.

In addition to the above, the start symbol StringNumericLiteral is used by the syntactic semantics for string-to-number conversions and the start symbol StringDecimalLiteral is used by the syntactic semantics for implementing the parseFloat function.

Unicode Character Classes

UnicodeCharacter Any Unicode character

UnicodeInitialAlphabetic Any character in category Lu (uppercase letter), Ll (lowercase letter), Lt (titlecase letter), Lm (modifier letter), Lo (other letter), or Nl (letter number) in the Unicode Character Database

UnicodeAlphanumeric Any character in category Lu (uppercase letter), Ll (lowercase letter), Lt (titlecase letter), Lm (modifier letter), Lo (other letter), Nd (decimal number), Nl (letter number), Mn (non-spacing mark), Mc (combining spacing mark), or Pc (connector punctuation) in the Unicode Character Database

WhiteSpaceCharacter

«TAB» | «VT» | «FF» | «SP» | «u00A0»

| «u2000» | «u2001» | «u2002» | «u2003» | «u2004» | «u2005» | «u2006» | «u2007»

| «u2008» | «u2009» | «u200A» | «u200B»

| «u3000»

LineTerminator «LF» | «CR» | «u0085» | «u2028» | «u2029»

ASCIIDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Comments

LineComment / / LineCommentCharacters

LineCommentCharacters

«empty»

| LineCommentCharacters NonTerminator

NonTerminator UnicodeCharacter except LineTerminator

SingleLineBlockComment / * BlockCommentCharacters * /

BlockCommentCharacters

«empty»

| BlockCommentCharacters NonTerminatorOrSlash

| PreSlashCharacters /

PreSlashCharacters

«empty»

| BlockCommentCharacters NonTerminatorOrAsteriskOrSlash

| PreSlashCharacters /

NonTerminatorOrSlash NonTerminator except /

NonTerminatorOrAsteriskOrSlash NonTerminator except * | /

MultiLineBlockComment / * MultiLineBlockCommentCharacters BlockCommentCharacters * /

MultiLineBlockCommentCharacters

BlockCommentCharacters LineTerminator

| MultiLineBlockCommentCharacters BlockCommentCharacters LineTerminator

White Space

WhiteSpace

«empty»

| WhiteSpace WhiteSpaceCharacter

| WhiteSpace SingleLineBlockComment

Line Breaks

LineBreak

LineTerminator

| LineComment LineTerminator

| MultiLineBlockComment

LineBreaks

LineBreak

| LineBreaks WhiteSpace LineBreak

Input Elements

{re, div, num}

NextInputElement^re WhiteSpace InputElement^re

NextInputElement^div WhiteSpace InputElement^div

NextInputElement^num [lookahead{ContinuingIdentifierCharacter, \}] WhiteSpace InputElement^div

InputElement^re

LineBreaks

| Punctuator

| RegExpLiteral

| EndOfInput

InputElement^div

LineBreaks

| Punctuator

| DivisionPunctuator

| EndOfInput

EndOfInput

End

| LineComment End

Keywords and Identifiers

IdentifierOrKeyword IdentifierName

IdentifierName

InitialIdentifierCharacterOrEscape

| NullEscapes InitialIdentifierCharacterOrEscape

| IdentifierName ContinuingIdentifierCharacterOrEscape

| IdentifierName NullEscape

NullEscapes

NullEscape

| NullEscapes NullEscape

NullEscape \ _

InitialIdentifierCharacterOrEscape

InitialIdentifierCharacter

| \ HexEscape

InitialIdentifierCharacter UnicodeInitialAlphabetic | $ | _

ContinuingIdentifierCharacterOrEscape

ContinuingIdentifierCharacter

| \ HexEscape

ContinuingIdentifierCharacter UnicodeAlphanumeric | $ | _

Punctuators

Punctuator

!

| ! =

| ! = =

| %

| % =

| &

| & &

| & & =

| & =

| (

| )

| *

| * =

| +

| + +

| + =

| ,

| -

| - -

| - =

| .

| . . .

| :

| : :

| ;

| <

| < <

| < < =

| < =

| =

| = =

| = = =

| >

| > =

| > >

| > > =

| > > >

| > > > =

| ?

| [

| ]

| ^

| ^ =

| ^ ^

| ^ ^ =

| {

| |

| | =

| | |

| | | =

| }

| ~

DivisionPunctuator

/ [lookahead{/, *}]

| / =

Numeric Literals

NumericLiteral

DecimalLiteral^{noLeadingZeros}

| DecimalLiteral^{noLeadingZeros} LetterF

| IntegerLiteral LetterL

| IntegerLiteral LetterU LetterL

IntegerLiteral

DecimalIntegerLiteral^{noLeadingZeros}

LetterF F | f

LetterL L | l

LetterU U | u

{noLeadingZeros, allowLeadingZeros}

DecimalLiteral

Mantissa

| Mantissa LetterE SignedInteger

LetterE E | e

Mantissa

DecimalIntegerLiteral

| DecimalIntegerLiteral .

| DecimalIntegerLiteral . Fraction

| . Fraction

DecimalIntegerLiteral^{noLeadingZeros}

0

DecimalIntegerLiteral^{allowLeadingZeros} DecimalDigits

NonZeroDecimalDigits

NonZeroDigit

| NonZeroDecimalDigits ASCIIDigit

NonZeroDigit 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Fraction DecimalDigits

SignedInteger OptionalSign DecimalDigits

OptionalSign

«empty»

| +

| -

DecimalDigits

ASCIIDigit

| DecimalDigits ASCIIDigit

HexIntegerLiteral

0 LetterX HexDigit

| HexIntegerLiteral HexDigit

LetterX X | x

HexDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | a | b | c | d | e | f

String Literals

{single, double}

StringLiteral

' StringChars^single '

| " StringChars^double "

StringChars

«empty»

| StringChars StringChar

| StringChars NullEscape

StringChar

LiteralStringChar

| \ StringEscape

LiteralStringChar^single UnicodeCharacter except ' | \ | LineTerminator

LiteralStringChar^double UnicodeCharacter except " | \ | LineTerminator

StringEscape

ControlEscape

| ZeroEscape

| HexEscape

IdentityEscape NonTerminator except _ | UnicodeAlphanumeric

ControlEscape

b

| f

| n

| r

| t

| v

ZeroEscape 0 [lookahead{ASCIIDigit}]

HexEscape

x HexDigit HexDigit

| u HexDigit HexDigit HexDigit HexDigit

| U HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit

Regular Expression Literals

RegExpLiteral RegExpBody RegExpFlags

RegExpFlags

«empty»

| RegExpFlags ContinuingIdentifierCharacterOrEscape

| RegExpFlags NullEscape

RegExpBody / [lookahead{*}] RegExpChars /

RegExpChars

RegExpChar

| RegExpChars RegExpChar

RegExpChar

OrdinaryRegExpChar

| \ NonTerminator

OrdinaryRegExpChar NonTerminator except \ | /

String-to-Number Conversion

StringNumericLiteral

StringWhiteSpace

| StringWhiteSpace SignedDecimalLiteral StringWhiteSpace

| StringWhiteSpace OptionalSign HexIntegerLiteral StringWhiteSpace

SignedDecimalLiteral

OptionalSign DecimalLiteral^{allowLeadingZeros}

| OptionalSign I n f i n i t y

| N a N

StringWhiteSpace

«empty»

| StringWhiteSpace WhiteSpaceOrLineTerminatorChar

WhiteSpaceOrLineTerminatorChar WhiteSpaceCharacter | LineTerminator

parseFloat Conversion

StringDecimalLiteral StringWhiteSpace SignedDecimalLiteral

ECMAScript 4 Netscape Proposal

Formal Description

Lexical Semantics

Monday, June 30, 2003

The lexical semantics describe the actions the lexer takes in order to transform an input stream of Unicode characters into a stream of tokens. For convenience, the lexical grammar is repeated here. See also the description of the semantic notation.

This document is also available as a Word RTF file.

Semantics

tag lineBreak;

tag endOfInput;

tuple Keyword

end tuple;

tuple Punctuator

end tuple;

tuple Identifier

end tuple;

tuple NumberToken

value: GeneralNumber

end tuple;

tag negatedMinLong;

tuple StringToken

value: String

end tuple;

tuple RegularExpression

body: String,

flags: String

end tuple;

Token = Keyword Punctuator Identifier NumberToken {negatedMinLong} StringToken RegularExpression;

InputElement = {lineBreak, endOfInput} Token;

tag syntaxError;

tag rangeError;

SemanticException = {syntaxError, rangeError};

Unicode Character Classes

Syntax

UnicodeCharacter Any Unicode character

WhiteSpaceCharacter

«TAB» | «VT» | «FF» | «SP» | «u00A0»

| «u2000» | «u2001» | «u2002» | «u2003» | «u2004» | «u2005» | «u2006» | «u2007»

| «u2008» | «u2009» | «u200A» | «u200B»

| «u3000»

LineTerminator «LF» | «CR» | «u0085» | «u2028» | «u2029»

ASCIIDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Semantics

DecimalValue[ASCIIDigit]: Integer = digitValue(ASCIIDigit);

Comments

Syntax

LineComment / / LineCommentCharacters

LineCommentCharacters

«empty»

| LineCommentCharacters NonTerminator

NonTerminator UnicodeCharacter except LineTerminator

SingleLineBlockComment / * BlockCommentCharacters * /

BlockCommentCharacters

«empty»

| BlockCommentCharacters NonTerminatorOrSlash

| PreSlashCharacters /

PreSlashCharacters

«empty»

| BlockCommentCharacters NonTerminatorOrAsteriskOrSlash

| PreSlashCharacters /

NonTerminatorOrSlash NonTerminator except /

NonTerminatorOrAsteriskOrSlash NonTerminator except * | /

MultiLineBlockComment / * MultiLineBlockCommentCharacters BlockCommentCharacters * /

MultiLineBlockCommentCharacters

BlockCommentCharacters LineTerminator

| MultiLineBlockCommentCharacters BlockCommentCharacters LineTerminator

White Space

Syntax

WhiteSpace

«empty»

| WhiteSpace WhiteSpaceCharacter

| WhiteSpace SingleLineBlockComment

Line Breaks

Syntax

LineBreak

LineTerminator

| LineComment LineTerminator

| MultiLineBlockComment

LineBreaks

LineBreak

| LineBreaks WhiteSpace LineBreak

Input Elements

Syntax

{re, div, num}

NextInputElement^re WhiteSpace InputElement^re

NextInputElement^div WhiteSpace InputElement^div

NextInputElement^num [lookahead{ContinuingIdentifierCharacter, \}] WhiteSpace InputElement^div

Semantics

Lex[NextInputElement]: InputElement;

Lex[NextInputElement^re WhiteSpace InputElement^re] = Lex[InputElement^re];

Lex[NextInputElement^div WhiteSpace InputElement^div] = Lex[InputElement^div];

Lex[NextInputElement^num [lookahead{ContinuingIdentifierCharacter, \}] WhiteSpace InputElement^div] = Lex[InputElement^div];

Syntax

InputElement^re

LineBreaks

| Punctuator

| RegExpLiteral

| EndOfInput

InputElement^div

LineBreaks

| Punctuator

| DivisionPunctuator

| EndOfInput

EndOfInput

End

| LineComment End

Semantics

Lex[InputElement]: InputElement;

Lex[InputElement LineBreaks] = lineBreak;

Lex[InputElement IdentifierOrKeyword] = Lex[IdentifierOrKeyword];

Lex[InputElement Punctuator] = Lex[Punctuator];

Lex[InputElement^div DivisionPunctuator] = Lex[DivisionPunctuator];

Lex[InputElement NumericLiteral] = Lex[NumericLiteral];

Lex[InputElement StringLiteral] = Lex[StringLiteral];

Lex[InputElement^re RegExpLiteral] = Lex[RegExpLiteral];

Lex[InputElement EndOfInput] = endOfInput;

Keywords and Identifiers

Syntax

IdentifierOrKeyword IdentifierName

Semantics

Lex[IdentifierOrKeyword IdentifierName]: InputElement

begin

id: String Lex[IdentifierName];

if id {“abstract”, “as”, “break”, “case”, “catch”, “class”, “const”, “continue”, “debugger”, “default”, “delete”, “do”, “else”, “enum”, “export”, “extends”, “false”, “finally”, “for”, “function”, “get”, “goto”, “if”, “implements”, “import”, “in”, “instanceof”, “interface”, “is”, “namespace”, “native”, “new”, “null”, “package”, “private”, “protected”, “public”, “return”, “set”, “super”, “switch”, “synchronized”, “this”, “throw”, “throws”, “transient”, “true”, “try”, “typeof”, “use”, “var”, “volatile”, “while”, “with”} and not ContainsEscapes[IdentifierName] then

return Keywordname: id

else return Identifiername: id

end if

end;

Syntax

IdentifierName

InitialIdentifierCharacterOrEscape

| NullEscapes InitialIdentifierCharacterOrEscape

| IdentifierName ContinuingIdentifierCharacterOrEscape

| IdentifierName NullEscape

NullEscapes

NullEscape

| NullEscapes NullEscape

NullEscape \ _

InitialIdentifierCharacterOrEscape

InitialIdentifierCharacter

| \ HexEscape

InitialIdentifierCharacter UnicodeInitialAlphabetic | $ | _

ContinuingIdentifierCharacterOrEscape

ContinuingIdentifierCharacter

| \ HexEscape

ContinuingIdentifierCharacter UnicodeAlphanumeric | $ | _

Semantics

Lex[IdentifierName]: String;

Lex[IdentifierName InitialIdentifierCharacterOrEscape] = [Lex[InitialIdentifierCharacterOrEscape]];

Lex[IdentifierName NullEscapes InitialIdentifierCharacterOrEscape] = [Lex[InitialIdentifierCharacterOrEscape]];

Lex[IdentifierName₀ IdentifierName₁ ContinuingIdentifierCharacterOrEscape] = Lex[IdentifierName₁] [Lex[ContinuingIdentifierCharacterOrEscape]];

Lex[IdentifierName₀ IdentifierName₁ NullEscape] = Lex[IdentifierName₁];

ContainsEscapes[IdentifierName]: Boolean;

ContainsEscapes[IdentifierName InitialIdentifierCharacterOrEscape] = ContainsEscapes[InitialIdentifierCharacterOrEscape];

ContainsEscapes[IdentifierName NullEscapes InitialIdentifierCharacterOrEscape] = true;

ContainsEscapes[IdentifierName₀ IdentifierName₁ ContinuingIdentifierCharacterOrEscape] = ContainsEscapes[IdentifierName₁] or ContainsEscapes[ContinuingIdentifierCharacterOrEscape];

ContainsEscapes[IdentifierName IdentifierName NullEscape] = true;

Lex[InitialIdentifierCharacterOrEscape]: Char16;

Lex[InitialIdentifierCharacterOrEscape InitialIdentifierCharacter] = InitialIdentifierCharacter;

Lex[InitialIdentifierCharacterOrEscape \ HexEscape]

begin

ch: Char16 Lex[HexEscape];

if the nonterminal InitialIdentifierCharacter can expand into [ch] then

return ch

else throw syntaxError

end if

end;

ContainsEscapes[InitialIdentifierCharacterOrEscape]: Boolean;

ContainsEscapes[InitialIdentifierCharacterOrEscape InitialIdentifierCharacter] = false;

ContainsEscapes[InitialIdentifierCharacterOrEscape \ HexEscape] = true;

Lex[ContinuingIdentifierCharacterOrEscape]: Char16;

Lex[ContinuingIdentifierCharacterOrEscape ContinuingIdentifierCharacter] = ContinuingIdentifierCharacter;

Lex[ContinuingIdentifierCharacterOrEscape \ HexEscape]

begin

ch: Char16 Lex[HexEscape];

if the nonterminal ContinuingIdentifierCharacter can expand into [ch] then

return ch

else throw syntaxError

end if

end;

ContainsEscapes[ContinuingIdentifierCharacterOrEscape]: Boolean;

ContainsEscapes[ContinuingIdentifierCharacterOrEscape ContinuingIdentifierCharacter] = false;

ContainsEscapes[ContinuingIdentifierCharacterOrEscape \ HexEscape] = true;

Punctuators

Syntax

Punctuator

!

| ! =

| ! = =

| %

| % =

| &

| & &

| & & =

| & =

| (

| )

| *

| * =

| +

| + +

| + =

| ,

| -

| - -

| - =

| .

| . . .

| :

| : :

| ;

| <

| < <

| < < =

| < =

| =

| = =

| = = =

| >

| > =

| > >

| > > =

| > > >

| > > > =

| ?

| [

| ]

| ^

| ^ =

| ^ ^

| ^ ^ =

| {

| |

| | =

| | |

| | | =

| }

| ~

DivisionPunctuator

/ [lookahead{/, *}]

| / =

Semantics

Lex[Punctuator]: Token;

Lex[Punctuator !] = Punctuatorname: “!”;

Lex[Punctuator ! =] = Punctuatorname: “!=”;

Lex[Punctuator ! = =] = Punctuatorname: “!==”;

Lex[Punctuator %] = Punctuatorname: “%”;

Lex[Punctuator % =] = Punctuatorname: “%=”;

Lex[Punctuator &] = Punctuatorname: “&”;

Lex[Punctuator & &] = Punctuatorname: “&&”;

Lex[Punctuator & & =] = Punctuatorname: “&&=”;

Lex[Punctuator & =] = Punctuatorname: “&=”;

Lex[Punctuator (] = Punctuatorname: “(”;

Lex[Punctuator )] = Punctuatorname: “)”;

Lex[Punctuator *] = Punctuatorname: “*”;

Lex[Punctuator * =] = Punctuatorname: “*=”;

Lex[Punctuator +] = Punctuatorname: “+”;

Lex[Punctuator + +] = Punctuatorname: “++”;

Lex[Punctuator + =] = Punctuatorname: “+=”;

Lex[Punctuator ,] = Punctuatorname: “,”;

Lex[Punctuator -] = Punctuatorname: “-”;

Lex[Punctuator - -] = Punctuatorname: “--”;

Lex[Punctuator - =] = Punctuatorname: “-=”;

Lex[Punctuator .] = Punctuatorname: “.”;

Lex[Punctuator . . .] = Punctuatorname: “...”;

Lex[Punctuator :] = Punctuatorname: “:”;

Lex[Punctuator : :] = Punctuatorname: “::”;

Lex[Punctuator ;] = Punctuatorname: “;”;

Lex[Punctuator <] = Punctuatorname: “<”;

Lex[Punctuator < <] = Punctuatorname: “<<”;

Lex[Punctuator < < =] = Punctuatorname: “<<=”;

Lex[Punctuator < =] = Punctuatorname: “<=”;

Lex[Punctuator =] = Punctuatorname: “=”;

Lex[Punctuator = =] = Punctuatorname: “==”;

Lex[Punctuator = = =] = Punctuatorname: “===”;

Lex[Punctuator >] = Punctuatorname: “>”;

Lex[Punctuator > =] = Punctuatorname: “>=”;

Lex[Punctuator > >] = Punctuatorname: “>>”;

Lex[Punctuator > > =] = Punctuatorname: “>>=”;

Lex[Punctuator > > >] = Punctuatorname: “>>>”;

Lex[Punctuator > > > =] = Punctuatorname: “>>>=”;

Lex[Punctuator ?] = Punctuatorname: “?”;

Lex[Punctuator [] = Punctuatorname: “[”;

Lex[Punctuator ]] = Punctuatorname: “]”;

Lex[Punctuator ^] = Punctuatorname: “^”;

Lex[Punctuator ^ =] = Punctuatorname: “^=”;

Lex[Punctuator ^ ^] = Punctuatorname: “^^”;

Lex[Punctuator ^ ^ =] = Punctuatorname: “^^=”;

Lex[Punctuator {] = Punctuatorname: “{”;

Lex[Punctuator |] = Punctuatorname: “|”;

Lex[Punctuator | =] = Punctuatorname: “|=”;

Lex[Punctuator | |] = Punctuatorname: “||”;

Lex[Punctuator | | =] = Punctuatorname: “||=”;

Lex[Punctuator }] = Punctuatorname: “}”;

Lex[Punctuator ~] = Punctuatorname: “~”;

Lex[DivisionPunctuator]: Token;

Lex[DivisionPunctuator / [lookahead{/, *}]] = Punctuatorname: “/”;

Lex[DivisionPunctuator / =] = Punctuatorname: “/=”;

Numeric Literals

Syntax

NumericLiteral

DecimalLiteral^{noLeadingZeros}

| DecimalLiteral^{noLeadingZeros} LetterF

| IntegerLiteral LetterL

| IntegerLiteral LetterU LetterL

IntegerLiteral

DecimalIntegerLiteral^{noLeadingZeros}

LetterF F | f

LetterL L | l

LetterU U | u

Semantics

Lex[NumericLiteral]: Token;

Lex[NumericLiteral DecimalLiteral^{noLeadingZeros}] = NumberTokenvalue: (Lex[DecimalLiteral^{noLeadingZeros}])_f64;

Lex[NumericLiteral HexIntegerLiteral] = NumberTokenvalue: (Lex[HexIntegerLiteral])_f64;

Lex[NumericLiteral DecimalLiteral^{noLeadingZeros} LetterF] = NumberTokenvalue: (Lex[DecimalLiteral^{noLeadingZeros}])_f32;

Lex[NumericLiteral IntegerLiteral LetterL]

begin

i: Integer Lex[IntegerLiteral];

if i 2⁶³ – 1 then return NumberTokenvalue: i_long

elsif i = 2⁶³ then return negatedMinLong

else throw rangeError

end if

end;

Lex[NumericLiteral IntegerLiteral LetterU LetterL]

begin

i: Integer Lex[IntegerLiteral];

if i 2⁶⁴ – 1 then return NumberTokenvalue: i_ulong

else throw rangeError

end if

end;

Lex[IntegerLiteral]: Integer;

Lex[IntegerLiteral DecimalIntegerLiteral^{noLeadingZeros}] = Lex[DecimalIntegerLiteral^{noLeadingZeros}];

Lex[IntegerLiteral HexIntegerLiteral] = Lex[HexIntegerLiteral];

Syntax

{noLeadingZeros, allowLeadingZeros}

DecimalLiteral

Mantissa

| Mantissa LetterE SignedInteger

LetterE E | e

Mantissa

DecimalIntegerLiteral

| DecimalIntegerLiteral .

| DecimalIntegerLiteral . Fraction

| . Fraction

DecimalIntegerLiteral^{noLeadingZeros}

0

DecimalIntegerLiteral^{allowLeadingZeros} DecimalDigits

NonZeroDecimalDigits

NonZeroDigit

| NonZeroDecimalDigits ASCIIDigit

NonZeroDigit 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Fraction DecimalDigits

Semantics

Lex[DecimalLiteral]: Rational;

Lex[DecimalLiteral Mantissa] = Lex[Mantissa];

Lex[DecimalLiteral Mantissa LetterE SignedInteger] = Lex[Mantissa]10^{Lex[SignedInteger]};

Lex[Mantissa]: Rational;

Lex[Mantissa DecimalIntegerLiteral] = Lex[DecimalIntegerLiteral];

Lex[Mantissa DecimalIntegerLiteral .] = Lex[DecimalIntegerLiteral];

Lex[Mantissa DecimalIntegerLiteral . Fraction] = Lex[DecimalIntegerLiteral] + Lex[Fraction];

Lex[Mantissa . Fraction] = Lex[Fraction];

Lex[DecimalIntegerLiteral]: Integer;

Lex[DecimalIntegerLiteral^{noLeadingZeros} 0] = 0;

Lex[DecimalIntegerLiteral^{noLeadingZeros} NonZeroDecimalDigits] = Lex[NonZeroDecimalDigits];

Lex[DecimalIntegerLiteral^{allowLeadingZeros} DecimalDigits] = Lex[DecimalDigits];

Lex[NonZeroDecimalDigits]: Integer;

Lex[NonZeroDecimalDigits NonZeroDigit] = DecimalValue[NonZeroDigit];

Lex[NonZeroDecimalDigits₀ NonZeroDecimalDigits₁ ASCIIDigit] = 10Lex[NonZeroDecimalDigits₁] + DecimalValue[ASCIIDigit];

DecimalValue[NonZeroDigit]: Integer = digitValue(NonZeroDigit);

Lex[Fraction DecimalDigits]: Rational = Lex[DecimalDigits]/10^{NDigits[DecimalDigits]};

Syntax

SignedInteger OptionalSign DecimalDigits

OptionalSign

«empty»

| +

| -

Semantics

Lex[SignedInteger OptionalSign DecimalDigits]: Integer = Lex[OptionalSign]Lex[DecimalDigits];

Lex[OptionalSign]: {–1, 1};

Lex[OptionalSign «empty»] = 1;

Lex[OptionalSign +] = 1;

Lex[OptionalSign -] = –1;

Syntax

DecimalDigits

ASCIIDigit

| DecimalDigits ASCIIDigit

Semantics

Lex[DecimalDigits]: Integer;

Lex[DecimalDigits ASCIIDigit] = DecimalValue[ASCIIDigit];

Lex[DecimalDigits₀ DecimalDigits₁ ASCIIDigit] = 10Lex[DecimalDigits₁] + DecimalValue[ASCIIDigit];

NDigits[DecimalDigits]: Integer;

NDigits[DecimalDigits ASCIIDigit] = 1;

NDigits[DecimalDigits₀ DecimalDigits₁ ASCIIDigit] = NDigits[DecimalDigits₁] + 1;

Syntax

HexIntegerLiteral

0 LetterX HexDigit

| HexIntegerLiteral HexDigit

LetterX X | x

HexDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | a | b | c | d | e | f

Semantics

Lex[HexIntegerLiteral]: Integer;

Lex[HexIntegerLiteral 0 LetterX HexDigit] = HexValue[HexDigit];

Lex[HexIntegerLiteral₀ HexIntegerLiteral₁ HexDigit] = 16Lex[HexIntegerLiteral₁] + HexValue[HexDigit];

HexValue[HexDigit]: Integer = digitValue(HexDigit);

String Literals

Syntax

{single, double}

StringLiteral

' StringChars^single '

| " StringChars^double "

Semantics

Lex[StringLiteral]: Token;

Lex[StringLiteral ' StringChars^single '] = StringTokenvalue: Lex[StringChars^single];

Lex[StringLiteral " StringChars^double "] = StringTokenvalue: Lex[StringChars^double];

Syntax

StringChars

«empty»

| StringChars StringChar

| StringChars NullEscape

StringChar

LiteralStringChar

| \ StringEscape

LiteralStringChar^single UnicodeCharacter except ' | \ | LineTerminator

LiteralStringChar^double UnicodeCharacter except " | \ | LineTerminator

Semantics

Lex[StringChars]: String;

Lex[StringChars «empty»] = “”;

Lex[StringChars₀ StringChars₁ StringChar] = Lex[StringChars₁] [Lex[StringChar]];

Lex[StringChars₀ StringChars₁ NullEscape] = Lex[StringChars₁];

Lex[StringChar]: Char16;

Lex[StringChar LiteralStringChar] = LiteralStringChar;

Lex[StringChar \ StringEscape] = Lex[StringEscape];

Syntax

StringEscape

ControlEscape

| ZeroEscape

| HexEscape

IdentityEscape NonTerminator except _ | UnicodeAlphanumeric

Semantics

Lex[StringEscape]: Char16;

Lex[StringEscape ControlEscape] = Lex[ControlEscape];

Lex[StringEscape ZeroEscape] = Lex[ZeroEscape];

Lex[StringEscape HexEscape] = Lex[HexEscape];

Lex[StringEscape IdentityEscape] = IdentityEscape;

Syntax

ControlEscape

b

| f

| n

| r

| t

| v

Semantics

Lex[ControlEscape]: Char16;

Lex[ControlEscape b] = ‘«BS»’;

Lex[ControlEscape f] = ‘«FF»’;

Lex[ControlEscape n] = ‘«LF»’;

Lex[ControlEscape r] = ‘«CR»’;

Lex[ControlEscape t] = ‘«TAB»’;

Lex[ControlEscape v] = ‘«VT»’;

Syntax

ZeroEscape 0 [lookahead{ASCIIDigit}]

Semantics

Lex[ZeroEscape 0 [lookahead{ASCIIDigit}]]: Char16 = ‘«NUL»’;

Syntax

HexEscape

x HexDigit HexDigit

| u HexDigit HexDigit HexDigit HexDigit

| U HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit

Semantics

Lex[HexEscape]: Char16;

Lex[HexEscape x HexDigit₁ HexDigit₂] = integerToChar16(16HexValue[HexDigit₁] + HexValue[HexDigit₂]);

Lex[HexEscape u HexDigit₁ HexDigit₂ HexDigit₃ HexDigit₄] = integerToChar16(4096HexValue[HexDigit₁] + 256HexValue[HexDigit₂] + 16HexValue[HexDigit₃] + HexValue[HexDigit₄]);

Lex[HexEscape U HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit] = ????;

Regular Expression Literals

Syntax

RegExpLiteral RegExpBody RegExpFlags

RegExpFlags

«empty»

| RegExpFlags ContinuingIdentifierCharacterOrEscape

| RegExpFlags NullEscape

RegExpBody / [lookahead{*}] RegExpChars /

RegExpChars

RegExpChar

| RegExpChars RegExpChar

RegExpChar

OrdinaryRegExpChar

| \ NonTerminator

OrdinaryRegExpChar NonTerminator except \ | /

Semantics

Lex[RegExpLiteral RegExpBody RegExpFlags]: Token = RegularExpressionbody: Lex[RegExpBody], flags: Lex[RegExpFlags];

Lex[RegExpFlags]: String;

Lex[RegExpFlags «empty»] = “”;

Lex[RegExpFlags₀ RegExpFlags₁ ContinuingIdentifierCharacterOrEscape] = Lex[RegExpFlags₁] [Lex[ContinuingIdentifierCharacterOrEscape]];

Lex[RegExpFlags₀ RegExpFlags₁ NullEscape] = Lex[RegExpFlags₁];

Lex[RegExpBody / [lookahead{*}] RegExpChars /]: String = Lex[RegExpChars];

Lex[RegExpChars]: String;

Lex[RegExpChars RegExpChar] = Lex[RegExpChar];

Lex[RegExpChars₀ RegExpChars₁ RegExpChar] = Lex[RegExpChars₁] Lex[RegExpChar];

Lex[RegExpChar]: String;

Lex[RegExpChar OrdinaryRegExpChar] = [OrdinaryRegExpChar];

Lex[RegExpChar \ NonTerminator] = [‘\’, NonTerminator];

String-to-Number Conversion

Syntax

StringNumericLiteral

StringWhiteSpace

| StringWhiteSpace SignedDecimalLiteral StringWhiteSpace

| StringWhiteSpace OptionalSign HexIntegerLiteral StringWhiteSpace

SignedDecimalLiteral

OptionalSign DecimalLiteral^{allowLeadingZeros}

| OptionalSign I n f i n i t y

| N a N

StringWhiteSpace

«empty»

| StringWhiteSpace WhiteSpaceOrLineTerminatorChar

WhiteSpaceOrLineTerminatorChar WhiteSpaceCharacter | LineTerminator

Semantics

tag +zero;

tag –zero;

tag +;

tag –;

tag NaN;

ExtendedRational = Rational {+zero, –zero, +, –, NaN};

Lex[StringNumericLiteral]: ExtendedRational;

Lex[StringNumericLiteral StringWhiteSpace] = +zero;

Lex[StringNumericLiteral StringWhiteSpace SignedDecimalLiteral StringWhiteSpace] = Lex[SignedDecimalLiteral];

Lex[StringNumericLiteral StringWhiteSpace OptionalSign HexIntegerLiteral StringWhiteSpace] = combineWithSign(Lex[OptionalSign], Lex[HexIntegerLiteral]);

Lex[SignedDecimalLiteral]: ExtendedRational;

Lex[SignedDecimalLiteral OptionalSign DecimalLiteral^{allowLeadingZeros}] = combineWithSign(Lex[OptionalSign], Lex[DecimalLiteral^{allowLeadingZeros}]);

Lex[SignedDecimalLiteral OptionalSign I n f i n i t y] = Lex[OptionalSign] > 0 ? + : –;

Lex[SignedDecimalLiteral N a N] = NaN;

proc combineWithSign(sign: {–1, 1}, q: Rational): ExtendedRational

if q 0 then return signq

elsif sign > 0 then return +zero

else return –zero

end if

end proc;

parseFloat Conversion

Syntax

StringDecimalLiteral StringWhiteSpace SignedDecimalLiteral

Semantics

Lex[StringDecimalLiteral StringWhiteSpace SignedDecimalLiteral]: ExtendedRational = Lex[SignedDecimalLiteral];

ECMAScript 4 Netscape Proposal

Formal Description

Regular Expression Grammar

Monday, June 9, 2003

This LR(1) grammar describes the regular expression syntax of the ECMAScript 4 proposal. See also the description of the grammar notation.

This document is also available as a Word RTF file.

Unicode Character Classes

UnicodeCharacter Any Unicode character

UnicodeAlphanumeric Any Unicode alphabetic or decimal digit character (includes ASCII 0-9, A-Z, and a-z)

LineTerminator «LF» | «CR» | «u0085» | «u2028» | «u2029»

Regular Expression Definitions

Regular Expression Patterns

RegularExpressionPattern Disjunction

Disjunctions

Disjunction

Alternative

| Alternative | Disjunction

Alternatives

Alternative

«empty»

| Alternative Term

Terms

Term

Assertion

| Atom

| Atom Quantifier

Quantifier

QuantifierPrefix

| QuantifierPrefix ?

QuantifierPrefix

*

| +

| ?

| { DecimalDigits }

| { DecimalDigits , }

| { DecimalDigits , DecimalDigits }

DecimalDigits

DecimalDigit

| DecimalDigits DecimalDigit

DecimalDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Assertions

Assertion

^

| $

| \ b

| \ B

Atoms

Atom

PatternCharacter

| .

| NullEscape

| \ AtomEscape

| CharacterClass

| ( Disjunction )

| ( ? : Disjunction )

| ( ? = Disjunction )

| ( ? ! Disjunction )

PatternCharacter UnicodeCharacter except ^ | $ | \ | . | * | + | ? | ( | ) | [ | ] | { | } | |

Escapes

NullEscape \ _

AtomEscape

DecimalEscape

CharacterEscape

ControlEscape

| c ControlLetter

| HexEscape

ControlLetter

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

| a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z

IdentityEscape UnicodeCharacter except _ | UnicodeAlphanumeric

ControlEscape

f

| n

| r

| t

| v

Decimal Escapes

DecimalEscape DecimalIntegerLiteral [lookahead{DecimalDigit}]

DecimalIntegerLiteral

0

NonZeroDecimalDigits

NonZeroDigit

| NonZeroDecimalDigits DecimalDigit

NonZeroDigit 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Hexadecimal Escapes

HexEscape

x HexDigit HexDigit

| u HexDigit HexDigit HexDigit HexDigit

HexDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | a | b | c | d | e | f

Character Class Escapes

CharacterClassEscape

s

| S

| d

| D

| w

| W

User-Specified Character Classes

CharacterClass

[ [lookahead{^}] ClassRanges ]

| [ ^ ClassRanges ]

ClassRanges

«empty»

| NonemptyClassRanges^dash

{dash, noDash}

NonemptyClassRanges

ClassAtom^dash

| ClassAtom NonemptyClassRanges^noDash

| ClassAtom - ClassAtom^dash ClassRanges

| NullEscape ClassRanges

Character Class Range Atoms

ClassAtom

ClassCharacter

| \ ClassEscape

ClassCharacter^dash UnicodeCharacter except \ | ]

ClassCharacter^noDash ClassCharacter^dash except -

ClassEscape

DecimalEscape

| b

ECMAScript 4 Netscape Proposal

Formal Description

Regular Expression Semantics

Monday, June 9, 2003

The regular expression semantics describe the actions the regular expression engine takes in order to transform a regular expression pattern into a function for matching against input strings. For convenience, the regular expression grammar is repeated here. See also the description of the semantic notation.

This document is also available as a Word RTF file.

Case-insensitive matches are not implemented in the semantics below.

Semantics

tag syntaxError;

SemanticException = {syntaxError};

Unicode Character Classes

Syntax

UnicodeCharacter Any Unicode character

UnicodeAlphanumeric Any Unicode alphabetic or decimal digit character (includes ASCII 0-9, A-Z, and a-z)

LineTerminator «LF» | «CR» | «u0085» | «u2028» | «u2029»

Semantics

lineTerminators: Char16{} = {‘«LF»’, ‘«CR»’, ‘«u2028»’, ‘«u2029»’};

reWhitespaces: Char16{} = {‘«FF»’, ‘«LF»’, ‘«CR»’, ‘«TAB»’, ‘«VT»’, ‘ ’};

reDigits: Char16{} = {‘0’ ... ‘9’};

reWordCharacters: Char16{} = {‘0’ ... ‘9’, ‘A’ ... ‘Z’, ‘a’ ... ‘z’, ‘_’};

Regular Expression Definitions

Semantics

tuple REInput

str: String,

ignoreCase: Boolean,

multiline: Boolean,

span: Boolean

end tuple;

Field str is the input string. ignoreCase, multiline, and span are the corresponding regular expression flags.

tag undefined;

Capture = String {undefined};

tuple REMatch

endIndex: Integer,

captures: Capture[]

end tuple;

tag failure;

REResult = REMatch {failure};

A REMatch holds an intermediate state during the pattern-matching process. endIndex is the index of the next input character to be matched by the next component in a regular expression pattern. If we are at the end of the pattern, endIndex is one plus the index of the last matched input character. captures is a zero-based array of the strings captured so far by capturing parentheses.

Continuation = REMatch REResult;

A Continuation is a function that attempts to match the remaining portion of the pattern against the input string, starting at the intermediate state given by its REMatch argument. If a match is possible, it returns a REMatch result that contains the final state; if no match is possible, it returns a failure result.

Matcher = REInput REMatch Continuation REResult;

A Matcher is a function that attempts to match a middle portion of the pattern against the input string, starting at the intermediate state given by its REMatch argument. Since the remainder of the pattern heavily influences whether (and how) a middle portion will match, we must pass in a Continuation function that checks whether the rest of the pattern matched. If the continuation returns failure, the matcher function may call it repeatedly, trying various alternatives at pattern choice points.

The REInput parameter contains the input string and is merely passed down to subroutines.

A Integer Matcher is a function executed at the time the regular expression is compiled that returns a Matcher for a part of the pattern. The Integer parameter contains the number of capturing left parentheses seen so far in the pattern and is used to assign static, consecutive numbers to capturing parentheses.

proc characterSetMatcher(acceptanceSet: Char16{}, invert: Boolean): Matcher

proc m(t: REInput, x: REMatch, c: Continuation): REResult

i: Integer x.endIndex;

s: String t.str;

if i = |s| then return failure

elsif s[i] acceptanceSet xor invert then

return c(REMatchendIndex: i + 1, captures: x.captures)

else return failure

end if

end proc;

return m

end proc;

characterSetMatcher returns a Matcher that matches a single input string character. If invert is false, the match succeeds if the character is a member of the acceptanceSet set of characters (possibly ignoring case). If invert is true, the match succeeds if the character is not a member of the acceptanceSet set of characters (possibly ignoring case).

proc characterMatcher(ch: Char16): Matcher

return characterSetMatcher({ch}, false)

end proc;

characterMatcher returns a Matcher that matches a single input string character. The match succeeds if the character is the same as ch (possibly ignoring case).

Regular Expression Patterns

Syntax

RegularExpressionPattern Disjunction

Semantics

Execute[RegularExpressionPattern Disjunction]: REInput Integer REResult

begin

m1: Matcher GenMatcher[Disjunction](0);

proc e(t: REInput, index: Integer): REResult

x: REMatch REMatchendIndex: index, captures: repeat(undefined, CountParens[Disjunction]);

return m1(t, x, successContinuation)

end proc;

return e

end;

proc successContinuation(x: REMatch): REResult

return x

end proc;

Disjunctions

Syntax

Disjunction

Alternative

| Alternative | Disjunction

Semantics

proc GenMatcher[Disjunction] (parenIndex: Integer): Matcher

[Disjunction Alternative] do return GenMatcher[Alternative](parenIndex);

[Disjunction₀ Alternative | Disjunction₁] do

m1: Matcher GenMatcher[Alternative](parenIndex);

m2: Matcher GenMatcher[Disjunction₁](parenIndex + CountParens[Alternative]);

proc m3(t: REInput, x: REMatch, c: Continuation): REResult

y: REResult m1(t, x, c);

case y of

REMatch do return y;

{failure} do return m2(t, x, c)

end case

end proc;

return m3

end proc;

CountParens[Disjunction]: Integer;

CountParens[Disjunction Alternative] = CountParens[Alternative];

CountParens[Disjunction₀ Alternative | Disjunction₁] = CountParens[Alternative] + CountParens[Disjunction₁];

Alternatives

Syntax

Alternative

«empty»

| Alternative Term

Semantics

proc GenMatcher[Alternative] (parenIndex: Integer): Matcher

[Alternative «empty»] do

proc m(t: REInput, x: REMatch, c: Continuation): REResult

return c(x)

end proc;

return m;

[Alternative₀ Alternative₁ Term] do

m1: Matcher GenMatcher[Alternative₁](parenIndex);

m2: Matcher GenMatcher[Term](parenIndex + CountParens[Alternative₁]);

proc m3(t: REInput, x: REMatch, c: Continuation): REResult

proc d(y: REMatch): REResult

return m2(t, y, c)

end proc;

return m1(t, x, d)

end proc;

return m3

end proc;

CountParens[Alternative]: Integer;

CountParens[Alternative «empty»] = 0;

CountParens[Alternative₀ Alternative₁ Term] = CountParens[Alternative₁] + CountParens[Term];

Terms

Syntax

Term

Assertion

| Atom

| Atom Quantifier

Semantics

proc GenMatcher[Term] (parenIndex: Integer): Matcher

[Term Assertion] do

proc m(t: REInput, x: REMatch, c: Continuation): REResult

if TestAssertion[Assertion](t, x) then return c(x) else return failure end if

end proc;

return m;

[Term Atom] do return GenMatcher[Atom](parenIndex);

[Term Atom Quantifier] do

m: Matcher GenMatcher[Atom](parenIndex);

min: Integer Minimum[Quantifier];

max: Limit Maximum[Quantifier];

greedy: Boolean Greedy[Quantifier];

if max + then if max < min then throw syntaxError end if end if;

return repeatMatcher(m, min, max, greedy, parenIndex, CountParens[Atom])

end proc;

CountParens[Term]: Integer;

CountParens[Term Assertion] = 0;

CountParens[Term Atom] = CountParens[Atom];

CountParens[Term Atom Quantifier] = CountParens[Atom];

Syntax

Quantifier

QuantifierPrefix

| QuantifierPrefix ?

QuantifierPrefix

*

| +

| ?

| { DecimalDigits }

| { DecimalDigits , }

| { DecimalDigits , DecimalDigits }

DecimalDigits

DecimalDigit

| DecimalDigits DecimalDigit

DecimalDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Semantics

tag +;

Limit = Integer {+};

proc resetParens(x: REMatch, p: Integer, nParens: Integer): REMatch

captures: Capture[] x.captures;

i: Integer p;

while i < p + nParens do captures captures[i \ undefined]; i i + 1 end while;

return REMatchendIndex: x.endIndex, captures: captures

end proc;

proc repeatMatcher(body: Matcher, min: Integer, max: Limit, greedy: Boolean, parenIndex: Integer, nBodyParens: Integer): Matcher

proc m(t: REInput, x: REMatch, c: Continuation): REResult

if max = 0 then return c(x) end if;

proc d(y: REMatch): REResult

if min = 0 and y.endIndex = x.endIndex then return failure end if;

newMin: Integer min;

if min 0 then newMin min – 1 end if;

newMax: Limit max;

if max + then newMax max – 1 end if;

m2: Matcher repeatMatcher(body, newMin, newMax, greedy, parenIndex, nBodyParens);

return m2(t, y, c)

end proc;

xr: REMatch resetParens(x, parenIndex, nBodyParens);

if min 0 then return body(t, xr, d)

elsif greedy then

z: REResult body(t, xr, d);

case z of

REMatch do return z;

{failure} do return c(x)

end case

else

z: REResult c(x);

case z of

REMatch do return z;

{failure} do return body(t, xr, d)

end case

end if

end proc;

return m

end proc;

Minimum[Quantifier]: Integer;

Minimum[Quantifier QuantifierPrefix] = Minimum[QuantifierPrefix];

Minimum[Quantifier QuantifierPrefix ?] = Minimum[QuantifierPrefix];

Maximum[Quantifier]: Limit;

Maximum[Quantifier QuantifierPrefix] = Maximum[QuantifierPrefix];

Maximum[Quantifier QuantifierPrefix ?] = Maximum[QuantifierPrefix];

Greedy[Quantifier]: Boolean;

Greedy[Quantifier QuantifierPrefix] = true;

Greedy[Quantifier QuantifierPrefix ?] = false;

Minimum[QuantifierPrefix]: Integer;

Minimum[QuantifierPrefix *] = 0;

Minimum[QuantifierPrefix +] = 1;

Minimum[QuantifierPrefix ?] = 0;

Minimum[QuantifierPrefix { DecimalDigits }] = IntegerValue[DecimalDigits];

Minimum[QuantifierPrefix { DecimalDigits , }] = IntegerValue[DecimalDigits];

Minimum[QuantifierPrefix { DecimalDigits₁ , DecimalDigits₂ }] = IntegerValue[DecimalDigits₁];

Maximum[QuantifierPrefix]: Limit;

Maximum[QuantifierPrefix *] = +;

Maximum[QuantifierPrefix +] = +;

Maximum[QuantifierPrefix ?] = 1;

Maximum[QuantifierPrefix { DecimalDigits }] = IntegerValue[DecimalDigits];

Maximum[QuantifierPrefix { DecimalDigits , }] = +;

Maximum[QuantifierPrefix { DecimalDigits₁ , DecimalDigits₂ }] = IntegerValue[DecimalDigits₂];

IntegerValue[DecimalDigits]: Integer;

IntegerValue[DecimalDigits DecimalDigit] = DecimalValue[DecimalDigit];

IntegerValue[DecimalDigits₀ DecimalDigits₁ DecimalDigit] = 10IntegerValue[DecimalDigits₁] + DecimalValue[DecimalDigit];

DecimalValue[DecimalDigit]: Integer = digitValue(DecimalDigit);

Assertions

Syntax

Assertion

^

| $

| \ b

| \ B

Semantics

proc TestAssertion[Assertion] (t: REInput, x: REMatch): Boolean

[Assertion ^] do

return x.endIndex = 0 or (t.multiline and t.str[x.endIndex – 1] lineTerminators);

[Assertion $] do

return x.endIndex = |t.str| or (t.multiline and t.str[x.endIndex] lineTerminators);

[Assertion \ b] do return atWordBoundary(x.endIndex, t.str);

[Assertion \ B] do return not atWordBoundary(x.endIndex, t.str)

end proc;

proc atWordBoundary(i: Integer, s: String): Boolean

return inWord(i – 1, s) xor inWord(i, s)

end proc;

proc inWord(i: Integer, s: String): Boolean

if i = –1 or i = |s| then return false else return s[i] reWordCharacters end if

end proc;

Atoms

Syntax

Atom

PatternCharacter

| .

| NullEscape

| \ AtomEscape

| CharacterClass

| ( Disjunction )

| ( ? : Disjunction )

| ( ? = Disjunction )

| ( ? ! Disjunction )

PatternCharacter UnicodeCharacter except ^ | $ | \ | . | * | + | ? | ( | ) | [ | ] | { | } | |

Semantics

proc GenMatcher[Atom] (parenIndex: Integer): Matcher

[Atom PatternCharacter] do return characterMatcher(PatternCharacter);

[Atom .] do

proc m1(t: REInput, x: REMatch, c: Continuation): REResult

a: Char16{} t.span ? {} : lineTerminators;

m2: Matcher characterSetMatcher(a, true);

return m2(t, x, c)

end proc;

return m1;

[Atom NullEscape] do

proc m(t: REInput, x: REMatch, c: Continuation): REResult

return c(x)

end proc;

return m;

[Atom \ AtomEscape] do return GenMatcher[AtomEscape](parenIndex);

[Atom CharacterClass] do

a: Char16{} AcceptanceSet[CharacterClass];

return characterSetMatcher(a, Invert[CharacterClass]);

[Atom ( Disjunction )] do

m1: Matcher GenMatcher[Disjunction](parenIndex + 1);

proc m2(t: REInput, x: REMatch, c: Continuation): REResult

proc d(y: REMatch): REResult

ref: Capture t.str[x.endIndex ... y.endIndex – 1];

updatedCaptures: Capture[] y.captures[parenIndex \ ref];

return c(REMatchendIndex: y.endIndex, captures: updatedCaptures)

end proc;

return m1(t, x, d)

end proc;

return m2;

[Atom ( ? : Disjunction )] do return GenMatcher[Disjunction](parenIndex);

[Atom ( ? = Disjunction )] do

m1: Matcher GenMatcher[Disjunction](parenIndex);

proc m2(t: REInput, x: REMatch, c: Continuation): REResult

y: REResult m1(t, x, successContinuation);

case y of

REMatch do return c(REMatchendIndex: x.endIndex, captures: y.captures);

{failure} do return failure

end case

end proc;

return m2;

[Atom ( ? ! Disjunction )] do

m1: Matcher GenMatcher[Disjunction](parenIndex);

proc m2(t: REInput, x: REMatch, c: Continuation): REResult

case m1(t, x, successContinuation) of

REMatch do return failure;

{failure} do return c(x)

end case

end proc;

return m2

end proc;

CountParens[Atom]: Integer;

CountParens[Atom PatternCharacter] = 0;

CountParens[Atom .] = 0;

CountParens[Atom NullEscape] = 0;

CountParens[Atom \ AtomEscape] = 0;

CountParens[Atom CharacterClass] = 0;

CountParens[Atom ( Disjunction )] = CountParens[Disjunction] + 1;

CountParens[Atom ( ? : Disjunction )] = CountParens[Disjunction];

CountParens[Atom ( ? = Disjunction )] = CountParens[Disjunction];

CountParens[Atom ( ? ! Disjunction )] = CountParens[Disjunction];

Escapes

Syntax

NullEscape \ _

AtomEscape

DecimalEscape

Semantics

proc GenMatcher[AtomEscape] (parenIndex: Integer): Matcher

[AtomEscape DecimalEscape] do

n: Integer EscapeValue[DecimalEscape];

if n = 0 then return characterMatcher(‘«NUL»’)

elsif n > parenIndex then throw syntaxError

else return backreferenceMatcher(n)

end if;

[AtomEscape CharacterEscape] do

return characterMatcher(CharacterValue[CharacterEscape]);

[AtomEscape CharacterClassEscape] do

return characterSetMatcher(AcceptanceSet[CharacterClassEscape], false)

end proc;

proc backreferenceMatcher(n: Integer): Matcher

proc m(t: REInput, x: REMatch, c: Continuation): REResult

ref: Capture nthBackreference(x, n);

case ref of

String do

i: Integer x.endIndex;

s: String t.str;

j: Integer i + |ref|;

if j |s| and s[i ... j – 1] = ref then

return c(REMatchendIndex: j, captures: x.captures)

else return failure

end if;

{undefined} do return c(x)

end case

end proc;

return m

end proc;

proc nthBackreference(x: REMatch, n: Integer): Capture

return x.captures[n – 1]

end proc;

Syntax

CharacterEscape

ControlEscape

| c ControlLetter

| HexEscape

ControlLetter

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

| a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z

IdentityEscape UnicodeCharacter except _ | UnicodeAlphanumeric

ControlEscape

f

| n

| r

| t

| v

Semantics

CharacterValue[CharacterEscape]: Char16;

CharacterValue[CharacterEscape ControlEscape] = CharacterValue[ControlEscape];

CharacterValue[CharacterEscape c ControlLetter] = integerToChar16(bitwiseAnd(char16ToInteger(ControlLetter), 31));

CharacterValue[CharacterEscape HexEscape] = CharacterValue[HexEscape];

CharacterValue[CharacterEscape IdentityEscape] = IdentityEscape;

CharacterValue[ControlEscape]: Char16;

CharacterValue[ControlEscape f] = ‘«FF»’;

CharacterValue[ControlEscape n] = ‘«LF»’;

CharacterValue[ControlEscape r] = ‘«CR»’;

CharacterValue[ControlEscape t] = ‘«TAB»’;

CharacterValue[ControlEscape v] = ‘«VT»’;

Decimal Escapes

Syntax

DecimalEscape DecimalIntegerLiteral [lookahead{DecimalDigit}]

DecimalIntegerLiteral

0

NonZeroDecimalDigits

NonZeroDigit

| NonZeroDecimalDigits DecimalDigit

NonZeroDigit 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Semantics

EscapeValue[DecimalEscape DecimalIntegerLiteral [lookahead{DecimalDigit}]]: Integer = IntegerValue[DecimalIntegerLiteral];

IntegerValue[DecimalIntegerLiteral]: Integer;

IntegerValue[DecimalIntegerLiteral 0] = 0;

IntegerValue[DecimalIntegerLiteral NonZeroDecimalDigits] = IntegerValue[NonZeroDecimalDigits];

IntegerValue[NonZeroDecimalDigits]: Integer;

IntegerValue[NonZeroDecimalDigits NonZeroDigit] = DecimalValue[NonZeroDigit];

IntegerValue[NonZeroDecimalDigits₀ NonZeroDecimalDigits₁ DecimalDigit] = 10IntegerValue[NonZeroDecimalDigits₁] + DecimalValue[DecimalDigit];

DecimalValue[NonZeroDigit]: Integer = digitValue(NonZeroDigit);

Hexadecimal Escapes

Syntax

HexEscape

x HexDigit HexDigit

| u HexDigit HexDigit HexDigit HexDigit

HexDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | a | b | c | d | e | f

Semantics

CharacterValue[HexEscape]: Char16;

CharacterValue[HexEscape x HexDigit₁ HexDigit₂] = integerToChar16(16HexValue[HexDigit₁] + HexValue[HexDigit₂]);

CharacterValue[HexEscape u HexDigit₁ HexDigit₂ HexDigit₃ HexDigit₄] = integerToChar16(4096HexValue[HexDigit₁] + 256HexValue[HexDigit₂] + 16HexValue[HexDigit₃] + HexValue[HexDigit₄]);

HexValue[HexDigit]: Integer = digitValue(HexDigit);

Character Class Escapes

Syntax

CharacterClassEscape

s

| S

| d

| D

| w

| W

Semantics

AcceptanceSet[CharacterClassEscape]: Char16{};

AcceptanceSet[CharacterClassEscape s] = reWhitespaces;

AcceptanceSet[CharacterClassEscape S] = {‘«NUL»’ ... ‘«uFFFF»’} – reWhitespaces;

AcceptanceSet[CharacterClassEscape d] = reDigits;

AcceptanceSet[CharacterClassEscape D] = {‘«NUL»’ ... ‘«uFFFF»’} – reDigits;

AcceptanceSet[CharacterClassEscape w] = reWordCharacters;

AcceptanceSet[CharacterClassEscape W] = {‘«NUL»’ ... ‘«uFFFF»’} – reWordCharacters;

User-Specified Character Classes

Syntax

CharacterClass

[ [lookahead{^}] ClassRanges ]

| [ ^ ClassRanges ]

ClassRanges

«empty»

| NonemptyClassRanges^dash

{dash, noDash}

NonemptyClassRanges

ClassAtom^dash

| ClassAtom NonemptyClassRanges^noDash

| ClassAtom - ClassAtom^dash ClassRanges

| NullEscape ClassRanges

Semantics

AcceptanceSet[CharacterClass]: Char16{};

AcceptanceSet[CharacterClass [ [lookahead{^}] ClassRanges ]] = AcceptanceSet[ClassRanges];

AcceptanceSet[CharacterClass [ ^ ClassRanges ]] = AcceptanceSet[ClassRanges];

Invert[CharacterClass]: Boolean;

Invert[CharacterClass [ [lookahead{^}] ClassRanges ]] = false;

Invert[CharacterClass [ ^ ClassRanges ]] = true;

AcceptanceSet[ClassRanges]: Char16{};

AcceptanceSet[ClassRanges «empty»] = {};

AcceptanceSet[ClassRanges NonemptyClassRanges^dash] = AcceptanceSet[NonemptyClassRanges^dash];

AcceptanceSet[NonemptyClassRanges]: Char16{};

AcceptanceSet[NonemptyClassRanges ClassAtom^dash] = AcceptanceSet[ClassAtom^dash];

AcceptanceSet[NonemptyClassRanges₀ ClassAtom NonemptyClassRanges^noDash₁] = AcceptanceSet[ClassAtom] AcceptanceSet[NonemptyClassRanges^noDash₁];

AcceptanceSet[NonemptyClassRanges ClassAtom₁ - ClassAtom^dash₂ ClassRanges] = characterRange(AcceptanceSet[ClassAtom₁], AcceptanceSet[ClassAtom^dash₂]) AcceptanceSet[ClassRanges];

AcceptanceSet[NonemptyClassRanges NullEscape ClassRanges] = AcceptanceSet[ClassRanges];

proc characterRange(low: Char16{}, high: Char16{}): Char16{}

if |low| 1 or |high| 1 then throw syntaxError end if;

l: Char16 the one element of low;

h: Char16 the one element of high;

if l h then return {l ... h} else throw syntaxError end if

end proc;

Character Class Range Atoms

Syntax

ClassAtom

ClassCharacter

| \ ClassEscape

ClassCharacter^dash UnicodeCharacter except \ | ]

ClassCharacter^noDash ClassCharacter^dash except -

ClassEscape

DecimalEscape

| b

Semantics

AcceptanceSet[ClassAtom]: Char16{};

AcceptanceSet[ClassAtom ClassCharacter] = {ClassCharacter};

AcceptanceSet[ClassAtom \ ClassEscape] = AcceptanceSet[ClassEscape];

AcceptanceSet[ClassEscape]: Char16{};

AcceptanceSet[ClassEscape DecimalEscape]

begin

if EscapeValue[DecimalEscape] = 0 then return {‘«NUL»’}

else throw syntaxError

end if

end;

AcceptanceSet[ClassEscape b] = {‘«BS»’};

AcceptanceSet[ClassEscape CharacterEscape] = {CharacterValue[CharacterEscape]};

AcceptanceSet[ClassEscape CharacterClassEscape] = AcceptanceSet[CharacterClassEscape];

ECMAScript 4 Netscape Proposal

Formal Description

Syntactic Grammar

Monday, June 30, 2003

This LALR(1) grammar describes the syntax of the ECMAScript 4 proposal. The starting nonterminal is Program. See also the description of the grammar notation.

This document is also available as a Word RTF file.

Terminals

General tokens: Identifier NegatedMinLong Number RegularExpression String VirtualSemicolon

Punctuation tokens: ! != !== % %= & && &&= &= ( ) * *= + ++ += , - -- -= . ... / /= : :: ; < << <<= <= = == === > >= >> >>= >>> >>>= ? [ ] ^ ^= ^^ ^^= { | |= || ||= } ~

Reserved words: as break case catch class const continue default delete do else extends false finally for function if import in instanceof is namespace new null package private public return super switch this throw true try typeof use var void while with

Future reserved words: abstract debugger enum export goto implements interface native protected synchronized throws transient volatile

Non-reserved words: get set

Expressions

{allowIn, noIn}

Identifiers

Identifier

| get

| set

Qualified Identifiers

SimpleQualifiedIdentifier

Identifier

| Identifier :: Identifier

| ReservedNamespace :: Identifier

ExpressionQualifiedIdentifier ParenExpression :: Identifier

QualifiedIdentifier

Primary Expressions

PrimaryExpression

null

| true

| false

| Number

| String

| this

| RegularExpression

ReservedNamespace

public

| private

ParenExpression ( AssignmentExpression^allowIn )

ParenListExpression

ParenExpression

| ( ListExpression^allowIn , AssignmentExpression^allowIn )

Function Expressions

FunctionExpression

function FunctionCommon

| function Identifier FunctionCommon

Object Literals

ObjectLiteral { FieldList }

FieldList

«empty»

| NonemptyFieldList

NonemptyFieldList

LiteralField

| LiteralField , NonemptyFieldList

LiteralField FieldName : AssignmentExpression^allowIn

FieldName

| String

| Number

| ParenExpression

Array Literals

ArrayLiteral [ ElementList ]

ElementList

«empty»

| LiteralElement

| , ElementList

| LiteralElement , ElementList

LiteralElement AssignmentExpression^allowIn

Super Expressions

SuperExpression

super

| super ParenExpression

Postfix Expressions

PostfixExpression

| FullPostfixExpression

AttributeExpression

| AttributeExpression PropertyOperator

| AttributeExpression Arguments

FullPostfixExpression

| PostfixExpression [no line break] ++

| PostfixExpression [no line break] --

FullNewExpression new FullNewSubexpression Arguments

FullNewSubexpression

| QualifiedIdentifier

| FullNewSubexpression PropertyOperator

ShortNewExpression new ShortNewSubexpression

ShortNewSubexpression

FullNewSubexpression

Property Operators

PropertyOperator

. QualifiedIdentifier

| Brackets

Brackets

[ ]

| [ ListExpression^allowIn ]

| [ ExpressionsWithRest ]

Arguments

( )

| ( ExpressionsWithRest )

ExpressionsWithRest

RestExpression

| ListExpression^allowIn , RestExpression

RestExpression ... AssignmentExpression^allowIn

Unary Operators

UnaryExpression

| delete PostfixExpression

| void UnaryExpression

| typeof UnaryExpression

| ++ PostfixExpression

| -- PostfixExpression

| + UnaryExpression

| - UnaryExpression

| - NegatedMinLong

| ~ UnaryExpression

| ! UnaryExpression

Multiplicative Operators

MultiplicativeExpression

| MultiplicativeExpression * UnaryExpression

| MultiplicativeExpression / UnaryExpression

| MultiplicativeExpression % UnaryExpression

Additive Operators

AdditiveExpression

| AdditiveExpression + MultiplicativeExpression

| AdditiveExpression - MultiplicativeExpression

Bitwise Shift Operators

ShiftExpression

| ShiftExpression << AdditiveExpression

| ShiftExpression >> AdditiveExpression

| ShiftExpression >>> AdditiveExpression

Relational Operators

RelationalExpression^allowIn

| RelationalExpression^allowIn < ShiftExpression

| RelationalExpression^allowIn > ShiftExpression

| RelationalExpression^allowIn <= ShiftExpression

| RelationalExpression^allowIn >= ShiftExpression

| RelationalExpression^allowIn is ShiftExpression

| RelationalExpression^allowIn as ShiftExpression

| RelationalExpression^allowIn in ShiftExpression

| RelationalExpression^allowIn instanceof ShiftExpression

RelationalExpression^noIn

| RelationalExpression^noIn < ShiftExpression

| RelationalExpression^noIn > ShiftExpression

| RelationalExpression^noIn <= ShiftExpression

| RelationalExpression^noIn >= ShiftExpression

| RelationalExpression^noIn is ShiftExpression

| RelationalExpression^noIn as ShiftExpression

| RelationalExpression^noIn instanceof ShiftExpression

Equality Operators

EqualityExpression

| EqualityExpression == RelationalExpression

| EqualityExpression != RelationalExpression

| EqualityExpression === RelationalExpression

| EqualityExpression !== RelationalExpression

Binary Bitwise Operators

BitwiseAndExpression

| BitwiseAndExpression & EqualityExpression

BitwiseXorExpression

| BitwiseXorExpression ^ BitwiseAndExpression

BitwiseOrExpression

| BitwiseOrExpression | BitwiseXorExpression

Binary Logical Operators

LogicalAndExpression

| LogicalAndExpression && BitwiseOrExpression

LogicalXorExpression

LogicalAndExpression

| LogicalXorExpression ^^ LogicalAndExpression

LogicalOrExpression

LogicalXorExpression

| LogicalOrExpression || LogicalXorExpression

Conditional Operator

ConditionalExpression

| LogicalOrExpression ? AssignmentExpression : AssignmentExpression

NonAssignmentExpression

| LogicalOrExpression ? NonAssignmentExpression : NonAssignmentExpression

Assignment Operators

AssignmentExpression

| PostfixExpression CompoundAssignment AssignmentExpression

| PostfixExpression LogicalAssignment AssignmentExpression

CompoundAssignment

*=

| /=

| %=

| +=

| -=

| <<=

| >>=

| >>>=

| &=

| ^=

| |=

LogicalAssignment

&&=

| ^^=

| ||=

Comma Expressions

ListExpression

| ListExpression , AssignmentExpression

Type Expressions

TypeExpression NonAssignmentExpression

Statements

{abbrev, noShortIf, full}

Statement

ExpressionStatement Semicolon

| SuperStatement Semicolon

| Block

| LabeledStatement

| IfStatement

| SwitchStatement

| DoStatement Semicolon

| WhileStatement

| ForStatement

| WithStatement

| ContinueStatement Semicolon

| BreakStatement Semicolon

| ReturnStatement Semicolon

| ThrowStatement Semicolon

| TryStatement

Substatement

| Statement

| SimpleVariableDefinition Semicolon

| Attributes [no line break] { Substatements }

Substatements

«empty»

| SubstatementsPrefix Substatement^abbrev

SubstatementsPrefix

«empty»

| SubstatementsPrefix Substatement^full

Semicolon^abbrev

;

| VirtualSemicolon

| «empty»

Semicolon^noShortIf

;

| VirtualSemicolon

| «empty»

Semicolon^full

;

| VirtualSemicolon

Empty Statement

EmptyStatement ;

Expression Statement

ExpressionStatement [lookahead{function, {}] ListExpression^allowIn

Super Statement

SuperStatement super Arguments

Block Statement

Block { Directives }

Labeled Statements

LabeledStatement Identifier : Substatement

If Statement

IfStatement^abbrev

if ParenListExpression Substatement^abbrev

| if ParenListExpression Substatement^noShortIf else Substatement^abbrev

IfStatement^full

if ParenListExpression Substatement^full

| if ParenListExpression Substatement^noShortIf else Substatement^full

IfStatement^noShortIf if ParenListExpression Substatement^noShortIf else Substatement^noShortIf

Switch Statement

SwitchStatement switch ParenListExpression { CaseElements }

CaseElements

«empty»

| CaseLabel

| CaseLabel CaseElementsPrefix CaseElement^abbrev

CaseElementsPrefix

«empty»

| CaseElementsPrefix CaseElement^full

CaseElement

Directive

| CaseLabel

CaseLabel

case ListExpression^allowIn :

| default :

Do-While Statement

DoStatement do Substatement^abbrev while ParenListExpression

While Statement

WhileStatement while ParenListExpression Substatement

For Statements

ForStatement

for ( ForInitializer ; OptionalExpression ; OptionalExpression ) Substatement

| for ( ForInBinding in ListExpression^allowIn ) Substatement

ForInitializer

«empty»

| ListExpression^noIn

| VariableDefinition^noIn

| Attributes [no line break] VariableDefinition^noIn

ForInBinding

| VariableDefinitionKind VariableBinding^noIn

| Attributes [no line break] VariableDefinitionKind VariableBinding^noIn

OptionalExpression

ListExpression^allowIn

| «empty»

With Statement

WithStatement with ParenListExpression Substatement

Continue and Break Statements

ContinueStatement

continue

| continue [no line break] Identifier

BreakStatement

break

| break [no line break] Identifier

Return Statement

ReturnStatement

return

| return [no line break] ListExpression^allowIn

Throw Statement

ThrowStatement throw [no line break] ListExpression^allowIn

Try Statement

TryStatement

try Block CatchClauses

| try Block CatchClausesOpt finally Block

CatchClausesOpt

«empty»

| CatchClauses

CatchClauses

CatchClause

| CatchClauses CatchClause

CatchClause catch ( Parameter ) Block

Directives

Directive

| Statement

| AnnotatableDirective

| Attributes [no line break] AnnotatableDirective

| Attributes [no line break] { Directives }

| Pragma Semicolon

AnnotatableDirective

VariableDefinition^allowIn Semicolon

| FunctionDefinition

| ClassDefinition

| NamespaceDefinition Semicolon

| ImportDirective Semicolon

| UseDirective Semicolon

Directives

«empty»

| DirectivesPrefix Directive^abbrev

DirectivesPrefix

«empty»

| DirectivesPrefix Directive^full

Attributes

Attribute

AttributeCombination Attribute [no line break] Attributes

Attribute

| true

| false

Use Directive

UseDirective use namespace ParenListExpression

Import Directive

ImportDirective

import PackageName

| import Identifier = PackageName

Pragma

Pragma use PragmaItems

PragmaItems

PragmaItem

| PragmaItems , PragmaItem

PragmaItem

PragmaExpr

| PragmaExpr ?

PragmaExpr

Identifier

| Identifier ( PragmaArgument )

PragmaArgument

true

| false

| Number

| - Number

| - NegatedMinLong

| String

Definitions

Variable Definition

VariableDefinition VariableDefinitionKind VariableBindingList

VariableDefinitionKind

var

| const

VariableBindingList

VariableBinding

| VariableBindingList , VariableBinding

VariableBinding TypedIdentifier VariableInitialisation

VariableInitialisation

«empty»

| = VariableInitializer

VariableInitializer

TypedIdentifier

Identifier

| Identifier : TypeExpression

Simple Variable Definition

SimpleVariableDefinition var UntypedVariableBindingList

UntypedVariableBindingList

UntypedVariableBinding

| UntypedVariableBindingList , UntypedVariableBinding

UntypedVariableBinding Identifier VariableInitialisation^allowIn

Function Definition

FunctionDefinition function FunctionName FunctionCommon

FunctionName

Identifier

| get [no line break] Identifier

| set [no line break] Identifier

FunctionCommon ( Parameters ) Result Block

Parameters

«empty»

NonemptyParameters

ParameterInit

Parameter ParameterAttributes TypedIdentifier^allowIn

ParameterAttributes

«empty»

| const

ParameterInit

Parameter

| Parameter = AssignmentExpression^allowIn

RestParameter

...

| ... ParameterAttributes Identifier

Result

«empty»

| : TypeExpression^allowIn

Class Definition

ClassDefinition class Identifier Inheritance Block

Inheritance

«empty»

| extends TypeExpression^allowIn

Namespace Definition

NamespaceDefinition namespace Identifier

Programs

Program

Directives

| PackageDefinition Program

Package Definition

PackageDefinition package PackageNameOpt Block

PackageNameOpt

«empty»

| PackageName

PackageName

String

| PackageIdentifiers

PackageIdentifiers

Identifier

| PackageIdentifiers . Identifier

ECMAScript 4 Netscape Proposal

Formal Description

Syntactic Semantics

Monday, June 30, 2003

The syntactic semantics describe the actions the parser takes to evaluate an ECMAScript 4 program. For convenience, the syntactic grammar is repeated here. The starting nonterminal is Program. See also the description of the semantic notation.

The semantics are under construction. Many execution paths resulting in ???? represent semantics yet to be implemented.

This document is also available as a Word RTF file.

Terminals

General tokens: Identifier NegatedMinLong Number RegularExpression String VirtualSemicolon

Future reserved words: abstract debugger enum export goto implements interface native protected synchronized throws transient volatile

Non-reserved words: get set

Data Model

Semantic Exceptions

tuple Break

value: Object,

label: Label

end tuple;

tuple Continue

value: Object,

label: Label

end tuple;

tuple Return

value: Object

end tuple;

ControlTransfer = Break Continue Return;

SemanticException = Object ControlTransfer;

Extended integers and rationals

tag +zero;

tag –zero;

tag +;

tag –;

tag NaN;

ExtendedRational = (Rational – {0}) {+zero, –zero, +, –, NaN};

ExtendedInteger = Integer {+, –, NaN};

Objects

tag none;

tag ok;

tag reject;

Object = Undefined Null Boolean Long ULong Float32 Float64 Char16 String Namespace CompoundAttribute Class SimpleInstance MethodClosure Date RegExp Package;

PrimitiveObject = Undefined Null Boolean Long ULong Float32 Float64 Char16 String;

NonprimitiveObject = Namespace CompoundAttribute Class SimpleInstance MethodClosure Date RegExp Package;

BindingObject = Class SimpleInstance RegExp Date Package;

ObjectOpt = Object {none};

BooleanOpt = Boolean {none};

IntegerOpt = Integer {none};

Undefined

tag undefined;

Undefined = {undefined};

Null

tag null;

Null = {null};

Strings

StringOpt = String {none};

Namespaces

record Namespace

end record;

Qualified Names

tuple QualifiedName

namespace: Namespace,

id: String

end tuple;

The notation ns::id is a shorthand for QualifiedNamenamespace: ns, id: id.

Multiname = QualifiedName{};

Attributes

tag static;

tag virtual;

tag final;

PropertyCategory = {none, static, virtual, final};

OverrideModifier = {none, true, false, undefined};

tuple CompoundAttribute

namespaces: Namespace{},

explicit: Boolean,

enumerable: Boolean,

dynamic: Boolean,

category: PropertyCategory,

overrideMod: OverrideModifier,

prototype: Boolean,

unused: Boolean

end tuple;

Attribute = Boolean Namespace CompoundAttribute;

AttributeOptNotFalse = {none, true} Namespace CompoundAttribute;

Classes

record Class

localBindings: LocalBinding{},

instanceProperties: InstanceProperty{},

super: ClassOpt,

prototype: ObjectOpt,

complete: Boolean,

typeofString: String,

privateNamespace: Namespace,

dynamic: Boolean,

final: Boolean,

defaultValue: ObjectOpt,

defaultHint: Hint,

hasProperty: Object Class Object Boolean Phase Boolean,

bracketRead: Object Class Object[] Boolean Phase ObjectOpt,

bracketWrite: Object Class Object[] Object Boolean {run} {none, ok},

bracketDelete: Object Class Object[] {run} BooleanOpt,

read: Object Class Multiname EnvironmentOpt Boolean Phase ObjectOpt,

write: Object Class Multiname EnvironmentOpt Object Boolean {run} {none, ok},

delete: Object Class Multiname EnvironmentOpt {run} BooleanOpt,

enumerate: Object Object{},

call: Object Class Object[] Phase Object,

construct: Class Object[] Phase Object,

init: (SimpleInstance Object[] {run} ()) {none},

is: Object Class Boolean,

coerce: Object Class ObjectOpt

end record;

ClassOpt = Class {none};

Simple Instances

record SimpleInstance

localBindings: LocalBinding{},

archetype: ObjectOpt,

sealed: Boolean,

type: Class,

slots: Slot{},

call: (Object SimpleInstance Object[] Phase Object) {none},

construct: (SimpleInstance Object[] Phase Object) {none},

env: EnvironmentOpt

end record;

Slots

record Slot

id: InstanceVariable,

value: ObjectOpt

end record;

Uninstantiated Functions

record UninstantiatedFunction

type: Class,

length: Integer,

call: (Object SimpleInstance Object[] Phase Object) {none},

construct: (SimpleInstance Object[] Phase Object) {none},

instantiations: SimpleInstance{}

end record;

Method Closures

tuple MethodClosure

this: Object,

method: InstanceMethod,

slots: Slot{}

end tuple;

Dates

record Date

localBindings: LocalBinding{},

archetype: ObjectOpt,

sealed: Boolean,

timeValue: Integer

end record;

Regular Expressions

record RegExp

localBindings: LocalBinding{},

archetype: ObjectOpt,

sealed: Boolean,

source: String,

lastIndex: Integer,

global: Boolean,

ignoreCase: Boolean,

multiline: Boolean

end record;

Packages

record Package

localBindings: LocalBinding{},

archetype: ObjectOpt,

initialize: (() ()) {none, busy},

sealed: Boolean,

internalNamespace: Namespace

end record;

Objects with Limits

instance must be an instance of one of limit’s descendants.

tuple LimitedInstance

instance: Object,

limit: Class

end tuple;

ObjOptionalLimit = Object LimitedInstance;

References

tuple LexicalReference

env: Environment,

variableMultiname: Multiname,

strict: Boolean

end tuple;

tuple DotReference

base: Object,

limit: Class,

multiname: Multiname

end tuple;

tuple BracketReference

base: Object,

limit: Class,

args: Object[]

end tuple;

Reference = LexicalReference DotReference BracketReference;

ObjOrRef = Object Reference;

Modes of expression evaluation

tag compile;

tag run;

Phase = {compile, run};

Contexts

record Context

strict: Boolean,

openNamespaces: Namespace{}

end record;

Labels

tag default;

Label = String {default};

tuple JumpTargets

breakTargets: Label{},

continueTargets: Label{}

end tuple;

Function Support

tag normal;

tag get;

tag set;

Handling = {normal, get, set};

tag plainFunction;

tag uncheckedFunction;

tag prototypeFunction;

tag instanceFunction;

tag constructorFunction;

StaticFunctionKind = {plainFunction, uncheckedFunction, prototypeFunction};

FunctionKind = {plainFunction, uncheckedFunction, prototypeFunction, instanceFunction, constructorFunction};

Environments

An Environment is a list of two or more frames. Each frame corresponds to a scope. More specific frames are listed first—each frame’s scope is directly contained in the following frame’s scope. The last frame is always a Package. A WithFrame is always preceded by a LocalFrame, so the first frame is never a WithFrame.

Environment = Frame[];

EnvironmentOpt = Environment {none};

Frame = NonWithFrame WithFrame;

NonWithFrame = Package ParameterFrame Class LocalFrame;

record ParameterFrame

localBindings: LocalBinding{},

kind: FunctionKind,

handling: Handling,

callsSuperconstructor: Boolean,

superconstructorCalled: Boolean,

this: ObjectOpt,

parameters: Parameter[],

rest: VariableOpt,

returnType: Class

end record;

ParameterFrameOpt = ParameterFrame {none};

tuple Parameter

var: Variable DynamicVar,

default: ObjectOpt

end tuple;

record LocalFrame

localBindings: LocalBinding{}

end record;

record WithFrame

value: ObjectOpt

end record;

Properties

tag read;

tag write;

tag readWrite;

Access = {read, write};

AccessSet = {read, write, readWrite};

tuple LocalBinding

qname: QualifiedName,

accesses: AccessSet,

explicit: Boolean,

enumerable: Boolean,

content: SingletonProperty

end tuple;

tag forbidden;

SingletonProperty = {forbidden} Variable DynamicVar Getter Setter;

SingletonPropertyOpt = SingletonProperty {none};

VariableValue = {none} Object UninstantiatedFunction;

tag busy;

Initializer = Environment Phase Object;

InitializerOpt = Initializer {none};

record Variable

type: Class,

value: VariableValue,

immutable: Boolean,

setup: (() ClassOpt) {none, busy},

initializer: Initializer {none, busy},

initializerEnv: Environment

end record;

VariableOpt = Variable {none};

record DynamicVar

value: Object UninstantiatedFunction,

sealed: Boolean

end record;

record Getter

call: Environment Phase Object,

env: EnvironmentOpt

end record;

record Setter

call: Object Environment Phase (),

env: EnvironmentOpt

end record;

InstanceProperty = InstanceVariable InstanceMethod InstanceGetter InstanceSetter;

InstancePropertyOpt = InstanceProperty {none};

record InstanceVariable

multiname: Multiname,

final: Boolean,

enumerable: Boolean,

type: Class,

defaultValue: ObjectOpt,

immutable: Boolean

end record;

InstanceVariableOpt = InstanceVariable {none};

record InstanceMethod

multiname: Multiname,

final: Boolean,

enumerable: Boolean,

signature: ParameterFrame,

length: Integer,

call: Object Object[] Phase Object

end record;

record InstanceGetter

multiname: Multiname,

final: Boolean,

enumerable: Boolean,

signature: ParameterFrame,

call: Object Phase Object

end record;

record InstanceSetter

multiname: Multiname,

final: Boolean,

enumerable: Boolean,

signature: ParameterFrame,

call: Object Object Phase ()

end record;

PropertyOpt = SingletonProperty InstanceProperty {none};

Miscellaneous

tag hintString;

tag hintNumber;

Hint = {hintString, hintNumber};

HintOpt = Hint {none};

tag less;

tag equal;

tag greater;

tag unordered;

Order = {less, equal, greater, unordered};

Data Operations

Numeric Utilities

unsignedWrap32(i) returns i converted to a value between 0 and 2³²–1 inclusive, wrapping around modulo 2³² if necessary.

proc unsignedWrap32(i: Integer): {0 ... 2³² – 1}

return bitwiseAnd(i, 0xFFFFFFFF)

end proc;

signedWrap32(i) returns i converted to a value between –2³¹ and 2³¹–1 inclusive, wrapping around modulo 2³² if necessary.

proc signedWrap32(i: Integer): {–2³¹ ... 2³¹ – 1}

j: Integer bitwiseAnd(i, 0xFFFFFFFF);

if j 2³¹ then j j – 2³² end if;

return j

end proc;

unsignedWrap64(i) returns i converted to a value between 0 and 2⁶⁴–1 inclusive, wrapping around modulo 2⁶⁴ if necessary.

proc unsignedWrap64(i: Integer): {0 ... 2⁶⁴ – 1}

return bitwiseAnd(i, 0xFFFFFFFFFFFFFFFF)

end proc;

signedWrap64(i) returns i converted to a value between –2⁶³ and 2⁶³–1 inclusive, wrapping around modulo 2⁶⁴ if necessary.

proc signedWrap64(i: Integer): {–2⁶³ ... 2⁶³ – 1}

j: Integer bitwiseAnd(i, 0xFFFFFFFFFFFFFFFF);

if j 2⁶³ then j j – 2⁶⁴ end if;

return j

end proc;

truncateToInteger(x) returns x converted to an integer by rounding towards zero. If x is an infinity or a NaN, the result is 0.

proc truncateToInteger(x: GeneralNumber): Integer

case x of

{NaN_f32, NaN_f64, +_f32, +_f64, –_f32, –_f64} do return 0;

FiniteFloat32 do return truncateFiniteFloat32(x);

FiniteFloat64 do return truncateFiniteFloat64(x);

Long ULong do return x.value

end case

end proc;

pinExtendedInteger(i, limit, negativeFromEnd) returns i pinned to the set {0 ... limit}, where limit is a nonnegative integer. If negativeFromEnd is true, then negative values of i from –limit through –1 are treated as 0 through limit – 1 respectively.

proc pinExtendedInteger(i: ExtendedInteger, limit: Integer, negativeFromEnd: Boolean): Integer

case i of

{NaN} do throw a RangeError exception;

{–} do return 0;

{+} do return limit;

Integer do

j: Integer i;

if j > limit then j limit end if;

if negativeFromEnd and j < 0 then j j + limit end if;

if j < 0 then j 0 end if;

note 0 j limit;

return j

end case

end proc;

checkInteger(x) returns x converted to an integer if its mathematical value is, in fact, an integer. If x is an infinity or a NaN or has a fractional part, the result is none.

proc checkInteger(x: GeneralNumber): IntegerOpt

case x of

{NaN_f32, NaN_f64, +_f32, +_f64, –_f32, –_f64} do return none;

{+zero_f32, +zero_f64, –zero_f32, –zero_f64} do return 0;

Long ULong do return x.value;

NonzeroFiniteFloat32 NonzeroFiniteFloat64 do

r: Rational x.value;

if r Integer then return none end if;

return r

end case

end proc;

integerToLong(i) converts i to the first of the types Long, ULong, or Float64 that can contain the value i. If necessary, the Float64 result may be rounded or converted to an infinity using the IEEE 754 “round to nearest” mode.

proc integerToLong(i: Integer): GeneralNumber

if –2⁶³ i 2⁶³ – 1 then return i_long

elsif 2⁶³ i 2⁶⁴ – 1 then return i_ulong

else return i_f64

end if

end proc;

integerToULong(i) converts i to the first of the types ULong, Long, or Float64 that can contain the value i. If necessary, the Float64 result may be rounded or converted to an infinity using the IEEE 754 “round to nearest” mode.

proc integerToULong(i: Integer): GeneralNumber

if 0 i 2⁶⁴ – 1 then return i_ulong

elsif –2⁶³ i –1 then return i_long

else return i_f64

end if

end proc;

rationalToLong(q) converts q to one of the types Long, ULong, or Float64, whichever one can come the closest to representing the true value of q. If several of these types can come equally close to the value of q, then one of them is chosen according to the algorithm below.

proc rationalToLong(q: Rational): GeneralNumber

if q Integer then return integerToLong(q)

elsif |q| 2⁵³ then return q_f64

elsif q < –2⁶³ – 1/2 or q 2⁶⁴ – 1/2 then return q_f64

else

Let i be the integer closest to q. If q is halfway between two integers, pick i so that it is even.

note –2⁶³ i 2⁶⁴ – 1;

if i < 2⁶³ then return i_long else return i_ulong end if

end if

end proc;

rationalToULong(q) converts q to one of the types ULong, Long, or Float64, whichever one can come the closest to representing the true value of q. If several of these types can come equally close to the value of q, then one of them is chosen according to the algorithm below.

proc rationalToULong(q: Rational): GeneralNumber

if q Integer then return integerToULong(q)

elsif |q| 2⁵³ then return q_f64

elsif q < –2⁶³ – 1/2 or q 2⁶⁴ – 1/2 then return q_f64

else

Let i be the integer closest to q. If q is halfway between two integers, pick i so that it is even.

note –2⁶³ i 2⁶⁴ – 1;

if i 0 then return i_ulong else return i_long end if

end if

end proc;

proc extendedRationalToFloat32(q: ExtendedRational): Float32

case q of

Rational do return q_f32;

{+zero} do return +zero_f32;

{–zero} do return –zero_f32;

{+} do return +_f32;

{–} do return –_f32;

{NaN} do return NaN_f32

end case

end proc;

proc extendedRationalToFloat64(q: ExtendedRational): Float64

case q of

Rational do return q_f64;

{+zero} do return +zero_f64;

{–zero} do return –zero_f64;

{+} do return +_f64;

{–} do return –_f64;

{NaN} do return NaN_f64

end case

end proc;

toRational(x) returns the exact Rational value of x.

proc toRational(x: FiniteGeneralNumber): Rational

case x of

{+zero_f32, +zero_f64, –zero_f32, –zero_f64} do return 0;

NonzeroFiniteFloat32 NonzeroFiniteFloat64 Long ULong do return x.value

end case

end proc;

toFloat32(x) converts x to a Float32, using the IEEE 754 “round to nearest” mode.

proc toFloat32(x: GeneralNumber): Float32

case x of

Long ULong do return (x.value)_f32;

Float32 do return x;

{–_f64} do return –_f32;

{–zero_f64} do return –zero_f32;

{+zero_f64} do return +zero_f32;

{+_f64} do return +_f32;

{NaN_f64} do return NaN_f32;

NonzeroFiniteFloat64 do return (x.value)_f32

end case

end proc;

toFloat64(x) converts x to a Float64, using the IEEE 754 “round to nearest” mode.

proc toFloat64(x: GeneralNumber): Float64

case x of

Long ULong do return (x.value)_f64;

Float32 do return float32ToFloat64(x);

Float64 do return x

end case

end proc;

generalNumberCompare(x, y) compares x with y using the IEEE 754 rules and returns less if x<y, equal if x=y, greater if x>y, or unordered if either x or y is a NaN. The comparison is done using the exact values of x and y, even if they have different types. Positive infinities compare equal to each other and greater than any other non-NaN values. Negative infinities compare equal to each other and less than any other non-NaN values. Positive and negative zeroes compare equal to each other.

proc generalNumberCompare(x: GeneralNumber, y: GeneralNumber): Order

if x {NaN_f32, NaN_f64} or y {NaN_f32, NaN_f64} then return unordered

elsif x {+_f32, +_f64} and y {+_f32, +_f64} then return equal

elsif x {–_f32, –_f64} and y {–_f32, –_f64} then return equal

elsif x {+_f32, +_f64} or y {–_f32, –_f64} then return greater

elsif x {–_f32, –_f64} or y {+_f32, +_f64} then return less

else

xr: Rational toRational(x);

yr: Rational toRational(y);

if xr < yr then return less

elsif xr > yr then return greater

else return equal

end if

end proc;

Character Utilities

proc integerToUTF16(i: {0 ... 0x10FFFF}): String

if 0 i 0xFFFF then return [integerToChar16(i)]

else

j: {0 ... 0xFFFFF} i – 0x10000;

high: Char16 integerToChar16(0xD800 + bitwiseShift(j, –10));

low: Char16 integerToChar16(0xDC00 + bitwiseAnd(j, 0x3FF));

return [high, low]

end if

end proc;

proc char21ToUTF16(ch: Char21): String

return integerToUTF16(char21ToInteger(ch))

end proc;

proc surrogatePairToSupplementaryChar(h: Char16, l: Char16): SupplementaryChar

codePoint: {0x10000 ... 0x10FFFF} 0x10000 + (char16ToInteger(h) – 0xD800)0x400 + char16ToInteger(l) – 0xDC00;

return integerToSupplementaryChar(codePoint)

end proc;

proc stringToUTF32(s: String): Char21[]

i: Integer 0;

result: Char21[] [];

while i |s| do

ch: Char21;

if s[i] {‘«uD800»’ ... ‘«uDBFF»’} and i + 1 |s| and s[i + 1] {‘«uDC00»’ ... ‘«uDFFF»’} then

ch surrogatePairToSupplementaryChar(s[i], s[i + 1]);

i i + 2

else ch s[i]; i i + 1

end if;

result result [ch]

end while;

return result

end proc;

proc charToLowerFull(ch: Char21): String

return ch converted to a lower case character using the Unicode full, locale-independent case mapping. A single character may be converted to multiple characters. If ch has no lower case equivalent, then the result is the string char21ToUTF16(ch).

end proc;

proc charToLowerLocalized(ch: Char21): String

return ch converted to a lower case character using the Unicode full case mapping in the host environment’s current locale. A single character may be converted to multiple characters. If ch has no lower case equivalent, then the result is the string char21ToUTF16(ch).

end proc;

proc charToUpperFull(ch: Char21): String

return ch converted to a upper case character using the Unicode full, locale-independent case mapping. A single character may be converted to multiple characters. If ch has no upper case equivalent, then the result is the string char21ToUTF16(ch).

end proc;

proc charToUpperLocalized(ch: Char21): String

return ch converted to a upper case character using the Unicode full case mapping in the host environment’s current locale. A single character may be converted to multiple characters. If ch has no upper case equivalent, then the result is the string char21ToUTF16(ch).

end proc;

Object Utilities

Object Class Inquiries

objectType(o) returns an Object o’s most specific type. Although objectType is used internally throughout this specification, in order to allow one programmer-visible class to be implemented as an ensemble of implementation-specific classes, no way is provided for a user program to directly obtain the result of calling objectType on an object.

proc objectType(o: Object): Class

case o of

Undefined do return Void;

Null do return Null;

Boolean do return Boolean;

Long do return long;

ULong do return ulong;

Float32 do return float;

Float64 do return Number;

Char16 do return char;

String do return String;

Namespace do return Namespace;

CompoundAttribute do return Attribute;

Class do return Class;

SimpleInstance do return o.type;

MethodClosure do return Function;

Date do return Date;

RegExp do return RegExp;

Package do return Package

end case

end proc;

is(o, c) returns true if o is an instance of class c or one of its subclasses.

proc is(o: Object, c: Class): Boolean

return c.is(o, c)

end proc;

ordinaryIs(o, c) is the implementation of is for a native class unless specified otherwise in the class’s definition. Host classes may either also use ordinaryIs or define a different procedure to perform this test.

proc ordinaryIs(o: Object, c: Class): Boolean

return isAncestor(c, objectType(o))

end proc;

Return an ordered list of class c’s ancestors, including c itself.

proc ancestors(c: Class): Class[]

s: ClassOpt c.super;

if s = none then return [c] else return ancestors(s) [c] end if

end proc;

Return true if c is d or an ancestor of d.

proc isAncestor(c: Class, d: Class): Boolean

if c = d then return true

else

s: ClassOpt d.super;

if s = none then return false end if;

return isAncestor(c, s)

end if

end proc;

Object to Boolean Conversion

objectToBoolean(o) returns o converted to a Boolean.

proc objectToBoolean(o: Object): Boolean

case o of

Undefined Null do return false;

Boolean do return o;

Long ULong do return o.value 0;

Float32 do return o {+zero_f32, –zero_f32, NaN_f32};

Float64 do return o {+zero_f64, –zero_f64, NaN_f64};

String do return o “”;

Char16 Namespace CompoundAttribute Class SimpleInstance MethodClosure Date RegExp Package do

return true

end case

end proc;

Object to Primitive Conversion

proc objectToPrimitive(o: Object, hint: HintOpt, phase: Phase): PrimitiveObject

if o PrimitiveObject then return o end if;

c: Class objectType(o);

h: Hint;

if hint Hint then h hint else h c.defaultHint end if;

case h of

{hintString} do

toStringMethod: ObjectOpt c.read(o, c, {public::“toString”}, none, false, phase);

if toStringMethod none then

r: Object call(o, toStringMethod, [], phase);

if r PrimitiveObject then return r end if

end if;

valueOfMethod: ObjectOpt c.read(o, c, {public::“valueOf”}, none, false, phase);

if valueOfMethod none then

r: Object call(o, valueOfMethod, [], phase);

if r PrimitiveObject then return r end if

end if;

{hintNumber} do

valueOfMethod: ObjectOpt c.read(o, c, {public::“valueOf”}, none, false, phase);

if valueOfMethod none then

r: Object call(o, valueOfMethod, [], phase);

if r PrimitiveObject then return r end if

end if;

toStringMethod: ObjectOpt c.read(o, c, {public::“toString”}, none, false, phase);

if toStringMethod none then

r: Object call(o, toStringMethod, [], phase);

if r PrimitiveObject then return r end if

end if

end case;

throw a TypeError exception — cannot convert this object to a primitive

end proc;

Object to Number Conversions

objectToGeneralNumber(o, phase) returns o converted to a GeneralNumber. If phase is compile, only constant conversions are permitted.

proc objectToGeneralNumber(o: Object, phase: Phase): GeneralNumber

a: PrimitiveObject objectToPrimitive(o, hintNumber, phase);

case a of

Undefined do return NaN_f64;

Null {false} do return +zero_f64;

{true} do return 1_f64;

GeneralNumber do return a;

Char16 String do return stringToFloat64(toString(a))

end case

end proc;

objectToFloat32(o, phase) returns o converted to a Float32. If phase is compile, only constant conversions are permitted.

proc objectToFloat32(o: Object, phase: Phase): Float32

a: PrimitiveObject objectToPrimitive(o, hintNumber, phase);

case a of

Undefined do return NaN_f32;

Null {false} do return +zero_f32;

{true} do return 1_f32;

GeneralNumber do return toFloat32(a);

Char16 String do return stringToFloat32(toString(a))

end case

end proc;

objectToFloat64(o, phase) returns o converted to a Float64. If phase is compile, only constant conversions are permitted.

proc objectToFloat64(o: Object, phase: Phase): Float64

return toFloat64(objectToGeneralNumber(o, phase))

end proc;

objectToExtendedInteger(o, phase) returns o converted to an ExtendedInteger. An error occurs if o has a fractional part or is a NaN. If o is a string, then it is converted exactly. If phase is compile, only constant conversions are permitted.

proc objectToExtendedInteger(o: Object, phase: Phase): ExtendedInteger

a: PrimitiveObject objectToPrimitive(o, hintNumber, phase);

case a of

Null {false} do return 0;

{true} do return 1;

{undefined, NaN_f32, NaN_f64} do return NaN;

{+_f32, +_f64} do return +;

{–_f32, –_f64} do return –;

{+zero_f32, +zero_f64, –zero_f32, –zero_f64} do return 0;

Long ULong do return a.value;

NonzeroFiniteFloat32 NonzeroFiniteFloat64 do

r: Rational a.value;

if r Integer then

throw a RangeError exception — the value a is not an integer

end if;

return r;

Char16 String do return stringToExtendedInteger(toString(a))

end case

end proc;

objectToInteger(o, phase) returns o converted to an Integer. An error occurs if o has a fractional part or is not finite. If o is a string, then it is converted exactly. If phase is compile, only constant conversions are permitted.

proc objectToInteger(o: Object, phase: Phase): Integer

i: ExtendedInteger objectToExtendedInteger(o, phase);

case i of

{+, –, NaN} do throw a RangeError exception — i is not an integer;

Integer do return i

end case

end proc;

proc stringToFloat32(s: String): Float32

Apply the lexer grammar with the start symbol StringNumericLiteral to the string s.

if the grammar cannot interpret the entire string as an expansion of StringNumericLiteral then

return NaN_f32

else

q: ExtendedRational the value of the action Lex applied to the obtained expansion of the nonterminal StringNumericLiteral;

return extendedRationalToFloat32(q)

end if

end proc;

proc stringToFloat64(s: String): Float64

Apply the lexer grammar with the start symbol StringNumericLiteral to the string s.

if the grammar cannot interpret the entire string as an expansion of StringNumericLiteral then

return NaN_f64

else

q: ExtendedRational the value of the action Lex applied to the obtained expansion of the nonterminal StringNumericLiteral;

return extendedRationalToFloat64(q)

end if

end proc;

proc stringToExtendedInteger(s: String): ExtendedInteger

Apply the lexer grammar with the start symbol StringNumericLiteral to the string s.

if the grammar cannot interpret the entire string as an expansion of StringNumericLiteral then

throw a TypeError exception — the string s does not contain a number

else

q: ExtendedRational the value of the action Lex applied to the obtained expansion of the nonterminal StringNumericLiteral;

case q of

{+zero, –zero} do return 0;

{+, –, NaN} do return q;

Rational do

if q Integer then return q

else throw a RangeError exception — the value should be an integer

end if

end case

end if

end proc;

Object to String Conversions

objectToString(o, phase) returns o converted to a String. If phase is compile, only constant conversions are permitted.

proc objectToString(o: Object, phase: Phase): String

a: PrimitiveObject objectToPrimitive(o, hintString, phase);

case a of

Undefined do return “undefined”;

Null do return “null”;

{false} do return “false”;

{true} do return “true”;

GeneralNumber do return generalNumberToString(a);

Char16 do return [a];

String do return a

end case

end proc;

proc toString(o: Char16 String): String

case o of

Char16 do return [o];

String do return o

end case

end proc;

proc generalNumberToString(x: GeneralNumber): String

case x of

Long ULong do return integerToString(x.value);

Float32 do return float32ToString(x);

Float64 do return float64ToString(x)

end case

end proc;

integerToString(i) converts an integer i to a string of one or more decimal digits. If i is negative, the string is preceded by a minus sign.

proc integerToString(i: Integer): String

if i < 0 then return [‘-’] integerToString(–i) end if;

q: Integer i/10;

r: Integer i – q10;

c: Char16 integerToChar16(r + char16ToInteger(‘0’));

if q = 0 then return [c] else return integerToString(q) [c] end if

end proc;

integerToStringWithSign(i) is the same as integerToString(i) except that the resulting string always begins with a plus or minus sign.

proc integerToStringWithSign(i: Integer): String

if i 0 then return [‘+’] integerToString(i)

else return [‘-’] integerToString(–i)

end if

end proc;

proc exponentialNotationString(digits: String, e: Integer): String

mantissa: String;

if |digits| = 1 then mantissa digits

else mantissa [digits[0]] “.” digits[1 ...]

end if;

return mantissa “e” integerToStringWithSign(e)

end proc;

float32ToString(x) converts a Float32 x to a string using fixed-point notation if the absolute value of x is between 10^–6 inclusive and 10²¹ exclusive, and exponential notation otherwise. The result has the fewest significant digits possible while still ensuring that converting the string back into a Float32 value would result in the same value x (except that –zero_f32 would become +zero_f32).

proc float32ToString(x: Float32): String

case x of

{NaN_f32} do return “NaN”;

{+zero_f32, –zero_f32} do return “0”;

{+_f32} do return “Infinity”;

{–_f32} do return “-Infinity”;

NonzeroFiniteFloat32 do

r: Rational x.value;

if r < 0 then return “-” float32ToString(float32Negate(x))

else

Let e, k, and s be integers such that k 1, 10^k–1 s 10^k, (s10^e+1–k)_f32 = x, and k is as small as possible.

note k is the number of digits in the decimal representation of s, s is not divisible by 10, and the least significant digit of s is not necessarily uniquely determined by the above criteria.

When there are multiple possibilities for s according to the rules above, implementations are encouraged but not required to select the one according to the following rule: Select the value of s for which s10^e+1–k is closest in value to r; if there are two such possible values of s, choose the one that is even.

digits: String integerToString(s)

if k – 1 e 20 then return digits repeat(‘0’, e + 1 – k)

elsif 0 e 20 then return digits[0 ... e] “.” digits[e + 1 ...]

elsif –6 e < 0 then return “0.” repeat(‘0’, –(e + 1)) digits

else return exponentialNotationString(digits, e)

end if

end case

end proc;

float64ToString(x) converts a Float64 x to a string using fixed-point notation if the absolute value of x is between 10^–6 inclusive and 10²¹ exclusive, and exponential notation otherwise. The result has the fewest significant digits possible while still ensuring that converting the string back into a Float64 value would result in the same value x (except that –zero_f64 would become +zero_f64).

proc float64ToString(x: Float64): String

case x of

{NaN_f64} do return “NaN”;

{+zero_f64, –zero_f64} do return “0”;

{+_f64} do return “Infinity”;

{–_f64} do return “-Infinity”;

NonzeroFiniteFloat64 do

r: Rational x.value;

if r < 0 then return “-” float64ToString(float64Negate(x))

else

Let e, k, and s be integers such that k 1, 10^k–1 s 10^k, (s10^e+1–k)_f64 = x, and k is as small as possible.

note k is the number of digits in the decimal representation of s, s is not divisible by 10, and the least significant digit of s is not necessarily uniquely determined by the above criteria.

digits: String integerToString(s)

if k – 1 e 20 then return digits repeat(‘0’, e + 1 – k)

elsif 0 e 20 then return digits[0 ... e] “.” digits[e + 1 ...]

elsif –6 e < 0 then return “0.” repeat(‘0’, –(e + 1)) digits

else return exponentialNotationString(digits, e)

end if

end case

end proc;

Object to Qualified Name Conversion

objectToQualifiedName(o, phase) coerces an object o to a qualified name. If phase is compile, only constant conversions are permitted.

proc objectToQualifiedName(o: Object, phase: Phase): QualifiedName

return public::(objectToString(o, phase))

end proc;

Object to Class Conversion

objectToClass(o) returns o converted to a non-null Class.

proc objectToClass(o: Object): Class

if o Class then return o else throw a TypeError exception end if

end proc;

Object to Attribute Conversion

objectToAttribute(o) returns o converted to an attribute.

proc objectToAttribute(o: Object, phase: Phase): Attribute

if o Attribute then return o

else

note If o is not an attribute, try to call it with no arguments.

a: Object call(null, o, [], phase);

if a Attribute then return a else throw a TypeError exception end if

end if

end proc;

Implicit Coercions

coerce(o, c) attempts to implicitly coerce o to class c. If the coercion succeeds, coerce returns the coerced value. If not, coerce throws a TypeError.

The coercion always succeeds and returns o unchanged if o is already a member of class c. The value returned from coerce always is a member of class c.

proc coerce(o: Object, c: Class): Object

result: ObjectOpt c.coerce(o, c);

if result none then return result

else throw a TypeError exception — coercion failed

end if

end proc;

coerceOrNull(o, c) attempts to implicitly coerce o to class c. If the coercion succeeds, coerceOrNull returns the coerced value. If not, then coerceOrNull returns null if null is a member of type c; otherwise, coerceOrNull throws a TypeError.

The coercion always succeeds and returns o unchanged if o is already a member of class c. The value returned from coerceOrNull always is a member of class c.

proc coerceOrNull(o: Object, c: Class): Object

result: ObjectOpt c.coerce(o, c);

if result none then return result

elsif c.coerce(null, c) = null then return null

else throw a TypeError exception — coercion failed

end if

end proc;

coerceNonNull(o, c) attempts to implicitly coerce o to class c. If the coercion succeeds and the result is not null, then coerceNonNull returns the coerced value. If not, coerceNonNull throws a TypeError.

proc coerceNonNull(o: Object, c: Class): Object

result: ObjectOpt c.coerce(o, c);

if result {none, null} then return result

else throw a TypeError exception — coercion failed

end if

end proc;

ordinaryCoerce(o, c) is the implementation of coercion for a native class unless specified otherwise in the class’s definition. Host classes may define a different procedure to perform this coercion.

proc ordinaryCoerce(o: Object, c: Class): ObjectOpt

if o = null or is(o, c) then return o else return none end if

end proc;

Attributes

combineAttributes(a, b) returns the attribute that results from concatenating the attributes a and b.

proc combineAttributes(a: AttributeOptNotFalse, b: Attribute): Attribute

if b = false then return false

elsif a {none, true} then return b

elsif b = true then return a

elsif a Namespace then

if a = b then return a

elsif b Namespace then

return CompoundAttributenamespaces: {a, b}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: false, unused: false

else return CompoundAttributenamespaces: b.namespaces {a}, other fields from b

end if

elsif b Namespace then

return CompoundAttributenamespaces: a.namespaces {b}, other fields from a

else

note At this point both a and b are compound attributes.

if (a.category none and b.category none and a.category b.category) or (a.overrideMod none and b.overrideMod none and a.overrideMod b.overrideMod) then

throw an AttributeError exception — attributes a and b have conflicting contents

else

return CompoundAttributenamespaces: a.namespaces b.namespaces, explicit: a.explicit or b.explicit, enumerable: a.enumerable or b.enumerable, dynamic: a.dynamic or b.dynamic, category: a.category none ? a.category : b.category, overrideMod: a.overrideMod none ? a.overrideMod : b.overrideMod, prototype: a.prototype or b.prototype, unused: a.unused or b.unused

end if

end proc;

toCompoundAttribute(a) returns a converted to a CompoundAttribute even if it was a simple namespace, true, or none.

proc toCompoundAttribute(a: AttributeOptNotFalse): CompoundAttribute

case a of

{none, true} do

return CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: false, unused: false;

Namespace do

return CompoundAttributenamespaces: {a}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: false, unused: false;

CompoundAttribute do return a

end case

end proc;

Access Utilities

accessesOverlap(accesses1, accesses2) returns true if the two AccessSets have a nonempty intersection.

proc accessesOverlap(accesses1: AccessSet, accesses2: AccessSet): Boolean

return accesses1 = accesses2 or accesses1 = readWrite or accesses2 = readWrite

end proc;

proc archetype(o: Object): ObjectOpt

case o of

Undefined Null do return none;

Boolean do return Boolean.prototype;

Long do return long.prototype;

ULong do return ulong.prototype;

Float32 do return float.prototype;

Float64 do return Number.prototype;

Char16 do return char.prototype;

String do return String.prototype;

Namespace do return Namespace.prototype;

CompoundAttribute do return Attribute.prototype;

MethodClosure do return Function.prototype;

Class do return Class.prototype;

SimpleInstance RegExp Date Package do return o.archetype

end case

end proc;

archetypes(o) returns the set of o’s archetypes, not including o itself.

proc archetypes(o: Object): Object{}

a: ObjectOpt archetype(o);

if a = none then return {} end if;

return {a} archetypes(a)

end proc;

o is an object that is known to have slot id. findSlot(o, id) returns that slot.

proc findSlot(o: Object, id: InstanceVariable): Slot

note o must be a SimpleInstance or a MethodClosure in order to have slots.

matchingSlots: Slot{} {s | s o.slots such that s.id = id};

return the one element of matchingSlots

end proc;

setupVariable(v) runs Setup and initialises the type of the variable v, making sure that Setup is done at most once and does not reenter itself.

proc setupVariable(v: Variable)

setup: (() ClassOpt) {none, busy} v.setup;

case setup of

() ClassOpt do

v.setup busy;

type: ClassOpt setup();

if type = none then type Object end if;

v.type type;

v.setup none;

{none} do nothing;

{busy} do

throw a ConstantError exception — a constant’s type or initialiser cannot depend on the value of that constant

end case

end proc;

writeVariable(v, newValue, clearInitializer) writes the value newValue into the mutable or immutable variable v. newValue is coerced to v’s type. If the clearInitializer flag is set, then the caller has just evaluated v’s initialiser and is supplying its result in newValue. In this case writeVariable atomically clears v.initializer while writing v.value. In all other cases the presence of an initialiser or an existing value will prevent an immutable variable’s value from being written.

proc writeVariable(v: Variable, newValue: Object, clearInitializer: Boolean): Object

coercedValue: Object coerce(newValue, v.type);

if clearInitializer then v.initializer none end if;

if v.immutable and (v.value none or v.initializer none) then

throw a ReferenceError exception — cannot initialise a const variable twice

end if;

v.value coercedValue;

return coercedValue

end proc;

Environmental Utilities

If env is from within a class’s body, getEnclosingClass(env) returns the innermost such class; otherwise, it returns none.

proc getEnclosingClass(env: Environment): ClassOpt

if some c env satisfies c Class then

Let c be the first element of env that is a Class.

return c

end if;

return none

end proc;

If env is from within a function’s body, getEnclosingParameterFrame(env) returns the ParameterFrame for the innermost such function; otherwise, it returns none.

proc getEnclosingParameterFrame(env: Environment): ParameterFrameOpt

for each frame env do

case frame of

LocalFrame WithFrame do nothing;

ParameterFrame do return frame;

Package Class do return none

end case

end for each;

return none

end proc;

getRegionalEnvironment(env) returns all frames in env up to and including the first regional frame. A regional frame is either any frame other than a with frame or local block frame, a local block frame directly enclosed in a class, or a local block frame directly enclosed in a with frame directly enclosed in a class.

proc getRegionalEnvironment(env: Environment): Frame[]

i: Integer 0;

while env[i] LocalFrame WithFrame do i i + 1 end while;

if env[i] Class then while i 0 and env[i] LocalFrame do i i – 1 end while

end if;

return env[0 ... i]

end proc;

getRegionalFrame(env) returns the most specific regional frame in env.

proc getRegionalFrame(env: Environment): Frame

regionalEnv: Frame[] getRegionalEnvironment(env);

return regionalEnv[|regionalEnv| – 1]

end proc;

getPackageFrame(env) returns the innermost package frame in env.

proc getPackageFrame(env: Environment): Package

i: Integer 0;

while env[i] Package do i i + 1 end while;

note Every environment ends with a Package frame, so one will always be found.

return env[i]

end proc;

Property Lookup

findLocalSingletonProperty(o, multiname, access) looks in o for a local singleton property with one of the names in multiname and access that includes access. If there is no such property, findLocalSingletonProperty returns none. If there is exactly one such property, findLocalSingletonProperty returns it. If there is more than one such property, findLocalSingletonProperty throws an error.

proc findLocalSingletonProperty(o: NonWithFrame SimpleInstance RegExp Date, multiname: Multiname, access: Access): SingletonPropertyOpt

matchingLocalBindings: LocalBinding{} {b | b o.localBindings such that b.qname multiname and accessesOverlap(b.accesses, access)};

note If the same property was found via several different bindings b, then it will appear only once in the set matchingProperties.

matchingProperties: SingletonProperty{} {b.content | b matchingLocalBindings};

if matchingProperties = {} then return none

elsif |matchingProperties| = 1 then return the one element of matchingProperties

else

throw a ReferenceError exception — this access is ambiguous because the bindings it found belong to several different local properties

end if

end proc;

instancePropertyAccesses(m) returns instance property’s AccessSet.

proc instancePropertyAccesses(m: InstanceProperty): AccessSet

case m of

InstanceVariable InstanceMethod do return readWrite;

InstanceGetter do return read;

InstanceSetter do return write

end case

end proc;

findLocalInstanceProperty(c, multiname, accesses) looks in class c for a local instance property with one of the names in multiname and accesses that have a nonempty intersection with accesses. If there is no such property, findLocalInstanceProperty returns none. If there is exactly one such property, findLocalInstanceProperty returns it. If there is more than one such property, findLocalInstanceProperty throws an error.

proc findLocalInstanceProperty(c: Class, multiname: Multiname, accesses: AccessSet): InstancePropertyOpt

matches: InstanceProperty{} {m | m c.instanceProperties such that m.multiname multiname {} and accessesOverlap(instancePropertyAccesses(m), accesses)};

if matches = {} then return none

elsif |matches| = 1 then return the one element of matches

else

throw a ReferenceError exception — this access is ambiguous because it found several different instance properties in the same class

end if

end proc;

findArchetypeProperty(o, multiname, access, flat) looks in object o for any local or inherited property with one of the names in multiname and access that includes access. If flat is true, then properties inherited from the archetype are not considered in the search. If it finds no property, findArchetypeProperty returns none. If it finds one property, findArchetypeProperty returns it. If it finds more than one property, findArchetypeProperty prefers the more local one in the list of o’s superclasses or archetypes; if two or more properties remain, the singleton one is preferred; if two or more properties still remain, findArchetypeProperty throws an error.

Note that findArchetypeProperty(o, multiname, access, flat) searches o itself rather than o’s class for properties. findArchetypeProperty will not find instance properties unless o is a class.

proc findArchetypeProperty(o: Object, multiname: Multiname, access: Access, flat: Boolean): PropertyOpt

m: PropertyOpt;

case o of

Undefined Null Boolean Long ULong Float32 Float64 Char16 String Namespace CompoundAttribute MethodClosure do

m none;

SimpleInstance RegExp Date Package do

m findLocalSingletonProperty(o, multiname, access);

Class do m findClassProperty(o, multiname, access)

end case;

if m none then return m end if;

if flat then return none end if;

a: ObjectOpt archetype(o);

if a = none then return none end if;

return findArchetypeProperty(a, multiname, access, flat)

end proc;

proc findClassProperty(c: Class, multiname: Multiname, access: Access): PropertyOpt

m: PropertyOpt findLocalSingletonProperty(c, multiname, access);

if m = none then

m findLocalInstanceProperty(c, multiname, access);

if m = none then

super: ClassOpt c.super;

if super none then m findClassProperty(super, multiname, access) end if

end if

end if;

return m

end proc;

findBaseInstanceProperty(c, multiname, accesses) looks in class c and its ancestors for an instance property with one of the names in multiname and accesses that have a nonempty intersection with accesses. If there is no such property, findBaseInstanceProperty returns none. If there is exactly one such property, findBaseInstanceProperty returns it. If there is more than one such property, findBaseInstanceProperty prefers the one defined in the least specific class; if two or more properties still remain, findBaseInstanceProperty throws an error.

proc findBaseInstanceProperty(c: Class, multiname: Multiname, accesses: AccessSet): InstancePropertyOpt

note Start from the root class (Object) and proceed through more specific classes that are ancestors of c.

for each s ancestors(c) do

m: InstancePropertyOpt findLocalInstanceProperty(s, multiname, accesses);

if m none then return m end if

end for each;

return none

end proc;

getDerivedInstanceProperty(c, mBase, accesses) returns the most derived instance property whose name includes that of mBase and whose accesses that have a nonempty intersection with accesses. The caller of getDerivedInstanceProperty ensures that such an instance property always exists. If accesses is readWrite then it is possible that this search could find both a getter and a setter defined in the same class; in this case either the getter or the setter is returned at the implementation’s discretion.

proc getDerivedInstanceProperty(c: Class, mBase: InstanceProperty, accesses: AccessSet): InstanceProperty

if some m c.instanceProperties satisfies mBase.multiname m.multiname and accessesOverlap(instancePropertyAccesses(m), accesses) then

return m

else return getDerivedInstanceProperty(c.super, mBase, accesses)

end if

end proc;

readImplicitThis(env) returns the value of implicit this to be used to access instance properties within a class’s scope without using the . operator. An implicit this is well-defined only inside instance methods and constructors; readImplicitThis throws an error if there is no well-defined implicit this value or if an attempt is made to read it before it has been initialised.

proc readImplicitThis(env: Environment): Object

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none then

throw a ReferenceError exception — can’t access instance properties outside an instance method without supplying an instance object

end if;

this: ObjectOpt frame.this;

if this = none then

throw a ReferenceError exception — can’t access instance properties inside a non-instance method without supplying an instance object

end if;

if frame.kind {instanceFunction, constructorFunction} then

throw a ReferenceError exception — can’t access instance properties inside a non-instance method without supplying an instance object

end if;

if not frame.superconstructorCalled then

throw an UninitializedError exception — can’t access instance properties from within a constructor before the superconstructor has been called

end if;

return this

end proc;

hasProperty(o, property, flat, phase) returns true if o has a readable or writable property named property. If flat is true, then properties inherited from the archetype are not considered.

proc hasProperty(o: Object, property: Object, flat: Boolean, phase: Phase): Boolean

c: Class objectType(o);

return c.hasProperty(o, c, property, flat, phase)

end proc;

hasProperty(o, c, property, flat, phase) is the implementation of hasProperty for a native class unless specified otherwise in the class’s definition. Host classes may either also use ordinaryHasProperty or define a different procedure to perform this test. c is o’s type.

proc ordinaryHasProperty(o: Object, c: Class, property: Object, flat: Boolean, phase: Phase): Boolean

qname: QualifiedName objectToQualifiedName(property, phase);

return findBaseInstanceProperty(c, {qname}, read) none or findBaseInstanceProperty(c, {qname}, write) none or findArchetypeProperty(o, {qname}, read, flat) none or findArchetypeProperty(o, {qname}, write, flat) none

end proc;

Reading

If r is an Object, readReference(r, phase) returns it unchanged. If r is a Reference, readReference reads r and returns the result. If phase is compile, only constant expressions can be evaluated in the process of reading r.

proc readReference(r: ObjOrRef, phase: Phase): Object

result: ObjectOpt;

case r of

Object do result r;

LexicalReference do result lexicalRead(r.env, r.variableMultiname, phase);

DotReference do

result r.limit.read(r.base, r.limit, r.multiname, none, true, phase);

BracketReference do

result r.limit.bracketRead(r.base, r.limit, r.args, true, phase)

end case;

if result none then return result

else

throw a ReferenceError exception — property not found, and no default value is available

end if

end proc;

dotRead(o, multiname, phase) reads and returns the value of the multiname property of o. dotRead throws an error if the property does not exist and no default value was available for it.

proc dotRead(o: Object, multiname: Multiname, phase: Phase): Object

limit: Class objectType(o);

result: ObjectOpt limit.read(o, limit, multiname, none, true, phase);

if result = none then

throw a ReferenceError exception — property not found, and no default value is available

end if;

return result

end proc;

readLength(o, phase) reads and returns the value of the length property of o, ensuring that it is an integer between 0 and arrayLimit inclusive.

proc readLength(o: Object, phase: Phase): Integer

value: Object dotRead(o, {public::“length”}, phase);

if value GeneralNumber then throw a TypeError exception — length not an integer

end if;

length: IntegerOpt checkInteger(value);

if length = none then throw a RangeError exception — length not an integer

elsif 0 length arrayLimit then return length

else throw a RangeError exception — length out of range

end if

end proc;

indexRead(o, i, phase) returns the value of o[i] or none if no such property was found; unlike dotRead, indexRead does not return a default value for missing properties. i should always be a valid array index.

proc indexRead(o: Object, i: Integer, phase: Phase): ObjectOpt

note 0 i < arrayLimit;

limit: Class objectType(o);

x: Float64 i_f64;

result: ObjectOpt limit.bracketRead(o, limit, [x], false, phase);

if result none and not hasProperty(o, x, true, phase) then

At the implementation’s discretion either do nothing, set result to none, or throw a ReferenceError.

end if;

return result

end proc;

ordinaryBracketRead(o, limit, args, undefinedIfMissing, phase) evaluates the expression o[args] when o is a native object. Host objects may either also use ordinaryBracketRead or choose a different procedure P to evaluate o[args] by writing P into objectType(o).bracketRead.

limit is used to handle the expression super(o)[args], in which case limit is the superclass of the class inside which the super expression appears. Otherwise, limit is set to objectType(o).

proc ordinaryBracketRead(o: Object, limit: Class, args: Object[], undefinedIfMissing: Boolean, phase: Phase): ObjectOpt

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

qname: QualifiedName objectToQualifiedName(args[0], phase);

return limit.read(o, limit, {qname}, none, undefinedIfMissing, phase)

end proc;

proc lexicalRead(env: Environment, multiname: Multiname, phase: Phase): Object

i: Integer 0;

while i < |env| do

frame: Frame env[i];

result: ObjectOpt none;

case frame of

Package Class do

limit: Class objectType(frame);

result limit.read(frame, limit, multiname, env, false, phase);

ParameterFrame LocalFrame do

m: SingletonPropertyOpt findLocalSingletonProperty(frame, multiname, read);

if m none then result readSingletonProperty(m, phase) end if;

WithFrame do

value: ObjectOpt frame.value;

if value = none then

case phase of

{compile} do

throw a ConstantError exception — cannot read a with statement’s frame from a constant expression;

{run} do

throw an UninitializedError exception — cannot read a with statement’s frame before that statement’s expression has been evaluated

end case

end if;

limit: Class objectType(value);

result limit.read(value, limit, multiname, env, false, phase)

end case;

if result none then return result end if;

i i + 1

end while;

throw a ReferenceError exception — no property found with the name multiname

end proc;

proc ordinaryRead(o: Object, limit: Class, multiname: Multiname, env: EnvironmentOpt, undefinedIfMissing: Boolean, phase: Phase): ObjectOpt

mBase: InstancePropertyOpt findBaseInstanceProperty(limit, multiname, read);

if mBase none then return readInstanceProperty(o, limit, mBase, phase) end if;

if limit objectType(o) then return none end if;

flat: Boolean env none and o Class;

m: PropertyOpt findArchetypeProperty(o, multiname, read, flat);

case m of

{none} do

if undefinedIfMissing and o SimpleInstance Date RegExp Package and not o.sealed then

case phase of

{compile} do

throw a ConstantError exception — a constant expression cannot read dynamic properties;

{run} do return undefined

end case

else return none

end if;

SingletonProperty do return readSingletonProperty(m, phase);

InstanceProperty do

if o Class or env = none then

throw a ReferenceError exception — cannot read an instance property without supplying an instance

end if;

this: Object readImplicitThis(env);

return readInstanceProperty(this, objectType(this), m, phase)

end case

end proc;

readInstanceProperty(o, qname, phase) is a simplified interface to ordinaryRead used to read instance slots that are known to exist.

proc readInstanceSlot(o: Object, qname: QualifiedName, phase: Phase): Object

c: Class objectType(o);

mBase: InstancePropertyOpt findBaseInstanceProperty(c, {qname}, read);

note readInstanceProperty is only called in cases where the instance property is known to exist, so mBase cannot be none here.

return readInstanceProperty(o, c, mBase, phase)

end proc;

proc readInstanceProperty(this: Object, c: Class, mBase: InstanceProperty, phase: Phase): Object

m: InstanceProperty getDerivedInstanceProperty(c, mBase, read);

case m of

if phase = compile and not m.immutable then

throw a ConstantError exception — a constant expression cannot read mutable variables

end if;

v: ObjectOpt findSlot(this, m).value;

if v = none then

case phase of

{compile} do

throw a ConstantError exception — cannot read uninitalised const variables from a constant expression;

{run} do

throw an UninitializedError exception — cannot read a const instance variable before it is initialised

end case

end if;

return v;

InstanceMethod do

slots: Slot{} {new Slotid: ivarFunctionLength, value: (m.length)_f64};

return MethodClosurethis: this, method: m, slots: slots;

InstanceGetter do return m.call(this, phase);

InstanceSetter do

m cannot be an InstanceSetter because these are only represented as write-only properties.

end case

end proc;

proc readSingletonProperty(m: SingletonProperty, phase: Phase): Object

case m of

{forbidden} do

throw a ReferenceError exception — cannot access a property defined in a scope outside the current region if any block inside the current region shadows it;

if phase = compile then

throw a ConstantError exception — a constant expression cannot read mutable variables

end if;

value: Object UninstantiatedFunction m.value;

note value can be an UninstantiatedFunction only during the compile phase, which was ruled out above.

return value;

Variable do

if phase = compile and not m.immutable then

throw a ConstantError exception — a constant expression cannot read mutable variables

end if;

value: VariableValue m.value;

case value of

Object do return value;

{none} do

if not m.immutable then throw an UninitializedError exception end if;

note Try to run a const variable’s initialiser if there is one.

Evaluate setupVariable(m) and ignore its result;

initializer: Initializer {none, busy} m.initializer;

if initializer {none, busy} then

case phase of

{compile} do

throw a ConstantError exception — a constant expression cannot access a constant with a missing or recursive initialiser;

{run} do throw an UninitializedError exception

end case

end if;

m.initializer busy;

coercedValue: Object;

try

newValue: Object initializer(m.initializerEnv, compile);

coercedValue writeVariable(m, newValue, true)

catch x: SemanticException do

note If initialisation failed, restore m.initializer to its original value so it can be tried later.

m.initializer initializer;

throw x

end try;

return coercedValue;

UninstantiatedFunction do

note An uninstantiated function can only be found when phase = compile.

throw a ConstantError exception — an uninstantiated function is not a constant expression

end case;

Getter do

env: EnvironmentOpt m.env;

if env = none then

note An uninstantiated getter can only be found when phase = compile.

throw a ConstantError exception — an uninstantiated getter is not a constant expression

end if;

return m.call(env, phase);

Setter do

m cannot be a Setter because these are only represented as write-only properties.

end case

end proc;

Writing

If r is a reference, writeReference(r, newValue) writes newValue into r. An error occurs if r is not a reference. writeReference is never called from a constant expression.

proc writeReference(r: ObjOrRef, newValue: Object, phase: {run})

result: {none, ok};

case r of

Object do

throw a ReferenceError exception — a non-reference is not a valid target of an assignment;

LexicalReference do

Evaluate lexicalWrite(r.env, r.variableMultiname, newValue, not r.strict, phase) and ignore its result;

result ok;

DotReference do

result r.limit.write(r.base, r.limit, r.multiname, none, newValue, true, phase);

BracketReference do

result r.limit.bracketWrite(r.base, r.limit, r.args, newValue, true, phase)

end case;

if result = none then

throw a ReferenceError exception — property not found and could not be created

end if

end proc;

dotWrite(o, multiname, newValue, phase) is a simplified interface to write newValue into the multiname property of o.

proc dotWrite(o: Object, multiname: Multiname, newValue: Object, phase: {run})

limit: Class objectType(o);

result: {none, ok} limit.write(o, limit, multiname, none, newValue, true, phase);

if result = none then

throw a ReferenceError exception — property not found and could not be created

end if

end proc;

writeLength(o, length, phase) ensures that length is between 0 and arrayLimit inclusive and then writes it into the length property of o. Note that if o is an Array, the act of writing its length property will invoke the Array_setLength setter.

proc writeLength(o: Object, length: Integer, phase: {run})

if length < 0 or length > arrayLimit then

throw a RangeError exception — length out of range

end if;

Evaluate dotWrite(o, {public::“length”}, length_f64, phase) and ignore its result

end proc;

proc indexWrite(o: Object, i: Integer, newValue: ObjectOpt, phase: {run})

if i < 0 or i arrayLimit then throw a RangeError exception — index out of range

end if;

limit: Class objectType(o);

if newValue = none then

deleteResult: BooleanOpt limit.bracketDelete(o, limit, [i_f64], phase);

if deleteResult = false then

throw a ReferenceError exception — cannot delete element

end if

else

writeResult: {none, ok} limit.bracketWrite(o, limit, [i_f64], newValue, true, phase);

if writeResult = none then

throw a ReferenceError exception — element not found and could not be created

end if

end proc;

proc ordinaryBracketWrite(o: Object, limit: Class, args: Object[], newValue: Object, createIfMissing: Boolean, phase: {run}): {none, ok}

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

qname: QualifiedName objectToQualifiedName(args[0], phase);

return limit.write(o, limit, {qname}, none, newValue, createIfMissing, phase)

end proc;

proc lexicalWrite(env: Environment, multiname: Multiname, newValue: Object, createIfMissing: Boolean, phase: {run})

i: Integer 0;

while i < |env| do

frame: Frame env[i];

result: {none, ok} none;

case frame of

Package Class do

limit: Class objectType(frame);

result limit.write(frame, limit, multiname, env, newValue, false, phase);

ParameterFrame LocalFrame do

m: SingletonPropertyOpt findLocalSingletonProperty(frame, multiname, write);

if m none then

Evaluate writeSingletonProperty(m, newValue, phase) and ignore its result;

result ok

end if;

WithFrame do

value: ObjectOpt frame.value;

if value = none then

throw an UninitializedError exception — cannot read a with statement’s frame before that statement’s expression has been evaluated

end if;

limit: Class objectType(value);

result limit.write(value, limit, multiname, env, newValue, false, phase)

end case;

if result = ok then return end if;

i i + 1

end while;

if createIfMissing then

pkg: Package getPackageFrame(env);

note Try to write the variable into pkg again, this time allowing new dynamic bindings to be created dynamically.

limit: Class objectType(pkg);

result: {none, ok} limit.write(pkg, limit, multiname, env, newValue, true, phase);

if result = ok then return end if

end if;

throw a ReferenceError exception — no existing property found with the name multiname and one could not be created

end proc;

proc ordinaryWrite(o: Object, limit: Class, multiname: Multiname, env: EnvironmentOpt, newValue: Object, createIfMissing: Boolean, phase: {run}): {none, ok}

mBase: InstancePropertyOpt findBaseInstanceProperty(limit, multiname, write);

if mBase none then

Evaluate writeInstanceProperty(o, limit, mBase, newValue, phase) and ignore its result;

return ok

end if;

if limit objectType(o) then return none end if;

m: PropertyOpt findArchetypeProperty(o, multiname, write, true);

case m of

{none} do

if createIfMissing and o SimpleInstance Date RegExp Package and not o.sealed and (some qname multiname satisfies qname.namespace = public) then

note Before trying to create a new dynamic property named qname, check that there is no read-only fixed property with the same name.

if findBaseInstanceProperty(objectType(o), {qname}, read) = none and findArchetypeProperty(o, {qname}, read, true) = none then

Evaluate createDynamicProperty(o, qname, false, true, newValue) and ignore its result;

return ok

end if

end if;

return none;

SingletonProperty do

Evaluate writeSingletonProperty(m, newValue, phase) and ignore its result;

return ok;

InstanceProperty do

if o Class or env = none then

throw a ReferenceError exception — cannot write an instance property without supplying an instance

end if;

this: Object readImplicitThis(env);

Evaluate writeInstanceProperty(this, objectType(this), m, newValue, phase) and ignore its result;

return ok

end case

end proc;

The caller must make sure that the created property does not already exist and does not conflict with any other property.

proc createDynamicProperty(o: SimpleInstance Date RegExp Package, qname: QualifiedName, sealed: Boolean, enumerable: Boolean, newValue: Object)

dv: DynamicVar new DynamicVarvalue: newValue, sealed: sealed;

o.localBindings o.localBindings {LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: enumerable, content: dv}

end proc;

proc writeInstanceProperty(this: Object, c: Class, mBase: InstanceProperty, newValue: Object, phase: {run})

m: InstanceProperty getDerivedInstanceProperty(c, mBase, write);

case m of

s: Slot findSlot(this, m);

coercedValue: Object coerce(newValue, m.type);

if m.immutable and s.value none then

throw a ReferenceError exception — cannot initialise a const instance variable twice

end if;

s.value coercedValue;

InstanceMethod do

throw a ReferenceError exception — cannot write to an instance method;

InstanceGetter do

m cannot be an InstanceGetter because these are only represented as read-only properties.

InstanceSetter do Evaluate m.call(this, newValue, phase) and ignore its result

end case

end proc;

proc writeSingletonProperty(m: SingletonProperty, newValue: Object, phase: {run})

case m of

{forbidden} do

throw a ReferenceError exception — cannot access a property defined in a scope outside the current region if any block inside the current region shadows it;

Variable do Evaluate writeVariable(m, newValue, false) and ignore its result;

DynamicVar do m.value newValue;

Getter do

m cannot be a Getter because these are only represented as read-only properties.

Setter do

env: EnvironmentOpt m.env;

note All instances are resolved for the run phase, so env none.

Evaluate m.call(newValue, env, phase) and ignore its result

end case

end proc;

Deleting

If r is a Reference, deleteReference(r) deletes it. If r is an Object, this function signals an error in strict mode or returns true in non-strict mode. deleteReference is never called from a constant expression.

proc deleteReference(r: ObjOrRef, strict: Boolean, phase: {run}): Boolean

result: BooleanOpt;

case r of

Object do

if strict then

throw a ReferenceError exception — a non-reference is not a valid target for delete in strict mode

else result true

end if;

LexicalReference do result lexicalDelete(r.env, r.variableMultiname, phase);

DotReference do

result r.limit.delete(r.base, r.limit, r.multiname, none, phase);

BracketReference do

result r.limit.bracketDelete(r.base, r.limit, r.args, phase)

end case;

if result none then return result else return true end if

end proc;

proc ordinaryBracketDelete(o: Object, limit: Class, args: Object[], phase: {run}): BooleanOpt

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

qname: QualifiedName objectToQualifiedName(args[0], phase);

return limit.delete(o, limit, {qname}, none, phase)

end proc;

proc lexicalDelete(env: Environment, multiname: Multiname, phase: {run}): Boolean

i: Integer 0;

while i < |env| do

frame: Frame env[i];

result: BooleanOpt none;

case frame of

Package Class do

limit: Class objectType(frame);

result limit.delete(frame, limit, multiname, env, phase);

ParameterFrame LocalFrame do

if findLocalSingletonProperty(frame, multiname, write) none then

result false

end if;

WithFrame do

value: ObjectOpt frame.value;

if value = none then

throw an UninitializedError exception — cannot read a with statement’s frame before that statement’s expression has been evaluated

end if;

limit: Class objectType(value);

result limit.delete(value, limit, multiname, env, phase)

end case;

if result none then return result end if;

i i + 1

end while;

return true

end proc;

proc ordinaryDelete(o: Object, limit: Class, multiname: Multiname, env: EnvironmentOpt, phase: {run}): BooleanOpt

if findBaseInstanceProperty(limit, multiname, write) none then return false end if;

if limit objectType(o) then return none end if;

m: PropertyOpt findArchetypeProperty(o, multiname, write, true);

case m of

{none} do return none;

{forbidden} do

throw a ReferenceError exception — cannot access a property defined in a scope outside the current region if any block inside the current region shadows it;

Variable Getter Setter do return false;

if m.sealed then return false

else

o.localBindings {b | b o.localBindings such that b.qname multiname or b.content m};

return true

end if;

InstanceProperty do

if o Class or env = none then return false end if;

Evaluate readImplicitThis(env) and ignore its result;

return false

end case

end proc;

Enumerating

proc ordinaryEnumerate(o: Object): Object{}

e1: Object{} enumerateInstanceProperties(objectType(o));

e2: Object{} enumerateArchetypeProperties(o);

return e1 e2

end proc;

proc enumerateInstanceProperties(c: Class): Object{}

e: Object{} {};

for each m c.instanceProperties do

if m.enumerable then

e e {qname.id | qname m.multiname such that qname.namespace = public}

end if

end for each;

super: ClassOpt c.super;

if super = none then return e

else return e enumerateInstanceProperties(super)

end if

end proc;

proc enumerateArchetypeProperties(o: Object): Object{}

e: Object{} {};

for each a {o} archetypes(o) do

if a BindingObject then e e enumerateSingletonProperties(a) end if

end for each;

return e

end proc;

proc enumerateSingletonProperties(o: BindingObject): Object{}

e: Object{} {};

for each b o.localBindings do

if b.enumerable and b.qname.namespace = public then e e {b.qname.id} end if

end for each;

if o Class then

super: ClassOpt o.super;

if super none then e e enumerateSingletonProperties(super) end if

end if;

return e

end proc;

Calling Instances

proc call(this: Object, a: Object, args: Object[], phase: Phase): Object

case a of

Undefined Null Boolean GeneralNumber Char16 String Namespace CompoundAttribute Date RegExp Package do

throw a TypeError exception;

Class do return a.call(this, a, args, phase);

SimpleInstance do

f: (Object SimpleInstance Object[] Phase Object) {none} a.call;

if f = none then throw a TypeError exception end if;

return f(this, a, args, phase);

MethodClosure do m: InstanceMethod a.method; return m.call(a.this, args, phase)

end case

end proc;

proc ordinaryCall(this: Object, c: Class, args: Object[], phase: Phase): Object

note This function can be used in a constant expression.

if not c.complete then

throw a ConstantError exception — cannot call a class before its definition has been compiled

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

return coerce(args[0], c)

end proc;

proc sameAsConstruct(this: Object, c: Class, args: Object[], phase: Phase): Object

return construct(c, args, phase)

end proc;

Creating Instances

proc construct(a: Object, args: Object[], phase: Phase): Object

case a of

Undefined Null Boolean GeneralNumber Char16 String Namespace CompoundAttribute MethodClosure Date RegExp Package do

throw a TypeError exception;

Class do return a.construct(a, args, phase);

SimpleInstance do

f: (SimpleInstance Object[] Phase Object) {none} a.construct;

if f = none then throw a TypeError exception end if;

return f(a, args, phase)

end case

end proc;

proc ordinaryConstruct(c: Class, args: Object[], phase: Phase): Object

if not c.complete then

throw a ConstantError exception — cannot construct an instance of a class before its definition has been compiled

end if;

if phase = compile then

throw a ConstantError exception — a class constructor call is not a constant expression because it evaluates to a new object each time it is evaluated

end if;

this: SimpleInstance createSimpleInstance(c, c.prototype, none, none, none);

Evaluate callInit(this, c, args, phase) and ignore its result;

return this

end proc;

proc createSimpleInstance(c: Class, archetype: ObjectOpt, call: (Object SimpleInstance Object[] Phase Object) {none}, construct: (SimpleInstance Object[] Phase Object) {none}, env: EnvironmentOpt): SimpleInstance

slots: Slot{} {};

for each s ancestors(c) do

for each m s.instanceProperties do

if m InstanceVariable then

slot: Slot new Slotid: m, value: m.defaultValue;

slots slots {slot}

end if

end for each

end for each;

return new SimpleInstancelocalBindings: {}, archetype: archetype, sealed: not c.dynamic, type: c, slots: slots, call: call, construct: construct, env: env

end proc;

proc callInit(this: SimpleInstance, c: ClassOpt, args: Object[], phase: {run})

init: (SimpleInstance Object[] {run} ()) {none} none;

if c none then init c.init end if;

if init none then Evaluate init(this, args, phase) and ignore its result

else

if args [] then

throw an ArgumentError exception — the default constructor does not take any arguments

end if

end proc;

Adding Local Definitions

proc defineSingletonProperty(env: Environment, id: String, namespaces: Namespace{}, overrideMod: OverrideModifier, explicit: Boolean, accesses: AccessSet, m: SingletonProperty): Multiname

innerFrame: NonWithFrame env[0];

if overrideMod none then

throw an AttributeError exception — a local definition cannot have the override attribute

end if;

if explicit and innerFrame Package then

throw an AttributeError exception — the explicit attribute can only be used at the top level of a package

end if;

namespaces2: Namespace{} namespaces;

if namespaces2 = {} then namespaces2 {public} end if;

multiname: Multiname {ns::id | ns namespaces2};

regionalEnv: Frame[] getRegionalEnvironment(env);

if some b innerFrame.localBindings satisfies b.qname multiname and accessesOverlap(b.accesses, accesses) then

throw a DefinitionError exception — duplicate definition in the same scope

end if;

if innerFrame Class and id = innerFrame.name then

throw a DefinitionError exception — a static property of a class cannot have the same name as the class, regardless of the namespace

end if;

for each frame regionalEnv[1 ...] do

if frame WithFrame and (some b frame.localBindings satisfies b.qname multiname and accessesOverlap(b.accesses, accesses) and b.content forbidden) then

throw a DefinitionError exception — this definition would shadow a property defined in an outer scope within the same region

end if

end for each;

newBindings: LocalBinding{} {LocalBindingqname: qname, accesses: accesses, explicit: explicit, enumerable: true, content: m | qname multiname};

innerFrame.localBindings innerFrame.localBindings newBindings;

note Mark the bindings of multiname as forbidden in all non-innermost frames in the current region if they haven’t been marked as such already.

newForbiddenBindings: LocalBinding{} {LocalBindingqname: qname, accesses: accesses, explicit: true, enumerable: true, content: forbidden | qname multiname};

for each frame regionalEnv[1 ...] do

note Since frame Class here, a Class frame never gets a forbidden binding.

if frame WithFrame then

frame.localBindings frame.localBindings newForbiddenBindings

end if

end for each;

return multiname

end proc;

defineHoistedVar(env, id, initialValue) defines a hoisted variable with the name id in the environment env. Hoisted variables are hoisted to the package or enclosing function scope. Multiple hoisted variables may be defined in the same scope, but they may not coexist with non-hoisted variables with the same name. A hoisted variable can be defined using either a var or a function statement. If it is defined using var, then initialValue is always undefined (if the var statement has an initialiser, then the variable’s value will be written later when the var statement is executed). If it is defined using function, then initialValue must be a function instance or open instance. A var hoisted variable may be hoisted into the ParameterFrame if there is already a parameter with the same name; a function hoisted variable is never hoisted into the ParameterFrame and will shadow a parameter with the same name for compatibility with ECMAScript Edition 3. If there are multiple function definitions, the initial value is the last function definition.

proc defineHoistedVar(env: Environment, id: String, initialValue: Object UninstantiatedFunction): DynamicVar

qname: QualifiedName public::id;

regionalEnv: Frame[] getRegionalEnvironment(env);

regionalFrame: Frame regionalEnv[|regionalEnv| – 1];

note env is either a Package or a ParameterFrame because hoisting only occurs into package or function scope.

existingBindings: LocalBinding{} {b | b regionalFrame.localBindings such that b.qname = qname};

if (existingBindings = {} or initialValue undefined) and regionalFrame ParameterFrame and |regionalEnv| 2 then

regionalFrame regionalEnv[|regionalEnv| – 2];

existingBindings {b | b regionalFrame.localBindings such that b.qname = qname}

end if;

if existingBindings = {} then

v: DynamicVar new DynamicVarvalue: initialValue, sealed: true;

regionalFrame.localBindings regionalFrame.localBindings {LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: true, content: v};

return v

elsif |existingBindings| 1 then

throw a DefinitionError exception — a hoisted definition conflicts with a non-hoisted one

else

b: LocalBinding the one element of existingBindings;

m: SingletonProperty b.content;

if b.accesses readWrite or m DynamicVar then

throw a DefinitionError exception — a hoisted definition conflicts with a non-hoisted one

end if;

note At this point a hoisted binding of the same var already exists, so there is no need to create another one. Overwrite its initial value if the new definition is a function definition.

if initialValue undefined then m.value initialValue end if;

m.sealed true;

regionalFrame.localBindings regionalFrame.localBindings – {b};

regionalFrame.localBindings regionalFrame.localBindings {LocalBindingenumerable: true, other fields from b};

return m

end if

end proc;

Adding Instance Definitions

proc searchForOverrides(c: Class, multiname: Multiname, accesses: AccessSet): InstancePropertyOpt

mBase: InstancePropertyOpt none;

s: ClassOpt c.super;

if s none then

for each qname multiname do

m: InstancePropertyOpt findBaseInstanceProperty(s, {qname}, accesses);

if mBase = none then mBase m

elsif m none and m mBase then

throw a DefinitionError exception — cannot override two separate superclass methods at the same time

end if

end for each

end if;

return mBase

end proc;

proc defineInstanceProperty(c: Class, cxt: Context, id: String, namespaces: Namespace{}, overrideMod: OverrideModifier, explicit: Boolean, m: InstanceProperty): InstancePropertyOpt

if explicit then

throw an AttributeError exception — the explicit attribute can only be used at the top level of a package

end if;

accesses: AccessSet instancePropertyAccesses(m);

requestedMultiname: Multiname {ns::id | ns namespaces};

openMultiname: Multiname {ns::id | ns cxt.openNamespaces};

definedMultiname: Multiname;

searchedMultiname: Multiname;

if requestedMultiname = {} then

definedMultiname {public::id};

searchedMultiname openMultiname;

note definedMultiname searchedMultiname because the public namespace is always open.

else definedMultiname requestedMultiname; searchedMultiname requestedMultiname

end if;

mBase: InstancePropertyOpt searchForOverrides(c, searchedMultiname, accesses);

mOverridden: InstancePropertyOpt none;

if mBase none then

mOverridden getDerivedInstanceProperty(c, mBase, accesses);

definedMultiname mOverridden.multiname;

if not (requestedMultiname definedMultiname) then

throw a DefinitionError exception — cannot extend the set of a property’s namespaces when overriding it

end if;

goodKind: Boolean;

case m of

InstanceVariable do goodKind mOverridden InstanceVariable;

InstanceGetter do

goodKind mOverridden InstanceVariable InstanceGetter;

InstanceSetter do

goodKind mOverridden InstanceVariable InstanceSetter;

InstanceMethod do goodKind mOverridden InstanceMethod

end case;

if not goodKind then

throw a DefinitionError exception — a method can override only another method, a variable can override only another variable, a getter can override only a getter or a variable, and a setter can override only a setter or a variable

end if;

if mOverridden.final then

throw a DefinitionError exception — cannot override a final property

end if

end if;

if some m2 c.instanceProperties satisfies m2.multiname definedMultiname {} and accessesOverlap(instancePropertyAccesses(m2), accesses) then

throw a DefinitionError exception — duplicate definition in the same scope

end if;

case overrideMod of

{none} do

if mBase none then

throw a DefinitionError exception — a definition that overrides a superclass’s property must be marked with the override attribute

end if;

if searchForOverrides(c, openMultiname, accesses) none then

throw a DefinitionError exception — this definition is hidden by one in a superclass when accessed without a namespace qualifier; in the rare cases where this is intentional, use the override(false) attribute

end if;

{false} do

if mBase none then

throw a DefinitionError exception — this definition is marked with override(false) but it overrides a superclass’s property

end if;

{true} do

if mBase = none then

throw a DefinitionError exception — this definition is marked with override or override(true) but it doesn’t override a superclass’s property

end if;

{undefined} do nothing

end case;

m.multiname definedMultiname;

c.instanceProperties c.instanceProperties {m};

return mOverridden

end proc;

Instantiation

proc instantiateFunction(uf: UninstantiatedFunction, env: Environment): SimpleInstance

c: Class uf.type;

i: SimpleInstance createSimpleInstance(c, c.prototype, uf.call, uf.construct, env);

Evaluate dotWrite(i, {public::“length”}, (uf.length)_f64, run) and ignore its result;

if c = PrototypeFunction then

prototype: Object construct(Object, [], run);

Evaluate dotWrite(prototype, {public::“constructor”}, i, run) and ignore its result;

Evaluate dotWrite(i, {public::“prototype”}, prototype, run) and ignore its result

end if;

instantiations: SimpleInstance{} uf.instantiations;

if instantiations {} then

Suppose that instantiateFunction were to choose at its discretion some element i2 of instantiations, assign i2.env env, and return i. If the behaviour of doing that assignment were observationally indistinguishable by the rest of the program from the behaviour of returning i without modifying i2.env, then the implementation may, but does not have to, return i2 now, discarding (or not even bothering to create) the value of i.

note The above rule allows an implementation to avoid creating a fresh closure each time a local function is instantiated if it can show that the closures would behave identically. This optimisation is not transparent to the programmer because the instantiations will be === to each other and share one set of properties (including the prototype property, if applicable) rather than each having its own. ECMAScript programs should not rely on this distinction.

end if;

uf.instantiations instantiations {i};

return i

end proc;

proc instantiateProperty(m: SingletonProperty, env: Environment): SingletonProperty

case m of

{forbidden} do return m;

Variable do

note m.setup = none because Setup must have been called on a frame before that frame can be instantiated.

value: VariableValue m.value;

if value UninstantiatedFunction then

value instantiateFunction(value, env)

end if;

return new Variabletype: m.type, value: value, immutable: m.immutable, setup: none, initializer: m.initializer, initializerEnv: env;

value: Object UninstantiatedFunction m.value;

if value UninstantiatedFunction then

value instantiateFunction(value, env)

end if;

return new DynamicVarvalue: value, sealed: m.sealed;

Getter do

case m.env of

Environment do return m;

{none} do return new Gettercall: m.call, env: env

end case;

Setter do

case m.env of

Environment do return m;

{none} do return new Settercall: m.call, env: env

end case

end proc;

tuple PropertyTranslation

from: SingletonProperty,

to: SingletonProperty

end tuple;

proc instantiateLocalFrame(frame: LocalFrame, env: Environment): LocalFrame

instantiatedFrame: LocalFrame new LocalFramelocalBindings: {};

properties: SingletonProperty{} {b.content | b frame.localBindings};

propertyTranslations: PropertyTranslation{} {PropertyTranslationfrom: m, to: instantiateProperty(m, [instantiatedFrame] env) | m properties};

proc translateProperty(m: SingletonProperty): SingletonProperty

mi: PropertyTranslation the one element mi propertyTranslations that satisfies mi.from = m;

return mi.to

end proc;

instantiatedFrame.localBindings {LocalBindingcontent: translateProperty(b.content), other fields from b | b frame.localBindings};

return instantiatedFrame

end proc;

proc instantiateParameterFrame(frame: ParameterFrame, env: Environment, singularThis: ObjectOpt): ParameterFrame

note frame.superconstructorCalled must be true if and only if frame.kind is not constructorFunction.

instantiatedFrame: ParameterFrame new ParameterFramelocalBindings: {}, kind: frame.kind, handling: frame.handling, callsSuperconstructor: frame.callsSuperconstructor, superconstructorCalled: frame.superconstructorCalled, this: singularThis, returnType: frame.returnType;

note properties will contain the set of all SingletonProperty records found in the frame.

properties: SingletonProperty{} {b.content | b frame.localBindings};

note If any of the parameters (including the rest parameter) are anonymous, their bindings will not be present in frame.localBindings. In this situation, the following steps add their SingletonProperty records to properties.

for each p frame.parameters do properties properties {p.var} end for each;

rest: VariableOpt frame.rest;

if rest none then properties properties {rest} end if;

propertyTranslations: PropertyTranslation{} {PropertyTranslationfrom: m, to: instantiateProperty(m, [instantiatedFrame] env) | m properties};

proc translateProperty(m: SingletonProperty): SingletonProperty

mi: PropertyTranslation the one element mi propertyTranslations that satisfies mi.from = m;

return mi.to

end proc;

instantiatedFrame.localBindings {LocalBindingcontent: translateProperty(b.content), other fields from b | b frame.localBindings};

instantiatedFrame.parameters [Parametervar: translateProperty(op.var), default: op.default | op frame.parameters];

if rest = none then instantiatedFrame.rest none

else instantiatedFrame.rest translateProperty(rest)

end if;

return instantiatedFrame

end proc;

Sealing

proc sealObject(o: Object)

if o SimpleInstance RegExp Date Package then o.sealed true end if

end proc;

proc sealAllLocalProperties(o: Object)

if o BindingObject then

for each b o.localBindings do

m: SingletonProperty b.content;

if m DynamicVar then m.sealed true end if

end for each

end if

end proc;

proc sealLocalProperty(o: Object, qname: QualifiedName)

c: Class objectType(o);

if findBaseInstanceProperty(c, {qname}, read) = none and findBaseInstanceProperty(c, {qname}, write) = none and o BindingObject then

matchingProperties: SingletonProperty{} {b.content | b o.localBindings such that b.qname = qname};

for each m matchingProperties do

if m DynamicVar then m.sealed true end if

end for each

end if

end proc;

Standard Class Utilities

proc defaultArg(args: Object[], n: Integer, default: Object): Object

if n |args| then return default end if;

arg: Object args[n];

if arg = undefined then return default else return arg end if

end proc;

proc stdConstBinding(qname: QualifiedName, type: Class, value: Object): LocalBinding

return LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: false, content: new Variabletype: type, value: value, immutable: true, setup: none, initializer: none

end proc;

proc stdExplicitConstBinding(qname: QualifiedName, type: Class, value: Object): LocalBinding

return LocalBindingqname: qname, accesses: readWrite, explicit: true, enumerable: false, content: new Variabletype: type, value: value, immutable: true, setup: none, initializer: none

end proc;

proc stdVarBinding(qname: QualifiedName, type: Class, value: Object): LocalBinding

return LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: false, content: new Variabletype: type, value: value, immutable: false, setup: none, initializer: none

end proc;

proc stdFunction(qname: QualifiedName, call: Object SimpleInstance Object[] Phase Object, length: Integer): LocalBinding

slots: Slot{} {new Slotid: ivarFunctionLength, value: length_f64};

f: SimpleInstance new SimpleInstancelocalBindings: {}, archetype: FunctionPrototype, sealed: true, type: Function, slots: slots, call: call, construct: none, env: none;

return LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: false, content: new Variabletype: Function, value: f, immutable: true, setup: none, initializer: none

end proc;

stdReserve(qname, archetype) is used during the creation of system objects. It returns an alias of the local binding of qname in archetype, which should be the archetype of the object being created. The alias that stdReserve defines serves to prevent qname from being later redefined by users in the object being created while at the same time retaining the definition of qname that would normally be inherited from archetype.

proc stdReserve(qname: QualifiedName, archetype: SimpleInstance): LocalBinding

matchingBindings: LocalBinding{} {b | b archetype.localBindings such that b.qname = qname};

return the one element of matchingBindings

end proc;

Expressions

Syntax

{allowIn, noIn}

Terminal Actions

Name[Identifier]: String;

Value[Number]: GeneralNumber;

Value[String]: String;

Body[RegularExpression]: String;

Flags[RegularExpression]: String;

Identifiers

Syntax

Identifier

| get

| set

Semantics

Name[Identifier]: String;

Name[Identifier Identifier] = Name[Identifier];

Name[Identifier get] = “get”;

Name[Identifier set] = “set”;

Qualified Identifiers

Syntax

SimpleQualifiedIdentifier

Identifier

| Identifier :: Identifier

| ReservedNamespace :: Identifier

ExpressionQualifiedIdentifier ParenExpression :: Identifier

QualifiedIdentifier

Validation

OpenNamespaces[SimpleQualifiedIdentifier]: Namespace{};

Strict[SimpleQualifiedIdentifier]: Boolean;

proc Validate[SimpleQualifiedIdentifier] (cxt: Context, env: Environment)

[SimpleQualifiedIdentifier Identifier] do

OpenNamespaces[SimpleQualifiedIdentifier] cxt.openNamespaces;

Strict[SimpleQualifiedIdentifier] cxt.strict;

[SimpleQualifiedIdentifier Identifier :: Identifier] do

OpenNamespaces[SimpleQualifiedIdentifier] cxt.openNamespaces;

[SimpleQualifiedIdentifier ReservedNamespace :: Identifier] do

Evaluate Validate[ReservedNamespace](cxt, env) and ignore its result

end proc;

Strict[ExpressionQualifiedIdentifier]: Boolean;

proc Validate[ExpressionQualifiedIdentifier ParenExpression :: Identifier] (cxt: Context, env: Environment)

Strict[ExpressionQualifiedIdentifier] cxt.strict;

Evaluate Validate[ParenExpression](cxt, env) and ignore its result

end proc;

Strict[QualifiedIdentifier]: Boolean;

proc Validate[QualifiedIdentifier] (cxt: Context, env: Environment)

[QualifiedIdentifier SimpleQualifiedIdentifier] do

Strict[QualifiedIdentifier] cxt.strict;

Evaluate Validate[SimpleQualifiedIdentifier](cxt, env) and ignore its result;

[QualifiedIdentifier ExpressionQualifiedIdentifier] do

Strict[QualifiedIdentifier] cxt.strict;

Evaluate Validate[ExpressionQualifiedIdentifier](cxt, env) and ignore its result

end proc;

Setup

proc Setup[SimpleQualifiedIdentifier] ()

[SimpleQualifiedIdentifier Identifier] do nothing;

[SimpleQualifiedIdentifier Identifier :: Identifier] do nothing;

[SimpleQualifiedIdentifier ReservedNamespace :: Identifier] do

Evaluate Setup[ReservedNamespace]() and ignore its result

end proc;

proc Setup[ExpressionQualifiedIdentifier ParenExpression :: Identifier] ()

Evaluate Setup[ParenExpression]() and ignore its result

end proc;

Setup[QualifiedIdentifier] () propagates the call to Setup to nonterminals in the expansion of QualifiedIdentifier.

Evaluation

proc Eval[SimpleQualifiedIdentifier] (env: Environment, phase: Phase): Multiname

[SimpleQualifiedIdentifier Identifier] do

return {ns::(Name[Identifier]) | ns OpenNamespaces[SimpleQualifiedIdentifier]};

[SimpleQualifiedIdentifier Identifier₁ :: Identifier₂] do

multiname: Multiname {ns::(Name[Identifier₁]) | ns OpenNamespaces[SimpleQualifiedIdentifier]};

a: Object lexicalRead(env, multiname, phase);

if a Namespace then

throw a TypeError exception — the qualifier must be a namespace

end if;

return {a::(Name[Identifier₂])};

[SimpleQualifiedIdentifier ReservedNamespace :: Identifier] do

q: Namespace Eval[ReservedNamespace](env, phase);

return {q::(Name[Identifier])}

end proc;

proc Eval[ExpressionQualifiedIdentifier ParenExpression :: Identifier] (env: Environment, phase: Phase): Multiname

q: Object readReference(Eval[ParenExpression](env, phase), phase);

if q Namespace then throw a TypeError exception — the qualifier must be a namespace

end if;

return {q::(Name[Identifier])}

end proc;

Eval[QualifiedIdentifier] (env: Environment, phase: Phase): Multiname propagates the call to Eval to nonterminals in the expansion of QualifiedIdentifier.

Primary Expressions

Syntax

PrimaryExpression

null

| true

| false

| Number

| String

| this

| RegularExpression

ReservedNamespace

public

| private

ParenExpression ( AssignmentExpression^allowIn )

ParenListExpression

ParenExpression

| ( ListExpression^allowIn , AssignmentExpression^allowIn )

Validation

proc Validate[PrimaryExpression] (cxt: Context, env: Environment)

[PrimaryExpression null] do nothing;

[PrimaryExpression true] do nothing;

[PrimaryExpression false] do nothing;

[PrimaryExpression Number] do nothing;

[PrimaryExpression String] do nothing;

[PrimaryExpression this] do

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none then

if cxt.strict then

throw a SyntaxError exception — this can be used outside a function only in non-strict mode

end if

elsif frame.kind = plainFunction then

throw a SyntaxError exception — this function does not define this

end if;

[PrimaryExpression RegularExpression] do nothing;

[PrimaryExpression ReservedNamespace] do

Evaluate Validate[ReservedNamespace](cxt, env) and ignore its result;

[PrimaryExpression ParenListExpression] do

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

[PrimaryExpression ArrayLiteral] do

Evaluate Validate[ArrayLiteral](cxt, env) and ignore its result;

[PrimaryExpression ObjectLiteral] do

Evaluate Validate[ObjectLiteral](cxt, env) and ignore its result;

[PrimaryExpression FunctionExpression] do

Evaluate Validate[FunctionExpression](cxt, env) and ignore its result

end proc;

proc Validate[ReservedNamespace] (cxt: Context, env: Environment)

[ReservedNamespace public] do nothing;

[ReservedNamespace private] do

if getEnclosingClass(env) = none then

throw a SyntaxError exception — private is meaningful only inside a class

end if

end proc;

Validate[ParenExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ParenExpression.

Validate[ParenListExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ParenListExpression.

Setup

Setup[PrimaryExpression] () propagates the call to Setup to nonterminals in the expansion of PrimaryExpression.

proc Setup[ReservedNamespace] ()

[ReservedNamespace public] do nothing;

[ReservedNamespace private] do nothing

end proc;

Setup[ParenExpression] () propagates the call to Setup to nonterminals in the expansion of ParenExpression.

Setup[ParenListExpression] () propagates the call to Setup to nonterminals in the expansion of ParenListExpression.

Evaluation

proc Eval[PrimaryExpression] (env: Environment, phase: Phase): ObjOrRef

[PrimaryExpression null] do return null;

[PrimaryExpression true] do return true;

[PrimaryExpression false] do return false;

[PrimaryExpression Number] do return Value[Number];

[PrimaryExpression String] do return Value[String];

[PrimaryExpression this] do

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none then return getPackageFrame(env) end if;

note Validate ensured that frame.kind plainFunction at this point.

this: ObjectOpt frame.this;

if this = none then

note If Validate passed, this can be uninitialised only when phase = compile.

throw a ConstantError exception — a constant expression cannot read an uninitialised this parameter

end if;

if not frame.superconstructorCalled then

throw an UninitializedError exception — can’t access this from within a constructor before the superconstructor has been called

end if;

return this;

[PrimaryExpression RegularExpression] do

return Body[RegularExpression] “#” Flags[RegularExpression];

[PrimaryExpression ReservedNamespace] do

return Eval[ReservedNamespace](env, phase);

[PrimaryExpression ParenListExpression] do

return Eval[ParenListExpression](env, phase);

[PrimaryExpression ArrayLiteral] do return Eval[ArrayLiteral](env, phase);

[PrimaryExpression ObjectLiteral] do return Eval[ObjectLiteral](env, phase);

[PrimaryExpression FunctionExpression] do

return Eval[FunctionExpression](env, phase)

end proc;

proc Eval[ReservedNamespace] (env: Environment, phase: Phase): Namespace

[ReservedNamespace public] do return public;

[ReservedNamespace private] do

c: ClassOpt getEnclosingClass(env);

note Validate already ensured that c none.

return c.privateNamespace

end proc;

Eval[ParenExpression] (env: Environment, phase: Phase): ObjOrRef propagates the call to Eval to nonterminals in the expansion of ParenExpression.

proc Eval[ParenListExpression] (env: Environment, phase: Phase): ObjOrRef

[ParenListExpression ParenExpression] do return Eval[ParenExpression](env, phase);

[ParenListExpression ( ListExpression^allowIn , AssignmentExpression^allowIn )] do

Evaluate readReference(Eval[ListExpression^allowIn](env, phase), phase) and ignore its result;

return readReference(Eval[AssignmentExpression^allowIn](env, phase), phase)

end proc;

proc EvalAsList[ParenListExpression] (env: Environment, phase: Phase): Object[]

[ParenListExpression ParenExpression] do

elt: Object readReference(Eval[ParenExpression](env, phase), phase);

return [elt];

[ParenListExpression ( ListExpression^allowIn , AssignmentExpression^allowIn )] do

elts: Object[] EvalAsList[ListExpression^allowIn](env, phase);

elt: Object readReference(Eval[AssignmentExpression^allowIn](env, phase), phase);

return elts [elt]

end proc;

Function Expressions

Syntax

FunctionExpression

function FunctionCommon

| function Identifier FunctionCommon

Validation

F[FunctionExpression]: UninstantiatedFunction;

proc Validate[FunctionExpression] (cxt: Context, env: Environment)

[FunctionExpression function FunctionCommon] do

kind: StaticFunctionKind plainFunction;

if not cxt.strict and Plain[FunctionCommon] then kind uncheckedFunction end if;

F[FunctionExpression] ValidateStaticFunction[FunctionCommon](cxt, env, kind);

[FunctionExpression function Identifier FunctionCommon] do

v: Variable new Variabletype: Function, value: none, immutable: true, setup: none, initializer: busy;

b: LocalBinding LocalBindingqname: public::(Name[Identifier]), accesses: readWrite, explicit: false, enumerable: true, content: v;

compileFrame: LocalFrame new LocalFramelocalBindings: {b};

kind: StaticFunctionKind plainFunction;

if not cxt.strict and Plain[FunctionCommon] then kind uncheckedFunction end if;

F[FunctionExpression] ValidateStaticFunction[FunctionCommon](cxt, [compileFrame] env, kind)

end proc;

Setup

proc Setup[FunctionExpression] ()

[FunctionExpression function FunctionCommon] do

Evaluate Setup[FunctionCommon]() and ignore its result;

[FunctionExpression function Identifier FunctionCommon] do

Evaluate Setup[FunctionCommon]() and ignore its result

end proc;

Evaluation

proc Eval[FunctionExpression] (env: Environment, phase: Phase): ObjOrRef

[FunctionExpression function FunctionCommon] do

if phase = compile then

throw a ConstantError exception — a function expression is not a constant expression because it can evaluate to different values

end if;

return instantiateFunction(F[FunctionExpression], env);

[FunctionExpression function Identifier FunctionCommon] do

if phase = compile then

throw a ConstantError exception — a function expression is not a constant expression because it can evaluate to different values

end if;

v: Variable new Variabletype: Function, value: none, immutable: true, setup: none, initializer: none;

b: LocalBinding LocalBindingqname: public::(Name[Identifier]), accesses: readWrite, explicit: false, enumerable: true, content: v;

runtimeFrame: LocalFrame new LocalFramelocalBindings: {b};

f: SimpleInstance instantiateFunction(F[FunctionExpression], [runtimeFrame] env);

v.value f;

return f

end proc;

Object Literals

Syntax

ObjectLiteral { FieldList }

FieldList

«empty»

| NonemptyFieldList

NonemptyFieldList

LiteralField

| LiteralField , NonemptyFieldList

LiteralField FieldName : AssignmentExpression^allowIn

FieldName

| String

| Number

| ParenExpression

Validation

Validate[ObjectLiteral] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ObjectLiteral.

Validate[FieldList] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of FieldList.

Validate[NonemptyFieldList] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of NonemptyFieldList.

Validate[LiteralField] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of LiteralField.

Validate[FieldName] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of FieldName.

Setup

Setup[ObjectLiteral] () propagates the call to Setup to nonterminals in the expansion of ObjectLiteral.

Setup[FieldList] () propagates the call to Setup to nonterminals in the expansion of FieldList.

Setup[NonemptyFieldList] () propagates the call to Setup to nonterminals in the expansion of NonemptyFieldList.

Setup[LiteralField] () propagates the call to Setup to nonterminals in the expansion of LiteralField.

Setup[FieldName] () propagates the call to Setup to nonterminals in the expansion of FieldName.

Evaluation

proc Eval[ObjectLiteral { FieldList }] (env: Environment, phase: Phase): ObjOrRef

if phase = compile then

throw a ConstantError exception — an object literal is not a constant expression because it evaluates to a new object each time it is evaluated

end if;

o: Object construct(Object, [], phase);

Evaluate Eval[FieldList](env, o, phase) and ignore its result;

return o

end proc;

Eval[FieldList] (env: Environment, o: Object, phase: {run}) propagates the call to Eval to nonterminals in the expansion of FieldList.

Eval[NonemptyFieldList] (env: Environment, o: Object, phase: {run}) propagates the call to Eval to nonterminals in the expansion of NonemptyFieldList.

proc Eval[LiteralField FieldName : AssignmentExpression^allowIn] (env: Environment, o: Object, phase: {run})

multiname: Multiname Eval[FieldName](env, phase);

value: Object readReference(Eval[AssignmentExpression^allowIn](env, phase), phase);

Evaluate dotWrite(o, multiname, value, phase) and ignore its result

end proc;

proc Eval[FieldName] (env: Environment, phase: Phase): Multiname

[FieldName QualifiedIdentifier] do return Eval[QualifiedIdentifier](env, phase);

[FieldName String] do return {objectToQualifiedName(Value[String], phase)};

[FieldName Number] do return {objectToQualifiedName(Value[Number], phase)};

[FieldName ParenExpression] do

a: Object readReference(Eval[ParenExpression](env, phase), phase);

return {objectToQualifiedName(a, phase)}

end proc;

Array Literals

Syntax

ArrayLiteral [ ElementList ]

ElementList

«empty»

| LiteralElement

| , ElementList

| LiteralElement , ElementList

LiteralElement AssignmentExpression^allowIn

Validation

Validate[ArrayLiteral] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ArrayLiteral.

Validate[ElementList] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ElementList.

Validate[LiteralElement] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of LiteralElement.

Setup

Setup[ArrayLiteral] () propagates the call to Setup to nonterminals in the expansion of ArrayLiteral.

Setup[ElementList] () propagates the call to Setup to nonterminals in the expansion of ElementList.

Setup[LiteralElement] () propagates the call to Setup to nonterminals in the expansion of LiteralElement.

Evaluation

proc Eval[ArrayLiteral [ ElementList ]] (env: Environment, phase: Phase): ObjOrRef

if phase = compile then

throw a ConstantError exception — an array literal is not a constant expression because it evaluates to a new object each time it is evaluated

end if;

o: Object construct(Array, [], phase);

length: Integer Eval[ElementList](env, 0, o, phase);

Evaluate writeArrayPrivateLength(o, length, phase) and ignore its result;

return o

end proc;

proc Eval[ElementList] (env: Environment, length: Integer, o: Object, phase: {run}): Integer

[ElementList «empty»] do return length;

[ElementList LiteralElement] do

Evaluate Eval[LiteralElement](env, length, o, phase) and ignore its result;

return length + 1;

[ElementList₀ , ElementList₁] do

return Eval[ElementList₁](env, length + 1, o, phase);

[ElementList₀ LiteralElement , ElementList₁] do

Evaluate Eval[LiteralElement](env, length, o, phase) and ignore its result;

return Eval[ElementList₁](env, length + 1, o, phase)

end proc;

proc Eval[LiteralElement AssignmentExpression^allowIn] (env: Environment, length: Integer, o: Object, phase: {run})

value: Object readReference(Eval[AssignmentExpression^allowIn](env, phase), phase);

Evaluate indexWrite(o, length, value, phase) and ignore its result

end proc;

Super Expressions

Syntax

SuperExpression

super

| super ParenExpression

Validation

proc Validate[SuperExpression] (cxt: Context, env: Environment)

[SuperExpression super] do

c: ClassOpt getEnclosingClass(env);

if c = none then

throw a SyntaxError exception — a super expression is meaningful only inside a class

end if;

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none or frame.kind StaticFunctionKind then

throw a SyntaxError exception — a super expression without an argument is meaningful only inside an instance method or a constructor

end if;

if c.super = none then

throw a SyntaxError exception — a super expression is meaningful only if the enclosing class has a superclass

end if;

[SuperExpression super ParenExpression] do

c: ClassOpt getEnclosingClass(env);

if c = none then

throw a SyntaxError exception — a super expression is meaningful only inside a class

end if;

if c.super = none then

throw a SyntaxError exception — a super expression is meaningful only if the enclosing class has a superclass

end if;

Evaluate Validate[ParenExpression](cxt, env) and ignore its result

end proc;

Setup

Setup[SuperExpression] () propagates the call to Setup to nonterminals in the expansion of SuperExpression.

Evaluation

proc Eval[SuperExpression] (env: Environment, phase: Phase): ObjOptionalLimit

[SuperExpression super] do

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

note Validate ensured that frame none and frame.kind StaticFunctionKind at this point.

this: ObjectOpt frame.this;

if this = none then

note If Validate passed, this can be uninitialised only when phase = compile.

throw a ConstantError exception — a constant expression cannot read an uninitialised this parameter

end if;

if not frame.superconstructorCalled then

throw an UninitializedError exception — can’t access super from within a constructor before the superconstructor has been called

end if;

return makeLimitedInstance(this, getEnclosingClass(env), phase);

[SuperExpression super ParenExpression] do

r: ObjOrRef Eval[ParenExpression](env, phase);

return makeLimitedInstance(r, getEnclosingClass(env), phase)

end proc;

proc makeLimitedInstance(r: ObjOrRef, c: Class, phase: Phase): ObjOptionalLimit

o: Object readReference(r, phase);

limit: ClassOpt c.super;

note Validate ensured that limit cannot be none at this point.

coerced: Object coerce(o, limit);

if coerced = null then return null end if;

return LimitedInstanceinstance: coerced, limit: limit

end proc;

Postfix Expressions

Syntax

PostfixExpression

| FullPostfixExpression

AttributeExpression

| AttributeExpression PropertyOperator

| AttributeExpression Arguments

FullPostfixExpression

| PostfixExpression [no line break] ++

| PostfixExpression [no line break] --

FullNewExpression new FullNewSubexpression Arguments

FullNewSubexpression

| QualifiedIdentifier

| FullNewSubexpression PropertyOperator

ShortNewExpression new ShortNewSubexpression

ShortNewSubexpression

FullNewSubexpression

Validation

Validate[PostfixExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of PostfixExpression.

Validate[AttributeExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of AttributeExpression.

Validate[FullPostfixExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of FullPostfixExpression.

Validate[FullNewExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of FullNewExpression.

Validate[FullNewSubexpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of FullNewSubexpression.

Validate[ShortNewExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ShortNewExpression.

Validate[ShortNewSubexpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ShortNewSubexpression.

Setup

Setup[PostfixExpression] () propagates the call to Setup to nonterminals in the expansion of PostfixExpression.

Setup[AttributeExpression] () propagates the call to Setup to nonterminals in the expansion of AttributeExpression.

Setup[FullPostfixExpression] () propagates the call to Setup to nonterminals in the expansion of FullPostfixExpression.

Setup[FullNewExpression] () propagates the call to Setup to nonterminals in the expansion of FullNewExpression.

Setup[FullNewSubexpression] () propagates the call to Setup to nonterminals in the expansion of FullNewSubexpression.

Setup[ShortNewExpression] () propagates the call to Setup to nonterminals in the expansion of ShortNewExpression.

Setup[ShortNewSubexpression] () propagates the call to Setup to nonterminals in the expansion of ShortNewSubexpression.

Evaluation

Eval[PostfixExpression] (env: Environment, phase: Phase): ObjOrRef propagates the call to Eval to nonterminals in the expansion of PostfixExpression.

proc Eval[AttributeExpression] (env: Environment, phase: Phase): ObjOrRef

[AttributeExpression SimpleQualifiedIdentifier] do

m: Multiname Eval[SimpleQualifiedIdentifier](env, phase);

return LexicalReferenceenv: env, variableMultiname: m, strict: Strict[SimpleQualifiedIdentifier];

[AttributeExpression₀ AttributeExpression₁ PropertyOperator] do

a: Object readReference(Eval[AttributeExpression₁](env, phase), phase);

return Eval[PropertyOperator](env, a, phase);

[AttributeExpression₀ AttributeExpression₁ Arguments] do

r: ObjOrRef Eval[AttributeExpression₁](env, phase);

f: Object readReference(r, phase);

base: Object;

case r of

Object LexicalReference do base null;

DotReference BracketReference do base r.base

end case;

args: Object[] Eval[Arguments](env, phase);

return call(base, f, args, phase)

end proc;

proc Eval[FullPostfixExpression] (env: Environment, phase: Phase): ObjOrRef

[FullPostfixExpression PrimaryExpression] do

return Eval[PrimaryExpression](env, phase);

[FullPostfixExpression ExpressionQualifiedIdentifier] do

m: Multiname Eval[ExpressionQualifiedIdentifier](env, phase);

return LexicalReferenceenv: env, variableMultiname: m, strict: Strict[ExpressionQualifiedIdentifier];

[FullPostfixExpression FullNewExpression] do

return Eval[FullNewExpression](env, phase);

[FullPostfixExpression₀ FullPostfixExpression₁ PropertyOperator] do

a: Object readReference(Eval[FullPostfixExpression₁](env, phase), phase);

return Eval[PropertyOperator](env, a, phase);

[FullPostfixExpression SuperExpression PropertyOperator] do

a: ObjOptionalLimit Eval[SuperExpression](env, phase);

return Eval[PropertyOperator](env, a, phase);

[FullPostfixExpression₀ FullPostfixExpression₁ Arguments] do

r: ObjOrRef Eval[FullPostfixExpression₁](env, phase);

f: Object readReference(r, phase);

base: Object;

case r of

Object LexicalReference do base null;

DotReference BracketReference do base r.base

end case;

args: Object[] Eval[Arguments](env, phase);

return call(base, f, args, phase);

[FullPostfixExpression PostfixExpression [no line break] ++] do

if phase = compile then

throw a ConstantError exception — ++ cannot be used in a constant expression

end if;

r: ObjOrRef Eval[PostfixExpression](env, phase);

a: Object readReference(r, phase);

b: Object plus(a, phase);

c: Object add(b, 1_f64, phase);

Evaluate writeReference(r, c, phase) and ignore its result;

return b;

[FullPostfixExpression PostfixExpression [no line break] --] do

if phase = compile then

throw a ConstantError exception — -- cannot be used in a constant expression

end if;

r: ObjOrRef Eval[PostfixExpression](env, phase);

a: Object readReference(r, phase);

b: Object plus(a, phase);

c: Object subtract(b, 1_f64, phase);

Evaluate writeReference(r, c, phase) and ignore its result;

return b

end proc;

proc Eval[FullNewExpression new FullNewSubexpression Arguments] (env: Environment, phase: Phase): ObjOrRef

f: Object readReference(Eval[FullNewSubexpression](env, phase), phase);

args: Object[] Eval[Arguments](env, phase);

return construct(f, args, phase)

end proc;

proc Eval[FullNewSubexpression] (env: Environment, phase: Phase): ObjOrRef

[FullNewSubexpression PrimaryExpression] do

return Eval[PrimaryExpression](env, phase);

[FullNewSubexpression QualifiedIdentifier] do

m: Multiname Eval[QualifiedIdentifier](env, phase);

return LexicalReferenceenv: env, variableMultiname: m, strict: Strict[QualifiedIdentifier];

[FullNewSubexpression FullNewExpression] do

return Eval[FullNewExpression](env, phase);

[FullNewSubexpression₀ FullNewSubexpression₁ PropertyOperator] do

a: Object readReference(Eval[FullNewSubexpression₁](env, phase), phase);

return Eval[PropertyOperator](env, a, phase);

[FullNewSubexpression SuperExpression PropertyOperator] do

a: ObjOptionalLimit Eval[SuperExpression](env, phase);

return Eval[PropertyOperator](env, a, phase)

end proc;

proc Eval[ShortNewExpression new ShortNewSubexpression] (env: Environment, phase: Phase): ObjOrRef

f: Object readReference(Eval[ShortNewSubexpression](env, phase), phase);

return construct(f, [], phase)

end proc;

Eval[ShortNewSubexpression] (env: Environment, phase: Phase): ObjOrRef propagates the call to Eval to nonterminals in the expansion of ShortNewSubexpression.

Property Operators

Syntax

PropertyOperator

. QualifiedIdentifier

| Brackets

Brackets

[ ]

| [ ListExpression^allowIn ]

| [ ExpressionsWithRest ]

Arguments

( )

| ( ExpressionsWithRest )

ExpressionsWithRest

RestExpression

| ListExpression^allowIn , RestExpression

RestExpression ... AssignmentExpression^allowIn

Validation

Validate[PropertyOperator] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of PropertyOperator.

Validate[Brackets] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Brackets.

Validate[Arguments] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Arguments.

Validate[ExpressionsWithRest] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ExpressionsWithRest.

Validate[RestExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of RestExpression.

Setup

Setup[PropertyOperator] () propagates the call to Setup to nonterminals in the expansion of PropertyOperator.

Setup[Brackets] () propagates the call to Setup to nonterminals in the expansion of Brackets.

Setup[Arguments] () propagates the call to Setup to nonterminals in the expansion of Arguments.

Setup[ExpressionsWithRest] () propagates the call to Setup to nonterminals in the expansion of ExpressionsWithRest.

Setup[RestExpression] () propagates the call to Setup to nonterminals in the expansion of RestExpression.

Evaluation

proc Eval[PropertyOperator] (env: Environment, base: ObjOptionalLimit, phase: Phase): ObjOrRef

[PropertyOperator . QualifiedIdentifier] do

m: Multiname Eval[QualifiedIdentifier](env, phase);

case base of

Object do

return DotReferencebase: base, limit: objectType(base), multiname: m;

LimitedInstance do

return DotReferencebase: base.instance, limit: base.limit, multiname: m

end case;

[PropertyOperator Brackets] do

args: Object[] Eval[Brackets](env, phase);

case base of

Object do

return BracketReferencebase: base, limit: objectType(base), args: args;

LimitedInstance do

return BracketReferencebase: base.instance, limit: base.limit, args: args

end case

end proc;

proc Eval[Brackets] (env: Environment, phase: Phase): Object[]

[Brackets [ ]] do return [];

[Brackets [ ListExpression^allowIn ]] do

return EvalAsList[ListExpression^allowIn](env, phase);

[Brackets [ ExpressionsWithRest ]] do return Eval[ExpressionsWithRest](env, phase)

end proc;

proc Eval[Arguments] (env: Environment, phase: Phase): Object[]

[Arguments ( )] do return [];

[Arguments ParenListExpression] do

return EvalAsList[ParenListExpression](env, phase);

[Arguments ( ExpressionsWithRest )] do

return Eval[ExpressionsWithRest](env, phase)

end proc;

proc Eval[ExpressionsWithRest] (env: Environment, phase: Phase): Object[]

[ExpressionsWithRest RestExpression] do return Eval[RestExpression](env, phase);

[ExpressionsWithRest ListExpression^allowIn , RestExpression] do

args1: Object[] EvalAsList[ListExpression^allowIn](env, phase);

args2: Object[] Eval[RestExpression](env, phase);

return args1 args2

end proc;

proc Eval[RestExpression ... AssignmentExpression^allowIn] (env: Environment, phase: Phase): Object[]

a: Object readReference(Eval[AssignmentExpression^allowIn](env, phase), phase);

length: Integer readLength(a, phase);

i: Integer 0;

args: Object[] [];

while i length do

arg: ObjectOpt indexRead(a, i, phase);

if arg = none then

An implementation may, at its discretion, either throw a ReferenceError or treat the hole as a missing argument, substituting the called function’s default parameter value if there is one, undefined if the called function is unchecked, or throwing an ArgumentError exception otherwise. An implementation must not replace such a hole with undefined except when the called function is unchecked or happens to have undefined as its default parameter value.

end if;

args args [arg];

i i + 1

end while;

return args

end proc;

Unary Operators

Syntax

UnaryExpression

| delete PostfixExpression

| void UnaryExpression

| typeof UnaryExpression

| ++ PostfixExpression

| -- PostfixExpression

| + UnaryExpression

| - UnaryExpression

| - NegatedMinLong

| ~ UnaryExpression

| ! UnaryExpression

Validation

Strict[UnaryExpression]: Boolean;

proc Validate[UnaryExpression] (cxt: Context, env: Environment)

[UnaryExpression PostfixExpression] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

[UnaryExpression delete PostfixExpression] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

Strict[UnaryExpression] cxt.strict;

[UnaryExpression₀ void UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result;

[UnaryExpression₀ typeof UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result;

[UnaryExpression ++ PostfixExpression] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

[UnaryExpression -- PostfixExpression] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

[UnaryExpression₀ + UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result;

[UnaryExpression₀ - UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result;

[UnaryExpression - NegatedMinLong] do nothing;

[UnaryExpression₀ ~ UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result;

[UnaryExpression₀ ! UnaryExpression₁] do

Evaluate Validate[UnaryExpression₁](cxt, env) and ignore its result

end proc;

Setup

Setup[UnaryExpression] () propagates the call to Setup to nonterminals in the expansion of UnaryExpression.

Evaluation

proc Eval[UnaryExpression] (env: Environment, phase: Phase): ObjOrRef

[UnaryExpression PostfixExpression] do return Eval[PostfixExpression](env, phase);

[UnaryExpression delete PostfixExpression] do

if phase = compile then

throw a ConstantError exception — delete cannot be used in a constant expression

end if;

r: ObjOrRef Eval[PostfixExpression](env, phase);

return deleteReference(r, Strict[UnaryExpression], phase);

[UnaryExpression₀ void UnaryExpression₁] do

Evaluate readReference(Eval[UnaryExpression₁](env, phase), phase) and ignore its result;

return undefined;

[UnaryExpression₀ typeof UnaryExpression₁] do

a: Object readReference(Eval[UnaryExpression₁](env, phase), phase);

c: Class objectType(a);

return c.typeofString;

[UnaryExpression ++ PostfixExpression] do

if phase = compile then

throw a ConstantError exception — ++ cannot be used in a constant expression

end if;

r: ObjOrRef Eval[PostfixExpression](env, phase);

a: Object readReference(r, phase);

b: Object plus(a, phase);

c: Object add(b, 1_f64, phase);

Evaluate writeReference(r, c, phase) and ignore its result;

return c;

[UnaryExpression -- PostfixExpression] do

if phase = compile then

throw a ConstantError exception — -- cannot be used in a constant expression

end if;

r: ObjOrRef Eval[PostfixExpression](env, phase);

a: Object readReference(r, phase);

b: Object plus(a, phase);

c: Object subtract(b, 1_f64, phase);

Evaluate writeReference(r, c, phase) and ignore its result;

return c;

[UnaryExpression₀ + UnaryExpression₁] do

a: Object readReference(Eval[UnaryExpression₁](env, phase), phase);

return plus(a, phase);

[UnaryExpression₀ - UnaryExpression₁] do

a: Object readReference(Eval[UnaryExpression₁](env, phase), phase);

return minus(a, phase);

[UnaryExpression - NegatedMinLong] do return (–2⁶³)_long;

[UnaryExpression₀ ~ UnaryExpression₁] do

a: Object readReference(Eval[UnaryExpression₁](env, phase), phase);

return bitNot(a, phase);

[UnaryExpression₀ ! UnaryExpression₁] do

a: Object readReference(Eval[UnaryExpression₁](env, phase), phase);

return logicalNot(a, phase)

end proc;

plus(a, phase) returns the value of the unary expression +a. If phase is compile, only constant operations are permitted.

proc plus(a: Object, phase: Phase): Object

return objectToGeneralNumber(a, phase)

end proc;

minus(a, phase) returns the value of the unary expression -a. If phase is compile, only constant operations are permitted.

proc minus(a: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

return generalNumberNegate(x)

end proc;

proc generalNumberNegate(x: GeneralNumber): GeneralNumber

case x of

Long do return integerToLong(–x.value);

ULong do return integerToULong(–x.value);

Float32 do return float32Negate(x);

Float64 do return float64Negate(x)

end case

end proc;

proc bitNot(a: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

case x of

Long do i: {–2⁶³ ... 2⁶³ – 1} x.value; return (bitwiseXor(i, –1))_long;

ULong do

i: {0 ... 2⁶⁴ – 1} x.value;

return (bitwiseXor(i, 0xFFFFFFFFFFFFFFFF))_ulong;

Float32 Float64 do

i: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(x));

return (bitwiseXor(i, –1))_f64

end case

end proc;

logicalNot(a, phase) returns the value of the unary expression !a. If phase is compile, only constant operations are permitted.

proc logicalNot(a: Object, phase: Phase): Object

return not objectToBoolean(a)

end proc;

Multiplicative Operators

Syntax

MultiplicativeExpression

| MultiplicativeExpression * UnaryExpression

| MultiplicativeExpression / UnaryExpression

| MultiplicativeExpression % UnaryExpression

Validation

Validate[MultiplicativeExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of MultiplicativeExpression.

Setup

Setup[MultiplicativeExpression] () propagates the call to Setup to nonterminals in the expansion of MultiplicativeExpression.

Evaluation

proc Eval[MultiplicativeExpression] (env: Environment, phase: Phase): ObjOrRef

[MultiplicativeExpression UnaryExpression] do

return Eval[UnaryExpression](env, phase);

[MultiplicativeExpression₀ MultiplicativeExpression₁ * UnaryExpression] do

a: Object readReference(Eval[MultiplicativeExpression₁](env, phase), phase);

b: Object readReference(Eval[UnaryExpression](env, phase), phase);

return multiply(a, b, phase);

[MultiplicativeExpression₀ MultiplicativeExpression₁ / UnaryExpression] do

a: Object readReference(Eval[MultiplicativeExpression₁](env, phase), phase);

b: Object readReference(Eval[UnaryExpression](env, phase), phase);

return divide(a, b, phase);

[MultiplicativeExpression₀ MultiplicativeExpression₁ % UnaryExpression] do

a: Object readReference(Eval[MultiplicativeExpression₁](env, phase), phase);

b: Object readReference(Eval[UnaryExpression](env, phase), phase);

return remainder(a, b, phase)

end proc;

proc multiply(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: IntegerOpt checkInteger(x);

j: IntegerOpt checkInteger(y);

if i none and j none then

k: Integer ij;

if x ULong or y ULong then return integerToULong(k)

else return integerToLong(k)

end if

end if;

return float64Multiply(toFloat64(x), toFloat64(y))

end proc;

proc divide(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: IntegerOpt checkInteger(x);

j: IntegerOpt checkInteger(y);

if i none and j none and j 0 then

q: Rational i/j;

if x ULong or y ULong then return rationalToULong(q)

else return rationalToLong(q)

end if

end if;

return float64Divide(toFloat64(x), toFloat64(y))

end proc;

proc remainder(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: IntegerOpt checkInteger(x);

j: IntegerOpt checkInteger(y);

if i none and j none and j 0 then

q: Rational i/j;

k: Integer q 0 ? q : q;

r: Integer i – jk;

if x ULong or y ULong then return integerToULong(r)

else return integerToLong(r)

end if

end if;

return float64Remainder(toFloat64(x), toFloat64(y))

end proc;

Additive Operators

Syntax

AdditiveExpression

| AdditiveExpression + MultiplicativeExpression

| AdditiveExpression - MultiplicativeExpression

Validation

Validate[AdditiveExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of AdditiveExpression.

Setup

Setup[AdditiveExpression] () propagates the call to Setup to nonterminals in the expansion of AdditiveExpression.

Evaluation

proc Eval[AdditiveExpression] (env: Environment, phase: Phase): ObjOrRef

[AdditiveExpression MultiplicativeExpression] do

return Eval[MultiplicativeExpression](env, phase);

[AdditiveExpression₀ AdditiveExpression₁ + MultiplicativeExpression] do

a: Object readReference(Eval[AdditiveExpression₁](env, phase), phase);

b: Object readReference(Eval[MultiplicativeExpression](env, phase), phase);

return add(a, b, phase);

[AdditiveExpression₀ AdditiveExpression₁ - MultiplicativeExpression] do

a: Object readReference(Eval[AdditiveExpression₁](env, phase), phase);

b: Object readReference(Eval[MultiplicativeExpression](env, phase), phase);

return subtract(a, b, phase)

end proc;

proc add(a: Object, b: Object, phase: Phase): Object

ap: PrimitiveObject objectToPrimitive(a, none, phase);

bp: PrimitiveObject objectToPrimitive(b, none, phase);

if ap Char16 String or bp Char16 String then

return objectToString(ap, phase) objectToString(bp, phase)

end if;

x: GeneralNumber objectToGeneralNumber(ap, phase);

y: GeneralNumber objectToGeneralNumber(bp, phase);

if x Long ULong or y Long ULong then

i: IntegerOpt checkInteger(x);

j: IntegerOpt checkInteger(y);

if i none and j none then

k: Integer i + j;

if x ULong or y ULong then return integerToULong(k)

else return integerToLong(k)

end if

end if;

return float64Add(toFloat64(x), toFloat64(y))

end proc;

proc subtract(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: IntegerOpt checkInteger(x);

j: IntegerOpt checkInteger(y);

if i none and j none then

k: Integer i – j;

if x ULong or y ULong then return integerToULong(k)

else return integerToLong(k)

end if

end if;

return float64Subtract(toFloat64(x), toFloat64(y))

end proc;

Bitwise Shift Operators

Syntax

ShiftExpression

| ShiftExpression << AdditiveExpression

| ShiftExpression >> AdditiveExpression

| ShiftExpression >>> AdditiveExpression

Validation

Validate[ShiftExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ShiftExpression.

Setup

Setup[ShiftExpression] () propagates the call to Setup to nonterminals in the expansion of ShiftExpression.

Evaluation

proc Eval[ShiftExpression] (env: Environment, phase: Phase): ObjOrRef

[ShiftExpression AdditiveExpression] do

return Eval[AdditiveExpression](env, phase);

[ShiftExpression₀ ShiftExpression₁ << AdditiveExpression] do

a: Object readReference(Eval[ShiftExpression₁](env, phase), phase);

b: Object readReference(Eval[AdditiveExpression](env, phase), phase);

return shiftLeft(a, b, phase);

[ShiftExpression₀ ShiftExpression₁ >> AdditiveExpression] do

a: Object readReference(Eval[ShiftExpression₁](env, phase), phase);

b: Object readReference(Eval[AdditiveExpression](env, phase), phase);

return shiftRight(a, b, phase);

[ShiftExpression₀ ShiftExpression₁ >>> AdditiveExpression] do

a: Object readReference(Eval[ShiftExpression₁](env, phase), phase);

b: Object readReference(Eval[AdditiveExpression](env, phase), phase);

return shiftRightUnsigned(a, b, phase)

end proc;

proc shiftLeft(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

count: Integer truncateToInteger(objectToGeneralNumber(b, phase));

case x of

Float32 Float64 do

count bitwiseAnd(count, 0x1F);

i: {–2³¹ ... 2³¹ – 1} signedWrap32(bitwiseShift(truncateToInteger(x), count));

return i_f64;

Long do

count bitwiseAnd(count, 0x3F);

i: {–2⁶³ ... 2⁶³ – 1} signedWrap64(bitwiseShift(x.value, count));

return i_long;

ULong do

count bitwiseAnd(count, 0x3F);

i: {0 ... 2⁶⁴ – 1} unsignedWrap64(bitwiseShift(x.value, count));

return i_ulong

end case

end proc;

proc shiftRight(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

count: Integer truncateToInteger(objectToGeneralNumber(b, phase));

case x of

Float32 Float64 do

i: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(x));

count bitwiseAnd(count, 0x1F);

i bitwiseShift(i, –count);

return i_f64;

Long do

count bitwiseAnd(count, 0x3F);

i: {–2⁶³ ... 2⁶³ – 1} bitwiseShift(x.value, –count);

return i_long;

ULong do

count bitwiseAnd(count, 0x3F);

i: {–2⁶³ ... 2⁶³ – 1} bitwiseShift(signedWrap64(x.value), –count);

return (unsignedWrap64(i))_ulong

end case

end proc;

proc shiftRightUnsigned(a: Object, b: Object, phase: Phase): Object

x: GeneralNumber objectToGeneralNumber(a, phase);

count: Integer truncateToInteger(objectToGeneralNumber(b, phase));

case x of

Float32 Float64 do

i: {0 ... 2³² – 1} unsignedWrap32(truncateToInteger(x));

count bitwiseAnd(count, 0x1F);

i bitwiseShift(i, –count);

return i_f64;

Long do

count bitwiseAnd(count, 0x3F);

i: {0 ... 2⁶⁴ – 1} bitwiseShift(unsignedWrap64(x.value), –count);

return (signedWrap64(i))_long;

ULong do

count bitwiseAnd(count, 0x3F);

i: {0 ... 2⁶⁴ – 1} bitwiseShift(x.value, –count);

return i_ulong

end case

end proc;

Relational Operators

Syntax

RelationalExpression^allowIn

| RelationalExpression^allowIn < ShiftExpression

| RelationalExpression^allowIn > ShiftExpression

| RelationalExpression^allowIn <= ShiftExpression

| RelationalExpression^allowIn >= ShiftExpression

| RelationalExpression^allowIn is ShiftExpression

| RelationalExpression^allowIn as ShiftExpression

| RelationalExpression^allowIn in ShiftExpression

| RelationalExpression^allowIn instanceof ShiftExpression

RelationalExpression^noIn

| RelationalExpression^noIn < ShiftExpression

| RelationalExpression^noIn > ShiftExpression

| RelationalExpression^noIn <= ShiftExpression

| RelationalExpression^noIn >= ShiftExpression

| RelationalExpression^noIn is ShiftExpression

| RelationalExpression^noIn as ShiftExpression

| RelationalExpression^noIn instanceof ShiftExpression

Validation

Validate[RelationalExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of RelationalExpression.

Setup

Setup[RelationalExpression] () propagates the call to Setup to nonterminals in the expansion of RelationalExpression.

Evaluation

proc Eval[RelationalExpression] (env: Environment, phase: Phase): ObjOrRef

[RelationalExpression ShiftExpression] do

return Eval[ShiftExpression](env, phase);

[RelationalExpression₀ RelationalExpression₁ < ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

return isLess(a, b, phase);

[RelationalExpression₀ RelationalExpression₁ > ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

return isLess(b, a, phase);

[RelationalExpression₀ RelationalExpression₁ <= ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

return isLessOrEqual(a, b, phase);

[RelationalExpression₀ RelationalExpression₁ >= ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

return isLessOrEqual(b, a, phase);

[RelationalExpression₀ RelationalExpression₁ is ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

c: Class objectToClass(b);

return is(a, c);

[RelationalExpression₀ RelationalExpression₁ as ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

c: Class objectToClass(b);

return coerceOrNull(a, c);

[RelationalExpression^allowIn₀ RelationalExpression^allowIn₁ in ShiftExpression] do

a: Object readReference(Eval[RelationalExpression^allowIn₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

return hasProperty(b, a, false, phase);

[RelationalExpression₀ RelationalExpression₁ instanceof ShiftExpression] do

a: Object readReference(Eval[RelationalExpression₁](env, phase), phase);

b: Object readReference(Eval[ShiftExpression](env, phase), phase);

if b Class then return is(a, b)

elsif is(b, PrototypeFunction) then

prototype: Object dotRead(b, {public::“prototype”}, phase);

return prototype archetypes(a)

else throw a TypeError exception

end if

end proc;

proc isLess(a: Object, b: Object, phase: Phase): Boolean

ap: PrimitiveObject objectToPrimitive(a, hintNumber, phase);

bp: PrimitiveObject objectToPrimitive(b, hintNumber, phase);

if ap Char16 String and bp Char16 String then

return toString(ap) < toString(bp)

end if;

return generalNumberCompare(objectToGeneralNumber(ap, phase), objectToGeneralNumber(bp, phase)) = less

end proc;

proc isLessOrEqual(a: Object, b: Object, phase: Phase): Boolean

ap: PrimitiveObject objectToPrimitive(a, hintNumber, phase);

bp: PrimitiveObject objectToPrimitive(b, hintNumber, phase);

if ap Char16 String and bp Char16 String then

return toString(ap) toString(bp)

end if;

return generalNumberCompare(objectToGeneralNumber(ap, phase), objectToGeneralNumber(bp, phase)) {less, equal}

end proc;

Equality Operators

Syntax

EqualityExpression

| EqualityExpression == RelationalExpression

| EqualityExpression != RelationalExpression

| EqualityExpression === RelationalExpression

| EqualityExpression !== RelationalExpression

Validation

Validate[EqualityExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of EqualityExpression.

Setup

Setup[EqualityExpression] () propagates the call to Setup to nonterminals in the expansion of EqualityExpression.

Evaluation

proc Eval[EqualityExpression] (env: Environment, phase: Phase): ObjOrRef

[EqualityExpression RelationalExpression] do

return Eval[RelationalExpression](env, phase);

[EqualityExpression₀ EqualityExpression₁ == RelationalExpression] do

a: Object readReference(Eval[EqualityExpression₁](env, phase), phase);

b: Object readReference(Eval[RelationalExpression](env, phase), phase);

return isEqual(a, b, phase);

[EqualityExpression₀ EqualityExpression₁ != RelationalExpression] do

a: Object readReference(Eval[EqualityExpression₁](env, phase), phase);

b: Object readReference(Eval[RelationalExpression](env, phase), phase);

return not isEqual(a, b, phase);

[EqualityExpression₀ EqualityExpression₁ === RelationalExpression] do

a: Object readReference(Eval[EqualityExpression₁](env, phase), phase);

b: Object readReference(Eval[RelationalExpression](env, phase), phase);

return isStrictlyEqual(a, b, phase);

[EqualityExpression₀ EqualityExpression₁ !== RelationalExpression] do

a: Object readReference(Eval[EqualityExpression₁](env, phase), phase);

b: Object readReference(Eval[RelationalExpression](env, phase), phase);

return not isStrictlyEqual(a, b, phase)

end proc;

proc isEqual(a: Object, b: Object, phase: Phase): Boolean

case a of

Undefined Null do return b Undefined Null;

Boolean do

if b Boolean then return a = b

else return isEqual(objectToGeneralNumber(a, phase), b, phase)

end if;

GeneralNumber do

bp: PrimitiveObject objectToPrimitive(b, none, phase);

case bp of

Undefined Null do return false;

Boolean GeneralNumber Char16 String do

return generalNumberCompare(a, objectToGeneralNumber(bp, phase)) = equal

end case;

Char16 String do

bp: PrimitiveObject objectToPrimitive(b, none, phase);

case bp of

Undefined Null do return false;

Boolean GeneralNumber do

return generalNumberCompare(objectToGeneralNumber(a, phase), objectToGeneralNumber(bp, phase)) = equal;

Char16 String do return toString(a) = toString(bp)

end case;

Namespace CompoundAttribute Class MethodClosure SimpleInstance Date RegExp Package do

case b of

Undefined Null do return false;

Namespace CompoundAttribute Class MethodClosure SimpleInstance Date RegExp Package do

return isStrictlyEqual(a, b, phase);

Boolean GeneralNumber Char16 String do

ap: PrimitiveObject objectToPrimitive(a, none, phase);

return isEqual(ap, b, phase)

end case

end proc;

proc isStrictlyEqual(a: Object, b: Object, phase: Phase): Boolean

if a GeneralNumber and b GeneralNumber then

return generalNumberCompare(a, b) = equal

else return a = b

end if

end proc;

Binary Bitwise Operators

Syntax

BitwiseAndExpression

| BitwiseAndExpression & EqualityExpression

BitwiseXorExpression

| BitwiseXorExpression ^ BitwiseAndExpression

BitwiseOrExpression

| BitwiseOrExpression | BitwiseXorExpression

Validation

Validate[BitwiseAndExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of BitwiseAndExpression.

Validate[BitwiseXorExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of BitwiseXorExpression.

Validate[BitwiseOrExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of BitwiseOrExpression.

Setup

Setup[BitwiseAndExpression] () propagates the call to Setup to nonterminals in the expansion of BitwiseAndExpression.

Setup[BitwiseXorExpression] () propagates the call to Setup to nonterminals in the expansion of BitwiseXorExpression.

Setup[BitwiseOrExpression] () propagates the call to Setup to nonterminals in the expansion of BitwiseOrExpression.

Evaluation

proc Eval[BitwiseAndExpression] (env: Environment, phase: Phase): ObjOrRef

[BitwiseAndExpression EqualityExpression] do

return Eval[EqualityExpression](env, phase);

[BitwiseAndExpression₀ BitwiseAndExpression₁ & EqualityExpression] do

a: Object readReference(Eval[BitwiseAndExpression₁](env, phase), phase);

b: Object readReference(Eval[EqualityExpression](env, phase), phase);

return bitAnd(a, b, phase)

end proc;

proc Eval[BitwiseXorExpression] (env: Environment, phase: Phase): ObjOrRef

[BitwiseXorExpression BitwiseAndExpression] do

return Eval[BitwiseAndExpression](env, phase);

[BitwiseXorExpression₀ BitwiseXorExpression₁ ^ BitwiseAndExpression] do

a: Object readReference(Eval[BitwiseXorExpression₁](env, phase), phase);

b: Object readReference(Eval[BitwiseAndExpression](env, phase), phase);

return bitXor(a, b, phase)

end proc;

proc Eval[BitwiseOrExpression] (env: Environment, phase: Phase): ObjOrRef

[BitwiseOrExpression BitwiseXorExpression] do

return Eval[BitwiseXorExpression](env, phase);

[BitwiseOrExpression₀ BitwiseOrExpression₁ | BitwiseXorExpression] do

a: Object readReference(Eval[BitwiseOrExpression₁](env, phase), phase);

b: Object readReference(Eval[BitwiseXorExpression](env, phase), phase);

return bitOr(a, b, phase)

end proc;

proc bitAnd(a: Object, b: Object, phase: Phase): GeneralNumber

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(x));

j: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(y));

k: {–2⁶³ ... 2⁶³ – 1} bitwiseAnd(i, j);

if x ULong or y ULong then return (unsignedWrap64(k))_ulong

else return k_long

end if

else

i: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(x));

j: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(y));

return (bitwiseAnd(i, j))_f64

end if

end proc;

proc bitXor(a: Object, b: Object, phase: Phase): GeneralNumber

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(x));

j: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(y));

k: {–2⁶³ ... 2⁶³ – 1} bitwiseXor(i, j);

if x ULong or y ULong then return (unsignedWrap64(k))_ulong

else return k_long

end if

else

i: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(x));

j: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(y));

return (bitwiseXor(i, j))_f64

end if

end proc;

proc bitOr(a: Object, b: Object, phase: Phase): GeneralNumber

x: GeneralNumber objectToGeneralNumber(a, phase);

y: GeneralNumber objectToGeneralNumber(b, phase);

if x Long ULong or y Long ULong then

i: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(x));

j: {–2⁶³ ... 2⁶³ – 1} signedWrap64(truncateToInteger(y));

k: {–2⁶³ ... 2⁶³ – 1} bitwiseOr(i, j);

if x ULong or y ULong then return (unsignedWrap64(k))_ulong

else return k_long

end if

else

i: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(x));

j: {–2³¹ ... 2³¹ – 1} signedWrap32(truncateToInteger(y));

return (bitwiseOr(i, j))_f64

end if

end proc;

Binary Logical Operators

Syntax

LogicalAndExpression

| LogicalAndExpression && BitwiseOrExpression

LogicalXorExpression

LogicalAndExpression

| LogicalXorExpression ^^ LogicalAndExpression

LogicalOrExpression

LogicalXorExpression

| LogicalOrExpression || LogicalXorExpression

Validation

Validate[LogicalAndExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of LogicalAndExpression.

Validate[LogicalXorExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of LogicalXorExpression.

Validate[LogicalOrExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of LogicalOrExpression.

Setup

Setup[LogicalAndExpression] () propagates the call to Setup to nonterminals in the expansion of LogicalAndExpression.

Setup[LogicalXorExpression] () propagates the call to Setup to nonterminals in the expansion of LogicalXorExpression.

Setup[LogicalOrExpression] () propagates the call to Setup to nonterminals in the expansion of LogicalOrExpression.

Evaluation

proc Eval[LogicalAndExpression] (env: Environment, phase: Phase): ObjOrRef

[LogicalAndExpression BitwiseOrExpression] do

return Eval[BitwiseOrExpression](env, phase);

[LogicalAndExpression₀ LogicalAndExpression₁ && BitwiseOrExpression] do

a: Object readReference(Eval[LogicalAndExpression₁](env, phase), phase);

if objectToBoolean(a) then

return readReference(Eval[BitwiseOrExpression](env, phase), phase)

else return a

end if

end proc;

proc Eval[LogicalXorExpression] (env: Environment, phase: Phase): ObjOrRef

[LogicalXorExpression LogicalAndExpression] do

return Eval[LogicalAndExpression](env, phase);

[LogicalXorExpression₀ LogicalXorExpression₁ ^^ LogicalAndExpression] do

a: Object readReference(Eval[LogicalXorExpression₁](env, phase), phase);

b: Object readReference(Eval[LogicalAndExpression](env, phase), phase);

ba: Boolean objectToBoolean(a);

bb: Boolean objectToBoolean(b);

return ba xor bb

end proc;

proc Eval[LogicalOrExpression] (env: Environment, phase: Phase): ObjOrRef

[LogicalOrExpression LogicalXorExpression] do

return Eval[LogicalXorExpression](env, phase);

[LogicalOrExpression₀ LogicalOrExpression₁ || LogicalXorExpression] do

a: Object readReference(Eval[LogicalOrExpression₁](env, phase), phase);

if objectToBoolean(a) then return a

else return readReference(Eval[LogicalXorExpression](env, phase), phase)

end if

end proc;

Conditional Operator

Syntax

ConditionalExpression

| LogicalOrExpression ? AssignmentExpression : AssignmentExpression

NonAssignmentExpression

| LogicalOrExpression ? NonAssignmentExpression : NonAssignmentExpression

Validation

Validate[ConditionalExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ConditionalExpression.

Validate[NonAssignmentExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of NonAssignmentExpression.

Setup

Setup[ConditionalExpression] () propagates the call to Setup to nonterminals in the expansion of ConditionalExpression.

Setup[NonAssignmentExpression] () propagates the call to Setup to nonterminals in the expansion of NonAssignmentExpression.

Evaluation

proc Eval[ConditionalExpression] (env: Environment, phase: Phase): ObjOrRef

[ConditionalExpression LogicalOrExpression] do

return Eval[LogicalOrExpression](env, phase);

[ConditionalExpression LogicalOrExpression ? AssignmentExpression₁ : AssignmentExpression₂] do

a: Object readReference(Eval[LogicalOrExpression](env, phase), phase);

if objectToBoolean(a) then

return readReference(Eval[AssignmentExpression₁](env, phase), phase)

else return readReference(Eval[AssignmentExpression₂](env, phase), phase)

end if

end proc;

proc Eval[NonAssignmentExpression] (env: Environment, phase: Phase): ObjOrRef

[NonAssignmentExpression LogicalOrExpression] do

return Eval[LogicalOrExpression](env, phase);

[NonAssignmentExpression₀ LogicalOrExpression ? NonAssignmentExpression₁ : NonAssignmentExpression₂] do

a: Object readReference(Eval[LogicalOrExpression](env, phase), phase);

if objectToBoolean(a) then

return readReference(Eval[NonAssignmentExpression₁](env, phase), phase)

else return readReference(Eval[NonAssignmentExpression₂](env, phase), phase)

end if

end proc;

Assignment Operators

Syntax

AssignmentExpression

| PostfixExpression CompoundAssignment AssignmentExpression

| PostfixExpression LogicalAssignment AssignmentExpression

CompoundAssignment

*=

| /=

| %=

| +=

| -=

| <<=

| >>=

| >>>=

| &=

| ^=

| |=

LogicalAssignment

&&=

| ^^=

| ||=

Semantics

tag andEq;

tag xorEq;

tag orEq;

Validation

proc Validate[AssignmentExpression] (cxt: Context, env: Environment)

[AssignmentExpression ConditionalExpression] do

Evaluate Validate[ConditionalExpression](cxt, env) and ignore its result;

[AssignmentExpression₀ PostfixExpression = AssignmentExpression₁] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

Evaluate Validate[AssignmentExpression₁](cxt, env) and ignore its result;

[AssignmentExpression₀ PostfixExpression CompoundAssignment AssignmentExpression₁] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

Evaluate Validate[AssignmentExpression₁](cxt, env) and ignore its result;

[AssignmentExpression₀ PostfixExpression LogicalAssignment AssignmentExpression₁] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

Evaluate Validate[AssignmentExpression₁](cxt, env) and ignore its result

end proc;

Setup

proc Setup[AssignmentExpression] ()

[AssignmentExpression ConditionalExpression] do

Evaluate Setup[ConditionalExpression]() and ignore its result;

[AssignmentExpression₀ PostfixExpression = AssignmentExpression₁] do

Evaluate Setup[PostfixExpression]() and ignore its result;

Evaluate Setup[AssignmentExpression₁]() and ignore its result;

[AssignmentExpression₀ PostfixExpression CompoundAssignment AssignmentExpression₁] do

Evaluate Setup[PostfixExpression]() and ignore its result;

Evaluate Setup[AssignmentExpression₁]() and ignore its result;

[AssignmentExpression₀ PostfixExpression LogicalAssignment AssignmentExpression₁] do

Evaluate Setup[PostfixExpression]() and ignore its result;

Evaluate Setup[AssignmentExpression₁]() and ignore its result

end proc;

Evaluation

proc Eval[AssignmentExpression] (env: Environment, phase: Phase): ObjOrRef

[AssignmentExpression ConditionalExpression] do

return Eval[ConditionalExpression](env, phase);

[AssignmentExpression₀ PostfixExpression = AssignmentExpression₁] do

if phase = compile then

throw a ConstantError exception — assignment cannot be used in a constant expression

end if;

ra: ObjOrRef Eval[PostfixExpression](env, phase);

b: Object readReference(Eval[AssignmentExpression₁](env, phase), phase);

Evaluate writeReference(ra, b, phase) and ignore its result;

return b;

[AssignmentExpression₀ PostfixExpression CompoundAssignment AssignmentExpression₁] do

if phase = compile then

throw a ConstantError exception — assignment cannot be used in a constant expression

end if;

rLeft: ObjOrRef Eval[PostfixExpression](env, phase);

oLeft: Object readReference(rLeft, phase);

oRight: Object readReference(Eval[AssignmentExpression₁](env, phase), phase);

result: Object Op[CompoundAssignment](oLeft, oRight, phase);

Evaluate writeReference(rLeft, result, phase) and ignore its result;

return result;

[AssignmentExpression₀ PostfixExpression LogicalAssignment AssignmentExpression₁] do

if phase = compile then

throw a ConstantError exception — assignment cannot be used in a constant expression

end if;

rLeft: ObjOrRef Eval[PostfixExpression](env, phase);

oLeft: Object readReference(rLeft, phase);

bLeft: Boolean objectToBoolean(oLeft);

result: Object oLeft;

case Operator[LogicalAssignment] of

{andEq} do

if bLeft then

result readReference(Eval[AssignmentExpression₁](env, phase), phase)

end if;

{xorEq} do

bRight: Boolean objectToBoolean(readReference(Eval[AssignmentExpression₁](env, phase), phase));

result bLeft xor bRight;

{orEq} do

if not bLeft then

result readReference(Eval[AssignmentExpression₁](env, phase), phase)

end if

end case;

Evaluate writeReference(rLeft, result, phase) and ignore its result;

return result

end proc;

Op[CompoundAssignment]: Object Object Phase Object;

Op[CompoundAssignment *=] = multiply;

Op[CompoundAssignment /=] = divide;

Op[CompoundAssignment %=] = remainder;

Op[CompoundAssignment +=] = add;

Op[CompoundAssignment -=] = subtract;

Op[CompoundAssignment <<=] = shiftLeft;

Op[CompoundAssignment >>=] = shiftRight;

Op[CompoundAssignment >>>=] = shiftRightUnsigned;

Op[CompoundAssignment &=] = bitAnd;

Op[CompoundAssignment ^=] = bitXor;

Op[CompoundAssignment |=] = bitOr;

Operator[LogicalAssignment]: {andEq, xorEq, orEq};

Operator[LogicalAssignment &&=] = andEq;

Operator[LogicalAssignment ^^=] = xorEq;

Operator[LogicalAssignment ||=] = orEq;

Comma Expressions

Syntax

ListExpression

| ListExpression , AssignmentExpression

Validation

Validate[ListExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ListExpression.

Setup

Setup[ListExpression] () propagates the call to Setup to nonterminals in the expansion of ListExpression.

Evaluation

proc Eval[ListExpression] (env: Environment, phase: Phase): ObjOrRef

[ListExpression AssignmentExpression] do

return Eval[AssignmentExpression](env, phase);

[ListExpression₀ ListExpression₁ , AssignmentExpression] do

Evaluate readReference(Eval[ListExpression₁](env, phase), phase) and ignore its result;

return readReference(Eval[AssignmentExpression](env, phase), phase)

end proc;

proc EvalAsList[ListExpression] (env: Environment, phase: Phase): Object[]

[ListExpression AssignmentExpression] do

elt: Object readReference(Eval[AssignmentExpression](env, phase), phase);

return [elt];

[ListExpression₀ ListExpression₁ , AssignmentExpression] do

elts: Object[] EvalAsList[ListExpression₁](env, phase);

elt: Object readReference(Eval[AssignmentExpression](env, phase), phase);

return elts [elt]

end proc;

Type Expressions

Syntax

TypeExpression NonAssignmentExpression

Validation

Validate[TypeExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of TypeExpression.

Setup and Evaluation

proc SetupAndEval[TypeExpression NonAssignmentExpression] (env: Environment): Class

Evaluate Setup[NonAssignmentExpression]() and ignore its result;

o: Object readReference(Eval[NonAssignmentExpression](env, compile), compile);

return objectToClass(o)

end proc;

Statements

Syntax

{abbrev, noShortIf, full}

Statement

ExpressionStatement Semicolon

| SuperStatement Semicolon

| Block

| LabeledStatement

| IfStatement

| SwitchStatement

| DoStatement Semicolon

| WhileStatement

| ForStatement

| WithStatement

| ContinueStatement Semicolon

| BreakStatement Semicolon

| ReturnStatement Semicolon

| ThrowStatement Semicolon

| TryStatement

Substatement

| Statement

| SimpleVariableDefinition Semicolon

| Attributes [no line break] { Substatements }

Substatements

«empty»

| SubstatementsPrefix Substatement^abbrev

SubstatementsPrefix

«empty»

| SubstatementsPrefix Substatement^full

Semicolon^abbrev

;

| VirtualSemicolon

| «empty»

Semicolon^noShortIf

;

| VirtualSemicolon

| «empty»

Semicolon^full

;

| VirtualSemicolon

Validation

proc Validate[Statement] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets, preinst: Boolean)

[Statement ExpressionStatement Semicolon] do

Evaluate Validate[ExpressionStatement](cxt, env) and ignore its result;

[Statement SuperStatement Semicolon] do

Evaluate Validate[SuperStatement](cxt, env) and ignore its result;

[Statement Block] do

Evaluate Validate[Block](cxt, env, jt, preinst) and ignore its result;

[Statement LabeledStatement] do

Evaluate Validate[LabeledStatement](cxt, env, sl, jt) and ignore its result;

[Statement IfStatement] do

Evaluate Validate[IfStatement](cxt, env, jt) and ignore its result;

[Statement SwitchStatement] do

Evaluate Validate[SwitchStatement](cxt, env, jt) and ignore its result;

[Statement DoStatement Semicolon] do

Evaluate Validate[DoStatement](cxt, env, sl, jt) and ignore its result;

[Statement WhileStatement] do

Evaluate Validate[WhileStatement](cxt, env, sl, jt) and ignore its result;

[Statement ForStatement] do

Evaluate Validate[ForStatement](cxt, env, sl, jt) and ignore its result;

[Statement WithStatement] do

Evaluate Validate[WithStatement](cxt, env, jt) and ignore its result;

[Statement ContinueStatement Semicolon] do

Evaluate Validate[ContinueStatement](jt) and ignore its result;

[Statement BreakStatement Semicolon] do

Evaluate Validate[BreakStatement](jt) and ignore its result;

[Statement ReturnStatement Semicolon] do

Evaluate Validate[ReturnStatement](cxt, env) and ignore its result;

[Statement ThrowStatement Semicolon] do

Evaluate Validate[ThrowStatement](cxt, env) and ignore its result;

[Statement TryStatement] do

Evaluate Validate[TryStatement](cxt, env, jt) and ignore its result

end proc;

Enabled[Substatement]: Boolean;

proc Validate[Substatement] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets)

[Substatement EmptyStatement] do nothing;

[Substatement Statement] do

Evaluate Validate[Statement](cxt, env, sl, jt, false) and ignore its result;

[Substatement SimpleVariableDefinition Semicolon] do

Evaluate Validate[SimpleVariableDefinition](cxt, env) and ignore its result;

[Substatement Attributes [no line break] { Substatements }] do

Evaluate Validate[Attributes](cxt, env) and ignore its result;

Evaluate Setup[Attributes]() and ignore its result;

attr: Attribute Eval[Attributes](env, compile);

if attr Boolean then

throw a TypeError exception — attributes other than true and false may be used in a statement but not a substatement

end if;

Enabled[Substatement] attr;

if attr then Evaluate Validate[Substatements](cxt, env, jt) and ignore its result

end if

end proc;

proc Validate[Substatements] (cxt: Context, env: Environment, jt: JumpTargets)

[Substatements «empty»] do nothing;

[Substatements SubstatementsPrefix Substatement^abbrev] do

Evaluate Validate[SubstatementsPrefix](cxt, env, jt) and ignore its result;

Evaluate Validate[Substatement^abbrev](cxt, env, {}, jt) and ignore its result

end proc;

proc Validate[SubstatementsPrefix] (cxt: Context, env: Environment, jt: JumpTargets)

[SubstatementsPrefix «empty»] do nothing;

[SubstatementsPrefix₀ SubstatementsPrefix₁ Substatement^full] do

Evaluate Validate[SubstatementsPrefix₁](cxt, env, jt) and ignore its result;

Evaluate Validate[Substatement^full](cxt, env, {}, jt) and ignore its result

end proc;

Setup

Setup[Statement] () propagates the call to Setup to nonterminals in the expansion of Statement.

proc Setup[Substatement] ()

[Substatement EmptyStatement] do nothing;

[Substatement Statement] do Evaluate Setup[Statement]() and ignore its result;

[Substatement SimpleVariableDefinition Semicolon] do

Evaluate Setup[SimpleVariableDefinition]() and ignore its result;

[Substatement Attributes [no line break] { Substatements }] do

if Enabled[Substatement] then

Evaluate Setup[Substatements]() and ignore its result

end if

end proc;

Setup[Substatements] () propagates the call to Setup to nonterminals in the expansion of Substatements.

Setup[SubstatementsPrefix] () propagates the call to Setup to nonterminals in the expansion of SubstatementsPrefix.

proc Setup[Semicolon] ()

[Semicolon ;] do nothing;

[Semicolon VirtualSemicolon] do nothing;

[Semicolon^abbrev «empty»] do nothing;

[Semicolon^noShortIf «empty»] do nothing

end proc;

Evaluation

proc Eval[Statement] (env: Environment, d: Object): Object

[Statement ExpressionStatement Semicolon] do

return Eval[ExpressionStatement](env);

[Statement SuperStatement Semicolon] do return Eval[SuperStatement](env);

[Statement Block] do return Eval[Block](env, d);

[Statement LabeledStatement] do return Eval[LabeledStatement](env, d);

[Statement IfStatement] do return Eval[IfStatement](env, d);

[Statement SwitchStatement] do return Eval[SwitchStatement](env, d);

[Statement DoStatement Semicolon] do return Eval[DoStatement](env, d);

[Statement WhileStatement] do return Eval[WhileStatement](env, d);

[Statement ForStatement] do return Eval[ForStatement](env, d);

[Statement WithStatement] do return Eval[WithStatement](env, d);

[Statement ContinueStatement Semicolon] do

return Eval[ContinueStatement](env, d);

[Statement BreakStatement Semicolon] do return Eval[BreakStatement](env, d);

[Statement ReturnStatement Semicolon] do return Eval[ReturnStatement](env);

[Statement ThrowStatement Semicolon] do return Eval[ThrowStatement](env);

[Statement TryStatement] do return Eval[TryStatement](env, d)

end proc;

proc Eval[Substatement] (env: Environment, d: Object): Object

[Substatement EmptyStatement] do return d;

[Substatement Statement] do return Eval[Statement](env, d);

[Substatement SimpleVariableDefinition Semicolon] do

return Eval[SimpleVariableDefinition](env, d);

[Substatement Attributes [no line break] { Substatements }] do

if Enabled[Substatement] then return Eval[Substatements](env, d)

else return d

end if

end proc;

proc Eval[Substatements] (env: Environment, d: Object): Object

[Substatements «empty»] do return d;

[Substatements SubstatementsPrefix Substatement^abbrev] do

o: Object Eval[SubstatementsPrefix](env, d);

return Eval[Substatement^abbrev](env, o)

end proc;

proc Eval[SubstatementsPrefix] (env: Environment, d: Object): Object

[SubstatementsPrefix «empty»] do return d;

[SubstatementsPrefix₀ SubstatementsPrefix₁ Substatement^full] do

o: Object Eval[SubstatementsPrefix₁](env, d);

return Eval[Substatement^full](env, o)

end proc;

Empty Statement

Syntax

EmptyStatement ;

Expression Statement

Syntax

ExpressionStatement [lookahead{function, {}] ListExpression^allowIn

Validation

Validate[ExpressionStatement] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ExpressionStatement.

Setup

Setup[ExpressionStatement] () propagates the call to Setup to nonterminals in the expansion of ExpressionStatement.

Evaluation

proc Eval[ExpressionStatement [lookahead{function, {}] ListExpression^allowIn] (env: Environment): Object

return readReference(Eval[ListExpression^allowIn](env, run), run)

end proc;

Super Statement

Syntax

SuperStatement super Arguments

Validation

proc Validate[SuperStatement super Arguments] (cxt: Context, env: Environment)

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none or frame.kind constructorFunction then

throw a SyntaxError exception — a super statement is meaningful only inside a constructor

end if;

Evaluate Validate[Arguments](cxt, env) and ignore its result;

frame.callsSuperconstructor true

end proc;

Setup

Setup[SuperStatement] () propagates the call to Setup to nonterminals in the expansion of SuperStatement.

Evaluation

proc Eval[SuperStatement super Arguments] (env: Environment): Object

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

note Validate already ensured that frame none and frame.kind = constructorFunction.

args: Object[] Eval[Arguments](env, run);

if frame.superconstructorCalled = true then

throw a ReferenceError exception — the superconstructor cannot be called twice

end if;

c: Class getEnclosingClass(env);

this: ObjectOpt frame.this;

note this SimpleInstance;

Evaluate callInit(this, c.super, args, run) and ignore its result;

frame.superconstructorCalled true;

return this

end proc;

Block Statement

Syntax

Block { Directives }

Validation

CompileFrame[Block]: LocalFrame;

Preinstantiate[Block]: Boolean;

proc ValidateUsingFrame[Block { Directives }] (cxt: Context, env: Environment, jt: JumpTargets, preinst: Boolean, frame: Frame)

localCxt: Context new Contextstrict: cxt.strict, openNamespaces: cxt.openNamespaces;

Evaluate Validate[Directives](localCxt, [frame] env, jt, preinst, none) and ignore its result

end proc;

proc Validate[Block { Directives }] (cxt: Context, env: Environment, jt: JumpTargets, preinst: Boolean)

compileFrame: LocalFrame new LocalFramelocalBindings: {};

CompileFrame[Block] compileFrame;

Preinstantiate[Block] preinst;

Evaluate ValidateUsingFrame[Block](cxt, env, jt, preinst, compileFrame) and ignore its result

end proc;

Setup

Setup[Block] () propagates the call to Setup to nonterminals in the expansion of Block.

Evaluation

proc Eval[Block { Directives }] (env: Environment, d: Object): Object

compileFrame: LocalFrame CompileFrame[Block];

runtimeFrame: LocalFrame;

if Preinstantiate[Block] then runtimeFrame compileFrame

else runtimeFrame instantiateLocalFrame(compileFrame, env)

end if;

return Eval[Directives]([runtimeFrame] env, d)

end proc;

proc EvalUsingFrame[Block { Directives }] (env: Environment, frame: Frame, d: Object): Object

return Eval[Directives]([frame] env, d)

end proc;

Labeled Statements

Syntax

LabeledStatement Identifier : Substatement

Validation

proc Validate[LabeledStatement Identifier : Substatement] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets)

name: String Name[Identifier];

if name jt.breakTargets then

throw a SyntaxError exception — nesting labeled statements with the same label is not permitted

end if;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {name}, continueTargets: jt.continueTargets;

Evaluate Validate[Substatement](cxt, env, sl {name}, jt2) and ignore its result

end proc;

Setup

proc Setup[LabeledStatement Identifier : Substatement] ()

Evaluate Setup[Substatement]() and ignore its result

end proc;

Evaluation

proc Eval[LabeledStatement Identifier : Substatement] (env: Environment, d: Object): Object

try return Eval[Substatement](env, d)

catch x: SemanticException do

if x Break and x.label = Name[Identifier] then return x.value

else throw x

end if

end try

end proc;

If Statement

Syntax

IfStatement^abbrev

if ParenListExpression Substatement^abbrev

| if ParenListExpression Substatement^noShortIf else Substatement^abbrev

IfStatement^full

if ParenListExpression Substatement^full

| if ParenListExpression Substatement^noShortIf else Substatement^full

IfStatement^noShortIf if ParenListExpression Substatement^noShortIf else Substatement^noShortIf

Validation

proc Validate[IfStatement] (cxt: Context, env: Environment, jt: JumpTargets)

[IfStatement^abbrev if ParenListExpression Substatement^abbrev] do

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

Evaluate Validate[Substatement^abbrev](cxt, env, {}, jt) and ignore its result;

[IfStatement^full if ParenListExpression Substatement^full] do

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

Evaluate Validate[Substatement^full](cxt, env, {}, jt) and ignore its result;

[IfStatement if ParenListExpression Substatement^noShortIf₁ else Substatement₂] do

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

Evaluate Validate[Substatement^noShortIf₁](cxt, env, {}, jt) and ignore its result;

Evaluate Validate[Substatement₂](cxt, env, {}, jt) and ignore its result

end proc;

Setup

Setup[IfStatement] () propagates the call to Setup to nonterminals in the expansion of IfStatement.

Evaluation

proc Eval[IfStatement] (env: Environment, d: Object): Object

[IfStatement^abbrev if ParenListExpression Substatement^abbrev] do

o: Object readReference(Eval[ParenListExpression](env, run), run);

if objectToBoolean(o) then return Eval[Substatement^abbrev](env, d)

else return d

end if;

[IfStatement^full if ParenListExpression Substatement^full] do

o: Object readReference(Eval[ParenListExpression](env, run), run);

if objectToBoolean(o) then return Eval[Substatement^full](env, d)

else return d

end if;

[IfStatement if ParenListExpression Substatement^noShortIf₁ else Substatement₂] do

o: Object readReference(Eval[ParenListExpression](env, run), run);

if objectToBoolean(o) then return Eval[Substatement^noShortIf₁](env, d)

else return Eval[Substatement₂](env, d)

end if

end proc;

Switch Statement

Semantics

tuple SwitchKey

key: Object

end tuple;

SwitchGuard = SwitchKey {default} Object;

Syntax

SwitchStatement switch ParenListExpression { CaseElements }

CaseElements

«empty»

| CaseLabel

| CaseLabel CaseElementsPrefix CaseElement^abbrev

CaseElementsPrefix

«empty»

| CaseElementsPrefix CaseElement^full

CaseElement

Directive

| CaseLabel

CaseLabel

case ListExpression^allowIn :

| default :

Validation

CompileFrame[SwitchStatement]: LocalFrame;

proc Validate[SwitchStatement switch ParenListExpression { CaseElements }] (cxt: Context, env: Environment, jt: JumpTargets)

if NDefaults[CaseElements] > 1 then

throw a SyntaxError exception — a case statement may have at most one default clause

end if;

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {default}, continueTargets: jt.continueTargets;

compileFrame: LocalFrame new LocalFramelocalBindings: {};

CompileFrame[SwitchStatement] compileFrame;

localCxt: Context new Contextstrict: cxt.strict, openNamespaces: cxt.openNamespaces;

Evaluate Validate[CaseElements](localCxt, [compileFrame] env, jt2) and ignore its result

end proc;

NDefaults[CaseElements]: Integer;

NDefaults[CaseElements «empty»] = 0;

NDefaults[CaseElements CaseLabel] = NDefaults[CaseLabel];

NDefaults[CaseElements CaseLabel CaseElementsPrefix CaseElement^abbrev] = NDefaults[CaseLabel] + NDefaults[CaseElementsPrefix] + NDefaults[CaseElement^abbrev];

Validate[CaseElements] (cxt: Context, env: Environment, jt: JumpTargets) propagates the call to Validate to nonterminals in the expansion of CaseElements.

NDefaults[CaseElementsPrefix]: Integer;

NDefaults[CaseElementsPrefix «empty»] = 0;

NDefaults[CaseElementsPrefix₀ CaseElementsPrefix₁ CaseElement^full] = NDefaults[CaseElementsPrefix₁] + NDefaults[CaseElement^full];

Validate[CaseElementsPrefix] (cxt: Context, env: Environment, jt: JumpTargets) propagates the call to Validate to nonterminals in the expansion of CaseElementsPrefix.

NDefaults[CaseElement]: Integer;

NDefaults[CaseElement Directive] = 0;

NDefaults[CaseElement CaseLabel] = NDefaults[CaseLabel];

proc Validate[CaseElement] (cxt: Context, env: Environment, jt: JumpTargets)

[CaseElement Directive] do

Evaluate Validate[Directive](cxt, env, jt, false, none) and ignore its result;

[CaseElement CaseLabel] do

Evaluate Validate[CaseLabel](cxt, env, jt) and ignore its result

end proc;

NDefaults[CaseLabel]: Integer;

NDefaults[CaseLabel case ListExpression^allowIn :] = 0;

NDefaults[CaseLabel default :] = 1;

proc Validate[CaseLabel] (cxt: Context, env: Environment, jt: JumpTargets)

[CaseLabel case ListExpression^allowIn :] do

Evaluate Validate[ListExpression^allowIn](cxt, env) and ignore its result;

[CaseLabel default :] do nothing

end proc;

Setup

Setup[SwitchStatement] () propagates the call to Setup to nonterminals in the expansion of SwitchStatement.

Setup[CaseElements] () propagates the call to Setup to nonterminals in the expansion of CaseElements.

Setup[CaseElementsPrefix] () propagates the call to Setup to nonterminals in the expansion of CaseElementsPrefix.

Setup[CaseElement] () propagates the call to Setup to nonterminals in the expansion of CaseElement.

Setup[CaseLabel] () propagates the call to Setup to nonterminals in the expansion of CaseLabel.

Evaluation

proc Eval[SwitchStatement switch ParenListExpression { CaseElements }] (env: Environment, d: Object): Object

key: Object readReference(Eval[ParenListExpression](env, run), run);

compileFrame: LocalFrame CompileFrame[SwitchStatement];

runtimeFrame: LocalFrame instantiateLocalFrame(compileFrame, env);

runtimeEnv: Environment [runtimeFrame] env;

result: SwitchGuard Eval[CaseElements](runtimeEnv, SwitchKeykey: key, d);

if result Object then return result end if;

note result = SwitchKeykey: key;

result Eval[CaseElements](runtimeEnv, default, d);

if result Object then return result end if;

note result = default;

return d

end proc;

proc Eval[CaseElements] (env: Environment, guard: SwitchGuard, d: Object): SwitchGuard

[CaseElements «empty»] do return guard;

[CaseElements CaseLabel] do return Eval[CaseLabel](env, guard, d);

[CaseElements CaseLabel CaseElementsPrefix CaseElement^abbrev] do

guard2: SwitchGuard Eval[CaseLabel](env, guard, d);

guard3: SwitchGuard Eval[CaseElementsPrefix](env, guard2, d);

return Eval[CaseElement^abbrev](env, guard3, d)

end proc;

proc Eval[CaseElementsPrefix] (env: Environment, guard: SwitchGuard, d: Object): SwitchGuard

[CaseElementsPrefix «empty»] do return guard;

[CaseElementsPrefix₀ CaseElementsPrefix₁ CaseElement^full] do

guard2: SwitchGuard Eval[CaseElementsPrefix₁](env, guard, d);

return Eval[CaseElement^full](env, guard2, d)

end proc;

proc Eval[CaseElement] (env: Environment, guard: SwitchGuard, d: Object): SwitchGuard

[CaseElement Directive] do

case guard of

SwitchKey {default} do return guard;

Object do return Eval[Directive](env, guard)

end case;

[CaseElement CaseLabel] do return Eval[CaseLabel](env, guard, d)

end proc;

proc Eval[CaseLabel] (env: Environment, guard: SwitchGuard, d: Object): SwitchGuard

[CaseLabel case ListExpression^allowIn :] do

case guard of

{default} Object do return guard;

SwitchKey do

label: Object readReference(Eval[ListExpression^allowIn](env, run), run);

if isStrictlyEqual(guard.key, label, run) then return d

else return guard

end if

end case;

[CaseLabel default :] do

case guard of

SwitchKey Object do return guard;

{default} do return d

end case

end proc;

Do-While Statement

Syntax

DoStatement do Substatement^abbrev while ParenListExpression

Validation

Labels[DoStatement]: Label{};

proc Validate[DoStatement do Substatement^abbrev while ParenListExpression] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets)

continueLabels: Label{} sl {default};

Labels[DoStatement] continueLabels;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {default}, continueTargets: jt.continueTargets continueLabels;

Evaluate Validate[Substatement^abbrev](cxt, env, {}, jt2) and ignore its result;

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result

end proc;

Setup

Setup[DoStatement] () propagates the call to Setup to nonterminals in the expansion of DoStatement.

Evaluation

proc Eval[DoStatement do Substatement^abbrev while ParenListExpression] (env: Environment, d: Object): Object

try

d1: Object d;

while true do

try d1 Eval[Substatement^abbrev](env, d1)

catch x: SemanticException do

if x Continue and x.label Labels[DoStatement] then d1 x.value

else throw x

end if

end try;

o: Object readReference(Eval[ParenListExpression](env, run), run);

if not objectToBoolean(o) then return d1 end if

end while

catch x: SemanticException do

if x Break and x.label = default then return x.value else throw x end if

end try

end proc;

While Statement

Syntax

WhileStatement while ParenListExpression Substatement

Validation

Labels[WhileStatement]: Label{};

proc Validate[WhileStatement while ParenListExpression Substatement] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets)

continueLabels: Label{} sl {default};

Labels[WhileStatement] continueLabels;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {default}, continueTargets: jt.continueTargets continueLabels;

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

Evaluate Validate[Substatement](cxt, env, {}, jt2) and ignore its result

end proc;

Setup

Setup[WhileStatement] () propagates the call to Setup to nonterminals in the expansion of WhileStatement.

Evaluation

proc Eval[WhileStatement while ParenListExpression Substatement] (env: Environment, d: Object): Object

try

d1: Object d;

while objectToBoolean(readReference(Eval[ParenListExpression](env, run), run)) do

try d1 Eval[Substatement](env, d1)

catch x: SemanticException do

if x Continue and x.label Labels[WhileStatement] then d1 x.value

else throw x

end if

end try

end while;

return d1

catch x: SemanticException do

if x Break and x.label = default then return x.value else throw x end if

end try

end proc;

For Statements

Syntax

ForStatement

for ( ForInitializer ; OptionalExpression ; OptionalExpression ) Substatement

| for ( ForInBinding in ListExpression^allowIn ) Substatement

ForInitializer

«empty»

| ListExpression^noIn

| VariableDefinition^noIn

| Attributes [no line break] VariableDefinition^noIn

ForInBinding

| VariableDefinitionKind VariableBinding^noIn

| Attributes [no line break] VariableDefinitionKind VariableBinding^noIn

OptionalExpression

ListExpression^allowIn

| «empty»

Validation

Labels[ForStatement]: Label{};

CompileLocalFrame[ForStatement]: LocalFrame;

proc Validate[ForStatement] (cxt: Context, env: Environment, sl: Label{}, jt: JumpTargets)

[ForStatement for ( ForInitializer ; OptionalExpression₁ ; OptionalExpression₂ ) Substatement] do

continueLabels: Label{} sl {default};

Labels[ForStatement] continueLabels;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {default}, continueTargets: jt.continueTargets continueLabels;

compileLocalFrame: LocalFrame new LocalFramelocalBindings: {};

CompileLocalFrame[ForStatement] compileLocalFrame;

compileEnv: Environment [compileLocalFrame] env;

Evaluate Validate[ForInitializer](cxt, compileEnv) and ignore its result;

Evaluate Validate[OptionalExpression₁](cxt, compileEnv) and ignore its result;

Evaluate Validate[OptionalExpression₂](cxt, compileEnv) and ignore its result;

Evaluate Validate[Substatement](cxt, compileEnv, {}, jt2) and ignore its result;

[ForStatement for ( ForInBinding in ListExpression^allowIn ) Substatement] do

continueLabels: Label{} sl {default};

Labels[ForStatement] continueLabels;

jt2: JumpTargets JumpTargetsbreakTargets: jt.breakTargets {default}, continueTargets: jt.continueTargets continueLabels;

Evaluate Validate[ListExpression^allowIn](cxt, env) and ignore its result;

compileLocalFrame: LocalFrame new LocalFramelocalBindings: {};

CompileLocalFrame[ForStatement] compileLocalFrame;

compileEnv: Environment [compileLocalFrame] env;

Evaluate Validate[ForInBinding](cxt, compileEnv) and ignore its result;

Evaluate Validate[Substatement](cxt, compileEnv, {}, jt2) and ignore its result

end proc;

Enabled[ForInitializer]: Boolean;

proc Validate[ForInitializer] (cxt: Context, env: Environment)

[ForInitializer «empty»] do nothing;

[ForInitializer ListExpression^noIn] do

Evaluate Validate[ListExpression^noIn](cxt, env) and ignore its result;

[ForInitializer VariableDefinition^noIn] do

Evaluate Validate[VariableDefinition^noIn](cxt, env, none) and ignore its result;

[ForInitializer Attributes [no line break] VariableDefinition^noIn] do

Evaluate Validate[Attributes](cxt, env) and ignore its result;

Evaluate Setup[Attributes]() and ignore its result;

attr: Attribute Eval[Attributes](env, compile);

Enabled[ForInitializer] attr false;

if attr false then

Evaluate Validate[VariableDefinition^noIn](cxt, env, attr) and ignore its result

end if

end proc;

proc Validate[ForInBinding] (cxt: Context, env: Environment)

[ForInBinding PostfixExpression] do

Evaluate Validate[PostfixExpression](cxt, env) and ignore its result;

[ForInBinding VariableDefinitionKind VariableBinding^noIn] do

Evaluate Validate[VariableBinding^noIn](cxt, env, none, Immutable[VariableDefinitionKind], true) and ignore its result;

[ForInBinding Attributes [no line break] VariableDefinitionKind VariableBinding^noIn] do

Evaluate Validate[Attributes](cxt, env) and ignore its result;

Evaluate Setup[Attributes]() and ignore its result;

attr: Attribute Eval[Attributes](env, compile);

if attr = false then

throw an AttributeError exception — the false attribute canot be applied to a for-in variable definition

end if;

Evaluate Validate[VariableBinding^noIn](cxt, env, attr, Immutable[VariableDefinitionKind], true) and ignore its result

end proc;

Validate[OptionalExpression] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of OptionalExpression.

Setup

Setup[ForStatement] () propagates the call to Setup to nonterminals in the expansion of ForStatement.

proc Setup[ForInitializer] ()

[ForInitializer «empty»] do nothing;

[ForInitializer ListExpression^noIn] do

Evaluate Setup[ListExpression^noIn]() and ignore its result;

[ForInitializer VariableDefinition^noIn] do

Evaluate Setup[VariableDefinition^noIn]() and ignore its result;

[ForInitializer Attributes [no line break] VariableDefinition^noIn] do

if Enabled[ForInitializer] then

Evaluate Setup[VariableDefinition^noIn]() and ignore its result

end if

end proc;

proc Setup[ForInBinding] ()

[ForInBinding PostfixExpression] do

Evaluate Setup[PostfixExpression]() and ignore its result;

[ForInBinding VariableDefinitionKind VariableBinding^noIn] do

Evaluate Setup[VariableBinding^noIn]() and ignore its result;

[ForInBinding Attributes [no line break] VariableDefinitionKind VariableBinding^noIn] do

Evaluate Setup[VariableBinding^noIn]() and ignore its result

end proc;

Setup[OptionalExpression] () propagates the call to Setup to nonterminals in the expansion of OptionalExpression.

Evaluation

proc Eval[ForStatement] (env: Environment, d: Object): Object

[ForStatement for ( ForInitializer ; OptionalExpression₁ ; OptionalExpression₂ ) Substatement] do

runtimeLocalFrame: LocalFrame instantiateLocalFrame(CompileLocalFrame[ForStatement], env);

runtimeEnv: Environment [runtimeLocalFrame] env;

try

Evaluate Eval[ForInitializer](runtimeEnv) and ignore its result;

d1: Object d;

while objectToBoolean(readReference(Eval[OptionalExpression₁](runtimeEnv, run), run)) do

try d1 Eval[Substatement](runtimeEnv, d1)

catch x: SemanticException do

if x Continue and x.label Labels[ForStatement] then

d1 x.value

else throw x

end if

end try;

Evaluate readReference(Eval[OptionalExpression₂](runtimeEnv, run), run) and ignore its result

end while;

return d1

catch x: SemanticException do

if x Break and x.label = default then return x.value else throw x end if

end try;

[ForStatement for ( ForInBinding in ListExpression^allowIn ) Substatement] do

try

o: Object readReference(Eval[ListExpression^allowIn](env, run), run);

c: Class objectType(o);

oldIndices: Object{} c.enumerate(o);

remainingIndices: Object{} oldIndices;

d1: Object d;

while remainingIndices {} do

runtimeLocalFrame: LocalFrame instantiateLocalFrame(CompileLocalFrame[ForStatement], env);

runtimeEnv: Environment [runtimeLocalFrame] env;

index: Object any element of remainingIndices;

remainingIndices remainingIndices – {index};

Evaluate WriteBinding[ForInBinding](runtimeEnv, index) and ignore its result;

try d1 Eval[Substatement](runtimeEnv, d1)

catch x: SemanticException do

if x Continue and x.label Labels[ForStatement] then

d1 x.value

else throw x

end if

end try;

newIndices: Object{} c.enumerate(o);

if newIndices oldIndices then

The implementation may, at its discretion, add none, some, or all of the objects in the set difference newIndices – oldIndices to remainingIndices;

The implementation may, at its discretion, remove none, some, or all of the objects in the set difference oldIndices – newIndices from remainingIndices;

end if;

oldIndices newIndices

end while;

return d1

catch x: SemanticException do

if x Break and x.label = default then return x.value else throw x end if

end try

end proc;

proc Eval[ForInitializer] (env: Environment)

[ForInitializer «empty»] do nothing;

[ForInitializer ListExpression^noIn] do

Evaluate readReference(Eval[ListExpression^noIn](env, run), run) and ignore its result;

[ForInitializer VariableDefinition^noIn] do

Evaluate Eval[VariableDefinition^noIn](env, undefined) and ignore its result;

[ForInitializer Attributes [no line break] VariableDefinition^noIn] do

if Enabled[ForInitializer] then

Evaluate Eval[VariableDefinition^noIn](env, undefined) and ignore its result

end if

end proc;

proc WriteBinding[ForInBinding] (env: Environment, newValue: Object)

[ForInBinding PostfixExpression] do

r: ObjOrRef Eval[PostfixExpression](env, run);

Evaluate writeReference(r, newValue, run) and ignore its result;

[ForInBinding VariableDefinitionKind VariableBinding^noIn] do

Evaluate WriteBinding[VariableBinding^noIn](env, newValue) and ignore its result;

[ForInBinding Attributes [no line break] VariableDefinitionKind VariableBinding^noIn] do

Evaluate WriteBinding[VariableBinding^noIn](env, newValue) and ignore its result

end proc;

proc Eval[OptionalExpression] (env: Environment, phase: Phase): ObjOrRef

[OptionalExpression ListExpression^allowIn] do

return Eval[ListExpression^allowIn](env, phase);

[OptionalExpression «empty»] do return true

end proc;

With Statement

Syntax

WithStatement with ParenListExpression Substatement

Validation

CompileLocalFrame[WithStatement]: LocalFrame;

proc Validate[WithStatement with ParenListExpression Substatement] (cxt: Context, env: Environment, jt: JumpTargets)

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

compileWithFrame: WithFrame new WithFramevalue: none;

compileLocalFrame: LocalFrame new LocalFramelocalBindings: {};

CompileLocalFrame[WithStatement] compileLocalFrame;

compileEnv: Environment [compileLocalFrame] [compileWithFrame] env;

Evaluate Validate[Substatement](cxt, compileEnv, {}, jt) and ignore its result

end proc;

Setup

Setup[WithStatement] () propagates the call to Setup to nonterminals in the expansion of WithStatement.

Evaluation

proc Eval[WithStatement with ParenListExpression Substatement] (env: Environment, d: Object): Object

value: Object readReference(Eval[ParenListExpression](env, run), run);

runtimeWithFrame: WithFrame new WithFramevalue: value;

runtimeLocalFrame: LocalFrame instantiateLocalFrame(CompileLocalFrame[WithStatement], [runtimeWithFrame] env);

runtimeEnv: Environment [runtimeLocalFrame] [runtimeWithFrame] env;

return Eval[Substatement](runtimeEnv, d)

end proc;

Continue and Break Statements

Syntax

ContinueStatement

continue

| continue [no line break] Identifier

BreakStatement

break

| break [no line break] Identifier

Validation

proc Validate[ContinueStatement] (jt: JumpTargets)

[ContinueStatement continue] do

if default jt.continueTargets then

throw a SyntaxError exception — there is no enclosing statement to which to continue

end if;

[ContinueStatement continue [no line break] Identifier] do

if Name[Identifier] jt.continueTargets then

throw a SyntaxError exception — there is no enclosing labeled statement to which to continue

end if

end proc;

proc Validate[BreakStatement] (jt: JumpTargets)

[BreakStatement break] do

if default jt.breakTargets then

throw a SyntaxError exception — there is no enclosing statement to which to break

end if;

[BreakStatement break [no line break] Identifier] do

if Name[Identifier] jt.breakTargets then

throw a SyntaxError exception — there is no enclosing labeled statement to which to break

end if

end proc;

Setup

proc Setup[ContinueStatement] ()

[ContinueStatement continue] do nothing;

[ContinueStatement continue [no line break] Identifier] do nothing

end proc;

proc Setup[BreakStatement] ()

[BreakStatement break] do nothing;

[BreakStatement break [no line break] Identifier] do nothing

end proc;

Evaluation

proc Eval[ContinueStatement] (env: Environment, d: Object): Object

[ContinueStatement continue] do throw Continuevalue: d, label: default;

[ContinueStatement continue [no line break] Identifier] do

throw Continuevalue: d, label: Name[Identifier]

end proc;

proc Eval[BreakStatement] (env: Environment, d: Object): Object

[BreakStatement break] do throw Breakvalue: d, label: default;

[BreakStatement break [no line break] Identifier] do

throw Breakvalue: d, label: Name[Identifier]

end proc;

Return Statement

Syntax

ReturnStatement

return

| return [no line break] ListExpression^allowIn

Validation

proc Validate[ReturnStatement] (cxt: Context, env: Environment)

[ReturnStatement return] do

if getEnclosingParameterFrame(env) = none then

throw a SyntaxError exception — a return statement must be located inside a function

end if;

[ReturnStatement return [no line break] ListExpression^allowIn] do

frame: ParameterFrameOpt getEnclosingParameterFrame(env);

if frame = none then

throw a SyntaxError exception — a return statement must be located inside a function

end if;

if cannotReturnValue(frame) then

throw a SyntaxError exception — a return statement inside a setter or constructor cannot return a value

end if;

Evaluate Validate[ListExpression^allowIn](cxt, env) and ignore its result

end proc;

Setup

Setup[ReturnStatement] () propagates the call to Setup to nonterminals in the expansion of ReturnStatement.

Evaluation

proc Eval[ReturnStatement] (env: Environment): Object

[ReturnStatement return] do throw Returnvalue: undefined;

[ReturnStatement return [no line break] ListExpression^allowIn] do

a: Object readReference(Eval[ListExpression^allowIn](env, run), run);

throw Returnvalue: a

end proc;

cannotReturnValue(frame) returns true if the function represented by frame cannot return a value because it is a setter or constructor.

proc cannotReturnValue(frame: ParameterFrame): Boolean

return frame.kind = constructorFunction or frame.handling = set

end proc;

Throw Statement

Syntax

ThrowStatement throw [no line break] ListExpression^allowIn

Validation

Validate[ThrowStatement] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of ThrowStatement.

Setup

Setup[ThrowStatement] () propagates the call to Setup to nonterminals in the expansion of ThrowStatement.

Evaluation

proc Eval[ThrowStatement throw [no line break] ListExpression^allowIn] (env: Environment): Object

a: Object readReference(Eval[ListExpression^allowIn](env, run), run);

throw a

end proc;

Try Statement

Syntax

TryStatement

try Block CatchClauses

| try Block CatchClausesOpt finally Block

CatchClausesOpt

«empty»

| CatchClauses

CatchClauses

CatchClause

| CatchClauses CatchClause

CatchClause catch ( Parameter ) Block

Validation

proc Validate[TryStatement] (cxt: Context, env: Environment, jt: JumpTargets)

[TryStatement try Block CatchClauses] do

Evaluate Validate[Block](cxt, env, jt, false) and ignore its result;

Evaluate Validate[CatchClauses](cxt, env, jt) and ignore its result;

[TryStatement try Block₁ CatchClausesOpt finally Block₂] do

Evaluate Validate[Block₁](cxt, env, jt, false) and ignore its result;

Evaluate Validate[CatchClausesOpt](cxt, env, jt) and ignore its result;

Evaluate Validate[Block₂](cxt, env, jt, false) and ignore its result

end proc;

Validate[CatchClausesOpt] (cxt: Context, env: Environment, jt: JumpTargets) propagates the call to Validate to nonterminals in the expansion of CatchClausesOpt.

Validate[CatchClauses] (cxt: Context, env: Environment, jt: JumpTargets) propagates the call to Validate to nonterminals in the expansion of CatchClauses.

CompileEnv[CatchClause]: Environment;

CompileFrame[CatchClause]: LocalFrame;

proc Validate[CatchClause catch ( Parameter ) Block] (cxt: Context, env: Environment, jt: JumpTargets)

compileFrame: LocalFrame new LocalFramelocalBindings: {};

compileEnv: Environment [compileFrame] env;

CompileFrame[CatchClause] compileFrame;

CompileEnv[CatchClause] compileEnv;

Evaluate Validate[Parameter](cxt, compileEnv, compileFrame) and ignore its result;

Evaluate Validate[Block](cxt, compileEnv, jt, false) and ignore its result

end proc;

Setup

Setup[TryStatement] () propagates the call to Setup to nonterminals in the expansion of TryStatement.

Setup[CatchClausesOpt] () propagates the call to Setup to nonterminals in the expansion of CatchClausesOpt.

Setup[CatchClauses] () propagates the call to Setup to nonterminals in the expansion of CatchClauses.

proc Setup[CatchClause catch ( Parameter ) Block] ()

Evaluate Setup[Parameter](CompileEnv[CatchClause], CompileFrame[CatchClause], none) and ignore its result;

Evaluate Setup[Block]() and ignore its result

end proc;

Evaluation

proc Eval[TryStatement] (env: Environment, d: Object): Object

[TryStatement try Block CatchClauses] do

try return Eval[Block](env, d)

catch x: SemanticException do

if x ControlTransfer then throw x

else

r: Object {reject} Eval[CatchClauses](env, x);

if r reject then return r else throw x end if

end if

end try;

[TryStatement try Block₁ CatchClausesOpt finally Block₂] do

result: ObjectOpt none;

exception: SemanticException {none} none;

try result Eval[Block₁](env, d)

catch x: SemanticException do exception x

end try;

note At this point exactly one of result and exception has a non-none value.

if exception Object then

try

r: Object {reject} Eval[CatchClausesOpt](env, exception);

if r reject then

note The exception has been handled, so clear it.

result r;

exception none

end if

catch x: SemanticException do

note The catch clause threw another exception or ControlTransfer x, so replace the original exception with x.

exception x

end try

end if;

note The finally clause is executed even if the original block exited due to a ControlTransfer (break, continue, or return).

note The finally clause is not inside a try-catch semantic statement, so if it throws another exception or ControlTransfer, then the original exception or ControlTransfer exception is dropped.

Evaluate Eval[Block₂](env, undefined) and ignore its result;

note At this point exactly one of result and exception has a non-none value.

if exception none then throw exception else return result end if

end proc;

proc Eval[CatchClausesOpt] (env: Environment, exception: Object): Object {reject}

[CatchClausesOpt «empty»] do return reject;

[CatchClausesOpt CatchClauses] do return Eval[CatchClauses](env, exception)

end proc;

proc Eval[CatchClauses] (env: Environment, exception: Object): Object {reject}

[CatchClauses CatchClause] do return Eval[CatchClause](env, exception);

[CatchClauses₀ CatchClauses₁ CatchClause] do

r: Object {reject} Eval[CatchClauses₁](env, exception);

if r reject then return r else return Eval[CatchClause](env, exception) end if

end proc;

proc Eval[CatchClause catch ( Parameter ) Block] (env: Environment, exception: Object): Object {reject}

compileFrame: LocalFrame CompileFrame[CatchClause];

runtimeFrame: LocalFrame instantiateLocalFrame(compileFrame, env);

runtimeEnv: Environment [runtimeFrame] env;

qname: QualifiedName public::(Name[Parameter]);

v: SingletonPropertyOpt findLocalSingletonProperty(runtimeFrame, {qname}, write);

note Validate created one local variable with the name in qname, so v Variable.

if is(exception, v.type) then

Evaluate writeSingletonProperty(v, exception, run) and ignore its result;

return Eval[Block](runtimeEnv, undefined)

else return reject

end if

end proc;

Directives

Syntax

Directive

| Statement

| AnnotatableDirective

| Attributes [no line break] AnnotatableDirective

| Attributes [no line break] { Directives }

| Pragma Semicolon

AnnotatableDirective

VariableDefinition^allowIn Semicolon

| FunctionDefinition

| ClassDefinition

| NamespaceDefinition Semicolon

| ImportDirective Semicolon

| UseDirective Semicolon

Directives

«empty»

| DirectivesPrefix Directive^abbrev

DirectivesPrefix

«empty»

| DirectivesPrefix Directive^full

Validation

Enabled[Directive]: Boolean;

proc Validate[Directive] (cxt: Context, env: Environment, jt: JumpTargets, preinst: Boolean, attr: AttributeOptNotFalse)

[Directive EmptyStatement] do nothing;

[Directive Statement] do

if attr {none, true} then

throw an AttributeError exception — an ordinary statement only permits the attributes true and false

end if;

Evaluate Validate[Statement](cxt, env, {}, jt, preinst) and ignore its result;

[Directive AnnotatableDirective] do

Evaluate Validate[AnnotatableDirective](cxt, env, preinst, attr) and ignore its result;

[Directive Attributes [no line break] AnnotatableDirective] do

Evaluate Validate[Attributes](cxt, env) and ignore its result;

Evaluate Setup[Attributes]() and ignore its result;

attr2: Attribute Eval[Attributes](env, compile);

attr3: Attribute combineAttributes(attr, attr2);

if attr3 = false then Enabled[Directive] false

else

Enabled[Directive] true;

Evaluate Validate[AnnotatableDirective](cxt, env, preinst, attr3) and ignore its result

end if;

[Directive Attributes [no line break] { Directives }] do

Evaluate Validate[Attributes](cxt, env) and ignore its result;

Evaluate Setup[Attributes]() and ignore its result;

attr2: Attribute Eval[Attributes](env, compile);

attr3: Attribute combineAttributes(attr, attr2);

if attr3 = false then Enabled[Directive] false

else

Enabled[Directive] true;

localCxt: Context new Contextstrict: cxt.strict, openNamespaces: cxt.openNamespaces;

Evaluate Validate[Directives](localCxt, env, jt, preinst, attr3) and ignore its result

end if;

[Directive Pragma Semicolon] do

if attr {none, true} then Evaluate Validate[Pragma](cxt) and ignore its result

else

throw an AttributeError exception — a pragma directive only permits the attributes true and false

end if

end proc;

proc Validate[AnnotatableDirective] (cxt: Context, env: Environment, preinst: Boolean, attr: AttributeOptNotFalse)

[AnnotatableDirective VariableDefinition^allowIn Semicolon] do

Evaluate Validate[VariableDefinition^allowIn](cxt, env, attr) and ignore its result;

[AnnotatableDirective FunctionDefinition] do

Evaluate Validate[FunctionDefinition](cxt, env, preinst, attr) and ignore its result;

[AnnotatableDirective ClassDefinition] do

Evaluate Validate[ClassDefinition](cxt, env, preinst, attr) and ignore its result;

[AnnotatableDirective NamespaceDefinition Semicolon] do

Evaluate Validate[NamespaceDefinition](cxt, env, preinst, attr) and ignore its result;

[AnnotatableDirective ImportDirective Semicolon] do

Evaluate Validate[ImportDirective](cxt, env, preinst, attr) and ignore its result;

[AnnotatableDirective UseDirective Semicolon] do

if attr {none, true} then

Evaluate Validate[UseDirective](cxt, env) and ignore its result

else

throw an AttributeError exception — a use directive only permits the attributes true and false

end if

end proc;

Validate[Directives] (cxt: Context, env: Environment, jt: JumpTargets, preinst: Boolean, attr: AttributeOptNotFalse) propagates the call to Validate to nonterminals in the expansion of Directives.

Validate[DirectivesPrefix] (cxt: Context, env: Environment, jt: JumpTargets, preinst: Boolean, attr: AttributeOptNotFalse) propagates the call to Validate to nonterminals in the expansion of DirectivesPrefix.

Setup

proc Setup[Directive] ()

[Directive EmptyStatement] do nothing;

[Directive Statement] do Evaluate Setup[Statement]() and ignore its result;

[Directive AnnotatableDirective] do

Evaluate Setup[AnnotatableDirective]() and ignore its result;

[Directive Attributes [no line break] AnnotatableDirective] do

if Enabled[Directive] then

Evaluate Setup[AnnotatableDirective]() and ignore its result

end if;

[Directive Attributes [no line break] { Directives }] do

if Enabled[Directive] then Evaluate Setup[Directives]() and ignore its result

end if;

[Directive Pragma Semicolon] do nothing

end proc;

proc Setup[AnnotatableDirective] ()

[AnnotatableDirective VariableDefinition^allowIn Semicolon] do

Evaluate Setup[VariableDefinition^allowIn]() and ignore its result;

[AnnotatableDirective FunctionDefinition] do

Evaluate Setup[FunctionDefinition]() and ignore its result;

[AnnotatableDirective ClassDefinition] do

Evaluate Setup[ClassDefinition]() and ignore its result;

[AnnotatableDirective NamespaceDefinition Semicolon] do nothing;

[AnnotatableDirective ImportDirective Semicolon] do nothing;

[AnnotatableDirective UseDirective Semicolon] do nothing

end proc;

Setup[Directives] () propagates the call to Setup to nonterminals in the expansion of Directives.

Setup[DirectivesPrefix] () propagates the call to Setup to nonterminals in the expansion of DirectivesPrefix.

Evaluation

proc Eval[Directive] (env: Environment, d: Object): Object

[Directive EmptyStatement] do return d;

[Directive Statement] do return Eval[Statement](env, d);

[Directive AnnotatableDirective] do return Eval[AnnotatableDirective](env, d);

[Directive Attributes [no line break] AnnotatableDirective] do

if Enabled[Directive] then return Eval[AnnotatableDirective](env, d)

else return d

end if;

[Directive Attributes [no line break] { Directives }] do

if Enabled[Directive] then return Eval[Directives](env, d) else return d end if;

[Directive Pragma Semicolon] do return d

end proc;

proc Eval[AnnotatableDirective] (env: Environment, d: Object): Object

[AnnotatableDirective VariableDefinition^allowIn Semicolon] do

return Eval[VariableDefinition^allowIn](env, d);

[AnnotatableDirective FunctionDefinition] do return d;

[AnnotatableDirective ClassDefinition] do return Eval[ClassDefinition](env, d);

[AnnotatableDirective NamespaceDefinition Semicolon] do return d;

[AnnotatableDirective ImportDirective Semicolon] do return d;

[AnnotatableDirective UseDirective Semicolon] do return d

end proc;

proc Eval[Directives] (env: Environment, d: Object): Object

[Directives «empty»] do return d;

[Directives DirectivesPrefix Directive^abbrev] do

o: Object Eval[DirectivesPrefix](env, d);

return Eval[Directive^abbrev](env, o)

end proc;

proc Eval[DirectivesPrefix] (env: Environment, d: Object): Object

[DirectivesPrefix «empty»] do return d;

[DirectivesPrefix₀ DirectivesPrefix₁ Directive^full] do

o: Object Eval[DirectivesPrefix₁](env, d);

return Eval[Directive^full](env, o)

end proc;

Attributes

Syntax

Attributes

Attribute

AttributeCombination Attribute [no line break] Attributes

Attribute

| true

| false

Validation

Validate[Attributes] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Attributes.

Validate[AttributeCombination] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of AttributeCombination.

Validate[Attribute] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Attribute.

Setup

Setup[Attributes] () propagates the call to Setup to nonterminals in the expansion of Attributes.

Setup[AttributeCombination] () propagates the call to Setup to nonterminals in the expansion of AttributeCombination.

Setup[Attribute] () propagates the call to Setup to nonterminals in the expansion of Attribute.

Evaluation

proc Eval[Attributes] (env: Environment, phase: Phase): Attribute

[Attributes Attribute] do return Eval[Attribute](env, phase);

[Attributes AttributeCombination] do return Eval[AttributeCombination](env, phase)

end proc;

proc Eval[AttributeCombination Attribute [no line break] Attributes] (env: Environment, phase: Phase): Attribute

a: Attribute Eval[Attribute](env, phase);

if a = false then return false end if;

b: Attribute Eval[Attributes](env, phase);

return combineAttributes(a, b)

end proc;

proc Eval[Attribute] (env: Environment, phase: Phase): Attribute

[Attribute AttributeExpression] do

a: Object readReference(Eval[AttributeExpression](env, phase), phase);

return objectToAttribute(a, phase);

[Attribute true] do return true;

[Attribute false] do return false;

[Attribute ReservedNamespace] do return Eval[ReservedNamespace](env, phase)

end proc;

Use Directive

Syntax

UseDirective use namespace ParenListExpression

Validation

proc Validate[UseDirective use namespace ParenListExpression] (cxt: Context, env: Environment)

Evaluate Validate[ParenListExpression](cxt, env) and ignore its result;

Evaluate Setup[ParenListExpression]() and ignore its result;

values: Object[] EvalAsList[ParenListExpression](env, compile);

namespaces: Namespace{} {};

for each v values do

if v Namespace then throw a TypeError exception end if;

namespaces namespaces {v}

end for each;

cxt.openNamespaces cxt.openNamespaces namespaces

end proc;

Import Directive

Syntax

ImportDirective

import PackageName

| import Identifier = PackageName

Validation

proc Validate[ImportDirective] (cxt: Context, env: Environment, preinst: Boolean, attr: AttributeOptNotFalse)

[ImportDirective import PackageName] do

if not preinst then

throw a SyntaxError exception — a package may be imported only in a preinstantiated scope

end if;

frame: Frame env[0];

if frame Package then

throw a SyntaxError exception — a package may be imported only into a package scope

end if;

if attr {none, true} then

throw an AttributeError exception — an unnamed import directive only permits the attributes true and false

end if;

pkgName: String Name[PackageName];

pkg: Package locatePackage(pkgName);

Evaluate importPackageInto(pkg, frame) and ignore its result;

[ImportDirective import Identifier = PackageName] do

if not preinst then

throw a SyntaxError exception — a package may be imported only in a preinstantiated scope

end if;

frame: Frame env[0];

if frame Package then

throw a SyntaxError exception — a package may be imported only into a package scope

end if;

a: CompoundAttribute toCompoundAttribute(attr);

if a.dynamic then

throw an AttributeError exception — a package definition cannot have the dynamic attribute

end if;

if a.prototype then

throw an AttributeError exception — a package definition cannot have the prototype attribute

end if;

pkgName: String Name[PackageName];

pkg: Package locatePackage(pkgName);

v: Variable new Variabletype: Package, value: pkg, immutable: true, setup: none, initializer: none;

Evaluate defineSingletonProperty(env, Name[Identifier], a.namespaces, a.overrideMod, a.explicit, readWrite, v) and ignore its result;

Evaluate importPackageInto(pkg, frame) and ignore its result

end proc;

proc locatePackage(name: String): Package

Look for a package bound to name in the implementation’s list of available packages. If one is found, let pkg: Package be that package; otherwise, throw an implementation-defined error.

initialize: (() ()) {none, busy} pkg.initialize;

case initialize of

{none} do nothing;

{busy} do throw an UninitializedError exception — circular package dependency;

() () do

Evaluate initialize() and ignore its result;

note pkg.initialize = none;

end case;

return pkg

end proc;

proc importPackageInto(source: Package, destination: Package)

for each b source.localBindings do

if not (b.explicit or b.content = forbidden or (some d destination.localBindings satisfies b.qname = d.qname and accessesOverlap(b.accesses, d.accesses))) then

destination.localBindings destination.localBindings {b}

end if

end for each

end proc;

Pragma

Syntax

Pragma use PragmaItems

PragmaItems

PragmaItem

| PragmaItems , PragmaItem

PragmaItem

PragmaExpr

| PragmaExpr ?

PragmaExpr

Identifier

| Identifier ( PragmaArgument )

PragmaArgument

true

| false

| Number

| - Number

| - NegatedMinLong

| String

Validation

Validate[Pragma] (cxt: Context) propagates the call to Validate to nonterminals in the expansion of Pragma.

Validate[PragmaItems] (cxt: Context) propagates the call to Validate to nonterminals in the expansion of PragmaItems.

proc Validate[PragmaItem] (cxt: Context)

[PragmaItem PragmaExpr] do

Evaluate Validate[PragmaExpr](cxt, false) and ignore its result;

[PragmaItem PragmaExpr ?] do

Evaluate Validate[PragmaExpr](cxt, true) and ignore its result

end proc;

proc Validate[PragmaExpr] (cxt: Context, optional: Boolean)

[PragmaExpr Identifier] do

Evaluate processPragma(cxt, Name[Identifier], undefined, optional) and ignore its result;

[PragmaExpr Identifier ( PragmaArgument )] do

arg: Object Value[PragmaArgument];

Evaluate processPragma(cxt, Name[Identifier], arg, optional) and ignore its result

end proc;

Value[PragmaArgument]: Object;

Value[PragmaArgument true] = true;

Value[PragmaArgument false] = false;

Value[PragmaArgument Number] = Value[Number];

Value[PragmaArgument - Number] = generalNumberNegate(Value[Number]);

Value[PragmaArgument - NegatedMinLong] = (–2⁶³)_long;

Value[PragmaArgument String] = Value[String];

proc processPragma(cxt: Context, name: String, value: Object, optional: Boolean)

if name = “strict” then

if value {true, undefined} then cxt.strict true; return end if;

if value = false then cxt.strict false; return end if

end if;

if name = “ecmascript” then

if value {undefined, 4_f64} then return end if;

if value {1_f64, 2_f64, 3_f64} then

An implementation may optionally modify cxt to disable features not available in ECMAScript Edition value other than subsequent pragmas.

return

end if

end if;

if not optional then throw a SyntaxError exception end if

end proc;

Definitions

Variable Definition

Syntax

VariableDefinition VariableDefinitionKind VariableBindingList

VariableDefinitionKind

var

| const

VariableBindingList

VariableBinding

| VariableBindingList , VariableBinding

VariableBinding TypedIdentifier VariableInitialisation

VariableInitialisation

«empty»

| = VariableInitializer

VariableInitializer

TypedIdentifier

Identifier

| Identifier : TypeExpression

Validation

proc Validate[VariableDefinition VariableDefinitionKind VariableBindingList] (cxt: Context, env: Environment, attr: AttributeOptNotFalse)

Evaluate Validate[VariableBindingList](cxt, env, attr, Immutable[VariableDefinitionKind], false) and ignore its result

end proc;

Immutable[VariableDefinitionKind]: Boolean;

Immutable[VariableDefinitionKind var] = false;

Immutable[VariableDefinitionKind const] = true;

Validate[VariableBindingList] (cxt: Context, env: Environment, attr: AttributeOptNotFalse, immutable: Boolean, noInitializer: Boolean) propagates the call to Validate to nonterminals in the expansion of VariableBindingList.

CompileEnv[VariableBinding]: Environment;

CompileVar[VariableBinding]: Variable DynamicVar InstanceVariable;

OverriddenVar[VariableBinding]: InstanceVariableOpt;

Multiname[VariableBinding]: Multiname;

proc Validate[VariableBinding TypedIdentifier VariableInitialisation] (cxt: Context, env: Environment, attr: AttributeOptNotFalse, immutable: Boolean, noInitializer: Boolean)

Evaluate Validate[TypedIdentifier](cxt, env) and ignore its result;

Evaluate Validate[VariableInitialisation](cxt, env) and ignore its result;

CompileEnv[VariableBinding] env;

name: String Name[TypedIdentifier];

if not cxt.strict and getRegionalFrame(env) Package ParameterFrame and not immutable and attr = none and Plain[TypedIdentifier] then

qname: QualifiedName public::name;

Multiname[VariableBinding] {qname};

CompileVar[VariableBinding] defineHoistedVar(env, name, undefined)

else

a: CompoundAttribute toCompoundAttribute(attr);

if a.dynamic then

throw an AttributeError exception — a variable definition cannot have the dynamic attribute

end if;

if a.prototype then

throw an AttributeError exception — a variable definition cannot have the prototype attribute

end if;

category: PropertyCategory a.category;

if env[0] Class then if category = none then category final end if

else

if category none then

throw an AttributeError exception — non-class variables cannot have a static, virtual, or final attribute

end if

end if;

case category of

{none, static} do

initializer: InitializerOpt Initializer[VariableInitialisation];

if noInitializer and initializer none then

throw a SyntaxError exception — a for-in statement’s variable definition must not have an initialiser

end if;

proc variableSetup(): ClassOpt

type: ClassOpt SetupAndEval[TypedIdentifier](env);

Evaluate Setup[VariableInitialisation]() and ignore its result;

return type

end proc;

v: Variable new Variablevalue: none, immutable: immutable, setup: variableSetup, initializer: initializer, initializerEnv: env;

multiname: Multiname defineSingletonProperty(env, name, a.namespaces, a.overrideMod, a.explicit, readWrite, v);

Multiname[VariableBinding] multiname;

CompileVar[VariableBinding] v;

{virtual, final} do

note not noInitializer;

c: Class env[0];

v: InstanceVariable new InstanceVariablefinal: category = final, immutable: immutable;

vOverridden: InstanceVariableOpt defineInstanceProperty(c, cxt, name, a.namespaces, a.overrideMod, a.explicit, v);

enumerable: Boolean a.enumerable;

if vOverridden none and vOverridden.enumerable then enumerable true

end if;

v.enumerable enumerable;

OverriddenVar[VariableBinding] vOverridden;

CompileVar[VariableBinding] v

end case

end if

end proc;

Validate[VariableInitialisation] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of VariableInitialisation.

Validate[VariableInitializer] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of VariableInitializer.

Name[TypedIdentifier]: String;

Name[TypedIdentifier Identifier] = Name[Identifier];

Name[TypedIdentifier Identifier : TypeExpression] = Name[Identifier];

Plain[TypedIdentifier]: Boolean;

Plain[TypedIdentifier Identifier] = true;

Plain[TypedIdentifier Identifier : TypeExpression] = false;

proc Validate[TypedIdentifier] (cxt: Context, env: Environment)

[TypedIdentifier Identifier] do nothing;

[TypedIdentifier Identifier : TypeExpression] do

Evaluate Validate[TypeExpression](cxt, env) and ignore its result

end proc;

Setup

proc Setup[VariableDefinition VariableDefinitionKind VariableBindingList] ()

Evaluate Setup[VariableBindingList]() and ignore its result

end proc;

Setup[VariableBindingList] () propagates the call to Setup to nonterminals in the expansion of VariableBindingList.

proc Setup[VariableBinding TypedIdentifier VariableInitialisation] ()

env: Environment CompileEnv[VariableBinding];

v: Variable DynamicVar InstanceVariable CompileVar[VariableBinding];

case v of

Variable do

Evaluate setupVariable(v) and ignore its result;

if not v.immutable then

defaultValue: ObjectOpt v.type.defaultValue;

if defaultValue = none then

throw an UninitializedError exception — Cannot declare a mutable variable of type Never

end if;

v.value defaultValue

end if;

DynamicVar do Evaluate Setup[VariableInitialisation]() and ignore its result;

t: ClassOpt SetupAndEval[TypedIdentifier](env);

if t = none then

overriddenVar: InstanceVariableOpt OverriddenVar[VariableBinding];

if overriddenVar none then t overriddenVar.type

else t Object

end if

end if;

v.type t;

Evaluate Setup[VariableInitialisation]() and ignore its result;

initializer: InitializerOpt Initializer[VariableInitialisation];

defaultValue: ObjectOpt none;

if initializer none then defaultValue initializer(env, compile)

elsif not v.immutable then

defaultValue t.defaultValue;

if defaultValue = none then

throw an UninitializedError exception — Cannot declare a mutable instance variable of type Never

end if

end if;

v.defaultValue defaultValue

end case

end proc;

Setup[VariableInitialisation] () propagates the call to Setup to nonterminals in the expansion of VariableInitialisation.

Setup[VariableInitializer] () propagates the call to Setup to nonterminals in the expansion of VariableInitializer.

Evaluation

proc Eval[VariableDefinition VariableDefinitionKind VariableBindingList] (env: Environment, d: Object): Object

Evaluate Eval[VariableBindingList](env) and ignore its result;

return d

end proc;

Eval[VariableBindingList] (env: Environment) propagates the call to Eval to nonterminals in the expansion of VariableBindingList.

proc Eval[VariableBinding TypedIdentifier VariableInitialisation] (env: Environment)

case CompileVar[VariableBinding] of

Variable do

innerFrame: NonWithFrame env[0];

properties: SingletonProperty{} {b.content | b innerFrame.localBindings such that b.qname Multiname[VariableBinding]};

note The properties set consists of exactly one Variable element because innerFrame was constructed with that Variable inside Validate.

v: Variable the one element of properties;

initializer: Initializer {none, busy} v.initializer;

case initializer of

{none} do nothing;

{busy} do throw a ReferenceError exception;

Initializer do

v.initializer busy;

value: Object initializer(v.initializerEnv, run);

Evaluate writeVariable(v, value, true) and ignore its result

end case;

initializer: InitializerOpt Initializer[VariableInitialisation];

if initializer none then

value: Object initializer(env, run);

Evaluate lexicalWrite(env, Multiname[VariableBinding], value, false, run) and ignore its result

end if;

InstanceVariable do nothing

end case

end proc;

proc WriteBinding[VariableBinding TypedIdentifier VariableInitialisation] (env: Environment, newValue: Object)

case CompileVar[VariableBinding] of

Variable do

innerFrame: NonWithFrame env[0];

properties: SingletonProperty{} {b.content | b innerFrame.localBindings such that b.qname Multiname[VariableBinding]};

note The properties set consists of exactly one Variable element because innerFrame was constructed with that Variable inside Validate.

v: Variable the one element of properties;

Evaluate writeVariable(v, newValue, false) and ignore its result;

Evaluate lexicalWrite(env, Multiname[VariableBinding], newValue, false, run) and ignore its result

end case

end proc;

Initializer[VariableInitialisation]: InitializerOpt;

Initializer[VariableInitialisation «empty»] = none;

Initializer[VariableInitialisation = VariableInitializer] = Eval[VariableInitializer];

proc Eval[VariableInitializer] (env: Environment, phase: Phase): Object

[VariableInitializer AssignmentExpression] do

return readReference(Eval[AssignmentExpression](env, phase), phase);

[VariableInitializer AttributeCombination] do

return Eval[AttributeCombination](env, phase)

end proc;

proc SetupAndEval[TypedIdentifier] (env: Environment): ClassOpt

[TypedIdentifier Identifier] do return none;

[TypedIdentifier Identifier : TypeExpression] do

return SetupAndEval[TypeExpression](env)

end proc;

Simple Variable Definition

Syntax

SimpleVariableDefinition var UntypedVariableBindingList

UntypedVariableBindingList

UntypedVariableBinding

| UntypedVariableBindingList , UntypedVariableBinding

UntypedVariableBinding Identifier VariableInitialisation^allowIn

Validation

proc Validate[SimpleVariableDefinition var UntypedVariableBindingList] (cxt: Context, env: Environment)

if cxt.strict or getRegionalFrame(env) Package ParameterFrame then

throw a SyntaxError exception — a variable may not be defined in a substatement except inside a non-strict function or non-strict top-level code; to fix this error, place the definition inside a block

end if;

Evaluate Validate[UntypedVariableBindingList](cxt, env) and ignore its result

end proc;

Validate[UntypedVariableBindingList] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of UntypedVariableBindingList.

proc Validate[UntypedVariableBinding Identifier VariableInitialisation^allowIn] (cxt: Context, env: Environment)

Evaluate Validate[VariableInitialisation^allowIn](cxt, env) and ignore its result;

Evaluate defineHoistedVar(env, Name[Identifier], undefined) and ignore its result

end proc;

Setup

Setup[SimpleVariableDefinition] () propagates the call to Setup to nonterminals in the expansion of SimpleVariableDefinition.

Setup[UntypedVariableBindingList] () propagates the call to Setup to nonterminals in the expansion of UntypedVariableBindingList.

proc Setup[UntypedVariableBinding Identifier VariableInitialisation^allowIn] ()

Evaluate Setup[VariableInitialisation^allowIn]() and ignore its result

end proc;

Evaluation

proc Eval[SimpleVariableDefinition var UntypedVariableBindingList] (env: Environment, d: Object): Object

Evaluate Eval[UntypedVariableBindingList](env) and ignore its result;

return d

end proc;

Eval[UntypedVariableBindingList] (env: Environment) propagates the call to Eval to nonterminals in the expansion of UntypedVariableBindingList.

proc Eval[UntypedVariableBinding Identifier VariableInitialisation^allowIn] (env: Environment)

initializer: InitializerOpt Initializer[VariableInitialisation^allowIn];

if initializer none then

value: Object initializer(env, run);

qname: QualifiedName public::(Name[Identifier]);

Evaluate lexicalWrite(env, {qname}, value, false, run) and ignore its result

end if

end proc;

Function Definition

Syntax

FunctionDefinition function FunctionName FunctionCommon

FunctionName

Identifier

| get [no line break] Identifier

| set [no line break] Identifier

FunctionCommon ( Parameters ) Result Block

Validation

OverriddenProperty[FunctionDefinition]: InstancePropertyOpt;

proc ValidateStatic[FunctionDefinition function FunctionName FunctionCommon] (cxt: Context, env: Environment, preinst: Boolean, a: CompoundAttribute, unchecked: Boolean, hoisted: Boolean)

name: String Name[FunctionName];

handling: Handling Handling[FunctionName];

case handling of

{normal} do

kind: StaticFunctionKind;

if unchecked then kind uncheckedFunction

elsif a.prototype then kind prototypeFunction

else kind plainFunction

end if;

f: SimpleInstance UninstantiatedFunction ValidateStaticFunction[FunctionCommon](cxt, env, kind);

if preinst then f instantiateFunction(f, env) end if;

if hoisted then Evaluate defineHoistedVar(env, name, f) and ignore its result

else

v: Variable new Variabletype: Function, value: f, immutable: true, setup: none, initializer: none;

Evaluate defineSingletonProperty(env, name, a.namespaces, a.overrideMod, a.explicit, readWrite, v) and ignore its result

end if;

{get, set} do

if a.prototype then

throw an AttributeError exception — a getter or setter cannot have the prototype attribute

end if;

note not (unchecked or hoisted);

Evaluate Validate[FunctionCommon](cxt, env, plainFunction, handling) and ignore its result;

boundEnv: EnvironmentOpt none;

if preinst then boundEnv env end if;

case handling of

{get} do

getter: Getter new Gettercall: EvalStaticGet[FunctionCommon], env: boundEnv;

Evaluate defineSingletonProperty(env, name, a.namespaces, a.overrideMod, a.explicit, read, getter) and ignore its result;

{set} do

setter: Setter new Settercall: EvalStaticSet[FunctionCommon], env: boundEnv;

Evaluate defineSingletonProperty(env, name, a.namespaces, a.overrideMod, a.explicit, write, setter) and ignore its result

end case

end case;

OverriddenProperty[FunctionDefinition] none

end proc;

proc ValidateInstance[FunctionDefinition function FunctionName FunctionCommon] (cxt: Context, env: Environment, c: Class, a: CompoundAttribute, final: Boolean)

if a.prototype then

throw an AttributeError exception — an instance method cannot have the prototype attribute

end if;

handling: Handling Handling[FunctionName];

Evaluate Validate[FunctionCommon](cxt, env, instanceFunction, handling) and ignore its result;

signature: ParameterFrame CompileFrame[FunctionCommon];

m: InstanceProperty;

case handling of

{normal} do

m new InstanceMethodfinal: final, signature: signature, length: signatureLength(signature), call: EvalInstanceCall[FunctionCommon];

{get} do

m new InstanceGetterfinal: final, signature: signature, call: EvalInstanceGet[FunctionCommon];

{set} do

m new InstanceSetterfinal: final, signature: signature, call: EvalInstanceSet[FunctionCommon]

end case;

mOverridden: InstancePropertyOpt defineInstanceProperty(c, cxt, Name[FunctionName], a.namespaces, a.overrideMod, a.explicit, m);

enumerable: Boolean a.enumerable;

if mOverridden none and mOverridden.enumerable then enumerable true end if;

m.enumerable enumerable;

OverriddenProperty[FunctionDefinition] mOverridden

end proc;

proc ValidateConstructor[FunctionDefinition function FunctionName FunctionCommon] (cxt: Context, env: Environment, c: Class, a: CompoundAttribute)

if a.prototype then

throw an AttributeError exception — a class constructor cannot have the prototype attribute

end if;

if Handling[FunctionName] {get, set} then

throw a SyntaxError exception — a class constructor cannot be a getter or a setter

end if;

Evaluate Validate[FunctionCommon](cxt, env, constructorFunction, normal) and ignore its result;

if c.init none then

throw a DefinitionError exception — duplicate constructor definition

end if;

c.init EvalInstanceInit[FunctionCommon];

OverriddenProperty[FunctionDefinition] none

end proc;

proc Validate[FunctionDefinition function FunctionName FunctionCommon] (cxt: Context, env: Environment, preinst: Boolean, attr: AttributeOptNotFalse)

a: CompoundAttribute toCompoundAttribute(attr);

if a.dynamic then

throw an AttributeError exception — a function cannot have the dynamic attribute

end if;

frame: Frame env[0];

if frame Class then

note preinst;

case a.category of

{static} do

Evaluate ValidateStatic[FunctionDefinition](cxt, env, preinst, a, false, false) and ignore its result;

{none} do

if Name[FunctionName] = frame.name then

Evaluate ValidateConstructor[FunctionDefinition](cxt, env, frame, a) and ignore its result

else

Evaluate ValidateInstance[FunctionDefinition](cxt, env, frame, a, false) and ignore its result

end if;

{virtual} do

Evaluate ValidateInstance[FunctionDefinition](cxt, env, frame, a, false) and ignore its result;

{final} do

Evaluate ValidateInstance[FunctionDefinition](cxt, env, frame, a, true) and ignore its result

end case

else

if a.category none then

throw an AttributeError exception — non-class functions cannot have a static, virtual, or final attribute

end if;

unchecked: Boolean not cxt.strict and Handling[FunctionName] = normal and Plain[FunctionCommon];

hoisted: Boolean unchecked and attr = none and (frame Package or (frame LocalFrame and env[1] ParameterFrame));

Evaluate ValidateStatic[FunctionDefinition](cxt, env, preinst, a, unchecked, hoisted) and ignore its result

end if

end proc;

Handling[FunctionName]: Handling;

Handling[FunctionName Identifier] = normal;

Handling[FunctionName get [no line break] Identifier] = get;

Handling[FunctionName set [no line break] Identifier] = set;

Name[FunctionName]: String;

Name[FunctionName Identifier] = Name[Identifier];

Name[FunctionName get [no line break] Identifier] = Name[Identifier];

Name[FunctionName set [no line break] Identifier] = Name[Identifier];

Plain[FunctionCommon ( Parameters ) Result Block]: Boolean = Plain[Parameters] and Plain[Result];

CompileEnv[FunctionCommon]: Environment;

CompileFrame[FunctionCommon]: ParameterFrame;

proc Validate[FunctionCommon ( Parameters ) Result Block] (cxt: Context, env: Environment, kind: FunctionKind, handling: Handling)

localCxt: Context new Contextstrict: cxt.strict, openNamespaces: cxt.openNamespaces;

superconstructorCalled: Boolean kind constructorFunction;

compileFrame: ParameterFrame new ParameterFramelocalBindings: {}, kind: kind, handling: handling, callsSuperconstructor: false, superconstructorCalled: superconstructorCalled, this: none, parameters: [], rest: none;

compileEnv: Environment [compileFrame] env;

CompileFrame[FunctionCommon] compileFrame;

CompileEnv[FunctionCommon] compileEnv;

if kind = uncheckedFunction then

Evaluate defineHoistedVar(compileEnv, “arguments”, undefined) and ignore its result

end if;

Evaluate Validate[Parameters](localCxt, compileEnv, compileFrame) and ignore its result;

Evaluate Validate[Result](localCxt, compileEnv) and ignore its result;

Evaluate Validate[Block](localCxt, compileEnv, JumpTargetsbreakTargets: {}, continueTargets: {}, false) and ignore its result

end proc;

proc ValidateStaticFunction[FunctionCommon ( Parameters ) Result Block] (cxt: Context, env: Environment, kind: StaticFunctionKind): UninstantiatedFunction

Evaluate Validate[FunctionCommon](cxt, env, kind, normal) and ignore its result;

length: Integer ParameterCount[Parameters];

case kind of

{plainFunction} do

return new UninstantiatedFunctiontype: Function, length: length, call: EvalStaticCall[FunctionCommon], construct: none, instantiations: {};

{uncheckedFunction, prototypeFunction} do

return new UninstantiatedFunctiontype: PrototypeFunction, length: length, call: EvalStaticCall[FunctionCommon], construct: EvalPrototypeConstruct[FunctionCommon], instantiations: {}

end case

end proc;

Setup

proc Setup[FunctionDefinition function FunctionName FunctionCommon] ()

overriddenProperty: InstancePropertyOpt OverriddenProperty[FunctionDefinition];

case overriddenProperty of

{none} do Evaluate Setup[FunctionCommon]() and ignore its result;

InstanceMethod InstanceGetter InstanceSetter do

Evaluate SetupOverride[FunctionCommon](overriddenProperty.signature) and ignore its result;

overriddenSignature: ParameterFrame;

case Handling[FunctionName] of

{normal} do

This cannot happen because ValidateInstance already ensured that a function cannot override an instance variable.

{get} do

overriddenSignature new ParameterFramelocalBindings: {}, kind: instanceFunction, handling: get, callsSuperconstructor: false, superconstructorCalled: false, this: none, parameters: [], rest: none, returnType: overriddenProperty.type;

{set} do

v: Variable new Variabletype: overriddenProperty.type, value: none, immutable: false, setup: none, initializer: none;

parameters: Parameter[] [Parametervar: v, default: none];

overriddenSignature new ParameterFramelocalBindings: {}, kind: instanceFunction, handling: set, callsSuperconstructor: false, superconstructorCalled: false, this: none, parameters: parameters, rest: none, returnType: Void

end case;

Evaluate SetupOverride[FunctionCommon](overriddenSignature) and ignore its result

end case

end proc;

proc Setup[FunctionCommon ( Parameters ) Result Block] ()

compileEnv: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

Evaluate Setup[Parameters](compileEnv, compileFrame) and ignore its result;

Evaluate checkAccessorParameters(compileFrame) and ignore its result;

Evaluate Setup[Result](compileEnv, compileFrame) and ignore its result;

Evaluate Setup[Block]() and ignore its result

end proc;

proc SetupOverride[FunctionCommon ( Parameters ) Result Block] (overriddenSignature: ParameterFrame)

compileEnv: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

Evaluate SetupOverride[Parameters](compileEnv, compileFrame, overriddenSignature) and ignore its result;

Evaluate checkAccessorParameters(compileFrame) and ignore its result;

Evaluate SetupOverride[Result](compileEnv, compileFrame, overriddenSignature) and ignore its result;

Evaluate Setup[Block]() and ignore its result

end proc;

Evaluation

proc EvalStaticCall[FunctionCommon ( Parameters ) Result Block] (this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call user-defined functions

end if;

runtimeEnv: Environment f.env;

runtimeThis: ObjectOpt none;

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

if compileFrame.kind {uncheckedFunction, prototypeFunction} then

if this PrimitiveObject then runtimeThis getPackageFrame(runtimeEnv)

else runtimeThis this

end if

end if;

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, runtimeEnv, runtimeThis);

Evaluate assignArguments(runtimeFrame, f, args, phase) and ignore its result;

result: Object;

try

Evaluate Eval[Block]([runtimeFrame] runtimeEnv, undefined) and ignore its result;

result undefined

catch x: SemanticException do

if x Return then result x.value else throw x end if

end try;

return coerce(result, runtimeFrame.returnType)

end proc;

proc EvalStaticGet[FunctionCommon ( Parameters ) Result Block] (runtimeEnv: Environment, phase: Phase): Object

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call user-defined getters

end if;

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, runtimeEnv, none);

Evaluate assignArguments(runtimeFrame, none, [], phase) and ignore its result;

result: Object;

try

Evaluate Eval[Block]([runtimeFrame] runtimeEnv, undefined) and ignore its result;

throw a SyntaxError exception — a getter must return a value and may not return by falling off the end of its code

catch x: SemanticException do

if x Return then result x.value else throw x end if

end try;

return coerce(result, runtimeFrame.returnType)

end proc;

proc EvalStaticSet[FunctionCommon ( Parameters ) Result Block] (newValue: Object, runtimeEnv: Environment, phase: Phase)

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call setters

end if;

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, runtimeEnv, none);

Evaluate assignArguments(runtimeFrame, none, [newValue], phase) and ignore its result;

try

Evaluate Eval[Block]([runtimeFrame] runtimeEnv, undefined) and ignore its result

catch x: SemanticException do if x Return then throw x end if

end try

end proc;

proc EvalInstanceCall[FunctionCommon ( Parameters ) Result Block] (this: Object, args: Object[], phase: Phase): Object

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call user-defined functions

end if;

note Class frames are always preinstantiated, so the run environment is the same as compile environment.

env: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, env, this);

Evaluate assignArguments(runtimeFrame, none, args, phase) and ignore its result;

result: Object;

try

Evaluate Eval[Block]([runtimeFrame] env, undefined) and ignore its result;

result undefined

catch x: SemanticException do

if x Return then result x.value else throw x end if

end try;

return coerce(result, runtimeFrame.returnType)

end proc;

proc EvalInstanceGet[FunctionCommon ( Parameters ) Result Block] (this: Object, phase: Phase): Object

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call user-defined getters

end if;

note Class frames are always preinstantiated, so the run environment is the same as compile environment.

env: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, env, this);

Evaluate assignArguments(runtimeFrame, none, [], phase) and ignore its result;

result: Object;

try

Evaluate Eval[Block]([runtimeFrame] env, undefined) and ignore its result;

throw a SyntaxError exception — a getter must return a value and may not return by falling off the end of its code

catch x: SemanticException do

if x Return then result x.value else throw x end if

end try;

return coerce(result, runtimeFrame.returnType)

end proc;

proc EvalInstanceSet[FunctionCommon ( Parameters ) Result Block] (this: Object, newValue: Object, phase: Phase)

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call setters

end if;

note Class frames are always preinstantiated, so the run environment is the same as compile environment.

env: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, env, this);

Evaluate assignArguments(runtimeFrame, none, [newValue], phase) and ignore its result;

try Evaluate Eval[Block]([runtimeFrame] env, undefined) and ignore its result

catch x: SemanticException do if x Return then throw x end if

end try

end proc;

proc EvalInstanceInit[FunctionCommon ( Parameters ) Result Block] (this: SimpleInstance, args: Object[], phase: {run})

note Class frames are always preinstantiated, so the run environment is the same as compile environment.

env: Environment CompileEnv[FunctionCommon];

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, env, this);

Evaluate assignArguments(runtimeFrame, none, args, phase) and ignore its result;

if not runtimeFrame.callsSuperconstructor then

c: Class getEnclosingClass(env);

Evaluate callInit(this, c.super, [], run) and ignore its result;

runtimeFrame.superconstructorCalled true

end if;

try Evaluate Eval[Block]([runtimeFrame] env, undefined) and ignore its result

catch x: SemanticException do if x Return then throw x end if

end try;

if not runtimeFrame.superconstructorCalled then

throw an UninitializedError exception — the superconstructor must be called before returning normally from a constructor

end if

end proc;

proc EvalPrototypeConstruct[FunctionCommon ( Parameters ) Result Block] (f: SimpleInstance, args: Object[], phase: Phase): Object

note The check that phase compile also ensures that Setup has been called.

if phase = compile then

throw a ConstantError exception — a constant expression cannot call user-defined prototype constructors

end if;

runtimeEnv: Environment f.env;

archetype: Object dotRead(f, {public::“prototype”}, phase);

if archetype {null, undefined} then archetype ObjectPrototype

elsif objectType(archetype) Object then

throw a TypeError exception — bad prototype value

end if;

o: Object createSimpleInstance(Object, archetype, none, none, none);

compileFrame: ParameterFrame CompileFrame[FunctionCommon];

runtimeFrame: ParameterFrame instantiateParameterFrame(compileFrame, runtimeEnv, o);

Evaluate assignArguments(runtimeFrame, f, args, phase) and ignore its result;

result: Object;

try

Evaluate Eval[Block]([runtimeFrame] runtimeEnv, undefined) and ignore its result;

result undefined

catch x: SemanticException do

if x Return then result x.value else throw x end if

end try;

coercedResult: Object coerce(result, runtimeFrame.returnType);

if coercedResult PrimitiveObject then return o else return coercedResult end if

end proc;

proc checkAccessorParameters(frame: ParameterFrame)

parameters: Parameter[] frame.parameters;

rest: VariableOpt frame.rest;

case frame.handling of

{normal} do nothing;

{get} do

if parameters [] or rest none then

throw a SyntaxError exception — a getter cannot take any parameters

end if;

{set} do

if |parameters| 1 or rest none then

throw a SyntaxError exception — a setter must take exactly one parameter

end if;

if parameters[0].default none then

throw a SyntaxError exception — a setter’s parameter cannot be optional

end if

end case

end proc;

proc assignArguments(runtimeFrame: ParameterFrame, f: SimpleInstance {none}, args: Object[], phase: {run})

This procedure performs a number of checks on the arguments, including checking their count, names, and values. Although this procedure performs these checks in a specific order for expository purposes, an implementation may perform these checks in a different order, which could have the effect of reporting a different error if there are multiple errors. For example, if a function only allows between 2 and 4 arguments, the first of which must be a Number and is passed five arguments the first of which is a String, then the implementation may throw an exception either about the argument count mismatch or about the type coercion error in the first argument.

argumentsObject: ObjectOpt none;

if runtimeFrame.kind = uncheckedFunction then

argumentsObject construct(Array, [], phase);

Evaluate createDynamicProperty(argumentsObject, public::“callee”, false, false, f) and ignore its result;

Evaluate writeArrayPrivateLength(argumentsObject, |args|, phase) and ignore its result

end if;

restObject: ObjectOpt none;

rest: Variable {none} runtimeFrame.rest;

if rest none then restObject construct(Array, [], phase) end if;

parameters: Parameter[] runtimeFrame.parameters;

i: Integer 0;

j: Integer 0;

for each arg args do

if i < |parameters| then

parameter: Parameter parameters[i];

default: ObjectOpt parameter.default;

argOrDefault: Object arg;

if argOrDefault = undefined and default none then argOrDefault default

end if;

v: DynamicVar Variable parameter.var;

Evaluate writeSingletonProperty(v, argOrDefault, phase) and ignore its result;

if argumentsObject none then

note Create an alias of v as the ith entry of the arguments object.

note v DynamicVar;

qname: QualifiedName objectToQualifiedName(i_f64, phase);

argumentsObject.localBindings argumentsObject.localBindings {LocalBindingqname: qname, accesses: readWrite, explicit: false, enumerable: false, content: v}

end if

elsif restObject none then

if j arrayLimit then throw a RangeError exception end if;

Evaluate indexWrite(restObject, j, arg, phase) and ignore its result;

note argumentsObject = none because a function can't have both a rest parameter and an arguments object.

j j + 1

elsif argumentsObject none then

Evaluate indexWrite(argumentsObject, i, arg, phase) and ignore its result

else

throw an ArgumentError exception — more arguments than parameters were supplied, and the called function does not have a ... parameter and is not unchecked.

end if;

i i + 1

end for each;

while i < |parameters| do

parameter: Parameter parameters[i];

default: ObjectOpt parameter.default;

if default = none then

if argumentsObject none then default undefined

else

throw an ArgumentError exception — fewer arguments than parameters were supplied, and the called function does not supply default values for the missing parameters and is not unchecked.

end if

end if;

Evaluate writeSingletonProperty(parameter.var, default, phase) and ignore its result;

i i + 1

end while

end proc;

proc signatureLength(signature: ParameterFrame): Integer

return |signature.parameters|

end proc;

Syntax

Parameters

«empty»

NonemptyParameters

ParameterInit

Parameter ParameterAttributes TypedIdentifier^allowIn

ParameterAttributes

«empty»

| const

ParameterInit

Parameter

| Parameter = AssignmentExpression^allowIn

RestParameter

...

| ... ParameterAttributes Identifier

Result

«empty»

| : TypeExpression^allowIn

Validation

Plain[Parameters]: Boolean;

Plain[Parameters «empty»] = true;

Plain[Parameters NonemptyParameters] = Plain[NonemptyParameters];

ParameterCount[Parameters]: Integer;

ParameterCount[Parameters «empty»] = 0;

ParameterCount[Parameters NonemptyParameters] = ParameterCount[NonemptyParameters];

Validate[Parameters] (cxt: Context, env: Environment, compileFrame: ParameterFrame) propagates the call to Validate to nonterminals in the expansion of Parameters.

Plain[NonemptyParameters]: Boolean;

Plain[NonemptyParameters ParameterInit] = Plain[ParameterInit];

Plain[NonemptyParameters₀ ParameterInit , NonemptyParameters₁] = Plain[ParameterInit] and Plain[NonemptyParameters₁];

Plain[NonemptyParameters RestParameter] = false;

ParameterCount[NonemptyParameters]: Integer;

ParameterCount[NonemptyParameters ParameterInit] = 1;

ParameterCount[NonemptyParameters₀ ParameterInit , NonemptyParameters₁] = 1 + ParameterCount[NonemptyParameters₁];

ParameterCount[NonemptyParameters RestParameter] = 0;

Validate[NonemptyParameters] (cxt: Context, env: Environment, compileFrame: ParameterFrame) propagates the call to Validate to nonterminals in the expansion of NonemptyParameters.

Name[Parameter ParameterAttributes TypedIdentifier^allowIn]: String = Name[TypedIdentifier^allowIn];

Plain[Parameter ParameterAttributes TypedIdentifier^allowIn]: Boolean = Plain[TypedIdentifier^allowIn] and not HasConst[ParameterAttributes];

CompileVar[Parameter]: DynamicVar Variable;

proc Validate[Parameter ParameterAttributes TypedIdentifier^allowIn] (cxt: Context, env: Environment, compileFrame: ParameterFrame LocalFrame)

Evaluate Validate[TypedIdentifier^allowIn](cxt, env) and ignore its result;

immutable: Boolean HasConst[ParameterAttributes];

name: String Name[TypedIdentifier^allowIn];

v: DynamicVar Variable;

if compileFrame ParameterFrame and compileFrame.kind = uncheckedFunction then

note not immutable;

v defineHoistedVar(env, name, undefined)

else

v new Variablevalue: none, immutable: immutable, setup: none, initializer: none;

Evaluate defineSingletonProperty(env, name, {public}, none, false, readWrite, v) and ignore its result

end if;

CompileVar[Parameter] v

end proc;

HasConst[ParameterAttributes]: Boolean;

HasConst[ParameterAttributes «empty»] = false;

HasConst[ParameterAttributes const] = true;

Plain[ParameterInit]: Boolean;

Plain[ParameterInit Parameter] = Plain[Parameter];

Plain[ParameterInit Parameter = AssignmentExpression^allowIn] = false;

proc Validate[ParameterInit] (cxt: Context, env: Environment, compileFrame: ParameterFrame)

[ParameterInit Parameter] do

Evaluate Validate[Parameter](cxt, env, compileFrame) and ignore its result;

[ParameterInit Parameter = AssignmentExpression^allowIn] do

Evaluate Validate[Parameter](cxt, env, compileFrame) and ignore its result;

Evaluate Validate[AssignmentExpression^allowIn](cxt, env) and ignore its result

end proc;

proc Validate[RestParameter] (cxt: Context, env: Environment, compileFrame: ParameterFrame)

[RestParameter ...] do

note compileFrame.kind uncheckedFunction;

v: Variable new Variabletype: Array, value: none, immutable: true, setup: none, initializer: none;

compileFrame.rest v;

[RestParameter ... ParameterAttributes Identifier] do

note compileFrame.kind uncheckedFunction;

v: Variable new Variabletype: Array, value: none, immutable: HasConst[ParameterAttributes], setup: none, initializer: none;

compileFrame.rest v;

name: String Name[Identifier];

Evaluate defineSingletonProperty(env, name, {public}, none, false, readWrite, v) and ignore its result

end proc;

Plain[Result]: Boolean;

Plain[Result «empty»] = true;

Plain[Result : TypeExpression^allowIn] = false;

Validate[Result] (cxt: Context, env: Environment) propagates the call to Validate to nonterminals in the expansion of Result.

Setup

Setup[Parameters] (compileEnv: Environment, compileFrame: ParameterFrame) propagates the call to Setup to nonterminals in the expansion of Parameters.

proc SetupOverride[Parameters] (compileEnv: Environment, compileFrame: ParameterFrame, overriddenSignature: ParameterFrame)

[Parameters «empty»] do

if overriddenSignature.parameters [] or overriddenSignature.rest none then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

[Parameters NonemptyParameters] do

Evaluate SetupOverride[NonemptyParameters](compileEnv, compileFrame, overriddenSignature, overriddenSignature.parameters) and ignore its result

end proc;

proc Setup[NonemptyParameters] (compileEnv: Environment, compileFrame: ParameterFrame)

[NonemptyParameters ParameterInit] do

Evaluate Setup[ParameterInit](compileEnv, compileFrame) and ignore its result;

[NonemptyParameters₀ ParameterInit , NonemptyParameters₁] do

Evaluate Setup[ParameterInit](compileEnv, compileFrame) and ignore its result;

Evaluate Setup[NonemptyParameters₁](compileEnv, compileFrame) and ignore its result;

[NonemptyParameters RestParameter] do nothing

end proc;

proc SetupOverride[NonemptyParameters] (compileEnv: Environment, compileFrame: ParameterFrame, overriddenSignature: ParameterFrame, overriddenParameters: Parameter[])

[NonemptyParameters ParameterInit] do

if overriddenParameters = [] then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

Evaluate SetupOverride[ParameterInit](compileEnv, compileFrame, overriddenParameters[0]) and ignore its result;

if |overriddenParameters| 1 or overriddenSignature.rest none then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

[NonemptyParameters₀ ParameterInit , NonemptyParameters₁] do

if overriddenParameters = [] then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

Evaluate SetupOverride[ParameterInit](compileEnv, compileFrame, overriddenParameters[0]) and ignore its result;

Evaluate SetupOverride[NonemptyParameters₁](compileEnv, compileFrame, overriddenSignature, overriddenParameters[1 ...]) and ignore its result;

[NonemptyParameters RestParameter] do

if overriddenParameters [] then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

overriddenRest: Variable {none} overriddenSignature.rest;

if overriddenRest = none or overriddenRest.type Array then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if

end proc;

proc Setup[Parameter ParameterAttributes TypedIdentifier^allowIn] (compileEnv: Environment, compileFrame: ParameterFrame LocalFrame, default: ObjectOpt)

if compileFrame ParameterFrame and default = none and (some p2 compileFrame.parameters satisfies p2.default none) then

throw a SyntaxError exception — a required parameter cannot follow an optional one

end if;

v: DynamicVar Variable CompileVar[Parameter];

case v of

DynamicVar do nothing;

Variable do

type: ClassOpt SetupAndEval[TypedIdentifier^allowIn](compileEnv);

if type = none then type Object end if;

v.type type

end case;

if compileFrame ParameterFrame then

p: Parameter Parametervar: v, default: default;

compileFrame.parameters compileFrame.parameters [p]

end if

end proc;

proc SetupOverride[Parameter ParameterAttributes TypedIdentifier^allowIn] (compileEnv: Environment, compileFrame: ParameterFrame, default: ObjectOpt, overriddenParameter: Parameter)

newDefault: ObjectOpt default;

if newDefault = none then newDefault overriddenParameter.default end if;

if default = none and (some p2 compileFrame.parameters satisfies p2.default none) then

throw a SyntaxError exception — a required parameter cannot follow an optional one

end if;

v: DynamicVar Variable CompileVar[Parameter];

note v DynamicVar;

type: ClassOpt SetupAndEval[TypedIdentifier^allowIn](compileEnv);

if type = none then type Object end if;

if type overriddenParameter.var.type then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

v.type type;

p: Parameter Parametervar: v, default: newDefault;

compileFrame.parameters compileFrame.parameters [p]

end proc;

proc Setup[ParameterInit] (compileEnv: Environment, compileFrame: ParameterFrame)

[ParameterInit Parameter] do

Evaluate Setup[Parameter](compileEnv, compileFrame, none) and ignore its result;

[ParameterInit Parameter = AssignmentExpression^allowIn] do

Evaluate Setup[AssignmentExpression^allowIn]() and ignore its result;

default: Object readReference(Eval[AssignmentExpression^allowIn](compileEnv, compile), compile);

Evaluate Setup[Parameter](compileEnv, compileFrame, default) and ignore its result

end proc;

proc SetupOverride[ParameterInit] (compileEnv: Environment, compileFrame: ParameterFrame, overriddenParameter: Parameter)

[ParameterInit Parameter] do

Evaluate SetupOverride[Parameter](compileEnv, compileFrame, none, overriddenParameter) and ignore its result;

[ParameterInit Parameter = AssignmentExpression^allowIn] do

Evaluate Setup[AssignmentExpression^allowIn]() and ignore its result;

default: Object readReference(Eval[AssignmentExpression^allowIn](compileEnv, compile), compile);

Evaluate SetupOverride[Parameter](compileEnv, compileFrame, default, overriddenParameter) and ignore its result

end proc;

proc Setup[Result] (compileEnv: Environment, compileFrame: ParameterFrame)

[Result «empty»] do

defaultReturnType: Class Object;

if cannotReturnValue(compileFrame) then defaultReturnType Void end if;

compileFrame.returnType defaultReturnType;

[Result : TypeExpression^allowIn] do

if cannotReturnValue(compileFrame) then

throw a SyntaxError exception — a setter or constructor cannot define a return type

end if;

compileFrame.returnType SetupAndEval[TypeExpression^allowIn](compileEnv)

end proc;

proc SetupOverride[Result] (compileEnv: Environment, compileFrame: ParameterFrame, overriddenSignature: ParameterFrame)

[Result «empty»] do compileFrame.returnType overriddenSignature.returnType;

[Result : TypeExpression^allowIn] do

t: Class SetupAndEval[TypeExpression^allowIn](compileEnv);

if overriddenSignature.returnType t then

throw a DefinitionError exception — mismatch with the overridden method’s signature

end if;

compileFrame.returnType t

end proc;

Class Definition

Syntax

ClassDefinition class Identifier Inheritance Block

Inheritance

«empty»

| extends TypeExpression^allowIn

Validation

Class[ClassDefinition]: Class;

proc Validate[ClassDefinition class Identifier Inheritance Block] (cxt: Context, env: Environment, preinst: Boolean, attr: AttributeOptNotFalse)

if not preinst then

throw a SyntaxError exception — a class may be defined only in a preinstantiated scope

end if;

super: Class Validate[Inheritance](cxt, env);

if not super.complete then

throw a ConstantError exception — cannot override a class before its definition has been compiled

end if;

if super.final then throw a DefinitionError exception — can’t override a final class

end if;

a: CompoundAttribute toCompoundAttribute(attr);

if a.prototype then

throw an AttributeError exception — a class definition cannot have the prototype attribute

end if;

final: Boolean;

case a.category of

{none} do final false;

{static} do

if env[0] Class then

throw an AttributeError exception — non-class property definitions cannot have a static attribute

end if;

final false;

{final} do final true;

{virtual} do

throw an AttributeError exception — a class definition cannot have the virtual attribute

end case;

privateNamespace: Namespace new Namespacename: “private”;

dynamic: Boolean a.dynamic or (super.dynamic and super Object);

c: Class new ClasslocalBindings: {}, instanceProperties: {}, super: super, prototype: super.prototype, complete: false, name: Name[Identifier], typeofString: “object”, privateNamespace: privateNamespace, dynamic: dynamic, final: final, defaultValue: null, defaultHint: hintNumber, hasProperty: super.hasProperty, bracketRead: super.bracketRead, bracketWrite: super.bracketWrite, bracketDelete: super.bracketDelete, read: super.read, write: super.write, delete: super.delete, enumerate: super.enumerate, call: ordinaryCall, construct: ordinaryConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

Class[ClassDefinition] c;

v: Variable new Variabletype: Class, value: c, immutable: true, setup: none, initializer: none;

Evaluate defineSingletonProperty(env, Name[Identifier], a.namespaces, a.overrideMod, a.explicit, readWrite, v) and ignore its result;

innerCxt: Context new Contextstrict: cxt.strict, openNamespaces: cxt.openNamespaces {privateNamespace};

Evaluate ValidateUsingFrame[Block](innerCxt, env, JumpTargetsbreakTargets: {}, continueTargets: {}, preinst, c) and ignore its result;

if c.init = none then c.init super.init end if;

c.complete true

end proc;

proc Validate[Inheritance] (cxt: Context, env: Environment): Class

[Inheritance «empty»] do return Object;

[Inheritance extends TypeExpression^allowIn] do

Evaluate Validate[TypeExpression^allowIn](cxt, env) and ignore its result;

return SetupAndEval[TypeExpression^allowIn](env)

end proc;

Setup

proc Setup[ClassDefinition class Identifier Inheritance Block] ()

Evaluate Setup[Block]() and ignore its result

end proc;

Evaluation

proc Eval[ClassDefinition class Identifier Inheritance Block] (env: Environment, d: Object): Object

c: Class Class[ClassDefinition];

return EvalUsingFrame[Block](env, c, d)

end proc;

Namespace Definition

Syntax

NamespaceDefinition namespace Identifier

Validation

proc Validate[NamespaceDefinition namespace Identifier] (cxt: Context, env: Environment, preinst: Boolean, attr: AttributeOptNotFalse)

if not preinst then

throw a SyntaxError exception — a namespace may be defined only in a preinstantiated scope

end if;

a: CompoundAttribute toCompoundAttribute(attr);

if a.dynamic then

throw an AttributeError exception — a namespace definition cannot have the dynamic attribute

end if;

if a.prototype then

throw an AttributeError exception — a namespace definition cannot have the prototype attribute

end if;

case a.category of

{none} do nothing;

{static} do

if env[0] Class then

throw an AttributeError exception — non-class property definitions cannot have a static attribute

end if;

{virtual, final} do

throw an AttributeError exception — a namespace definition cannot have the virtual or final attribute

end case;

name: String Name[Identifier];

ns: Namespace new Namespacename: name;

v: Variable new Variabletype: Namespace, value: ns, immutable: true, setup: none, initializer: none;

Evaluate defineSingletonProperty(env, name, a.namespaces, a.overrideMod, a.explicit, readWrite, v) and ignore its result

end proc;

Programs

Syntax

Program

Directives

| PackageDefinition Program

Processing

Process[Program]: Object;

Process[Program Directives]

begin

cxt: Context new Contextstrict: false, openNamespaces: {public, internal};

initialEnvironment: Environment [createGlobalObject()];

Evaluate Validate[Directives](cxt, initialEnvironment, JumpTargetsbreakTargets: {}, continueTargets: {}, true, none) and ignore its result;

Evaluate Setup[Directives]() and ignore its result;

return Eval[Directives](initialEnvironment, undefined)

end;

Process[Program₀ PackageDefinition Program₁]

begin

Evaluate Process[PackageDefinition] and ignore its result;

return Process[Program₁]

end;

Package Definition

Syntax

PackageDefinition package PackageNameOpt Block

PackageNameOpt

«empty»

| PackageName

PackageName

String

| PackageIdentifiers

PackageIdentifiers

Identifier

| PackageIdentifiers . Identifier

Processing

Process[PackageDefinition package PackageNameOpt Block]: Void

begin

name: String Name[PackageNameOpt];

cxt: Context new Contextstrict: false, openNamespaces: {public, internal};

globalObject: Package createGlobalObject();

pkgInternal: Namespace new Namespacename: “internal”;

pkg: Package new PackagelocalBindings: {stdExplicitConstBinding(internal::“internal”, Namespace, internal)}, archetype: ObjectPrototype, name: name, initialize: busy, sealed: true, internalNamespace: pkgInternal;

initialEnvironment: Environment [pkg, globalObject];

Evaluate Validate[Block](cxt, initialEnvironment, JumpTargetsbreakTargets: {}, continueTargets: {}, true) and ignore its result;

Evaluate Setup[Block]() and ignore its result;

proc evalPackage()

pkg.initialize busy;

Evaluate Eval[Block](initialEnvironment, undefined) and ignore its result;

pkg.initialize none

end proc;

pkg.initialize evalPackage;

Bind name to package pkg in the system’s list of packages in an implementation-defined manner.

end;

Name[PackageNameOpt]: String;

Name[PackageNameOpt «empty»] = an implementation-supplied name;

Name[PackageNameOpt PackageName] = Name[PackageName];

Name[PackageName]: String;

Name[PackageName String] = Value[String] processed in an implementation-defined manner;

Name[PackageName PackageIdentifiers] = Names[PackageIdentifiers] processed in an implementation-defined manner;

Names[PackageIdentifiers]: String[];

Names[PackageIdentifiers Identifier] = [Name[Identifier]];

Names[PackageIdentifiers₀ PackageIdentifiers₁ . Identifier] = Names[PackageIdentifiers₁] [Name[Identifier]];

packageDatabase: Package{} {};

Predefined Identifiers

proc createGlobalObject(): Package

return new PackagelocalBindings: {
stdExplicitConstBinding(internal::“internal”, Namespace, internal),
stdConstBinding(public::“explicit”, Attribute, global_explicit),
stdConstBinding(public::“enumerable”, Attribute, global_enumerable),
stdConstBinding(public::“dynamic”, Attribute, global_dynamic),
stdConstBinding(public::“static”, Attribute, global_static),
stdConstBinding(public::“virtual”, Attribute, global_virtual),
stdConstBinding(public::“final”, Attribute, global_final),
stdConstBinding(public::“prototype”, Attribute, global_prototype),
stdConstBinding(public::“unused”, Attribute, global_unused),
stdFunction(public::“override”, global_override, 1),
stdConstBinding(public::“NaN”, Number, NaN_f64),
stdConstBinding(public::“Infinity”, Number, +_f64),
stdConstBinding(public::“fNaN”, float, NaN_f32),
stdConstBinding(public::“fInfinity”, float, +_f32),
stdConstBinding(public::“undefined”, Void, undefined),
stdFunction(public::“eval”, global_eval, 1),
stdFunction(public::“parseInt”, global_parseint, 2),
stdFunction(public::“parseLong”, global_parselong, 2),
stdFunction(public::“parseFloat”, global_parsefloat, 1),
stdFunction(public::“isNaN”, global_isnan, 1),
stdFunction(public::“isFinite”, global_isfinite, 1),
stdFunction(public::“decodeURI”, global_decodeuri, 1),
stdFunction(public::“decodeURIComponent”, global_decodeuricomponent, 1),
stdFunction(public::“encodeURI”, global_encodeuri, 1),
stdFunction(public::“encodeURIComponent”, global_encodeuricomponent, 1),
stdConstBinding(public::“Object”, Class, Object),
stdConstBinding(public::“Never”, Class, Never),
stdConstBinding(public::“Void”, Class, Void),
stdConstBinding(public::“Null”, Class, Null),
stdConstBinding(public::“Boolean”, Class, Boolean),
stdConstBinding(public::“GeneralNumber”, Class, GeneralNumber),
stdConstBinding(public::“long”, Class, long),
stdConstBinding(public::“ulong”, Class, ulong),
stdConstBinding(public::“float”, Class, float),
stdConstBinding(public::“Number”, Class, Number),
stdConstBinding(public::“sbyte”, Class, sbyte),
stdConstBinding(public::“byte”, Class, byte),
stdConstBinding(public::“short”, Class, short),
stdConstBinding(public::“ushort”, Class, ushort),
stdConstBinding(public::“int”, Class, int),
stdConstBinding(public::“uint”, Class, uint),
stdConstBinding(public::“char”, Class, char),
stdConstBinding(public::“String”, Class, String),
stdConstBinding(public::“Array”, Class, Array),
stdConstBinding(public::“Namespace”, Class, Namespace),
stdConstBinding(public::“Attribute”, Class, Attribute),
stdConstBinding(public::“Date”, Class, Date),
stdConstBinding(public::“RegExp”, Class, RegExp),
stdConstBinding(public::“Class”, Class, Class),
stdConstBinding(public::“Function”, Class, Function),
stdConstBinding(public::“PrototypeFunction”, Class, PrototypeFunction),
stdConstBinding(public::“Package”, Class, Package),
stdConstBinding(public::“Error”, Class, Error),
stdConstBinding(public::“ArgumentError”, Class, ArgumentError),
stdConstBinding(public::“AttributeError”, Class, AttributeError),
stdConstBinding(public::“ConstantError”, Class, ConstantError),
stdConstBinding(public::“DefinitionError”, Class, DefinitionError),
stdConstBinding(public::“EvalError”, Class, EvalError),
stdConstBinding(public::“RangeError”, Class, RangeError),
stdConstBinding(public::“ReferenceError”, Class, ReferenceError),
stdConstBinding(public::“SyntaxError”, Class, SyntaxError),
stdConstBinding(public::“TypeError”, Class, TypeError),
stdConstBinding(public::“UninitializedError”, Class, UninitializedError),
stdConstBinding(public::“URIError”, Class, URIError)},
archetype: ObjectPrototype, name: “”, initialize: none, sealed: false, internalNamespace: internal

end proc;

Built-in Namespaces

public: Namespace = new Namespacename: “public”;

internal: Namespace = new Namespacename: “internal”;

Built-in Attributes

global_explicit: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: true, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: false, unused: false;

global_enumerable: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: true, dynamic: false, category: none, overrideMod: none, prototype: false, unused: false;

global_dynamic: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: true, category: none, overrideMod: none, prototype: false, unused: false;

global_static: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: static, overrideMod: none, prototype: false, unused: false;

global_virtual: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: virtual, overrideMod: none, prototype: false, unused: false;

global_final: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: final, overrideMod: none, prototype: false, unused: false;

global_prototype: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: true, unused: false;

global_unused: CompoundAttribute = CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: none, prototype: false, unused: true;

proc global_override(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function does not check phase and therefore can be used in a constant expression.

overrideMod: OverrideModifier;

if args = [] then overrideMod true

elsif |args| = 1 then

arg: Object args[0];

if arg {true, false, undefined} then throw a TypeError exception end if;

overrideMod arg

else throw an ArgumentError exception — too many arguments supplied

end if;

return CompoundAttributenamespaces: {}, explicit: false, enumerable: false, dynamic: false, category: none, overrideMod: overrideMod, prototype: false, unused: false

end proc;

Built-in Functions

proc global_eval(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

proc global_parseint(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if the arguments can be converted to primitives in constant expressions.

if |args| {1, 2} then

throw an ArgumentError exception — at least one and at most two arguments must be supplied

end if;

s: String objectToString(args[0], phase);

radix: Integer objectToInteger(defaultArg(args, 1, +zero_f64), phase);

i: (Integer – {0}) {+zero, –zero, NaN} stringPrefixToInteger(s, radix);

return extendedRationalToFloat64(i)

end proc;

proc stringPrefixToInteger(s: String, radix: Integer): (Integer – {0}) {+zero, –zero, NaN}

r: Integer radix;

if r {0, 2 ... 36} then throw a RangeError exception — radix out of range end if;

i: Integer 0;

while i < |s| and the nonterminal WhiteSpaceOrLineTerminatorChar can expand into [s[i]] do

i i + 1

end while;

sign: {–1, 1} 1;

if i < |s| then

if s[i] = ‘+’ then i i + 1 elsif s[i] = ‘-’ then sign –1; i i + 1 end if

end if;

if r {0, 16} and i + 2 |s| and s[i ... i + 1] {“0x”, “0X”} then

r 16;

i i + 2

end if;

if r = 0 then r 10 end if;

n: Integer 0;

start: Integer i;

digit: IntegerOpt 0;

while i < |s| and digit none do

ch: Char16 s[i];

if ch {‘0’ ... ‘9’} then digit char16ToInteger(ch) – char16ToInteger(‘0’)

elsif ch {‘A’ ... ‘Z’} then

digit char16ToInteger(ch) – char16ToInteger(‘A’) + 10

elsif ch {‘a’ ... ‘z’} then

digit char16ToInteger(ch) – char16ToInteger(‘a’) + 10

else digit none

end if;

if digit none and digit r then digit none end if;

if digit none then n nr + digit; i i + 1 end if

end while;

if i = start then return NaN end if;

if n 0 then return nsign

elsif sign > 0 then return +zero

else return –zero

end if

end proc;

proc global_parselong(this: Object, f: SimpleInstance, args: Object[], phase: Phase): GeneralNumber

note This function can be used in a constant expression if the arguments can be converted to primitives in constant expressions.

if |args| {1, 2} then

throw an ArgumentError exception — at least one and at most two arguments must be supplied

end if;

s: String objectToString(args[0], phase);

radix: Integer objectToInteger(defaultArg(args, 1, +zero_f64), phase);

i: (Integer – {0}) {+zero, –zero, NaN} stringPrefixToInteger(s, radix);

case i of

{+zero, –zero} do return 0_long;

Integer do return integerToLong(i);

{NaN} do return NaN_f64

end case

end proc;

proc global_parsefloat(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if its argument can be converted to a primitive in a constant expression.

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

s: String objectToString(args[0], phase);

Apply the lexer grammar with the start symbol StringDecimalLiteral to the string s. If the grammar can interpret neither s nor any prefix of s as an expansion of StringDecimalLiteral, then return NaN_f64. Otherwise, let p be the longest prefix of s (possibly s itself) such that p is an expansion of StringDecimalLiteral.

q: ExtendedRational the value of the action Lex applied to p’s expansion of the nonterminal StringDecimalLiteral;

return extendedRationalToFloat64(q)

end proc;

proc global_isnan(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Boolean

note This function can be used in a constant expression if its argument can be converted to a primitive in a constant expression.

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

x: GeneralNumber objectToGeneralNumber(args[0], phase);

return x {NaN_f32, NaN_f64}

end proc;

proc global_isfinite(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Boolean

note This function can be used in a constant expression if its argument can be converted to a primitive in a constant expression.

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

x: GeneralNumber objectToGeneralNumber(args[0], phase);

return x {NaN_f32, NaN_f64, +_f32, +_f64, –_f32, –_f64}

end proc;

proc global_decodeuri(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

proc global_decodeuricomponent(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

proc global_encodeuri(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

proc global_encodeuricomponent(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

Built-in Classes

proc dummyCall(this: Object, c: Class, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

proc dummyConstruct(c: Class, args: Object[], phase: Phase): Object

Evaluate ???? and ignore its result

end proc;

prototypesSealed: Boolean = false;

Object

Object: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: none, prototype: ObjectPrototype, complete: true, name: “Object”, typeofString: “object”, dynamic: true, final: false, defaultValue: undefined, defaultHint: hintNumber, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: callObject, construct: constructObject, init: none, is: ordinaryIs, coerce: coerceObject;

proc callObject(this: Object, c: Class, args: Object[], phase: Phase): Object

note This function does not check phase and therefore can be used in a constant expression.

if |args| = 0 then return undefined

elsif |args| = 1 then return args[0]

else throw an ArgumentError exception — at most one argument can be supplied

end if

end proc;

proc constructObject(c: Class, args: Object[], phase: Phase): Object

note This function does not check phase and therefore can be used in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

o: Object defaultArg(args, 0, undefined);

if o {null, undefined} then

return createSimpleInstance(Object, ObjectPrototype, none, none, none)

else return o

end if

end proc;

proc coerceObject(o: Object, c: Class): ObjectOpt

return o

end proc;

ObjectPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Object),
stdFunction(public::“toString”, Object_toString, 0),
stdFunction(public::“toLocaleString”, Object_toLocaleString, 0),
stdFunction(public::“valueOf”, Object_valueOf, 0),
stdFunction(public::“hasOwnProperty”, Object_hasOwnProperty, 1),
stdFunction(public::“isPrototypeOf”, Object_isPrototypeOf, 1),
stdFunction(public::“propertyIsEnumerable”, Object_propertyIsEnumerable, 1),
stdFunction(public::“sealProperty”, Object_sealProperty, 1)},
archetype: none, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Object_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function does not check phase and therefore can be used in a constant expression.

note This function ignores any arguments passed to it in args.

c: Class objectType(this);

return “[object ” c.name “]”

end proc;

proc Object_toLocaleString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — toLocaleString cannot be called from a constant expression

end if;

toStringMethod: Object dotRead(this, {public::“toString”}, phase);

return call(this, toStringMethod, args, phase)

end proc;

proc Object_valueOf(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function does not check phase and therefore can be used in a constant expression.

note This function ignores any arguments passed to it in args.

return this

end proc;

proc Object_hasOwnProperty(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Boolean

if phase = compile then

throw a ConstantError exception — hasOwnProperty cannot be called from a constant expression

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

return hasProperty(this, args[0], true, phase)

end proc;

proc Object_isPrototypeOf(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Boolean

if phase = compile then

throw a ConstantError exception — isPrototypeOf cannot be called from a constant expression

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

o: Object args[0];

return this archetypes(o)

end proc;

proc Object_propertyIsEnumerable(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Boolean

if phase = compile then

throw a ConstantError exception — propertyIsEnumerable cannot be called from a constant expression

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

qname: QualifiedName objectToQualifiedName(args[0], phase);

c: Class objectType(this);

mBase: InstancePropertyOpt findBaseInstanceProperty(c, {qname}, read);

if mBase none then

m: InstanceProperty getDerivedInstanceProperty(c, mBase, read);

if m.enumerable then return true end if

end if;

mBase findBaseInstanceProperty(c, {qname}, write);

if mBase none then

m: InstanceProperty getDerivedInstanceProperty(c, mBase, write);

if m.enumerable then return true end if

end if;

if this BindingObject then return false end if;

return some b this.localBindings satisfies b.qname = qname and b.enumerable

end proc;

proc Object_sealProperty(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Undefined

if phase = compile then

throw a ConstantError exception — sealProperty cannot be called from a constant expression

end if;

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, true);

if arg = false then Evaluate sealObject(this) and ignore its result

elsif arg = true then

Evaluate sealObject(this) and ignore its result;

Evaluate sealAllLocalProperties(this) and ignore its result

elsif arg Char16 String then

if not hasProperty(this, arg, true, phase) then

throw a ReferenceError exception — property not found

end if;

qname: QualifiedName objectToQualifiedName(arg, phase);

Evaluate sealLocalProperty(this, qname) and ignore its result

end if;

return undefined

end proc;

Never

Never: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: none, complete: true, name: “Never”, typeofString: “”, dynamic: false, final: true, defaultValue: none, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructNever, init: none, is: ordinaryIs, coerce: coerceNever;

proc constructNever(c: Class, args: Object[], phase: Phase): Object

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

throw a TypeError exception — no coercions to Never are possible

end proc;

proc coerceNever(o: Object, c: Class): {none}

return none

end proc;

Void

Void: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: none, complete: true, name: “Void”, typeofString: “undefined”, dynamic: false, final: true, defaultValue: undefined, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: callVoid, construct: constructVoid, init: none, is: ordinaryIs, coerce: coerceVoid;

proc callVoid(this: Object, c: Class, args: Object[], phase: Phase): Undefined

note This function does not check phase and therefore can be used in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

return undefined

end proc;

proc constructVoid(c: Class, args: Object[], phase: Phase): Undefined

note This function does not check phase and therefore can be used in a constant expression.

if |args| 0 then throw an ArgumentError exception — no arguments can be supplied

end if;

return undefined

end proc;

proc coerceVoid(o: Object, c: Class): {undefined, none}

if o Null Undefined then return undefined else return none end if

end proc;

Null

Null: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: none, complete: true, name: “Null”, typeofString: “object”, dynamic: false, final: true, defaultValue: null, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: callNull, construct: constructNull, init: none, is: ordinaryIs, coerce: coerceNull;

proc callNull(this: Object, c: Class, args: Object[], phase: Phase): Null

note This function does not check phase and therefore can be used in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

return null

end proc;

proc constructNull(c: Class, args: Object[], phase: Phase): Null

note This function does not check phase and therefore can be used in a constant expression.

if |args| 0 then throw an ArgumentError exception — no arguments can be supplied

end if;

return null

end proc;

proc coerceNull(o: Object, c: Class): {null, none}

if o = null then return o else return none end if

end proc;

Boolean

Boolean: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: BooleanPrototype, complete: true, name: “Boolean”, typeofString: “boolean”, dynamic: false, final: true, defaultValue: false, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructBoolean, init: none, is: ordinaryIs, coerce: coerceBoolean;

proc constructBoolean(c: Class, args: Object[], phase: Phase): Boolean

note This function does not check phase and therefore can be used in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

return objectToBoolean(defaultArg(args, 0, false))

end proc;

proc coerceBoolean(o: Object, c: Class): BooleanOpt

if o Boolean then return o else return none end if

end proc;

BooleanPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Boolean),
stdFunction(public::“toString”, Boolean_toString, 0),
stdReserve(public::“valueOf”, ObjectPrototype)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Boolean_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression.

note This function ignores any arguments passed to it in args.

a: Boolean objectToBoolean(this);

return objectToString(a, phase)

end proc;

GeneralNumber

GeneralNumber: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: GeneralNumberPrototype, complete: true, name: “GeneralNumber”, typeofString: “object”, dynamic: false, final: true, defaultValue: NaN_f64, defaultHint: hintNumber, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructGeneralNumber, init: none, is: ordinaryIs, coerce: coerceGeneralNumber;

proc constructGeneralNumber(c: Class, args: Object[], phase: Phase): GeneralNumber

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| = 0 then return +zero_f64

elsif |args| = 1 then return objectToGeneralNumber(args[0], phase)

else throw an ArgumentError exception — at most one argument can be supplied

end if

end proc;

proc coerceGeneralNumber(o: Object, c: Class): GeneralNumber {none}

if o GeneralNumber then return o else return none end if

end proc;

GeneralNumberPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, GeneralNumber),
stdFunction(public::“toString”, GeneralNumber_toString, 1),
stdReserve(public::“valueOf”, ObjectPrototype),
stdFunction(public::“toFixed”, GeneralNumber_toFixed, 1),
stdFunction(public::“toExponential”, GeneralNumber_toExponential, 1),
stdFunction(public::“toPrecision”, GeneralNumber_toPrecision, 1)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc GeneralNumber_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a general number.

x: GeneralNumber objectToGeneralNumber(this, phase);

radix: Integer objectToInteger(defaultArg(args, 0, 10_f64), phase);

if radix < 2 or radix > 36 then throw a RangeError exception — bad radix end if;

if radix = 10 then return generalNumberToString(x)

else

return x converted to a string containing a base-radix number in an implementation-defined manner

end if

end proc;

precisionLimit: Integer = an implementation-defined integer not less than 20;

proc GeneralNumber_toFixed(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a general number.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

x: GeneralNumber objectToGeneralNumber(this, phase);

fractionDigits: Integer objectToInteger(defaultArg(args, 0, +zero_f64), phase);

if fractionDigits < 0 or fractionDigits > precisionLimit then

throw a RangeError exception

end if;

if x FiniteGeneralNumber then return generalNumberToString(x) end if;

r: Rational toRational(x);

if |r| 10²¹ then return generalNumberToString(x) end if;

sign: String “”;

if r < 0 then sign “-”; r –r end if;

n: Integer r10^{fractionDigits} + 1/2;

digits: String integerToString(n);

if fractionDigits = 0 then return sign digits

else

if |digits| fractionDigits then

digits repeat(‘0’, fractionDigits + 1 – |digits|) digits

end if;

k: Integer |digits| – fractionDigits;

return sign digits[0 ... k – 1] “.” digits[k ...]

end if

end proc;

proc GeneralNumber_toExponential(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a general number.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

x: GeneralNumber objectToGeneralNumber(this, phase);

fractionDigits: ExtendedInteger objectToExtendedInteger(defaultArg(args, 0, NaN_f64), phase);

if fractionDigits {+, –} or (fractionDigits NaN and (fractionDigits < 0 or fractionDigits > precisionLimit)) then

throw a RangeError exception

end if;

if x FiniteGeneralNumber then return generalNumberToString(x) end if;

r: Rational toRational(x);

sign: String “”;

if r < 0 then sign “-”; r –r end if;

digits: String;

e: Integer;

if fractionDigits NaN then

if r = 0 then digits repeat(‘0’, fractionDigits + 1); e 0

else

e log₁₀(r);

n: Integer r10^{fractionDigits–e} + 1/2;

note At this point 10^{fractionDigits} n 10^{fractionDigits+1}

if n = 10^{fractionDigits+1} then n n/10; e e + 1 end if;

digits integerToString(n)

end if;

note At this point the string digits has exactly fractionDigits + 1 digits

elsif r = 0 then digits “0”; e 0

elsif x Long ULong then

digits integerToString(r);

e |digits| – 1;

while digits[|digits| – 1] = ‘0’ do digits digits[0 ... |digits| – 2] end while

else

k: Integer;

s: Integer;

case x of

NonzeroFiniteFloat32 do

Let e, k, and s be integers such that k 1, 10^k–1 s 10^k, (s10^e+1–k)_f32 = x, and k is as small as possible.

NonzeroFiniteFloat64 do

Let e, k, and s be integers such that k 1, 10^k–1 s 10^k, (s10^e+1–k)_f64 = x, and k is as small as possible.

end case;

note k is the number of digits in the decimal representation of s, s is not divisible by 10, and the least significant digit of s is not necessarily uniquely determined by the above criteria.

When there are multiple possibilities for s according to the rules above, implementations are encouraged but not required to select the one according to the following rules: Select the value of s for which s10^e+1–k is closest in value to r; if there are two such possible values of s, choose the one that is even.

digits integerToString(s)

end if;

return sign exponentialNotationString(digits, e)

end proc;

proc GeneralNumber_toPrecision(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a general number.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

x: GeneralNumber objectToGeneralNumber(this, phase);

precision: ExtendedInteger objectToExtendedInteger(defaultArg(args, 0, NaN_f64), phase);

if precision = NaN then return generalNumberToString(x) end if;

if precision {+, –} or precision < 1 or precision > precisionLimit + 1 then

throw a RangeError exception

end if;

if x FiniteGeneralNumber then return generalNumberToString(x) end if;

r: Rational toRational(x);

sign: String “”;

if r < 0 then sign “-”; r –r end if;

digits: String;

e: Integer;

if r = 0 then digits repeat(‘0’, precision); e 0

else

e log₁₀(r);

n: Integer r10^{precision–1–e} + 1/2;

note At this point 10^{precision–1} n 10^precision

if n = 10^precision then n n/10; e e + 1 end if;

digits integerToString(n)

end if;

note At this point the string digits has exactly precision digits

if e < –6 or e precision then return sign exponentialNotationString(digits, e)

elsif e = precision – 1 then return sign digits

elsif e 0 then return sign digits[0 ... e] “.” digits[e + 1 ...]

else return sign “0.” repeat(‘0’, –(e + 1)) digits

end if

end proc;

long

long: Class = new ClasslocalBindings: {
stdConstBinding(public::“MAX_VALUE”, ulong, (2⁶³ – 1)_long),
stdConstBinding(public::“MIN_VALUE”, ulong, (–2⁶³)_long)},
instanceProperties: {}, super: GeneralNumber, prototype: longPrototype, complete: true, name: “long”, typeofString: “long”, dynamic: false, final: true, defaultValue: 0_long, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructLong, init: none, is: ordinaryIs, coerce: coerceLong;

proc constructLong(c: Class, args: Object[], phase: Phase): Long

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, +zero_f64);

i: Integer objectToInteger(arg, phase);

if –2⁶³ i 2⁶³ – 1 then return i_long

else throw a RangeError exception — i is out of the Long range

end if

end proc;

proc coerceLong(o: Object, c: Class): Long {none}

if o GeneralNumber then return none end if;

i: IntegerOpt checkInteger(o);

if i none and –2⁶³ i 2⁶³ – 1 then return i_long

else throw a RangeError exception — i is out of the Long range

end if

end proc;

longPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, long),
stdReserve(public::“toString”, GeneralNumberPrototype),
stdReserve(public::“valueOf”, GeneralNumberPrototype)},
archetype: GeneralNumberPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

ulong

ulong: Class = new ClasslocalBindings: {
stdConstBinding(public::“MAX_VALUE”, ulong, (2⁶⁴ – 1)_ulong),
stdConstBinding(public::“MIN_VALUE”, ulong, 0_ulong)},
instanceProperties: {}, super: GeneralNumber, prototype: ulongPrototype, complete: true, name: “ulong”, typeofString: “ulong”, dynamic: false, final: true, defaultValue: 0_ulong, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructULong, init: none, is: ordinaryIs, coerce: coerceULong;

proc constructULong(c: Class, args: Object[], phase: Phase): ULong

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, +zero_f64);

i: Integer objectToInteger(arg, phase);

if 0 i 2⁶⁴ – 1 then return i_ulong

else throw a RangeError exception — i is out of the ULong range

end if

end proc;

proc coerceULong(o: Object, c: Class): ULong {none}

if o GeneralNumber then return none end if;

i: IntegerOpt checkInteger(o);

if i none and 0 i 2⁶⁴ – 1 then return i_ulong

else throw a RangeError exception — i is out of the ULong range

end if

end proc;

ulongPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, ulong),
stdReserve(public::“toString”, GeneralNumberPrototype),
stdReserve(public::“valueOf”, GeneralNumberPrototype)},
archetype: GeneralNumberPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

float

float: Class = new ClasslocalBindings: {
stdConstBinding(public::“MAX_VALUE”, float, (3.402823510³⁸)_f32),
stdConstBinding(public::“MIN_VALUE”, float, (10^–45)_f32),
stdConstBinding(public::“NaN”, float, NaN_f32),
stdConstBinding(public::“NEGATIVE_INFINITY”, float, –_f32),
stdConstBinding(public::“POSITIVE_INFINITY”, float, +_f32)},
instanceProperties: {}, super: GeneralNumber, prototype: floatPrototype, complete: true, name: “float”, typeofString: “float”, dynamic: false, final: true, defaultValue: NaN_f32, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructFloat, init: none, is: ordinaryIs, coerce: coerceFloat;

proc constructFloat(c: Class, args: Object[], phase: Phase): Float32

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| = 0 then return +zero_f32

elsif |args| = 1 then return objectToFloat32(args[0], phase)

else throw an ArgumentError exception — at most one argument can be supplied

end if

end proc;

proc coerceFloat(o: Object, c: Class): Float32 {none}

if o GeneralNumber then return toFloat32(o) else return none end if

end proc;

floatPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, float),
stdReserve(public::“toString”, GeneralNumberPrototype),
stdReserve(public::“valueOf”, GeneralNumberPrototype)},
archetype: GeneralNumberPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

Number

Number: Class = new ClasslocalBindings: {
stdConstBinding(public::“MAX_VALUE”, Number, (1.797693134862315710³⁰⁸)_f64),
stdConstBinding(public::“MIN_VALUE”, Number, (510^–324)_f64),
stdConstBinding(public::“NaN”, Number, NaN_f64),
stdConstBinding(public::“NEGATIVE_INFINITY”, Number, –_f64),
stdConstBinding(public::“POSITIVE_INFINITY”, Number, +_f64)},
instanceProperties: {}, super: GeneralNumber, prototype: NumberPrototype, complete: true, name: “Number”, typeofString: “number”, dynamic: false, final: true, defaultValue: NaN_f64, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructNumber, init: none, is: ordinaryIs, coerce: coerceNumber;

proc constructNumber(c: Class, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| = 0 then return +zero_f64

elsif |args| = 1 then return objectToFloat64(args[0], phase)

else throw an ArgumentError exception — at most one argument can be supplied

end if

end proc;

proc coerceNumber(o: Object, c: Class): Float64 {none}

if o GeneralNumber then return toFloat64(o) else return none end if

end proc;

NumberPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Number),
stdReserve(public::“toString”, GeneralNumberPrototype),
stdReserve(public::“valueOf”, GeneralNumberPrototype)},
archetype: GeneralNumberPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc makeBuiltInIntegerClass(name: String, low: Integer, high: Integer): Class

proc construct(c: Class, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, +zero_f64);

x: Float64 objectToFloat64(arg, phase);

i: IntegerOpt checkInteger(x);

if i none and low i high then

note –zero_f64 is coerced to +zero_f64.

return i_f64

end if;

throw a RangeError exception

end proc;

proc is(o: Object, c: Class): Boolean

if o Float64 then return false end if;

i: IntegerOpt checkInteger(o);

return i none and low i high

end proc;

proc coerce(o: Object, c: Class): Float64 {none}

if o GeneralNumber then return none end if;

i: IntegerOpt checkInteger(o);

if i none and low i high then

note –zero_f32, +zero_f32, and –zero_f64 are all coerced to +zero_f64.

return i_f64

end if;

throw a RangeError exception

end proc;

return new ClasslocalBindings: {
stdConstBinding(public::“MAX_VALUE”, Number, high_f64),
stdConstBinding(public::“MIN_VALUE”, Number, low_f64)},
instanceProperties: {}, super: Number, prototype: Number.prototype, complete: true, name: name, typeofString: “number”, dynamic: false, final: true, defaultValue: +zero_f64, hasProperty: Number.hasProperty, bracketRead: Number.bracketRead, bracketWrite: Number.bracketWrite, bracketDelete: Number.bracketDelete, read: Number.read, write: Number.write, delete: Number.delete, enumerate: Number.enumerate, call: sameAsConstruct, construct: construct, init: none, is: is, coerce: coerce

end proc;

sbyte: Class = makeBuiltInIntegerClass(“sbyte”, –128, 127);

byte: Class = makeBuiltInIntegerClass(“byte”, 0, 255);

short: Class = makeBuiltInIntegerClass(“short”, –32768, 32767);

ushort: Class = makeBuiltInIntegerClass(“ushort”, 0, 65535);

int: Class = makeBuiltInIntegerClass(“int”, –2147483648, 2147483647);

uint: Class = makeBuiltInIntegerClass(“uint”, 0, 4294967295);

char

char: Class = new ClasslocalBindings: {stdFunction(public::“fromCharCode”, char_fromCharCode, 1)}, instanceProperties: {}, super: Object, prototype: charPrototype, complete: true, name: “char”, typeofString: “char”, dynamic: false, final: true, defaultValue: ‘«NUL»’, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructChar, init: none, is: ordinaryIs, coerce: coerceChar;

proc callChar(this: Object, c: Class, args: Object[], phase: Phase): Char16

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

s: String objectToString(args[0], phase);

if |s| 1 then throw a RangeError exception — only one character may be given end if;

return s[0]

end proc;

proc constructChar(c: Class, args: Object[], phase: Phase): Char16

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, undefined);

if arg = undefined then return ‘«NUL»’

elsif arg Char16 then return arg

else

s: String objectToString(args[0], phase);

if |s| 1 then throw a RangeError exception — only one character may be given

end if;

return s[0]

end if

end proc;

proc coerceChar(o: Object, c: Class): Char16 {none}

if o Char16 then return o else return none end if

end proc;

proc char_fromCharCode(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

i: Integer objectToInteger(args[0], phase);

if 0 i 0xFFFF then return integerToChar16(i)

else throw a RangeError exception — character code out of range

end if

end proc;

charPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, char),
stdReserve(public::“toString”, StringPrototype),
stdReserve(public::“valueOf”, StringPrototype)},
archetype: StringPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

String

String: Class = new ClasslocalBindings: {stdFunction(public::“fromCharCode”, String_fromCharCode, 1)}, instanceProperties: {
new InstanceGettermultiname: {public::“length”}, final: true, enumerable: false, call: String_length},
super: Object, prototype: StringPrototype, complete: true, name: “String”, typeofString: “string”, dynamic: false, final: true, defaultValue: null, hasProperty: stringHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: readString, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: constructString, init: none, is: ordinaryIs, coerce: coerceString;

proc stringHasProperty(o: Object, c: Class, property: Object, flat: Boolean, phase: Phase): Boolean

note o String because stringHasProperty is only called on instances of class String.

qname: QualifiedName objectToQualifiedName(property, phase);

i: IntegerOpt multinameToUnsignedInteger({qname});

if i none then return i < |o|

else

end if

end proc;

proc readString(o: Object, limit: Class, multiname: Multiname, env: EnvironmentOpt, undefinedIfMissing: Boolean, phase: Phase): ObjectOpt

note o String because readString is only called on instances of class String.

if limit = String then

i: IntegerOpt multinameToUnsignedInteger(multiname);

if i none then

if i < |o| then return o[i]

elsif undefinedIfMissing then return undefined

else return none

end if

end if;

return ordinaryRead(o, limit, multiname, env, undefinedIfMissing, phase)

end proc;

proc constructString(c: Class, args: Object[], phase: Phase): String

note This function can be used in a constant expression if the argument can be converted to a primitive in a constant expression.

if |args| = 0 then return “”

elsif |args| = 1 then return objectToString(args[0], phase)

else throw an ArgumentError exception — at most one argument can be supplied

end if

end proc;

proc coerceString(o: Object, c: Class): String Null {none}

if o Null String then return o

elsif o Char16 then return [o]

else return none

end if

end proc;

proc String_length(this: Object, phase: Phase): Object

note this String because this getter cannot be extracted from the String class.

length: Integer |this|;

return length_f64

end proc;

proc String_fromCharCode(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function can be used in a constant expression if the arguments can be converted to primitives in constant expressions.

s: String “”;

for each arg args do

i: Integer objectToInteger(arg, phase);

if 0 i 0x10FFFF then s s integerToUTF16(i)

else throw a RangeError exception — character code out of range

end if

end for each;

return s

end proc;

StringPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, String),
stdFunction(public::“toString”, String_toString, 0),
stdReserve(public::“valueOf”, ObjectPrototype),
stdFunction(public::“charAt”, String_charAt, 1),
stdFunction(public::“charCodeAt”, String_charCodeAt, 1),
stdFunction(public::“concat”, String_concat, 1),
stdFunction(public::“indexOf”, String_indexOf, 1),
stdFunction(public::“lastIndexOf”, String_lastIndexOf, 1),
stdFunction(public::“localeCompare”, String_localeCompare, 1),
stdFunction(public::“match”, String_match, 1),
stdFunction(public::“replace”, String_replace, 1),
stdFunction(public::“search”, String_search, 1),
stdFunction(public::“slice”, String_slice, 2),
stdFunction(public::“split”, String_split, 2),
stdFunction(public::“substring”, String_substring, 2),
stdFunction(public::“toLowerCase”, String_toLowerCase, 0),
stdFunction(public::“toLocaleLowerCase”, String_toLocaleLowerCase, 0),
stdFunction(public::“toUpperCase”, String_toUpperCase, 0),
stdFunction(public::“toLocaleUpperCase”, String_toLocaleUpperCase, 0)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc String_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this can be converted to a primitive in a constant expression.

note This function is generic and can be applied even if this is not a string.

note This function ignores any arguments passed to it in args.

return objectToString(this, phase)

end proc;

proc String_charAt(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

s: String objectToString(this, phase);

position: ExtendedInteger objectToExtendedInteger(defaultArg(args, 0, +zero_f64), phase);

if position = NaN then throw a RangeError exception

elsif position {+, –} and 0 position < |s| then return [s[position]]

else return “”

end if

end proc;

proc String_charCodeAt(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

s: String objectToString(this, phase);

position: ExtendedInteger objectToExtendedInteger(defaultArg(args, 0, +zero_f64), phase);

if position = NaN then throw a RangeError exception

elsif position {+, –} and 0 position < |s| then

return (char16ToInteger(s[position]))_f64

else return NaN_f64

end if

end proc;

proc String_concat(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the argument can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

s: String objectToString(this, phase);

for each arg args do s s objectToString(arg, phase) end for each;

return s

end proc;

proc String_indexOf(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if this and the arguments can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| {1, 2} then

throw an ArgumentError exception — at least one and at most two arguments must be supplied

end if;

s: String objectToString(this, phase);

pattern: String objectToString(args[0], phase);

arg: Object defaultArg(args, 1, +zero_f64);

position: Integer pinExtendedInteger(objectToExtendedInteger(arg, phase), |s|, false);

while position + |pattern| |s| do

if s[position ... position + |pattern| – 1] = pattern then return position_f64

end if;

position position + 1

end while;

return (–1)_f64

end proc;

proc String_lastIndexOf(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function can be used in a constant expression if this and the arguments can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| {1, 2} then

throw an ArgumentError exception — at least one and at most two arguments must be supplied

end if;

s: String objectToString(this, phase);

pattern: String objectToString(args[0], phase);

arg: Object defaultArg(args, 1, +_f64);

position: Integer pinExtendedInteger(objectToExtendedInteger(arg, phase), |s|, false);

if position + |pattern| > |s| then position |s| – |pattern| end if;

while position 0 do

if s[position ... position + |pattern| – 1] = pattern then return position_f64

end if;

position position – 1

end while;

return (–1)_f64

end proc;

proc String_localeCompare(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — localeCompare cannot be called from a constant expression

end if;

if |args| < 1 then

throw an ArgumentError exception — at least one argument must be supplied

end if;

s1: String objectToString(this, phase);

s2: String objectToString(args[0], phase);

Let result: Object be a value of type Number that is the result of a locale-sensitive string comparison of s1 and s2. The two strings are compared in an implementation-defined fashion. The result is intended to order strings in the sort order specified by the system default locale, and will be negative, zero, or positive, depending on whether s1 comes before s2 in the sort order, they are equal, or s1 comes after s2 in the sort order, respectively. The result shall not be NaN_f64. The comparison shall be a consistent comparison function on the set of all strings.

return result

end proc;

proc String_match(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — match cannot be called from a constant expression

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

s: String objectToString(this, phase);

Evaluate ???? and ignore its result

end proc;

proc String_replace(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — replace cannot be called from a constant expression

end if;

if |args| 2 then

throw an ArgumentError exception — exactly two arguments must be supplied

end if;

s: String objectToString(this, phase);

Evaluate ???? and ignore its result

end proc;

proc String_search(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — search cannot be called from a constant expression

end if;

if |args| 1 then

throw an ArgumentError exception — exactly one argument must be supplied

end if;

s: String objectToString(this, phase);

Evaluate ???? and ignore its result

end proc;

proc String_slice(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the arguments can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| > 2 then

throw an ArgumentError exception — at most two arguments can be supplied

end if;

s: String objectToString(this, phase);

startArg: Object defaultArg(args, 0, +zero_f64);

endArg: Object defaultArg(args, 1, +_f64);

start: Integer pinExtendedInteger(objectToExtendedInteger(startArg, phase), |s|, true);

end: Integer pinExtendedInteger(objectToExtendedInteger(endArg, phase), |s|, true);

if start < end then return s[start ... end – 1] else return “” end if

end proc;

proc String_split(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — split cannot be called from a constant expression

end if;

if |args| > 2 then

throw an ArgumentError exception — at most two arguments can be supplied

end if;

s: String objectToString(this, phase);

Evaluate ???? and ignore its result

end proc;

proc String_substring(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this and the arguments can be converted to primitives in constant expressions.

note This function is generic and can be applied even if this is not a string.

if |args| > 2 then

throw an ArgumentError exception — at most two arguments can be supplied

end if;

s: String objectToString(this, phase);

startArg: Object defaultArg(args, 0, +zero_f64);

endArg: Object defaultArg(args, 1, +_f64);

start: Integer pinExtendedInteger(objectToExtendedInteger(startArg, phase), |s|, false);

end: Integer pinExtendedInteger(objectToExtendedInteger(endArg, phase), |s|, false);

if start end then return s[start ... end – 1]

else return s[end ... start – 1]

end if

end proc;

proc String_toLowerCase(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this can be converted to a primitive in a constant expression.

note This function is generic and can be applied even if this is not a string.

s: String objectToString(this, phase);

s32: Char21[] stringToUTF32(s);

r: String “”;

for each ch s32 do r r charToLowerFull(ch) end for each;

return r

end proc;

proc String_toLocaleLowerCase(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — toLocaleLowerCase cannot be called from a constant expression

end if;

s: String objectToString(this, phase);

s32: Char21[] stringToUTF32(s);

r: String “”;

for each ch s32 do r r charToLowerLocalized(ch) end for each;

return r

end proc;

proc String_toUpperCase(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function can be used in a constant expression if this can be converted to a primitive in a constant expression.

note This function is generic and can be applied even if this is not a string.

s: String objectToString(this, phase);

s32: Char21[] stringToUTF32(s);

r: String “”;

for each ch s32 do r r charToUpperFull(ch) end for each;

return r

end proc;

proc String_toLocaleUpperCase(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function is generic and can be applied even if this is not a string.

if phase = compile then

throw a ConstantError exception — toLocaleUpperCase cannot be called from a constant expression

end if;

s: String objectToString(this, phase);

s32: Char21[] stringToUTF32(s);

r: String “”;

for each ch s32 do r r charToUpperLocalized(ch) end for each;

return r

end proc;

Array

Array: Class = new ClasslocalBindings: {}, instanceProperties: {
new InstanceVariablemultiname: {arrayPrivate::“length”}, final: true, enumerable: false, type: Number, defaultValue: +zero_f64, immutable: false,
new InstanceGettermultiname: {public::“length”}, final: true, enumerable: false, call: Array_getLength,
new InstanceSettermultiname: {public::“length”}, final: true, enumerable: false, call: Array_setLength},
super: Object, prototype: ArrayPrototype, complete: true, name: “Array”, typeofString: “object”, privateNamespace: arrayPrivate, dynamic: true, final: true, defaultValue: null, defaultHint: hintNumber, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: writeArray, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: sameAsConstruct, construct: ordinaryConstruct, init: initArray, is: ordinaryIs, coerce: ordinaryCoerce;

arrayLimit: Integer = an implementation-defined integer value between 2³² – 1 and 2⁵³ inclusive;

arrayPrivate: Namespace = new Namespacename: “private”;

proc writeArray(o: Object, limit: Class, multiname: Multiname, env: EnvironmentOpt, newValue: Object, createIfMissing: Boolean, phase: {run}): {none, ok}

result: {none, ok} ordinaryWrite(o, limit, multiname, env, newValue, createIfMissing, phase);

if result = ok then

i: IntegerOpt multinameToUnsignedInteger(multiname);

if i none then

if i arrayLimit then

throw a RangeError exception — array index out of range

end if;

length: Integer readArrayPrivateLength(o, phase);

if i length then

length i + 1;

Evaluate writeArrayPrivateLength(o, length, phase) and ignore its result

end if

end if;

return result

end proc;

readArrayPrivateLength(array, phase) returns an Array’s private length. See also readLength, which can work on non-Array objects.

proc readArrayPrivateLength(array: Object, phase: Phase): Integer

length: Float64 readInstanceSlot(array, arrayPrivate::“length”, phase);

note length {NaN_f64, +_f64, –_f64};

n: Rational toRational(length);

note n Integer and 0 n arrayLimit;

return n

end proc;

writeArrayPrivateLength(array, length, phase) sets an Array’s private length to length after ensuring that length is between 0 and arrayLimit inclusive. See also writeLength, which can work on non-Array objects.

proc writeArrayPrivateLength(array: Object, length: Integer, phase: {run})

if length < 0 or length > arrayLimit then

throw a RangeError exception — array length out of range

end if;

Evaluate dotWrite(array, {arrayPrivate::“length”}, length_f64, phase) and ignore its result

end proc;

proc multinameToUnsignedInteger(multiname: Multiname): IntegerOpt

if |multiname| 1 then return none end if;

qname: QualifiedName the one element of multiname;

if qname.namespace public then return none end if;

name: String qname.id;

if name [] then

if name = “0” then return 0

elsif name[0] ‘0’ and (every ch name satisfies ch {‘0’ ... ‘9’}) then

return stringToExtendedInteger(name)

end if

end if;

return none

end proc;

proc initArray(this: SimpleInstance, args: Object[], phase: {run})

if |args| = 1 then

arg: Object args[0];

if arg GeneralNumber then

length: IntegerOpt checkInteger(arg);

if length = none then

throw a RangeError exception — array length must be an integer

end if;

Evaluate writeArrayPrivateLength(this, length, phase) and ignore its result;

return

end if

end if;

i: Integer 0;

for each arg args do

Evaluate indexWrite(this, i, arg, phase) and ignore its result;

i i + 1

end for each;

note The call to indexWrite above also set the array’s length to i.

end proc;

proc Array_getLength(this: Object, phase: Phase): Float64

note is(this, Array) because this getter cannot be extracted from the Array class.

note An array’s length is mutable, so reading it will throw ConstantError when phase = compile.

return readInstanceSlot(this, arrayPrivate::“length”, phase)

end proc;

proc Array_setLength(this: Object, length: Object, phase: Phase)

note is(this, Array) because this setter cannot be extracted from the Array class.

if phase = compile then

throw a ConstantError exception — an array’s length cannot be set from a constant expression

end if;

newLength: IntegerOpt checkInteger(objectToGeneralNumber(length, phase));

if newLength = none or newLength < 0 or newLength > arrayLimit then

throw a RangeError exception — array length out of range or not an integer

end if;

oldLength: Integer readArrayPrivateLength(this, phase);

if newLength < oldLength then

note Delete all indexed properties greater than or equal to the new length

proc qnameInDeletedRange(qname: QualifiedName): Boolean

i: IntegerOpt multinameToUnsignedInteger({qname});

return i none and newLength i < oldLength

end proc;

this.localBindings {b | b this.localBindings such that not qnameInDeletedRange(b.qname)}

end if;

Evaluate writeArrayPrivateLength(this, newLength, phase) and ignore its result

end proc;

ArrayPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Array),
stdFunction(public::“toString”, Array_toString, 0),
stdFunction(public::“toLocaleString”, Array_toLocaleString, 0),
stdFunction(public::“concat”, Array_concat, 1),
stdFunction(public::“join”, Array_join, 1),
stdFunction(public::“pop”, Array_pop, 0),
stdFunction(public::“push”, Array_push, 1),
stdFunction(public::“reverse”, Array_reverse, 0),
stdFunction(public::“shift”, Array_shift, 0),
stdFunction(public::“slice”, Array_slice, 2),
stdFunction(public::“sort”, Array_sort, 1),
stdFunction(public::“splice”, Array_splice, 2),
stdFunction(public::“unshift”, Array_unshift, 1)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Array_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

if phase = compile then

throw a ConstantError exception — toString cannot be called on an Array from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

note This function ignores any arguments passed to it in args.

return internalJoin(this, “,”, phase)

end proc;

proc Array_toLocaleString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

if phase = compile then

throw a ConstantError exception — toLocaleString cannot be called on an Array from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

note This function passes any arguments passed to it in args to toLocaleString applied to the elements of the array.

separator: String the list-separator string appropriate for the host’s current locale, derived in an implementation-defined way;

length: Integer readLength(this, phase);

result: String “”;

i: Integer 0;

while i length do

elt: ObjectOpt indexRead(this, i, phase);

if elt {undefined, null, none} then

toLocaleStringMethod: Object dotRead(elt, {public::“toLocaleString”}, phase);

s: Object call(elt, toLocaleStringMethod, args, phase);

if s Char16 String then

throw a TypeError exception — toLocaleString should return a string

end if;

result result toString(s)

end if;

i i + 1;

if i length then result result separator end if

end while;

return result

end proc;

proc Array_concat(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — concat cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

constituents: Object[] [this] args;

array: Object construct(Array, [], phase);

i: Integer 0;

for each o constituents do

if is(o, Array) then

oLength: Integer readLength(o, phase);

k: Integer 0;

while k oLength do

elt: ObjectOpt indexRead(o, k, phase);

if elt none then

Evaluate indexWrite(array, i, elt, phase) and ignore its result

end if;

k k + 1;

i i + 1

end while

else Evaluate indexWrite(array, i, o, phase) and ignore its result; i i + 1

end if

end for each;

Evaluate writeArrayPrivateLength(array, i, phase) and ignore its result;

return array

end proc;

proc Array_join(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

if phase = compile then

throw a ConstantError exception — join cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, undefined);

separator: String “,”;

if arg undefined then separator objectToString(arg, phase) end if;

return internalJoin(this, separator, phase)

end proc;

proc internalJoin(this: Object, separator: String, phase: {run}): String

length: Integer readLength(this, phase);

result: String “”;

i: Integer 0;

while i length do

elt: ObjectOpt indexRead(this, i, phase);

if elt {undefined, null, none} then

result result objectToString(elt, phase)

end if;

i i + 1;

if i length then result result separator end if

end while;

return result

end proc;

proc Array_pop(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — pop cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| 0 then throw an ArgumentError exception — no arguments can be supplied

end if;

length: Integer readLength(this, phase);

result: Object undefined;

if length 0 then

length length – 1;

elt: ObjectOpt indexRead(this, length, phase);

if elt none then

result elt;

Evaluate indexWrite(this, length, none, phase) and ignore its result

end if

end if;

Evaluate writeLength(this, length, phase) and ignore its result;

return result

end proc;

proc Array_push(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — push cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

length: Integer readLength(this, phase);

for each arg args do

Evaluate indexWrite(this, length, arg, phase) and ignore its result;

length length + 1

end for each;

Evaluate writeLength(this, length, phase) and ignore its result;

return length_f64

end proc;

proc Array_reverse(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — reverse cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| 0 then throw an ArgumentError exception — no arguments can be supplied

end if;

length: Integer readLength(this, phase);

lo: Integer 0;

hi: Integer length – 1;

while lo < hi do

loElt: ObjectOpt indexRead(this, lo, phase);

hiElt: ObjectOpt indexRead(this, hi, phase);

Evaluate indexWrite(this, lo, hiElt, phase) and ignore its result;

Evaluate indexWrite(this, hi, loElt, phase) and ignore its result;

lo lo + 1;

hi hi – 1

end while;

return this

end proc;

proc Array_shift(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — shift cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| 0 then throw an ArgumentError exception — no arguments can be supplied

end if;

length: Integer readLength(this, phase);

result: Object undefined;

if length 0 then

elt: ObjectOpt indexRead(this, 0, phase);

if elt none then result elt end if;

i: Integer 1;

while i length do

elt indexRead(this, i, phase);

Evaluate indexWrite(this, i – 1, elt, phase) and ignore its result;

i i + 1

end while;

length length – 1;

Evaluate indexWrite(this, length, none, phase) and ignore its result

end if;

Evaluate writeLength(this, length, phase) and ignore its result;

return result

end proc;

proc Array_slice(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — slice cannot be called on an Array from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| > 2 then

throw an ArgumentError exception — at most two arguments can be supplied

end if;

length: Integer readLength(this, phase);

startArg: Object defaultArg(args, 0, +zero_f64);

endArg: Object defaultArg(args, 1, +_f64);

start: Integer pinExtendedInteger(objectToExtendedInteger(startArg, phase), length, true);

end: Integer pinExtendedInteger(objectToExtendedInteger(endArg, phase), length, true);

return makeArraySlice(this, start, end, phase)

end proc;

proc makeArraySlice(array: Object, start: Integer, end: Integer, phase: {run}): Object

slice: Object construct(Array, [], phase);

i: Integer start;

j: Integer 0;

while i < end do

elt: ObjectOpt indexRead(array, i, phase);

Evaluate indexWrite(slice, j, elt, phase) and ignore its result;

i i + 1;

j j + 1

end while;

Evaluate writeLength(slice, j, phase) and ignore its result;

return slice

end proc;

proc Array_sort(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — sort cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

Evaluate ???? and ignore its result

end proc;

proc Array_splice(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Object

if phase = compile then

throw a ConstantError exception — splice cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

if |args| < 2 then

throw an ArgumentError exception — at least two arguments must be supplied

end if;

length: Integer readLength(this, phase);

startArg: Object defaultArg(args, 0, +zero_f64);

deleteCountArg: Object defaultArg(args, 1, +zero_f64);

start: Integer pinExtendedInteger(objectToExtendedInteger(startArg, phase), length, true);

deleteCount: Integer pinExtendedInteger(objectToExtendedInteger(deleteCountArg, phase), length – start, false);

deletedSlice: Object makeArraySlice(this, start, start + deleteCount, phase);

newElts: Object[] args[2 ...];

newEltCount: Integer |newElts|;

countDiff: Integer newEltCount – deleteCount;

i: Integer;

if countDiff < 0 then

i start + deleteCount;

while i length do

elt: ObjectOpt indexRead(this, i, phase);

Evaluate indexWrite(this, i + countDiff, elt, phase) and ignore its result;

i i + 1

end while;

i 0;

while i countDiff do

i i – 1;

Evaluate indexWrite(this, length + i, none, phase) and ignore its result

end while

elsif countDiff > 0 then

i length;

while i start + deleteCount do

i i – 1;

elt: ObjectOpt indexRead(this, i, phase);

Evaluate indexWrite(this, i + countDiff, elt, phase) and ignore its result

end while

end if;

Evaluate writeLength(this, length + countDiff, phase) and ignore its result;

i start;

for each arg newElts do

Evaluate indexWrite(this, i, arg, phase) and ignore its result;

i i + 1

end for each;

return deletedSlice

end proc;

proc Array_unshift(this: Object, f: SimpleInstance, args: Object[], phase: Phase): Float64

if phase = compile then

throw a ConstantError exception — unshift cannot be called from a constant expression

end if;

note This function is generic and can be applied even if this is not an Array.

i: Integer readLength(this, phase);

nArgs: Integer |args|;

newLength: Integer nArgs + i;

if nArgs = 0 then

At the implementation’s discretion, either do nothing or return newLength_f64

end if;

Evaluate writeLength(this, newLength, phase) and ignore its result;

while i 0 do

i i – 1;

elt: ObjectOpt indexRead(this, i, phase);

Evaluate indexWrite(this, i + nArgs, elt, phase) and ignore its result

end while;

for each arg args do

Evaluate indexWrite(this, i, arg, phase) and ignore its result;

i i + 1

end for each;

return newLength_f64

end proc;

Namespace

Namespace: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: NamespacePrototype, complete: true, name: “Namespace”, typeofString: “namespace”, dynamic: false, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: ordinaryCall, construct: constructNamespace, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

proc constructNamespace(c: Class, args: Object[], phase: Phase): Namespace

note This function can be used in a constant expression if its argument is a string.

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, undefined);

if arg Null Undefined then

if phase = compile then

throw a ConstantError exception — a constant expression cannot construct new anonymous namespaces

end if;

return new Namespacename: “anonymous”

elsif arg Char16 String then

name: String toString(arg);

if name = “” then return public

elsif some ns namedNamespaces satisfies ns.name = name then return ns

else

ns2: Namespace new Namespacename: name;

namedNamespaces namedNamespaces {ns2};

return ns2

end if

else throw a TypeError exception

end if

end proc;

namedNamespaces: Namespace{} {};

NamespacePrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdFunction(public::“toString”, Namespace_toString, 0),
stdReserve(public::“valueOf”, ObjectPrototype)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Namespace_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function does not check phase and therefore can be used in a constant expression.

note This function ignores any arguments passed to it in args.

if this Namespace then throw a TypeError exception end if;

return this.name

end proc;

Attribute

Attribute: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: ObjectPrototype, complete: true, name: “Attribute”, typeofString: “object”, dynamic: false, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

Date

Date: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: DatePrototype, complete: true, name: “Date”, typeofString: “object”, dynamic: true, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

DatePrototype: SimpleInstance = new SimpleInstancelocalBindings: {}, archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

RegExp

RegExp: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: RegExpPrototype, complete: true, name: “RegExp”, typeofString: “object”, dynamic: true, final: true, defaultValue: null, defaultHint: hintNumber, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

RegExpPrototype: SimpleInstance = new SimpleInstancelocalBindings: {}, archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

Class

Class: Class = new ClasslocalBindings: {}, instanceProperties: {classPrototypeGetter}, super: Object, prototype: ClassPrototype, complete: true, name: “Class”, typeofString: “function”, dynamic: false, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

classPrototypeGetter: InstanceGetter = new InstanceGettermultiname: {public::“prototype”}, final: true, enumerable: false, call: Class_prototype;

proc Class_prototype(this: Object, phase: Phase): Object

note this Class because this getter cannot be extracted from the Class class.

prototype: ObjectOpt this.prototype;

if prototype = none then return undefined else return prototype end if

end proc;

ClassPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Class),
stdFunction(public::“toString”, Class_toString, 0),
stdReserve(public::“valueOf”, ObjectPrototype),
stdConstBinding(public::“length”, Number, 1_f64)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Class_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

note This function does not check phase and therefore can be used in a constant expression.

note This function ignores any arguments passed to it in args.

c: Class objectToClass(this);

return “[class ” c.name “]”

end proc;

Function

Function: Class = new ClasslocalBindings: {}, instanceProperties: {ivarFunctionLength}, super: Object, prototype: FunctionPrototype, complete: true, name: “Function”, typeofString: “function”, dynamic: false, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

ivarFunctionLength: InstanceVariable = new InstanceVariablemultiname: {public::“length”}, final: true, enumerable: false, type: Number, defaultValue: none, immutable: true;

FunctionPrototype: SimpleInstance = new SimpleInstancelocalBindings: {}, archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

PrototypeFunction

PrototypeFunction: Class = new ClasslocalBindings: {}, instanceProperties: {new InstanceVariablemultiname: {public::“prototype”}, final: true, enumerable: false, type: Object, defaultValue: undefined, immutable: false}, super: Function, prototype: FunctionPrototype, complete: true, name: “Function”, typeofString: “function”, dynamic: true, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

Package

Package: Class = new ClasslocalBindings: {}, instanceProperties: {}, super: Object, prototype: ObjectPrototype, complete: true, name: “Package”, typeofString: “object”, dynamic: true, final: true, defaultValue: null, defaultHint: hintString, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: dummyCall, construct: dummyConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

Error

Error: Class = new ClasslocalBindings: {}, instanceProperties: {
new InstanceVariablemultiname: {public::“name”}, final: false, enumerable: true, type: String, defaultValue: null, immutable: false,
new InstanceVariablemultiname: {public::“message”}, final: false, enumerable: true, type: String, defaultValue: null, immutable: false},
super: Object, prototype: ErrorPrototype, complete: true, name: “Error”, typeofString: “object”, dynamic: true, final: false, defaultValue: null, defaultHint: hintNumber, hasProperty: ordinaryHasProperty, bracketRead: ordinaryBracketRead, bracketWrite: ordinaryBracketWrite, bracketDelete: ordinaryBracketDelete, read: ordinaryRead, write: ordinaryWrite, delete: ordinaryDelete, enumerate: ordinaryEnumerate, call: callError, construct: ordinaryConstruct, init: initError, is: ordinaryIs, coerce: ordinaryCoerce;

proc callError(this: Object, c: Class, args: Object[], phase: Phase): Object

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, undefined);

if arg = null or is(arg, Error) then return arg

else return construct(c, args, phase)

end if

end proc;

proc initError(this: SimpleInstance, args: Object[], phase: {run})

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

name: String Null dotRead(ErrorPrototype, {public::“name”}, phase);

Evaluate dotWrite(this, {public::“name”}, name, phase) and ignore its result;

arg: Object defaultArg(args, 0, undefined);

message: String Null;

if arg = undefined then message dotRead(ErrorPrototype, {public::“message”}, phase)

else message objectToString(arg, phase)

end if;

Evaluate dotWrite(this, {public::“message”}, message, phase) and ignore its result

end proc;

ErrorPrototype: SimpleInstance = new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, Error),
stdFunction(public::“toString”, Error_toString, 1),
stdVarBinding(public::“name”, String, “Error”),
stdVarBinding(public::“message”, String, an implementation-defined string)},
archetype: ObjectPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc Error_toString(this: Object, f: SimpleInstance, args: Object[], phase: Phase): String

if phase = compile then

throw a ConstantError exception — toString cannot be called on an Error from a constant expression

end if;

note This function ignores any arguments passed to it in args.

err: Object coerceNonNull(this, Error);

name: String Null dotRead(err, {public::“name”}, phase);

message: String Null dotRead(err, {public::“message”}, phase);

return an implementation-defined string derived from name, message, and optionally other properties of err

end proc;

proc systemError(e: Class, msg: String Undefined): Object

return construct(e, [msg], run)

end proc;

Error Subclasses

proc makeBuiltInErrorSubclass(name: String): Class

proc call(this: Object, c: Class, args: Object[], phase: Phase): Object

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

arg: Object defaultArg(args, 0, undefined);

if arg = null or is(arg, Error) then return coerce(arg, c)

else return construct(c, args, phase)

end if

end proc;

c: Class new ClasslocalBindings: {}, instanceProperties: {}, super: Error, complete: false, name: name, typeofString: “object”, dynamic: true, final: false, defaultValue: null, defaultHint: hintNumber, hasProperty: Error.hasProperty, bracketRead: Error.bracketRead, bracketWrite: Error.bracketWrite, bracketDelete: Error.bracketDelete, read: Error.read, write: Error.write, delete: Error.delete, enumerate: Error.enumerate, call: call, construct: ordinaryConstruct, init: none, is: ordinaryIs, coerce: ordinaryCoerce;

prototype: SimpleInstance new SimpleInstancelocalBindings: {
stdConstBinding(public::“constructor”, Class, c),
stdVarBinding(public::“name”, String, name),
stdVarBinding(public::“message”, String, an implementation-defined string)},
archetype: ErrorPrototype, sealed: prototypesSealed, type: Object, slots: {}, call: none, construct: none, env: none;

proc init(this: SimpleInstance, args: Object[], phase: {run})

if |args| > 1 then

throw an ArgumentError exception — at most one argument can be supplied

end if;

name2: String Null dotRead(prototype, {public::“name”}, phase);

Evaluate dotWrite(this, {public::“name”}, name2, phase) and ignore its result;

arg: Object defaultArg(args, 0, undefined);

message: String Null;

if arg = undefined then message dotRead(prototype, {public::“message”}, phase)

else message objectToString(arg, phase)

end if;

Evaluate dotWrite(this, {public::“message”}, message, phase) and ignore its result

end proc;

c.prototype prototype;

c.init init;

c.complete true;

return c

end proc;

ArgumentError: Class = makeBuiltInErrorSubclass(“ArgumentError”);

AttributeError: Class = makeBuiltInErrorSubclass(“AttributeError”);

ConstantError: Class = makeBuiltInErrorSubclass(“ConstantError”);

DefinitionError: Class = makeBuiltInErrorSubclass(“DefinitionError”);

EvalError: Class = makeBuiltInErrorSubclass(“EvalError”);

RangeError: Class = makeBuiltInErrorSubclass(“RangeError”);

ReferenceError: Class = makeBuiltInErrorSubclass(“ReferenceError”);

SyntaxError: Class = makeBuiltInErrorSubclass(“SyntaxError”);

TypeError: Class = makeBuiltInErrorSubclass(“TypeError”);

UninitializedError: Class = makeBuiltInErrorSubclass(“UninitializedError”);

URIError: Class = makeBuiltInErrorSubclass(“URIError”);

ECMAScript 4 Netscape Proposal

Rationale

Tuesday, January 28, 2003

Execution Model
Member Lookup
Versioning
Named Function Parameters
Operators
Units
Unit Patterns (Word RTF)
Syntax
Miscellaneous

This chapter discusses the decisions made in desigining ECMAScript 4. Rationales are presented together with descriptions of other alternatives that were/are considered. Currently outstanding issues are in red.

ECMAScript 4 Netscape Proposal

Rationale

Execution Model

Tuesday, September 10, 2002

This page is somewhat out of date.

Introduction

When does a declaration (of a value, function, type, class, method, pragma, etc.) take effect? When are expressions evaluated? The answers to these questions distinguish among major kinds of programming languages. Let’s consider the following function definition in a language with C++ or Java-like syntax:

gadget f(widget x) {
  if ((gizmo)(x) != null)
    return (gizmo)(x);
  return x.owner;
}

In a static language such as Java or C++, all type expressions are evaluated at compile time. Thus, in this example widget and gadget would be evaluated at compile time. If gizmo were a type, then it too would be evaluated at compile time ((gizmo)(x) would become a type cast). Note that we must be able to statically distinguish identifiers used for variables from identifiers used for types so we can decide whether (gizmo)(x) is a one-argument function call (in which case gizmo would be evaluated at run time) or a type cast (in which case gizmo would be evaluated at compile time). In most cases, in a static language a declaration is visible throughout its enclosing scope, although there are exceptions that have been deemed too complicated for a compiler to handle such as the following C++:

typedef int *x;

class foo {
  typedef x *y;
  typedef char *x;
}

Many dynamic languages can construct, evaluate, and manipulate type expressions at run time. Some dynamic languages (such as Common Lisp) distinguish between compile time and run time and provide constructs (eval-when) to evaluate expressions early. The simplest dynamic languages (such as Scheme) process input in a single pass and do not distinguish between compile time and run time. If we evaluated the above function in such a simple language, widget and gadget would be evaluated at the time the function is called.

Challenges

ECMAScript is a scripting language. Many programmers wish to write ECMAScript scripts embedded in web pages that work in a variety of environments. Some of these environments may provide libraries that a script would like to use, while on other environments the script may have to emulate those libraries. Let’s take a look at an example of something one would expect to be able to easily do in a scripting language:

Bob is writing a script for a web page that wants to take advantage of an optional package MacPack that is present on some environments (Macintoshes) but not on others. MacPack provides a class HyperWindoid from which Bob wants to subclass his own class BobWindoid. On other platforms Bob has to define an emulation class BobWindoid' that is implemented differently from BobWindoid — it has a different set of private methods and fields. There also is a class WindoidGuide in Bob’s package; the code and method signatures of classes BobWindoid and BobWindoid' refer to objects of type WindoidGuide, and class WindoidGuide’s code refers to objects of type BobWindoid (or BobWindoid' as appropriate).

Were ECMAScript to use a dynamic execution model (described below), declarations take effect only when executed, and Bob can implement his package as shown below.

class WindoidGuide; // forward declaration

if (onMac()) {
  import "MacPack";

  global class BobWindoid extends HyperWindoid {
    private var x;
    var g:WindoidGuide;

    private function speck() {...};
    public function zoom(a:WindoidGuide, uncle:HyperWindoid = null):WindoidGuide {...};
  }
} else {
  // emulation class BobWindoid'
  global class BobWindoid {
    private var i:Integer, j:Integer;
    var g:WindoidGuide;

    private function advertise(h:WindoidGuide):WindoidGuide {...};
    private function subscribe(h:WindoidGuide):WindoidGuide {...};
    public function zoom(a:WindoidGuide):WindoidGuide {...};
  }
}

class WindoidGuide {
  var currentWindoid:BobWindoid;

  function introduce(arg:BobWindoid):BobWindoid {...};
}

On the other hand, if the language were static (meaning that types are compile-time expressions), Bob would run into problems. How could he declare the two alternatives for the class BobWindoid?

Bob’s first thought was to split his package into three HTML SCRIPT tags (containing BobWindoid, BobWindoid', and WindoidGuide) and turn one of the first two off depending on the platform. Unfortunately this doesn’t work because he gets type errors if he separates the definition of class BobWindoid (or BobWindoid') from the definition of WindoidGuide because these classes mutually refer to each other. Furthermore, Bob would like to share the script among many pages, so he’d like to have the entire script in a single BobUtilities.js file.

Note that this problem would be newly introduced by ECMAScript 4 if it were to evaluate type expressions at compile time. ECMAScript 3 does not suffer from this problem because it does not have a concept of evaluating an expression at compile time, and it is relatively easy to conditionally define a class (which is merely a function) by declaring a single global variable g and conditionally assigning either one or another anonymous function to it.

There exist other alternatives in between the dynamic execution model and the static model that also solve Bob’s problem. One of them is described at the end of this chapter.

Dynamic Execution Model

In a pure dynamic execution model the entire program is processed in one pass. Declarations take effect only when they are executed. A declaration that is never executed is ignored. Scheme follows this model, as did early versions of Visual Basic.

The dynamic execution model considerably simplifies the language and allows an interpreter to treat programs read from a file identically to programs typed in via an interactive console. Also, a dynamic execution model interpreter or just-in-time compiler may start to execute a script even before it has finished downloading all of it.

One of the most significant advantages of the dynamic execution model is that it allows ECMAScript 4 scripts to turn parts of themselves on and off based on dynamically obtained information. For example, a script or library could define additional functions and classes if it runs on an environment that provides a CSS unit arithmetic library while still working on environments that do not.

The dynamic execution model requires identifiers naming functions and variables to be defined before they are used. A use occurs when an identifier is read, written, or called, at which point that identifier is resolved to a variable or a function according to the scoping rules. A reference from within a control statement such as if and while located outside a function is resolved only when execution reaches the reference. References from within the body of a function are resolved only after the function is called; for efficiency, an implementation is allowed to resolve all references within a function or method that does not contain eval at the first time the function is called.

According to these rules, the following program is correct and would print 7:

function f(a:Integer):Integer {
  return a+b;
}

var b:Integer = 4;
print(f(3));

Assuming that variable b is predefined by the host if featurePresent is true, this program would also work:

function f(a:Integer):Integer {
  return a+b;
}

if (!featurePresent) {
  var b:Integer = 4;
}

print(f(3));

On the other hand, the following program would produce an error because f is referenced before it is defined:

print(f(3));

function f(a:Integer):Integer {
  return a*2;
}

Defining mutually recursive functions is not a problem as long as one defines all of them before calling them.

Hybrid Execution Model

ECMAScript 3 does not follow the pure dynamic execution model, and, for reasons of compatibility, ECMAScript 4 strays from that model as well, adopting a hybrid execution model instead. Specifically, ECMAScript 4 inherits the following static execution model aspects from ECMAScript 3:

Variable declarations of variables at the global scope cause the variables to be created at the time the program is entered rather than at the time the declaractions are evaluated.
Variable declarations of local variables inside a function cause the variables to be created at the time the function is entered rather than at the time the declaractions are evaluated.
Unless specified otherwise, declarations of functions at the global scope cause the functions to be created at the time the program is entered rather than at the time the declaractions are evaluated.
Unless specified otherwise, declarations of functions nested inside a function cause the functions to be created at the time the function is entered rather than at the time the declaractions are evaluated.

In addition to the above, the evaluation of class declarations has special provisions for delayed evaluation to allow mutually-referencing classes.

The second condition above allows the following program to work in ECMAScript 4:

const b:String = "Bee";

function square(a:Integer):Integer {
  b = a;   // Refers to local b defined below, not global b
  return b*a;
  var b:Integer;
}

While allowed, using variables ahead of declaring them, such as in the above example, is considered bad style and may generate a warning.

The third condition above makes the last example from the pure execution model section work:

print(f(3));

function f(a:Integer):Integer {
  return a*2;
}

Again, actually calling a function at the top level before declaring it is considered bad style and may generate a warning. It also will not work with classes.

Compiling The Dynamic Execution Model

Perhaps the easiest way to compile a script under the dynamic execution model is to accumulate function definitions unprocessed and compile them only when they are first called. Many JITs do this anyway because this lets them avoid the overhead of compiling functions that are never called. This process does not impose any more of an overhead than the static model would because under the static model the compiler would need to either scan the source code twice or save all of it unprocessed during the first pass for processing in the second pass.

Compiling a dynamic execution model script off-line also does not present special difficulties as long as eval is restricted to not introduce additional declarations that shadow existing ones (if eval is allowed to do this, it would present problems for any execution model, including the static one). Under the dynamic execution model, once the compiler has reached the end of a scope it can assume that that scope is complete; at that point all identifiers inside that scope can be resolved to the same extent that they would be in the static model.

Conditional Compilation Alternative

Bob’s problem could also be solved by using conditional compilation similar in spirit to C’s preprocessor. If we do this, we have to ask about how expressive the conditional compilation meta-language should be. C’s preprocessor is too weak. In ECMAScript applications we’d often find that we need the full power of ECMAScript so that we can inspect the DOM, the environment, etc. when deciding how to control compilation. Besides, using ECMAScript as the meta-language would reduce the number of languages that a programmer would have to learn.

Here’s one sketch of how this could be done:

Execution of a script occurs in a series of passes. The last one is called run time. It is preceded by a compile time pass, which is preceded (if necessary) by a compile compile time pass, which is preceded (if necessary) by a compile compile compile time pass, etc. Having anything beyond a compile compile time pass is very rare, but rapid-development tools could generate such code.
All definitions made in a previous pass (such as compile time) are also visible in a later pass (such as run time). If we define a type to also be a function that casts its argument to it type, this allows an implementation to not worry about whether (x)(y) is a function call of function x or a cast of y to type x.
TypeExpressions are evaluated at compile time. These appear as types of variables, constants, and fields; argument and result types of functions and methods; and superclasses.
Declarations are accumulated at compile time. Variables are declared, but variable initializers are not evaluated. Functions and classes are declared and defined at compile time.
One can lift a Block from run time to compile time by preceding the block with a # symbol. For example, #{var x:int = 3} defines a compile-time constant x and initializes it to 3. One can also lift a var, const, or function declaration directly by preceding it with a # symbol, so #var x:int = 3; would accomplish the same thing.
Any TypeExpressions in blocks or statements lifted to compile time are evaluated at compile compile time. int in the preceding example is such a TypeExpression.
Any block or statement that is lifted twice (as in #{#var x:int = 3}) is evaluated at compile compile time, and so forth.
The compile time pass can selectively exclude source code statements from the run time pass using the construct below. If the first Expression is true, the first Statements list is included in the run time pass. Otherwise, if the second Expression is true, the second Statements list is included in the run time pass, and so on.

# if ( Expression ) Statements [# else if ( Expression ) Statements] ... [# else Statements] # end if
Unlike in C, the Statements above must have balanced parentheses, braces, brackets, etc. Also, unlike in C, preprocessing is not line-oriented; #’s can appear anywhere on a line.
The compile compile time pass can use #if to conditionally exclude compile time code, etc.

Note that because variable initializers are not evaluated at compile time, one has to use #var a = int rather than var a = int to define an alias a for a type name int.

This sketch does not address many issues that would have to be resolved, such as how typed variables are handled after they are declared but before they are initialized (this problem doesn’t arise in the dynamic execution model), how the lexical scopes of the run time pass would interact with scoping of the compile time pass, etc.

Comparing the Dynamic Execution Model with Conditional Compilation

Both approaches solve Bob’s problem, but they differ in other areas. In the sequel "conditional compilation" refers to the conditional compilation alternative described above.

The dynamic execution model is simpler to describe and analyze.
The dynamic execution model is easier to learn for non-programmers.
Conditional compilation is more familar to C/C++ programmers.
Conditional compilation requires either a control meta-language or facilities for lifting execution from run to compile time. These often have unintended consequences (compile-time evaluation does not follow the same scopes as run-time evaluation) and have been a significant source of problems in Common Lisp.
Conditional compilation can more faithfully emulate ECMAScript 3 semantics because it allows a function to be called at the top level before it is defined.
Conditional compilation cannot guarantee that variables’ initializers have been run before the variables are referenced. The dynamic execution model guarantees that.
Conditional compilation does not allow one to use general prototype-based types because prototypes are often calculated at run time. The dynamic execution model allows these.
Conditional compilation does not support functors and templates without significant additional syntax. The dynamic execution model naturally extends to these.

Compiler Blocks

Another alternative execution model briefly considered but rejected is the idea of allowing compiler blocks. A compiler block has the syntax:

compile { Statement ... Statement }

The compile attribute is a hint that the block may be (but does not have to be) evaluated early. The statements inside this block should depend only on each other, on the results of earlier compiler blocks, and on properties of the environment that are designated as being available early. Other than perhaps being evaluated early, compiler blocks respect all of the scope rules and semantics of the enclosing program. Any definitions introduced by a compiler block are saved and reintroduced at normal evaluation time. On the other hand, side effects may or may not be reintroduced at normal evaluation time, so compiler blocks should not rely on side effects.

compile is an attribute, so it may also be applied to individual definitions without enclosing them in a block.

As an example, after defining

compile var x = 2;

function f1() {
  compile {
    var y = 5;
    var x = 1;
    while (y) x *= y--;
  }
  return ++x;
}

function f2() {
  compile {
    var y = x;
  }
  return x+y;
}

the value of global x will still be 2, calling f1() will always return 121, and calling f2() will return 4. If the statement x=5 is then evaluated at the global level, f1() will still return 121 because it uses its own local x. On the other hand, calling f2() may return either 7 or 10 at the implementation’s discretion — 7 if the implementation evaluated the compile block early and saved the value of y or 10 if it didn’t. As this example illustrates, it is poor technique to define variables inside compiler blocks; constants are usually better.

A fully dynamic implementation of ECMAScript 4 may choose to ignore the compile attribute and evaluate all compiler blocks at normal evaluation time. A fully static implementation may require that all user-defined types and attributes be defined inside compiler blocks.

Should const definitions with simple constant expressions such as const four = 2+2 be treated as though they were implicitly compiler definitions (compile const four = 2+2)?

ECMAScript 4 Netscape Proposal

Rationale

Member Lookup

Friday, September 20, 2002

This page is somewhat out of date.

Introduction

There have been much discussion in the TC39 subgroup about the meaning of a member lookup operation. Numerous considerations intersect here.

We will express a general unqualified member lookup operation as a.b, where a is an expression and b is an identifier. We will also consider qualified member lookup operations and write them as a.n::b, where n is an expression that evaluates to some namespace. In almost all cases we will be interested in the dynamic type Td of a. In one scheme we will also consider the static type Ts of the expression a. If the language is sound, we will always have Td Ts.

In the simplest approach, we treat an object as merely an association table of member names and member values. In this interpretation we simply look inside object a and check if there is a member named b. If there is, we return the member’s value; if not, we return undefined or signal an error.

There are a number of difficulties with this simple approach, and most object-oriented languages have not adopted it:

Members cannot be made private or internal.
Accidental clashes can occur when programming in the large.

Once we allow private or internal members, we must allow for the possibility that object a will have more than one member named b — abstraction considerations require that users of a class C not be aware of expose C’s private members, so, in particular, a user should be able to create a subclass D of C and add members to D without knowing the names of C’s private members. Both C++ and Java allow this. We must also allow for the possibility that object a will have a member named b but we are not allowed to access it. We will assume that access control is specified by lexical scoping, as is traditional in modern languages.

Desirable Criteria

Some of the criteria we would like the member lookup model to satisfy are:

Safety. The lookup does not permit access to a private member outside the class where the member is defined, nor does it allow access to an internal member outside the package where the member is defined. Furthermore, if a class C accesses its private member m, a hostile subclass D of C cannot silently substitute a member m' that would masquerade as m inside C’s code.
Abstraction. private and internal members are invisible outside their respective classes or packages. For programming in the large, a class can provide several public versions to its importers, and public members of more recent versions are invisible to importers of older versions. This is needed to provide robust libraries.
Robustness. We can make any of the following program changes without having to restructure the program:
1. Add valid type annotations to variables and functions.
2. Change a member’s visibility to private, internal, or public, assuming, of course, that that member is not used outside its new visibility.
3. Split a complicated expression statement e into several statements that compute subexpressions of e, store them in local variables, and then combine them to compute e. We should be able to do this without intimate knowledge of what e does or calls.
4. Rename a member to a different name, assuming, of course, that the new name does not cause conflicts and that we fix up all references to that member.
Namespace independence. If one class C has a member named m, this should not place restrictions on an unrelated class D having an unrelated member with the same name m.
Compatibility. An ECMAScript 4 class should be usable from ECMAScript 3 code and ECMAScript 3 code minimally upgraded to ECMAScript 4 without having to restructure the latter code. Achieving compatibility should not require the ECMAScript 4 class itself to be restructured or give up any of the other desirable criteria. Code without type annotations works as expected.

Lookup Models

There are three main competing models for performing a general unqualified member lookup operation as a.b. Let S be the set of members named b of the object obtained by evaluating expression a (hereafter shortened to just "object a") that are accessible via the namespace rules applied in the lexical scope where a.b is evaluated. All three models pick some member s S. Clearly, if the set S is empty, then the member lookup fails. In addition, the Spice and pure Static models may sometimes deliberately fail even when set S is not empty. Except for such deliberate failures, if the set S contains only one member s, all three models return that element s. If the set S contains multiple members, the three models will likely choose different members.

Another interesting (and useful) tidbit is that the Static and Dynamic models always agree on the interpretation of member lookup operations of the form this.b. All three models agree on on the interpretation of member lookup operations of the form this.b in the case where b is a member defined in the current class.

A note about overriding: When a subclass D overrides a member m of its superclass C, then the definition of the member m is conceptually replaced in all instances of D. However, the three models are only concerned with the topmost class in which member m is declared. All three models handle overriding the way one would expect of an object-oriented language. They differ in the cases where class C has a member named m, subclass D of C has a member with the same name m, but D’s m does not override C’s m because C’s m is not visible inside D (it’s not well known, but such non-overriding does and must happen in C++ and Java as well).

Static Model

In the Static model we look at the static type Ts of expression a. Let S1 be the subset of S whose class is either Ts or one of Ts’s ancestors. We pick the member in S1 with the most derived class.

The pure static model above is implemented by Java and C++. It would not work well in that form in ECMAScript because many, if not most, expressions have type Any. Because type Any has no members, users would have to cast expression a to a given type T before they could access members of type T. Because of this we must extend the static model to handle the case where the subset S1 is empty, or, in other words, the static lookup fails. (Rather than doing this, we could extend the static model in the case where the static type Ts is some special type, but then we would have to decide which types are special and which ones are not. Any is clearly special. What about Object? What about Array? It’s hard to draw the line consistently.)

In whichever cases way we extend the static model, we also have a choice of which member we choose. We could back off to the dynamic model, we could choose the most derived member in S, or perhaps we could choose some other approach.

Constraints:

Safety	Good within the pure static model. Problems in the extended static model (a subclass could silently shadow a member) that could perhaps be addressed by warnings.
Abstraction	Good.
Robustness	Very bad. Updating a function’s or global variable return type silently changes the meaning of all code that uses that function or global variable; in a large project such a change would be quite difficult. Difficult to correctly split expressions into subexpressions.
Namespace independence	Good.
Compatibility	Bad within the pure static model (type casts needed everywhere). May be good in the extended static model, depending on the choice of how we extend it.
Other	This model may be difficult to compile well because the compiler may have difficulty in determining the intermediate types in compound expressions. Languages based on the static model have traditionally been compiled off-line, and such compilers tend to be difficult to write for on-line compilation without requiring the programmer to predeclare all of his data structures (if there are any forward-referenced ones, then the compiler doesn’t know whether they should have a type or not). A more dynamic execution model may actually help because it defers compilation until more information is known.

Spice Model

In the Spice model we think of each member m defined in a class C as though it were a function definition for a (possibly overloaded) function whose first argument has type C. Definitions in an inner lexical scope shadow definitions in outer scopes. The Spice model does not consider the static type Ts of expression a.

Let L be the innermost lexical scope enclosing the member lookup expression a.b such that some member named b is defined in L. Let Lb be the set of all members named b defined in lexical scope L, and let S1 = S Lb (the intersection of S and Lb). If S1 is empty, we fail. If S1 contains exactly one member s, we use s. If S1 contains several members, we fail (this would only happen for import conflicts).

Constraints:

Safety	Good.
Abstraction	Good.
Robustness	Poor. Renaming an `internal` member may break code outside the class that defines that member even if that code does not access that member. Converting a member from `private` to one of the other two visibilities also can introduce conflicts in other, unrelated classes in the same package that just happen to have an unrelated member with the same name. Fortunately these conflicts usually (but not always) result in errors rather than silent changes to the meaning of the program, so one can often find them by exhaustively testing the program after making a change.
Namespace independence	Bad. Members with the same name in unrelated classes often conflict.
Compatibility	Poor? Many existing programs rely on namespace independence and would have to be restructured.
Other	Most object-oriented programmers would be confused by a violation of namespace independence. Programming without this assumption requires a different point of view than most programmers are used to. (I am not talking about Lisp and Self programmers, who are familiar with that way of thinking.)

[There are numerous other variants of the Spice model as well.]

Dynamic Model

In the Dynamic model we pick the member s in S defined in the innermost lexical scope L enclosing the member lookup expression a.b. We fail if the innermost such lexical scope L contains more than one member in S (this would only happen for import conflicts).

Constraints:

Safety	Good at the language level, but see "other" below.
Abstraction	Good.
Robustness	Good. All of these changes are easy to do.
Namespace independence	Good.
Compatibility	Good.
Other	Packages using the dynamic model may be vulnerable to hijacking (coerced into doing something other than what the author intended) by a determined intruder. It is possible for a compiler to detect such vulnerabilities and warn about them.

Namespaces

The various models make it possible to get into situations where either there is no way to access a visible member of an object or it is not safe to do so (see member hijacking). In these cases we’d like to be able to explicitly choose one of several potential members with the same name. The :: namespace syntax allows this. The left operand of :: is an expression that evaluates to a package or class; we may also allow special keywords such as public, internal, or private instead of an expression here, or omit the expression altogether. The right operand of :: is a name. The result is the name qualified by the namespace.

As we have seen, the name b in a member access expression a.b does not necessarily refer to a unique accessible member of object a. In a qualified member access expression a.n::b, the namespace n narrows the set of members considered, although it’s possible that the set may still contain more than one member, in which case the lookup model again disambiguates. Let S be the set of members named b of object a that are accessible. The following table shows how a.n::b subsets set S depending on n:

n	Subset
None	Only the dynamic member named `b`, if any exists
A class `C`	The fixed member of `C` named `b`, if it exists; if not, try `C`’s superclass instead, and so on up the chain
A package `P`	The subset of `S` containing all accessible members of `P`
`private`	The fixed member named `b` of the current class
`internal`	The subset of `S` containing all accessible members that have package (`internal`) visibility
`public`	The subset of `S` containing all accessible members that have `public` visibility

The :: operator serves a different role from the . operator. The :: operator produces a qualified name, while the . operator produces a value. A qualified name can be used as the right operand of .; a value cannot. If a qualified name is used in a place where a value is expected, the qualified name is looked up using the lexical scoping rules to obtain the value (most likely a global variable).

Dynamic Members

All of the models above address only access to fixed properties of a class. ECMAScript also allows one to dynamically add properties to individual instances of a class. For simplicity we do not provide access control or versioning on these dynamic properties — all of them are public and open to everyone. Because of the safety criterion, a member lookup of a private or internal member must choose the private or internal member even if there is a dynamic member of the same name. To satisfy the robustness criterion, we should treat public members as similarly as possible to private or internal members, so we always give preference to a fixed property when there is a dynamic property of the same name.

To access a dynamic property that is shadowed by a fixed property, we can either prefix the member’s name with :: or use an indirect property access.

Indirect Member Access

How should we define the behavior of the expression a[b] (assuming a’s class is not a typed array or other class that overrides the default meaning of the [] operator)? There are a couple of possibilities:

We could evaluate the expression b to some string "s" and treat a[b] as though it were a.s. This is essentially what ECMAScript 3 does. Unfortunately it’s hard to keep this behavior consistent with ECMAScript 3 programs’ expectations (they expect no more than one member with the same name, etc.), and this kind of indirection is also vulnerable to hijacking. It may be possible to solve the hijacking problem by devising restricted variants of the [] operator such as a.n::[b] that follow the rules given in the namespaces section above.
We could evaluate the expression b to some string "s" and treat a[b] as though it were a.::s, thus limiting our selection to dynamic members. Dynamic members are well-behaved, but this kind of behavior would violate the compatibility criterion when ECMAScript 3 scripts try to reflect an ECMAScript 4 object using the [] operator.

In general it seems like it would be a bad idea to extend the syntax of the string "s" to allow :: operators inside the string. Such strings are too easily forged to play the role of pointers to members.

Member Hijacking

[explain security attacks]

ECMAScript 4 Netscape Proposal

Rationale

Versioning

Tuesday, October 9, 2001

Motivation

As a package evolves over time it often becomes necessary to change its exported interface. Most of these changes involve adding definitions (top-level or class members), although occasionally a definition may be deleted or renamed. In a monolithic environment where all ECMAScript source code comes preassembled from the same source, this is not a problem. On the other hand, if packages are dynamically linked from several sources then versioning problems are likely to arise.

One of the most common avoidable problems is collision of definitions. Unless we solve this problem, an author of a library will not be able to add even one definition in a future version of his library because that definition’s name could already be in use by some client or some other library that a client also links with. This problem occurs both in the global scope and in the scopes of classes from which clients are allowed to inherit.

Example

Here’s an example of how such a collision can arise. Suppose that a library provider creates a library called BitTracker that exports a class Data. This library becomes so successful that it is bundled with all web browsers produced by the BrowsersRUs company:

package BitTracker;

public class Data {
  public field author;
  public field contents;
  function save() {...}
};

function store(d) {
  ...
  storeOnFastDisk(d);
}

Now someone else writes a web page W that takes advantage of BitTracker. The class Picture derives from Data and adds, among other things, a method called size that returns the dimensions of the picture:

import BitTracker;

class Picture extends Data {
  public method size() {...}
  field palette;
};

function orientation(d) {
  if (d.size().h >= d.size().v)
    return "Landscape";
  else
    return "Portrait";
}

The author of the BitTracker library, who hasn’t seen W, decides in response to customer requests to add a method called size that returns the number of bytes of data in a Data object. He then releases the new and improved BitTracker library. BrowsersRUs includes this library with its latest NavigatorForInternetComputing 17.0 browser:

package BitTracker;

public class Data {
  public field author;
  public field contents;
  public method size() {...}
  function save() {...}
};

function store(d) {
  ...
  if (d.size() > limit)
    storeOnSlowDisk(d);
  else
    storeOnFastDisk(d);
}

An unsuspecting user U upgrades his old BrowsersRUs browser to the latest NavigatorForInternetComputing 17.0 browser and a week later is dismayed to find that page W doesn’t work anymore. U’s granddaughter Alyssa P. Hacker tries to explain to U that he’s experiencing a name conflict on the size methods, but U has no idea what she is talking about. U attempts to contact the author of W, but she has moved on to other pursuits and is on a self-discovery mission to sub-Saharan Africa. Now U is steaming at BrowsersRUs, which in turn is pointing its finger at the author of BitTracker.

Solutions

How could the author of BitTracker have avoided this problem? Simply choosing a name other than size wouldn’t work, because there could be some other page W2 that conflicts with the new name. There are several possible approaches:

Naming conventions. We could require each defined name to be prefixed by the full name of the party from which this definition originates. Unfortunately, this would get tedious and unnecessarily impact casual uses of the language. Furthermore, this approach is impractical for the names of methods because it is often desirable to share the same method name across several classes to attain polymorphism; this would not be possible if Netscape’s objects all used the com_netscape_length method while MIT’s objects used the edu_mit_length method.
Explicit imports. We could require each client package to import every external name it references. This works reasonably well for global names but becomes tedious for the names of class members, which would have to be imported separately for each class. Alternatives exist for bulk importing members of a class, but they are somewhat complicated and do not work for interfaces or multiple inheritance.
Versions. We could require package authors to mark the names they export with explicit versions. A package’s developer could introduce a new version of the package with additional names as long as those names were made invisible to prior versions.

The last approach appears to be the most desirable because it places the smallest burden on casual users of the language, who merely have to import the packages they use and supply the current version numbers in the import statements. A package author has to be careful not to disturb the set of visible prior-version definitions when releasing an updated package, but authors of dynamically linkable packages are assumed to be more sophisticated users of the language and could be supplied with tools to automatically check updated packages’ consistency.

Versioning in ECMAScript 4

ECMAScript 4 employs namespaces to provide safe versioning. A package can export several namespaces, each of which provides a different view of the package’s contents. Each namespace corresponds to a version of the package’s API.

Terminology

A version describes the API of a package. A release refers to the entirety of a package, including its code. One release can export many versions of its API. A package developer should make sure that multiple releases of a package that export version V export exactly the same set of definitions in version V.

Example

As an example, suppose that a developer wrote a sorting package Sorter with functions sort and merge that called bubble sort in the initial version. In the next release the developer adds a function called stablesort and includes it in version V2. In a subsequent release V3, the developer changes the sort algorithm to a quicksort that calls stablesort as a subroutine and adds the permute function. That last release of the package might look like:

package Sorter {
explicit namespace V2;
explicit namespace V3;
internal const V2and3 = V2 V3;

public var serialNumber;

public function sort(compare: Function, array: Array):Array {...}
public function merge(compare: Function, array1: Array, array2: Array):Array {...}
V2and3 function stablesort(compare: Function, array: Array):Array {...}
V3 function permute(array: Array):Array {...}
}

Suppose, further, that client packages C₁ and C₂ both import Sorter. There is only one instance of Sorter running — the latest release. By default, both C₁ and C₂ see only Sorter’s original API. However, suppose that C₂ is aware that Sorter has been extended and would like to also use some of its newer functionality. To do this, C₂ evaluates the magic incantation

use namespace(Sorter.V2);

after it imports Sorter. This enables C₂ to also see the stablesort function. Note that, in this example, both clients see the same sort and merge functions and the same serialNumber variable (in particular, if C1 wrote to serialNumber, then C2 would see the updated value), but only C2 can see the stablesort function. Both clients get the quicksort release of sort. If client package C1 defined its own stablesort function, then that function would not conflict with Sorter’s stablesort; furthermore, Sorter’s sort would still refer to Sorter’s stablesort in its internal subroutine call.

Had only the first release of Sorter been available, client C₂ would obtain an error because Sorter.V2 would be undefined. Client C₁ could run normally, although the sort function it calls would use bubble sort instead of the quicksort.

The example above illustrates versioning as it applies to a package’s globals. The same techniques can be used to add members to existing classes, and there versioning is much more useful.

ECMAScript 4 Netscape Proposal

Rationale

Named Function Parameters

Wednesday, January 29, 2003

Named function parameters had originally been part of the ECMAScript 4 proposal but were deferred to a future version of the language in order to keep ECMAScript 4 small. If implemented, named function parameters might behave as described in this section.

Overview

The named function parameter extension allows some function parameters to be passed by name instead of by position. Parameter names are simple strings. A function with three positional (one of which is optional) and four named parameters might be declared as:

function f(a: Number, b: Boolean, c: Number = 5, named x: Integer = 7, named y = null, named z = 34, named t = undefined)

Such a function can then be invoked as follows:

f(2, true, y: 5);
f(2, true, 8, z: 32, x: 9);

Named parameters are always optional and must include default values. A function call may specify positional arguments followed by named arguments. Positional parameters can only match positional arguments. Named parameters can only match named arguments. The same parameter may not be both positional and named.

The following sections explain the changes to add named function parameters in more detail.

Lexer

A new non-reserved keyword named named is added. This keyword is a valid identifier:

Identifier

| get

| set

| exclude

| include

| named

Function Parameter Lists

A function may take zero or more positional parameters followed by either an optional rest parameter followed by zero or more named parameters or a named rest parameter:

Parameters

«empty»

NonemptyParameters

ParameterInit

| RestAndNamedParameters

RestAndNamedParameters

NamedParameters

| RestParameter , NamedParameters

| NamedRestParameter

NamedParameters

NamedParameter

| NamedParameter , NamedParameters

Individual parameters have the forms:

ParameterCore TypedIdentifier^allowIn

Parameter

ParameterCore

| const ParameterCore

ParameterInit

Parameter

| Parameter = AssignmentExpression^allowIn

NamedParameterCore TypedIdentifier^allowIn = AssignmentExpression^allowIn

NamedParameter

named NamedParameterCore

| const named NamedParameterCore

| named const NamedParameterCore

RestParameter

...

| ... Parameter

NamedRestParameter

... named Identifier

| ... const named Identifier

| ... named const Identifier

If a parameter is prefixed with named, then the parameter is matched by name rather than by position. Named parameters are always optional and must have initializers.

Attempting to define a function with two different parameters with the same name is an error.

A function with named parameters is never unchecked.

Rest Parameter

If the ... is present, the function accepts arguments not matched by any of the other listed parameters. If a parameter is given after the ..., then that parameter’s identifier is bound to an array of all remaining arguments. That identifier is declared as a local const using the parameter’s type, which defaults to Array. If the rest parameter is named, then the parameter’s type is always Array and cannot be specified explicitly.

The remaining positional arguments are stored as elements of the rest array with numeric indices starting from 0. If the rest parameter is not named, then there must be no remaining named arguments. Otherwise, extra named arguments are allowed and are stored as named properties of the rest array.

Call Processing

If the function is unchecked, bind the arguments local variable to an array of all arguments and their names.
Get the saved type t that was the result of evaluating the first parameter’s TypeExpression at the time the function was defined.
If the first parameter is required and no positional argument has been supplied for it, then raise an error unless the function is unchecked, in which case let undefined be the first parameter’s value.
If the first parameter is optional and there is a positional argument remaining, use the value of the positional argument. If there are no remaining positional arguments, then evaluate the first parameter’s AssignmentExpression and let it be the first parameter’s value.
If the first parameter is named and there is a named argument with a matching argument name, then use the value of that named argument. Otherwise, evaluate the first parameter’s AssignmentExpression and let it be the first parameter’s value.
Implicitly coerce the argument (or default) value to type t and bind the parameter’s Identifier to the result.
Repeat steps 2-6 for each additional required, optional, and named parameter.
If there is a RestParameter and one or more of the remaining arguments is named, raise an error.
If there is a RestParameter with an Identifier, bind that Identifier to an array of the remaining positional arguments using indices starting from 0.
If there is a NamedRestParameter, bind its Identifier to an array of the remaining positional arguments using indices starting from 0 as well as the remaining named arguments stored using named properties.
If there is no RestParameter or NamedRestParameter and any arguments remain, raise an error unless the function is unchecked.
Evaluate the body.
Get the saved type r that was the result of evaluating the result TypeExpression at the time the function was defined.
Implicitly coerce the result to type r and return it.

Function Calls

The a[args] and f(args) indexing and function call operators are extended to allow named arguments:

Brackets

[ ]

| [ ListExpression^allowIn ]

| [ NamedArgumentList ]

Arguments

ParenExpressions

| ( NamedArgumentList )

ParenExpressions

( )

NamedArgumentList

LiteralField

| ListExpression^allowIn , LiteralField

| NamedArgumentList , LiteralField

A list of arguments can contain both positional and named arguments. The positional arguments are the subexpressions separated by commas within the ListExpression^allowIn. Named arguments use the same syntax as object literals. All strings except those consisting entirely of digits are legal for argument names. No two arguments may have the same name. Named arguments must follow positional arguments, but otherwise the order of named arguments is immaterial.

ECMAScript 4 Netscape Proposal

Rationale

Operators

Thursday, May 22, 2003

User-overridable operators had originally been part of the ECMAScript 4 proposal but were deferred to a future version of the language in order to keep ECMAScript 4 small. If implemented, operator overriding might behave as described in this section.

Overview

ECMAScript 4 provides a number of operators such as such as +, *, a[b], and -=. These operators are dispatched based on the types of their arguments. Some operators are dispatched only on one operand, in which case the dispatch behaves like property lookup. Other operators are dispatched on two operands simultaneously. Finally, some operators are syntactic sugars for combinations of existing operators.

There are predefined definitions for all ECMAScript operators. In addition, a class may provide additional definitions by overriding the existing behavior. Such overrides apply only when at least one of the dispatched operands is an instance of that class or its descendants. Operator overriding is useful, for example, to implement units without having to add units to the core of the ECMAScript 4 language.

This section presents the expansions of operators in ECMAScript source code, the built-in definitions of those operators, and the means of overriding them.

Invoking Operators

When an operator is invoked in an expression, the corresponding operator is invoked according to the table below. The operator invocations use pseudo-syntax to denote which operator is called; only the expression syntax on the left side of the table can be used to invoke operators.

Expression	Operator Invocation
`+x`	operator `"+"(x)`
`-x`	operator `"-"(x)`
`~x`	operator `"~"(x)`
`++x`	`(x` `=` operator `"++"(x))`
`x++`	`(` `=` `x,` `x` `=` operator `"++"(x),` `)`, where is a temporary variable
`--x`	`(x` `=` operator `"--"(x))`
`x--`	`(` `=` `x,` `x` `=` operator `"--"(x),` `)`, where is a temporary variable
`x(a`₁`,` ...`,` `a_n)`	operator `"()"(x,` `a`₁`,` ...`,` `a_n)`
`new` `x`	operator `"new"(x)`
`new` `x(a`₁`,` ...`,` `a_n)`	operator `"new"(x,` `a`₁`,` ...`,` `a_n)`
`x[a`₁`,` ...`,` `a_n]`	operator `"[]"(x,` `a`₁`,` ...`,` `a_n)`
`x[a`₁`,` ...`,` `a_n] =` `y`	operator `"[]="(x,` `y,` `a`₁`,` ...`,` `a_n)`
`delete` `x[a`₁`,` ...`,` `a_n]`	operator `"delete[]"(x,` `a`₁`,` ...`,` `a_n)`
`x` `+` `y`	operator `"+"(x,` `y)`
`x` `-` `y`	operator `"-"(x,` `y)`
`x` `*` `y`	operator `"*"(x,` `y)`
`x` `/` `y`	operator `"/"(x,` `y)`
`x` `%` `y`	operator `"%"(x,` `y)`
`x` `<<` `y`	operator `"<<"(x,` `y)`
`x` `>>` `y`	operator `">>"(x,` `y)`
`x` `>>>` `y`	operator `">>>"(x,` `y)`
`x` `<` `y`	operator `"<"(x,` `y)`
`x` `>` `y`	operator `"<"(y,` `x)`
`x` `<=` `y`	operator `"<="(x,` `y)`
`x` `>=` `y`	operator `"<="(y,` `x)`
`x` `in` `y`	operator `"in"(x,` `y)`
`x` `==` `y`	operator `"=="(x,` `y)`
`x` `!=` `y`	`!(`operator `"=="(x,` `y))`
`x` `===` `y`	operator `"==="(x,` `y)`
`x` `!==` `y`	`!(`operator `"==="(x,` `y))`
`x` `&` `y`	operator `"&"(x,` `y)`
`x` `^` `y`	operator `"^"(x,` `y)`
`x` `\|` `y`	operator `"\|"(x,` `y)`
`x` `+=` `y`	`(x` `=` operator `"+"(x,` `y))`
`x` `-=` `y`	`(x` `=` operator `"-"(x,` `y))`
`x` `*=` `y`	`(x` `=` operator `"*"(x,` `y))`
`x` `/=` `y`	`(x` `=` operator `"/"(x,` `y))`
`x` `%=` `y`	`(x` `=` operator `"%"(x,` `y))`
`x` `<<=` `y`	`(x` `=` operator `"<<"(x,` `y))`
`x` `>>=` `y`	`(x` `=` operator `">>"(x,` `y))`
`x` `>>>=` `y`	`(x` `=` operator `">>>"(x,` `y))`
`x` `&=` `y`	`(x` `=` operator `"&"(x,` `y))`
`x` `^=` `y`	`(x` `=` operator `"^"(x,` `y))`
`x` `\|=` `y`	`(x` `=` operator `"\|"(x,` `y))`

Operator Dispatch

Unary operators are single-dispatched just like regular methods. in is like a unary operator in that it can only be overridden by its right operand’s class, and it is single-dispatched by its right operand. Like in regular method dispatch, null is considered to be a member of only the types Null and Object.

Binary operator methods are double-dispatched based on the types of both operands. When one of the binary operators is invoked in an expression a b, all applicable operator ""(x, y) methods are examined to find the most specific one, which is then called. A definition of operator ""(x:X, y:Y) is applicable to a b if the value of a is a member of X and the value of b is a member of Y, except that, like in regular method dispatch, null is considered to be a member of only the types Null and Object. A definition of operator ""(x:X, y:Y) is most specific if it is applicable and if every applicable definition of operator ""(x:X', y:Y') satisfies X X' and Y Y'. If there is no most specific applicable definition of or if there is more than one most specific applicable definition of , then an error occurs when the expression a b is evaluated.

One of the operands of an operator expression inside a class C can be a super expression, in which case the set of applicable definitions of the operator is restricted to those defined to take a parameter of type T in that position, where T is any proper ancestor of C. This way a method overriding an operator can invoke its superclass’s definition of that operator.

Expression Grammar Changes

To accommodate super expressions, the grammar rules for expressions would be changed as described below.

Super Expressions

The SuperExpression grammar rule is split into two to make FullSuperExpression into a separate rule:

SuperExpression

super

| FullSuperExpression

FullSuperExpression super ParenExpression

As specified in the grammar below, the SuperExpression must be embedded as an operand of one of the following operators:

The left operand of a . (property lookup), [] (indexing), () (call), new, or new() operator (for the () and new() operators the SuperExpression must be a FullSuperExpression)
The right operand of an in operator
The operand of a unary +, -, ~, ++, or -- operator
Either operand of a binary +, -, *, /, %, <<, >>, >>>, |, ^, &, <, >, <=, >=, ==, !=, ===, or !== operator
Either operand of a +=, -=, *=, /=, %=, <<=, >>=, >>>=, |=, ^=, or &= operator

super changes the behavior of the operator in which it is embedded by limiting its property search to definitions inherited from class C’s superclass. See property lookup and operator dispatch.

Postfix Expressions

These grammar rules are modified to permit super expressions as operands of () (call), new, new(), and postfix ++ and --. Unmodified rules are not shown below.

PostfixExpressionOrSuper

FullPostfixExpression

| FullSuperExpression Arguments

| PostfixExpressionOrSuper [no line break] ++

| PostfixExpressionOrSuper [no line break] --

FullNewExpression

new FullNewSubexpression Arguments

| new FullSuperExpression Arguments

ShortNewExpression

new ShortNewSubexpression

| new SuperExpression

Unary Operators

These grammar rules are modified to permit super expressions as operands of unary +, -, and ~ as well as prefix ++ and -- operators.

UnaryExpression

| delete PostfixExpression

| void UnaryExpression

| typeof UnaryExpression

| ++ PostfixExpressionOrSuper

| -- PostfixExpressionOrSuper

| + UnaryExpressionOrSuper

| - UnaryExpressionOrSuper

| - NegatedMinLong

| ~ UnaryExpressionOrSuper

| ! UnaryExpression

UnaryExpressionOrSuper

Multiplicative Operators

These grammar rules are modified to permit super expressions as operands of binary *, /, and % operators.

MultiplicativeExpression

| MultiplicativeExpressionOrSuper * UnaryExpressionOrSuper

| MultiplicativeExpressionOrSuper / UnaryExpressionOrSuper

| MultiplicativeExpressionOrSuper % UnaryExpressionOrSuper

MultiplicativeExpressionOrSuper

Additive Operators

These grammar rules are modified to permit super expressions as operands of binary + and - operators.

AdditiveExpression

| AdditiveExpressionOrSuper + MultiplicativeExpressionOrSuper

| AdditiveExpressionOrSuper - MultiplicativeExpressionOrSuper

AdditiveExpressionOrSuper

Bitwise Shift Operators

These grammar rules are modified to permit super expressions as operands of the <<, >>, and >>> operators.

ShiftExpression

| ShiftExpressionOrSuper << AdditiveExpressionOrSuper

| ShiftExpressionOrSuper >> AdditiveExpressionOrSuper

| ShiftExpressionOrSuper >>> AdditiveExpressionOrSuper

ShiftExpressionOrSuper

Relational Operators

These grammar rules are modified to permit super expressions as operands of the <, >, <=, and >= operators and the right operand of an in operator.

RelationalExpression^allowIn

| RelationalExpressionOrSuper^allowIn < ShiftExpressionOrSuper

| RelationalExpressionOrSuper^allowIn > ShiftExpressionOrSuper

| RelationalExpressionOrSuper^allowIn <= ShiftExpressionOrSuper

| RelationalExpressionOrSuper^allowIn >= ShiftExpressionOrSuper

| RelationalExpression^allowIn is ShiftExpression

| RelationalExpression^allowIn as ShiftExpression

| RelationalExpression^allowIn in ShiftExpressionOrSuper

| RelationalExpression^allowIn instanceof ShiftExpression

RelationalExpression^noIn

| RelationalExpressionOrSuper^noIn < ShiftExpressionOrSuper

| RelationalExpressionOrSuper^noIn > ShiftExpressionOrSuper

| RelationalExpressionOrSuper^noIn <= ShiftExpressionOrSuper

| RelationalExpressionOrSuper^noIn >= ShiftExpressionOrSuper

| RelationalExpression^noIn is ShiftExpression

| RelationalExpression^noIn as ShiftExpression

| RelationalExpression^noIn instanceof ShiftExpression

RelationalExpressionOrSuper

Equality Operators

These grammar rules are modified to permit super expressions as operands of the ==, !=, ===, and !== operators.

EqualityExpression

| EqualityExpressionOrSuper == RelationalExpressionOrSuper

| EqualityExpressionOrSuper != RelationalExpressionOrSuper

| EqualityExpressionOrSuper === RelationalExpressionOrSuper

| EqualityExpressionOrSuper !== RelationalExpressionOrSuper

EqualityExpressionOrSuper

Binary Bitwise Operators

These grammar rules are modified to permit super expressions as operands of the &, ^, and | operators.

BitwiseAndExpression

| BitwiseAndExpressionOrSuper & EqualityExpressionOrSuper

BitwiseXorExpression

| BitwiseXorExpressionOrSuper ^ BitwiseAndExpressionOrSuper

BitwiseOrExpression

| BitwiseOrExpressionOrSuper | BitwiseXorExpressionOrSuper

BitwiseAndExpressionOrSuper

BitwiseXorExpressionOrSuper

BitwiseOrExpressionOrSuper

Assignment Operators

These grammar rules are modified to permit super expressions as operands of the +=, -=, *=, /=, %=, <<=, >>=, >>>=, |=, ^=, and &= operators.

AssignmentExpression

| PostfixExpressionOrSuper CompoundAssignment AssignmentExpression

| PostfixExpressionOrSuper CompoundAssignment SuperExpression

| PostfixExpression LogicalAssignment AssignmentExpression

Built-In Operator Definitions

All operators have built-in definitions. These are summarized in the table below.

Name	Signature	Behavior
`"()"`	`(x:Object, ...` `args)`	Call `x` with the arguments `args` and return the result.
`"new"`	`(x:Object, ...` `args)`	Call `x`’s constructor slot with the arguments `args` and return the result.
`"[]"`	`(x:Object,` `n:Object)`	Return the value of `x`’s most derived `public` property named `n.toString()`. See property lookup.
`"[]="`	`(x:Object,` `y:Object,` `n:Object)`	Set the value of `x`’s most derived `public` property named `n.toString()` to `y`.
`"[]="`	`(x:Array,` `y:Object,` `n:Object)`	Set the value of `x`’s most derived `public` property named `n.toString()` to `y`. Update the `length` property as in ECMAScript 3.
`"delete[]"`	`(x:Object,` `n:Object)`	Try to delete `x`’s most derived `public` property named `n.toString()`.
`"~"`	`(x:Object)`	Return the bitwise complement of ToInt32(operator `"+"(x)`).
`"++"`	`(x:Object)`	Return operator `"+"(`operator `"+"(x), 1)`.
`"--"`	`(x:Object)`	Return operator `"-"(`operator `"+"(x), 1)`.
`"+"`	`(x:Object)`	Return ToNumber(`x`).
	`(x:Object,` `y:Object)`	Let `x'` = ToPrimitive(`x`) and `y'` = ToPrimitive(`y`). If at least one of `x'` and `y'` is a string, then return operator `"+"(x',` `y')`. Otherwise return ToNumber(`x'`) + ToNumber(`y'`).
	`(x:String,` `y:Object)`	Return `x` concatenated with `y.toString()`.
	`(x:Object,` `y:String)`	Return `x.toString()` concatenated with `y`.
	`(x:String,` `y:String)`	Return `x` concatenated with `y`.
	`(x:Number,` `y:Number)`	Return `x` + `y`.
`"-"`	`(x:Object)`	Return -ToNumber(`x`).
`"-"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) – ToNumber(`y`).
`"*"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) ToNumber(`y`).
`"/"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) / ToNumber(`y`).
`"%"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) % ToNumber(`y`).
`"<<"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) << ToNumber(`y`).
`">>"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) >> ToNumber(`y`).
`">>>"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) >>> ToNumber(`y`).
`"<"`	`(x:Object,` `y:Object)`	Same as in ECMAScript 3.
`">="`	`(x:Object,` `y:Object)`	Same as in ECMAScript 3.
`"in"`	`(x:Object,` `y:Object)`	Same as in ECMAScript 3.
`"=="`	`(x:Object,` `y:Object)`	Same as in ECMAScript 3.
`"==="`	`(x:Object,` `y:Object)`	Same as in ECMAScript 3.
`"&"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) & ToNumber(`y`).
`"^"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) ^ ToNumber(`y`).
`"\|"`	`(x:Object,` `y:Object)`	Return ToNumber(`x`) \| ToNumber(`y`).

Operator Overriding

An operator can be overridden only inside a class C. That class should define a function with the operator attribute (operator is an additional member modifier attribute). The function’s name must be one of the strings in the table below. The name must be a string rather than an identifier; the FunctionName grammar rule is extended to allow strings:

FunctionName

Identifier

| get [no line break] Identifier

| set [no line break] Identifier

| String

A FunctionName can be a String only for operator overrides.

The table also defines the acceptable signatures that the operator can have. At least one parameter must be specified as taking a value of type C (a type that is a subclass of C is not acceptable). If the operator is ===, then both parameters must take values of type C. A class can define several different signatures of the same binary (but not unary) operator, differing in the choice of parameter types X or Y, which may be omitted if they are Object. The parameters denoted as taking types C, X, or Y in the table below cannot be optional or named parameters. The return type of an operator override can be any type.

Name	Signatures
`"~" "++" "--"`	`(x:C)`
`"+" "-"`	`(x:C)` `(x:C,` `y:Y)` `(x:X,` `y:C)` `(x:C,` `y:C)`
`"*" "/" "%" "<<" ">>" ">>>" "<" "<=" "==" "&" "^" "\|"`	`(x:C,` `y:Y)` `(x:X,` `y:C)` `(x:C,` `y:C)`
`"==="`	`(x:C,` `y:C)`
`"in"`	`(x:X,` `y:C)`
`"()" "new" "[]" "delete[]"`	`(x:C,` `a`₁`,` ...`,` `a_n)`
`"[]="`	`(x:C,` `y:Y,` `a`₁`,` ...`,` `a_n)`

The operator methods should return the result of the operator. For the ++ and -- operators, the result is the incremented or decremented value. The (), new, [], delete[], and []= operators take additional argument lists. If desired, these argument lists can include optional, named, or rest arguments. The []= operator must take one more initial required parameter, which is the value stored in the element.

The >, >=, !=, and !== operators cannot be overridden directly because they are syntactic sugars for invocations of the <, <=, ==, and === operators; override the latter operators instead. The !, ||, ^^, &&, and ?: operators cannot be overridden directly, but they are affected by any redefinition of toBoolean. The reason for not overriding ||, &&, and ?: is that they do not always evaluate all of their arguments, and programmers often take advantage of this short-circuiting behavior. ! is not overridable in order to preserve useful identities such as:

if (!x) A else B if (x) B else A
!(x && y) !x || !y
x != y !(x == y)

Definitions of operators cannot specify a namespace. No access restrictions can be imposed on operators.

Example

The following class illustrates overriding a few operators.

class Complex {
  var x:Number, y:Number;

  operator function "+"(a:Complex):Complex {
    return a;
  }

  operator function "-"(a:Complex):Complex {
    return new Complex(x: -a.x, y: -a.y);
  }

  operator function "+"(a:Complex, b:Complex):Complex {
    return new Complex(x: a.x+b.x, y: a.y+b.y);
  }

  operator function "+"(a:Complex, b:Number):Complex {
    return new Complex(x: a.x+b, y: a.y);
  }

  operator function "+"(a:Number, b:Complex):Complex {
    return new Complex(x: a+b.x, y: b.y);
  }

  function toBoolean():Boolean {
    return this.x != 0 || this.y != 0;
  }
}

`toBoolean` Method

Just like toString, every object has a toBoolean method that can be overridden. This method is called by statements such as if, while, do while, and for and operators such as !, ||, ^^, &&, and ? :. This method should return either true or false.

For-In Operator

An object x’s class can override the meaning of for-in loops such as for (v in x) by overriding the following three methods which are located in the system-defined namespace Iterator:

Method	Description
`x.Iterator::forIn()`	If the iteration is empty, return `null`. Otherwise, return an object `o` with `public` properties named `value` and `state` (`o` may also have other properties). The value of `o.value` is the first element returned by the iteration. The value of `o.state` can have any type and will be passed exactly once to either `Iterator::next` or `Iterator::done`. The value of `o` is not guaranteed to be valid after `o.state` is passed to `Iterator::next` or `Iterator::done`.
`x.Iterator::next(i)`	`i` was returned by a previous call to `Iterator::forIn` or `Iterator::next`. If the iteration is done, return `null`. Otherwise, return an object `o` with `public` properties named `value` and `state` (`o` may also have other properties). The value of `o.value` is the next element returned by the iteration. The value of `o.state` can have any type and will be passed exactly once to either `Iterator::next` or `Iterator::done`. The value of `o` is not guaranteed to be valid after `o.state` is passed to `Iterator::next` or `Iterator::done`.
`x.Iterator::done(i)`	`i` was returned by a previous call to `Iterator::forIn` or `Iterator::next`. This call alerts `x` that the iteration is exiting prematurely and it can do whatever cleanup it needs on `i`. Every `i` returned by `Iterator::forIn` or `Iterator::next` is guaranteed to be subsequently passed exactly once either to `Iterator::next` or `Iterator::done`. `Iterator::done` should return `undefined`.

Rationale

A few other approaches had been considered for overriding the for-in operator. The three-method approach above was chosen for the following reasons:

Why use an iterator object instead of a function and a callback (i.e. have Iterator::forIn take a parameter f and have it call f for each element in the collection)? The reason is that the iterator model permits future extensions such as iterating through two collections concurrently. This cannot be done using callbacks.
Why return an object from Iterator::forIn and Iterator::next instead of having Iterator::forIn and Iterator::next return just an iterator and having a separate Iterator::get method that, given an iterator, returns an element? The rationale here is that the separate Iterator::get method would introduce unavoidable concurrency hazards. Since null (or any other value) can be a member of a collection, we can’t use the return value from Iterator::get to detect the end of iteration; instead, we’d have to use a null return value from Iterator::forIn or Iterator::next to indicate the end of iteration. In such a case, however, it would be possible for another thread to delete the last element between the call to Iterator::forIn or Iterator::next and the call to Iterator::get, and Iterator::get would then be stuck. We could use an exception to indicate the end of iteration, but this would put exception handling on the fast path of program execution.
Why use an object with two named slots rather than a two-element read-only array for the return value? Named slots can have heterogeneous types, while the types of array elements must be the same.
Why define Iterator::done? Some objects may erect temporary scaffolding to support iteration. This method informs them that they can take down such scaffolding. Since ECMAScript currently lacks finalization, there is no other way for the iterated object to know that the iteration aborted early — the start of another iteration cannot be used as an indication that the previous iteration completed because several iterations can be happening simultaneously on the same object.

Class Reflection Operator

Earlier drafts of this proposal had a .class operator that returned an instance’s class. This operator was defined using the grammar production:

PropertyOperator

. QualifiedIdentifier

| . class

| Brackets

The operator was removed because obtaining an instance’s class breaks abstraction. The client of a factory method m could determine whether m was returning instances of some stated class C or subclasses of C, and m could not evolve to alter its implementation decision of what precise instances to return without potentially breaking clients.

ECMAScript 4 Netscape Proposal

Rationale

Units

Friday, September 20, 2002

Units derived from the Spice proposals had originally been part of the ECMAScript 4 proposal but were deferred to a future version of the language in order to keep ECMAScript 4 small. If implemented, units might behave as described in this section.

Lexing Units

A unit expression usually consists of a number followed by a unit name with no intervening white space, as in 7cm. The unit name can be quoted (for example, 7 "cm"), in which case white space is permitted between the number and the unit and the unit name can instead be a unit pattern (for example, 7 "Kg*cm^2/s").

When a numeric literal is immediately followed by an identifier, the lexer converts the identifier to a string literal. The parser then treats the number and string as a unit expression. The identifier cannot start with an underscore, but there are no reserved word restrictions on the identifier; any identifier that begins with a letter will work, even if it is a reserved word.

For example, 3in is converted to 3 "in". 5xena is converted to 5 "xena". On the other hand, 0xena is converted to 0xe "na". It is unwise to define unit names that begin with the letters e or E either alone or followed by a decimal digit, or x or X followed by a hexadecimal digit because of potential ambiguities with exponential or hexadecimal notation.

Unit Expressions

PrimaryExpression

null

| true

| false

| public

| Number

| String

| this

| RegularExpression

| UnitExpression

UnitExpression

ParenListExpression

| Number [no line break] String

| UnitExpression [no line break] String

A Number literal, ParenListExpression, or UnitExpression followed by a String literal is a unit expression, which is evaluated as follows:

Evaluate the String literal to obtain a string S. Parse that string according to the unit pattern grammar and semantics to obtain a list of identifiers and exponents [id₁^e₁, id₂^e₂, ..., id_n^e_n]. If the parse fails, signal a syntax error. If the list is empty, let U be the function nullUnit, which accepts one required and one optional argument and returns its first argument, ignoring the optional argument.

If the list is not empty, for each i between 1 and n, let V_i be the value of looking up id_i in the system unit namespace. If e_i is 1, let F_i = V_i; otherwise, let F_i = V_i.public::pow(e_i). Then let U = F₁*F₂*...*F_n. For example, if S is "Kg*m^2/s^2*q", then U is the value of unit::Kg*unit::m.public::pow(2)*unit::s.public::pow(–2)*unit::q.public::pow(–1), where unit is the system unit namespace (the distinction between unit and the name unit is only relevant for perverse code that has a local definition named unit; the presence of such a local definition doesn’t affect unit lookup).

The result U should be callable as a function that accepts one required and one optional argument. The unit expression calls U, providing the numeric value of the Number literal, ParenListExpression, or UnitExpression as the first argument. The second argument is present only for the UnitExpression Number [no line break] String production, in which case it is the original Number literal expressed as a string. Continuing the example above, the unit expression 32.50 "Kg*m^2/s^2*q", evaluates to the result of (unit::Kg*unit::m.public::pow(2)*unit::s.public::pow(–2)*unit::q.public::pow(–1))(32.5, "32.50").

U’s second argument allows user-defined unit classes to define extended syntaxes for numbers. For instance, a long-integer package might define a unit called "L" that treats the Number literal as a full 64-bit number without rounding it to a float64 first. Such a unit can be combined with other units by listing the units one after another; note that the lexer allows the first unit to be unquoted if it directly follows the number: 3L "cm" is the same as 3 "L" "cm" and evaluates to the result of unit::cm(unit::L(3, "3")).

Defining Units

Units are defined by placing them in the unit namespace, which is predefined by the system. Unit expressions are implicitly qualified using the unit namespace. The unit namespace is not used by default, so a program needs to explicitly qualify identifiers with unit:: to access existing unit definitions..

The easiest way to define new units is to scale, multiply, or divide existing ones. For example:

unit const µm = unit::m/1e6;
unit const Å = unit::m/1e10;
unit const dm = unit::m/10;
unit const \_in = unit::m*0.0254;
unit const liter = unit::dm.pow(3);

\_ must be used to define the unit in because in is a reserved word. However, the unit in may be used without quoting it, as in the expression 3in + 5cm.

Unit Class Extension

If class extensions were also added to the language, the class extension mechanism could be used instead of a unit namespace to define units. This way units could be designated as internal, private, etc.

The unit attribute would be defined as though

const unit = extend(Unit);

were evaluated at the top level. Unit would be the class that holds the definitions of unit names.

ECMAScript 4 Netscape Proposal

Rationale

Unit Patterns

Monday, June 30, 2003

This LALR(1) grammar describes the syntax of quoted unit patterns. The semantics describe the actions the lexer takes in order to interpret a quoted unit pattern. The input to this grammar and semantics is the unit string literal’s contents after the string literal has been processed. See also the description of the semantic notation.

This document is also available as a Word RTF file.

The start nonterminal is UnitPattern.

White Space

Syntax

{wsopt, wsreq}

WhiteSpaceCharacter

«TAB» | «VT» | «FF» | «SP» | «u00A0»

| «u2000» | «u2001» | «u2002» | «u2003» | «u2004» | «u2005» | «u2006» | «u2007»

| «u2008» | «u2009» | «u200A» | «u200B»

| «u3000»

LineTerminator «LF» | «CR» | «u0085» | «u2028» | «u2029»

RequiredWhiteSpace

WhiteSpaceCharacter

| LineTerminator

| RequiredWhiteSpace WhiteSpaceCharacter

| RequiredWhiteSpace LineTerminator

WhiteSpace^wsopt

RequiredWhiteSpace

| «empty»

WhiteSpace^wsreq RequiredWhiteSpace

Unit Patterns

Syntax

UnitPattern WhiteSpace^wsopt UnitQuotient

UnitQuotient

UnitProduct^wsopt

| UnitProduct^wsopt / WhiteSpace^wsopt UnitProduct^wsopt

UnitProduct

UnitFactor

| UnitProduct^wsopt * WhiteSpace^wsopt UnitFactor

| UnitProduct^wsreq UnitFactor

UnitFactor

1 WhiteSpace

| 1 WhiteSpace^wsopt ^ WhiteSpace^wsopt SignedInteger WhiteSpace

| Identifier WhiteSpace

| Identifier WhiteSpace^wsopt ^ WhiteSpace^wsopt SignedInteger WhiteSpace

Semantics

tuple UnitFactor

identifier: String,

exponent: Integer

end tuple;

UnitList = UnitFactor[];

proc unitReciprocal(value: UnitList): UnitList

return [UnitFactoridentifier: f.identifier, exponent: –f.exponent | f value]

end proc;

Value[UnitPattern WhiteSpace^wsopt UnitQuotient]: UnitList = Value[UnitQuotient];

Value[UnitQuotient]: UnitList;

Value[UnitQuotient UnitProduct^wsopt] = Value[UnitProduct^wsopt];

Value[UnitQuotient UnitProduct^wsopt₁ / WhiteSpace^wsopt UnitProduct^wsopt₂] = Value[UnitProduct^wsopt₁] unitReciprocal(Value[UnitProduct^wsopt₂]);

Value[UnitProduct]: UnitList;

Value[UnitProduct UnitFactor] = Value[UnitFactor];

Value[UnitProduct₀ UnitProduct^wsopt₁ * WhiteSpace^wsopt UnitFactor] = Value[UnitProduct^wsopt₁] Value[UnitFactor];

Value[UnitProduct₀ UnitProduct^wsreq₁ UnitFactor] = Value[UnitProduct^wsreq₁] Value[UnitFactor];

Value[UnitFactor]: UnitList;

Value[UnitFactor 1 WhiteSpace] = [];

Value[UnitFactor 1 WhiteSpace^wsopt ^ WhiteSpace^wsopt SignedInteger WhiteSpace] = [];

Value[UnitFactor Identifier WhiteSpace] = [UnitFactoridentifier: Name[Identifier], exponent: 1];

Value[UnitFactor Identifier WhiteSpace^wsopt ^ WhiteSpace^wsopt SignedInteger WhiteSpace] = [UnitFactoridentifier: Name[Identifier], exponent: IntegerValue[SignedInteger]];

Signed Integers

Syntax

SignedInteger

DecimalDigits

| + DecimalDigits

| - DecimalDigits

DecimalDigits

ASCIIDigit

| DecimalDigits ASCIIDigit

ASCIIDigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Semantics

IntegerValue[SignedInteger]: Integer;

IntegerValue[SignedInteger DecimalDigits] = IntegerValue[DecimalDigits];

IntegerValue[SignedInteger + DecimalDigits] = IntegerValue[DecimalDigits];

IntegerValue[SignedInteger - DecimalDigits] = –IntegerValue[DecimalDigits];

IntegerValue[DecimalDigits]: Integer;

IntegerValue[DecimalDigits ASCIIDigit] = DecimalValue[ASCIIDigit];

IntegerValue[DecimalDigits₀ DecimalDigits₁ ASCIIDigit] = 10IntegerValue[DecimalDigits₁] + DecimalValue[ASCIIDigit];

DecimalValue[ASCIIDigit]: Integer = digitValue(ASCIIDigit);

Identifiers

Syntax

Identifier

InitialIdentifierCharacter

| Identifier ContinuingIdentifierCharacter

InitialIdentifierCharacter UnicodeInitialAlphabetic | $ | _

ContinuingIdentifierCharacter UnicodeAlphanumeric | $ | _

UnicodeInitialAlphabetic Any Unicode initial alphabetic character (includes ASCII A-Z and a-z)

UnicodeAlphanumeric Any Unicode alphabetic or decimal digit character (includes ASCII 0-9, A-Z, and a-z)

Semantics

Name[Identifier]: String;

Name[Identifier InitialIdentifierCharacter] = [InitialIdentifierCharacter];

Name[Identifier₀ Identifier₁ ContinuingIdentifierCharacter] = Name[Identifier₁] [ContinuingIdentifierCharacter];

ECMAScript 4 Netscape Proposal

Rationale

Syntax

Tuesday, November 19, 2002

This section presents a number of syntactic alternatives that were considered while developing this proposal.

Semicolon Insertion

Definitions

The term semicolon insertion informally refers to the ability to write programs while omitting semicolons between statements. In both ECMAScript 3 and ECMAScript 4 there are two kinds of semicolon insertion:

Grammatical Semicolon Insertion: Semicolons before a closing } and the end of the program are optional in both ECMAScript 3 and 2.0. In addition, the ECMAScript 4 parser allows semicolons to be omitted before the else of an if-else statement and before the while of a do-while statement.
Line-Break Semicolon Insertion: If the first through the n^th tokens of an ECMAScript program form are grammatically valid but the first through the n+1^st tokens are not and there is a line break between the n^th tokens and the n+1^st tokens, then the parser tries to parse the program again after inserting a VirtualSemicolon token between the n^th and the n+1^st tokens.

Grammatical semicolon insertion is implemented directly by the syntactic grammar’s productions, which simply do not require a semicolon in the aforementioned cases. Line breaks in the source code are not relevant to grammatical semicolon insertion.

Line-break semicolon insertion cannot be easily implemented in the syntactic grammar. This kind of semicolon insertion turns a syntactically incorrect program into a correct program and relies on line breaks in the source code.

Discussion

Grammatical semicolon insertion is harmless. On the other hand, line-break semicolon insertion suffers from the following problems:

Line breaks are relevant in the program’s source code
The consequences of this kind of semicolon insertion appear inconsistent to programmers
Existing program behavior can change unexpectedly when new syntax is introduced

The first problem presents difficulty for some preprocessors such as the one for XML attributes which turn line breaks into spaces. The second and third ones are more serious. Programmers are confused when they discover that the program

a = b + c
(d + e).print()

doesn’t do what they expect:

a = b + c;
(d + e).print();

Instead, that program is parsed as:

a = b + c(d + e).print();

The third problem is the most serious. New features are added to the language turn illegal syntax into legal syntax. If an existing program relies on the illegal syntax to trigger line-break semicolon insertion, then the program will silently change behavior once the feature is added. For example, the juxtaposition of a numeric literal followed by a string literal (such as 4 "in") is illegal in ECMAScript 3. ECMAScript 4 makes this legal syntax for expressions with units. This syntax extension has the unfortunate consequence of silently changing the meaning of the following ECMAScript 3 program:

a = b + 4
"in".print()

from:

a = b + 4;
"in".print();

to:

a = b + 4"in".print();

ECMAScript 4 gets around this incompatibility by adding a [no line break] restriction in the grammar that requires the numeric and string literals to be on the same line. Unfortunately, this compatibility is a double-edged sword. Due to ECMAScript 3 compatibility, ECMAScript 4 has to have a large number of these [no line break] restrictions. It is hard to remember all of them, and forgetting one of them often silently causes an ECMAScript 4 program to be reinterpreted. Some programmers will be dismayed to find that:

internal
  function f(x) {return x*x}

turns into:

internal;
function f(x) {return x*x}

(where internal; is an expression statement) instead of:

internal function f(x) {return x*x}

An earlier version of ECMAScript 4 disallowed line-break semicolon insertion. The current version allows it but only in non-strict mode. Strict mode removes all [no line break] restrictions, simplifying the language again. As a side effect, it is possible to write a program that does different things in strict and non-strict modes (the last example above is one such program), but this is the price to pay to achieve simplicity.

Regular Expression Literals

ECMAScript 4 retains compatibility with ECMAScript 3 by adopting the same rules for detecting regular expression literals. This complicates the design of programs such as syntax-directed text editors and machine scanners because it makes it impossible to find all of the tokens in an ECMAScript program without parsing the program.

Making ECMAScript 4’s lexical grammar independent of its syntactic grammar significantly would have allowed tools to easily process an ECMAScript program and escape all instances of, say, </ to properly embed an ECMAScript 4 or later program in an HTML page. The full parser changes for each version of ECMAScript. To illustrate the difficulties, compare such ECMAScript 3 gems as:

for (var x = a in foo && "</x>" || mot ? z:/x:3;x<5;y</g/i) {xyz(x++);}
for (var x = a in foo && "</x>" || mot ? z/x:3;x<5;y</g/i) {xyz(x++);}

Alternate Regular Expression Syntax

One idea explored early in the design of ECMAScript 4 was providing an alternate, unambiguous syntax for regular expressions and encouraging the use of the new syntax. A RegularExpression could have been specified unambiguously using « and » as its opening and closing delimiters instead of / and /. For example, «3*» would be a regular expression that matches zero or more 3’s. Such a regular expression could be empty: «» is a regular expression that matches only the empty string, while // starts a comment. To write such a regular expression using the slash syntax one needs to write /(?:)/.

Syntactic Resynchronization

Syntactic resynchronization occurs when the lexer needs to find the end of a block (the matching }) in order to skip a portion of a program written in a future version of ECMAScript. Ordinarily this would not be a problem, but regular expressions complicate matters because they make lexing dependent on parsing. The rules for recognizing regular expression literals must be changed for those portions of the program. The rule below might work, or a simplified parse might be performed on the input to determine the locations of regular expressions. This is an area that needs further work.

During syntax resynchronization ECMAScript 4 determines whether a / starts a regular expression or is a division (or /=) operator solely based on the previous token:

/ interpretation Previous token

/ or /= Identifier Number RegularExpression String
) ++ -- ] }
class false null private protected public super this true
get set
Any other punctuation

RegularExpression ! != !== # % %= & && &&= &= ( * *= + += , - -= -> . .. ... / /= : :: ; < << <<= <= = == === > >= >> >>= >>> >>>= ? @ [ ^ ^= ^^ ^^= { | |= || ||= ~
abstract break case catch const continue debugger default delete do else enum export extends final finally for function goto if implements import in instanceof interface is namespace native new package return static switch synchronized throw throws transient try typeof use var volatile while with

Regardless of the previous token, // is interpreted as the beginning of a comment.

The only controversial choices are ) and }. A / after either a ) or } token can be either a division symbol (if the ) or } closes a subexpression or an object literal) or a regular expression token (if the ) or } closes a preceding statement or an if, while, or for expression). Having / be interpreted as a RegularExpression in expressions such as (x+y)/2 would be problematic, so it is interpreted as a division operator after ) or }. If one wants to place a regular expression literal at the very beginning of an expression statement, it’s best to put the regular expression in parentheses. Fortunately, this is not common since one usually assigns the result of the regular expression operation to a variable.

Type Declarations

The current ECMAScript 4 proposal uses Pascal-style colons to introduce types in declarations. For example:

var x:Integer = 7;
function square(a:Number):Number {return a*a}

This is due to a consensus decision of the ECMA working group, with Waldemar the only dissenter. There are a couple of alternative syntaxes:

C-Style

We could allow modified C-style type declarations as long as a function’s return type is listed after its parameters:

var Integer x = 7;
var Integer y = 8, Integer z = 9;  // Declares two Integer variables
function square(Number a) Number {return a*a}

A function’s return type cannot be listed before the parameters because this would make the grammar ambiguous.

In fact, an implementation could unambiguously admit both the Pascal-style and the modified C-style declarations by replacing the TypedIdentifier and Result grammar rules with the ones listed below. The resulting grammar is still LALR(1).

TypedIdentifier

Identifier

| Identifier : TypeExpression

| TypeExpression Identifier

Result

«empty»

| : TypeExpression^allowIn

| [lookahead{{}] TypeExpression^allowIn

Advantages of using the modified C-style syntax include:

On the Pascal/Modula/Ada vs. C/C++/Java syntax debate, ECMAScript tends to use syntax more similar to Java.
We already use the colon syntax for statement labels and object literal elements (for example {a:17, b:33}). The latter would present a conundrum if we ever wanted to declare field types in an object literal. Some programmers have been using these as a convenient facility for passing named arguments to functions.

Attribute-Style

Since attributes are simple expressions, we could allow attributes that evaluate to types. For var and const declarations, these attributes would specify the type of the declared variables. For function declarations, these attributes would specify the function’s return type. For stylistic consistency, types of arguments would also be listed before their identifiers.

Integer var x = 7;
Integer var y = 8, z = 9;        // Declares two Integer variables
Number function square(Number a) {return a*a}

This style is simple and reads fairly naturally.

Again, an implementation could unambiguously admit both the Pascal-style and the attribute-style declarations, with the resulting grammar still being LALR(1). However, it’s better if the language made a choice rather than propagating the confusion of having two or three styles; this flexibility could be used for compatibility with existing programs.

Type Expressions

ECMAScript 4 uses the same syntax for type expressions as for value expressions for the following reasons:

Creating two different syntaxes for two kinds of expressions would add to the complexity of the language.
ECMAScript is a dynamic language and it is useful to manipulate types as though they were first-class values.
It’s difficult to unambiguously distinguish type expressions from value expressions. In the expression (expr1)(expr2), is expr1 a type or a value expression? If the two have the same syntax, it doesn’t matter.

Function Declarations

Getters and Setters

By consensus in the ECMA TC39 modularity subcommittee, we decided to use the syntax function get id (...) rather than getter function id (...) for defining a getter and function set id (...) rather than setter function id (...) for defining a setter. The latter would have simplified the FunctionName rule to:

FunctionName Identifier

while creating two additional attributes, getter and setter. The decision was based on aesthetics; neither syntax is more difficult to implement than the other.

Language Directives

An alternative to pragmas that was considered early was to report syntax errors at the time the relevant statement was executed rather than at the time it was parsed. This way a single program could include parts written in a future version of ECMAScript without getting an error unless it tries to execute those portions on a system that does not understand that version of ECMAScript. If a program part that contains an error is never executed, the error never breaks the script. For example, the following function finishes successfully if whizBangFeature is false:

function move(x:Integer, y:Integer, d:Integer) {
  x += 10;
  y += 3;
  if (whizBangFeature) {
    simulate{@x and #y} along path
  } else {
    x += d; y += d;
  }
  return [x,y];
}

The code simulate{@x and #y} along path is a syntax error, but this error does not break the script unless the script attempts to execute that piece of code.

One problem with this approach is that it frustrates debugging; a script author benefits from knowing about syntax errors at compile time rather than at run time.

ECMAScript 4 Netscape Proposal

Rationale

Miscellaneous

Wednesday, June 4, 2003

This section presents a number of miscellaneous alternatives that were considered while developing this proposal.

Types

`Object`

The root of the type hierarchy was chosen to be the existing ECMAScript 3 type Object. Primitive numbers, strings, and booleans were made into instances of subclasses of Object and the existing wrapper classes eliminated, thereby eliminating the confusing distinction between boolean primitives and objects, etc. in ECMAScript 3.

The alternative was to define a new root type, any, that is an ancestor of Object as well as primitive numbers, strings, and booleans, which could have their own types number, string, and boolean respectively. In this scenario the ECMAScript 3 classes Number, String, and Boolean would still be subclasses of Object, but the primitive values could not be members of these classes — for example, false would be a member of the class boolean but not Boolean. The object obtained by boxing false would be a member of the class Boolean but not boolean and would evaluate to true (!) if used in an if statement.

The any alternative was more compatible with ECMAScript 3, but the added complexity and confusion was not deemed worthwhile for the extra compatibility. Instead, ECMAScript 4 simplifies and regularizes the behavior of ECMAScript 3 in this area.

`Never` and `Void`

The types Never and Void are different and serve different purposes. When used as a return type, Never describes the inability to return from a function, while Void states that the function returns, but the value returned is not useful (it’s always undefined).

The following example illustrates the use of Never and Void:

// This function returns no useful value.
function display(message:String):Void {
  document.write("<\_P>" + message + "<\/P>\n");
}

// This function cannot return.
function abort(message:String):Never {
  display(message);
  throw AbortException;
}

function chickenCount(myChickens:Array[Chicken]):Integer {
  if (notHatched(myChickens))
    abort("Can’t count the chickens yet");
  else
    return myChickens.length;
}

Note that if the function abort had no explicit return type or any return type other than Never, then the compiler would likely issue a warning inside the function chickenCount because it contains a code path (the false case of its if) that appears to fall out of the function without returning a value, while chickenCount is declared to return an Integer. The Never return type on abort tells the compiler that there is no such code path inside chickenCount.

It might be a good idea for a compiler to issue a warning for a function that is declared as returning type Never for which the compiler can’t verify that the function can’t return.

Typed Arrays

The proposal originally had additional array types which were dropped for simplicity. The following are some candidates for a future revision of the language:

Type	Set of Values
`Array`	Same as `Array[Object]`
`Array[t]`	`null` as well as all arrays (dense or sparse) capable of holding elements of type `t`
`List[t]`	`null` as well as all resizeable, dense arrays capable of holding elements of type `t`
`t[]`	`null` as well as all nonresizeable, dense arrays capable of holding elements of type `t`
`ConstArray`	Same as `ConstArray[Object]`
`ConstArray[t]`	`null` as well as all constant arrays capable of holding elements of type `t`

A sparse array may have holes. A dense array always has contiguous elements indexed starting from zero. Resizeable arrays may be resized by writing to the length property.

When A is one of the type expressions Array[t], List[t], t[], ConstArray, or ConstArray[t], the following three operations can be used to create an array of type A or coerce to one:

new A(elt1, elt2, ...) creates an instance of the corresponding array type with the given elements; this is true even if there is only one element given.
new A(length: n) creates an instance of the corresponding array type with a length of n. The initial elements are holes if the array is sparse or the default value for A’s element type if the array is dense. Note that this form requires the named function parameters extension.
A(B) creates an instance of the corresponding array type. The new instance’s elements are copied from B, which should be any kind of an array. It’s unresolved what should happen if A is a dense array and B has holes.

Instances of non-ConstArray array types are equal only when they are the same object. Instances of ConstArray array types are equal when they have the same contents and the same element type t.

Type Expressions

We could define other type operators such as the ones in the table below. s and t are type expressions.

Type	Values	Implicit coercion of value `v`
`t[]`	`null` as well as nonresizable arrays of values of type `t`	`undefined` `null`
`const` `t`	Makes type `t`, which must be an array type, into a read-only array type	None
`-` `t`	Any value belonging to type `t` except `null`
`~` `t`	`undefined` or any value belonging to type `t`	`undefined` `undefined`; any other implicit coercions already defined for `t`
`+t`	`null` or any value belonging to type `t`	`null` `null`; `undefined` `null` (if `undefined` is not a member of `t`); any other implicit coercions already defined for `t`
`s` `+` `t`	All values belonging to either type `s` or type `t` or both	If `vs+t`, then use `v`; otherwise, if `v` `as` `s` is defined then use `v` `as` `s`; otherwise, if `v` `as` `t` is defined then use `v` `as` `t`.
`s` `*` `t`	All values simultaneously belonging to both type `s` and type `t`	If `v` `as` `s` `as` `t` is defined and is a member of `s*t`, then use `v` `as` `s` `as` `t`.
`s` `/` `t`	All values belonging to type `s` but not type `t`	If `v` `as` `s` is defined and is a member of `s/t`, then use `v` `as` `s`.

The [] suffix operator could be used to make array types. Unlike Array, these arrays would be dense, indexable only by integers, nonresizable, and non-subclassable — t[] has the class modifier final.

A new unary operator, const, could be added. This operator would take a PostfixExpressionOrSuper x as an operand. If x is an instance of a non-ConstArray array, const x would return a ConstArray[T] copy of x, where T is the most specific type such that every element of x is a member of T. If x is an array type, const x would be the corresponding ConstArray type.

t[] is the type of writable arrays of t.
const t[] is the type of constant arrays of t.
t[][] is the type of writable arrays of writable arrays of t.
const t[][] is the type of constant arrays of writable arrays of t — const binds looser than [] so it’s the same as const (t[])[].
(const t[])[] is the type of writable arrays of constant arrays of t.

Multiple Constructors

Earlier ECMAScript 4 proposals allowed a class to have multiple constructors with different names, callable using the same syntax as calling static functions. These were dropped to keep the language simple. Since now each class can have at most one constructor, the this(args) form for calling another constructor from the same class was also dropped. Constructors had been defined as described below.

A constructor is a function that creates a new instance of a class C. Constructors are defined using the attribute constructor. A constructor is usually given the same name as its class, in which case the constructor attribute is optional and the constructor is known as a default constructor and can be called as new C. If a constructor has a different name, it is invoked as though it were a static function of the class:

class C {
  var a:String;

  constructor function C(p:String) {this.a = "New "+p}      // The attribute constructor is optional here
  constructor function make(p:String) {this.a = "Make "+p}
  static function obtain(p:String):C {return new C(p)}
}

var c:C = new C("one");
var d:C = C.C("two");
var e:C = C.make("three");
var f:C = C.obtain("four");

c.a;     // Returns "New one"
d.a;     // Returns "New two"
e.a;     // Returns "Make three"
f.a;     // Returns "New four"

A constructor should not return a value with a return statement; the newly created object is returned automatically. A constructor’s return type must be omitted.

A constructor function always returns a new instance. On the other hand, a static function can return an existing instance of its class. It is possible to define a static function with the same name as its class C; such a function looks like a constructor to the outside (it can be called as new C) but can hand out existing instances of its class. However, subclasses will see that C is not a constructor in such a class because they will not be able to invoke C’s pseudo-constructor from their constructors.

If a class C does not define the default constructor C.C, the default constructor C.C is automatically defined; that constructor takes the arguments that C’s superclass’s default constructor B.B takes. C.C calls B.B and then initializes C’s new instance members to their default values.

Calling a Superconstructor

Let C be a class and B its superclass. Any constructor C.n must call a constructor B.m or C.m before it accesses this or super or before it returns. The call can be either explicit or implicit; if C.n does not contain any calls to a constructor B.m or C.m, then a call to B.B with no arguments is automatically inserted as the first statement of C.n. The constructor C.n does not have to call another constructor if it exits by throwing an exception. C.n may not make a constructor call more than once.

A constructor C.n can call another constructor using one of the following statements:

`super(args)`	Calls `B`’s default constructor `B.B`.
`super.m(args)`	Calls `B`’s constructor `B.m`. `m` must be a QualifiedIdentifier that names one of `B`’s constructors.
`this(args)`	Calls `C`’s default constructor `C.C`.
`this.m(args)`	Calls `C`’s constructor `C.m`. `m` must be a QualifiedIdentifier that names one of `C`’s constructors.

The above must be complete statements, not subexpressions of larger expressions. The first of the four forms above is unambiguously a SuperStatement, but the remaining three are parsed as ExpressionStatements. The following rules indicate whether one of these three forms (super.m(args), this(args), or this.m(args)) is treated as an expression or a call to a constructor:

If the form is part of a larger expression (for example, this(3,4)+5), then it is an expression.
If the form is not located inside a constructor (excluding nested functions), then it is an expression.
If m in super.m(args) does not name one of the superclass’s constructors, then the form is an expression (that, in this case, looks up the superclass’s property m on this and invokes it as a method with the arguments args).
If m in this.m(args) does not name one of the current class’s constructors, then the form is an expression (that, in this case, looks up the property m on this and invokes it as a method with the arguments args).
Otherwise, the form is a constructor call.

It is not possible to skip class hierarchy levels while constructing an object — if C’s superclass is B and B’s superclass is A, then one of C’s constructors may not directly call one of A’s constructors.

Class Extensions

A class extension is the ability to add methods to a class defined somewhere else. Class extensions were part of the ECMAScript 4 proposal but were dropped to keep the language simple; although useful, they significantly complicated the design of classes and introduced some pesky problems such as what to do when a package P first imports a base class C from package Q, then defines a subclass D of C, and finally extends C with an extension with the same name and namespace as a method of D.

The proposed class extensions were created using the extend attribute described below.

`extend` Attribute

The extend attribute takes a parameter C, which should be a compile-time constant expression that evaluates to a class, and adds the definition as a new member of class C. This allows one to add a method to an existing class C even if C is in an already defined package P. There are several restrictions:

The extend attribute can only be used on function, const, class, or namespace definitions, or on static var definitions. Thus, a class extension cannot add new instance variables to objects of class C; it can, however, add getters and setters. Operators cannot be defined in class extensions.
The new member must be either static or final, and it cannot override any existing member. If the new member is a function, the default is final.
The new member must be defined in a namespace that has been defined in the current package. In particular, it means that the new member cannot be public, because the public namespace is predefined by the system and not by any package. The default namespace is internal, which makes the new member of C visible only from inside the current package.
The new member does not get any special access privileges granted to C’s indigenous members. For example, it cannot see C’s private members, and it cannot see P’s internal members if P is not the current package. On the other hand, it can see the current package’s internal members.

The following example indicates adding methods to the system class String, using a newly created namespace StringExtension:

namespace StringExtension;

StringExtension extend(String) function scramble():String {...}
StringExtension extend(String) function unscramble():String {...}

use namespace(StringExtension);

var x:String = "abc".scramble();

Once the class extension is evaluated, methods scramble and unscramble become available on all strings in code within the scope of a use namespace(StringExtension). There is no possibility of name clashes with extensions of class String in other, unrelated packages because the names scramble and unscramble only acquire their special meanings when qualified by the namespace StringExtension.

Unless one desires to export a class extension to other packages, the default namespace internal generally works best and simplifies the above example to:

extend(String) {
  function scramble():String {...}
  function unscramble():String {...}
}

var x:String = "abc".scramble();

Interfaces

Interfaces were considered for ECMAScript 4 but were dropped to keep the language simple — they are not needed as much in a dynamically typed language than in a statically typed one.

Interfaces might be defined by adding the syntax and semantics below.

Interface Definition

InterfaceDefinition

interface Identifier ExtendsList Block

| interface Identifier Semicolon

ExtendsList

«empty»

| extends TypeExpressionList

TypeExpressionList

TypeExpression^allowIn

| TypeExpressionList , TypeExpression^allowIn

Interfaces behave much like classes except that an interface I is not a supertype of a class C that implements I. Instead, an instance c of C may be implicitly coerced to type I, which creates an instance i of I. Implicitly coercing i to type C yields the original instance c. It is unspecified whether c == i.

An interface may have both concrete and abstract members, but it may not have constructors.

In the absence of name conflicts, an interface I’s members may be accessed as properties of any instance c of a class C that implements I. However, it is legal to define an interface I with a member m with the same name as a member of class C and yet have the two members be different. It is also legal for a class to implement two interfaces I and J both of which have a member named m and have the two m’s remain distinct. Which one gets extracted when one performs the property lookup operation c.m depends on whether c was last coerced to one of the interfaces or to an object type.

Class Definitions

The Inheritance clause of class definitions would be modified to accommodate interfaces, as listed in an implements clause:

ClassDefinition class Identifier Inheritance Block

Inheritance

«empty»

| extends TypeExpression^allowIn

| implements TypeExpressionList

| extends TypeExpression^allowIn implements TypeExpressionList

The newly defined class inherits instance and static members from the superclass and superinterfaces, if any. In the case of a conflict between a superclass and a superinterface, the superclass prevails. In the case of a conflict between two superinterfaces, neither is preferred and the lookup has to be qualified by the name of the superinterface for instance members or done directly on one of the superinterfaces for static members.

Attributes

`primitive`

A primitive class modifier attribute was considered. This attribute would exclude null from the set of values that can be stored in variables typed with this class: if a class C is defined using the primitive attribute, then null is not considered to be a member of the type C (there would have to be a way to specify a default value for uninitialized variables of type C). This attribute would permit user-defined classes to behave like some predefined classes such as Number.

This attribute was dropped for now because of circularity problems with classes that haven’t been defined yet. If class C hasn’t been defined yet, one can still create a variable of type C; such a variable is initialized to null. If C turned out to be a primitive class then the variable’s value would need to be retroactively changed.

Importing Packages

The import directive can be extended with more options for better identifier and namespace management, as described below:

A package P can reference another package Q via an import directive:

ImportDirective

import ImportBinding IncludesExcludes

| import ImportBinding , namespace ParenListExpression IncludesExcludes

ImportBinding

PackageName

| Identifier = PackageName

IncludesExcludes

«empty»

| , exclude ( NamePatterns )

| , include ( NamePatterns )

NamePatterns

«empty»

| NamePatternList

NamePatternList