10.1 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 that Program.

• 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.2 Lexical Environments

A Lexical Environment is a specification type used to define the association of Identifiers to specific variables and functions based upon the lexical nesting structure of ECMAScript code. A Lexical Environment consists of an Environment Record and a possibly null reference to an outer Lexical Environment. Usually a Lexical Environment is associated with some specific syntactic structure of ECMAScript code such as a FunctionDeclaration, a WithStatement, or a Catch clause of a TryStatement and a new Lexical Environment is created each time such code is evaluated.

An Environment Record records the identifier bindings that are created within the scope of its associated Lexical Environment.

The outer environment reference is used to model the logical nesting of Lexical Environment values. The outer reference of a (inner) Lexical Environment is a reference to the Lexical Environment that logically surrounds the inner Lexical Environment. An outer Lexical Environment may, of course, have its own outer Lexical Environment. A Lexical Environment may serve as the outer environment for multiple inner Lexical Environments. For example, if a FunctionDeclaration contains two nested FunctionDeclarations then the Lexical Environments of each of the nested functions will have as their outer Lexical Environment the Lexical Environment of the current execution of the surrounding function.

Lexical Environments and Environment Record values are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.

10.3 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. A new execution context is created whenever control is transferred from the executable code associated with the currently running execution context to executable code that is not associated with that execution context. The newly created execution context is pushed onto the stack and becomes the running execution context.

An execution context contains whatever state is necessary to track the execution progress of its associated code. In addition, each execution context has the state components listed in Table 19.

The LexicalEnvironment and VariableEnvironment components of an execution context are always Lexical Environments. When an execution context is created its LexicalEnvironment and VariableEnvironment components initially have the same value. The value of the VariableEnvironment component never changes while the value of the LexicalEnvironment component may change during execution of code within an execution context.

In most situations only the running execution context (the top of the execution context stack) is directly manipulated by algorithms within this specification. Hence when the terms “LexicalEnvironment”, “VariableEnvironment” and “ThisBinding” are used without qualification they are in reference to those components of the running execution context.

An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to access an execution context.

10.4 Establishing an Execution Context

Evaluation of global code or code using the eval function (15.1.2.1) establishes and enters a new execution context. Every invocation of an ECMAScript code function (13.2.1) also establishes and enters a new execution context, even if a function is calling itself recursively. Every return exits an execution context. A thrown exception may also exit one or more execution contexts.

When control enters an execution context, the execution context's ThisBinding is set, its VariableEnvironment and initial LexicalEnvironment are defined, and declaration binding instantiation (10.5) is performed. The exact manner in which these actions occur depend on the type of code being entered.

10.5 Declaration Binding Instantiation

Every execution context has an associated VariableEnvironment. Variables and functions declared in ECMAScript code evaluated in an execution context are added as bindings in that VariableEnvironment's Environment Record. For function code, parameters are also added as bindings to that Environment Record.

Which Environment Record is used to bind a declaration and its kind depends upon the type of ECMAScript code executed by the execution context, but the remainder of the behaviour is generic. On entering an execution context, bindings are created in the VariableEnvironment as follows using the caller provided code and, if it is function code, argument List args:

1. Let env be the environment record component of the running execution context's VariableEnvironment.
2. If code is eval code, then let configurableBindings be true else let configurableBindings be false.
3. If code is strict mode code, then let strict be true else let strict be false.
4. If code is function code, then
   1. Let func be the function whose [[Call]] internal method initiated execution of code. Let names be the value of func's [[FormalParameters]] internal property.
   2. Let argCount be the number of elements in args.
   3. Let n be the number 0.
   4. For each String argName in names, in list order do
      1. Let n be the current value of n plus 1.
      2. If n is greater than argCount, let v be undefined otherwise let v be the value of the n’th element of args.
      3. Let argAlreadyDeclared be the result of calling env’s HasBinding concrete method passing argName as the argument.
      4. If argAlreadyDeclared is false, call env’s CreateMutableBinding concrete method passing argName as the argument.
      5. Call env’s SetMutableBinding concrete method passing argName, v, and strict as the arguments.
5. For each FunctionDeclaration f in code, in source text order do
   1. Let fn be the Identifier in FunctionDeclaration f.
   2. Let fo be the result of instantiating FunctionDeclaration f as described in Clause 13.
   3. Let funcAlreadyDeclared be the result of calling env’s HasBinding concrete method passing fn as the argument.
   4. If funcAlreadyDeclared is false, call env’s CreateMutableBinding concrete method passing fn and configurableBindings as the arguments.
   5. Else if env is the environment record component of the global environment then
      1. Let go be the global object.
      2. Let existingProp be the resulting of calling the [[GetProperty]] internal method of go with argument fn.
      3. If existingProp .[[Configurable]] is true, then
         1. Call the [[DefineOwnProperty]] internal method of go, passing fn, Property Descriptor {[[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true , [[Configurable]]: configurableBindings }, and true as arguments.
      4. Else if IsAccessorDescriptor(existingProp) or existingProp does not have attribute values {[[Writable]]: true, [[Enumerable]]: true}, then
         1. Throw a TypeError exception.
   6. Call env’s SetMutableBinding concrete method passing fn, fo, and strict as the arguments.
6. Let argumentsAlreadyDeclared be the result of calling env’s HasBinding concrete method passing "arguments" as the argument.
7. If code is function code and argumentsAlreadyDeclared is false, then
   1. Let argsObj be the result of calling the abstract operation CreateArgumentsObject (10.6) passing func, names, args, env and strict as arguments.
   2. If strict is true, then
      1. Call env's CreateImmutableBinding concrete method passing the String "arguments" as the argument.
      2. Call env's InitializeImmutableBinding concrete method passing "arguments" and argsObj as arguments.
   3. Else,
      1. Call env's CreateMutableBinding concrete method passing the String "arguments" as the argument.
      2. Call env's SetMutableBinding concrete method passing "arguments", argsObj, and false as arguments.
8. For each VariableDeclaration and VariableDeclarationNoIn d in code, in source text order do
   1. Let dn be the Identifier in d.
   2. Let varAlreadyDeclared be the result of calling env’s HasBinding concrete method passing dn as the argument.
   3. If varAlreadyDeclared is false, then
      1. Call env's CreateMutableBinding concrete method passing dn and configurableBindings as the arguments.
      2. Call env's SetMutableBinding concrete method passing dn, undefined, and strict as the arguments.

10.6 Arguments Object

When control enters an execution context for function code, an arguments object is created unless (as specified in 10.5) the identifier arguments occurs as an Identifier in the function's FormalParameterList or occurs as the Identifier of a VariableDeclaration or FunctionDeclaration contained in the function code.

The arguments object is created by calling the abstract operation CreateArgumentsObject with arguments func the function object whose code is to be evaluated, names a List containing the function’s formal parameter names, args the actual arguments passed to the [[Call]] internal method, env the variable environment for the function code, and strict a Boolean that indicates whether or not the function code is strict code. When CreateArgumentsObject is called the following steps are performed:

1. Let len be the number of elements in args.
2. Let obj be the result of creating a new ECMAScript object.
3. Set all the internal methods of obj as specified in 8.12.
4. Set the [[Class]] internal property of obj to "Arguments".
5. Let Object be the standard built-in Object constructor (15.2.2).
6. Set the [[Prototype]] internal property of obj to the standard built-in Object prototype object (15.2.4).
7. Call the [[DefineOwnProperty]] internal method on obj passing "length", the Property Descriptor {[[Value]]: len, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}, and false as arguments.
8. Let map be the result of creating a new object as if by the expression new Object() where Object is the standard built-in constructor with that name
9. Let mappedNames be an empty List.
10. Let indx = len - 1.
11. Repeat while indx >= 0,
    1. Let val be the element of args at 0-origined list position indx.
    2. Call the [[DefineOwnProperty]] internal method on obj passing ToString(indx), the property descriptor {[[Value]]: val, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, and false as arguments.
    3. If indx is less than the number of elements in names, then
       1. Let name be the element of names at 0-origined list position indx.
       2. If strict is false and name is not an element of mappedNames, then
          1. Add name as an element of the list mappedNames.
          2. Let g be the result of calling the MakeArgGetter abstract operation with arguments name and env.
          3. Let p be the result of calling the MakeArgSetter abstract operation with arguments name and env.
          4. Call the [[DefineOwnProperty]] internal method of map passing ToString(indx), the Property Descriptor {[[Set]]: p, [[Get]]: g, [[Configurable]]: true}, and false as arguments.
    4. Let indx = indx - 1
12. If mappedNames is not empty, then
    1. Set the [[ParameterMap]] internal property of obj to map.
    2. Set the [[Get]], [[GetOwnProperty]], [[DefineOwnProperty]], and [[Delete]] internal methods of obj to the definitions provided below.
13. If strict is false, then
    1. Call the [[DefineOwnProperty]] internal method on obj passing "callee", the property descriptor {[[Value]]: func, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}, and false as arguments.
14. Else, strict is true so
    1. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
    2. Call the [[DefineOwnProperty]] internal method of obj with arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, and false.
    3. Call the [[DefineOwnProperty]] internal method of obj with arguments "callee", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, and false.
15. Return obj

The abstract operation MakeArgGetter called with String name and environment record env creates a function object that when executed returns the value bound for name in env. It performs the following steps:

1. Let body be the result of concatenating the Strings "return ", name, and ";".
2. Return the result of creating a function object as described in 13.2 using no FormalParameterList, body for FunctionBody, env as Scope, and true for Strict.

The abstract operation MakeArgSetter called with String name and environment record env creates a function object that when executed sets the value bound for name in env. It performs the following steps:

1. Let param be the String name concatenated with the String "_arg".
2. Let body be the String "<name> = <param>;" with <name> replaced by the value of name and <param> replaced by the value of param.
3. Return the result of creating a function object as described in 13.2 using a List containing the single String param as FormalParameterList, body for FunctionBody, env as Scope, and true for Strict.

The [[Get]] internal method of an arguments object for a non-strict mode function with formal parameters when called with a property name P performs the following steps:

1. Let map be the value of the [[ParameterMap]] internal property of the arguments object.
2. Let isMapped be the result of calling the [[GetOwnProperty]] internal method of map passing P as the argument.
3. If the value of isMapped is undefined, then
   1. Let v be the result of calling the default [[Get]] internal method (8.12.3) on the arguments object passing P as the argument.
   2. If P is "caller" and v is a strict mode Function object, throw a TypeError exception.
   3. Return v.
4. Else, map contains a formal parameter mapping for P so,
   1. Return the result of calling the [[Get]] internal method of map passing P as the argument.

The [[GetOwnProperty]] internal method of an arguments object for a non-strict mode function with formal parameters when called with a property name P performs the following steps:

1. Let desc be the result of calling the default [[GetOwnProperty]] internal method (8.12.1) on the arguments object passing P as the argument.
2. If desc is undefined then return desc.
3. Let map be the value of the [[ParameterMap]] internal property of the arguments object.
4. Let isMapped be the result of calling the [[GetOwnProperty]] internal method of map passing P as the argument.
5. If the value of isMapped is not undefined, then
   1. Set desc.[[Value]] to the result of calling the [[Get]] internal method of map passing P as the argument.
6. Return desc.

The [[DefineOwnProperty]] internal method of an arguments object for a non-strict mode function with formal parameters when called with a property name P, Property Descriptor Desc, and Boolean flag Throw performs the following steps:

1. Let map be the value of the [[ParameterMap]] internal property of the arguments object.
2. Let isMapped be the result of calling the [[GetOwnProperty]] internal method of map passing P as the argument.
3. Let allowed be the result of calling the default [[DefineOwnProperty]] internal method (8.12.9) on the arguments object passing P, Desc, and false as the arguments.
4. If allowed is false, then
   1. If Throw is true then throw a TypeError exception, otherwise return false.
5. If the value of isMapped is not undefined, then
   1. If IsAccessorDescriptor(Desc) is true, then
      1. Call the [[Delete]] internal method of map passing P, and false as the arguments.
   2. Else
      1. If Desc.[[Value]] is present, then
         1. Call the [[Put]] internal method of map passing P, Desc.[[Value]], and Throw as the arguments.
      2. If Desc.[[Writable]] is present and its value is false, then
         1. Call the [[Delete]] internal method of map passing P and false as arguments.
6. Return true.

The [[Delete]] internal method of an arguments object for a non-strict mode function with formal parameters when called with a property name P and Boolean flag Throw performs the following steps:

1. Let map be the value of the [[ParameterMap]] internal property of the arguments object.
2. Let isMapped be the result of calling the [[GetOwnProperty]] internal method of map passing P as the argument.
3. Let result be the result of calling the default [[Delete]] internal method (8.12.7) on the arguments object passing P and Throw as the arguments.
4. If result is true and the value of isMapped is not undefined, then
   1. Call the [[Delete]] internal method of map passing P, and false as the arguments.
5. Return result.