text: /*
   *  If a non-strict context contains a strict function, where do 'strict'
   *  semantics actually begin?
   *
   *  Clearly, all the statements inside the function obey strict semantics.
   *  What about the argument list of the function?  For instance, consider:
   *
   *    (function (a,a) { 'use strict'; return a; })(1,2);
   *
   *  Strict code cannot contain a function expression with two arguments
   *  of the same name.  However, in this case the function expression itself
   *  exists in non-strict code.
   *
   *  E5 Section 11.2.5 refers to Section 13 for the semantics of evaluating
   *  a FunctionExpression.  The specification text for a FunctionExpression
   *  is as follows:
   *
   *    The production
   *
   *    FunctionExpression : function ( FormalParameterList_opt ) { FunctionBody }
   *
   *    is evaluated as follows:
   *
   *    1. Return the result of creating a new Function object as specified in
   *       13.2 with parameters specified by FormalParameterList_opt and body
   *       specified by FunctionBody. Pass in the LexicalEnvironment of the
   *       running execution context as the Scope. Pass in true as the Strict
   *       flag if the FunctionExpression is contained in strict code or if
   *       its FunctionBody is strict code.
   *
   *  This refers to Section 13.2 for creating a function object.  The 'Strict'
   *  flag for that "call" is set to true here, because FunctionBody is strict
   *  code.  However, the algorithm of Section 13.2 does no strict-mode related
   *  checks for duplicate argument names.
   *
   *  E5 Section 13.1 describes strict mode restrictions, which include:
   *
   *    It is a SyntaxError if any Identifier value occurs more than once within
   *    a FormalParameterList of a strict mode FunctionDeclaration or
   *    FunctionExpression.
   *
   *  Does this apply?  The FunctionExpression itself is *not* in strict mode.
   *  FormalParameterList is presumably evaluated in non-strict mode.
   *
   *  When building functions with the Function constructor, the specification
   *  clearly states that strict mode restrictions are checked and applied
   *  after function parsing: E5 Section 15.3.2.1, step 10.  Thus it would
   *  seem reasonable to have the same semantics for other function parsing
   *  cases, too.
   *
   *  In any case, V8 will throw SyntaxError in this case, and we follows that
   *  behavior.  Test cases below check for this expected behavior.
   *
   *  Note that the strict mode restrictions of E5 Section 13.1 are a bit
   *  awkward to check from an implementation perspective: while we're parsing
   *  a function expression (in particular, a possible name and the argument
   *  list) we don't yet know that the function may turn out to be strict.
   *  The optional function name and the argument list need to be checked
   *  at some point, when we know we're dealing with a strict function.
   */
  
  /*===
  2
  SyntaxError
  ===*/
  
  /* Duplicate argument names */
  
  try {
      // non-strict function -> acceptable syntax, latter parameter
      // is bound to 'a'
      eval("(function (a,a) { print(a); })(1,2);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      // SyntaxError
      eval("(function (a,a) { 'use strict'; print(a); })(1,2);");
  } catch (e) {
      print(e.name);
  }
  
  /*===
  1
  SyntaxError
  1
  SyntaxError
  ===*/
  
  /* Argument named 'eval' or 'arguments' */
  
  try {
      eval("(function (eval) { print(eval); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function (eval) { 'use strict'; print(eval); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function (arguments) { print(arguments); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function (arguments) { 'use strict'; print(arguments); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  /*===
  1
  SyntaxError
  1
  SyntaxError
  ===*/
  
  /* Function name 'eval' or 'arguments' */
  
  try {
      eval("(function eval(a) { print(a); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function eval(a) { 'use strict'; print(a); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function arguments(a) { print(a); })(1);");
  } catch (e) {
      print(e.name);
  }
  
  try {
      eval("(function arguments(a) { 'use strict'; print(a); })(1);");
  } catch (e) {
      print(e.name);
  }
  