PageRenderTime 345ms CodeModel.GetById 151ms app.highlight 170ms RepoModel.GetById 12ms app.codeStats 1ms

/bundles/plugins-trunk/XML/sidekick/ecmascript/parser/EcmaScript.java

#
Java | 2234 lines | 1891 code | 63 blank | 280 comment | 254 complexity | 0ef31a8dd1234ab49f5b16b50109c04b MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/* Generated By:JJTree&JavaCC: Do not edit this line. EcmaScript.java */
   2package sidekick.ecmascript.parser;
   3
   4import java.io.*;
   5import java.util.*;
   6import java.util.regex.*;
   7import sidekick.util.*;
   8
   9public class EcmaScript/*@bgen(jjtree)*/implements EcmaScriptTreeConstants, EcmaScriptConstants {/*@bgen(jjtree)*/
  10  protected JJTEcmaScriptState jjtree = new JJTEcmaScriptState();
  11    private int lineOffset = 0;
  12    private List<ParseError> parseErrors = new ArrayList<ParseError>();
  13
  14    public static void main(String args[]){
  15        EcmaScript parser;
  16        if(args.length == 0){
  17            System.out.println("EcmaScript Parser:  Reading from standard input . . .");
  18            parser = new EcmaScript(System.in);
  19        } else if(args.length == 1){
  20            System.out.println("EcmaScript Parser:  Reading from file " + args[0] + " . . .");
  21            try {
  22                parser = new EcmaScript(new FileInputStream(args[0]), "UTF-8");
  23            } catch(java.io.FileNotFoundException e){
  24                System.out.println("EcmaScript Parser:  File " + args[0] + " not found.");
  25                return;
  26            }
  27        } else {
  28            System.out.println("EcmaScript Parser:  Usage is one of:");
  29            System.out.println("         EcmaScript < inputfile");
  30            System.out.println("OR");
  31            System.out.println("         EcmaScript inputfile");
  32            return;
  33        }
  34        try {
  35            SimpleNode n = parser.Program();
  36            System.out.println("EcmaScript parser:  EcmaScript program parsed successfully.");
  37        } catch (ParseException e) {
  38            System.out.println(e.getMessage());
  39            System.out.println("EcmaScript parser:  Encountered errors during parse.");
  40        }
  41    }
  42
  43    void jjtreeOpenNodeScope(Node n){
  44        Token t = getToken(1);
  45        if(t != null){
  46            ((SimpleNode) n).setBeginToken(t);
  47            ((SimpleNode) n).setStartLocation(getStartLocation(t));
  48        }
  49    }
  50
  51    void jjtreeCloseNodeScope(Node n){
  52        Token t = getToken(0);
  53        if(t != null){
  54            ((SimpleNode) n).setEndToken(t);
  55            ((SimpleNode) n).setEndLocation(getEndLocation(t));
  56        }
  57    }
  58
  59    public Location getStartLocation(Token t) {
  60       if (t == null)
  61           return new Location(0 + lineOffset, 0);
  62       return new Location(t.beginLine + lineOffset, t.beginColumn);
  63    }
  64
  65    public Location getEndLocation(Token t) {
  66       if (t == null)
  67           return new Location(0 + lineOffset, 0);
  68       return new Location(t.endLine + lineOffset, t.endColumn + 1);
  69    }
  70
  71    public void setLineOffset(int offset) {
  72        lineOffset = offset > 0 ? offset : 0;
  73    }
  74
  75    public void setTabSize(int size) {
  76        jj_input_stream.setTabSize(size);
  77    }
  78
  79    public int getTabSize() {
  80        return jj_input_stream.getTabSize(0);
  81    }
  82
  83    private void addException(ParseException pe) {
  84        // check for a jsp tag, these can appear in several places and will cause
  85        // a parse error, but they can be ignored.  It's easier to catch them and
  86        // ignore them than rewrite the grammar to allow them in all the appropriate
  87        // places.
  88        Token t = pe.currentToken;
  89        if (t != null) {
  90            if (t.next != null && t.next.image.startsWith("<%")) {
  91                return;
  92            }
  93        }
  94        Range range = getExceptionLocation( pe );
  95        parseErrors.add(new ParseError(pe.getMessage(), range));
  96    }
  97
  98    public List<ParseError> getParseErrors() {
  99       return parseErrors;
 100    }
 101
 102    /**
 103     * @return attempts to return a Location indicating the location of a parser
 104     * exception.  If the ParseException contains a Token reference, all is well,
 105     * otherwise, this method attempts to parse the message string for the
 106     * exception.
 107     */
 108    private Range getExceptionLocation( ParseException pe ) {
 109        Token t = pe.currentToken;
 110        if ( t != null ) {
 111            return new Range( new Location( t.next.beginLine + lineOffset, t.next.beginColumn ), new Location( t.next.endLine + lineOffset, t.next.endColumn ) );
 112        }
 113
 114        // ParseException message look like: "Parse error at line 116, column 5.  Encountered: }"
 115        try {
 116            Pattern p = Pattern.compile( "(.*?)(\\d+)(.*?)(\\d+)(.*?)" );
 117            Matcher m = p.matcher( pe.getMessage() );
 118            if ( m.matches() ) {
 119                String ln = m.group( 2 );
 120                String cn = m.group( 4 );
 121                int line_number = -1;
 122                int column_number = 0;
 123                if ( ln != null )
 124                    line_number = Integer.parseInt( ln );
 125                if ( cn != null )
 126                    column_number = Integer.parseInt( cn );
 127                return line_number > -1 ? new Range( new Location( line_number + lineOffset, column_number - 1 ), new Location( line_number + lineOffset, column_number ) ) : null;
 128            }
 129            return new Range();
 130        }
 131        catch ( Exception e ) {
 132            //e.printStackTrace();
 133            return new Range();
 134        }
 135    }
 136
 137/*
 138
 139<DEFAULT>
 140TOKEN:
 141{
 142    < REGULAR_EXPRESSION_LITERAL:
 143        "/" <REGULAR_EXPRESSION_BODY> "/" <REGULAR_EXPRESSION_FLAGS>
 144    > : IN_REGEX
 145|
 146    < #REGULAR_EXPRESSION_BODY: <REGULAR_EXPRESSION_FIRSTCHAR> <REGULAR_EXPRESSION_CHARS> >
 147|
 148    < #REGULAR_EXPRESSION_CHARS: (<REGULAR_EXPRESSION_CHAR>)* >
 149|
 150    < #REGULAR_EXPRESSION_FIRSTCHAR:
 151    // ~["*","\\","/"] <NON_TERMINATOR>
 152    <NON_TERMINATOR_FIRSTCHAR>
 153    | <BACKSLASH_SEQUENCE>
 154    >
 155|
 156    < #REGULAR_EXPRESSION_CHAR:
 157        //~["\\","/"] <NON_TERMINATOR> <NON_TERMINATOR_CHAR>
 158        | <BACKSLASH_SEQUENCE>
 159    >
 160|
 161    < #BACKSLASH_SEQUENCE: "\\" <NON_TERMINATOR> >
 162|
 163    < #NON_TERMINATOR_FIRSTCHAR: ~["\n","\r","?","?","*","\\","/"] >
 164|
 165    < #NON_TERMINATOR_CHAR: ~["\n","\r","?","?","\\","/"] >
 166|
 167    < #NON_TERMINATOR: ~["\n","\r","?","?"] >
 168|
 169    < #REGULAR_EXPRESSION_FLAGS: (<IDENTIFIER_PART>)* >
 170}
 171
 172*/
 173
 174
 175/*****************************************
 176 *	NUMERIC STRING GRAMMAR	STARTS HERE	 *
 177 *****************************************/
 178
 179/* Section 9.3: String-to-Number Conversion */
 180
 181/*
 182MORE:
 183{
 184    <STRING_NUMERIC_LITERAL: (<STR_WHITESPACE>)? (<STR_NUMERIC_LITERAL> (<STR_WHITESPACE>)?)? >
 185}
 186
 187MORE:
 188{
 189    < STR_WHITESPACE: (<STR_WHITESPACE_CHAR>)+ >
 190}
 191
 192MORE:
 193{
 194    < STR_WHITESPACE_CHAR:
 195        <TAB>
 196        | <SP>
 197        | <NBSP>
 198        | <FF>
 199        | <VT>
 200        | <CR>
 201        | <LF>
 202        | <LS>
 203        | <PS>
 204        | <USP>
 205    >
 206}
 207
 208
 209MORE:
 210{
 211    < STR_NUMERIC_LITERAL:
 212        <STR_DECIMAL_LITERAL> | <HEX_INTEGER_LITERAL>
 213    >
 214}
 215
 216MORE:
 217{
 218    <STR_DECIMAL_LITERAL: <STR_UNSIGNED_DECIMAL_LITERAL> ("+" | "-") <STR_UNSIGNED_DECIMAL_LITERAL>	>
 219}
 220
 221MORE:
 222{
 223    < STR_UNSIGNED_DECIMAL_LITERAL:
 224    "Infinity"
 225    | <DECIMAL_DIGITS> "." (<DECIMAL_DIGITS>)* (<EXPONENT_PART>)*
 226    >
 227}
 228
 229*/
 230
 231
 232/* A.6 Universal Resource Identifier Character Classes */
 233
 234
 235/*
 236
 237TOKEN:
 238{
 239    < URIRESERVED : [";" , "/" , "?" , ":" , "@" , "&" , "=" , "+" , "$" , ","] >
 240}
 241
 242TOKEN:
 243{
 244    < URI_ALPHA : ["a"-"z","A"-"Z"] >
 245}
 246
 247TOKEN:
 248{
 249    < URI_MARK : ["-" , "_" , "." , "!" , "~" , "*" , "'" , "(" , ")"] >
 250}
 251
 252void uri() :
 253{}
 254{
 255    (uriCharacters())?
 256}
 257
 258void uriCharacters() :
 259{}
 260{
 261    (uriCharacter())+
 262}
 263
 264void uriCharacter() :
 265{}
 266{
 267    <URIRESERVED>
 268    | uriUnescaped()
 269    | uriEscaped()
 270}
 271
 272void uriUnescaped() :
 273{}
 274{
 275    <URI_ALPHA>
 276    | <DECIMAL_DIGIT>
 277    | <URI_MARK>
 278}
 279
 280void uriEscaped() :
 281{}
 282{
 283    "%" <HEX_DIGIT> <HEX_DIGIT>
 284}
 285
 286*/
 287
 288/* A.7 Regular Expressions */
 289
 290/*
 291
 292MORE :
 293{
 294    "/^" : INSIDE_PATTERN
 295}
 296
 297<INSIDE_PATTERN, IN_PATTERN>
 298TOKEN:
 299{
 300    < PATTERN : <DISJUNCTION> > : DEFAULT
 301|
 302    < #DISJUNCTION : (<ALTERNATIVE>)+ >
 303|
 304    < #ALTERNATIVE : (<TERM>)* >
 305|
 306    < #TERM : <ASSERTION> | <ATOM> (<QUANTIFIER>)? >
 307|
 308    < #ASSERTION :
 309        "^"
 310        | "$"
 311        | "\\" ("b" | "B")
 312    >
 313|
 314    < #QUANTIFIER : <QUANTIFIERPREFIX> ("?")? >
 315|
 316    < #QUANTIFIERPREFIX : "*" | "+" | "?" | ( "{" <DECIMAL_DIGITS> ("," (<DECIMAL_DIGITS>)?)? "}" ) >
 317|
 318    < #ATOM :
 319        <PATTERN_CHARACTER>
 320        | "."
 321        | "\\" <ATOMESCAPE>
 322        | <CHARACTERCLASS>
 323        //| "(" ("?" (":" | "=" | "!"))?	 <DISJUNCTION> ")"
 324        | "(" ("?" (":" | "=" | "!"))?  ")"
 325    >
 326|
 327    < #PATTERN_CHARACTER : ~["^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", "|"] >
 328|
 329    < #ATOMESCAPE : <DECIMALESCAPE> | <CHARACTERESCAPE> | <CHARACTER_CLASS_ESCAPE> >
 330|
 331    < #CHARACTER_CLASS_ESCAPE : ["d", "D", "s", "S", "w", "W"] >
 332|
 333    < #CHARACTERESCAPE :
 334        <CONTROL_ESCAPE>
 335        | "c" <CONTROL_LETTER>
 336        | <HEX_ESCAPE_SEQUENCE>
 337        | <UNICODE_ESCAPE_SEQUENCE>
 338        | <IDENTITY_ESCAPE>
 339    >
 340|
 341    < #CONTROL_ESCAPE : ["f" , "n" , "r" , "t" , "v"] >
 342|
 343    < #CONTROL_LETTER : ["a"-"z","A"-"Z"] >
 344|
 345    < #IDENTITY_ESCAPE : ~["0"-"9", "A"-"Z", "a"-"z","-"] >
 346|
 347    < #DECIMALESCAPE : <DECIMAL_INTEGER_LITERAL> >
 348|
 349    < #CHARACTERCLASS : "[" ("^")? <CLASSRANGES> "]" >
 350|
 351    < #CLASSRANGES : (<NONEMPTYCLASSRANGES>)? >
 352|
 353    //< #NONEMPTYCLASSRANGES : <CLASSATOM> (<NONEMPTYCLASSRANGESNODASH> | "-" <CLASSATOM> <CLASSRANGES>) >
 354    < #NONEMPTYCLASSRANGES : <CLASSATOM> (<NONEMPTYCLASSRANGESNODASH> | "-" <CLASSATOM>) >
 355|
 356    //< #NONEMPTYCLASSRANGESNODASH : <CLASSATOM> | <CLASSATOMNODASH> ( <NONEMPTYCLASSRANGESNODASH> | "-" <CLASSATOM> <CLASSRANGES> ) >
 357    < #NONEMPTYCLASSRANGESNODASH : <CLASSATOM> | <CLASSATOMNODASH> ( <CLASSATOM> | "-" <CLASSATOM> ) >
 358|
 359    < #CLASSATOM : "-" <CLASSATOMNODASH> >
 360|
 361    < #CLASSATOMNODASH : <CLASS_ATOM_NODASH_TOKEN> | "\\" <CLASSESCAPE> >
 362|
 363    < #CLASS_ATOM_NODASH_TOKEN : ~["\\", "]", "-"] >
 364|
 365    < #CLASSESCAPE :
 366        <DECIMALESCAPE>
 367        | "b"
 368        | <CHARACTERESCAPE>
 369        | <CHARACTER_CLASS_ESCAPE>
 370    >
 371}
 372
 373*/
 374
 375/*****************************************
 376 * ECMA SYNTACTIC GRAMMARS  STARTS HERE  *
 377 *****************************************/
 378
 379    /* Section 11.1: Primary Expressions */
 380  final public void PrimaryExpression() throws ParseException {
 381    try {
 382      if (jj_2_1(2147483647)) {
 383                                ASTThisReference jjtn001 = new ASTThisReference(JJTTHISREFERENCE);
 384                                boolean jjtc001 = true;
 385                                jjtree.openNodeScope(jjtn001);
 386                                jjtreeOpenNodeScope(jjtn001);
 387        try {
 388          jj_consume_token(THIS);
 389        } finally {
 390                                if (jjtc001) {
 391                                  jjtree.closeNodeScope(jjtn001, true);
 392                                  jjtreeCloseNodeScope(jjtn001);
 393                                }
 394        }
 395      } else if (jj_2_2(2147483647)) {
 396        ObjectLiteral();
 397      } else if (jj_2_3(2147483647)) {
 398                           ASTParenExpression jjtn002 = new ASTParenExpression(JJTPARENEXPRESSION);
 399                           boolean jjtc002 = true;
 400                           jjtree.openNodeScope(jjtn002);
 401                           jjtreeOpenNodeScope(jjtn002);
 402        try {
 403          jj_consume_token(LPAREN);
 404          Expression();
 405          jj_consume_token(RPAREN);
 406        } catch (Throwable jjte002) {
 407                           if (jjtc002) {
 408                             jjtree.clearNodeScope(jjtn002);
 409                             jjtc002 = false;
 410                           } else {
 411                             jjtree.popNode();
 412                           }
 413                           if (jjte002 instanceof RuntimeException) {
 414                             {if (true) throw (RuntimeException)jjte002;}
 415                           }
 416                           if (jjte002 instanceof ParseException) {
 417                             {if (true) throw (ParseException)jjte002;}
 418                           }
 419                           {if (true) throw (Error)jjte002;}
 420        } finally {
 421                           if (jjtc002) {
 422                             jjtree.closeNodeScope(jjtn002, true);
 423                             jjtreeCloseNodeScope(jjtn002);
 424                           }
 425        }
 426      } else if (jj_2_4(2147483647)) {
 427        Identifier();
 428      } else if (jj_2_5(2147483647)) {
 429        ArrayLiteral();
 430      } else if (jj_2_6(2)) {
 431        Literal();
 432      } else {
 433        jj_consume_token(-1);
 434        throw new ParseException();
 435      }
 436    } catch (ParseException pe) {
 437            addException(pe);
 438    }
 439  }
 440
 441    /* Section 7.8: Literals */
 442  final public void Literal() throws ParseException {
 443     /*@bgen(jjtree) Literal */
 444      ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
 445      boolean jjtc000 = true;
 446      jjtree.openNodeScope(jjtn000);
 447      jjtreeOpenNodeScope(jjtn000);Token t;
 448      Map objLiteral;
 449      List arrayLiteral;
 450    try {
 451      try {
 452        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 453        case DECIMAL_LITERAL:
 454          t = jj_consume_token(DECIMAL_LITERAL);
 455          jjtree.closeNodeScope(jjtn000, true);
 456          jjtc000 = false;
 457          jjtreeCloseNodeScope(jjtn000);
 458            jjtn000.setDecimalValue(t.image);
 459          break;
 460        case HEX_INTEGER_LITERAL:
 461          t = jj_consume_token(HEX_INTEGER_LITERAL);
 462          jjtree.closeNodeScope(jjtn000, true);
 463          jjtc000 = false;
 464          jjtreeCloseNodeScope(jjtn000);
 465            jjtn000.setHexValue(t.image);
 466          break;
 467        case STRING_LITERAL:
 468          t = jj_consume_token(STRING_LITERAL);
 469          jjtree.closeNodeScope(jjtn000, true);
 470          jjtc000 = false;
 471          jjtreeCloseNodeScope(jjtn000);
 472            jjtn000.setStringValue(t.image);
 473          break;
 474        case BOOLEAN_LITERAL:
 475          t = jj_consume_token(BOOLEAN_LITERAL);
 476          jjtree.closeNodeScope(jjtn000, true);
 477          jjtc000 = false;
 478          jjtreeCloseNodeScope(jjtn000);
 479            jjtn000.setBooleanValue(t.image);
 480          break;
 481        case NULL_LITERAL:
 482          t = jj_consume_token(NULL_LITERAL);
 483          jjtree.closeNodeScope(jjtn000, true);
 484          jjtc000 = false;
 485          jjtreeCloseNodeScope(jjtn000);
 486            jjtn000.setNullValue();
 487          break;
 488        case REGULAR_EXPRESSION_LITERAL:
 489          t = jj_consume_token(REGULAR_EXPRESSION_LITERAL);
 490          jjtree.closeNodeScope(jjtn000, true);
 491          jjtc000 = false;
 492          jjtreeCloseNodeScope(jjtn000);
 493            jjtn000.setRegexValue(t.image);
 494          break;
 495        default:
 496          jj_la1[0] = jj_gen;
 497          jj_consume_token(-1);
 498          throw new ParseException();
 499        }
 500      } catch (ParseException pe) {
 501            addException(pe);
 502      }
 503    } finally {
 504      if (jjtc000) {
 505        jjtree.closeNodeScope(jjtn000, true);
 506        jjtreeCloseNodeScope(jjtn000);
 507      }
 508    }
 509  }
 510
 511  final public void Identifier() throws ParseException {
 512     /*@bgen(jjtree) Identifier */
 513      ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
 514      boolean jjtc000 = true;
 515      jjtree.openNodeScope(jjtn000);
 516      jjtreeOpenNodeScope(jjtn000);Token t;
 517    try {
 518      try {
 519        t = jj_consume_token(IDENTIFIER_NAME);
 520        jjtree.closeNodeScope(jjtn000, true);
 521        jjtc000 = false;
 522        jjtreeCloseNodeScope(jjtn000);
 523        jjtn000.setName(t.image);
 524      } catch (ParseException pe) {
 525            addException(pe);
 526      }
 527    } finally {
 528      if (jjtc000) {
 529        jjtree.closeNodeScope(jjtn000, true);
 530        jjtreeCloseNodeScope(jjtn000);
 531      }
 532    }
 533  }
 534
 535    /* Section 11.1.4: Array Initialiser */
 536  final public void ArrayLiteral() throws ParseException {
 537     /*@bgen(jjtree) ArrayLiteral */
 538  ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL);
 539  boolean jjtc000 = true;
 540  jjtree.openNodeScope(jjtn000);
 541  jjtreeOpenNodeScope(jjtn000);
 542    try {
 543      try {
 544        jj_consume_token(LBRACKET);
 545        if (jj_2_7(2)) {
 546          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 547          case COMMA:
 548            Elision();
 549            break;
 550          default:
 551            jj_la1[1] = jj_gen;
 552            ;
 553          }
 554          jj_consume_token(RBRACKET);
 555        } else if (jj_2_8(2147483647)) {
 556          ElementList();
 557          Elision();
 558          jj_consume_token(RBRACKET);
 559        } else {
 560          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 561          case DELETE:
 562          case FUNCTION:
 563          case NEW:
 564          case THIS:
 565          case TYPEOF:
 566          case VOID:
 567          case LBRACE:
 568          case LPAREN:
 569          case LBRACKET:
 570          case RBRACKET:
 571          case COMMA:
 572          case PLUS:
 573          case MINUS:
 574          case INCR:
 575          case DECR:
 576          case BANG:
 577          case TILDE:
 578          case DECIMAL_LITERAL:
 579          case HEX_INTEGER_LITERAL:
 580          case NULL_LITERAL:
 581          case BOOLEAN_LITERAL:
 582          case STRING_LITERAL:
 583          case IDENTIFIER_NAME:
 584          case REGULAR_EXPRESSION_LITERAL:
 585            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 586            case DELETE:
 587            case FUNCTION:
 588            case NEW:
 589            case THIS:
 590            case TYPEOF:
 591            case VOID:
 592            case LBRACE:
 593            case LPAREN:
 594            case LBRACKET:
 595            case COMMA:
 596            case PLUS:
 597            case MINUS:
 598            case INCR:
 599            case DECR:
 600            case BANG:
 601            case TILDE:
 602            case DECIMAL_LITERAL:
 603            case HEX_INTEGER_LITERAL:
 604            case NULL_LITERAL:
 605            case BOOLEAN_LITERAL:
 606            case STRING_LITERAL:
 607            case IDENTIFIER_NAME:
 608            case REGULAR_EXPRESSION_LITERAL:
 609              ElementList();
 610              break;
 611            default:
 612              jj_la1[2] = jj_gen;
 613              ;
 614            }
 615            jj_consume_token(RBRACKET);
 616            break;
 617          default:
 618            jj_la1[3] = jj_gen;
 619            jj_consume_token(-1);
 620            throw new ParseException();
 621          }
 622        }
 623      } catch (ParseException pe) {
 624            addException(pe);
 625      }
 626    } catch (Throwable jjte000) {
 627      if (jjtc000) {
 628        jjtree.clearNodeScope(jjtn000);
 629        jjtc000 = false;
 630      } else {
 631        jjtree.popNode();
 632      }
 633      if (jjte000 instanceof RuntimeException) {
 634        {if (true) throw (RuntimeException)jjte000;}
 635      }
 636      if (jjte000 instanceof ParseException) {
 637        {if (true) throw (ParseException)jjte000;}
 638      }
 639      {if (true) throw (Error)jjte000;}
 640    } finally {
 641      if (jjtc000) {
 642        jjtree.closeNodeScope(jjtn000, true);
 643        jjtreeCloseNodeScope(jjtn000);
 644      }
 645    }
 646  }
 647
 648  final public void ElementList() throws ParseException {
 649    try {
 650      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 651      case COMMA:
 652        Elision();
 653        break;
 654      default:
 655        jj_la1[4] = jj_gen;
 656        ;
 657      }
 658      AssignmentExpression();
 659      label_1:
 660      while (true) {
 661        if (jj_2_9(2147483647)) {
 662          ;
 663        } else {
 664          break label_1;
 665        }
 666        Elision();
 667        AssignmentExpression();
 668      }
 669    } catch (ParseException pe) {
 670            addException(pe);
 671    }
 672  }
 673
 674  final public void Elision() throws ParseException {
 675    try {
 676      label_2:
 677      while (true) {
 678        jj_consume_token(COMMA);
 679        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 680        case COMMA:
 681          ;
 682          break;
 683        default:
 684          jj_la1[5] = jj_gen;
 685          break label_2;
 686        }
 687      }
 688    } catch (ParseException pe) {
 689            addException(pe);
 690    }
 691  }
 692
 693    /* Section 11.1.5: Object Initialiser */
 694  final public void ObjectLiteral() throws ParseException {
 695     /*@bgen(jjtree) ObjectLiteral */
 696  ASTObjectLiteral jjtn000 = new ASTObjectLiteral(JJTOBJECTLITERAL);
 697  boolean jjtc000 = true;
 698  jjtree.openNodeScope(jjtn000);
 699  jjtreeOpenNodeScope(jjtn000);
 700    try {
 701      try {
 702        jj_consume_token(LBRACE);
 703        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 704        case DECIMAL_LITERAL:
 705        case STRING_LITERAL:
 706        case IDENTIFIER_NAME:
 707          PropertyNameAndValueList();
 708          break;
 709        default:
 710          jj_la1[6] = jj_gen;
 711          ;
 712        }
 713        jj_consume_token(RBRACE);
 714      } catch (ParseException pe) {
 715            addException(pe);
 716      }
 717    } catch (Throwable jjte000) {
 718      if (jjtc000) {
 719        jjtree.clearNodeScope(jjtn000);
 720        jjtc000 = false;
 721      } else {
 722        jjtree.popNode();
 723      }
 724      if (jjte000 instanceof RuntimeException) {
 725        {if (true) throw (RuntimeException)jjte000;}
 726      }
 727      if (jjte000 instanceof ParseException) {
 728        {if (true) throw (ParseException)jjte000;}
 729      }
 730      {if (true) throw (Error)jjte000;}
 731    } finally {
 732      if (jjtc000) {
 733        jjtree.closeNodeScope(jjtn000, true);
 734        jjtreeCloseNodeScope(jjtn000);
 735      }
 736    }
 737  }
 738
 739  final public void PropertyNameAndValueList() throws ParseException {
 740    try {
 741      PropertyNameAndValue();
 742      label_3:
 743      while (true) {
 744        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 745        case COMMA:
 746          ;
 747          break;
 748        default:
 749          jj_la1[7] = jj_gen;
 750          break label_3;
 751        }
 752        if (jj_2_10(2147483647)) {
 753          jj_consume_token(COMMA);
 754          PropertyNameAndValue();
 755        } else {
 756          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 757          case COMMA:
 758            jj_consume_token(COMMA);
 759            break;
 760          default:
 761            jj_la1[8] = jj_gen;
 762            jj_consume_token(-1);
 763            throw new ParseException();
 764          }
 765        }
 766      }
 767    } catch (ParseException pe) {
 768            addException(pe);
 769    }
 770  }
 771
 772  final public void PropertyNameAndValue() throws ParseException {
 773     /*@bgen(jjtree) LiteralField */
 774  ASTLiteralField jjtn000 = new ASTLiteralField(JJTLITERALFIELD);
 775  boolean jjtc000 = true;
 776  jjtree.openNodeScope(jjtn000);
 777  jjtreeOpenNodeScope(jjtn000);
 778    try {
 779      try {
 780        PropertyName();
 781        jj_consume_token(COLON);
 782        if (jj_2_11(2147483647)) {
 783          FunctionExpression();
 784        } else {
 785          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 786          case DELETE:
 787          case FUNCTION:
 788          case NEW:
 789          case THIS:
 790          case TYPEOF:
 791          case VOID:
 792          case LBRACE:
 793          case LPAREN:
 794          case LBRACKET:
 795          case PLUS:
 796          case MINUS:
 797          case INCR:
 798          case DECR:
 799          case BANG:
 800          case TILDE:
 801          case DECIMAL_LITERAL:
 802          case HEX_INTEGER_LITERAL:
 803          case NULL_LITERAL:
 804          case BOOLEAN_LITERAL:
 805          case STRING_LITERAL:
 806          case IDENTIFIER_NAME:
 807          case REGULAR_EXPRESSION_LITERAL:
 808            AssignmentExpression();
 809            break;
 810          default:
 811            jj_la1[9] = jj_gen;
 812            jj_consume_token(-1);
 813            throw new ParseException();
 814          }
 815        }
 816      } catch (ParseException pe) {
 817            addException(pe);
 818      }
 819    } catch (Throwable jjte000) {
 820          if (jjtc000) {
 821            jjtree.clearNodeScope(jjtn000);
 822            jjtc000 = false;
 823          } else {
 824            jjtree.popNode();
 825          }
 826          if (jjte000 instanceof RuntimeException) {
 827            {if (true) throw (RuntimeException)jjte000;}
 828          }
 829          if (jjte000 instanceof ParseException) {
 830            {if (true) throw (ParseException)jjte000;}
 831          }
 832          {if (true) throw (Error)jjte000;}
 833    } finally {
 834          if (jjtc000) {
 835            jjtree.closeNodeScope(jjtn000, true);
 836            jjtreeCloseNodeScope(jjtn000);
 837          }
 838    }
 839  }
 840
 841  final public void PropertyName() throws ParseException {
 842    try {
 843      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 844      case IDENTIFIER_NAME:
 845        Identifier();
 846        break;
 847      case STRING_LITERAL:
 848          ASTLiteral jjtn001 = new ASTLiteral(JJTLITERAL);
 849          boolean jjtc001 = true;
 850          jjtree.openNodeScope(jjtn001);
 851          jjtreeOpenNodeScope(jjtn001);
 852        try {
 853          jj_consume_token(STRING_LITERAL);
 854        } finally {
 855          if (jjtc001) {
 856            jjtree.closeNodeScope(jjtn001, true);
 857            jjtreeCloseNodeScope(jjtn001);
 858          }
 859        }
 860        break;
 861      case DECIMAL_LITERAL:
 862          ASTLiteral jjtn002 = new ASTLiteral(JJTLITERAL);
 863          boolean jjtc002 = true;
 864          jjtree.openNodeScope(jjtn002);
 865          jjtreeOpenNodeScope(jjtn002);
 866        try {
 867          jj_consume_token(DECIMAL_LITERAL);
 868        } finally {
 869          if (jjtc002) {
 870            jjtree.closeNodeScope(jjtn002, true);
 871            jjtreeCloseNodeScope(jjtn002);
 872          }
 873        }
 874        break;
 875      default:
 876        jj_la1[10] = jj_gen;
 877        jj_consume_token(-1);
 878        throw new ParseException();
 879      }
 880    } catch (ParseException pe) {
 881            addException(pe);
 882    }
 883  }
 884
 885    /* Section 11.2: Left-Hand-Side Expressions */
 886  final public void MemberExpression() throws ParseException {
 887    try {
 888      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 889      case FUNCTION:
 890      case THIS:
 891      case LBRACE:
 892      case LPAREN:
 893      case LBRACKET:
 894      case DECIMAL_LITERAL:
 895      case HEX_INTEGER_LITERAL:
 896      case NULL_LITERAL:
 897      case BOOLEAN_LITERAL:
 898      case STRING_LITERAL:
 899      case IDENTIFIER_NAME:
 900      case REGULAR_EXPRESSION_LITERAL:
 901              ASTCompositeReference jjtn001 = new ASTCompositeReference(JJTCOMPOSITEREFERENCE);
 902              boolean jjtc001 = true;
 903              jjtree.openNodeScope(jjtn001);
 904              jjtreeOpenNodeScope(jjtn001);
 905        try {
 906          if (jj_2_12(2147483647)) {
 907            FunctionExpression();
 908          } else {
 909            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 910            case THIS:
 911            case LBRACE:
 912            case LPAREN:
 913            case LBRACKET:
 914            case DECIMAL_LITERAL:
 915            case HEX_INTEGER_LITERAL:
 916            case NULL_LITERAL:
 917            case BOOLEAN_LITERAL:
 918            case STRING_LITERAL:
 919            case IDENTIFIER_NAME:
 920            case REGULAR_EXPRESSION_LITERAL:
 921              PrimaryExpression();
 922              break;
 923            default:
 924              jj_la1[11] = jj_gen;
 925              jj_consume_token(-1);
 926              throw new ParseException();
 927            }
 928          }
 929          label_4:
 930          while (true) {
 931            if (jj_2_13(2)) {
 932              ;
 933            } else {
 934              break label_4;
 935            }
 936            MemberExpressionPart();
 937          }
 938        } catch (Throwable jjte001) {
 939              if (jjtc001) {
 940                jjtree.clearNodeScope(jjtn001);
 941                jjtc001 = false;
 942              } else {
 943                jjtree.popNode();
 944              }
 945              if (jjte001 instanceof RuntimeException) {
 946                {if (true) throw (RuntimeException)jjte001;}
 947              }
 948              if (jjte001 instanceof ParseException) {
 949                {if (true) throw (ParseException)jjte001;}
 950              }
 951              {if (true) throw (Error)jjte001;}
 952        } finally {
 953              if (jjtc001) {
 954                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
 955                jjtreeCloseNodeScope(jjtn001);
 956              }
 957        }
 958        break;
 959      case NEW:
 960        AllocationExpression();
 961        break;
 962      default:
 963        jj_la1[12] = jj_gen;
 964        jj_consume_token(-1);
 965        throw new ParseException();
 966      }
 967    } catch (ParseException pe) {
 968            addException(pe);
 969    }
 970  }
 971
 972  final public void MemberExpressionForIn() throws ParseException {
 973    try {
 974              ASTCompositeReference jjtn001 = new ASTCompositeReference(JJTCOMPOSITEREFERENCE);
 975              boolean jjtc001 = true;
 976              jjtree.openNodeScope(jjtn001);
 977              jjtreeOpenNodeScope(jjtn001);
 978      try {
 979        if (jj_2_14(2147483647)) {
 980          FunctionExpression();
 981        } else {
 982          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 983          case THIS:
 984          case LBRACE:
 985          case LPAREN:
 986          case LBRACKET:
 987          case DECIMAL_LITERAL:
 988          case HEX_INTEGER_LITERAL:
 989          case NULL_LITERAL:
 990          case BOOLEAN_LITERAL:
 991          case STRING_LITERAL:
 992          case IDENTIFIER_NAME:
 993          case REGULAR_EXPRESSION_LITERAL:
 994            PrimaryExpression();
 995            break;
 996          default:
 997            jj_la1[13] = jj_gen;
 998            jj_consume_token(-1);
 999            throw new ParseException();
1000          }
1001        }
1002        label_5:
1003        while (true) {
1004          if (jj_2_15(2)) {
1005            ;
1006          } else {
1007            break label_5;
1008          }
1009          MemberExpressionPart();
1010        }
1011      } catch (Throwable jjte001) {
1012              if (jjtc001) {
1013                jjtree.clearNodeScope(jjtn001);
1014                jjtc001 = false;
1015              } else {
1016                jjtree.popNode();
1017              }
1018              if (jjte001 instanceof RuntimeException) {
1019                {if (true) throw (RuntimeException)jjte001;}
1020              }
1021              if (jjte001 instanceof ParseException) {
1022                {if (true) throw (ParseException)jjte001;}
1023              }
1024              {if (true) throw (Error)jjte001;}
1025      } finally {
1026              if (jjtc001) {
1027                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1028                jjtreeCloseNodeScope(jjtn001);
1029              }
1030      }
1031    } catch (ParseException pe) {
1032            addException(pe);
1033    }
1034  }
1035
1036  final public void AllocationExpression() throws ParseException {
1037     /*@bgen(jjtree) AllocationExpression */
1038  ASTAllocationExpression jjtn000 = new ASTAllocationExpression(JJTALLOCATIONEXPRESSION);
1039  boolean jjtc000 = true;
1040  jjtree.openNodeScope(jjtn000);
1041  jjtreeOpenNodeScope(jjtn000);
1042    try {
1043      try {
1044              ASTCompositeReference jjtn001 = new ASTCompositeReference(JJTCOMPOSITEREFERENCE);
1045              boolean jjtc001 = true;
1046              jjtree.openNodeScope(jjtn001);
1047              jjtreeOpenNodeScope(jjtn001);
1048        try {
1049          jj_consume_token(NEW);
1050          MemberExpression();
1051          label_6:
1052          while (true) {
1053            if (jj_2_16(2147483647)) {
1054              ;
1055            } else {
1056              break label_6;
1057            }
1058            Arguments();
1059            label_7:
1060            while (true) {
1061              if (jj_2_17(2)) {
1062                ;
1063              } else {
1064                break label_7;
1065              }
1066              MemberExpressionPart();
1067            }
1068          }
1069        } catch (Throwable jjte001) {
1070              if (jjtc001) {
1071                jjtree.clearNodeScope(jjtn001);
1072                jjtc001 = false;
1073              } else {
1074                jjtree.popNode();
1075              }
1076              if (jjte001 instanceof RuntimeException) {
1077                {if (true) throw (RuntimeException)jjte001;}
1078              }
1079              if (jjte001 instanceof ParseException) {
1080                {if (true) throw (ParseException)jjte001;}
1081              }
1082              {if (true) throw (Error)jjte001;}
1083        } finally {
1084              if (jjtc001) {
1085                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1086                jjtreeCloseNodeScope(jjtn001);
1087              }
1088        }
1089      } catch (ParseException pe) {
1090            addException(pe);
1091      }
1092    } catch (Throwable jjte000) {
1093      if (jjtc000) {
1094        jjtree.clearNodeScope(jjtn000);
1095        jjtc000 = false;
1096      } else {
1097        jjtree.popNode();
1098      }
1099      if (jjte000 instanceof RuntimeException) {
1100        {if (true) throw (RuntimeException)jjte000;}
1101      }
1102      if (jjte000 instanceof ParseException) {
1103        {if (true) throw (ParseException)jjte000;}
1104      }
1105      {if (true) throw (Error)jjte000;}
1106    } finally {
1107      if (jjtc000) {
1108        jjtree.closeNodeScope(jjtn000, true);
1109        jjtreeCloseNodeScope(jjtn000);
1110      }
1111    }
1112  }
1113
1114  final public void MemberExpressionPart() throws ParseException {
1115    try {
1116      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1117      case LBRACKET:
1118          ASTPropertyValueReference jjtn001 = new ASTPropertyValueReference(JJTPROPERTYVALUEREFERENCE);
1119          boolean jjtc001 = true;
1120          jjtree.openNodeScope(jjtn001);
1121          jjtreeOpenNodeScope(jjtn001);
1122        try {
1123          jj_consume_token(LBRACKET);
1124          Expression();
1125          jj_consume_token(RBRACKET);
1126        } catch (Throwable jjte001) {
1127          if (jjtc001) {
1128            jjtree.clearNodeScope(jjtn001);
1129            jjtc001 = false;
1130          } else {
1131            jjtree.popNode();
1132          }
1133          if (jjte001 instanceof RuntimeException) {
1134            {if (true) throw (RuntimeException)jjte001;}
1135          }
1136          if (jjte001 instanceof ParseException) {
1137            {if (true) throw (ParseException)jjte001;}
1138          }
1139          {if (true) throw (Error)jjte001;}
1140        } finally {
1141          if (jjtc001) {
1142            jjtree.closeNodeScope(jjtn001, true);
1143            jjtreeCloseNodeScope(jjtn001);
1144          }
1145        }
1146        break;
1147      case DOT:
1148                                                             ASTPropertyIdentifierReference jjtn002 = new ASTPropertyIdentifierReference(JJTPROPERTYIDENTIFIERREFERENCE);
1149                                                             boolean jjtc002 = true;
1150                                                             jjtree.openNodeScope(jjtn002);
1151                                                             jjtreeOpenNodeScope(jjtn002);
1152        try {
1153          jj_consume_token(DOT);
1154          Identifier();
1155        } catch (Throwable jjte002) {
1156                                                             if (jjtc002) {
1157                                                               jjtree.clearNodeScope(jjtn002);
1158                                                               jjtc002 = false;
1159                                                             } else {
1160                                                               jjtree.popNode();
1161                                                             }
1162                                                             if (jjte002 instanceof RuntimeException) {
1163                                                               {if (true) throw (RuntimeException)jjte002;}
1164                                                             }
1165                                                             if (jjte002 instanceof ParseException) {
1166                                                               {if (true) throw (ParseException)jjte002;}
1167                                                             }
1168                                                             {if (true) throw (Error)jjte002;}
1169        } finally {
1170                                                             if (jjtc002) {
1171                                                               jjtree.closeNodeScope(jjtn002, true);
1172                                                               jjtreeCloseNodeScope(jjtn002);
1173                                                             }
1174        }
1175        break;
1176      default:
1177        jj_la1[14] = jj_gen;
1178        jj_consume_token(-1);
1179        throw new ParseException();
1180      }
1181    } catch (ParseException pe) {
1182        addException(pe);
1183    }
1184  }
1185
1186  final public void CallExpression() throws ParseException {
1187     /*@bgen(jjtree) #CompositeReference(> 1) */
1188  ASTCompositeReference jjtn000 = new ASTCompositeReference(JJTCOMPOSITEREFERENCE);
1189  boolean jjtc000 = true;
1190  jjtree.openNodeScope(jjtn000);
1191  jjtreeOpenNodeScope(jjtn000);
1192    try {
1193      try {
1194        MemberExpression();
1195        Arguments();
1196        label_8:
1197        while (true) {
1198          if (jj_2_18(2)) {
1199            ;
1200          } else {
1201            break label_8;
1202          }
1203          CallExpressionPart();
1204        }
1205      } catch (ParseException pe) {
1206            addException(pe);
1207      }
1208    } catch (Throwable jjte000) {
1209      if (jjtc000) {
1210        jjtree.clearNodeScope(jjtn000);
1211        jjtc000 = false;
1212      } else {
1213        jjtree.popNode();
1214      }
1215      if (jjte000 instanceof RuntimeException) {
1216        {if (true) throw (RuntimeException)jjte000;}
1217      }
1218      if (jjte000 instanceof ParseException) {
1219        {if (true) throw (ParseException)jjte000;}
1220      }
1221      {if (true) throw (Error)jjte000;}
1222    } finally {
1223      if (jjtc000) {
1224        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1225        jjtreeCloseNodeScope(jjtn000);
1226      }
1227    }
1228  }
1229
1230  final public void CallExpressionForIn() throws ParseException {
1231     /*@bgen(jjtree) #CompositeReference(> 1) */
1232  ASTCompositeReference jjtn000 = new ASTCompositeReference(JJTCOMPOSITEREFERENCE);
1233  boolean jjtc000 = true;
1234  jjtree.openNodeScope(jjtn000);
1235  jjtreeOpenNodeScope(jjtn000);
1236    try {
1237      try {
1238        MemberExpressionForIn();
1239        Arguments();
1240        label_9:
1241        while (true) {
1242          if (jj_2_19(2)) {
1243            ;
1244          } else {
1245            break label_9;
1246          }
1247          CallExpressionPart();
1248        }
1249      } catch (ParseException pe) {
1250            addException(pe);
1251      }
1252    } catch (Throwable jjte000) {
1253      if (jjtc000) {
1254        jjtree.clearNodeScope(jjtn000);
1255        jjtc000 = false;
1256      } else {
1257        jjtree.popNode();
1258      }
1259      if (jjte000 instanceof RuntimeException) {
1260        {if (true) throw (RuntimeException)jjte000;}
1261      }
1262      if (jjte000 instanceof ParseException) {
1263        {if (true) throw (ParseException)jjte000;}
1264      }
1265      {if (true) throw (Error)jjte000;}
1266    } finally {
1267      if (jjtc000) {
1268        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1269        jjtreeCloseNodeScope(jjtn000);
1270      }
1271    }
1272  }
1273
1274  final public void CallExpressionPart() throws ParseException {
1275    try {
1276      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1277      case LPAREN:
1278        Arguments();
1279        break;
1280      case LBRACKET:
1281                            ASTPropertyValueReference jjtn001 = new ASTPropertyValueReference(JJTPROPERTYVALUEREFERENCE);
1282                            boolean jjtc001 = true;
1283                            jjtree.openNodeScope(jjtn001);
1284                            jjtreeOpenNodeScope(jjtn001);
1285        try {
1286          jj_consume_token(LBRACKET);
1287          Expression();
1288          jj_consume_token(RBRACKET);
1289        } catch (Throwable jjte001) {
1290                            if (jjtc001) {
1291                              jjtree.clearNodeScope(jjtn001);
1292                              jjtc001 = false;
1293                            } else {
1294                              jjtree.popNode();
1295                            }
1296                            if (jjte001 instanceof RuntimeException) {
1297                              {if (true) throw (RuntimeException)jjte001;}
1298                            }
1299                            if (jjte001 instanceof ParseException) {
1300                              {if (true) throw (ParseException)jjte001;}
1301                            }
1302                            {if (true) throw (Error)jjte001;}
1303        } finally {
1304                            if (jjtc001) {
1305                              jjtree.closeNodeScope(jjtn001, true);
1306                              jjtreeCloseNodeScope(jjtn001);
1307                            }
1308        }
1309        break;
1310      case DOT:
1311                                                                               ASTPropertyIdentifierReference jjtn002 = new ASTPropertyIdentifierReference(JJTPROPERTYIDENTIFIERREFERENCE);
1312                                                                               boolean jjtc002 = true;
1313                                                                               jjtree.openNodeScope(jjtn002);
1314                                                                               jjtreeOpenNodeScope(jjtn002);
1315        try {
1316          jj_consume_token(DOT);
1317          Identifier();
1318        } catch (Throwable jjte002) {
1319                                                                               if (jjtc002) {
1320                                                                                 jjtree.clearNodeScope(jjtn002);
1321                                                                                 jjtc002 = false;
1322                                                                               } else {
1323                                                                                 jjtree.popNode();
1324                                                                               }
1325                                                                               if (jjte002 instanceof RuntimeException) {
1326                                                                                 {if (true) throw (RuntimeException)jjte002;}
1327                                                                               }
1328                                                                               if (jjte002 instanceof ParseException) {
1329                                                                                 {if (true) throw (ParseException)jjte002;}
1330                                                                               }
1331                                                                               {if (true) throw (Error)jjte002;}
1332        } finally {
1333                                                                               if (jjtc002) {
1334                                                                                 jjtree.closeNodeScope(jjtn002, true);
1335                                                                                 jjtreeCloseNodeScope(jjtn002);
1336                                                                               }
1337        }
1338        break;
1339      default:
1340        jj_la1[15] = jj_gen;
1341        jj_consume_token(-1);
1342        throw new ParseException();
1343      }
1344    } catch (ParseException pe) {
1345            addException(pe);
1346    }
1347  }
1348
1349  final public void Arguments() throws ParseException {
1350     /*@bgen(jjtree) FunctionCallParameters */
1351  ASTFunctionCallParameters jjtn000 = new ASTFunctionCallParameters(JJTFUNCTIONCALLPARAMETERS);
1352  boolean jjtc000 = true;
1353  jjtree.openNodeScope(jjtn000);
1354  jjtreeOpenNodeScope(jjtn000);
1355    try {
1356      try {
1357        jj_consume_token(LPAREN);
1358        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1359        case DELETE:
1360        case FUNCTION:
1361        case NEW:
1362        case THIS:
1363        case TYPEOF:
1364        case VOID:
1365        case LBRACE:
1366        case LPAREN:
1367        case LBRACKET:
1368        case PLUS:
1369        case MINUS:
1370        case INCR:
1371        case DECR:
1372        case BANG:
1373        case TILDE:
1374        case DECIMAL_LITERAL:
1375        case HEX_INTEGER_LITERAL:
1376        case NULL_LITERAL:
1377        case BOOLEAN_LITERAL:
1378        case STRING_LITERAL:
1379        case IDENTIFIER_NAME:
1380        case REGULAR_EXPRESSION_LITERAL:
1381          ArgumentList();
1382          break;
1383        default:
1384          jj_la1[16] = jj_gen;
1385          ;
1386        }
1387        jj_consume_token(RPAREN);
1388      } catch (ParseException pe) {
1389            addException(pe);
1390      }
1391    } catch (Throwable jjte000) {
1392      if (jjtc000) {
1393        jjtree.clearNodeScope(jjtn000);
1394        jjtc000 = false;
1395      } else {
1396        jjtree.popNode();
1397      }
1398      if (jjte000 instanceof RuntimeException) {
1399        {if (true) throw (RuntimeException)jjte000;}
1400      }
1401      if (jjte000 instanceof ParseException) {
1402        {if (true) throw (ParseException)jjte000;}
1403      }
1404      {if (true) throw (Error)jjte000;}
1405    } finally {
1406      if (jjtc000) {
1407        jjtree.closeNodeScope(jjtn000, true);
1408        jjtreeCloseNodeScope(jjtn000);
1409      }
1410    }
1411  }
1412
1413  final public void ArgumentList() throws ParseException {
1414    try {
1415      AssignmentExpression();
1416      label_10:
1417      while (true) {
1418        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1419        case COMMA:
1420          ;
1421          break;
1422        default:
1423          jj_la1[17] = jj_gen;
1424          break label_10;
1425        }
1426        jj_consume_token(COMMA);
1427        AssignmentExpression();
1428      }
1429    } catch (ParseException pe) {
1430            addException(pe);
1431    }
1432  }
1433
1434  final public void LeftHandSideExpression() throws ParseException {
1435    try {
1436      if (jj_2_20(2147483647)) {
1437        CallExpression();
1438      } else {
1439        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1440        case FUNCTION:
1441        case NEW:
1442        case THIS:
1443        case LBRACE:
1444        case LPAREN:
1445        case LBRACKET:
1446        case DECIMAL_LITERAL:
1447        case HEX_INTEGER_LITERAL:
1448        case NULL_LITERAL:
1449        case BOOLEAN_LITERAL:
1450        case STRING_LITERAL:
1451        case IDENTIFIER_NAME:
1452        case REGULAR_EXPRESSION_LITERAL:
1453          MemberExpression();
1454          break;
1455        default:
1456          jj_la1[18] = jj_gen;
1457          jj_consume_token(-1);
1458          throw new ParseException();
1459        }
1460      }
1461    } catch (ParseException pe) {
1462            addException(pe);
1463    }
1464  }
1465
1466  final public void LeftHandSideExpressionForIn() throws ParseException {
1467    try {
1468      if (jj_2_21(2147483647)) {
1469        CallExpressionForIn();
1470      } else {
1471        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1472        case FUNCTION:
1473        case THIS:
1474        case LBRACE:
1475        case LPAREN:
1476        case LBRACKET:
1477        case DECIMAL_LITERAL:
1478        case HEX_INTEGER_LITERAL:
1479        case NULL_LITERAL:
1480        case BOOLEAN_LITERAL:
1481        case STRING_LITERAL:
1482        case IDENTIFIER_NAME:
1483        case REGULAR_EXPRESSION_LITERAL:
1484          MemberExpressionForIn();
1485          break;
1486        default:
1487          jj_la1[19] = jj_gen;
1488          jj_consume_token(-1);
1489          throw new ParseException();
1490        }
1491      }
1492    } catch (ParseException pe) {
1493            addException(pe);
1494    }
1495  }
1496
1497    /* Section 11.3 Postfix Expressions */
1498  final public void PostfixExpression() throws ParseException {
1499     /*@bgen(jjtree) #PostfixExpression(> 1) */
1500  ASTPostfixExpression jjtn000 = new ASTPostfixExpression(JJTPOSTFIXEXPRESSION);
1501  boolean jjtc000 = true;
1502  jjtree.openNodeScope(jjtn000);
1503  jjtreeOpenNodeScope(jjtn000);
1504    try {
1505      try {
1506        LeftHandSideExpression();
1507        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1508        case INCR:
1509        case DECR:
1510          PostfixOperator();
1511          break;
1512        default:
1513          jj_la1[20] = jj_gen;
1514          ;
1515        }
1516      } catch (ParseException pe) {
1517            addException(pe);
1518      }
1519    } catch (Throwable jjte000) {
1520      if (jjtc000) {
1521        jjtree.clearNodeScope(jjtn000);
1522        jjtc000 = false;
1523      } else {
1524        jjtree.popNode();
1525      }
1526      if (jjte000 instanceof RuntimeException) {
1527        {if (true) throw (RuntimeException)jjte000;}
1528      }
1529      if (jjte000 instanceof ParseException) {
1530        {if (true) throw (ParseException)jjte000;}
1531      }
1532      {if (true) throw (Error)jjte000;}
1533    } finally {
1534      if (jjtc000) {
1535        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1536        jjtreeCloseNodeScope(jjtn000);
1537      }
1538    }
1539  }
1540
1541  final public void PostfixOperator() throws ParseException {
1542     /*@bgen(jjtree) Operator */
1543  ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
1544  boolean jjtc000 = true;
1545  jjtree.openNodeScope(jjtn000);
1546  jjtreeOpenNodeScope(jjtn000);
1547    try {
1548      try {
1549        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1550        case INCR:
1551          jj_consume_token(INCR);
1552          break;
1553        case DECR:
1554          jj_consume_token(DECR);
1555          break;
1556        default:
1557          jj_la1[21] = jj_gen;
1558          jj_consume_token(-1);
1559          throw new ParseException();
1560        }
1561      } catch (ParseException pe) {
1562            addException(pe);
1563      }
1564    } finally {
1565      if (jjtc000) {
1566        jjtree.closeNodeScope(jjtn000, true);
1567        jjtreeCloseNodeScope(jjtn000);
1568      }
1569    }
1570  }
1571
1572    /* Section 11.4 Unary Operators */
1573  final public void UnaryExpression() throws ParseException {
1574     /*@bgen(jjtree) #UnaryExpression(> 1) */
1575  ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION);
1576  boolean jjtc000 = true;
1577  jjtree.openNodeScope(jjtn000);
1578  jjtreeOpenNodeScope(jjtn000);
1579    try {
1580      try {
1581        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1582        case FUNCTION:
1583        case NEW:
1584        case THIS:
1585        case LBRACE:
1586        case LPAREN:
1587        case LBRACKET:
1588        case DECIMAL_LITERAL:
1589        case HEX_INTEGER_LITERAL:
1590        case NULL_LITERAL:
1591        case BOOLEAN_LITERAL:
1592        case STRING_LITERAL:
1593        case IDENTIFIER_NAME:
1594        case REGULAR_EXPRESSION_LITERAL:
1595          PostfixExpression();
1596          break;
1597        case DELETE:
1598        case TYPEOF:
1599        case VOID:
1600        case PLUS:
1601        case MINUS:
1602        case INCR:
1603        case DECR:
1604        case BANG:
1605        case TILDE:
1606          label_11:
1607          while (true) {
1608            UnaryOperator();
1609            UnaryExpression();
1610            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1611            case DELETE:
1612            case TYPEOF:
1613            case VOID:
1614            case PLUS:
1615            case MINUS:
1616            case INCR:
1617            case DECR:
1618            case BANG:
1619            case TILDE:
1620              ;
1621              break;
1622            default:
1623              jj_la1[22] = jj_gen;
1624              break label_11;
1625            }
1626          }
1627          break;
1628        default:
1629          jj_la1[23] = jj_gen;
1630          jj_consume_token(-1);
1631          throw new ParseException();
1632        }
1633      } catch (ParseException pe) {
1634            addException(pe);
1635      }
1636    } catch (Throwable jjte000) {
1637      if (jjtc000) {
1638        jjtree.clearNodeScope(jjtn000);
1639        jjtc000 = false;
1640      } else {
1641        jjtree.popNode();
1642      }
1643      if (jjte000 instanceof RuntimeException) {
1644        {if (true) throw (RuntimeException)jjte000;}
1645      }
1646      if (jjte000 instanceof ParseException) {
1647        {if (true) throw (ParseException)jjte000;}
1648      }
1649      {if (true) throw (Error)jjte000;}
1650    } finally {
1651      if (jjtc000) {
1652        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1653        jjtreeCloseNodeScope(jjtn000);
1654      }
1655    }
1656  }
1657
1658  final public void UnaryOperator() throws ParseException {
1659     /*@bgen(jjtree) Operato

Large files files are truncated, but you can click here to view the full file