PageRenderTime 142ms CodeModel.GetById 72ms app.highlight 59ms RepoModel.GetById 1ms app.codeStats 0ms

/jEdit/tags/jedit-4-2-pre4/bsh/Parser.java

#
Java | 2298 lines | 2096 code | 62 blank | 140 comment | 265 complexity | 5bf1ebd4005fc0aade8cb6d68d86bf40 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. Parser.java */
   2package bsh;
   3
   4import java.io.*;
   5import java.util.Vector;
   6
   7/**
   8	This is the BeanShell parser.  It is used internally by the Interpreter
   9	class (which is probably what you are looking for).  The parser knows
  10	only how to parse the structure of the language, it does not understand
  11	names, commands, etc.
  12	<p>
  13	You can use the Parser from the command line to do basic structural 
  14	validation of BeanShell files without actually executing them. e.g.
  15	<code><pre>
  16		java bsh.Parser [ -p ] file [ file ] [ ... ]
  17	</pre></code>
  18	<p>
  19	The -p option causes the abstract syntax to be printed.
  20	<p>
  21
  22	From code you'd use the Parser like this:
  23	<p
  24	<code><pre>
  25		Parser parser = new Parser(in);
  26		while( !(eof=parser.Line()) ) {
  27			SimpleNode node = parser.popNode();
  28			// use the node, etc. (See bsh.BSH* classes)
  29		}
  30	</pre></code>
  31*/
  32public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
  33  protected JJTParserState jjtree = new JJTParserState();boolean retainComments = false;
  34
  35        public void setRetainComments( boolean b ) {
  36                retainComments = b;
  37        }
  38
  39        void jjtreeOpenNodeScope(Node n) {
  40                ((SimpleNode)n).firstToken = getToken(1);
  41        }
  42
  43        void jjtreeCloseNodeScope(Node n) {
  44                ((SimpleNode)n).lastToken = getToken(0);
  45        }
  46
  47        /**
  48		Re-initialize the input stream and token source.
  49	*/
  50        void reInitInput( Reader in ) {
  51                ReInit(in);
  52        }
  53
  54        public SimpleNode popNode()
  55        {
  56                if ( jjtree.nodeArity() > 0)  // number of child nodes 
  57                        return (SimpleNode)jjtree.popNode();
  58                else
  59                        return null;
  60        }
  61
  62        /**
  63		Explicitly re-initialize just the token reader.
  64		This seems to be necessary to avoid certain looping errors when
  65		reading bogus input.  See Interpreter.
  66	*/
  67        void reInitTokenInput( Reader in ) {
  68                jj_input_stream.ReInit( in,
  69                        jj_input_stream.getEndLine(),
  70                        jj_input_stream.getEndColumn() );
  71        }
  72
  73        public static void main( String [] args )
  74                throws IOException, ParseException
  75        {
  76                boolean print = false;
  77                int i=0;
  78                if ( args[0].equals("-p") ) {
  79                        i++;
  80                        print=true;
  81                }
  82                for(; i< args.length; i++) {
  83                        Reader in = new FileReader(args[i]);
  84                        Parser parser = new Parser(in);
  85                        parser.setRetainComments(true);
  86                        while( !parser.Line()/*eof*/ )
  87                                if ( print )
  88                                        System.out.println( parser.popNode() );
  89                }
  90        }
  91
  92        /**
  93		Lookahead for the enhanced for statement.  
  94		Expect "for" "(" and then see whether we hit ":" or a ";" first.
  95	*/
  96        boolean isRegularForStatement()
  97        {
  98                int curTok = 1;
  99                Token tok;
 100                tok = getToken(curTok++);
 101                if ( tok.kind != FOR ) return false;
 102                tok = getToken(curTok++);
 103                if ( tok.kind != LPAREN ) return false;
 104                while (true)
 105                {
 106                        tok = getToken(curTok++);
 107                        switch (tok.kind) {
 108                                case COLON:
 109                                        return false;
 110                                case SEMICOLON:
 111                                        return true;
 112                                case EOF:
 113                                        return false;
 114                        }
 115                }
 116        }
 117
 118        /**
 119		Lookahead to determine whether a method has a return type.
 120
 121		// Case 1 - primitive or void
 122		[ void, boolean, char, ... ] foo() { }
 123		byte [] foo() { }
 124
 125		// Case 2 - simple type name
 126		Foo foo () { } 
 127		Foo [] foo () { } 
 128
 129		// Case 3 - compound type name
 130		foo.Foo foo () { }
 131		foo.Foo [] foo () { }
 132
 133		// Case 4 - Parameterized return type?
 134		// ??
 135
 136		// Case N - no type
 137		foo () { }
 138	*/
 139        /*
 140		Note: it's important not to read ahead tokens (e.g. tok2) unless 
 141		previous ones match.  We're used in lookaheads and if we have to wait
 142		for tokens that couldn't match it messes up interactivity on the
 143		command line.
 144	*/
 145        boolean methodHasReturnType()
 146        {
 147                Token tok1 = getToken(1), tok2=null;
 148
 149                // Case 1
 150                if ( tok1.kind == VOID || tok1.kind == BOOLEAN || tok1.kind == CHAR
 151                        || tok1.kind == BYTE || tok1.kind == SHORT || tok1.kind == INT
 152                        || tok1.kind == LONG || tok1.kind == FLOAT || tok1.kind == DOUBLE
 153                )
 154                                return true;
 155
 156                // Case 2
 157                if ( tok1.kind == IDENTIFIER && (tok2=getToken(2)).kind == LBRACKET )
 158                        return true;
 159                if ( tok1.kind == IDENTIFIER && tok2.kind == IDENTIFIER
 160                        && getToken(3).kind == LPAREN )
 161                        return true;
 162
 163                // Case 3
 164                if ( tok1.kind == IDENTIFIER && tok2.kind == DOT )
 165                        return true;
 166
 167                // Case N
 168                return false;
 169        }
 170
 171        /**
 172		Generate a ParseException with the specified message, pointing to the
 173		current token.
 174		The auto-generated Parser.generateParseException() method does not
 175		provide line number info, therefore we do this.
 176	*/
 177        ParseException createParseException( String message )
 178        {
 179                Token errortok = token;
 180                int line = errortok.beginLine, column = errortok.beginColumn;
 181                String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
 182                return new ParseException( "Parse error at line " + line
 183                        + ", column " + column + " : " + message );
 184        }
 185
 186/*
 187	Thanks to Sreenivasa Viswanadha for suggesting how to get rid of expensive
 188	lookahead here.
 189*/
 190  final public boolean Line() throws ParseException {
 191    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 192    case 0:
 193      jj_consume_token(0);
 194        Interpreter.debug("End of File!");
 195        {if (true) return true;}
 196      break;
 197    default:
 198      if (jj_2_1(1)) {
 199        BlockStatement();
 200        {if (true) return false;}
 201      } else {
 202        jj_consume_token(-1);
 203        throw new ParseException();
 204      }
 205    }
 206    throw new Error("Missing return statement in function");
 207  }
 208
 209/*****************************************
 210 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
 211 *****************************************/
 212
 213/*
 214	Gather modifiers for a class, method, or field.
 215	I lookahead is true then we are being called as part of a lookahead and we
 216	should not enforce any rules.  Otherwise we validate based on context
 217	(field, method, class)
 218*/
 219  final public Modifiers Modifiers(int context, boolean lookahead) throws ParseException {
 220        Modifiers mods = null;
 221    label_1:
 222    while (true) {
 223      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 224      case ABSTRACT:
 225      case FINAL:
 226      case NATIVE:
 227      case PRIVATE:
 228      case PROTECTED:
 229      case PUBLIC:
 230      case STATIC:
 231      case STRICTFP:
 232      case SYNCHRONIZED:
 233      case TRANSIENT:
 234      case VOLATILE:
 235        ;
 236        break;
 237      default:
 238        break label_1;
 239      }
 240      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 241      case PRIVATE:
 242        jj_consume_token(PRIVATE);
 243        break;
 244      case PROTECTED:
 245        jj_consume_token(PROTECTED);
 246        break;
 247      case PUBLIC:
 248        jj_consume_token(PUBLIC);
 249        break;
 250      case SYNCHRONIZED:
 251        jj_consume_token(SYNCHRONIZED);
 252        break;
 253      case FINAL:
 254        jj_consume_token(FINAL);
 255        break;
 256      case NATIVE:
 257        jj_consume_token(NATIVE);
 258        break;
 259      case TRANSIENT:
 260        jj_consume_token(TRANSIENT);
 261        break;
 262      case VOLATILE:
 263        jj_consume_token(VOLATILE);
 264        break;
 265      case ABSTRACT:
 266        jj_consume_token(ABSTRACT);
 267        break;
 268      case STATIC:
 269        jj_consume_token(STATIC);
 270        break;
 271      case STRICTFP:
 272        jj_consume_token(STRICTFP);
 273        break;
 274      default:
 275        jj_consume_token(-1);
 276        throw new ParseException();
 277      }
 278                if ( !lookahead )
 279                        try {
 280                                if ( mods == null ) mods = new Modifiers();
 281                                mods.addModifier( context, getToken(0).image );
 282                        } catch ( IllegalStateException e ) {
 283                                {if (true) throw createParseException( e.getMessage() );}
 284                        }
 285    }
 286        {if (true) return mods;}
 287    throw new Error("Missing return statement in function");
 288  }
 289
 290/**
 291*/
 292  final public void ClassDeclaration() throws ParseException {
 293 /*@bgen(jjtree) ClassDeclaration */
 294        BSHClassDeclaration jjtn000 = new BSHClassDeclaration(JJTCLASSDECLARATION);
 295        boolean jjtc000 = true;
 296        jjtree.openNodeScope(jjtn000);
 297        jjtreeOpenNodeScope(jjtn000);Modifiers mods;
 298        Token t;
 299        int numInterfaces;
 300    try {
 301      mods = Modifiers(Modifiers.CLASS, false);
 302      jj_consume_token(CLASS);
 303      t = jj_consume_token(IDENTIFIER);
 304      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 305      case EXTENDS:
 306        jj_consume_token(EXTENDS);
 307        AmbiguousName();
 308                                              jjtn000.extend = true;
 309        break;
 310      default:
 311        ;
 312      }
 313      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 314      case IMPLEMENTS:
 315        jj_consume_token(IMPLEMENTS);
 316        numInterfaces = NameList();
 317                          jjtn000.numInterfaces=numInterfaces;
 318        break;
 319      default:
 320        ;
 321      }
 322      Block();
 323                          jjtree.closeNodeScope(jjtn000, true);
 324                          jjtc000 = false;
 325                          jjtreeCloseNodeScope(jjtn000);
 326                        jjtn000.modifiers = mods;
 327                        jjtn000.name = t.image;
 328    } catch (Throwable jjte000) {
 329          if (jjtc000) {
 330            jjtree.clearNodeScope(jjtn000);
 331            jjtc000 = false;
 332          } else {
 333            jjtree.popNode();
 334          }
 335          if (jjte000 instanceof RuntimeException) {
 336            {if (true) throw (RuntimeException)jjte000;}
 337          }
 338          if (jjte000 instanceof ParseException) {
 339            {if (true) throw (ParseException)jjte000;}
 340          }
 341          {if (true) throw (Error)jjte000;}
 342    } finally {
 343          if (jjtc000) {
 344            jjtree.closeNodeScope(jjtn000, true);
 345            jjtreeCloseNodeScope(jjtn000);
 346          }
 347    }
 348  }
 349
 350  final public void MethodDeclaration() throws ParseException {
 351 /*@bgen(jjtree) MethodDeclaration */
 352        BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(JJTMETHODDECLARATION);
 353        boolean jjtc000 = true;
 354        jjtree.openNodeScope(jjtn000);
 355        jjtreeOpenNodeScope(jjtn000);Token t = null;
 356        Modifiers mods;
 357        int count;
 358    try {
 359      mods = Modifiers(Modifiers.METHOD, false);
 360                                                      jjtn000.modifiers = mods;
 361      if (methodHasReturnType()) {
 362        ReturnType();
 363      } else {
 364        ;
 365      }
 366      t = jj_consume_token(IDENTIFIER);
 367                           jjtn000.name = t.image;
 368      FormalParameters();
 369      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 370      case THROWS:
 371        jj_consume_token(THROWS);
 372        count = NameList();
 373                                      jjtn000.numThrows=count;
 374        break;
 375      default:
 376        ;
 377      }
 378      Block();
 379    } catch (Throwable jjte000) {
 380          if (jjtc000) {
 381            jjtree.clearNodeScope(jjtn000);
 382            jjtc000 = false;
 383          } else {
 384            jjtree.popNode();
 385          }
 386          if (jjte000 instanceof RuntimeException) {
 387            {if (true) throw (RuntimeException)jjte000;}
 388          }
 389          if (jjte000 instanceof ParseException) {
 390            {if (true) throw (ParseException)jjte000;}
 391          }
 392          {if (true) throw (Error)jjte000;}
 393    } finally {
 394          if (jjtc000) {
 395            jjtree.closeNodeScope(jjtn000, true);
 396            jjtreeCloseNodeScope(jjtn000);
 397          }
 398    }
 399  }
 400
 401/**
 402	It's tempting to collapse this to one like like so:
 403
 404      [ LOOKAHEAD( { methodHasReturnType() } ) ReturnType() ]
 405      <IDENTIFIER> FormalParameters() "{"
 406
 407	However this doesn't work because nested lookaheads are not evaluated
 408	during lookahead!
 409	http://www.engr.mun.ca/~theo/JavaCC-FAQ/javacc-faq.htm#tth_sEc4.9
 410*/
 411  final public void MethodDeclarationLookahead() throws ParseException {
 412    Modifiers(Modifiers.METHOD, true);
 413    if (methodHasReturnType()) {
 414      ReturnType();
 415      jj_consume_token(IDENTIFIER);
 416      FormalParameters();
 417      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 418      case THROWS:
 419        jj_consume_token(THROWS);
 420        NameList();
 421        break;
 422      default:
 423        ;
 424      }
 425      jj_consume_token(LBRACE);
 426    } else {
 427      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 428      case IDENTIFIER:
 429        jj_consume_token(IDENTIFIER);
 430        FormalParameters();
 431        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 432        case THROWS:
 433          jj_consume_token(THROWS);
 434          NameList();
 435          break;
 436        default:
 437          ;
 438        }
 439        jj_consume_token(LBRACE);
 440        break;
 441      default:
 442        jj_consume_token(-1);
 443        throw new ParseException();
 444      }
 445    }
 446  }
 447
 448  final public void ImportDeclaration() throws ParseException {
 449 /*@bgen(jjtree) ImportDeclaration */
 450    BSHImportDeclaration jjtn000 = new BSHImportDeclaration(JJTIMPORTDECLARATION);
 451    boolean jjtc000 = true;
 452    jjtree.openNodeScope(jjtn000);
 453    jjtreeOpenNodeScope(jjtn000);Token t = null;
 454    try {
 455      if (jj_2_2(2)) {
 456        jj_consume_token(IMPORT);
 457        AmbiguousName();
 458        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 459        case DOT:
 460          t = jj_consume_token(DOT);
 461          jj_consume_token(STAR);
 462          break;
 463        default:
 464          ;
 465        }
 466        jj_consume_token(SEMICOLON);
 467                                                 jjtree.closeNodeScope(jjtn000, true);
 468                                                 jjtc000 = false;
 469                                                 jjtreeCloseNodeScope(jjtn000);
 470    if ( t != null )
 471        jjtn000.importPackage = true;
 472      } else {
 473        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 474        case IMPORT:
 475          jj_consume_token(IMPORT);
 476          jj_consume_token(STAR);
 477          jj_consume_token(SEMICOLON);
 478                     jjtree.closeNodeScope(jjtn000, true);
 479                     jjtc000 = false;
 480                     jjtreeCloseNodeScope(jjtn000);
 481                jjtn000.superImport = true;
 482          break;
 483        default:
 484          jj_consume_token(-1);
 485          throw new ParseException();
 486        }
 487      }
 488    } catch (Throwable jjte000) {
 489    if (jjtc000) {
 490      jjtree.clearNodeScope(jjtn000);
 491      jjtc000 = false;
 492    } else {
 493      jjtree.popNode();
 494    }
 495    if (jjte000 instanceof RuntimeException) {
 496      {if (true) throw (RuntimeException)jjte000;}
 497    }
 498    if (jjte000 instanceof ParseException) {
 499      {if (true) throw (ParseException)jjte000;}
 500    }
 501    {if (true) throw (Error)jjte000;}
 502    } finally {
 503    if (jjtc000) {
 504      jjtree.closeNodeScope(jjtn000, true);
 505      jjtreeCloseNodeScope(jjtn000);
 506    }
 507    }
 508  }
 509
 510  final public void VariableDeclarator() throws ParseException {
 511 /*@bgen(jjtree) VariableDeclarator */
 512        BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(JJTVARIABLEDECLARATOR);
 513        boolean jjtc000 = true;
 514        jjtree.openNodeScope(jjtn000);
 515        jjtreeOpenNodeScope(jjtn000);Token t;
 516        Modifiers mods;
 517    try {
 518      t = jj_consume_token(IDENTIFIER);
 519      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 520      case ASSIGN:
 521        jj_consume_token(ASSIGN);
 522        VariableInitializer();
 523        break;
 524      default:
 525        ;
 526      }
 527          jjtree.closeNodeScope(jjtn000, true);
 528          jjtc000 = false;
 529          jjtreeCloseNodeScope(jjtn000);
 530                jjtn000.name = t.image;
 531    } catch (Throwable jjte000) {
 532          if (jjtc000) {
 533            jjtree.clearNodeScope(jjtn000);
 534            jjtc000 = false;
 535          } else {
 536            jjtree.popNode();
 537          }
 538          if (jjte000 instanceof RuntimeException) {
 539            {if (true) throw (RuntimeException)jjte000;}
 540          }
 541          if (jjte000 instanceof ParseException) {
 542            {if (true) throw (ParseException)jjte000;}
 543          }
 544          {if (true) throw (Error)jjte000;}
 545    } finally {
 546          if (jjtc000) {
 547            jjtree.closeNodeScope(jjtn000, true);
 548            jjtreeCloseNodeScope(jjtn000);
 549          }
 550    }
 551  }
 552
 553/*
 554Can get rid of this if we ignore postfix array dimensions in declarations.
 555I don't like them and I don't want to deal with them right now.
 556
 557void VariableDeclaratorId() #VariableDeclaratorId :
 558{ Token t; }
 559{
 560  t=<IDENTIFIER> { jjtThis.name = t.image; }
 561  ( "[" "]" { jjtThis.addUndefinedDimension(); } )*
 562}
 563*/
 564  final public void VariableInitializer() throws ParseException {
 565    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 566    case LBRACE:
 567      ArrayInitializer();
 568      break;
 569    case BOOLEAN:
 570    case BYTE:
 571    case CHAR:
 572    case DOUBLE:
 573    case FALSE:
 574    case FLOAT:
 575    case INT:
 576    case LONG:
 577    case NEW:
 578    case NULL:
 579    case SHORT:
 580    case TRUE:
 581    case VOID:
 582    case INTEGER_LITERAL:
 583    case FLOATING_POINT_LITERAL:
 584    case CHARACTER_LITERAL:
 585    case STRING_LITERAL:
 586    case IDENTIFIER:
 587    case LPAREN:
 588    case BANG:
 589    case TILDE:
 590    case INCR:
 591    case DECR:
 592    case PLUS:
 593    case MINUS:
 594      Expression();
 595      break;
 596    default:
 597      jj_consume_token(-1);
 598      throw new ParseException();
 599    }
 600  }
 601
 602  final public void ArrayInitializer() throws ParseException {
 603 /*@bgen(jjtree) ArrayInitializer */
 604  BSHArrayInitializer jjtn000 = new BSHArrayInitializer(JJTARRAYINITIALIZER);
 605  boolean jjtc000 = true;
 606  jjtree.openNodeScope(jjtn000);
 607  jjtreeOpenNodeScope(jjtn000);
 608    try {
 609      jj_consume_token(LBRACE);
 610      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 611      case BOOLEAN:
 612      case BYTE:
 613      case CHAR:
 614      case DOUBLE:
 615      case FALSE:
 616      case FLOAT:
 617      case INT:
 618      case LONG:
 619      case NEW:
 620      case NULL:
 621      case SHORT:
 622      case TRUE:
 623      case VOID:
 624      case INTEGER_LITERAL:
 625      case FLOATING_POINT_LITERAL:
 626      case CHARACTER_LITERAL:
 627      case STRING_LITERAL:
 628      case IDENTIFIER:
 629      case LPAREN:
 630      case LBRACE:
 631      case BANG:
 632      case TILDE:
 633      case INCR:
 634      case DECR:
 635      case PLUS:
 636      case MINUS:
 637        VariableInitializer();
 638        label_2:
 639        while (true) {
 640          if (jj_2_3(2)) {
 641            ;
 642          } else {
 643            break label_2;
 644          }
 645          jj_consume_token(COMMA);
 646          VariableInitializer();
 647        }
 648        break;
 649      default:
 650        ;
 651      }
 652      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 653      case COMMA:
 654        jj_consume_token(COMMA);
 655        break;
 656      default:
 657        ;
 658      }
 659      jj_consume_token(RBRACE);
 660    } catch (Throwable jjte000) {
 661    if (jjtc000) {
 662      jjtree.clearNodeScope(jjtn000);
 663      jjtc000 = false;
 664    } else {
 665      jjtree.popNode();
 666    }
 667    if (jjte000 instanceof RuntimeException) {
 668      {if (true) throw (RuntimeException)jjte000;}
 669    }
 670    if (jjte000 instanceof ParseException) {
 671      {if (true) throw (ParseException)jjte000;}
 672    }
 673    {if (true) throw (Error)jjte000;}
 674    } finally {
 675    if (jjtc000) {
 676      jjtree.closeNodeScope(jjtn000, true);
 677      jjtreeCloseNodeScope(jjtn000);
 678    }
 679    }
 680  }
 681
 682  final public void FormalParameters() throws ParseException {
 683 /*@bgen(jjtree) FormalParameters */
 684  BSHFormalParameters jjtn000 = new BSHFormalParameters(JJTFORMALPARAMETERS);
 685  boolean jjtc000 = true;
 686  jjtree.openNodeScope(jjtn000);
 687  jjtreeOpenNodeScope(jjtn000);
 688    try {
 689      jj_consume_token(LPAREN);
 690      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 691      case BOOLEAN:
 692      case BYTE:
 693      case CHAR:
 694      case DOUBLE:
 695      case FLOAT:
 696      case INT:
 697      case LONG:
 698      case SHORT:
 699      case IDENTIFIER:
 700        FormalParameter();
 701        label_3:
 702        while (true) {
 703          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 704          case COMMA:
 705            ;
 706            break;
 707          default:
 708            break label_3;
 709          }
 710          jj_consume_token(COMMA);
 711          FormalParameter();
 712        }
 713        break;
 714      default:
 715        ;
 716      }
 717      jj_consume_token(RPAREN);
 718    } catch (Throwable jjte000) {
 719    if (jjtc000) {
 720      jjtree.clearNodeScope(jjtn000);
 721      jjtc000 = false;
 722    } else {
 723      jjtree.popNode();
 724    }
 725    if (jjte000 instanceof RuntimeException) {
 726      {if (true) throw (RuntimeException)jjte000;}
 727    }
 728    if (jjte000 instanceof ParseException) {
 729      {if (true) throw (ParseException)jjte000;}
 730    }
 731    {if (true) throw (Error)jjte000;}
 732    } finally {
 733    if (jjtc000) {
 734      jjtree.closeNodeScope(jjtn000, true);
 735      jjtreeCloseNodeScope(jjtn000);
 736    }
 737    }
 738  }
 739
 740  final public void FormalParameter() throws ParseException {
 741 /*@bgen(jjtree) FormalParameter */
 742  BSHFormalParameter jjtn000 = new BSHFormalParameter(JJTFORMALPARAMETER);
 743  boolean jjtc000 = true;
 744  jjtree.openNodeScope(jjtn000);
 745  jjtreeOpenNodeScope(jjtn000);Token t;
 746    try {
 747      if (jj_2_4(2)) {
 748        Type();
 749        t = jj_consume_token(IDENTIFIER);
 750                                       jjtree.closeNodeScope(jjtn000, true);
 751                                       jjtc000 = false;
 752                                       jjtreeCloseNodeScope(jjtn000);
 753                                       jjtn000.name = t.image;
 754      } else {
 755        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 756        case IDENTIFIER:
 757          t = jj_consume_token(IDENTIFIER);
 758                   jjtree.closeNodeScope(jjtn000, true);
 759                   jjtc000 = false;
 760                   jjtreeCloseNodeScope(jjtn000);
 761                   jjtn000.name = t.image;
 762          break;
 763        default:
 764          jj_consume_token(-1);
 765          throw new ParseException();
 766        }
 767      }
 768    } catch (Throwable jjte000) {
 769    if (jjtc000) {
 770      jjtree.clearNodeScope(jjtn000);
 771      jjtc000 = false;
 772    } else {
 773      jjtree.popNode();
 774    }
 775    if (jjte000 instanceof RuntimeException) {
 776      {if (true) throw (RuntimeException)jjte000;}
 777    }
 778    if (jjte000 instanceof ParseException) {
 779      {if (true) throw (ParseException)jjte000;}
 780    }
 781    {if (true) throw (Error)jjte000;}
 782    } finally {
 783    if (jjtc000) {
 784      jjtree.closeNodeScope(jjtn000, true);
 785      jjtreeCloseNodeScope(jjtn000);
 786    }
 787    }
 788  }
 789
 790/*
 791	Type, name and expression syntax follows.
 792*/
 793  final public void Type() throws ParseException {
 794 /*@bgen(jjtree) Type */
 795  BSHType jjtn000 = new BSHType(JJTTYPE);
 796  boolean jjtc000 = true;
 797  jjtree.openNodeScope(jjtn000);
 798  jjtreeOpenNodeScope(jjtn000);
 799    try {
 800      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 801      case BOOLEAN:
 802      case BYTE:
 803      case CHAR:
 804      case DOUBLE:
 805      case FLOAT:
 806      case INT:
 807      case LONG:
 808      case SHORT:
 809        PrimitiveType();
 810        break;
 811      case IDENTIFIER:
 812        AmbiguousName();
 813        break;
 814      default:
 815        jj_consume_token(-1);
 816        throw new ParseException();
 817      }
 818      label_4:
 819      while (true) {
 820        if (jj_2_5(2)) {
 821          ;
 822        } else {
 823          break label_4;
 824        }
 825        jj_consume_token(LBRACKET);
 826        jj_consume_token(RBRACKET);
 827                                 jjtn000.addArrayDimension();
 828      }
 829    } catch (Throwable jjte000) {
 830    if (jjtc000) {
 831      jjtree.clearNodeScope(jjtn000);
 832      jjtc000 = false;
 833    } else {
 834      jjtree.popNode();
 835    }
 836    if (jjte000 instanceof RuntimeException) {
 837      {if (true) throw (RuntimeException)jjte000;}
 838    }
 839    if (jjte000 instanceof ParseException) {
 840      {if (true) throw (ParseException)jjte000;}
 841    }
 842    {if (true) throw (Error)jjte000;}
 843    } finally {
 844    if (jjtc000) {
 845      jjtree.closeNodeScope(jjtn000, true);
 846      jjtreeCloseNodeScope(jjtn000);
 847    }
 848    }
 849  }
 850
 851/*
 852	Originally called ResultType in the grammar
 853*/
 854  final public void ReturnType() throws ParseException {
 855 /*@bgen(jjtree) ReturnType */
 856  BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
 857  boolean jjtc000 = true;
 858  jjtree.openNodeScope(jjtn000);
 859  jjtreeOpenNodeScope(jjtn000);
 860    try {
 861      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 862      case VOID:
 863        jj_consume_token(VOID);
 864           jjtree.closeNodeScope(jjtn000, true);
 865           jjtc000 = false;
 866           jjtreeCloseNodeScope(jjtn000);
 867           jjtn000.isVoid = true;
 868        break;
 869      case BOOLEAN:
 870      case BYTE:
 871      case CHAR:
 872      case DOUBLE:
 873      case FLOAT:
 874      case INT:
 875      case LONG:
 876      case SHORT:
 877      case IDENTIFIER:
 878        Type();
 879        break;
 880      default:
 881        jj_consume_token(-1);
 882        throw new ParseException();
 883      }
 884    } catch (Throwable jjte000) {
 885    if (jjtc000) {
 886      jjtree.clearNodeScope(jjtn000);
 887      jjtc000 = false;
 888    } else {
 889      jjtree.popNode();
 890    }
 891    if (jjte000 instanceof RuntimeException) {
 892      {if (true) throw (RuntimeException)jjte000;}
 893    }
 894    if (jjte000 instanceof ParseException) {
 895      {if (true) throw (ParseException)jjte000;}
 896    }
 897    {if (true) throw (Error)jjte000;}
 898    } finally {
 899    if (jjtc000) {
 900      jjtree.closeNodeScope(jjtn000, true);
 901      jjtreeCloseNodeScope(jjtn000);
 902    }
 903    }
 904  }
 905
 906  final public void PrimitiveType() throws ParseException {
 907 /*@bgen(jjtree) PrimitiveType */
 908  BSHPrimitiveType jjtn000 = new BSHPrimitiveType(JJTPRIMITIVETYPE);
 909  boolean jjtc000 = true;
 910  jjtree.openNodeScope(jjtn000);
 911  jjtreeOpenNodeScope(jjtn000);
 912    try {
 913      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 914      case BOOLEAN:
 915        jj_consume_token(BOOLEAN);
 916            jjtree.closeNodeScope(jjtn000, true);
 917            jjtc000 = false;
 918            jjtreeCloseNodeScope(jjtn000);
 919            jjtn000.type = Boolean.TYPE;
 920        break;
 921      case CHAR:
 922        jj_consume_token(CHAR);
 923           jjtree.closeNodeScope(jjtn000, true);
 924           jjtc000 = false;
 925           jjtreeCloseNodeScope(jjtn000);
 926           jjtn000.type =  Character.TYPE;
 927        break;
 928      case BYTE:
 929        jj_consume_token(BYTE);
 930           jjtree.closeNodeScope(jjtn000, true);
 931           jjtc000 = false;
 932           jjtreeCloseNodeScope(jjtn000);
 933           jjtn000.type =  Byte.TYPE;
 934        break;
 935      case SHORT:
 936        jj_consume_token(SHORT);
 937            jjtree.closeNodeScope(jjtn000, true);
 938            jjtc000 = false;
 939            jjtreeCloseNodeScope(jjtn000);
 940            jjtn000.type =  Short.TYPE;
 941        break;
 942      case INT:
 943        jj_consume_token(INT);
 944          jjtree.closeNodeScope(jjtn000, true);
 945          jjtc000 = false;
 946          jjtreeCloseNodeScope(jjtn000);
 947          jjtn000.type =  Integer.TYPE;
 948        break;
 949      case LONG:
 950        jj_consume_token(LONG);
 951           jjtree.closeNodeScope(jjtn000, true);
 952           jjtc000 = false;
 953           jjtreeCloseNodeScope(jjtn000);
 954           jjtn000.type =  Long.TYPE;
 955        break;
 956      case FLOAT:
 957        jj_consume_token(FLOAT);
 958            jjtree.closeNodeScope(jjtn000, true);
 959            jjtc000 = false;
 960            jjtreeCloseNodeScope(jjtn000);
 961            jjtn000.type =  Float.TYPE;
 962        break;
 963      case DOUBLE:
 964        jj_consume_token(DOUBLE);
 965             jjtree.closeNodeScope(jjtn000, true);
 966             jjtc000 = false;
 967             jjtreeCloseNodeScope(jjtn000);
 968             jjtn000.type =  Double.TYPE;
 969        break;
 970      default:
 971        jj_consume_token(-1);
 972        throw new ParseException();
 973      }
 974    } finally {
 975  if (jjtc000) {
 976    jjtree.closeNodeScope(jjtn000, true);
 977    jjtreeCloseNodeScope(jjtn000);
 978  }
 979    }
 980  }
 981
 982  final public void AmbiguousName() throws ParseException {
 983 /*@bgen(jjtree) AmbiguousName */
 984    BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
 985    boolean jjtc000 = true;
 986    jjtree.openNodeScope(jjtn000);
 987    jjtreeOpenNodeScope(jjtn000);Token t;
 988    StringBuffer s;
 989    try {
 990      t = jj_consume_token(IDENTIFIER);
 991        s = new StringBuffer(t.image);
 992      label_5:
 993      while (true) {
 994        if (jj_2_6(2)) {
 995          ;
 996        } else {
 997          break label_5;
 998        }
 999        jj_consume_token(DOT);
1000        t = jj_consume_token(IDENTIFIER);
1001                                        s.append("."+t.image);
1002      }
1003                                                                      jjtree.closeNodeScope(jjtn000, true);
1004                                                                      jjtc000 = false;
1005                                                                      jjtreeCloseNodeScope(jjtn000);
1006        jjtn000.text = s.toString();
1007    } finally {
1008    if (jjtc000) {
1009      jjtree.closeNodeScope(jjtn000, true);
1010      jjtreeCloseNodeScope(jjtn000);
1011    }
1012    }
1013  }
1014
1015  final public int NameList() throws ParseException {
1016  int count = 0;
1017    AmbiguousName();
1018                    ++count;
1019    label_6:
1020    while (true) {
1021      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1022      case COMMA:
1023        ;
1024        break;
1025      default:
1026        break label_6;
1027      }
1028      jj_consume_token(COMMA);
1029      AmbiguousName();
1030                                                       ++count;
1031    }
1032    {if (true) return count;}
1033    throw new Error("Missing return statement in function");
1034  }
1035
1036/*
1037 * Expression syntax follows.
1038 */
1039  final public void Expression() throws ParseException {
1040    if (jj_2_7(2147483647)) {
1041      Assignment();
1042    } else {
1043      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1044      case BOOLEAN:
1045      case BYTE:
1046      case CHAR:
1047      case DOUBLE:
1048      case FALSE:
1049      case FLOAT:
1050      case INT:
1051      case LONG:
1052      case NEW:
1053      case NULL:
1054      case SHORT:
1055      case TRUE:
1056      case VOID:
1057      case INTEGER_LITERAL:
1058      case FLOATING_POINT_LITERAL:
1059      case CHARACTER_LITERAL:
1060      case STRING_LITERAL:
1061      case IDENTIFIER:
1062      case LPAREN:
1063      case BANG:
1064      case TILDE:
1065      case INCR:
1066      case DECR:
1067      case PLUS:
1068      case MINUS:
1069        ConditionalExpression();
1070        break;
1071      default:
1072        jj_consume_token(-1);
1073        throw new ParseException();
1074      }
1075    }
1076  }
1077
1078  final public void Assignment() throws ParseException {
1079 /*@bgen(jjtree) Assignment */
1080  BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
1081  boolean jjtc000 = true;
1082  jjtree.openNodeScope(jjtn000);
1083  jjtreeOpenNodeScope(jjtn000);int op ;
1084    try {
1085      PrimaryExpression();
1086      op = AssignmentOperator();
1087                                    jjtn000.operator = op;
1088      Expression();
1089    } catch (Throwable jjte000) {
1090    if (jjtc000) {
1091      jjtree.clearNodeScope(jjtn000);
1092      jjtc000 = false;
1093    } else {
1094      jjtree.popNode();
1095    }
1096    if (jjte000 instanceof RuntimeException) {
1097      {if (true) throw (RuntimeException)jjte000;}
1098    }
1099    if (jjte000 instanceof ParseException) {
1100      {if (true) throw (ParseException)jjte000;}
1101    }
1102    {if (true) throw (Error)jjte000;}
1103    } finally {
1104    if (jjtc000) {
1105      jjtree.closeNodeScope(jjtn000, true);
1106      jjtreeCloseNodeScope(jjtn000);
1107    }
1108    }
1109  }
1110
1111  final public int AssignmentOperator() throws ParseException {
1112  Token t;
1113    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1114    case ASSIGN:
1115      jj_consume_token(ASSIGN);
1116      break;
1117    case STARASSIGN:
1118      jj_consume_token(STARASSIGN);
1119      break;
1120    case SLASHASSIGN:
1121      jj_consume_token(SLASHASSIGN);
1122      break;
1123    case MODASSIGN:
1124      jj_consume_token(MODASSIGN);
1125      break;
1126    case PLUSASSIGN:
1127      jj_consume_token(PLUSASSIGN);
1128      break;
1129    case MINUSASSIGN:
1130      jj_consume_token(MINUSASSIGN);
1131      break;
1132    case ANDASSIGN:
1133      jj_consume_token(ANDASSIGN);
1134      break;
1135    case XORASSIGN:
1136      jj_consume_token(XORASSIGN);
1137      break;
1138    case ORASSIGN:
1139      jj_consume_token(ORASSIGN);
1140      break;
1141    case LSHIFTASSIGN:
1142      jj_consume_token(LSHIFTASSIGN);
1143      break;
1144    case LSHIFTASSIGNX:
1145      jj_consume_token(LSHIFTASSIGNX);
1146      break;
1147    case RSIGNEDSHIFTASSIGN:
1148      jj_consume_token(RSIGNEDSHIFTASSIGN);
1149      break;
1150    case RSIGNEDSHIFTASSIGNX:
1151      jj_consume_token(RSIGNEDSHIFTASSIGNX);
1152      break;
1153    case RUNSIGNEDSHIFTASSIGN:
1154      jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1155      break;
1156    case RUNSIGNEDSHIFTASSIGNX:
1157      jj_consume_token(RUNSIGNEDSHIFTASSIGNX);
1158      break;
1159    default:
1160      jj_consume_token(-1);
1161      throw new ParseException();
1162    }
1163        t = getToken(0);
1164        {if (true) return t.kind;}
1165    throw new Error("Missing return statement in function");
1166  }
1167
1168  final public void ConditionalExpression() throws ParseException {
1169    ConditionalOrExpression();
1170    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1171    case HOOK:
1172      jj_consume_token(HOOK);
1173      Expression();
1174      jj_consume_token(COLON);
1175                                                     BSHTernaryExpression jjtn001 = new BSHTernaryExpression(JJTTERNARYEXPRESSION);
1176                                                     boolean jjtc001 = true;
1177                                                     jjtree.openNodeScope(jjtn001);
1178                                                     jjtreeOpenNodeScope(jjtn001);
1179      try {
1180        ConditionalExpression();
1181      } catch (Throwable jjte001) {
1182                                                     if (jjtc001) {
1183                                                       jjtree.clearNodeScope(jjtn001);
1184                                                       jjtc001 = false;
1185                                                     } else {
1186                                                       jjtree.popNode();
1187                                                     }
1188                                                     if (jjte001 instanceof RuntimeException) {
1189                                                       {if (true) throw (RuntimeException)jjte001;}
1190                                                     }
1191                                                     if (jjte001 instanceof ParseException) {
1192                                                       {if (true) throw (ParseException)jjte001;}
1193                                                     }
1194                                                     {if (true) throw (Error)jjte001;}
1195      } finally {
1196                                                     if (jjtc001) {
1197                                                       jjtree.closeNodeScope(jjtn001,  3);
1198                                                       jjtreeCloseNodeScope(jjtn001);
1199                                                     }
1200      }
1201      break;
1202    default:
1203      ;
1204    }
1205  }
1206
1207  final public void ConditionalOrExpression() throws ParseException {
1208  Token t=null;
1209    ConditionalAndExpression();
1210    label_7:
1211    while (true) {
1212      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1213      case BOOL_OR:
1214      case BOOL_ORX:
1215        ;
1216        break;
1217      default:
1218        break label_7;
1219      }
1220      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1221      case BOOL_OR:
1222        t = jj_consume_token(BOOL_OR);
1223        break;
1224      case BOOL_ORX:
1225        t = jj_consume_token(BOOL_ORX);
1226        break;
1227      default:
1228        jj_consume_token(-1);
1229        throw new ParseException();
1230      }
1231      ConditionalAndExpression();
1232      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1233      boolean jjtc001 = true;
1234      jjtree.openNodeScope(jjtn001);
1235      jjtreeOpenNodeScope(jjtn001);
1236      try {
1237      jjtree.closeNodeScope(jjtn001,  2);
1238      jjtc001 = false;
1239      jjtreeCloseNodeScope(jjtn001);
1240      jjtn001.kind = t.kind;
1241      } finally {
1242      if (jjtc001) {
1243        jjtree.closeNodeScope(jjtn001,  2);
1244        jjtreeCloseNodeScope(jjtn001);
1245      }
1246      }
1247    }
1248  }
1249
1250  final public void ConditionalAndExpression() throws ParseException {
1251  Token t=null;
1252    InclusiveOrExpression();
1253    label_8:
1254    while (true) {
1255      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1256      case BOOL_AND:
1257      case BOOL_ANDX:
1258        ;
1259        break;
1260      default:
1261        break label_8;
1262      }
1263      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1264      case BOOL_AND:
1265        t = jj_consume_token(BOOL_AND);
1266        break;
1267      case BOOL_ANDX:
1268        t = jj_consume_token(BOOL_ANDX);
1269        break;
1270      default:
1271        jj_consume_token(-1);
1272        throw new ParseException();
1273      }
1274      InclusiveOrExpression();
1275      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1276      boolean jjtc001 = true;
1277      jjtree.openNodeScope(jjtn001);
1278      jjtreeOpenNodeScope(jjtn001);
1279      try {
1280      jjtree.closeNodeScope(jjtn001,  2);
1281      jjtc001 = false;
1282      jjtreeCloseNodeScope(jjtn001);
1283      jjtn001.kind = t.kind;
1284      } finally {
1285      if (jjtc001) {
1286        jjtree.closeNodeScope(jjtn001,  2);
1287        jjtreeCloseNodeScope(jjtn001);
1288      }
1289      }
1290    }
1291  }
1292
1293  final public void InclusiveOrExpression() throws ParseException {
1294  Token t=null;
1295    ExclusiveOrExpression();
1296    label_9:
1297    while (true) {
1298      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1299      case BIT_OR:
1300      case BIT_ORX:
1301        ;
1302        break;
1303      default:
1304        break label_9;
1305      }
1306      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1307      case BIT_OR:
1308        t = jj_consume_token(BIT_OR);
1309        break;
1310      case BIT_ORX:
1311        t = jj_consume_token(BIT_ORX);
1312        break;
1313      default:
1314        jj_consume_token(-1);
1315        throw new ParseException();
1316      }
1317      ExclusiveOrExpression();
1318      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1319      boolean jjtc001 = true;
1320      jjtree.openNodeScope(jjtn001);
1321      jjtreeOpenNodeScope(jjtn001);
1322      try {
1323      jjtree.closeNodeScope(jjtn001,  2);
1324      jjtc001 = false;
1325      jjtreeCloseNodeScope(jjtn001);
1326      jjtn001.kind = t.kind;
1327      } finally {
1328      if (jjtc001) {
1329        jjtree.closeNodeScope(jjtn001,  2);
1330        jjtreeCloseNodeScope(jjtn001);
1331      }
1332      }
1333    }
1334  }
1335
1336  final public void ExclusiveOrExpression() throws ParseException {
1337  Token t=null;
1338    AndExpression();
1339    label_10:
1340    while (true) {
1341      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1342      case XOR:
1343        ;
1344        break;
1345      default:
1346        break label_10;
1347      }
1348      t = jj_consume_token(XOR);
1349      AndExpression();
1350      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1351      boolean jjtc001 = true;
1352      jjtree.openNodeScope(jjtn001);
1353      jjtreeOpenNodeScope(jjtn001);
1354      try {
1355      jjtree.closeNodeScope(jjtn001,  2);
1356      jjtc001 = false;
1357      jjtreeCloseNodeScope(jjtn001);
1358      jjtn001.kind = t.kind;
1359      } finally {
1360      if (jjtc001) {
1361        jjtree.closeNodeScope(jjtn001,  2);
1362        jjtreeCloseNodeScope(jjtn001);
1363      }
1364      }
1365    }
1366  }
1367
1368  final public void AndExpression() throws ParseException {
1369  Token t=null;
1370    EqualityExpression();
1371    label_11:
1372    while (true) {
1373      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1374      case BIT_AND:
1375      case BIT_ANDX:
1376        ;
1377        break;
1378      default:
1379        break label_11;
1380      }
1381      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1382      case BIT_AND:
1383        t = jj_consume_token(BIT_AND);
1384        break;
1385      case BIT_ANDX:
1386        t = jj_consume_token(BIT_ANDX);
1387        break;
1388      default:
1389        jj_consume_token(-1);
1390        throw new ParseException();
1391      }
1392      EqualityExpression();
1393      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1394      boolean jjtc001 = true;
1395      jjtree.openNodeScope(jjtn001);
1396      jjtreeOpenNodeScope(jjtn001);
1397      try {
1398      jjtree.closeNodeScope(jjtn001,  2);
1399      jjtc001 = false;
1400      jjtreeCloseNodeScope(jjtn001);
1401      jjtn001.kind = t.kind;
1402      } finally {
1403      if (jjtc001) {
1404        jjtree.closeNodeScope(jjtn001,  2);
1405        jjtreeCloseNodeScope(jjtn001);
1406      }
1407      }
1408    }
1409  }
1410
1411  final public void EqualityExpression() throws ParseException {
1412  Token t = null;
1413    InstanceOfExpression();
1414    label_12:
1415    while (true) {
1416      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1417      case EQ:
1418      case NE:
1419        ;
1420        break;
1421      default:
1422        break label_12;
1423      }
1424      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1425      case EQ:
1426        t = jj_consume_token(EQ);
1427        break;
1428      case NE:
1429        t = jj_consume_token(NE);
1430        break;
1431      default:
1432        jj_consume_token(-1);
1433        throw new ParseException();
1434      }
1435      InstanceOfExpression();
1436      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1437      boolean jjtc001 = true;
1438      jjtree.openNodeScope(jjtn001);
1439      jjtreeOpenNodeScope(jjtn001);
1440      try {
1441      jjtree.closeNodeScope(jjtn001,  2);
1442      jjtc001 = false;
1443      jjtreeCloseNodeScope(jjtn001);
1444      jjtn001.kind = t.kind;
1445      } finally {
1446      if (jjtc001) {
1447        jjtree.closeNodeScope(jjtn001,  2);
1448        jjtreeCloseNodeScope(jjtn001);
1449      }
1450      }
1451    }
1452  }
1453
1454  final public void InstanceOfExpression() throws ParseException {
1455  Token t = null;
1456    RelationalExpression();
1457    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1458    case INSTANCEOF:
1459      t = jj_consume_token(INSTANCEOF);
1460      Type();
1461                              BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1462                              boolean jjtc001 = true;
1463                              jjtree.openNodeScope(jjtn001);
1464                              jjtreeOpenNodeScope(jjtn001);
1465      try {
1466                              jjtree.closeNodeScope(jjtn001,  2);
1467                              jjtc001 = false;
1468                              jjtreeCloseNodeScope(jjtn001);
1469                              jjtn001.kind = t.kind;
1470      } finally {
1471                              if (jjtc001) {
1472                                jjtree.closeNodeScope(jjtn001,  2);
1473                                jjtreeCloseNodeScope(jjtn001);
1474                              }
1475      }
1476      break;
1477    default:
1478      ;
1479    }
1480  }
1481
1482  final public void RelationalExpression() throws ParseException {
1483  Token t = null;
1484    ShiftExpression();
1485    label_13:
1486    while (true) {
1487      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1488      case GT:
1489      case GTX:
1490      case LT:
1491      case LTX:
1492      case LE:
1493      case LEX:
1494      case GE:
1495      case GEX:
1496        ;
1497        break;
1498      default:
1499        break label_13;
1500      }
1501      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1502      case LT:
1503        t = jj_consume_token(LT);
1504        break;
1505      case LTX:
1506        t = jj_consume_token(LTX);
1507        break;
1508      case GT:
1509        t = jj_consume_token(GT);
1510        break;
1511      case GTX:
1512        t = jj_consume_token(GTX);
1513        break;
1514      case LE:
1515        t = jj_consume_token(LE);
1516        break;
1517      case LEX:
1518        t = jj_consume_token(LEX);
1519        break;
1520      case GE:
1521        t = jj_consume_token(GE);
1522        break;
1523      case GEX:
1524        t = jj_consume_token(GEX);
1525        break;
1526      default:
1527        jj_consume_token(-1);
1528        throw new ParseException();
1529      }
1530      ShiftExpression();
1531    BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1532    boolean jjtc001 = true;
1533    jjtree.openNodeScope(jjtn001);
1534    jjtreeOpenNodeScope(jjtn001);
1535      try {
1536    jjtree.closeNodeScope(jjtn001,  2);
1537    jjtc001 = false;
1538    jjtreeCloseNodeScope(jjtn001);
1539    jjtn001.kind = t.kind;
1540      } finally {
1541    if (jjtc001) {
1542      jjtree.closeNodeScope(jjtn001,  2);
1543      jjtreeCloseNodeScope(jjtn001);
1544    }
1545      }
1546    }
1547  }
1548
1549  final public void ShiftExpression() throws ParseException {
1550  Token t = null;
1551    AdditiveExpression();
1552    label_14:
1553    while (true) {
1554      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1555      case LSHIFT:
1556      case LSHIFTX:
1557      case RSIGNEDSHIFT:
1558      case RSIGNEDSHIFTX:
1559      case RUNSIGNEDSHIFT:
1560      case RUNSIGNEDSHIFTX:
1561        ;
1562        break;
1563      default:
1564        break label_14;
1565      }
1566      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1567      case LSHIFT:
1568        t = jj_consume_token(LSHIFT);
1569        break;
1570      case LSHIFTX:
1571        t = jj_consume_token(LSHIFTX);
1572        break;
1573      case RSIGNEDSHIFT:
1574        t = jj_consume_token(RSIGNEDSHIFT);
1575        break;
1576      case RSIGNEDSHIFTX:
1577        t = jj_consume_token(RSIGNEDSHIFTX);
1578        break;
1579      case RUNSIGNEDSHIFT:
1580        t = jj_consume_token(RUNSIGNEDSHIFT);
1581        break;
1582      case RUNSIGNEDSHIFTX:
1583        t = jj_consume_token(RUNSIGNEDSHIFTX);
1584        break;
1585      default:
1586        jj_consume_token(-1);
1587        throw new ParseException();
1588      }
1589      AdditiveExpression();
1590    BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1591    boolean jjtc001 = true;
1592    jjtree.openNodeScope(jjtn001);
1593    jjtreeOpenNodeScope(jjtn001);
1594      try {
1595    jjtree.closeNodeScope(jjtn001,  2);
1596    jjtc001 = false;
1597    jjtreeCloseNodeScope(jjtn001);
1598    jjtn001.kind = t.kind;
1599      } finally {
1600    if (jjtc001) {
1601      jjtree.closeNodeScope(jjtn001,  2);
1602      jjtreeCloseNodeScope(jjtn001);
1603    }
1604      }
1605    }
1606  }
1607
1608  final public void AdditiveExpression() throws ParseException {
1609  Token t = null;
1610    MultiplicativeExpression();
1611    label_15:
1612    while (true) {
1613      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1614      case PLUS:
1615      case MINUS:
1616        ;
1617        break;
1618      default:
1619        break label_15;
1620      }
1621      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1622      case PLUS:
1623        t = jj_consume_token(PLUS);
1624        break;
1625      case MINUS:
1626        t = jj_consume_token(MINUS);
1627        break;
1628      default:
1629        jj_consume_token(-1);
1630        throw new ParseException();
1631      }
1632      MultiplicativeExpression();
1633                                                     BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1634                                                     boolean jjtc001 = true;
1635                                                     jjtree.openNodeScope(jjtn001);
1636                                                     jjtreeOpenNodeScope(jjtn001);
1637      try {
1638                                                     jjtree.closeNodeScope(jjtn001,  2);
1639                                                     jjtc001 = false;
1640                                                     jjtreeCloseNodeScope(jjtn001);
1641                                                     jjtn001.kind = t.kind;
1642      } finally {
1643                                                     if (jjtc001) {
1644                                                       jjtree.closeNodeScope(jjtn001,  2);
1645                                                       jjtreeCloseNodeScope(jjtn001);
1646                                                     }
1647      }
1648    }
1649  }
1650
1651  final public void MultiplicativeExpression() throws ParseException {
1652  Token t = null;
1653    UnaryExpression();
1654    label_16:
1655    while (true) {
1656      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1657      case STAR:
1658      case SLASH:
1659      case MOD:
1660        ;
1661        break;
1662      default:
1663        break label_16;
1664      }
1665      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1666      case STAR:
1667        t = jj_consume_token(STAR);
1668        break;
1669      case SLASH:
1670        t = jj_consume_token(SLASH);
1671        break;
1672      case MOD:
1673        t = jj_consume_token(MOD);
1674        break;
1675      default:
1676        jj_consume_token(-1);
1677        throw new ParseException();
1678      }
1679      UnaryExpression();
1680                      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1681                      boolean jjtc001 = true;
1682                      jjtree.openNodeScope(jjtn001);
1683                      jjtreeOpenNodeScope(jjtn001);
1684      try {
1685                      jjtree.closeNodeScope(jjtn001,  2);
1686                      jjtc001 = false;
1687                      jjtreeCloseNodeScope(jjtn001);
1688                      jjtn001.kind = t.kind;
1689      } finally {
1690                      if (jjtc001) {
1691                        jjtree.closeNodeScope(jjtn001,  2);
1692                        jjtreeCloseNodeScope(jjtn001);
1693                      }
1694      }
1695    }
1696  }
1697
1698  final public void UnaryExpression() throws ParseException {
1699  Token t = null;
1700    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1701    case PLUS:
1702    case MINUS:
1703      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1704      case PLUS:
1705        t = jj_consume_token(PLUS);
1706        break;
1707      case MINUS:
1708        t = jj_consume_token(MINUS);
1709        break;
1710      default:
1711        jj_consume_token(-1);
1712        throw new ParseException();
1713      }
1714      UnaryExpression();
1715      BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1716      boolean jjtc001 = true;
1717      jjtree.openNodeScope(jjtn001);
1718      jjtreeOpenNodeScope(jjtn001);
1719      try {
1720      jjtree.closeNodeScope(jjtn001,  1);
1721      jjtc001 = false;
1722      jjtreeCloseNodeScope(jjtn001);
1723      jjtn001.kind = t.kind;
1724      } finally {
1725      if (jjtc001) {
1726        jjtree.closeNodeScope(jjtn001,  1);
1727        jjtreeCloseNodeScope(jjtn001);
1728      }
1729      }
1730      break;
1731    case INCR:
1732      PreIncrementExpression();
1733      break;
1734    case DECR:
1735      PreDecrementExpression();
1736      break;
1737    case BOOLEAN:
1738    case BYTE:
1739    case CHAR:
1740    case DOUBLE:
1741    case FALSE:
1742    case FLOAT:
1743    case INT:
1744    case LONG:
1745    case NEW:
1746    case NULL:
1747    case SHORT:
1748    case TRUE:
1749    case VOID:
1750    case INTEGER_LITERAL:
1751    case FLOATING_POINT_LITERAL:
1752    case CHARACTER_LITERAL:
1753    case STRING_LITERAL:
1754    case IDENTIFIER:
1755    case LPAREN:
1756    case BANG:
1757    case TILDE:
1758      UnaryExpressionNotPlusMinus();
1759      break;
1760    default:
1761      jj_consume_token(-1);
1762      throw new ParseException();
1763    }
1764  }
1765
1766  final public void PreIncrementExpression() throws ParseException {
1767  Token t = null;
1768    t = jj_consume_token(INCR);
1769 

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