[webkit-changes] cvs commit: JavaScriptCore/tests/mozilla expected.html

Darin darin at opensource.apple.com
Wed Sep 28 11:51:17 PDT 2005


darin       05/09/28 11:51:16

  Modified:    .        ChangeLog
               kjs      grammar.y nodes.cpp nodes.h nodes2string.cpp
               tests/mozilla expected.html
  Removed:     kjs      kjs-test kjs-test.chk test.js
  Log:
          Reviewed by Maciej.
  
          - update grammar to fix conflicts; fixes one of our test cases
            because it resolves the relationship between function expressions
            and declarations in the way required by the ECMA specification
  
          * kjs/grammar.y: Added lots of new grammar rules so we have no conflicts.
          A new set of rules for "no bracket or function at start of expression" and
          another set of rules for "no in anywhere in expression". Also simplified the
          handling of try to use only a single node and used operator precedence to
          get rid of the conflict in handling of if and else. Also used a macro to
          streamline the handling of automatic semicolons and changed parenthesis
          handling to use a virtual function.
  
          * kjs/nodes.h: Added nodeInsideAllParens, removed unused abortStatement.
          (KJS::TryNode::TryNode): Updated to hold catch and finally blocks directly instead
          of using a special node for each.
          * kjs/nodes.cpp:
          (Node::createErrorCompletion): Added. Used instead of throwError when creating errors
          that should not be in a completion rather than an ExecState.
          (Node::throwUndefinedVariableError): Added. Sets source location unlike the call it
          replaces.
          (Node::nodeInsideAllParens): Added.
          (GroupNode::nodeInsideAllParens): Added.
          (StatListNode::execute): Removed code to move exceptions into completion objects;
          that's now done solely by the KJS_CHECKEXCEPTION macro.
          (TryNode::execute): Include execution of catch and finally here rather than using
          separate nodes.
          (FuncDeclNode::execute): Moved here, no longer inline.
          * kjs/nodes2string.cpp:
          (TryNode::streamTo): Updated for change.
          (FuncDeclNode::streamTo): Ditto.
          (FuncExprNode::streamTo): Ditto.
  
          * kjs/kjs-test: Removed. Was part of "make check".
          * kjs/kjs-test.chk: Ditto.
          * kjs/test.js: Ditto.
  
          * tests/mozilla/expected.html: Updated because one more test succeeds.
  
  Revision  Changes    Path
  1.842     +42 -0     JavaScriptCore/ChangeLog
  
  Index: ChangeLog
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/ChangeLog,v
  retrieving revision 1.841
  retrieving revision 1.842
  diff -u -r1.841 -r1.842
  --- ChangeLog	28 Sep 2005 02:25:48 -0000	1.841
  +++ ChangeLog	28 Sep 2005 18:51:11 -0000	1.842
  @@ -1,3 +1,45 @@
  +2005-09-27  Darin Adler  <darin at apple.com>
  +
  +        Reviewed by Maciej.
  +
  +        - update grammar to fix conflicts; fixes one of our test cases
  +          because it resolves the relationship between function expressions
  +          and declarations in the way required by the ECMA specification
  +
  +        * kjs/grammar.y: Added lots of new grammar rules so we have no conflicts.
  +        A new set of rules for "no bracket or function at start of expression" and
  +        another set of rules for "no in anywhere in expression". Also simplified the
  +        handling of try to use only a single node and used operator precedence to
  +        get rid of the conflict in handling of if and else. Also used a macro to
  +        streamline the handling of automatic semicolons and changed parenthesis
  +        handling to use a virtual function.
  +
  +        * kjs/nodes.h: Added nodeInsideAllParens, removed unused abortStatement.
  +        (KJS::TryNode::TryNode): Updated to hold catch and finally blocks directly instead
  +        of using a special node for each.
  +        * kjs/nodes.cpp:
  +        (Node::createErrorCompletion): Added. Used instead of throwError when creating errors
  +        that should not be in a completion rather than an ExecState.
  +        (Node::throwUndefinedVariableError): Added. Sets source location unlike the call it
  +        replaces.
  +        (Node::nodeInsideAllParens): Added.
  +        (GroupNode::nodeInsideAllParens): Added.
  +        (StatListNode::execute): Removed code to move exceptions into completion objects;
  +        that's now done solely by the KJS_CHECKEXCEPTION macro.
  +        (TryNode::execute): Include execution of catch and finally here rather than using
  +        separate nodes.
  +        (FuncDeclNode::execute): Moved here, no longer inline.
  +        * kjs/nodes2string.cpp:
  +        (TryNode::streamTo): Updated for change.
  +        (FuncDeclNode::streamTo): Ditto.
  +        (FuncExprNode::streamTo): Ditto.
  +
  +        * kjs/kjs-test: Removed. Was part of "make check".
  +        * kjs/kjs-test.chk: Ditto.
  +        * kjs/test.js: Ditto.
  +
  +        * tests/mozilla/expected.html: Updated because one more test succeeds.
  +
   2005-09-27  Adele Peterson  <adele at apple.com>
   
           Reviewed by Maciej.
  
  
  
  1.31      +456 -316  JavaScriptCore/kjs/grammar.y
  
  Index: grammar.y
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/kjs/grammar.y,v
  retrieving revision 1.30
  retrieving revision 1.31
  diff -u -r1.30 -r1.31
  --- grammar.y	24 Sep 2005 22:34:13 -0000	1.30
  +++ grammar.y	28 Sep 2005 18:51:13 -0000	1.31
  @@ -41,11 +41,13 @@
   #if !APPLE_CHANGES
   #define YYERROR_VERBOSE
   #endif
  -#define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::sid); } // location
   
   extern int kjsyylex();
   int kjsyyerror(const char *);
  -static bool automatic();
  +static bool allowAutomaticSemicolon();
  +
  +#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0)
  +#define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line, Parser::sid)
   
   using namespace KJS;
   
  @@ -84,16 +86,10 @@
     Operator            op;
     PropertyValueNode   *plist;
     PropertyNode        *pnode;
  -  CatchNode           *cnode;
  -  FinallyNode         *fnode;
   }
   
   %start Program
   
  -/* expect a shift/reduce conflict from the "dangling else" problem
  -   when using bison the warning can be supressed */
  -// %expect 1
  -
   /* literals */
   %token NULLTOKEN TRUETOKEN FALSETOKEN
   %token STRING NUMBER
  @@ -101,10 +97,14 @@
   /* keywords */
   %token BREAK CASE DEFAULT FOR NEW VAR CONST CONTINUE
   %token FUNCTION RETURN VOID DELETE
  -%token IF THIS DO WHILE ELSE IN INSTANCEOF TYPEOF
  +%token IF THIS DO WHILE IN INSTANCEOF TYPEOF
   %token SWITCH WITH RESERVED
   %token THROW TRY CATCH FINALLY
   
  +/* give an if without an else higher precedence than an else to resolve the ambiguity */
  +%nonassoc IF_WITHOUT_ELSE
  +%nonassoc ELSE
  +
   /* punctuators */
   %token EQEQ NE                     /* == and != */
   %token STREQ STRNEQ                /* === and !== */
  @@ -129,18 +129,30 @@
   %token AUTOPLUSPLUS AUTOMINUSMINUS
   
   /* non-terminal types */
  -%type <node>  Literal PrimaryExpr Expr MemberExpr NewExpr CallExpr
  -%type <node>  ArrayLiteral
  -%type <node>  LeftHandSideExpr PostfixExpr UnaryExpr
  -%type <node>  MultiplicativeExpr AdditiveExpr
  -%type <node>  ShiftExpr RelationalExpr EqualityExpr
  -%type <node>  BitwiseANDExpr BitwiseXORExpr BitwiseORExpr
  -%type <node>  LogicalANDExpr LogicalORExpr
  -%type <node>  ConditionalExpr AssignmentExpr
  -%type <node>  ExprOpt
  +%type <node>  Literal ArrayLiteral
   
  -%type <cnode> Catch
  -%type <fnode> Finally
  +%type <node>  PrimaryExpr PrimaryExprNoBrace
  +%type <node>  MemberExpr MemberExprNoBF /* BF => brace or function */
  +%type <node>  NewExpr NewExprNoBF
  +%type <node>  CallExpr CallExprNoBF
  +%type <node>  LeftHandSideExpr LeftHandSideExprNoBF
  +%type <node>  PostfixExpr PostfixExprNoBF
  +%type <node>  UnaryExpr UnaryExprNoBF UnaryExprCommon
  +%type <node>  MultiplicativeExpr MultiplicativeExprNoBF
  +%type <node>  AdditiveExpr AdditiveExprNoBF
  +%type <node>  ShiftExpr ShiftExprNoBF
  +%type <node>  RelationalExpr RelationalExprNoIn RelationalExprNoBF
  +%type <node>  EqualityExpr EqualityExprNoIn EqualityExprNoBF
  +%type <node>  BitwiseANDExpr BitwiseANDExprNoIn BitwiseANDExprNoBF
  +%type <node>  BitwiseXORExpr BitwiseXORExprNoIn BitwiseXORExprNoBF
  +%type <node>  BitwiseORExpr BitwiseORExprNoIn BitwiseORExprNoBF
  +%type <node>  LogicalANDExpr LogicalANDExprNoIn LogicalANDExprNoBF
  +%type <node>  LogicalORExpr LogicalORExprNoIn LogicalORExprNoBF
  +%type <node>  ConditionalExpr ConditionalExprNoIn ConditionalExprNoBF
  +%type <node>  AssignmentExpr AssignmentExprNoIn AssignmentExprNoBF
  +%type <node>  Expr ExprNoIn ExprNoBF
  +
  +%type <node>  ExprOpt ExprNoInOpt
   
   %type <stat>  Statement Block
   %type <stat>  VariableStatement ConstStatement EmptyStatement ExprStatement
  @@ -151,18 +163,17 @@
   %type <stat>  SourceElement
   
   %type <slist> StatementList
  -%type <init>  Initializer
  +%type <init>  Initializer InitializerNoIn
   %type <func>  FunctionDeclaration
   %type <funcExpr>  FunctionExpr
   %type <body>  FunctionBody
   %type <srcs>  SourceElements
   %type <param> FormalParameterList
   %type <op>    AssignmentOperator
  -%type <prog>  Program
   %type <args>  Arguments
   %type <alist> ArgumentList
  -%type <vlist> VariableDeclarationList ConstDeclarationList
  -%type <decl>  VariableDeclaration ConstDeclaration
  +%type <vlist> VariableDeclarationList VariableDeclarationListNoIn ConstDeclarationList
  +%type <decl>  VariableDeclaration VariableDeclarationNoIn ConstDeclaration
   %type <cblk>  CaseBlock
   %type <ccl>   CaseClause DefaultClause
   %type <clist> CaseClauses  CaseClausesOpt
  @@ -174,92 +185,118 @@
   %%
   
   Literal:
  -    NULLTOKEN                      { $$ = new NullNode(); }
  -  | TRUETOKEN                      { $$ = new BooleanNode(true); }
  -  | FALSETOKEN                     { $$ = new BooleanNode(false); }
  -  | NUMBER                         { $$ = new NumberNode($1); }
  -  | STRING                         { $$ = new StringNode($1); }
  -  | '/'       /* a RegExp ? */     { Lexer *l = Lexer::curr();
  -                                     if (!l->scanRegExp()) YYABORT;
  -                                     $$ = new RegExpNode(l->pattern,l->flags);}
  -  | DIVEQUAL /* a RegExp starting with /= ! */
  -                                   { Lexer *l = Lexer::curr();
  -                                     if (!l->scanRegExp()) YYABORT;
  -                                     $$ = new RegExpNode(UString('=')+l->pattern,l->flags);}
  +    NULLTOKEN                           { $$ = new NullNode(); }
  +  | TRUETOKEN                           { $$ = new BooleanNode(true); }
  +  | FALSETOKEN                          { $$ = new BooleanNode(false); }
  +  | NUMBER                              { $$ = new NumberNode($1); }
  +  | STRING                              { $$ = new StringNode($1); }
  +  | '/' /* regexp */                    {
  +                                            Lexer *l = Lexer::curr();
  +                                            if (!l->scanRegExp()) YYABORT;
  +                                            $$ = new RegExpNode(l->pattern, l->flags);
  +                                        }
  +  | DIVEQUAL /* regexp with /= */       {
  +                                            Lexer *l = Lexer::curr();
  +                                            if (!l->scanRegExp()) YYABORT;
  +                                            $$ = new RegExpNode(UString('=') + l->pattern, l->flags);
  +                                        }
   ;
   
   PrimaryExpr:
  -    THIS                           { $$ = new ThisNode(); }
  +    PrimaryExprNoBrace
  +  | '{' '}'                             { $$ = new ObjectLiteralNode(); }
  +  | '{' PropertyNameAndValueList '}'    { $$ = new ObjectLiteralNode($2); }
  +;
  +
  +PrimaryExprNoBrace:
  +    THIS                                { $$ = new ThisNode(); }
     | Literal
     | ArrayLiteral
  -  | IDENT                          { $$ = new ResolveNode(*$1); }
  -  | '(' Expr ')'                   { if ($2->isResolveNode()) $$ = $2; else $$ = new GroupNode($2); }
  -  | '{' '}'                        { $$ = new ObjectLiteralNode(); }
  -  | '{' PropertyNameAndValueList '}'   { $$ = new ObjectLiteralNode($2); }
  +  | IDENT                               { $$ = new ResolveNode(*$1); }
  +  | '(' Expr ')'                        { $$ = $2->isResolveNode() ? $2 : new GroupNode($2); }
   ;
   
   ArrayLiteral:
  -    '[' ElisionOpt ']'                 { $$ = new ArrayNode($2); }
  -  | '[' ElementList ']'                { $$ = new ArrayNode($2); }
  -  | '[' ElementList ',' ElisionOpt ']' { $$ = new ArrayNode($4, $2); }
  +    '[' ElisionOpt ']'                  { $$ = new ArrayNode($2); }
  +  | '[' ElementList ']'                 { $$ = new ArrayNode($2); }
  +  | '[' ElementList ',' ElisionOpt ']'  { $$ = new ArrayNode($4, $2); }
   ;
   
   ElementList:
  -    ElisionOpt AssignmentExpr      { $$ = new ElementNode($1, $2); }
  +    ElisionOpt AssignmentExpr           { $$ = new ElementNode($1, $2); }
     | ElementList ',' ElisionOpt AssignmentExpr
  -                                   { $$ = new ElementNode($1, $3, $4); }
  +                                        { $$ = new ElementNode($1, $3, $4); }
   ;
   
   ElisionOpt:
  -    /* nothing */                  { $$ = 0; }
  +    /* nothing */                       { $$ = 0; }
     | Elision
   ;
   
   Elision:
  -    ','                            { $$ = 1; }
  -  | Elision ','                    { $$ = $1 + 1; }
  +    ','                                 { $$ = 1; }
  +  | Elision ','                         { $$ = $1 + 1; }
   ;
   
   PropertyNameAndValueList:
       PropertyName ':' AssignmentExpr     { $$ = new PropertyValueNode($1, $3); }
     | PropertyNameAndValueList ',' PropertyName ':' AssignmentExpr
  -                                   { $$ = new PropertyValueNode($3, $5, $1); }
  +                                        { $$ = new PropertyValueNode($3, $5, $1); }
   ;
   
   PropertyName:
  -    IDENT                          { $$ = new PropertyNode(*$1); }
  -  | STRING                         { $$ = new PropertyNode(Identifier(*$1)); }
  -  | NUMBER                         { $$ = new PropertyNode($1); }
  +    IDENT                               { $$ = new PropertyNode(*$1); }
  +  | STRING                              { $$ = new PropertyNode(Identifier(*$1)); }
  +  | NUMBER                              { $$ = new PropertyNode($1); }
   ;
   
   MemberExpr:
       PrimaryExpr
  -  | FunctionExpr                   { $$ = $1; }
  -  | MemberExpr '[' Expr ']'        { $$ = new BracketAccessorNode($1, $3); }
  -  | MemberExpr '.' IDENT           { $$ = new DotAccessorNode($1, *$3); }
  -  | NEW MemberExpr Arguments       { $$ = new NewExprNode($2, $3); }
  +  | FunctionExpr                        { $$ = $1; }
  +  | MemberExpr '[' Expr ']'             { $$ = new BracketAccessorNode($1, $3); }
  +  | MemberExpr '.' IDENT                { $$ = new DotAccessorNode($1, *$3); }
  +  | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
  +;
  +
  +MemberExprNoBF:
  +    PrimaryExprNoBrace
  +  | MemberExprNoBF '[' Expr ']'         { $$ = new BracketAccessorNode($1, $3); }
  +  | MemberExprNoBF '.' IDENT            { $$ = new DotAccessorNode($1, *$3); }
  +  | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
   ;
   
   NewExpr:
       MemberExpr
  -  | NEW NewExpr                    { $$ = new NewExprNode($2); }
  +  | NEW NewExpr                         { $$ = new NewExprNode($2); }
  +;
  +
  +NewExprNoBF:
  +    MemberExprNoBF
  +  | NEW NewExpr                         { $$ = new NewExprNode($2); }
   ;
   
   CallExpr:
  -    MemberExpr Arguments { $$ = makeFunctionCallNode($1, $2); }
  -  | CallExpr Arguments   { $$ = makeFunctionCallNode($1, $2); }
  -  | CallExpr '[' Expr ']'  { $$ = new BracketAccessorNode($1, $3); }
  -  | CallExpr '.' IDENT     { $$ = new DotAccessorNode($1, *$3); }
  +    MemberExpr Arguments                { $$ = makeFunctionCallNode($1, $2); }
  +  | CallExpr Arguments                  { $$ = makeFunctionCallNode($1, $2); }
  +  | CallExpr '[' Expr ']'               { $$ = new BracketAccessorNode($1, $3); }
  +  | CallExpr '.' IDENT                  { $$ = new DotAccessorNode($1, *$3); }
  +;
  +
  +CallExprNoBF:
  +    MemberExprNoBF Arguments            { $$ = makeFunctionCallNode($1, $2); }
  +  | CallExprNoBF Arguments              { $$ = makeFunctionCallNode($1, $2); }
  +  | CallExprNoBF '[' Expr ']'           { $$ = new BracketAccessorNode($1, $3); }
  +  | CallExprNoBF '.' IDENT              { $$ = new DotAccessorNode($1, *$3); }
   ;
   
   Arguments:
  -    '(' ')'                        { $$ = new ArgumentsNode(); }
  -  | '(' ArgumentList ')'           { $$ = new ArgumentsNode($2); }
  +    '(' ')'                             { $$ = new ArgumentsNode(); }
  +  | '(' ArgumentList ')'                { $$ = new ArgumentsNode($2); }
   ;
   
   ArgumentList:
  -    AssignmentExpr                  { $$ = new ArgumentListNode($1); }
  -  | ArgumentList ',' AssignmentExpr { $$ = new ArgumentListNode($1, $3); }
  +    AssignmentExpr                      { $$ = new ArgumentListNode($1); }
  +  | ArgumentList ',' AssignmentExpr     { $$ = new ArgumentListNode($1, $3); }
   ;
   
   LeftHandSideExpr:
  @@ -267,32 +304,61 @@
     | CallExpr
   ;
   
  -PostfixExpr:    /* TODO: no line terminator here */
  +LeftHandSideExprNoBF:
  +    NewExprNoBF
  +  | CallExprNoBF
  +;
  +
  +PostfixExpr:
       LeftHandSideExpr
  -  | LeftHandSideExpr PLUSPLUS      { if (!makePostfixNode($$, $1, OpPlusPlus)) YYABORT; }
  -  | LeftHandSideExpr MINUSMINUS    { if (!makePostfixNode($$, $1, OpMinusMinus)) YYABORT; }
  +  | LeftHandSideExpr PLUSPLUS           { if (!makePostfixNode($$, $1, OpPlusPlus)) YYABORT; }
  +  | LeftHandSideExpr MINUSMINUS         { if (!makePostfixNode($$, $1, OpMinusMinus)) YYABORT; }
   ;
   
  +PostfixExprNoBF:
  +    LeftHandSideExprNoBF
  +  | LeftHandSideExprNoBF PLUSPLUS       { if (!makePostfixNode($$, $1, OpPlusPlus)) YYABORT; }
  +  | LeftHandSideExprNoBF MINUSMINUS     { if (!makePostfixNode($$, $1, OpMinusMinus)) YYABORT; }
  +;
  +
  +UnaryExprCommon:
  +    DELETE UnaryExpr                    { $$ = makeDeleteNode($2); }
  +  | VOID UnaryExpr                      { $$ = new VoidNode($2); }
  +  | TYPEOF UnaryExpr                    { $$ = makeTypeOfNode($2); }
  +  | PLUSPLUS UnaryExpr                  { if (!makePrefixNode($$, $2, OpPlusPlus)) YYABORT; }
  +  | AUTOPLUSPLUS UnaryExpr              { if (!makePrefixNode($$, $2, OpPlusPlus)) YYABORT; }
  +  | MINUSMINUS UnaryExpr                { if (!makePrefixNode($$, $2, OpMinusMinus)) YYABORT; }
  +  | AUTOMINUSMINUS UnaryExpr            { if (!makePrefixNode($$, $2, OpMinusMinus)) YYABORT; }
  +  | '+' UnaryExpr                       { $$ = new UnaryPlusNode($2); }
  +  | '-' UnaryExpr                       { $$ = new NegateNode($2); }
  +  | '~' UnaryExpr                       { $$ = new BitwiseNotNode($2); }
  +  | '!' UnaryExpr                       { $$ = new LogicalNotNode($2); }
  +
   UnaryExpr:
       PostfixExpr
  -  | DELETE UnaryExpr               { $$ = makeDeleteNode($2); }
  -  | VOID UnaryExpr                 { $$ = new VoidNode($2); }
  -  | TYPEOF UnaryExpr               { $$ = makeTypeOfNode($2); }
  -  | PLUSPLUS UnaryExpr             { if (!makePrefixNode($$, $2, OpPlusPlus)) YYABORT; }
  -  | AUTOPLUSPLUS UnaryExpr         { if (!makePrefixNode($$, $2, OpPlusPlus)) YYABORT; }
  -  | MINUSMINUS UnaryExpr           { if (!makePrefixNode($$, $2, OpMinusMinus)) YYABORT; }
  -  | AUTOMINUSMINUS UnaryExpr       { if (!makePrefixNode($$, $2, OpMinusMinus)) YYABORT; }
  -  | '+' UnaryExpr                  { $$ = new UnaryPlusNode($2); }
  -  | '-' UnaryExpr                  { $$ = new NegateNode($2); }
  -  | '~' UnaryExpr                  { $$ = new BitwiseNotNode($2); }
  -  | '!' UnaryExpr                  { $$ = new LogicalNotNode($2); }
  +  | UnaryExprCommon
  +;
  +
  +UnaryExprNoBF:
  +    PostfixExprNoBF
  +  | UnaryExprCommon
   ;
   
   MultiplicativeExpr:
       UnaryExpr
  -  | MultiplicativeExpr '*' UnaryExpr { $$ = new MultNode($1, $3, '*'); }
  -  | MultiplicativeExpr '/' UnaryExpr { $$ = new MultNode($1, $3, '/'); }
  -  | MultiplicativeExpr '%' UnaryExpr { $$ = new MultNode($1,$3,'%'); }
  +  | MultiplicativeExpr '*' UnaryExpr    { $$ = new MultNode($1, $3, '*'); }
  +  | MultiplicativeExpr '/' UnaryExpr    { $$ = new MultNode($1, $3, '/'); }
  +  | MultiplicativeExpr '%' UnaryExpr    { $$ = new MultNode($1, $3,'%'); }
  +;
  +
  +MultiplicativeExprNoBF:
  +    UnaryExprNoBF
  +  | MultiplicativeExprNoBF '*' UnaryExpr
  +                                        { $$ = new MultNode($1, $3, '*'); }
  +  | MultiplicativeExprNoBF '/' UnaryExpr
  +                                        { $$ = new MultNode($1, $3, '/'); }
  +  | MultiplicativeExprNoBF '%' UnaryExpr
  +                                        { $$ = new MultNode($1, $3,'%'); }
   ;
   
   AdditiveExpr:
  @@ -301,94 +367,237 @@
     | AdditiveExpr '-' MultiplicativeExpr { $$ = new AddNode($1, $3, '-'); }
   ;
   
  +AdditiveExprNoBF:
  +    MultiplicativeExprNoBF
  +  | AdditiveExprNoBF '+' MultiplicativeExpr
  +                                        { $$ = new AddNode($1, $3, '+'); }
  +  | AdditiveExprNoBF '-' MultiplicativeExpr
  +                                        { $$ = new AddNode($1, $3, '-'); }
  +;
  +
   ShiftExpr:
       AdditiveExpr
  -  | ShiftExpr LSHIFT AdditiveExpr  { $$ = new ShiftNode($1, OpLShift, $3); }
  -  | ShiftExpr RSHIFT AdditiveExpr  { $$ = new ShiftNode($1, OpRShift, $3); }
  -  | ShiftExpr URSHIFT AdditiveExpr { $$ = new ShiftNode($1, OpURShift, $3); }
  +  | ShiftExpr LSHIFT AdditiveExpr       { $$ = new ShiftNode($1, OpLShift, $3); }
  +  | ShiftExpr RSHIFT AdditiveExpr       { $$ = new ShiftNode($1, OpRShift, $3); }
  +  | ShiftExpr URSHIFT AdditiveExpr      { $$ = new ShiftNode($1, OpURShift, $3); }
  +;
  +
  +ShiftExprNoBF:
  +    AdditiveExprNoBF
  +  | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = new ShiftNode($1, OpLShift, $3); }
  +  | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = new ShiftNode($1, OpRShift, $3); }
  +  | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = new ShiftNode($1, OpURShift, $3); }
   ;
   
   RelationalExpr:
       ShiftExpr
  -  | RelationalExpr '<' ShiftExpr
  -                           { $$ = new RelationalNode($1, OpLess, $3); }
  -  | RelationalExpr '>' ShiftExpr
  -                           { $$ = new RelationalNode($1, OpGreater, $3); }
  -  | RelationalExpr LE ShiftExpr
  -                           { $$ = new RelationalNode($1, OpLessEq, $3); }
  -  | RelationalExpr GE ShiftExpr
  -                           { $$ = new RelationalNode($1, OpGreaterEq, $3); }
  -  | RelationalExpr INSTANCEOF ShiftExpr
  -                           { $$ = new RelationalNode($1, OpInstanceOf, $3); }
  -  | RelationalExpr IN ShiftExpr
  -                           { $$ = new RelationalNode($1, OpIn, $3); }
  +  | RelationalExpr '<' ShiftExpr        { $$ = new RelationalNode($1, OpLess, $3); }
  +  | RelationalExpr '>' ShiftExpr        { $$ = new RelationalNode($1, OpGreater, $3); }
  +  | RelationalExpr LE ShiftExpr         { $$ = new RelationalNode($1, OpLessEq, $3); }
  +  | RelationalExpr GE ShiftExpr         { $$ = new RelationalNode($1, OpGreaterEq, $3); }
  +  | RelationalExpr INSTANCEOF ShiftExpr { $$ = new RelationalNode($1, OpInstanceOf, $3); }
  +  | RelationalExpr IN ShiftExpr         { $$ = new RelationalNode($1, OpIn, $3); }
  +;
  +
  +RelationalExprNoIn:
  +    ShiftExpr
  +  | RelationalExprNoIn '<' ShiftExpr    { $$ = new RelationalNode($1, OpLess, $3); }
  +  | RelationalExprNoIn '>' ShiftExpr    { $$ = new RelationalNode($1, OpGreater, $3); }
  +  | RelationalExprNoIn LE ShiftExpr     { $$ = new RelationalNode($1, OpLessEq, $3); }
  +  | RelationalExprNoIn GE ShiftExpr     { $$ = new RelationalNode($1, OpGreaterEq, $3); }
  +  | RelationalExprNoIn INSTANCEOF ShiftExpr
  +                                        { $$ = new RelationalNode($1, OpInstanceOf, $3); }
  +;
  +
  +RelationalExprNoBF:
  +    ShiftExprNoBF
  +  | RelationalExprNoBF '<' ShiftExpr    { $$ = new RelationalNode($1, OpLess, $3); }
  +  | RelationalExprNoBF '>' ShiftExpr    { $$ = new RelationalNode($1, OpGreater, $3); }
  +  | RelationalExprNoBF LE ShiftExpr     { $$ = new RelationalNode($1, OpLessEq, $3); }
  +  | RelationalExprNoBF GE ShiftExpr     { $$ = new RelationalNode($1, OpGreaterEq, $3); }
  +  | RelationalExprNoBF INSTANCEOF ShiftExpr
  +                                        { $$ = new RelationalNode($1, OpInstanceOf, $3); }
  +  | RelationalExprNoBF IN ShiftExpr     { $$ = new RelationalNode($1, OpIn, $3); }
   ;
   
   EqualityExpr:
       RelationalExpr
  -  | EqualityExpr EQEQ RelationalExpr   { $$ = new EqualNode($1, OpEqEq, $3); }
  -  | EqualityExpr NE RelationalExpr     { $$ = new EqualNode($1, OpNotEq, $3); }
  -  | EqualityExpr STREQ RelationalExpr  { $$ = new EqualNode($1, OpStrEq, $3); }
  -  | EqualityExpr STRNEQ RelationalExpr { $$ = new EqualNode($1, OpStrNEq, $3);}
  +  | EqualityExpr EQEQ RelationalExpr    { $$ = new EqualNode($1, OpEqEq, $3); }
  +  | EqualityExpr NE RelationalExpr      { $$ = new EqualNode($1, OpNotEq, $3); }
  +  | EqualityExpr STREQ RelationalExpr   { $$ = new EqualNode($1, OpStrEq, $3); }
  +  | EqualityExpr STRNEQ RelationalExpr  { $$ = new EqualNode($1, OpStrNEq, $3);}
  +;
  +
  +EqualityExprNoIn:
  +    RelationalExprNoIn
  +  | EqualityExprNoIn EQEQ RelationalExprNoIn
  +                                        { $$ = new EqualNode($1, OpEqEq, $3); }
  +  | EqualityExprNoIn NE RelationalExprNoIn
  +                                        { $$ = new EqualNode($1, OpNotEq, $3); }
  +  | EqualityExprNoIn STREQ RelationalExprNoIn
  +                                        { $$ = new EqualNode($1, OpStrEq, $3); }
  +  | EqualityExprNoIn STRNEQ RelationalExprNoIn
  +                                        { $$ = new EqualNode($1, OpStrNEq, $3);}
  +;
  +
  +EqualityExprNoBF:
  +    RelationalExprNoBF
  +  | EqualityExprNoBF EQEQ RelationalExpr
  +                                        { $$ = new EqualNode($1, OpEqEq, $3); }
  +  | EqualityExprNoBF NE RelationalExpr  { $$ = new EqualNode($1, OpNotEq, $3); }
  +  | EqualityExprNoBF STREQ RelationalExpr
  +                                        { $$ = new EqualNode($1, OpStrEq, $3); }
  +  | EqualityExprNoBF STRNEQ RelationalExpr
  +                                        { $$ = new EqualNode($1, OpStrNEq, $3);}
   ;
   
   BitwiseANDExpr:
       EqualityExpr
  -  | BitwiseANDExpr '&' EqualityExpr { $$ = new BitOperNode($1, OpBitAnd, $3); }
  +  | BitwiseANDExpr '&' EqualityExpr     { $$ = new BitOperNode($1, OpBitAnd, $3); }
  +;
  +
  +BitwiseANDExprNoIn:
  +    EqualityExprNoIn
  +  | BitwiseANDExprNoIn '&' EqualityExprNoIn
  +                                        { $$ = new BitOperNode($1, OpBitAnd, $3); }
  +;
  +
  +BitwiseANDExprNoBF:
  +    EqualityExprNoBF
  +  | BitwiseANDExprNoBF '&' EqualityExpr { $$ = new BitOperNode($1, OpBitAnd, $3); }
   ;
   
   BitwiseXORExpr:
       BitwiseANDExpr
  -  | BitwiseXORExpr '^' BitwiseANDExpr { $$ = new BitOperNode($1, OpBitXOr, $3); }
  +  | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = new BitOperNode($1, OpBitXOr, $3); }
  +;
  +
  +BitwiseXORExprNoIn:
  +    BitwiseANDExprNoIn
  +  | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
  +                                        { $$ = new BitOperNode($1, OpBitXOr, $3); }
  +;
  +
  +BitwiseXORExprNoBF:
  +    BitwiseANDExprNoBF
  +  | BitwiseXORExprNoBF '^' BitwiseANDExpr
  +                                        { $$ = new BitOperNode($1, OpBitXOr, $3); }
   ;
   
   BitwiseORExpr:
       BitwiseXORExpr
  -  | BitwiseORExpr '|' BitwiseXORExpr { $$ = new BitOperNode($1, OpBitOr, $3); }
  +  | BitwiseORExpr '|' BitwiseXORExpr    { $$ = new BitOperNode($1, OpBitOr, $3); }
  +;
  +
  +BitwiseORExprNoIn:
  +    BitwiseXORExprNoIn
  +  | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
  +                                        { $$ = new BitOperNode($1, OpBitOr, $3); }
  +;
  +
  +BitwiseORExprNoBF:
  +    BitwiseXORExprNoBF
  +  | BitwiseORExprNoBF '|' BitwiseXORExpr
  +                                        { $$ = new BitOperNode($1, OpBitOr, $3); }
   ;
   
   LogicalANDExpr:
       BitwiseORExpr
  -  | LogicalANDExpr AND BitwiseORExpr
  -                           { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
  +  | LogicalANDExpr AND BitwiseORExpr    { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
  +;
  +
  +LogicalANDExprNoIn:
  +    BitwiseORExprNoIn
  +  | LogicalANDExprNoIn AND BitwiseORExprNoIn
  +                                        { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
  +;
  +
  +LogicalANDExprNoBF:
  +    BitwiseORExprNoBF
  +  | LogicalANDExprNoBF AND BitwiseORExpr
  +                                        { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
   ;
   
   LogicalORExpr:
       LogicalANDExpr
  -  | LogicalORExpr OR LogicalANDExpr
  -                           { $$ = new BinaryLogicalNode($1, OpOr, $3); }
  +  | LogicalORExpr OR LogicalANDExpr     { $$ = new BinaryLogicalNode($1, OpOr, $3); }
  +;
  +
  +LogicalORExprNoIn:
  +    LogicalANDExprNoIn
  +  | LogicalORExprNoIn OR LogicalANDExprNoIn
  +                                        { $$ = new BinaryLogicalNode($1, OpOr, $3); }
  +;
  +
  +LogicalORExprNoBF:
  +    LogicalANDExprNoBF
  +  | LogicalORExprNoBF OR LogicalANDExpr { $$ = new BinaryLogicalNode($1, OpOr, $3); }
   ;
   
   ConditionalExpr:
       LogicalORExpr
     | LogicalORExpr '?' AssignmentExpr ':' AssignmentExpr
  -                           { $$ = new ConditionalNode($1, $3, $5); }
  +                                        { $$ = new ConditionalNode($1, $3, $5); }
  +;
  +
  +ConditionalExprNoIn:
  +    LogicalORExprNoIn
  +  | LogicalORExprNoIn '?' AssignmentExprNoIn ':' AssignmentExprNoIn
  +                                        { $$ = new ConditionalNode($1, $3, $5); }
  +;
  +
  +ConditionalExprNoBF:
  +    LogicalORExprNoBF
  +  | LogicalORExprNoBF '?' AssignmentExpr ':' AssignmentExpr
  +                                        { $$ = new ConditionalNode($1, $3, $5); }
   ;
   
   AssignmentExpr:
       ConditionalExpr
     | LeftHandSideExpr AssignmentOperator AssignmentExpr
  -                           { if (!makeAssignNode($$, $1, $2, $3)) YYABORT; }
  +                                        { if (!makeAssignNode($$, $1, $2, $3)) YYABORT; }
  +;
  +
  +AssignmentExprNoIn:
  +    ConditionalExprNoIn
  +  | LeftHandSideExpr AssignmentOperator AssignmentExprNoIn
  +                                        { if (!makeAssignNode($$, $1, $2, $3)) YYABORT; }
  +;
  +
  +AssignmentExprNoBF:
  +    ConditionalExprNoBF
  +  | LeftHandSideExprNoBF AssignmentOperator AssignmentExpr
  +                                        { if (!makeAssignNode($$, $1, $2, $3)) YYABORT; }
   ;
   
   AssignmentOperator:
  -    '='                            { $$ = OpEqual; }
  -  | PLUSEQUAL                      { $$ = OpPlusEq; }
  -  | MINUSEQUAL                     { $$ = OpMinusEq; }
  -  | MULTEQUAL                      { $$ = OpMultEq; }
  -  | DIVEQUAL                       { $$ = OpDivEq; }
  -  | LSHIFTEQUAL                    { $$ = OpLShift; }
  -  | RSHIFTEQUAL                    { $$ = OpRShift; }
  -  | URSHIFTEQUAL                   { $$ = OpURShift; }
  -  | ANDEQUAL                       { $$ = OpAndEq; }
  -  | XOREQUAL                       { $$ = OpXOrEq; }
  -  | OREQUAL                        { $$ = OpOrEq; }
  -  | MODEQUAL                       { $$ = OpModEq; }
  +    '='                                 { $$ = OpEqual; }
  +  | PLUSEQUAL                           { $$ = OpPlusEq; }
  +  | MINUSEQUAL                          { $$ = OpMinusEq; }
  +  | MULTEQUAL                           { $$ = OpMultEq; }
  +  | DIVEQUAL                            { $$ = OpDivEq; }
  +  | LSHIFTEQUAL                         { $$ = OpLShift; }
  +  | RSHIFTEQUAL                         { $$ = OpRShift; }
  +  | URSHIFTEQUAL                        { $$ = OpURShift; }
  +  | ANDEQUAL                            { $$ = OpAndEq; }
  +  | XOREQUAL                            { $$ = OpXOrEq; }
  +  | OREQUAL                             { $$ = OpOrEq; }
  +  | MODEQUAL                            { $$ = OpModEq; }
   ;
   
   Expr:
       AssignmentExpr
  -  | Expr ',' AssignmentExpr        { $$ = new CommaNode($1, $3); }
  +  | Expr ',' AssignmentExpr             { $$ = new CommaNode($1, $3); }
  +;
  +
  +ExprNoIn:
  +    AssignmentExprNoIn
  +  | ExprNoIn ',' AssignmentExprNoIn     { $$ = new CommaNode($1, $3); }
  +;
  +
  +ExprNoBF:
  +    AssignmentExprNoBF
  +  | ExprNoBF ',' AssignmentExpr         { $$ = new CommaNode($1, $3); }
   ;
   
   Statement:
  @@ -410,277 +619,229 @@
   ;
   
   Block:
  -    '{' '}'                        { $$ = new BlockNode(0); DBG($$, @2, @2); }
  -  | '{' SourceElements '}'          { $$ = new BlockNode($2); DBG($$, @3, @3); }
  +    '{' '}'                             { $$ = new BlockNode(0); DBG($$, @2, @2); }
  +  | '{' SourceElements '}'              { $$ = new BlockNode($2); DBG($$, @3, @3); }
   ;
   
   StatementList:
  -    Statement                      { $$ = new StatListNode($1); }
  -  | StatementList Statement        { $$ = new StatListNode($1, $2); }
  +    Statement                           { $$ = new StatListNode($1); }
  +  | StatementList Statement             { $$ = new StatListNode($1, $2); }
   ;
   
   VariableStatement:
  -    VAR VariableDeclarationList ';' { $$ = new VarStatementNode($2);
  -                                      DBG($$, @1, @3); }
  -  | VAR VariableDeclarationList error { if (automatic()) {
  -                                          $$ = new VarStatementNode($2);
  -					  DBG($$, @1, @2);
  -                                        } else {
  -					  YYABORT;
  -					}
  -                                      }
  +    VAR VariableDeclarationList ';'     { $$ = new VarStatementNode($2); DBG($$, @1, @3); }
  +  | VAR VariableDeclarationList error   { $$ = new VarStatementNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   VariableDeclarationList:
  -    VariableDeclaration            { $$ = new VarDeclListNode($1); }
  +    VariableDeclaration                 { $$ = new VarDeclListNode($1); }
     | VariableDeclarationList ',' VariableDeclaration
  -                                   { $$ = new VarDeclListNode($1, $3); }
  +                                        { $$ = new VarDeclListNode($1, $3); }
  +;
  +
  +VariableDeclarationListNoIn:
  +    VariableDeclarationNoIn             { $$ = new VarDeclListNode($1); }
  +  | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
  +                                        { $$ = new VarDeclListNode($1, $3); }
   ;
   
   VariableDeclaration:
  -    IDENT                          { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
  -  | IDENT Initializer              { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
  +    IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
  +  | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
  +;
  +
  +VariableDeclarationNoIn:
  +    IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
  +  | IDENT InitializerNoIn               { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
   ;
   
   ConstStatement:
  -    CONST ConstDeclarationList ';' { $$ = new VarStatementNode($2);
  -                                      DBG($$, @1, @3); }
  -  | CONST ConstDeclarationList error { if (automatic()) {
  -                                          $$ = new VarStatementNode($2);
  -					  DBG($$, @1, @2);
  -                                        } else {
  -					  YYABORT;
  -					}
  -                                      }
  +    CONST ConstDeclarationList ';'      { $$ = new VarStatementNode($2); DBG($$, @1, @3); }
  +  | CONST ConstDeclarationList error    { $$ = new VarStatementNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   ConstDeclarationList:
  -    ConstDeclaration            { $$ = new VarDeclListNode($1); }
  -  | ConstDeclarationList ',' VariableDeclaration
  -                                   { $$ = new VarDeclListNode($1, $3); }
  +    ConstDeclaration                    { $$ = new VarDeclListNode($1); }
  +  | ConstDeclarationList ',' ConstDeclaration
  +                                        { $$ = new VarDeclListNode($1, $3); }
   ;
   
   ConstDeclaration:
  -    IDENT                          { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Constant); }
  -  | IDENT Initializer              { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Constant); }
  +    IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Constant); }
  +  | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Constant); }
   ;
   
   Initializer:
  -    '=' AssignmentExpr             { $$ = new AssignExprNode($2); }
  +    '=' AssignmentExpr                  { $$ = new AssignExprNode($2); }
  +;
  +
  +InitializerNoIn:
  +    '=' AssignmentExprNoIn              { $$ = new AssignExprNode($2); }
   ;
   
   EmptyStatement:
  -    ';'                            { $$ = new EmptyStatementNode(); }
  +    ';'                                 { $$ = new EmptyStatementNode(); }
   ;
   
   ExprStatement:
  -    Expr ';'                       { $$ = new ExprStatementNode($1);
  -                                     DBG($$, @1, @2); }
  -  | Expr error                     { if (automatic()) {
  -                                       $$ = new ExprStatementNode($1);
  -				       DBG($$, @1, @1);
  -                                     } else
  -				       YYABORT; }
  +    ExprNoBF ';'                        { $$ = new ExprStatementNode($1); DBG($$, @1, @2); }
  +  | ExprNoBF error                      { $$ = new ExprStatementNode($1); DBG($$, @1, @1); AUTO_SEMICOLON; }
   ;
   
  -IfStatement: /* shift/reduce conflict due to dangling else */
  -    IF '(' Expr ')' Statement      { $$ = new IfNode($3,$5,0);DBG($$, at 1, at 4); }
  +IfStatement:
  +    IF '(' Expr ')' Statement %prec IF_WITHOUT_ELSE
  +                                        { $$ = new IfNode($3, $5, 0); DBG($$, @1, @4); }
     | IF '(' Expr ')' Statement ELSE Statement
  -                                   { $$ = new IfNode($3,$5,$7);DBG($$, at 1, at 4); }
  +                                        { $$ = new IfNode($3, $5, $7); DBG($$, @1, @4); }
   ;
   
   IterationStatement:
  -    DO Statement WHILE '(' Expr ')' { $$=new DoWhileNode($2,$5);DBG($$, at 1, at 3);}
  -  | WHILE '(' Expr ')' Statement   { $$ = new WhileNode($3,$5);DBG($$, at 1, at 4); }
  -  | FOR '(' ExprOpt ';' ExprOpt ';' ExprOpt ')'
  -            Statement              { $$ = new ForNode($3,$5,$7,$9);
  -	                             DBG($$, at 1, at 8); }
  -  | FOR '(' VAR VariableDeclarationList ';' ExprOpt ';' ExprOpt ')'
  -            Statement              { $$ = new ForNode($4,$6,$8,$10);
  -	                             DBG($$, at 1, at 9); }
  -  | FOR '(' LeftHandSideExpr IN Expr ')'
  -            Statement              { 
  -                                     Node *n = $3;
  -                                     bool paren = n->isGroupNode();
  -                                     if (paren)
  -                                         n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  -                                     
  -                                     if (!n->isLocation())
  -                                         YYABORT;
  -
  -                                     $$ = new ForInNode(n, $5, $7);
  -	                             DBG($$, at 1, at 6); 
  -                                   }
  -  | FOR '(' VAR IDENT IN Expr ')'
  -            Statement              { $$ = new ForInNode(*$4,0,$6,$8);
  -	                             DBG($$, at 1, at 7); }
  -  | FOR '(' VAR IDENT Initializer IN Expr ')'
  -            Statement              { $$ = new ForInNode(*$4,$5,$7,$9);
  -	                             DBG($$, at 1, at 8); }
  +    DO Statement WHILE '(' Expr ')'     { $$ = new DoWhileNode($2, $5); DBG($$, @1, @3);}
  +  | WHILE '(' Expr ')' Statement        { $$ = new WhileNode($3, $5); DBG($$, @1, @4); }
  +  | FOR '(' ExprNoInOpt ';' ExprOpt ';' ExprOpt ')' Statement
  +                                        { $$ = new ForNode($3, $5, $7, $9); DBG($$, @1, @8); }
  +  | FOR '(' VAR VariableDeclarationListNoIn ';' ExprOpt ';' ExprOpt ')' Statement
  +                                        { $$ = new ForNode($4, $6, $8, $10); DBG($$, @1, @9); }
  +  | FOR '(' LeftHandSideExpr IN Expr ')' Statement
  +                                        {
  +                                            Node *n = $3->nodeInsideAllParens();
  +                                            if (!n->isLocation())
  +                                                YYABORT;
  +                                            $$ = new ForInNode(n, $5, $7);
  +                                            DBG($$, @1, @6);
  +                                        }
  +  | FOR '(' VAR IDENT IN Expr ')' Statement
  +                                        { $$ = new ForInNode(*$4, 0, $6, $8); DBG($$, @1, @7); }
  +  | FOR '(' VAR IDENT InitializerNoIn IN Expr ')' Statement
  +                                        { $$ = new ForInNode(*$4, $5, $7, $9); DBG($$, @1, @8); }
   ;
   
   ExprOpt:
  -    /* nothing */                  { $$ = 0; }
  +    /* nothing */                       { $$ = 0; }
     | Expr
   ;
   
  +ExprNoInOpt:
  +    /* nothing */                       { $$ = 0; }
  +  | ExprNoIn
  +;
  +
   ContinueStatement:
  -    CONTINUE ';'                   { $$ = new ContinueNode(); DBG($$, at 1, at 2); }
  -  | CONTINUE error                 { if (automatic()) {
  -                                       $$ = new ContinueNode(); DBG($$, at 1, at 1);
  -                                     } else
  -				       YYABORT; }
  -  | CONTINUE IDENT ';'             { $$ = new ContinueNode(*$2); DBG($$, at 1, at 3); }
  -  | CONTINUE IDENT error           { if (automatic()) {
  -                                       $$ = new ContinueNode(*$2);DBG($$, at 1, at 2);
  -                                     } else
  -				       YYABORT; }
  +    CONTINUE ';'                        { $$ = new ContinueNode(); DBG($$, @1, @2); }
  +  | CONTINUE error                      { $$ = new ContinueNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
  +  | CONTINUE IDENT ';'                  { $$ = new ContinueNode(*$2); DBG($$, @1, @3); }
  +  | CONTINUE IDENT error                { $$ = new ContinueNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   BreakStatement:
  -    BREAK ';'                      { $$ = new BreakNode();DBG($$, at 1, at 2); }
  -  | BREAK error                    { if (automatic()) {
  -                                       $$ = new BreakNode(); DBG($$, at 1, at 1);
  -                                     } else
  -				       YYABORT; }
  -  | BREAK IDENT ';'                { $$ = new BreakNode(*$2); DBG($$, at 1, at 3); }
  -  | BREAK IDENT error              { if (automatic()) {
  -                                       $$ = new BreakNode(*$2); DBG($$, at 1, at 2);
  -                                     } else
  -				       YYABORT;
  -                                   }
  +    BREAK ';'                           { $$ = new BreakNode(); DBG($$, @1, @2); }
  +  | BREAK error                         { $$ = new BreakNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
  +  | BREAK IDENT ';'                     { $$ = new BreakNode(*$2); DBG($$, @1, @3); }
  +  | BREAK IDENT error                   { $$ = new BreakNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   ReturnStatement:
  -    RETURN ';'                     { $$ = new ReturnNode(0); DBG($$, at 1, at 2); }
  -  | RETURN error                   { if (automatic()) {
  -                                       $$ = new ReturnNode(0); DBG($$, at 1, at 1);
  -                                     } else
  -				       YYABORT; }
  -  | RETURN Expr ';'                { $$ = new ReturnNode($2); DBG($$, at 1, at 3); }
  -  | RETURN Expr error              { if (automatic()) {
  -                                       $$ = new ReturnNode($2); DBG($$, at 1, at 2);
  -                                     } else
  -				       YYABORT; }
  +    RETURN ';'                          { $$ = new ReturnNode(0); DBG($$, @1, @2); }
  +  | RETURN error                        { $$ = new ReturnNode(0); DBG($$, @1, @1); AUTO_SEMICOLON; }
  +  | RETURN Expr ';'                     { $$ = new ReturnNode($2); DBG($$, @1, @3); }
  +  | RETURN Expr error                   { $$ = new ReturnNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   WithStatement:
  -    WITH '(' Expr ')' Statement    { $$ = new WithNode($3,$5);
  -                                     DBG($$, @1, @4); }
  +    WITH '(' Expr ')' Statement         { $$ = new WithNode($3, $5); DBG($$, @1, @4); }
   ;
   
   SwitchStatement:
  -    SWITCH '(' Expr ')' CaseBlock  { $$ = new SwitchNode($3, $5);
  -                                     DBG($$, @1, @4); }
  +    SWITCH '(' Expr ')' CaseBlock       { $$ = new SwitchNode($3, $5); DBG($$, @1, @4); }
   ;
   
   CaseBlock:
  -    '{' CaseClausesOpt '}'         { $$ = new CaseBlockNode($2, 0, 0); }
  +    '{' CaseClausesOpt '}'              { $$ = new CaseBlockNode($2, 0, 0); }
     | '{' CaseClausesOpt DefaultClause CaseClausesOpt '}'
  -                                   { $$ = new CaseBlockNode($2, $3, $4); }
  +                                        { $$ = new CaseBlockNode($2, $3, $4); }
   ;
   
   CaseClausesOpt:
  -    /* nothing */                  { $$ = 0; }
  +    /* nothing */                       { $$ = 0; }
     | CaseClauses
   ;
   
   CaseClauses:
  -    CaseClause                     { $$ = new ClauseListNode($1); }
  -  | CaseClauses CaseClause         { $$ = new ClauseListNode($1, $2); }
  +    CaseClause                          { $$ = new ClauseListNode($1); }
  +  | CaseClauses CaseClause              { $$ = new ClauseListNode($1, $2); }
   ;
   
   CaseClause:
  -    CASE Expr ':'                  { $$ = new CaseClauseNode($2); }
  -  | CASE Expr ':' StatementList    { $$ = new CaseClauseNode($2, $4); }
  +    CASE Expr ':'                       { $$ = new CaseClauseNode($2); }
  +  | CASE Expr ':' StatementList         { $$ = new CaseClauseNode($2, $4); }
   ;
   
   DefaultClause:
  -    DEFAULT ':'                    { $$ = new CaseClauseNode(0); }
  -  | DEFAULT ':' StatementList      { $$ = new CaseClauseNode(0, $3); }
  +    DEFAULT ':'                         { $$ = new CaseClauseNode(0); }
  +  | DEFAULT ':' StatementList           { $$ = new CaseClauseNode(0, $3); }
   ;
   
   LabelledStatement:
  -    IDENT ':' Statement            { $3->pushLabel(*$1);
  -                                     $$ = new LabelNode(*$1, $3); }
  +    IDENT ':' Statement                 { $3->pushLabel(*$1); $$ = new LabelNode(*$1, $3); }
   ;
   
   ThrowStatement:
  -    THROW Expr ';'                 { $$ = new ThrowNode($2); DBG($$, at 1, at 3); }
  -  | THROW Expr error               { if (automatic()) { $$ = new ThrowNode($2); DBG($$, at 1, at 2); } else YYABORT; }
  +    THROW Expr ';'                      { $$ = new ThrowNode($2); DBG($$, @1, @3); }
  +  | THROW Expr error                    { $$ = new ThrowNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
   ;
   
   TryStatement:
  -    TRY Block Catch                { $$ = new TryNode($2, $3); DBG($$, at 1, at 2); }
  -  | TRY Block Finally              { $$ = new TryNode($2, $3); DBG($$, at 1, at 2); }
  -  | TRY Block Catch Finally        { $$ = new TryNode($2, $3, $4); DBG($$, at 1, at 2); }
  -;
  -
  -Catch:
  -    CATCH '(' IDENT ')' Block      { $$ = new CatchNode(*$3, $5); }
  -;
  -
  -Finally:
  -    FINALLY Block                  { $$ = new FinallyNode($2); }
  +    TRY Block FINALLY Block             { $$ = new TryNode($2, Identifier::null(), 0, $4); DBG($$, @1, @2); }
  +  | TRY Block CATCH '(' IDENT ')' Block { $$ = new TryNode($2, *$5, $7, 0); DBG($$, @1, @2); }
  +  | TRY Block CATCH '(' IDENT ')' Block FINALLY Block
  +                                        { $$ = new TryNode($2, *$5, $7, $9); DBG($$, @1, @2); }
   ;
   
   FunctionDeclaration:
  -    FUNCTION '(' ')' FunctionBody  { YYABORT; }
  -  | FUNCTION '(' FormalParameterList ')' FunctionBody
  -                                   { YYABORT; }
  -  | FUNCTION IDENT '(' ')' FunctionBody
  -                                   { $$ = new FuncDeclNode(*$2, $5); }
  +    FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncDeclNode(*$2, $5); }
     | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
  -                                   { $$ = new FuncDeclNode(*$2, $4, $6); }
  +                                        { $$ = new FuncDeclNode(*$2, $4, $6); }
   ;
   
   FunctionExpr:
  -    FUNCTION '(' ')' FunctionBody  { $$ = new FuncExprNode(Identifier::null(), $4); }
  +    FUNCTION '(' ')' FunctionBody       { $$ = new FuncExprNode(Identifier::null(), $4); }
     | FUNCTION '(' FormalParameterList ')' FunctionBody
  -                                   { $$ = new FuncExprNode(Identifier::null(), $3, $5); }
  -  | FUNCTION IDENT '(' ')' FunctionBody
  -                                   { $$ = new FuncExprNode(*$2, $5); }
  +                                        { $$ = new FuncExprNode(Identifier::null(), $3, $5); }
  +  | FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncExprNode(*$2, $5); }
     | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
  -                                   { $$ = new FuncExprNode(*$2, $4, $6); }
  +                                        { $$ = new FuncExprNode(*$2, $4, $6); }
   ;
   
   FormalParameterList:
  -    IDENT                          { $$ = new ParameterNode(*$1); }
  -  | FormalParameterList ',' IDENT  { $$ = new ParameterNode($1, *$3); }
  +    IDENT                               { $$ = new ParameterNode(*$1); }
  +  | FormalParameterList ',' IDENT       { $$ = new ParameterNode($1, *$3); }
   ;
   
   FunctionBody:
  -    '{' '}'  /* TODO: spec ??? */  { $$ = new FunctionBodyNode(0);
  -	                             DBG($$, @1, @2);}
  -  | '{' SourceElements '}'         { $$ = new FunctionBodyNode($2);
  -	                             DBG($$, @1, @3);}
  +    '{' '}' /* not in spec */           { $$ = new FunctionBodyNode(0); DBG($$, @1, @2); }
  +  | '{' SourceElements '}'              { $$ = new FunctionBodyNode($2); DBG($$, @1, @3); }
   ;
   
   Program:
  -    /* nothing, empty script */      { $$ = new ProgramNode(0);
  -                                     Parser::accept($$); }
  -    | SourceElements                 { $$ = new ProgramNode($1);
  -                                     Parser::accept($$); }
  +    /* not in spec */                   { Parser::accept(new ProgramNode(0)); }
  +    | SourceElements                    { Parser::accept(new ProgramNode($1)); }
   ;
   
   SourceElements:
  -    SourceElement                  { $$ = new SourceElementsNode($1); }
  -  | SourceElements SourceElement   { $$ = new SourceElementsNode($1, $2); }
  +    SourceElement                       { $$ = new SourceElementsNode($1); }
  +  | SourceElements SourceElement        { $$ = new SourceElementsNode($1, $2); }
   ;
   
   SourceElement:
  -    FunctionDeclaration            { $$ = $1; }
  -  | Statement                      { $$ = $1; }
  +    FunctionDeclaration                 { $$ = $1; }
  +  | Statement                           { $$ = $1; }
   ;
  -
  + 
   %%
   
   static bool makeAssignNode(Node*& result, Node *loc, Operator op, Node *expr)
   { 
  -    Node *n = loc;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = loc->nodeInsideAllParens();
   
       if (!n->isLocation())
           return false;
  @@ -702,10 +863,7 @@
   
   static bool makePrefixNode(Node*& result, Node *expr, Operator op)
   { 
  -    Node *n = expr;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = expr->nodeInsideAllParens();
   
       if (!n->isLocation())
           return false;
  @@ -727,10 +885,7 @@
   
   static bool makePostfixNode(Node*& result, Node *expr, Operator op)
   { 
  -    Node *n = expr;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = expr->nodeInsideAllParens();
   
       if (!n->isLocation())
           return false;
  @@ -752,10 +907,7 @@
   
   static Node *makeFunctionCallNode(Node *func, ArgumentsNode *args)
   {
  -    Node *n = func;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = func->nodeInsideAllParens();
       
       if (!n->isLocation())
           return new FunctionCallValueNode(func, args);
  @@ -764,14 +916,14 @@
           return new FunctionCallResolveNode(resolve->identifier(), args);
       } else if (n->isBracketAccessorNode()) {
           BracketAccessorNode *bracket = static_cast<BracketAccessorNode *>(n);
  -        if (paren)
  +        if (n != func)
               return new FunctionCallParenBracketNode(bracket->base(), bracket->subscript(), args);
           else
               return new FunctionCallBracketNode(bracket->base(), bracket->subscript(), args);
       } else {
           assert(n->isDotAccessorNode());
           DotAccessorNode *dot = static_cast<DotAccessorNode *>(n);
  -        if (paren)
  +        if (n != func)
               return new FunctionCallParenDotNode(dot->base(), dot->identifier(), args);
           else
               return new FunctionCallDotNode(dot->base(), dot->identifier(), args);
  @@ -780,10 +932,7 @@
   
   static Node *makeTypeOfNode(Node *expr)
   {
  -    Node *n = expr;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = expr->nodeInsideAllParens();
   
       if (n->isResolveNode()) {
           ResolveNode *resolve = static_cast<ResolveNode *>(n);
  @@ -794,10 +943,7 @@
   
   static Node *makeDeleteNode(Node *expr)
   {
  -    Node *n = expr;
  -    bool paren = n->isGroupNode();
  -    if (paren)
  -        n = static_cast<GroupNode *>(n)->nodeInsideAllParens();
  +    Node *n = expr->nodeInsideAllParens();
       
       if (!n->isLocation())
           return new DeleteValueNode(expr);
  @@ -814,20 +960,14 @@
       }
   }
   
  -int yyerror (const char * /* s */)  /* Called by yyparse on error */
  +int yyerror(const char * /* s */)  /* Called by yyparse on error */
   {
  -  // fprintf(stderr, "ERROR: %s at line %d\n",
  -  //	  s, KJS::Lexer::curr()->lineNo());
  +  // fprintf(stderr, "ERROR: %s at line %d\n", s, KJS::Lexer::curr()->lineNo());
     return 1;
   }
   
   /* may we automatically insert a semicolon ? */
  -bool automatic()
  +static bool allowAutomaticSemicolon()
   {
  -  if (yychar == '}' || yychar == 0)
  -    return true;
  -  else if (Lexer::curr()->prevTerminator())
  -    return true;
  -
  -  return false;
  +    return yychar == '}' || yychar == 0 || Lexer::curr()->prevTerminator();
   }
  
  
  
  1.84      +109 -178  JavaScriptCore/kjs/nodes.cpp
  
  Index: nodes.cpp
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/kjs/nodes.cpp,v
  retrieving revision 1.83
  retrieving revision 1.84
  diff -u -r1.83 -r1.84
  --- nodes.cpp	27 Sep 2005 23:38:22 -0000	1.83
  +++ nodes.cpp	28 Sep 2005 18:51:14 -0000	1.84
  @@ -59,7 +59,9 @@
   #define KJS_CHECKEXCEPTION \
     if (exec->hadException()) { \
       setExceptionDetailsIfNeeded(exec); \
  -    return Completion(Throw, exec->exception()); \
  +    ValueImp *ex = exec->exception(); \
  +    exec->clearException(); \
  +    return Completion(Throw, ex); \
     } \
     if (Collector::outOfMemory()) \
       return Completion(Throw, Error::create(exec, GeneralError, "Out of memory"));
  @@ -67,7 +69,7 @@
   #define KJS_CHECKEXCEPTIONVALUE \
     if (exec->hadException()) { \
       setExceptionDetailsIfNeeded(exec); \
  -    return exec->exception(); \
  +    return Undefined(); \
     } \
     if (Collector::outOfMemory()) \
       return Undefined(); // will be picked up by KJS_CHECKEXCEPTION
  @@ -80,10 +82,6 @@
     if (Collector::outOfMemory()) \
       return List(); // will be picked up by KJS_CHECKEXCEPTION
   
  -#ifdef KJS_DEBUG_MEM
  -std::list<Node *> * Node::s_nodes = 0L;
  -#endif
  -
   // ------------------------------ Node -----------------------------------------
   
   Node::Node()
  @@ -98,28 +96,28 @@
   {
   }
   
  -#ifdef KJS_DEBUG_MEM
  -void Node::finalCheck()
  +static void substitute(UString &string, const UString &substring)
   {
  -  fprintf( stderr, "Node::finalCheck(): list count       : %d\n", (int)s_nodes.size() );
  -  std::list<Node *>::iterator it = s_nodes->begin();
  -  for ( unsigned i = 0; it != s_nodes->end() ; ++it, ++i )
  -    fprintf( stderr, "[%d] Still having node %p (%s) (refcount %d)\n", i, (void*)*it, typeid( **it ).name(), (*it)->refcount );
  -  delete s_nodes;
  -  s_nodes = 0L;
  +    int position = string.find("%s");
  +    assert(position != -1);
  +    string = string.substr(0, position) + substring + string.substr(position + 2);
   }
  -#endif
   
  -ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg)
  +Completion Node::createErrorCompletion(ExecState *exec, ErrorType e, const char *msg)
   {
  -    return KJS::throwError(exec, e, msg, lineNo(), sourceId(), &sourceURL);
  +    return Completion(Throw, Error::create(exec, e, msg, lineNo(), sourceId(), &sourceURL));
   }
   
  -static void substitute(UString &string, const UString &substring)
  +Completion Node::createErrorCompletion(ExecState *exec, ErrorType e, const char *msg, const Identifier &ident)
   {
  -    int position = string.find("%s");
  -    assert(position != -1);
  -    string = string.substr(0, position) + substring + string.substr(position + 2);
  +    UString message = msg;
  +    substitute(message, ident.ustring());
  +    return Completion(Throw, Error::create(exec, e, message, lineNo(), sourceId(), &sourceURL));
  +}
  +
  +ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg)
  +{
  +    return KJS::throwError(exec, e, msg, lineNo(), sourceId(), &sourceURL);
   }
   
   ValueImp *Node::throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *v, Node *expr)
  @@ -164,6 +162,11 @@
       return KJS::throwError(exec, e, message, lineNo(), sourceId(), &sourceURL);
   }
   
  +ValueImp *Node::throwUndefinedVariableError(ExecState *exec, const Identifier &ident)
  +{
  +    return throwError(exec, ReferenceError, "Can't find variable: %s", ident);
  +}
  +
   void Node::setExceptionDetailsIfNeeded(ExecState *exec)
   {
       ValueImp *exceptionValue = exec->exception();
  @@ -176,6 +179,11 @@
       }
   }
   
  +Node *Node::nodeInsideAllParens()
  +{
  +    return this;
  +}
  +
   // ------------------------------ StatementNode --------------------------------
   
   StatementNode::StatementNode() : l0(-1), l1(-1), sid(-1), breakPoint(false)
  @@ -199,44 +207,34 @@
       return true; // continue
   }
   
  -// return true if the debugger wants us to stop at this point
  -bool StatementNode::abortStatement(ExecState *exec)
  -{
  -  Debugger *dbg = exec->dynamicInterpreter()->imp()->debugger();
  -  if (dbg)
  -    return dbg->imp()->aborted();
  -  else
  -    return false;
  -}
  -
   void StatementNode::processFuncDecl(ExecState *exec)
   {
   }
   
   // ------------------------------ NullNode -------------------------------------
   
  -ValueImp *NullNode::evaluate(ExecState */*exec*/)
  +ValueImp *NullNode::evaluate(ExecState *)
   {
     return Null();
   }
   
   // ------------------------------ BooleanNode ----------------------------------
   
  -ValueImp *BooleanNode::evaluate(ExecState */*exec*/)
  +ValueImp *BooleanNode::evaluate(ExecState *)
   {
     return jsBoolean(value);
   }
   
   // ------------------------------ NumberNode -----------------------------------
   
  -ValueImp *NumberNode::evaluate(ExecState */*exec*/)
  +ValueImp *NumberNode::evaluate(ExecState *)
   {
     return jsNumber(value);
   }
   
   // ------------------------------ StringNode -----------------------------------
   
  -ValueImp *StringNode::evaluate(ExecState */*exec*/)
  +ValueImp *StringNode::evaluate(ExecState *)
   {
     return jsString(value);
   }
  @@ -263,11 +261,6 @@
   
   // ------------------------------ ResolveNode ----------------------------------
   
  -static ValueImp *undefinedVariableError(ExecState *exec, const Identifier &ident)
  -{
  -    return throwError(exec, ReferenceError, "Can't find variable: " + ident.ustring());
  -}
  -
   // ECMA 11.1.2 & 10.1.4
   ValueImp *ResolveNode::evaluate(ExecState *exec)
   {
  @@ -288,7 +281,7 @@
       ++iter;
     } while (iter != end);
   
  -  return undefinedVariableError(exec, ident);
  +  return throwUndefinedVariableError(exec, ident);
   }
   
   // ------------------------------ GroupNode ------------------------------------
  @@ -299,6 +292,15 @@
     return group->evaluate(exec);
   }
   
  +Node *GroupNode::nodeInsideAllParens()
  +{
  +    Node *n = this;
  +    do
  +        n = static_cast<GroupNode *>(n)->group.get();
  +    while (n->isGroupNode());
  +    return n;
  +}
  +
   // ------------------------------ ElementNode ----------------------------------
   
   // ECMA 11.1.4
  @@ -372,7 +374,7 @@
   // ------------------------------ PropertyNode ---------------------------------
   
   // ECMA 11.1.5
  -ValueImp *PropertyNode::evaluate(ExecState */*exec*/)
  +ValueImp *PropertyNode::evaluate(ExecState *)
   {
     ValueImp *s;
   
  @@ -414,10 +416,10 @@
   
   // ------------------------------ ArgumentListNode -----------------------------
   
  -ValueImp *ArgumentListNode::evaluate(ExecState */*exec*/)
  +ValueImp *ArgumentListNode::evaluate(ExecState *)
   {
     assert(0);
  -  return NULL; // dummy, see evaluateList()
  +  return 0; // dummy, see evaluateList()
   }
   
   // ECMA 11.2.4
  @@ -436,10 +438,10 @@
   
   // ------------------------------ ArgumentsNode --------------------------------
   
  -ValueImp *ArgumentsNode::evaluate(ExecState */*exec*/)
  +ValueImp *ArgumentsNode::evaluate(ExecState *)
   {
     assert(0);
  -  return NULL; // dummy, see evaluateList()
  +  return 0; // dummy, see evaluateList()
   }
   
   // ECMA 11.2.4
  @@ -548,7 +550,7 @@
       ++iter;
     } while (iter != end);
     
  -  return undefinedVariableError(exec, ident);
  +  return throwUndefinedVariableError(exec, ident);
   }
   
   // ECMA 11.2.3
  @@ -671,7 +673,7 @@
       ++iter;
     } while (iter != end);
   
  -  return undefinedVariableError(exec, m_ident);
  +  return throwUndefinedVariableError(exec, m_ident);
   }
   
   // ------------------------------ PostfixBracketNode ----------------------------------
  @@ -902,7 +904,7 @@
       ++iter;
     } while (iter != end);
   
  -  return undefinedVariableError(exec, m_ident);
  +  return throwUndefinedVariableError(exec, m_ident);
   }
   
   // ------------------------------ PrefixBracketNode ----------------------------------
  @@ -977,7 +979,7 @@
     ValueImp *v = expr->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
   
  -  return jsNumber(v->toNumber(exec)); /* TODO: optimize */
  +  return jsNumber(v->toNumber(exec));
   }
   
   // ------------------------------ NegateNode -----------------------------------
  @@ -1291,7 +1293,7 @@
     } while (iter != end);
   
     if (m_oper != OpEqual)
  -    return undefinedVariableError(exec, m_ident);
  +    return throwUndefinedVariableError(exec, m_ident);
   
    found:
     ValueImp *v;
  @@ -1419,12 +1421,6 @@
   {
     Completion c = statement->execute(exec);
     KJS_ABORTPOINT
  -  if (exec->hadException()) {
  -    ValueImp *ex = exec->exception();
  -    exec->clearException();
  -    return Completion(Throw, ex);
  -  }
  -
     if (c.complType() != Normal)
       return c;
     
  @@ -1436,12 +1432,6 @@
       if (c2.complType() != Normal)
         return c2;
   
  -    if (exec->hadException()) {
  -      ValueImp *ex = exec->exception();
  -      exec->clearException();
  -      return Completion(Throw, ex);
  -    }
  -
       if (c2.isValueCompletion())
         v = c2.value();
       c = c2;
  @@ -1485,7 +1475,7 @@
         // already declared? - check with getDirect so you can override
         // built-in properties of the global object with var declarations.
         if (variable->getDirect(ident)) 
  -          return NULL;
  +          return 0;
         val = Undefined();
     }
   
  @@ -1589,7 +1579,7 @@
   // ------------------------------ EmptyStatementNode ---------------------------
   
   // ECMA 12.3
  -Completion EmptyStatementNode::execute(ExecState */*exec*/)
  +Completion EmptyStatementNode::execute(ExecState *)
   {
     return Completion(Normal);
   }
  @@ -1657,7 +1647,7 @@
       exec->context().imp()->seenLabels()->popIteration();
       if (!((c.complType() == Continue) && ls.contains(c.target()))) {
         if ((c.complType() == Break) && ls.contains(c.target()))
  -        return Completion(Normal, NULL);
  +        return Completion(Normal, 0);
         if (c.complType() != Normal)
           return c;
       }
  @@ -1665,7 +1655,7 @@
       KJS_CHECKEXCEPTION
     } while (bv->toBoolean(exec));
   
  -  return Completion(Normal, NULL);
  +  return Completion(Normal, 0);
   }
   
   void DoWhileNode::processVarDecls(ExecState *exec)
  @@ -1683,7 +1673,7 @@
     ValueImp *bv;
     Completion c;
     bool b(false);
  -  ValueImp *value = NULL;
  +  ValueImp *value = 0;
   
     while (1) {
       bv = expr->evaluate(exec);
  @@ -1723,7 +1713,7 @@
   // ECMA 12.6.3
   Completion ForNode::execute(ExecState *exec)
   {
  -  ValueImp *v, *cval = NULL;
  +  ValueImp *v, *cval = 0;
   
     if (expr1) {
       v = expr1->evaluate(exec);
  @@ -1786,7 +1776,7 @@
   Completion ForInNode::execute(ExecState *exec)
   {
     ValueImp *e;
  -  ValueImp *retval = NULL;
  +  ValueImp *retval = 0;
     ObjectImp *v;
     Completion c;
     ReferenceList propList;
  @@ -1803,7 +1793,7 @@
     // property list but will throw an exception if you attempt to
     // access any property.
     if (e->isUndefinedOrNull()) {
  -    return Completion(Normal, NULL);
  +    return Completion(Normal, 0);
     }
   
     KJS_CHECKEXCEPTION
  @@ -1902,13 +1892,11 @@
     KJS_BREAKPOINT;
   
     if (ident.isEmpty() && !exec->context().imp()->seenLabels()->inIteration())
  -    return Completion(Throw,
  -		      throwError(exec, SyntaxError, "Invalid continue statement."));
  +    return createErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
     else if (!ident.isEmpty() && !exec->context().imp()->seenLabels()->contains(ident))
  -    return Completion(Throw,
  -                      throwError(exec, SyntaxError, "Label %s not found.", ident));
  +    return createErrorCompletion(exec, SyntaxError, "Label %s not found.", ident);
     else
  -    return Completion(Continue, NULL, ident);
  +    return Completion(Continue, 0, ident);
   }
   
   // ------------------------------ BreakNode ------------------------------------
  @@ -1920,13 +1908,11 @@
   
     if (ident.isEmpty() && !exec->context().imp()->seenLabels()->inIteration() &&
         !exec->context().imp()->seenLabels()->inSwitch())
  -    return Completion(Throw,
  -		      throwError(exec, SyntaxError, "Invalid break statement."));
  +    return createErrorCompletion(exec, SyntaxError, "Invalid break statement.");
     else if (!ident.isEmpty() && !exec->context().imp()->seenLabels()->contains(ident))
  -    return Completion(Throw,
  -                      throwError(exec, SyntaxError, "Label %s not found.", ident));
  +    return createErrorCompletion(exec, SyntaxError, "Label %s not found.");
     else
  -    return Completion(Break, NULL, ident);
  +    return Completion(Break, 0, ident);
   }
   
   // ------------------------------ ReturnNode -----------------------------------
  @@ -1938,7 +1924,7 @@
   
     CodeType codeType = exec->context().imp()->codeType();
     if (codeType != FunctionCode && codeType != AnonymousCode ) {
  -    return Completion(Throw, throwError(exec, SyntaxError, "Invalid return statement."));    
  +    return createErrorCompletion(exec, SyntaxError, "Invalid return statement.");
     }
   
     if (!value)
  @@ -2001,11 +1987,11 @@
   
   // ------------------------------ ClauseListNode -------------------------------
   
  -ValueImp *ClauseListNode::evaluate(ExecState */*exec*/)
  +ValueImp *ClauseListNode::evaluate(ExecState *)
   {
  -  /* should never be called */
  +  // should never be called
     assert(false);
  -  return NULL;
  +  return 0;
   }
   
   // ECMA 12.11
  @@ -2038,11 +2024,11 @@
     }
   }
    
  -ValueImp *CaseBlockNode::evaluate(ExecState */*exec*/)
  +ValueImp *CaseBlockNode::evaluate(ExecState *)
   {
  -  /* should never be called */
  +  // should never be called
     assert(false);
  -  return NULL;
  +  return 0;
   }
   
   // ECMA 12.11
  @@ -2147,13 +2133,9 @@
   // ECMA 12.12
   Completion LabelNode::execute(ExecState *exec)
   {
  -  Completion e;
  -
  -  if (!exec->context().imp()->seenLabels()->push(label)) {
  -    return Completion( Throw,
  -		       throwError(exec, SyntaxError, "Duplicated label %s found.", label));
  -  };
  -  e = statement->execute(exec);
  +  if (!exec->context().imp()->seenLabels()->push(label))
  +    return createErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", label);
  +  Completion e = statement->execute(exec);
     exec->context().imp()->seenLabels()->pop();
   
     if ((e.complType() == Break) && (e.target() == label))
  @@ -2179,49 +2161,6 @@
     return Completion(Throw, v);
   }
   
  -// ------------------------------ CatchNode ------------------------------------
  -
  -Completion CatchNode::execute(ExecState */*exec*/)
  -{
  -  // should never be reached. execute(exec, arg) is used instead
  -  assert(0L);
  -  return Completion();
  -}
  -
  -// ECMA 12.14
  -Completion CatchNode::execute(ExecState *exec, ValueImp *arg)
  -{
  -  /* TODO: correct ? Not part of the spec */
  -
  -  exec->clearException();
  -
  -  ObjectImp *obj(new ObjectImp());
  -  obj->put(exec, ident, arg, DontDelete);
  -  exec->context().imp()->pushScope(obj);
  -  Completion c = block->execute(exec);
  -  exec->context().imp()->popScope();
  -
  -  return c;
  -}
  -
  -void CatchNode::processVarDecls(ExecState *exec)
  -{
  -  block->processVarDecls(exec);
  -}
  -
  -// ------------------------------ FinallyNode ----------------------------------
  -
  -// ECMA 12.14
  -Completion FinallyNode::execute(ExecState *exec)
  -{
  -  return block->execute(exec);
  -}
  -
  -void FinallyNode::processVarDecls(ExecState *exec)
  -{
  -  block->processVarDecls(exec);
  -}
  -
   // ------------------------------ TryNode --------------------------------------
   
   // ECMA 12.14
  @@ -2229,48 +2168,38 @@
   {
     KJS_BREAKPOINT;
   
  -  Completion c, c2;
  +  Completion c = tryBlock->execute(exec);
   
  -  c = block->execute(exec);
  -
  -  if (!_final) {
  -    if (c.complType() != Throw)
  -      return c;
  -    return _catch->execute(exec,c.value());
  +  if (catchBlock && c.complType() == Throw) {
  +    ObjectImp *obj = new ObjectImp;
  +    obj->put(exec, exceptionIdent, c.value(), DontDelete);
  +    exec->context().imp()->pushScope(obj);
  +    c = catchBlock->execute(exec);
  +    exec->context().imp()->popScope();
     }
   
  -  if (!_catch) {
  -    ValueImp *lastException = exec->exception();
  -    exec->clearException();
  -    
  -    c2 = _final->execute(exec);
  -    
  -    if (!exec->hadException())
  -      exec->setException(lastException);
  -    
  -    return (c2.complType() == Normal) ? c : c2;
  +  if (finallyBlock) {
  +    Completion c2 = finallyBlock->execute(exec);
  +    if (c2.complType() != Normal)
  +      c = c2;
     }
   
  -  if (c.complType() == Throw)
  -    c = _catch->execute(exec,c.value());
  -
  -  c2 = _final->execute(exec);
  -  return (c2.complType() == Normal) ? c : c2;
  +  return c;
   }
   
   void TryNode::processVarDecls(ExecState *exec)
   {
  -  block->processVarDecls(exec);
  -  if (_final)
  -    _final->processVarDecls(exec);
  -  if (_catch)
  -    _catch->processVarDecls(exec);
  +  tryBlock->processVarDecls(exec);
  +  if (catchBlock)
  +    catchBlock->processVarDecls(exec);
  +  if (finallyBlock)
  +    finallyBlock->processVarDecls(exec);
   }
   
   // ------------------------------ ParameterNode --------------------------------
   
   // ECMA 13
  -ValueImp *ParameterNode::evaluate(ExecState */*exec*/)
  +ValueImp *ParameterNode::evaluate(ExecState *)
   {
     return Undefined();
   }
  @@ -2281,7 +2210,6 @@
     : BlockNode(s)
   {
     setLoc(-1, -1, -1);
  -  //fprintf(stderr,"FunctionBodyNode::FunctionBodyNode %p\n",this);
   }
   
   void FunctionBodyNode::processFuncDecl(ExecState *exec)
  @@ -2298,8 +2226,7 @@
     ContextImp *context = exec->context().imp();
   
     // TODO: let this be an object with [[Class]] property "Function"
  -  FunctionImp *fimp = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
  -  ObjectImp *func(fimp); // protect from GC
  +  FunctionImp *func = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
   
     ObjectImp *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
     proto->put(exec, constructorPropertyName, func, ReadOnly|DontDelete|DontEnum);
  @@ -2307,7 +2234,7 @@
   
     int plen = 0;
     for(ParameterNode *p = param.get(); p != 0L; p = p->nextParam(), plen++)
  -    fimp->addParameter(p->ident());
  +    func->addParameter(p->ident());
   
     func->put(exec, lengthPropertyName, Number(plen), ReadOnly|DontDelete|DontEnum);
   
  @@ -2326,6 +2253,11 @@
     }
   }
   
  +Completion FuncDeclNode::execute(ExecState *)
  +{
  +    return Completion(Normal);
  +}
  +
   // ------------------------------ FuncExprNode ---------------------------------
   
   // ECMA 13
  @@ -2333,7 +2265,7 @@
   {
     ContextImp *context = exec->context().imp();
     bool named = !ident.isNull();
  -  ObjectImp *functionScopeObject = NULL;
  +  ObjectImp *functionScopeObject = 0;
   
     if (named) {
       // named FunctionExpressions can recursively call themselves,
  @@ -2343,22 +2275,21 @@
       context->pushScope(functionScopeObject);
     }
   
  -  FunctionImp *fimp = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
  -  ValueImp *ret(fimp);
  +  FunctionImp *func = new DeclaredFunctionImp(exec, ident, body.get(), context->scopeChain());
     ObjectImp *proto = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());
  -  proto->put(exec, constructorPropertyName, ret, ReadOnly|DontDelete|DontEnum);
  -  fimp->put(exec, prototypePropertyName, proto, Internal|DontDelete);
  +  proto->put(exec, constructorPropertyName, func, ReadOnly|DontDelete|DontEnum);
  +  func->put(exec, prototypePropertyName, proto, Internal|DontDelete);
   
     int plen = 0;
     for(ParameterNode *p = param.get(); p != 0L; p = p->nextParam(), plen++)
  -    fimp->addParameter(p->ident());
  +    func->addParameter(p->ident());
   
     if (named) {
  -    functionScopeObject->put(exec, ident, ret, Internal | ReadOnly | (context->codeType() == EvalCode ? 0 : DontDelete));
  +    functionScopeObject->put(exec, ident, func, Internal | ReadOnly | (context->codeType() == EvalCode ? 0 : DontDelete));
       context->popScope();
     }
   
  -  return ret;
  +  return func;
   }
   
   // ------------------------------ SourceElementsNode ---------------------------
  
  
  
  1.37      +29 -67    JavaScriptCore/kjs/nodes.h
  
  Index: nodes.h
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/kjs/nodes.h,v
  retrieving revision 1.36
  retrieving revision 1.37
  diff -u -r1.36 -r1.37
  --- nodes.h	27 Sep 2005 22:36:50 -0000	1.36
  +++ nodes.h	28 Sep 2005 18:51:14 -0000	1.37
  @@ -29,12 +29,6 @@
   #include <kxmlcore/SharedPtr.h>
   
   #include "internal.h"
  -//#include "debugger.h"
  -#ifndef NDEBUG
  -#ifndef __osf__
  -#include <list>
  -#endif
  -#endif
   
   namespace KJS {
   
  @@ -85,35 +79,42 @@
       virtual ValueImp *evaluate(ExecState *exec) = 0;
       UString toString() const;
       virtual void streamTo(SourceStream &s) const = 0;
  -    virtual void processVarDecls(ExecState */*exec*/) {}
  +    virtual void processVarDecls(ExecState *) {}
       int lineNo() const { return line; }
   
  -  public:
       // reference counting mechanism
       void ref() { ++m_refcount; }
       void deref() { --m_refcount; if (!m_refcount) delete this; }
       unsigned int refcount() { return m_refcount; }
   
  -    virtual bool isGroupNode() const { return false; }
  +    virtual Node *nodeInsideAllParens();
   
       virtual bool isLocation() const { return false; }
       virtual bool isResolveNode() const { return false; }
       virtual bool isBracketAccessorNode() const { return false; }
       virtual bool isDotAccessorNode() const { return false; }
  +    virtual bool isGroupNode() const { return false; }
   
     protected:
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg);
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *, Node *);
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg, const Identifier &);
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *, const Identifier &);
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *, Node *, Node *);
  -    ValueImp *throwError(ExecState *exec, ErrorType e, const char *msg, ValueImp *, Node *, const Identifier &);
  +    Completion createErrorCompletion(ExecState *, ErrorType, const char *msg);
  +    Completion createErrorCompletion(ExecState *, ErrorType, const char *msg, const Identifier &);
  +
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg);
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg, ValueImp *, Node *);
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg, const Identifier &);
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg, ValueImp *, const Identifier &);
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg, ValueImp *, Node *, Node *);
  +    ValueImp *throwError(ExecState *, ErrorType, const char *msg, ValueImp *, Node *, const Identifier &);
  +
  +    ValueImp *throwUndefinedVariableError(ExecState *, const Identifier &);
  +
  +    void setExceptionDetailsIfNeeded(ExecState *);
   
  -    void setExceptionDetailsIfNeeded(ExecState *exec);
       int line;
       UString sourceURL;
       unsigned int m_refcount;
       virtual int sourceId() const { return -1; }
  +
     private:
       // disallow assignment
       Node& operator=(const Node&);
  @@ -128,7 +129,6 @@
       int lastLine() const { return l1; }
       int sourceId() const { return sid; }
       bool hitStatement(ExecState *exec);
  -    bool abortStatement(ExecState *exec);
       virtual Completion execute(ExecState *exec) = 0;
       void pushLabel(const Identifier &id) { ls.push(id); }
       virtual void processFuncDecl(ExecState *exec);
  @@ -210,18 +210,9 @@
     public:
       GroupNode(Node *g) : group(g) { }
       virtual ValueImp *evaluate(ExecState *exec);
  +    virtual Node *nodeInsideAllParens();
       virtual void streamTo(SourceStream &s) const;
  -
       virtual bool isGroupNode() const { return true; }
  -    Node *nodeInsideAllParens()
  -    { 
  -        Node *n = group.get();
  -        while (n->isGroupNode()) {
  -            n = static_cast<GroupNode *>(n)->group.get();
  -        }
  -        return n;
  -    }
  -        
     private:
       SharedPtr<Node> group;
     };
  @@ -1000,43 +991,18 @@
       SharedPtr<Node> expr;
     };
   
  -  class CatchNode : public StatementNode {
  -  public:
  -    CatchNode(const Identifier &i, StatementNode *b) : ident(i), block(b) {}
  -    virtual Completion execute(ExecState *exec);
  -    Completion execute(ExecState *exec, ValueImp *arg);
  -    virtual void processVarDecls(ExecState *exec);
  -    virtual void streamTo(SourceStream &s) const;
  -  private:
  -    Identifier ident;
  -    SharedPtr<StatementNode> block;
  -  };
  -
  -  class FinallyNode : public StatementNode {
  -  public:
  -    FinallyNode(StatementNode *b) : block(b) {}
  -    virtual Completion execute(ExecState *exec);
  -    virtual void processVarDecls(ExecState *exec);
  -    virtual void streamTo(SourceStream &s) const;
  -  private:
  -    SharedPtr<StatementNode> block;
  -  };
  -
     class TryNode : public StatementNode {
     public:
  -    TryNode(StatementNode *b, CatchNode *c)
  -      : block(b), _catch(c), _final(0) {}
  -    TryNode(StatementNode *b, FinallyNode *f)
  -      : block(b), _catch(0), _final(f) {}
  -    TryNode(StatementNode *b, CatchNode *c, FinallyNode *f)
  -      : block(b), _catch(c), _final(f) {}
  +    TryNode(StatementNode *b, const Identifier &e, StatementNode *c, StatementNode *f)
  +      : tryBlock(b), exceptionIdent(e), catchBlock(c), finallyBlock(f) { }
       virtual Completion execute(ExecState *exec);
       virtual void processVarDecls(ExecState *exec);
       virtual void streamTo(SourceStream &s) const;
     private:
  -    SharedPtr<StatementNode> block;
  -    SharedPtr<CatchNode> _catch;
  -    SharedPtr<FinallyNode> _final;
  +    SharedPtr<StatementNode> tryBlock;
  +    Identifier exceptionIdent;
  +    SharedPtr<StatementNode> catchBlock;
  +    SharedPtr<StatementNode> finallyBlock;
     };
   
     class ParameterNode : public Node {
  @@ -1069,12 +1035,9 @@
         : ident(i), param(0), body(b) { }
       FuncExprNode(const Identifier &i, ParameterNode *p, FunctionBodyNode *b)
         : ident(i), param(p->next), body(b) { p->next = 0; }
  -    ValueImp *evaluate(ExecState *exec);
  -    virtual void streamTo(SourceStream &s) const;
  -
  +    virtual ValueImp *evaluate(ExecState *);
  +    virtual void streamTo(SourceStream &) const;
     private:
  -    friend class FuncDeclNode;
  -
       Identifier ident;
       SharedPtr<ParameterNode> param;
       SharedPtr<FunctionBodyNode> body;
  @@ -1086,10 +1049,9 @@
         : ident(i), param(0), body(b) { }
       FuncDeclNode(const Identifier &i, ParameterNode *p, FunctionBodyNode *b)
         : ident(i), param(p->next), body(b) { p->next = 0; }
  -    Completion execute(ExecState */*exec*/)
  -      { /* empty */ return Completion(); }
  -    void processFuncDecl(ExecState *exec);
  -    virtual void streamTo(SourceStream &s) const;
  +    virtual Completion execute(ExecState *);
  +    virtual void processFuncDecl(ExecState *);
  +    virtual void streamTo(SourceStream &) const;
     private:
       Identifier ident;
       SharedPtr<ParameterNode> param;
  
  
  
  1.19      +9 -23     JavaScriptCore/kjs/nodes2string.cpp
  
  Index: nodes2string.cpp
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/kjs/nodes2string.cpp,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- nodes2string.cpp	27 Sep 2005 22:36:50 -0000	1.18
  +++ nodes2string.cpp	28 Sep 2005 18:51:14 -0000	1.19
  @@ -1,4 +1,3 @@
  -// -*- c-basic-offset: 2 -*-
   /*
    *  This file is part of the KDE libraries
    *  Copyright (C) 2002 Harri Porten (porten at kde.org)
  @@ -664,21 +663,13 @@
     s << SourceStream::Endl << "throw " << expr << ";";
   }
   
  -void CatchNode::streamTo(SourceStream &s) const
  -{
  -  s << SourceStream::Endl << "catch (" << ident << ")" << block;
  -}
  -
  -void FinallyNode::streamTo(SourceStream &s) const
  -{
  -  s << SourceStream::Endl << "finally " << block;
  -}
  -
   void TryNode::streamTo(SourceStream &s) const
   {
  -  s << "try " << block
  -    << _catch
  -    << _final;
  +  s << "try " << tryBlock;
  +  if (catchBlock)
  +    s << SourceStream::Endl << "catch (" << exceptionIdent << ")" << catchBlock;
  +  if (finallyBlock)
  +    s << SourceStream::Endl << "finally " << finallyBlock;
   }
   
   void ParameterNode::streamTo(SourceStream &s) const
  @@ -688,18 +679,14 @@
       s << ", " << n->id;
   }
   
  -void FuncDeclNode::streamTo(SourceStream &s) const {
  -  s << "function " << ident << "(";
  -  if (param)
  -    s << param;
  -  s << ")" << body;
  +void FuncDeclNode::streamTo(SourceStream &s) const
  +{
  +  s << "function " << ident << "(" << param << ")" << body;
   }
   
   void FuncExprNode::streamTo(SourceStream &s) const
   {
  -  s << "function " << "("
  -    << param
  -    << ")" << body;
  +  s << "function " << ident << "(" << param << ")" << body;
   }
   
   void SourceElementsNode::streamTo(SourceStream &s) const
  @@ -707,4 +694,3 @@
     for (const SourceElementsNode *n = this; n; n = n->elements.get())
       s << n->element;
   }
  -
  
  
  
  1.45      +133 -303  JavaScriptCore/tests/mozilla/expected.html
  
  Index: expected.html
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/tests/mozilla/expected.html,v
  retrieving revision 1.44
  retrieving revision 1.45
  diff -u -r1.44 -r1.45
  --- expected.html	24 Sep 2005 22:34:15 -0000	1.44
  +++ expected.html	28 Sep 2005 18:51:15 -0000	1.45
  @@ -7,11 +7,11 @@
   <p class='results_summary'>
   Test List: All tests<br>
   Skip List: (none)<br>
  -1116 test(s) selected, 1111 test(s) completed, 94 failures reported (8.46% failed)<br>
  -Engine command line: /Users/mjs/Work/symroots/Development/testkjs <br>
  -OS type: Darwin maciej-stachowiaks-powerbook-g4-17.local 8.3.0 Darwin Kernel Version 8.3.0: Fri Sep 16 11:56:43 PDT 2005; root:xnu-792.6.17.obj~1/RELEASE_PPC Power Macintosh powerpc<br>
  -Testcase execution time: 5 minutes, 56 seconds.<br>
  -Tests completed on Thu Sep 22 23:37:42 2005.<br><br>
  +1116 test(s) selected, 1111 test(s) completed, 93 failures reported (8.37% failed)<br>
  +Engine command line: /Users/darin/symroots/Development/testkjs <br>
  +OS type: Darwin ap0101m-dhcp90.apple.com 8.3.0 Darwin Kernel Version 8.3.0: Fri Sep 16 11:56:43 PDT 2005; root:xnu-792.6.17.obj~1/RELEASE_PPC Power Macintosh powerpc<br>
  +Testcase execution time: 7 minutes, 54 seconds.<br>
  +Tests completed on Wed Sep 28 10:24:02 2005.<br><br>
   [ <a href='#fail_detail'>Failure Details</a> | <a href='#retest_list'>Retest List</a> | <a href='menu.html'>Test Selection Page</a> ]<br>
   <hr>
   <a name='fail_detail'></a>
  @@ -105,8 +105,8 @@
   --> (Mon Feb 28 2000 16:00:00 GMT-0800).toLocaleTimeString() = 4:00:00 PM PST FAILED! expected: 16:00:00<br>
   --> (Mon Feb 28 2000 15:59:59 GMT-0800).toLocaleTimeString() = 3:59:59 PM PST FAILED! expected: 15:59:59<br>
   --> (Tue Feb 29 2000 00:00:00 GMT-0800).toLocaleTimeString() = 12:00:00 AM PST FAILED! expected: 00:00:00<br>
  ---> (Thu Sep 22 2005 23:37:00 GMT-0700).toLocaleTimeString() = 11:37:00 PM PDT FAILED! expected: 23:37:00<br>
  ---> (Fri Sep 23 2005 07:37:00 GMT-0700).toLocaleTimeString() = 7:37:00 AM PDT FAILED! expected: 07:37:00<br>
  +--> (Wed Sep 28 2005 10:22:52 GMT-0700).toLocaleTimeString() = 10:22:52 AM PDT FAILED! expected: 10:22:52<br>
  +--> (Wed Sep 28 2005 18:22:52 GMT-0700).toLocaleTimeString() = 6:22:52 PM PDT FAILED! expected: 18:22:52<br>
   --> (Fri Dec 31 2004 16:00:00 GMT-0800).toLocaleTimeString() = 4:00:00 PM PST FAILED! expected: 16:00:00<br>
   --> (Fri Dec 31 2004 15:59:59 GMT-0800).toLocaleTimeString() = 3:59:59 PM PST FAILED! expected: 15:59:59<br>
   --> (Sat Jan 01 2005 00:00:00 GMT-0800).toLocaleTimeString() = 12:00:00 AM PST FAILED! expected: 00:00:00<br>
  @@ -116,8 +116,7 @@
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
  ---> STATUS: Function Expression Statements basic test.<br>
  -Exception, line 35: ReferenceError: Can't find variable: f<br>
  +Exception, line 26: SyntaxError: Parse error<br>
   </tt><br>
   <a name='failure10'></a><dd><b>Testcase <a target='other_window' href='./ecma_3/Function/regress-58274.js'>ecma_3/Function/regress-58274.js</a> failed</b> <br>
    [ <a href='#failure9'>Previous Failure</a> | <a href='#failure11'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  @@ -351,116 +350,116 @@
   Failure messages were:<br>
   --> FAILED!: Section 4 of test -<br>
   --> FAILED!: regexp = /[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: "]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: "]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
"]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
   --> FAILED!: -]*(?:(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)|"[^\\€-ÿ<br>
  ---> FAILED!: "]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: "]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)|"[^\\€-ÿ<br>
  +--> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
"]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
   --> FAILED!: -]*)*<[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*)*(?:,[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*)*)*:[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*)?(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: "]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: "]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*)*>|(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: "]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: "]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: \[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: ()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: ()]*)*\)[ 	]*)*)*)/g<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:@[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*)*(?:,[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*)*)*:[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*)?(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
"]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*)*>|(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
"]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  +--> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  +--> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  +--> FAILED!: 
()]*)*\)[ 	]*)*)*)/g<br>
   --> FAILED!: string = 'Jeffy<"That Tall Guy"@ora.com (this address is no longer acti\ve)>'<br>
   --> FAILED!: ERROR !!! regexp FAILED to match anything !!!<br>
   --> FAILED!: Expect: ["Jeffy<"That Tall Guy"@ora.com (this address is no longer active)>"]<br>
  @@ -672,166 +671,6 @@
   --> FAILED!: [reported from test()] Actual: ["1.000,00", "", ",00"]<br>
   --> FAILED!: [reported from test()] <br>
   </tt><br>
  -<a name='failure21'></a><dd><b>Testcase <a target='other_window' href='./ecma_3/RegExp/regress-72964.js'>ecma_3/RegExp/regress-72964.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=72964' target='other_window'>Bug Number 72964</a><br>
  - [ <a href='#failure20'>Previous Failure</a> | <a href='#failure22'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  -<tt>--> STATUS: Testing regular expressions containing non-Latin1 characters<br>
  -Failure messages were:<br>
  ---> FAILED!: [reported from test()] Section 3 of test -<br>
  ---> FAILED!: [reported from test()] regexp = /[\S]+/<br>
  ---> FAILED!: [reported from test()] string = '<br>
  ---> FAILED!: [reported from test()] ERROR !!! regexp FAILED to match anything !!!<br>
  ---> FAILED!: [reported from test()] Expect: ["<br>
  ---> FAILED!: [reported from test()] Actual: null<br>
  ---> FAILED!: [reported from test()] <br>
  ---> FAILED!: [reported from test()] Section 4 of test -<br>
  ---> FAILED!: [reported from test()] regexp = /[\S]+/<br>
  ---> FAILED!: [reported from test()] string = '<br>
  ---> FAILED!: [reported from test()] ERROR !!! regexp FAILED to match anything !!!<br>
  ---> FAILED!: [reported from test()] Expect: ["<br>
  ---> FAILED!: [reported from test()] Actual: null<br>
  ---> FAILED!: [reported from test()] <br>
  -</tt><br>
  -<a name='failure22'></a><dd><b>Testcase <a target='other_window' href='./ecma_3/RegExp/regress-78156.js'>ecma_3/RegExp/regress-78156.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=78156' target='other_window'>Bug Number 78156</a><br>
  - [ <a href='#failure21'>Previous Failure</a> | <a href='#failure23'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  -<tt>--> STATUS: Testing regular expressions with  ^, $, and the m flag -<br>
  -Failure messages were:<br>
  ---> FAILED!: [reported from test()] Section 2 of test -<br>
  ---> FAILED!: [reported from test()] regexp = /\d$/gm<br>
  ---> FAILED!: [reported from test()] string = 'aaa\n789\r\nccc\r\n345'<br>
  ---> FAILED!: [reported from test()] ERROR !!! match arrays have different lengths:<br>
  ---> FAILED!: [reported from test()] Expect: ["9", "5"]<br>
  ---> FAILED!: [reported from test()] Actual: ["5"]<br>
  ---> FAILED!: [reported from test()] <br>
  ---> FAILED!: [reported from test()] Section 4 of test -<br>
  ---> FAILED!: [reported from test()] regexp = /\d$/gm<br>
  ---> FAILED!: [reported from test()] string = 'aaa\n789\r\nccc\r\nddd'<br>
  ---> FAILED!: [reported from test()] ERROR !!! regexp FAILED to match anything !!!<br>
  ---> FAILED!: [reported from test()] Expect: ["9"]<br>
  ---> FAILED!: [reported from test()] Actual: null<br>
  ---> FAILED!: [reported from test()] <br>
  -</tt><br>
  -<a name='failure23'></a><dd><b>Testcase <a target='other_window' href='./ecma_3/RegExp/regress-85721.js'>ecma_3/RegExp/regress-85721.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=85721' target='other_window'>Bug Number 85721</a><br>
  - [ <a href='#failure22'>Previous Failure</a> | <a href='#failure24'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  -<tt>--> STATUS: Performance: execution of regular expression<br>
  -Failure messages were:<br>
  ---> FAILED!: Section 4 of test -<br>
  ---> FAILED!: regexp = /[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
"]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
  ---> FAILED!: -]*(?:(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)|"[^\\€-ÿ<br>
  ---> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
"]*)*")[^()<>@,;:".\\\[\]€-ÿ<br>
  ---> FAILED!: -]*)*<[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*)*(?:,[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*)*)*:[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*)?(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
"]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*)*>|(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
"]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
"]*)*")[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*@[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:.[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*(?:[^( <>@,;:".\\\[\]<br>
  ---> FAILED!: 
\[\]]|\\[^€-ÿ])*\])[ 	]*(?:\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:(?:\\[^€-ÿ]|\([^\\€-ÿ<br>
  ---> FAILED!: 
()]*(?:\\[^€-ÿ][^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\))[^\\€-ÿ<br>
  ---> FAILED!: 
()]*)*\)[ 	]*)*)*)/g<br>
  ---> FAILED!: string = 'Jeffy<"That Tall Guy"@ora.com (this address is no longer acti\ve)>'<br>
  ---> FAILED!: ERROR !!! regexp FAILED to match anything !!!<br>
  ---> FAILED!: Expect: ["Jeffy<"That Tall Guy"@ora.com (this address is no longer active)>"]<br>
  ---> FAILED!: Actual: null<br>
  ---> FAILED!: <br>
  -</tt><br>
   <a name='failure24'></a><dd><b>Testcase <a target='other_window' href='./ecma_3/Statements/regress-194364.js'>ecma_3/Statements/regress-194364.js</a> failed</b> <br>
    [ <a href='#failure23'>Previous Failure</a> | <a href='#failure25'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
  @@ -1364,37 +1203,29 @@
   Complete testcase output was:<br>
   Exception, line 351: SyntaxError: Parse error<br>
   </tt><br>
  -<a name='failure86'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-114491.js'>js1_5/Regress/regress-114491.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=114491' target='other_window'>Bug Number 114491</a><br>
  +<a name='failure86'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-127557.js'>js1_5/Regress/regress-127557.js</a> failed</b> <br>
    [ <a href='#failure85'>Previous Failure</a> | <a href='#failure87'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  -<tt>--> STATUS: Regression test for bug 114491<br>
  -Failure messages were:<br>
  ---> FAILED!: [reported from test()] Section 1 of test -<br>
  ---> FAILED!: [reported from test()] Expected value 'Program execution fell into into catch-block', Actual value 'Program execution did NOT fall into catch-block'<br>
  ---> FAILED!: [reported from test()] <br>
  -</tt><br>
  -<a name='failure87'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-127557.js'>js1_5/Regress/regress-127557.js</a> failed</b> <br>
  - [ <a href='#failure86'>Previous Failure</a> | <a href='#failure88'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
   Exception, line 76: ReferenceError: Can't find variable: clone<br>
   </tt><br>
  -<a name='failure88'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-156354.js'>js1_5/Regress/regress-156354.js</a> failed</b> <br>
  - [ <a href='#failure87'>Previous Failure</a> | <a href='#failure89'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure87'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-156354.js'>js1_5/Regress/regress-156354.js</a> failed</b> <br>
  + [ <a href='#failure86'>Previous Failure</a> | <a href='#failure88'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
   Exception, line 56: TypeError: Value undefined (result of expression this.propertyIsEnumerable) is not object.<br>
   </tt><br>
  -<a name='failure89'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-172699.js'>js1_5/Regress/regress-172699.js</a> failed</b> <br>
  - [ <a href='#failure88'>Previous Failure</a> | <a href='#failure90'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure88'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-172699.js'>js1_5/Regress/regress-172699.js</a> failed</b> <br>
  + [ <a href='#failure87'>Previous Failure</a> | <a href='#failure89'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
   Exception, line 62: URIError: URI error<br>
   </tt><br>
  -<a name='failure90'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-179524.js'>js1_5/Regress/regress-179524.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=179524' target='other_window'>Bug Number 179524</a><br>
  - [ <a href='#failure89'>Previous Failure</a> | <a href='#failure91'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure89'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-179524.js'>js1_5/Regress/regress-179524.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=179524' target='other_window'>Bug Number 179524</a><br>
  + [ <a href='#failure88'>Previous Failure</a> | <a href='#failure90'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>--> STATUS: Don't crash on extraneous arguments to str.match(), etc.<br>
   Failure messages were:<br>
   --> FAILED!: [reported from test()] Section 14 of test -<br>
  @@ -1444,16 +1275,16 @@
   --> FAILED!: [reported from test()] Expected value 'SHOULD HAVE FALLEN INTO CATCH-BLOCK!', Actual value 'ABC Zbc'<br>
   --> FAILED!: [reported from test()] <br>
   </tt><br>
  -<a name='failure91'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-185165.js'>js1_5/Regress/regress-185165.js</a> failed</b> <br>
  - [ <a href='#failure90'>Previous Failure</a> | <a href='#failure92'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure90'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Regress/regress-185165.js'>js1_5/Regress/regress-185165.js</a> failed</b> <br>
  + [ <a href='#failure89'>Previous Failure</a> | <a href='#failure91'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
   yylex: ERROR.<br>
   Exception, line 3: SyntaxError: Parse error<br>
   </tt><br>
  -<a name='failure92'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/regress-185485.js'>js1_5/Scope/regress-185485.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=185485' target='other_window'>Bug Number 185485</a><br>
  - [ <a href='#failure91'>Previous Failure</a> | <a href='#failure93'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure91'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/regress-185485.js'>js1_5/Scope/regress-185485.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=185485' target='other_window'>Bug Number 185485</a><br>
  + [ <a href='#failure90'>Previous Failure</a> | <a href='#failure92'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>--> STATUS: Testing |with (x) {function f() {}}| when |x.f| already exists<br>
   Failure messages were:<br>
   --> FAILED!: [reported from test()] Section 2 of test -<br>
  @@ -1468,15 +1299,15 @@
   --> FAILED!: [reported from test()] }', Actual value '0'<br>
   --> FAILED!: [reported from test()] <br>
   </tt><br>
  -<a name='failure93'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/regress-220584.js'>js1_5/Scope/regress-220584.js</a> failed</b> <br>
  - [ <a href='#failure92'>Previous Failure</a> | <a href='#failure94'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure92'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/regress-220584.js'>js1_5/Scope/regress-220584.js</a> failed</b> <br>
  + [ <a href='#failure91'>Previous Failure</a> | <a href='#failure93'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>Expected exit code 0, got 3<br>
   Testcase terminated with signal 0<br>
   Complete testcase output was:<br>
   Exception, line 57: ReferenceError: Can't find variable: Script<br>
   </tt><br>
  -<a name='failure94'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/scope-001.js'>js1_5/Scope/scope-001.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=53268' target='other_window'>Bug Number 53268</a><br>
  - [ <a href='#failure93'>Previous Failure</a> | <a href='#failure95'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
  +<a name='failure93'></a><dd><b>Testcase <a target='other_window' href='./js1_5/Scope/scope-001.js'>js1_5/Scope/scope-001.js</a> failed</b> <a href='http://bugzilla.mozilla.org/show_bug.cgi?id=53268' target='other_window'>Bug Number 53268</a><br>
  + [ <a href='#failure92'>Previous Failure</a> | <a href='#failure94'>Next Failure</a> | <a href='#tippy_top'>Top of Page</a> ]<br>
   <tt>--> STATUS: Testing scope after changing obj.__proto__<br>
   Failure messages were:<br>
   --> FAILED!: [reported from test()] Step 1:  setting obj.__proto__ = global object<br>
  @@ -1493,9 +1324,9 @@
   <pre>
   <a name='retest_list'></a>
   <h2>Retest List</h2><br>
  -# Retest List, kjs, generated Thu Sep 22 23:37:42 2005.
  +# Retest List, kjs, generated Wed Sep 28 10:24:02 2005.
   # Original test base was: All tests.
  -# 1111 of 1116 test(s) were completed, 94 failures reported.
  +# 1111 of 1116 test(s) were completed, 93 failures reported.
   ecma/Date/15.9.5.28-1.js
   ecma/GlobalObject/15.1.2.2-2.js
   ecma/LexicalConventions/7.7.3-1.js
  @@ -1581,7 +1412,6 @@
   js1_5/Regress/regress-68498-003.js
   js1_5/Regress/regress-103602.js
   js1_5/Regress/regress-104077.js
  -js1_5/Regress/regress-114491.js
   js1_5/Regress/regress-127557.js
   js1_5/Regress/regress-156354.js
   js1_5/Regress/regress-172699.js
  
  
  



More information about the webkit-changes mailing list