- 10 Execution Contexts
-
When control is transferred to ECMAScript executable code, control
is entering an execution context. Active execution contexts
logically form a stack. The top execution context on this logical stack
is the running execution context.
- 10.1 Definitions
- 10.1.1 Function Objects
-
There are two types of Function objects:
- Program functions are defined in source text by a
FunctionDeclaration or created dynamically either by using a
FunctionExpression or by using the built-in
Function object as a constructor.
- Internal functions are built-in objects of the language, such as
parseInt and Math.exp. An
implementation may also provide implementation-dependent internal
functions that are not described in this specification. These
functions do not contain executable code defined by the ECMAScript
grammar, so they are excluded from this discussion of execution
contexts.
- 10.1.2 Types of Executable
Code
-
There are three types of ECMAScript executable code:
- Global code is source text that is treated as an
ECMAScript Program. The global code of a particular
Program does not include any source text that is parsed as
part of a FunctionBody.
- Eval code is the source text supplied to the built-in
eval function. More precisely, if the parameter to
the built-in eval function is a string, it is treated
as an ECMAScript Program. The eval code for a particular
invocation of eval is the global code portion of the
string parameter.
- Function code is source text that is parsed as part of a
FunctionBody. The function code of a particular
FunctionBody does not include any source text that is parsed
as part of a nested FunctionBody. Function code also denotes
the source text supplied when using the built-in
Function object as a constructor. More precisely, the
last parameter provided to the Function constructor
is converted to a string and treated as the FunctionBody. If
more than one parameter is provided to the Function
constructor, all parameters except the last one are converted to
strings and concatenated together, separated by commas. The resulting
string is interpreted as the FormalParameterList for the
FunctionBody defined by the last parameter. The function
code for a particular instantiation of a Function
does not include any source text that is parsed as part of a nested
FunctionBody.
- 10.1.3 Variable
Instantiation
-
Every execution context has associated with it a variable object.
Variables and functions declared in the source text are added as
properties of the variable object. For function code, parameters are
added as properties of the variable object.
Which object is used as the variable object and what attributes are
used for the properties depends on the type of code, but the remainder
of the behaviour is generic. On entering an execution context, the
properties are bound to the variable object in the following order:
- For function code: for each formal parameter, as defined in the
FormalParameterList, create a property of the variable object
whose name is the Identifier and whose attributes are
determined by the type of code. The values of the parameters are
supplied by the caller as arguments to [[Call]]. If the caller
supplies fewer parameter values than there are formal parameters, the
extra formal parameters have value undefined. If two or more
formal parameters share the same name, hence the same property, the
corresponding property is given the value that was supplied for the
last parameter with this name. If the value of this last parameter
was not supplied by the caller, the value of the corresponding
property is undefined.
- For each FunctionDeclaration in the code, in source text
order, create a property of the variable object whose name is the
Identifier in the FunctionDeclaration, whose value is
the result returned by creating a Function object as described in 13,
and whose attributes are determined by the type of code. If the
variable object already has a property with this name, replace its
value and attributes. Semantically, this step must follow the
creation of FormalParameterList properties.
- For each VariableDeclaration or
VariableDeclarationNoIn in the code, create a property of the
variable object whose name is the Identifier in the
VariableDeclaration or VariableDeclarationNoIn, whose
value is undefined and whose attributes are determined by the
type of code. If there is already a property of the variable object
with the name of a declared variable, the value of the property and
its attributes are not changed. Semantically, this step must follow
the creation of the FormalParameterList and
FunctionDeclaration properties. In particular, if a declared
variable has the same name as a declared function or formal
parameter, the variable declaration does not disturb the existing
property.
- 10.1.4 Scope Chain and
Identifier Resolution
-
Every execution context has associated with it a scope chain. A
scope chain is a list of objects that are searched when evaluating an
Identifier. When control enters an execution context, a scope
chain is created and populated with an initial set of objects,
depending on the type of code. During execution within an execution
context, the scope chain of the execution context is affected only by
with statements (see 12.10) and
catch clauses (see 12.14).
During execution, the syntactic production PrimaryExpression
: Identifier is evaluated using the following algorithm:
1. Get the next object in the scope chain. If there isn't one, go to
step 5.
2. Call the [[HasProperty]] method of Result(1), passing the
Identifier as the property name.
3. If Result(2) is true, return a value of type Reference
whose base object is Result(1) and whose property name is the
Identifier.
4. Go to step 1.
5. Return a value of type Reference whose base object is
null and whose property name is the
Identifier.
The result of evaluating an identifier is always a value of type
Reference with its member name component equal to the identifier
string.
- 10.1.5 Global Object
-
There is a unique global object (15.1),
which is created before control enters any execution context. Initially
the global object has the following properties:
- Built-in objects such as Math, String, Date, parseInt, etc. These
have attributes { DontEnum }.
- Additional host defined properties. This may include a property
whose value is the global object itself; for example, in the HTML
document object model the window property of the
global object is the global object itself.
As control enters execution contexts, and as ECMAScript code is
executed, additional properties may be added to the global object and
the initial properties may be changed.
- 10.1.6 Activation Object
-
When control enters an execution context for function code, an
object called the activation object is created and associated with the
execution context. The activation object is initialised with a property
with name arguments and attributes { DontDelete }. The
initial value of this property is the arguments object described
below.
The activation object is then used as the variable object for the
purposes of variable instantiation.
The activation object is purely a specification mechanism. It is
impossible for an ECMAScript program to access the activation object.
It can access members of the activation object, but not the activation
object itself. When the call operation is applied to a Reference value
whose base object is an activation object, null is used
as the this value of the call.
- 10.1.7 This
-
There is a this value associated with every active execution
context. The this value depends on the caller and the type of
code being executed and is determined when control enters the execution
context. The this value associated with an execution context is
immutable.
- 10.1.8 Arguments Object
-
When control enters an execution context for function code, an
arguments object is created and initialised as follows:
- The value of the internal [[Prototype]] property of the arguments
object is the original Object prototype object, the one that is the
initial value of Object.prototype (see 15.2.3.1).
- A property is created with name callee and
property attributes { DontEnum }. The initial value of this property
is the Function object being executed. This allows anonymous
functions to be recursive.
- A property is created with name length and
property attributes { DontEnum }. The initial value of this property
is the number of actual parameter values supplied by the caller.
- For each non-negative integer, arg, less than the value of
the length property, a property is created with name
ToString(arg) and property attributes { DontEnum }. The
initial value of this property is the value of the corresponding
actual parameter supplied by the caller. The first actual parameter
value corresponds to arg = 0, the second to arg = 1,
and so on. In the case when arg is less than the number of
formal parameters for the Function object, this property shares its
value with the corresponding property of the activation object. This
means that changing this property changes the corresponding property
of the activation object and vice versa.
- 10.2 Entering An Execution
Context
-
Every function and constructor call enters a new execution context,
even if a function is calling itself recursively. Every return exits an
execution context. A thrown exception, if not caught, may also exit one
or more execution contexts.
When control enters an execution context, the scope chain is created
and initialised, variable instantiation is performed, and the
this value is determined.
The initialisation of the scope chain, variable instantiation, and
the determination of the this value depend on the type of code
being entered.
- 10.2.1 Global Code
-
- The scope chain is created and initialised to contain the global
object and no others.
- Variable instantiation is performed using the global object as
the variable object and using property attributes { DontDelete
}.
- The this value is the global object.
- 10.2.2 Eval Code
-
When control enters an execution context for eval code, the previous
active execution context, referred to as the calling context, is
used to determine the scope chain, the variable object, and the
this value. If there is no calling context, then initialising
the scope chain, variable instantiation, and determination of the
this value are performed just as for global code.
- The scope chain is initialised to contain the same objects, in
the same order, as the calling context's scope chain. This includes
objects added to the calling context's scope chain by
with statements and catch
clauses.
- Variable instantiation is performed using the calling context's
variable object and using empty property attributes.
- The this value is the same as the this value of the
calling context.
- 10.2.3 Function Code
-
- The scope chain is initialised to contain the activation object
followed by the objects in the scope chain stored in the [[Scope]]
property of the Function object.
- Variable instantiation is performed using the activation object
as the variable object and using property attributes { DontDelete
}.
- The caller provides the this value. If the this
value provided by the caller is not an object (note that null is not an object), then the this value is the
global object.