PageRenderTime 138ms CodeModel.GetById 2ms app.highlight 122ms RepoModel.GetById 1ms app.codeStats 1ms

/jEdit/tags/jedit-4-0-pre3/bsh/bsh.jj

#
Unknown | 2424 lines | 2326 code | 98 blank | 0 comment | 0 complexity | 14b9f04c54708cbbdde889850c34c04e MD5 | raw file
   1/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. src/bsh/bsh.jj */
   2/*@egen*//*****************************************************************************
   3 *                                                                           *
   4 *  This file is part of the BeanShell Java Scripting distribution.          *
   5 *  Documentation and updates may be found at http://www.beanshell.org/      *
   6 *                                                                           *
   7 *  Sun Public License Notice:                                               *
   8 *                                                                           *
   9 *  The contents of this file are subject to the Sun Public License Version  *
  10 *  1.0 (the "License"); you may not use this file except in compliance with *
  11 *  the License. A copy of the License is available at http://www.sun.com    * 
  12 *                                                                           *
  13 *  The Original Code is BeanShell. The Initial Developer of the Original    *
  14 *  Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright     *
  15 *  (C) 2000.  All Rights Reserved.                                          *
  16 *                                                                           *
  17 *  GNU Public License Notice:                                               *
  18 *                                                                           *
  19 *  Alternatively, the contents of this file may be used under the terms of  *
  20 *  the GNU Lesser General Public License (the "LGPL"), in which case the    *
  21 *  provisions of LGPL are applicable instead of those above. If you wish to *
  22 *  allow use of your version of this file only under the  terms of the LGPL *
  23 *  and not to allow others to use your version of this file under the SPL,  *
  24 *  indicate your decision by deleting the provisions above and replace      *
  25 *  them with the notice and other provisions required by the LGPL.  If you  *
  26 *  do not delete the provisions above, a recipient may use your version of  *
  27 *  this file under either the SPL or the LGPL.                              *
  28 *                                                                           *
  29 *  Patrick Niemeyer (pat@pat.net)                                           *
  30 *  Author of Learning Java, O'Reilly & Associates                           *
  31 *  http://www.pat.net/~pat/                                                 *
  32 *                                                                           *
  33 *****************************************************************************/
  34
  35/*
  36	Notes:
  37	There is probably a lot of room for improvement in here.
  38	All of the syntactic lookaheads have been commented with:
  39		SYNTACTIC_LOOKAHEAD
  40	These are probably expensive and we may want to start weeding them out
  41	where possible.
  42*/
  43
  44options {
  45    JAVA_UNICODE_ESCAPE=true;
  46    STATIC=false;                                                                                       
  47	/* Print grammar debugging info as we parse 
  48	DEBUG_PARSER=true; */
  49	/* Print detailed lookahead debugging info
  50	DEBUG_LOOKAHEAD=true; */
  51}
  52
  53PARSER_BEGIN(Parser)
  54package bsh;
  55
  56import java.io.Reader;
  57
  58class Parser/*@bgen(jjtree)*/implements ParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
  59  protected JJTParserState jjtree = new JJTParserState();
  60
  61/*@egen*/ 
  62
  63	void jjtreeOpenNodeScope(Node n) {
  64		((SimpleNode)n).firstToken = getToken(1);
  65	}
  66
  67	void jjtreeCloseNodeScope(Node n) {
  68		((SimpleNode)n).lastToken = getToken(0);
  69	}
  70
  71	/**
  72		Re-initialize the input stream and token source.
  73	*/
  74	void reInitInput( Reader in ) {
  75		ReInit(in);
  76	}
  77
  78	/**
  79		Explicitly re-initialize just the token reader.
  80		This seems to be necessary to avoid certain looping errors when
  81		reading bogus input.  See Interpreter.
  82	*/
  83	void reInitTokenInput( Reader in ) {
  84		jj_input_stream.ReInit( in, 
  85			jj_input_stream.getEndLine(), 
  86			jj_input_stream.getEndColumn() );
  87	}
  88
  89}
  90
  91
  92PARSER_END(Parser)
  93
  94SKIP : /* WHITE SPACE */
  95{ 
  96	" " | "\t" | "\r" | "\f"
  97	| "\n" 
  98	| < NONPRINTABLE: (["\u0000"-" ", "\u0080"-"\u00ff"])+ >
  99}
 100
 101SPECIAL_TOKEN : /* COMMENTS */
 102{
 103/*
 104	Single line comments fail on the last line of a file with no terminating
 105	linefeed.  I thought the <EOF> would fix that, but no...
 106  <SINGLE_LINE_COMMENT: "//" (~["\n","\r"])* "<EOF>"|("\n"|"\r"|"\r\n")>
 107*/
 108  <SINGLE_LINE_COMMENT: "//" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
 109| <HASH_BANG_COMMENT: "#!" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
 110| <FORMAL_COMMENT: "/**" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
 111| <MULTI_LINE_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
 112}
 113
 114TOKEN : /* RESERVED WORDS AND LITERALS */
 115{
 116< BOOLEAN: "boolean" >
 117| < BREAK: "break" >
 118| < CLASS: "class" >
 119| < BYTE: "byte" >
 120| < CASE: "case" >
 121| < CATCH: "catch" >
 122| < CHAR: "char" >
 123| < CONST: "const" >
 124| < CONTINUE: "continue" >
 125| < _DEFAULT: "default" >
 126| < DO: "do" >
 127| < DOUBLE: "double" >
 128| < ELSE: "else" >
 129| < FALSE: "false" >
 130| < FINAL: "final" >
 131| < FINALLY: "finally" >
 132| < FLOAT: "float" >
 133| < FOR: "for" >
 134| < GOTO: "goto" >
 135| < IF: "if" >
 136| < IMPORT: "import" >
 137| < INSTANCEOF: "instanceof" >
 138| < INT: "int" >
 139| < INTERFACE: "interface" >
 140| < LONG: "long" >
 141| < NEW: "new" >
 142| < NULL: "null" >
 143| < PRIVATE: "private" >
 144| < PROTECTED: "protected" >
 145| < PUBLIC: "public" >
 146| < RETURN: "return" >
 147| < SHORT: "short" >
 148| < STATIC: "static" >
 149| < SWITCH: "switch" >
 150| < THROW: "throw" >
 151| < TRUE: "true" >
 152| < TRY: "try" >
 153| < VOID: "void" >
 154| < WHILE: "while" >
 155}
 156
 157TOKEN : /* LITERALS */
 158{
 159  < INTEGER_LITERAL:
 160        <DECIMAL_LITERAL> (["l","L"])?
 161      | <HEX_LITERAL> (["l","L"])?
 162      | <OCTAL_LITERAL> (["l","L"])?
 163  >
 164|
 165  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
 166|
 167  < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
 168|
 169  < #OCTAL_LITERAL: "0" (["0"-"7"])* >
 170|
 171  < FLOATING_POINT_LITERAL:
 172        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
 173      | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
 174      | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
 175      | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
 176  >
 177|
 178  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
 179|
 180  < CHARACTER_LITERAL:
 181      "'"
 182      (   (~["'","\\","\n","\r"])
 183        | ("\\"
 184            ( ["n","t","b","r","f","\\","'","\""]
 185            | ["0"-"7"] ( ["0"-"7"] )?
 186            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
 187            )
 188          )
 189      )
 190      "'"
 191  >
 192|
 193  < STRING_LITERAL:
 194      "\""
 195      (   (~["\"","\\","\n","\r"])
 196        | ("\\"
 197            ( ["n","t","b","r","f","\\","'","\""]
 198            | ["0"-"7"] ( ["0"-"7"] )?
 199            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
 200            )
 201          )
 202      )*
 203      "\""
 204  >
 205}
 206
 207TOKEN : /* IDENTIFIERS */
 208{
 209  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
 210|
 211  < #LETTER:
 212      [
 213       "$",
 214       "A"-"Z",
 215       "_",
 216       "a"-"z",
 217       "\u00c0"-"\u00d6",
 218       "\u00d8"-"\u00f6",
 219       "\u00f8"-"\u00ff",
 220       "\u0100"-"\u1fff",
 221       "\u3040"-"\u318f",
 222       "\u3300"-"\u337f",
 223       "\u3400"-"\u3d2d",
 224       "\u4e00"-"\u9fff",
 225       "\uf900"-"\ufaff"
 226      ]
 227  >
 228|
 229  < #DIGIT:
 230      [
 231       "0"-"9",
 232       "\u0660"-"\u0669",
 233       "\u06f0"-"\u06f9",
 234       "\u0966"-"\u096f",
 235       "\u09e6"-"\u09ef",
 236       "\u0a66"-"\u0a6f",
 237       "\u0ae6"-"\u0aef",
 238       "\u0b66"-"\u0b6f",
 239       "\u0be7"-"\u0bef",
 240       "\u0c66"-"\u0c6f",
 241       "\u0ce6"-"\u0cef",
 242       "\u0d66"-"\u0d6f",
 243       "\u0e50"-"\u0e59",
 244       "\u0ed0"-"\u0ed9",
 245       "\u1040"-"\u1049"
 246      ]
 247  >
 248}
 249
 250TOKEN : /* SEPARATORS */
 251{
 252  < LPAREN: "(" >
 253| < RPAREN: ")" >
 254| < LBRACE: "{" >
 255| < RBRACE: "}" >
 256| < LBRACKET: "[" >
 257| < RBRACKET: "]" >
 258| < SEMICOLON: ";" >
 259| < COMMA: "," >
 260| < DOT: "." >
 261}
 262
 263TOKEN : /* OPERATORS */
 264{
 265  < ASSIGN: "=" >
 266| < GT: ">" >
 267| < GTX: "@gt" >
 268| < LT: "<" >
 269| < LTX: "@lt" >
 270| < BANG: "!" >
 271| < TILDE: "~" >
 272| < HOOK: "?" >
 273| < COLON: ":" >
 274| < EQ: "==" >
 275| < LE: "<=" >
 276| < LEX: "@lteq" >
 277| < GE: ">=" >
 278| < GEX: "@gteq" >
 279| < NE: "!=" >
 280| < BOOL_OR: "||" >
 281| < BOOL_ORX: "@or" >
 282| < BOOL_AND: "&&" >
 283| < BOOL_ANDX: "@and" >
 284| < INCR: "++" >
 285| < DECR: "--" >
 286| < PLUS: "+" >
 287| < MINUS: "-" >
 288| < STAR: "*" >
 289| < SLASH: "/" >
 290| < BIT_AND: "&" >
 291| < BIT_ANDX: "@bitwise_and" >
 292| < BIT_OR: "|" >
 293| < BIT_ORX: "@bitwise_or" >
 294| < XOR: "^" >
 295| < MOD: "%" >
 296| < LSHIFT: "<<" >
 297| < LSHIFTX: "@left_shift" >
 298| < RSIGNEDSHIFT: ">>" >
 299| < RSIGNEDSHIFTX: "@right_shift" >
 300| < RUNSIGNEDSHIFT: ">>>" >
 301| < RUNSIGNEDSHIFTX: "@right_unsigned_shift" >
 302| < PLUSASSIGN: "+=" >
 303| < MINUSASSIGN: "-=" >
 304| < STARASSIGN: "*=" >
 305| < SLASHASSIGN: "/=" >
 306| < ANDASSIGN: "&=" >
 307| < ANDASSIGNX: "@and_assign" >
 308| < ORASSIGN: "|=" >
 309| < ORASSIGNX: "@or_assign" >
 310| < XORASSIGN: "^=" >
 311| < MODASSIGN: "%=" >
 312| < LSHIFTASSIGN: "<<=" >
 313| < LSHIFTASSIGNX: "@left_shift_assign" >
 314| < RSIGNEDSHIFTASSIGN: ">>=" >
 315| < RSIGNEDSHIFTASSIGNX: "@right_shift_assign" >
 316| < RUNSIGNEDSHIFTASSIGN: ">>>=" >
 317| < RUNSIGNEDSHIFTASSIGNX: "@right_unsigned_shift_assign" >
 318}
 319
 320
 321boolean Line() :
 322{}
 323{
 324  <EOF> { 
 325	Interpreter.debug("End of File!"); 
 326	return true; 
 327	}
 328|
 329  (
 330	/*
 331		SYNTACTIC_LOOKAHEAD
 332		I'm guessing this is expensive, but I don't know how to work around
 333		it...  Is there another syntactic indication that we are working 
 334		through an expression as opposed to a statement?
 335		What is the difference?  Well, some statements don't require a
 336		semicolon and they don't return vlues...  We could probably broaden
 337		bsh to allow everything to return a value, but the semi-colon thing
 338		is tougher.  You don't want to have to say if ( foo ) { } ;
 339		Maybe we can invert ths and enumerate all of those types of 
 340		statements in a special lookahead that's cheaper??
 341	*/
 342   LOOKAHEAD( Expression() ";" )
 343   Expression() ";" 
 344  |
 345   BlockStatement()
 346  )
 347	{ 
 348		return false; 
 349	}
 350}
 351
 352/*****************************************
 353 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
 354 *****************************************/
 355
 356void MethodDeclaration()                    :
 357{/*@bgen(jjtree) MethodDeclaration */
 358  BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(JJTMETHODDECLARATION);
 359  boolean jjtc000 = true;
 360  jjtree.openNodeScope(jjtn000);
 361  jjtreeOpenNodeScope(jjtn000);
 362/*@egen*/ Token t = null; }
 363{/*@bgen(jjtree) MethodDeclaration */
 364    try {
 365/*@egen*/
 366	// SYNTACTIC_LOOKAHEAD
 367	// this one seems cheap enough
 368    LOOKAHEAD( MethodDeclarationTypeLookahead() )
 369    ReturnType() t = <IDENTIFIER> { jjtn000.name = t.image; }
 370    FormalParameters() Block()
 371|
 372    t = <IDENTIFIER> { jjtn000.name = t.image; }
 373    FormalParameters() Block()/*@bgen(jjtree)*/
 374    } catch (Throwable jjte000) {
 375      if (jjtc000) {
 376        jjtree.clearNodeScope(jjtn000);
 377        jjtc000 = false;
 378      } else {
 379        jjtree.popNode();
 380      }
 381      if (jjte000 instanceof RuntimeException) {
 382        throw (RuntimeException)jjte000;
 383      }
 384      if (jjte000 instanceof ParseException) {
 385        throw (ParseException)jjte000;
 386      }
 387      throw (Error)jjte000;
 388    } finally {
 389      if (jjtc000) {
 390        jjtree.closeNodeScope(jjtn000, true);
 391        jjtreeCloseNodeScope(jjtn000);
 392      }
 393    }
 394/*@egen*/
 395}
 396
 397void MethodDeclarationLookahead() : { }
 398{
 399	// SYNTACTIC_LOOKAHEAD
 400	// this one seems cheap enough
 401    LOOKAHEAD( MethodDeclarationTypeLookahead() )
 402    ReturnType() <IDENTIFIER> FormalParameters() "{"
 403|
 404    <IDENTIFIER> FormalParameters() "{"
 405}
 406
 407void MethodDeclarationTypeLookahead() : { }
 408{
 409    ReturnType() <IDENTIFIER> "("
 410}
 411
 412void ImportDeclaration()                    :
 413{/*@bgen(jjtree) ImportDeclaration */
 414    BSHImportDeclaration jjtn000 = new BSHImportDeclaration(JJTIMPORTDECLARATION);
 415    boolean jjtc000 = true;
 416    jjtree.openNodeScope(jjtn000);
 417    jjtreeOpenNodeScope(jjtn000);
 418/*@egen*/
 419    Token t = null;
 420}
 421{/*@bgen(jjtree) ImportDeclaration */
 422  try {
 423/*@egen*/
 424  LOOKAHEAD( 2 )
 425
 426  "import" AmbiguousName() [ t = "." "*" ] ";"/*@bgen(jjtree)*/
 427                                               {
 428                                                 jjtree.closeNodeScope(jjtn000, true);
 429                                                 jjtc000 = false;
 430                                                 jjtreeCloseNodeScope(jjtn000);
 431                                               }
 432/*@egen*/ {
 433    if ( t != null )
 434        jjtn000.importPackage = true;
 435    }
 436  |
 437	// bsh super import statement
 438  "import" "*" ";"/*@bgen(jjtree)*/
 439                   {
 440                     jjtree.closeNodeScope(jjtn000, true);
 441                     jjtc000 = false;
 442                     jjtreeCloseNodeScope(jjtn000);
 443                   }
 444/*@egen*/ {
 445		jjtn000.superImport = true;
 446	}/*@bgen(jjtree)*/
 447  } catch (Throwable jjte000) {
 448    if (jjtc000) {
 449      jjtree.clearNodeScope(jjtn000);
 450      jjtc000 = false;
 451    } else {
 452      jjtree.popNode();
 453    }
 454    if (jjte000 instanceof RuntimeException) {
 455      throw (RuntimeException)jjte000;
 456    }
 457    if (jjte000 instanceof ParseException) {
 458      throw (ParseException)jjte000;
 459    }
 460    throw (Error)jjte000;
 461  } finally {
 462    if (jjtc000) {
 463      jjtree.closeNodeScope(jjtn000, true);
 464      jjtreeCloseNodeScope(jjtn000);
 465    }
 466  }
 467/*@egen*/
 468}
 469
 470void VariableDeclarator()                     :
 471{/*@bgen(jjtree) VariableDeclarator */
 472  BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(JJTVARIABLEDECLARATOR);
 473  boolean jjtc000 = true;
 474  jjtree.openNodeScope(jjtn000);
 475  jjtreeOpenNodeScope(jjtn000);
 476/*@egen*/ Token t; }
 477{/*@bgen(jjtree) VariableDeclarator */
 478  try {
 479/*@egen*/
 480  t=<IDENTIFIER> [ "=" VariableInitializer() ]/*@bgen(jjtree)*/
 481                                               {
 482                                                 jjtree.closeNodeScope(jjtn000, true);
 483                                                 jjtc000 = false;
 484                                                 jjtreeCloseNodeScope(jjtn000);
 485                                               }
 486/*@egen*/ { jjtn000.name = t.image; }/*@bgen(jjtree)*/
 487  } catch (Throwable jjte000) {
 488    if (jjtc000) {
 489      jjtree.clearNodeScope(jjtn000);
 490      jjtc000 = false;
 491    } else {
 492      jjtree.popNode();
 493    }
 494    if (jjte000 instanceof RuntimeException) {
 495      throw (RuntimeException)jjte000;
 496    }
 497    if (jjte000 instanceof ParseException) {
 498      throw (ParseException)jjte000;
 499    }
 500    throw (Error)jjte000;
 501  } finally {
 502    if (jjtc000) {
 503      jjtree.closeNodeScope(jjtn000, true);
 504      jjtreeCloseNodeScope(jjtn000);
 505    }
 506  }
 507/*@egen*/
 508}
 509
 510/*
 511Can get rid of this if we ignore postfix array dimensions in declarations.
 512I don't like them and I don't want to deal with them right now.
 513
 514void VariableDeclaratorId() #VariableDeclaratorId :
 515{ Token t; }
 516{
 517  t=<IDENTIFIER> { jjtThis.name = t.image; }
 518  ( "[" "]" { jjtThis.addArrayDimension(); } )*
 519}
 520*/
 521
 522void VariableInitializer() :
 523{}
 524{
 525  ArrayInitializer()
 526|
 527  Expression()
 528}
 529
 530void ArrayInitializer()                   :
 531{/*@bgen(jjtree) ArrayInitializer */
 532  BSHArrayInitializer jjtn000 = new BSHArrayInitializer(JJTARRAYINITIALIZER);
 533  boolean jjtc000 = true;
 534  jjtree.openNodeScope(jjtn000);
 535  jjtreeOpenNodeScope(jjtn000);
 536/*@egen*/}
 537{/*@bgen(jjtree) ArrayInitializer */
 538  try {
 539/*@egen*/
 540  "{" [ VariableInitializer() 
 541		( LOOKAHEAD(2) "," VariableInitializer() )* ] [ "," ] "}"/*@bgen(jjtree)*/
 542  } catch (Throwable jjte000) {
 543    if (jjtc000) {
 544      jjtree.clearNodeScope(jjtn000);
 545      jjtc000 = false;
 546    } else {
 547      jjtree.popNode();
 548    }
 549    if (jjte000 instanceof RuntimeException) {
 550      throw (RuntimeException)jjte000;
 551    }
 552    if (jjte000 instanceof ParseException) {
 553      throw (ParseException)jjte000;
 554    }
 555    throw (Error)jjte000;
 556  } finally {
 557    if (jjtc000) {
 558      jjtree.closeNodeScope(jjtn000, true);
 559      jjtreeCloseNodeScope(jjtn000);
 560    }
 561  }
 562/*@egen*/
 563}
 564
 565void FormalParameters()                   :
 566{/*@bgen(jjtree) FormalParameters */
 567  BSHFormalParameters jjtn000 = new BSHFormalParameters(JJTFORMALPARAMETERS);
 568  boolean jjtc000 = true;
 569  jjtree.openNodeScope(jjtn000);
 570  jjtreeOpenNodeScope(jjtn000);
 571/*@egen*/}
 572{/*@bgen(jjtree) FormalParameters */
 573  try {
 574/*@egen*/
 575  "(" [ FormalParameter() ( "," FormalParameter() )* ] ")"/*@bgen(jjtree)*/
 576  } catch (Throwable jjte000) {
 577    if (jjtc000) {
 578      jjtree.clearNodeScope(jjtn000);
 579      jjtc000 = false;
 580    } else {
 581      jjtree.popNode();
 582    }
 583    if (jjte000 instanceof RuntimeException) {
 584      throw (RuntimeException)jjte000;
 585    }
 586    if (jjte000 instanceof ParseException) {
 587      throw (ParseException)jjte000;
 588    }
 589    throw (Error)jjte000;
 590  } finally {
 591    if (jjtc000) {
 592      jjtree.closeNodeScope(jjtn000, true);
 593      jjtreeCloseNodeScope(jjtn000);
 594    }
 595  }
 596/*@egen*/
 597}
 598
 599/*
 600void FormalParameter() #FormalParameter :
 601{ Token t; }
 602{
 603    // added [] to Type for bsh.  Removed [ final ] - is that legal?
 604  [ LOOKAHEAD(2) Type() ] t=<IDENTIFIER> { jjtThis.name = t.image; }
 605}
 606*/
 607void FormalParameter()                  :
 608{/*@bgen(jjtree) FormalParameter */
 609  BSHFormalParameter jjtn000 = new BSHFormalParameter(JJTFORMALPARAMETER);
 610  boolean jjtc000 = true;
 611  jjtree.openNodeScope(jjtn000);
 612  jjtreeOpenNodeScope(jjtn000);
 613/*@egen*/ Token t; }
 614{/*@bgen(jjtree) FormalParameter */
 615  try {
 616/*@egen*/
 617  // added [] to Type for bsh.  Removed [ final ] - is that legal?
 618  LOOKAHEAD(2) Type() t=<IDENTIFIER>/*@bgen(jjtree)*/
 619                                     {
 620                                       jjtree.closeNodeScope(jjtn000, true);
 621                                       jjtc000 = false;
 622                                       jjtreeCloseNodeScope(jjtn000);
 623                                     }
 624/*@egen*/ { jjtn000.name = t.image; }
 625|
 626  t=<IDENTIFIER>/*@bgen(jjtree)*/
 627                 {
 628                   jjtree.closeNodeScope(jjtn000, true);
 629                   jjtc000 = false;
 630                   jjtreeCloseNodeScope(jjtn000);
 631                 }
 632/*@egen*/ { jjtn000.name = t.image; }/*@bgen(jjtree)*/
 633  } catch (Throwable jjte000) {
 634    if (jjtc000) {
 635      jjtree.clearNodeScope(jjtn000);
 636      jjtc000 = false;
 637    } else {
 638      jjtree.popNode();
 639    }
 640    if (jjte000 instanceof RuntimeException) {
 641      throw (RuntimeException)jjte000;
 642    }
 643    if (jjte000 instanceof ParseException) {
 644      throw (ParseException)jjte000;
 645    }
 646    throw (Error)jjte000;
 647  } finally {
 648    if (jjtc000) {
 649      jjtree.closeNodeScope(jjtn000, true);
 650      jjtreeCloseNodeScope(jjtn000);
 651    }
 652  }
 653/*@egen*/
 654}
 655
 656
 657/*
 658	Type, name and expression syntax follows.
 659*/
 660void Type()       :
 661{/*@bgen(jjtree) Type */
 662  BSHType jjtn000 = new BSHType(JJTTYPE);
 663  boolean jjtc000 = true;
 664  jjtree.openNodeScope(jjtn000);
 665  jjtreeOpenNodeScope(jjtn000);
 666/*@egen*/ }
 667{/*@bgen(jjtree) Type */
 668  try {
 669/*@egen*/
 670	/* 
 671		The embedded lookahead is (was?) necessary to disambiguate for
 672		PrimaryPrefix.  ( )* is a choice point.  It took me a while to
 673		figure out where to put that.  This stuff is annoying.
 674	*/
 675  ( PrimitiveType() | AmbiguousName() ) 
 676	( LOOKAHEAD(2) "[" "]" { jjtn000.addArrayDimension(); } )*/*@bgen(jjtree)*/
 677  } catch (Throwable jjte000) {
 678    if (jjtc000) {
 679      jjtree.clearNodeScope(jjtn000);
 680      jjtc000 = false;
 681    } else {
 682      jjtree.popNode();
 683    }
 684    if (jjte000 instanceof RuntimeException) {
 685      throw (RuntimeException)jjte000;
 686    }
 687    if (jjte000 instanceof ParseException) {
 688      throw (ParseException)jjte000;
 689    }
 690    throw (Error)jjte000;
 691  } finally {
 692    if (jjtc000) {
 693      jjtree.closeNodeScope(jjtn000, true);
 694      jjtreeCloseNodeScope(jjtn000);
 695    }
 696  }
 697/*@egen*/ 
 698}
 699
 700/*
 701	Originally called ResultType in the grammar
 702*/
 703void ReturnType()             :
 704{/*@bgen(jjtree) ReturnType */
 705  BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
 706  boolean jjtc000 = true;
 707  jjtree.openNodeScope(jjtn000);
 708  jjtreeOpenNodeScope(jjtn000);
 709/*@egen*/ }
 710{/*@bgen(jjtree) ReturnType */
 711  try {
 712/*@egen*/
 713  "void"/*@bgen(jjtree)*/
 714         {
 715           jjtree.closeNodeScope(jjtn000, true);
 716           jjtc000 = false;
 717           jjtreeCloseNodeScope(jjtn000);
 718         }
 719/*@egen*/ { jjtn000.isVoid = true; }
 720|
 721  Type()/*@bgen(jjtree)*/
 722  } catch (Throwable jjte000) {
 723    if (jjtc000) {
 724      jjtree.clearNodeScope(jjtn000);
 725      jjtc000 = false;
 726    } else {
 727      jjtree.popNode();
 728    }
 729    if (jjte000 instanceof RuntimeException) {
 730      throw (RuntimeException)jjte000;
 731    }
 732    if (jjte000 instanceof ParseException) {
 733      throw (ParseException)jjte000;
 734    }
 735    throw (Error)jjte000;
 736  } finally {
 737    if (jjtc000) {
 738      jjtree.closeNodeScope(jjtn000, true);
 739      jjtreeCloseNodeScope(jjtn000);
 740    }
 741  }
 742/*@egen*/
 743}
 744
 745void PrimitiveType()                :
 746{/*@bgen(jjtree) PrimitiveType */
 747  BSHPrimitiveType jjtn000 = new BSHPrimitiveType(JJTPRIMITIVETYPE);
 748  boolean jjtc000 = true;
 749  jjtree.openNodeScope(jjtn000);
 750  jjtreeOpenNodeScope(jjtn000);
 751/*@egen*/ } {/*@bgen(jjtree) PrimitiveType */
 752try {
 753/*@egen*/
 754"boolean"/*@bgen(jjtree)*/
 755          {
 756            jjtree.closeNodeScope(jjtn000, true);
 757            jjtc000 = false;
 758            jjtreeCloseNodeScope(jjtn000);
 759          }
 760/*@egen*/ { jjtn000.type = Boolean.TYPE; }
 761| "char"/*@bgen(jjtree)*/
 762         {
 763           jjtree.closeNodeScope(jjtn000, true);
 764           jjtc000 = false;
 765           jjtreeCloseNodeScope(jjtn000);
 766         }
 767/*@egen*/ { jjtn000.type =  Character.TYPE; }
 768| "byte"/*@bgen(jjtree)*/
 769         {
 770           jjtree.closeNodeScope(jjtn000, true);
 771           jjtc000 = false;
 772           jjtreeCloseNodeScope(jjtn000);
 773         }
 774/*@egen*/ { jjtn000.type =  Byte.TYPE; }
 775| "short"/*@bgen(jjtree)*/
 776          {
 777            jjtree.closeNodeScope(jjtn000, true);
 778            jjtc000 = false;
 779            jjtreeCloseNodeScope(jjtn000);
 780          }
 781/*@egen*/ { jjtn000.type =  Short.TYPE; }
 782| "int"/*@bgen(jjtree)*/
 783        {
 784          jjtree.closeNodeScope(jjtn000, true);
 785          jjtc000 = false;
 786          jjtreeCloseNodeScope(jjtn000);
 787        }
 788/*@egen*/ { jjtn000.type =  Integer.TYPE; }
 789| "long"/*@bgen(jjtree)*/
 790         {
 791           jjtree.closeNodeScope(jjtn000, true);
 792           jjtc000 = false;
 793           jjtreeCloseNodeScope(jjtn000);
 794         }
 795/*@egen*/ { jjtn000.type =  Long.TYPE; }
 796| "float"/*@bgen(jjtree)*/
 797          {
 798            jjtree.closeNodeScope(jjtn000, true);
 799            jjtc000 = false;
 800            jjtreeCloseNodeScope(jjtn000);
 801          }
 802/*@egen*/ { jjtn000.type =  Float.TYPE; }
 803| "double"/*@bgen(jjtree)*/
 804           {
 805             jjtree.closeNodeScope(jjtn000, true);
 806             jjtc000 = false;
 807             jjtreeCloseNodeScope(jjtn000);
 808           }
 809/*@egen*/ { jjtn000.type =  Double.TYPE; }/*@bgen(jjtree)*/
 810} finally {
 811  if (jjtc000) {
 812    jjtree.closeNodeScope(jjtn000, true);
 813    jjtreeCloseNodeScope(jjtn000);
 814  }
 815}
 816/*@egen*/
 817}
 818
 819void AmbiguousName()                :
 820/*
 821 * A lookahead of 2 is required below since "Name" can be followed
 822 * by a ".*" when used in the context of an "ImportDeclaration".
 823 */
 824{/*@bgen(jjtree) AmbiguousName */
 825    BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
 826    boolean jjtc000 = true;
 827    jjtree.openNodeScope(jjtn000);
 828    jjtreeOpenNodeScope(jjtn000);
 829/*@egen*/
 830    Token t;
 831    StringBuffer s;
 832}
 833{/*@bgen(jjtree) AmbiguousName */
 834  try {
 835/*@egen*/
 836  t = <IDENTIFIER> {
 837        s = new StringBuffer(t.image);
 838    }
 839  ( LOOKAHEAD(2) "." t = <IDENTIFIER> {
 840        s.append("."+t.image);
 841    }
 842  )*/*@bgen(jjtree)*/
 843     {
 844       jjtree.closeNodeScope(jjtn000, true);
 845       jjtc000 = false;
 846       jjtreeCloseNodeScope(jjtn000);
 847     }
 848/*@egen*/ {
 849        jjtn000.text = s.toString();
 850    }/*@bgen(jjtree)*/
 851  } finally {
 852    if (jjtc000) {
 853      jjtree.closeNodeScope(jjtn000, true);
 854      jjtreeCloseNodeScope(jjtn000);
 855    }
 856  }
 857/*@egen*/
 858}
 859
 860/*
 861 * Expression syntax follows.
 862 */
 863void Expression() :
 864{ }
 865{
 866	/**
 867		SYNTACTIC_LOOKAHEAD
 868		This is probably expensive.  Can we simplify it somehow?
 869	*/
 870  LOOKAHEAD( LHSPrimaryExpression() AssignmentOperator() )
 871  Assignment()
 872|
 873  ConditionalExpression()
 874}
 875
 876void Assignment()             :
 877{/*@bgen(jjtree) Assignment */
 878  BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
 879  boolean jjtc000 = true;
 880  jjtree.openNodeScope(jjtn000);
 881  jjtreeOpenNodeScope(jjtn000);
 882/*@egen*/ int op ; }
 883{/*@bgen(jjtree) Assignment */
 884  try {
 885/*@egen*/
 886  LHSPrimaryExpression()
 887  op = AssignmentOperator() {
 888    jjtn000.operator = op;
 889  }
 890  Expression()/*@bgen(jjtree)*/
 891  } catch (Throwable jjte000) {
 892    if (jjtc000) {
 893      jjtree.clearNodeScope(jjtn000);
 894      jjtc000 = false;
 895    } else {
 896      jjtree.popNode();
 897    }
 898    if (jjte000 instanceof RuntimeException) {
 899      throw (RuntimeException)jjte000;
 900    }
 901    if (jjte000 instanceof ParseException) {
 902      throw (ParseException)jjte000;
 903    }
 904    throw (Error)jjte000;
 905  } finally {
 906    if (jjtc000) {
 907      jjtree.closeNodeScope(jjtn000, true);
 908      jjtreeCloseNodeScope(jjtn000);
 909    }
 910  }
 911/*@egen*/
 912}
 913
 914int AssignmentOperator() :
 915{ Token t; }
 916{
 917    ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "&=" | "^=" | "|=" |
 918      "<<=" | "@left_shift_assign" | ">>=" | "@right_shift_assign" |
 919      ">>>=" | "@right_unsigned_shift_assign" )
 920    {
 921        t = getToken(0);
 922        return t.kind;
 923    }
 924}
 925
 926void ConditionalExpression() : 
 927{ }
 928{
 929  ConditionalOrExpression() [ "?" Expression() ":"/*@bgen(jjtree) #TernaryExpression( 3) */
 930                                                   {
 931                                                     BSHTernaryExpression jjtn001 = new BSHTernaryExpression(JJTTERNARYEXPRESSION);
 932                                                     boolean jjtc001 = true;
 933                                                     jjtree.openNodeScope(jjtn001);
 934                                                     jjtreeOpenNodeScope(jjtn001);
 935                                                   }
 936                                                   try {
 937/*@egen*/ ConditionalExpression()/*@bgen(jjtree)*/
 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                                                       throw (RuntimeException)jjte001;
 947                                                     }
 948                                                     if (jjte001 instanceof ParseException) {
 949                                                       throw (ParseException)jjte001;
 950                                                     }
 951                                                     throw (Error)jjte001;
 952                                                   } finally {
 953                                                     if (jjtc001) {
 954                                                       jjtree.closeNodeScope(jjtn001,  3);
 955                                                       jjtreeCloseNodeScope(jjtn001);
 956                                                     }
 957                                                   }
 958/*@egen*/ ]
 959}
 960
 961void ConditionalOrExpression() :
 962{ Token t=null; }
 963{
 964  ConditionalAndExpression()
 965  ( ( t = "||" | t = "@or" )
 966    ConditionalAndExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
 967    {
 968      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
 969      boolean jjtc001 = true;
 970      jjtree.openNodeScope(jjtn001);
 971      jjtreeOpenNodeScope(jjtn001);
 972    }
 973    try {
 974/*@egen*//*@bgen(jjtree)*/
 975    {
 976      jjtree.closeNodeScope(jjtn001,  2);
 977      jjtc001 = false;
 978      jjtreeCloseNodeScope(jjtn001);
 979    }
 980/*@egen*/
 981    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
 982    } finally {
 983      if (jjtc001) {
 984        jjtree.closeNodeScope(jjtn001,  2);
 985        jjtreeCloseNodeScope(jjtn001);
 986      }
 987    }
 988/*@egen*/ )*
 989}
 990
 991void ConditionalAndExpression() :
 992{ Token t=null; }
 993{
 994  InclusiveOrExpression()
 995  ( ( t = "&&" | t = "@and" )
 996    InclusiveOrExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
 997    {
 998      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
 999      boolean jjtc001 = true;
1000      jjtree.openNodeScope(jjtn001);
1001      jjtreeOpenNodeScope(jjtn001);
1002    }
1003    try {
1004/*@egen*//*@bgen(jjtree)*/
1005    {
1006      jjtree.closeNodeScope(jjtn001,  2);
1007      jjtc001 = false;
1008      jjtreeCloseNodeScope(jjtn001);
1009    }
1010/*@egen*/
1011    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1012    } finally {
1013      if (jjtc001) {
1014        jjtree.closeNodeScope(jjtn001,  2);
1015        jjtreeCloseNodeScope(jjtn001);
1016      }
1017    }
1018/*@egen*/ )*
1019}
1020
1021void InclusiveOrExpression() :
1022{ Token t=null; }
1023{
1024  ExclusiveOrExpression()
1025  ( ( t = "|" | t = "@bitwise_or" )
1026    ExclusiveOrExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1027    {
1028      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1029      boolean jjtc001 = true;
1030      jjtree.openNodeScope(jjtn001);
1031      jjtreeOpenNodeScope(jjtn001);
1032    }
1033    try {
1034/*@egen*//*@bgen(jjtree)*/
1035    {
1036      jjtree.closeNodeScope(jjtn001,  2);
1037      jjtc001 = false;
1038      jjtreeCloseNodeScope(jjtn001);
1039    }
1040/*@egen*/
1041    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1042    } finally {
1043      if (jjtc001) {
1044        jjtree.closeNodeScope(jjtn001,  2);
1045        jjtreeCloseNodeScope(jjtn001);
1046      }
1047    }
1048/*@egen*/ )*
1049}
1050
1051void ExclusiveOrExpression() :
1052{ Token t=null; }
1053{
1054  AndExpression() ( t="^" AndExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1055    {
1056      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1057      boolean jjtc001 = true;
1058      jjtree.openNodeScope(jjtn001);
1059      jjtreeOpenNodeScope(jjtn001);
1060    }
1061    try {
1062/*@egen*//*@bgen(jjtree)*/
1063    {
1064      jjtree.closeNodeScope(jjtn001,  2);
1065      jjtc001 = false;
1066      jjtreeCloseNodeScope(jjtn001);
1067    }
1068/*@egen*/
1069    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1070    } finally {
1071      if (jjtc001) {
1072        jjtree.closeNodeScope(jjtn001,  2);
1073        jjtreeCloseNodeScope(jjtn001);
1074      }
1075    }
1076/*@egen*/ )*
1077}
1078
1079void AndExpression() :
1080{ Token t=null; }
1081{
1082  EqualityExpression()
1083  ( ( t = "&" | t = "@bitwise_and" )
1084    EqualityExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1085    {
1086      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1087      boolean jjtc001 = true;
1088      jjtree.openNodeScope(jjtn001);
1089      jjtreeOpenNodeScope(jjtn001);
1090    }
1091    try {
1092/*@egen*//*@bgen(jjtree)*/
1093    {
1094      jjtree.closeNodeScope(jjtn001,  2);
1095      jjtc001 = false;
1096      jjtreeCloseNodeScope(jjtn001);
1097    }
1098/*@egen*/
1099    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1100    } finally {
1101      if (jjtc001) {
1102        jjtree.closeNodeScope(jjtn001,  2);
1103        jjtreeCloseNodeScope(jjtn001);
1104      }
1105    }
1106/*@egen*/ )*
1107}
1108
1109void EqualityExpression() :
1110{ Token t = null; }
1111{
1112  InstanceOfExpression() ( ( t= "==" | t= "!=" ) InstanceOfExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1113    {
1114      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1115      boolean jjtc001 = true;
1116      jjtree.openNodeScope(jjtn001);
1117      jjtreeOpenNodeScope(jjtn001);
1118    }
1119    try {
1120/*@egen*//*@bgen(jjtree)*/
1121    {
1122      jjtree.closeNodeScope(jjtn001,  2);
1123      jjtc001 = false;
1124      jjtreeCloseNodeScope(jjtn001);
1125    }
1126/*@egen*/
1127    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1128    } finally {
1129      if (jjtc001) {
1130        jjtree.closeNodeScope(jjtn001,  2);
1131        jjtreeCloseNodeScope(jjtn001);
1132      }
1133    }
1134/*@egen*/
1135  )*
1136}
1137
1138void InstanceOfExpression() :
1139{ Token t = null; }
1140{
1141  RelationalExpression()
1142  [ t = "instanceof" Type()/*@bgen(jjtree) #BinaryExpression( 2) */
1143                            {
1144                              BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1145                              boolean jjtc001 = true;
1146                              jjtree.openNodeScope(jjtn001);
1147                              jjtreeOpenNodeScope(jjtn001);
1148                            }
1149                            try {
1150/*@egen*//*@bgen(jjtree)*/
1151                            {
1152                              jjtree.closeNodeScope(jjtn001,  2);
1153                              jjtc001 = false;
1154                              jjtreeCloseNodeScope(jjtn001);
1155                            }
1156/*@egen*/ { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1157                            } finally {
1158                              if (jjtc001) {
1159                                jjtree.closeNodeScope(jjtn001,  2);
1160                                jjtreeCloseNodeScope(jjtn001);
1161                              }
1162                            }
1163/*@egen*/ ]
1164}
1165
1166void RelationalExpression() :
1167{ Token t = null; }
1168{
1169  ShiftExpression()
1170  ( ( t = "<" | t = "@lt" | t = ">" | t = "@gt" |
1171      t = "<=" | t = "@lteq" | t = ">=" | t = "@gteq" )
1172  ShiftExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1173  {
1174    BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1175    boolean jjtc001 = true;
1176    jjtree.openNodeScope(jjtn001);
1177    jjtreeOpenNodeScope(jjtn001);
1178  }
1179  try {
1180/*@egen*//*@bgen(jjtree)*/
1181  {
1182    jjtree.closeNodeScope(jjtn001,  2);
1183    jjtc001 = false;
1184    jjtreeCloseNodeScope(jjtn001);
1185  }
1186/*@egen*/
1187  { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1188  } finally {
1189    if (jjtc001) {
1190      jjtree.closeNodeScope(jjtn001,  2);
1191      jjtreeCloseNodeScope(jjtn001);
1192    }
1193  }
1194/*@egen*/ )*
1195}
1196
1197void ShiftExpression() :
1198{ Token t = null; }
1199{
1200  AdditiveExpression()
1201  ( ( t = "<<" | t = "@left_shift" | t = ">>" | t = "@right_shift" |
1202      t = ">>>" | t = "@right_unsigned_shift" )
1203  AdditiveExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1204  {
1205    BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1206    boolean jjtc001 = true;
1207    jjtree.openNodeScope(jjtn001);
1208    jjtreeOpenNodeScope(jjtn001);
1209  }
1210  try {
1211/*@egen*//*@bgen(jjtree)*/
1212  {
1213    jjtree.closeNodeScope(jjtn001,  2);
1214    jjtc001 = false;
1215    jjtreeCloseNodeScope(jjtn001);
1216  }
1217/*@egen*/
1218  { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1219  } finally {
1220    if (jjtc001) {
1221      jjtree.closeNodeScope(jjtn001,  2);
1222      jjtreeCloseNodeScope(jjtn001);
1223    }
1224  }
1225/*@egen*/ )*
1226}
1227
1228void AdditiveExpression() :
1229{ Token t = null; }
1230{
1231  MultiplicativeExpression()
1232  ( ( t= "+" | t= "-" ) MultiplicativeExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1233                                                   {
1234                                                     BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1235                                                     boolean jjtc001 = true;
1236                                                     jjtree.openNodeScope(jjtn001);
1237                                                     jjtreeOpenNodeScope(jjtn001);
1238                                                   }
1239                                                   try {
1240/*@egen*//*@bgen(jjtree)*/
1241                                                   {
1242                                                     jjtree.closeNodeScope(jjtn001,  2);
1243                                                     jjtc001 = false;
1244                                                     jjtreeCloseNodeScope(jjtn001);
1245                                                   }
1246/*@egen*/ { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1247                                                   } finally {
1248                                                     if (jjtc001) {
1249                                                       jjtree.closeNodeScope(jjtn001,  2);
1250                                                       jjtreeCloseNodeScope(jjtn001);
1251                                                     }
1252                                                   }
1253/*@egen*/
1254  )*
1255}
1256
1257void MultiplicativeExpression() :
1258{ Token t = null; }
1259{
1260  UnaryExpression() ( ( t= "*" | t= "/" | t= "%" )
1261  UnaryExpression()/*@bgen(jjtree) #BinaryExpression( 2) */
1262                    {
1263                      BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1264                      boolean jjtc001 = true;
1265                      jjtree.openNodeScope(jjtn001);
1266                      jjtreeOpenNodeScope(jjtn001);
1267                    }
1268                    try {
1269/*@egen*//*@bgen(jjtree)*/
1270                    {
1271                      jjtree.closeNodeScope(jjtn001,  2);
1272                      jjtc001 = false;
1273                      jjtreeCloseNodeScope(jjtn001);
1274                    }
1275/*@egen*/ { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1276                    } finally {
1277                      if (jjtc001) {
1278                        jjtree.closeNodeScope(jjtn001,  2);
1279                        jjtreeCloseNodeScope(jjtn001);
1280                      }
1281                    }
1282/*@egen*/ )*
1283}
1284
1285void UnaryExpression() :
1286{ Token t = null; }
1287{
1288  ( t="+" | t="-" ) UnaryExpression()/*@bgen(jjtree) #UnaryExpression( 1) */
1289    {
1290      BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1291      boolean jjtc001 = true;
1292      jjtree.openNodeScope(jjtn001);
1293      jjtreeOpenNodeScope(jjtn001);
1294    }
1295    try {
1296/*@egen*//*@bgen(jjtree)*/
1297    {
1298      jjtree.closeNodeScope(jjtn001,  1);
1299      jjtc001 = false;
1300      jjtreeCloseNodeScope(jjtn001);
1301    }
1302/*@egen*/
1303    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1304    } finally {
1305      if (jjtc001) {
1306        jjtree.closeNodeScope(jjtn001,  1);
1307        jjtreeCloseNodeScope(jjtn001);
1308      }
1309    }
1310/*@egen*/
1311|
1312  PreIncrementExpression()
1313|
1314  PreDecrementExpression()
1315|
1316  UnaryExpressionNotPlusMinus()
1317}
1318
1319void PreIncrementExpression() :
1320{ Token t = null; }
1321{
1322  t="++" LHSPrimaryExpression()/*@bgen(jjtree) #UnaryExpression( 1) */
1323    {
1324      BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1325      boolean jjtc001 = true;
1326      jjtree.openNodeScope(jjtn001);
1327      jjtreeOpenNodeScope(jjtn001);
1328    }
1329    try {
1330/*@egen*//*@bgen(jjtree)*/
1331    {
1332      jjtree.closeNodeScope(jjtn001,  1);
1333      jjtc001 = false;
1334      jjtreeCloseNodeScope(jjtn001);
1335    }
1336/*@egen*/
1337    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1338    } finally {
1339      if (jjtc001) {
1340        jjtree.closeNodeScope(jjtn001,  1);
1341        jjtreeCloseNodeScope(jjtn001);
1342      }
1343    }
1344/*@egen*/
1345}
1346
1347void PreDecrementExpression() :
1348{ Token t = null; }
1349{
1350  t="--" LHSPrimaryExpression()/*@bgen(jjtree) #UnaryExpression( 1) */
1351    {
1352      BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1353      boolean jjtc001 = true;
1354      jjtree.openNodeScope(jjtn001);
1355      jjtreeOpenNodeScope(jjtn001);
1356    }
1357    try {
1358/*@egen*//*@bgen(jjtree)*/
1359    {
1360      jjtree.closeNodeScope(jjtn001,  1);
1361      jjtc001 = false;
1362      jjtreeCloseNodeScope(jjtn001);
1363    }
1364/*@egen*/
1365    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1366    } finally {
1367      if (jjtc001) {
1368        jjtree.closeNodeScope(jjtn001,  1);
1369        jjtreeCloseNodeScope(jjtn001);
1370      }
1371    }
1372/*@egen*/
1373}
1374
1375void UnaryExpressionNotPlusMinus() :
1376{ Token t = null; }
1377{
1378  ( t="~" | t="!" ) UnaryExpression()/*@bgen(jjtree) #UnaryExpression( 1) */
1379    {
1380      BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1381      boolean jjtc001 = true;
1382      jjtree.openNodeScope(jjtn001);
1383      jjtreeOpenNodeScope(jjtn001);
1384    }
1385    try {
1386/*@egen*//*@bgen(jjtree)*/
1387    {
1388      jjtree.closeNodeScope(jjtn001,  1);
1389      jjtc001 = false;
1390      jjtreeCloseNodeScope(jjtn001);
1391    }
1392/*@egen*/
1393    { jjtn001.kind = t.kind; }/*@bgen(jjtree)*/
1394    } finally {
1395      if (jjtc001) {
1396        jjtree.closeNodeScope(jjtn001,  1);
1397        jjtreeCloseNodeScope(jjtn001);
1398      }
1399    }
1400/*@egen*/
1401|
1402	// SYNTACTIC_LOOKAHEAD
1403  LOOKAHEAD( CastLookahead() ) CastExpression()
1404|
1405  PostfixExpression()
1406}
1407
1408// This production is to determine lookahead only.
1409void CastLookahead() : { }
1410{
1411  LOOKAHEAD(2) "(" PrimitiveType()
1412|
1413// SYNTACTIC_LOOKAHEAD
1414  LOOKAHEAD( "(" AmbiguousName() "[" ) "(" AmbiguousName() "[" "]"
1415|
1416  "(" AmbiguousName() ")" ( "~" | "!" | "(" | <IDENTIFIER> | /* "this" | "super" | */ "new" | Literal() )
1417}
1418
1419void PostfixExpression() :
1420{ Token t = null; }
1421{
1422 (
1423// SYNTACTIC_LOOKAHEAD
1424  LOOKAHEAD( LHSPrimaryExpression() ("++"|"--") )
1425  LHSPrimaryExpression()
1426	  [ ( t="++" | t="--" )/*@bgen(jjtree) #UnaryExpression( 1) */
1427                                {
1428                                  BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1429                                  boolean jjtc001 = true;
1430                                  jjtree.openNodeScope(jjtn001);
1431                                  jjtreeOpenNodeScope(jjtn001);
1432                                }
1433                                try {
1434/*@egen*//*@bgen(jjtree)*/
1435                                {
1436                                  jjtree.closeNodeScope(jjtn001,  1);
1437                                  jjtc001 = false;
1438                                  jjtreeCloseNodeScope(jjtn001);
1439                                }
1440/*@egen*/ { 
1441		jjtn001.kind = t.kind; jjtn001.postfix = true; }/*@bgen(jjtree)*/
1442                                } finally {
1443                                  if (jjtc001) {
1444                                    jjtree.closeNodeScope(jjtn001,  1);
1445                                    jjtreeCloseNodeScope(jjtn001);
1446                                  }
1447                                }
1448/*@egen*/ ]
1449|
1450  PrimaryExpression()
1451 )
1452}
1453
1454void CastExpression()                 :
1455{/*@bgen(jjtree) CastExpression */
1456  BSHCastExpression jjtn000 = new BSHCastExpression(JJTCASTEXPRESSION);
1457  boolean jjtc000 = true;
1458  jjtree.openNodeScope(jjtn000);
1459  jjtreeOpenNodeScope(jjtn000);
1460/*@egen*/ }
1461{/*@bgen(jjtree) CastExpression */
1462  try {
1463/*@egen*/
1464// SYNTACTIC_LOOKAHEAD
1465  LOOKAHEAD( "(" PrimitiveType() ) "(" Type() ")" UnaryExpression()
1466|
1467  "(" Type() ")" UnaryExpressionNotPlusMinus()/*@bgen(jjtree)*/
1468  } catch (Throwable jjte000) {
1469    if (jjtc000) {
1470      jjtree.clearNodeScope(jjtn000);
1471      jjtc000 = false;
1472    } else {
1473      jjtree.popNode();
1474    }
1475    if (jjte000 instanceof RuntimeException) {
1476      throw (RuntimeException)jjte000;
1477    }
1478    if (jjte000 instanceof ParseException) {
1479      throw (ParseException)jjte000;
1480    }
1481    throw (Error)jjte000;
1482  } finally {
1483    if (jjtc000) {
1484      jjtree.closeNodeScope(jjtn000, true);
1485      jjtreeCloseNodeScope(jjtn000);
1486    }
1487  }
1488/*@egen*/
1489}
1490
1491void PrimaryExpression()                    : {/*@bgen(jjtree) PrimaryExpression */
1492  BSHPrimaryExpression jjtn000 = new BSHPrimaryExpression(JJTPRIMARYEXPRESSION);
1493  boolean jjtc000 = true;
1494  jjtree.openNodeScope(jjtn000);
1495  jjtreeOpenNodeScope(jjtn000);
1496/*@egen*/ }
1497{/*@bgen(jjtree) PrimaryExpression */
1498 try {
1499/*@egen*/
1500 PrimaryPrefix() ( PrimarySuffix() )*/*@bgen(jjtree)*/
1501 } catch (Throwable jjte000) {
1502   if (jjtc000) {
1503     jjtree.clearNodeScope(jjtn000);
1504     jjtc000 = false;
1505   } else {
1506     jjtree.popNode();
1507   }
1508   if (jjte000 instanceof RuntimeException) {
1509     throw (RuntimeException)jjte000;
1510   }
1511   if (jjte000 instanceof ParseException) {
1512     throw (ParseException)jjte000;
1513   }
1514   throw (Error)jjte000;
1515 } finally {
1516   if (jjtc000) {
1517     jjtree.closeNodeScope(jjtn000, true);
1518     jjtreeCloseNodeScope(jjtn000);
1519   }
1520 }
1521/*@egen*/
1522}
1523
1524// The MethodInvocation node here simplifies the prefix/suffix parsing a bit
1525//  by forcing the prefix to an object.
1526void PrimaryPrefix() : { }
1527{
1528  Literal()
1529|
1530  "(" Expression() ")"
1531|
1532  AllocationExpression()
1533|
1534// SYNTACTIC_LOOKAHEAD
1535  LOOKAHEAD( Type() "." "class" )
1536  Type()
1537|/*@bgen(jjtree) #MethodInvocation(> 1) */
1538  {
1539    BSHMethodInvocation jjtn001 = new BSHMethodInvocation(JJTMETHODINVOCATION);
1540    boolean jjtc001 = true;
1541    jjtree.openNodeScope(jjtn001);
1542    jjtreeOpenNodeScope(jjtn001);
1543  }
1544  try {
1545/*@egen*/
1546	/* 
1547		Handle method invocation OR straight ambigous name...
1548		(probably should just write this as two rules more clearly)
1549	*/ 
1550  ( AmbiguousName() [ Arguments() ]  )/*@bgen(jjtree)*/
1551  } catch (Throwable jjte001) {
1552    if (jjtc001) {
1553      jjtree.clearNodeScope(jjtn001);
1554      jjtc001 = false;
1555    } else {
1556      jjtree.popNode();
1557    }
1558    if (jjte001 instanceof RuntimeException) {
1559      throw (RuntimeException)jjte001;
1560    }
1561    if (jjte001 instanceof ParseException) {
1562      throw (ParseException)jjte001;
1563    }
1564    throw (Error)jjte001;
1565  } finally {
1566    if (jjtc001) {
1567      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1568      jjtreeCloseNodeScope(jjtn001);
1569    }
1570  }
1571/*@egen*/
1572
1573/*
1574|
1575  LOOKAHEAD( "void" "." "class" )
1576*/
1577}
1578
1579void PrimarySuffix()                :
1580{/*@bgen(jjtree) PrimarySuffix */
1581    BSHPrimarySuffix jjtn000 = new BSHPrimarySuffix(JJTPRIMARYSUFFIX);
1582    boolean jjtc000 = true;
1583    jjtree.openNodeScope(jjtn000);
1584    jjtreeOpenNodeScope(jjtn000);
1585/*@egen*/
1586    Token t = null;
1587}
1588{/*@bgen(jjtree) PrimarySuffix */
1589  try {
1590/*@egen*/
1591  LOOKAHEAD(2)
1592  "." "class"/*@bgen(jjtree)*/
1593              {
1594                jjtree.closeNodeScope(jjtn000, true);
1595                jjtc000 = false;
1596                jjtreeCloseNodeScope(jjtn000);
1597              }
1598/*@egen*/ {
1599        jjtn000.operation = BSHPrimarySuffix.CLASS;
1600    }
1601|
1602  "[" Expression() "]"/*@bgen(jjtree)*/
1603                       {
1604                         jjtree.closeNodeScope(jjtn000, true);
1605                         jjtc000 = false;
1606                         jjtreeCloseNodeScope(jjtn000);
1607                       }
1608/*@egen*/ {
1609        jjtn000.operation = BSHPrimarySuffix.INDEX;
1610    }
1611|
1612    // Field access or method invocation
1613  "." t = <IDENTIFIER> [ Arguments() ]/*@bgen(jjtree)*/
1614                                       {
1615                                         jjtree.closeNodeScope(jjtn000, true);
1616                                         jjtc000 = false;
1617                                         jjtreeCloseNodeScope(jjtn000);
1618                                       }
1619/*@egen*/ {
1620        jjtn000.operation = BSHPrimarySuffix.NAME;
1621        jjtn000.field = t.image;
1622    }
1623|
1624  "{" Expression() "}"/*@bgen(jjtree)*/
1625                       {
1626                         jjtree.closeNodeScope(jjtn000, true);
1627                         jjtc000 = false;
1628                         jjtreeCloseNodeScope(jjtn000);
1629                       }
1630/*@egen*/ {
1631        jjtn000.operation = BSHPrimarySuffix.PROPERTY;
1632    }/*@bgen(jjtree)*/
1633  } catch (Throwable jjte000) {
1634    if (jjtc000) {
1635      jjtree.clearNodeScope(jjtn000);
1636      jjtc000 = false;
1637    } else {
1638      jjtree.popNode();
1639    }
1640    if (jjte000 instanceof RuntimeException) {
1641      throw (RuntimeException)jjte000;
1642    }
1643    if (jjte000 instanceof ParseException) {
1644      throw (ParseException)jjte000;
1645    }
1646    throw (Error)jjte000;
1647  } finally {
1648    if (jjtc000) {
1649      jjtree.closeNodeScope(jjtn000, true);
1650      jjtreeCloseNodeScope(jjtn000);
1651    }
1652  }
1653/*@egen*/
1654/*
1655    For inner classes
1656|
1657  LOOKAHEAD(2)
1658  "." AllocationExpression()
1659*/
1660}
1661
1662
1663/*
1664	Begin LHS part of the grammar --
1665
1666	The reason this stuff is duplicated (e.g. LHSPrimaryPrefix and 
1667	PrimaryPrefix) is that the whole grammar splits based on whether we 
1668	are preparig to do an assignment or not.  This is an important issue 
1669	to revisit in the future.
1670*/
1671/**
1672	The method invocation is here to force this to an object type in order 
1673	to simplify the suffix processing.  
1674*/
1675void LHSPrimaryPrefix() : { }
1676{/*@bgen(jjtree) #MethodInvocation(> 1) */
1677  {
1678    BSHMethodInvocation jjtn001 = new BSHMethodInvocation(JJTMETHODINVOCATION);
1679    boolean jjtc001 = true;
1680    jjtree.openNodeScope(jjtn001);
1681    jjtreeOpenNodeScope(jjtn001);
1682  }
1683  try {
1684/*@egen*/
1685	/* 
1686		Method invocation or simple ambiguous name.
1687		(probably should just write this as two rules more clearly)
1688	*/ 
1689  ( AmbiguousName() [ Arguments() ]  )/*@bgen(jjtree)*/
1690  } catch (Throwable jjte001) {
1691    if (jjtc001) {
1692      jjtree.clearNodeScope(jjtn001);
1693      jjtc001 = false;
1694    } else {
1695      jjtree.popNode();
1696    }
1697    if (jjte001 instanceof RuntimeException) {
1698      throw (RuntimeException)jjte001;
1699    }
1700    if (jjte001 instanceof ParseException) {
1701      throw (ParseException)jjte001;
1702    }
1703    throw (Error)jjte001;
1704  } finally {
1705    if (jjtc001) {
1706      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1707      jjtreeCloseNodeScope(jjtn001);
1708    }
1709  }
1710/*@egen*/
1711}
1712
1713void LHSPrimaryExpression()                       : {/*@bgen(jjtree) LHSPrimaryExpression */
1714  BSHLHSPrimaryExpression jjtn000 = new BSHLHSPrimaryExpression(JJTLHSPRIMARYEXPRESSION);
1715  boolean jjtc000 = true;
1716  jjtree.openNodeScope(jjtn000);
1717  jjtreeOpenNodeScope(jjtn000);
1718/*@egen*/ }
1719{/*@bgen(jjtree) LHSPrimaryExpression */
1720  try {
1721/*@egen*/
1722  LHSPrimaryPrefix() ( LHSPrimarySuffix( ) )*/*@bgen(jjtree)*/
1723  } catch (Throwable jjte000) {
1724    if (jjtc000) {
1725      jjtree.clearNodeScope(jjtn000);
1726      jjtc000 = false;
1727    } else {
1728      jjtree.popNode();
1729    }
1730    if (jjte000 instanceof RuntimeException) {
1731      throw (RuntimeException)jjte000;
1732    }
1733    if (jjte000 instanceof ParseException) {
1734      throw (ParseException)jjte000;
1735    }
1736    throw (Error)jjte000;
1737  } finally {
1738    if (jjtc000) {
1739      jjtree.closeNodeScope(jjtn000, true);
1740      jjtreeCloseNodeScope(jjtn000);
1741    }
1742  }
1743/*@egen*/
1744}
1745
1746void LHSPrimarySuffix()                   :
1747{/*@bgen(jjtree) LHSPrimarySuffix */
1748    BSHLHSPrimarySuffix jjtn000 = new BSHLHSPrimarySuffix(JJTLHSPRIMARYSUFFIX);
1749    boolean jjtc000 = true;
1750    jjtree.openNodeScope(jjtn000);
1751    jjtreeOpenNodeScope(jjtn000);
1752/*@egen*/
1753    Token t=null, t1, t2 = null;
1754}
1755{/*@bgen(jjtree) LHSPrimarySuffix */
1756  try {
1757/*@egen*/
1758    // Indexed to a field
1759  "[" Expression() "]"/*@bgen(jjtree)*/
1760                       {
1761                         jjtree.closeNodeScope(jjtn000, true);
1762                         jjtc000 = false;
1763                         jjtreeCloseNodeScope(jjtn000);
1764                       }
1765/*@egen*/ {
1766        jjtn000.operation = BSHLHSPrimarySuffix.INDEX;
1767    }
1768|
1769    // Field access or method invocation followed by field access
1770  "." t1 = <IDENTIFIER> [ Arguments() "." t2 = <IDENTIFIER> ]/*@bgen(jjtree)*/
1771                                                              {
1772                                                                jjtree.closeNodeScope(jjtn000, true);
1773                                                                jjtc000 = false;
1774                                                                jjtreeCloseNodeScope(jjtn000);
1775                                                              }
1776/*@egen*/ {
1777        jjtn000.operation = BSHLHSPrimarySuffix.NAME;
1778        if ( t2 == null )
1779            jjtn000.field = t1.image;
1780        else {
1781            jjtn000.method = t1.image;
1782            jjtn000.field = t2.image;
1783        }
1784    }
1785|
1786  "{" Expression() "}"/*@bgen(jjtree)*/
1787                       {
1788                         jjtree.closeNodeScope(jjtn000, true);
1789                         jjtc000 = false;
1790                         jjtreeCloseNodeScope(jjtn000);
1791                       }
1792/*@egen*/ {
1793        jjtn000.operation = BSHLHSPrimarySuffix.PROPERTY;
1794    }/*@bgen(jjtree)*/
1795  } catch (Throwable jjte000) {
1796    if (jjtc000) {
1797      jjtree.clearNodeScope(jjtn000);
1798      jjtc000 = false;
1799    } else {
1800      jjtree.popNode();
1801    }
1802    if (jjte000 instanceof RuntimeException) {
1803      throw (RuntimeException)jjte000;
1804    }
1805    if (jjte000 instanceof ParseException) {
1806      throw (ParseException)jjte000;
1807    }
1808    throw (Error)jjte000;
1809  } finally {
1810    if (jjtc000) {
1811      jjtree.closeNodeScope(jjtn000, true);
1812      jjtreeCloseNodeScope(jjtn000);
1813    }
1814  }
1815/*@egen*/
1816}
1817
1818/*
1819	-- End LHS part of the grammar
1820*/
1821
1822void Literal()          :
1823{/*@bgen(jjtree) Literal */
1824    BSHLiteral jjtn000 = new BSHLiteral(JJTLITERAL);
1825    boolean jjtc000 = true;
1826    jjtree.openNodeScope(jjtn000);
1827    jjtreeOpenNodeScope(jjtn000);
1828/*@egen*/
1829    Token x;
1830    boolean b;
1831    String literal;
1832    char ch;
1833}
1834{/*@bgen(jjtree) Literal */
1835  try {
1836/*@egen*/
1837  x = <INTEGER_LITERAL>/*@bgen(jjtree)*/
1838  {
1839    jjtree.closeNodeScope(jjtn000, true);
1840    jjtc000 = false;
1841    jjtreeCloseNodeScope(jjtn000);
1842  }
1843/*@egen*/
1844  {
1845    literal = x.image;
1846    ch = literal.charAt(literal.length()-1);
1847    if(ch == 'l' || ch == 'L')
1848    {
1849        literal = literal.substring(0,literal.length()-1);
1850
1851        // This really should be Long.decode, but there isn't one. As a result,
1852        // hex and octal literals ending in 'l' or 'L' don't work.
1853        jjtn000.value = new Primitive( new Long( literal ) );
1854    }
1855    else
1856        jjtn000.value = new Primitive( Integer.decode( literal ) );
1857  }
1858|
1859  x = <FLOATING_POINT_LITERAL>/*@bgen(jjtree)*/
1860  {
1861    jjtree.closeNodeScope(jjtn000, true);
1862    jjtc000 = false;
1863    jjtreeCloseNodeScope(jjtn000);
1864  }
1865/*@egen*/
1866  {
1867    literal = x.image;
1868    ch = literal.charAt(literal.length()-1);
1869    if(ch == 'f' || ch == 'F')
1870    {
1871        literal = literal.substring(0,literal.length()-1);
1872        jjtn000.value = new Primitive( new Float( literal ) );
1873    }
1874    else
1875    {
1876        if(ch == 'd' || ch == 'D')
1877            literal = literal.substring(0,literal.length()-1);
1878
1879        jjtn000.value = new Primitive( new Double( literal ) );
1880    }
1881  }
1882|
1883  x = <CHARACTER_LITERAL>/*@bgen(jjtree)*/
1884                          {
1885                            jjtree.closeNodeScope(jjtn000, true);
1886                            jjtc000 = false;
1887                            jjtreeCloseNodeScope(jjtn000);
1888                          }
1889/*@egen*/ {
1890		try {
1891    		jjtn000.charSetup( x.image.substring(1, x.image.length() - 1) );
1892		} catch ( Exception e ) {
1893			throw new ParseException("Error parsing character: "+x.image);
1894		}
1895    }
1896|
1897  x = <STRING_LITERAL>/*@bgen(jjtree)*/
1898                       {
1899                         jjtree.closeNodeScope(jjtn000, true);
1900                         jjtc000 = false;
1901                         jjtreeCloseNodeScope(jjtn000);
1902                       }
1903/*@egen*/ {
1904		try {
1905			jjtn000.stringSetup( x.image.substring(1, x.image.length() - 1) );
1906		} catch ( Exception e ) {
1907			throw new ParseException("Error parsing string: "+x.image);
1908		}
1909    }
1910|
1911  b = BooleanLiteral()/*@bgen(jjtree)*/
1912                        {
1913                          jjtree.closeNodeScope(jjtn000, true);
1914                          jjtc000 = false;
1915                          jjtreeCloseNodeScope(jjtn000);
1916                        }
1917/*@egen*/  {
1918    jjtn000.value = new Primitive( new Boolean(b) ); }
1919|
1920  NullLiteral()/*@bgen(jjtree)*/
1921                {
1922                  jjtree.closeNodeScope(jjtn000, true);
1923                  jjtc000 = false;
1924                  jjtreeCloseNodeScope(jjtn000);
1925                }
1926/*@egen*/ {
1927    jjtn000.value = Primitive.NULL; 
1928}
1929|
1930 VoidLiteral()/*@bgen(jjtree)*/
1931               {
1932                 jjtree.closeNodeScope(jjtn000, true);
1933                 jjtc000 = false;
1934                 jjtreeCloseNodeScope(jjtn000);
1935               }
1936/*@egen*/ {
1937    jjtn000.value = Primitive.VOID; }/*@bgen(jjtree)*/
1938  } catch (Throwable jjte000) {
1939    if (jjtc000) {
1940      jjtree.clearNodeScope(jjtn000);
1941      jjtc000 = false;
1942    } else {
1943      jjtree.popNode();
1944    }
1945    if (jjte000 instanceof RuntimeException) {
1946      throw (RuntimeException)jjte000;
1947    }
1948    if (jjte000 instanceof ParseException) {
1949      throw (ParseException)jjte000;
1950    }
1951    throw (Error)jjte000;
1952  } finally {
1953    if (jjtc000) {
1954      jjtree.closeNodeScope(jjtn000, true);
1955      jjtreeCloseNodeScope(jjtn000);
1956    }
1957  }
1958/*@egen*/
1959}
1960
1961boolean BooleanLiteral() :
1962{}
1963{
1964  "true" { return true; }
1965|
1966  "false" { return false; }
1967}
1968
1969void NullLiteral() :
1970{}
1971{
1972  "null"
1973}
1974
1975void VoidLiteral() :
1976{}
1977{
1978  "void"
1979}
1980
1981void Arguments()            :
1982{/*@bgen(jjtree) Arguments */
1983  BSHArguments jjtn000 = new BSHArguments(JJTARGUMENTS);
1984  boolean jjtc000 = true;
1985  jjtree.openNodeScope(jjtn000);
1986  jjtreeOpenNodeScope(jjtn000);
1987/*@egen*/ }
1988{/*@bgen(jjtree) Arguments */
1989  try {
1990/*@egen*/
1991  "(" [ ArgumentList()  ]  ")"/*@bgen(jjtree)*/
1992  } catch (Throwable jjte000) {
1993    if (jjtc000) {
1994      jjtree.clearNodeScope(jjtn000);
1995      jjtc000 = false;
1996    } else {
1997      jjtree.popNode();
1998    }
1999    if (jjte000 instanceof RuntimeException) {
2000      throw (RuntimeException)jjte000;
2001    }
2002    if (jjte000 instanceof ParseException) {
2003      throw (ParseException)jjte000;
2004    }
2005    throw (Error)jjte000;
2006  } finally {
2007    if (jjtc000) {
2008      jjtree.closeNodeScope(jjtn000, true);
2009      jjtreeCloseNodeScope(jjtn000);
2010    }
2011  }
2012/*@egen*/
2013}
2014
2015// leave these on the stack for Arguments() to handle
2016void ArgumentList() :
2017{ }
2018{
2019  Expression()
2020  ( "," Expression() )*
2021}
2022
2023void AllocationExpression()                       :
2024{/*@bgen(jjtree) AllocationExpression */
2025  BSHAllocationExpression jjtn000 = new BSHAllocationExpression(JJTALLOCATIONEXPRESSION);
2026  boolean jjtc000 = true;
2027  jjtree.openNodeScope(jjtn000);
2028  jjtreeOpenNodeScope(jjtn000);
2029/*@egen*/ }
2030{/*@bgen(jjtree) AllocationExpression */
2031  try {
2032/*@egen*/
2033  LOOKAHEAD(2)
2034  "new" PrimitiveType() ArrayDimensions()
2035|
2036  "new" AmbiguousName() 
2037	( 
2038		ArrayDimensions() 
2039	| 
2040		// SYNTACTIC_LOOKAHEAD
2041		Arguments() [ LOOKAHEAD(2) Block() ]
2042	)/*@bgen(jjtree)*/
2043  } catch (Throwable jjte000) {
2044    if (jjtc000) {
2045      jjtree.clearNodeScope(jjtn000);
2046      jjtc000 = false;
2047    } else {
2048      jjtree.popNode();
2049    }
2050    if (jjte000 instanceof RuntimeException) {
2051      throw (RuntimeException)jjte000;
2052    }
2053    if (jjte000 instanceof ParseException) {
2054      throw (ParseException)jjte000;
2055    }
2056    throw (Error)jjte000;
2057  } finally {
2058    if (jjtc000) {
2059      jjtree.closeNodeScope(jjtn000, true);
2060      jjtreeCloseNodeScope(jjtn000);
2061    }
2062  }
2063/*@egen*/
2064}
2065
2066void ArrayDimensions()                  :
2067{/*@bgen(jjtree) ArrayDimensions */
2068  BSHArrayDimensions jjtn000 = new BSHArrayDimensions(JJTARRAYDIMENSIONS);
2069  boolean jjtc000 = true;
2070  jjtree.openNodeScope(jjtn000);
2071  jjtreeOpenNodeScope(jjtn000);
2072/*@egen*/}
2073{/*@bgen(jjtree) ArrayDimensions */
2074  try {
2075/*@egen*/
2076  LOOKAHEAD(2)
2077  ( LOOKAHEAD(2) "[" Expression() "]" { jjtn000.addArrayDimension(); } )+
2078  // Removed trailing "[]" identifiers.  Specify array dims fully.
2079|
2080  ( "[" "]" { jjtn000.addArrayDimension(); } )+ ArrayInitializer()/*@bgen(jjtree)*/
2081  } catch (Throwable jjte000) {
2082    if (jjtc000) {
2083      jjtree.clearNodeScope(jjtn000);
2084      jjtc000 = false;
2085    } else {
2086      jjtree.popNode();
2087    }
2088    if (jjte000 instanceof RuntimeException) {
2089      throw (RuntimeException)jjte000;
2090    }
2091    if (jjte000 instanceof ParseException) {
2092      throw (ParseException)jjte000;
2093    }
2094    throw (Error)jjte000;
2095  } finally {
2096    if (jjtc000) {
2097      jjtree.closeNodeScope(jjtn000, true);
2098      jjtreeCloseNodeScope(jjtn000);
2099    }
2100  }
2101/*@egen*/
2102}
2103
2104
2105/*
2106 * Statement syntax follows.
2107 */
2108
2109void Statement() : { }
2110{
2111  LOOKAHEAD(2)
2112  LabeledStatement()
2113|
2114  Block()
2115|
2116  EmptyStatement()
2117|
2118  StatementExpression() ";"
2119|
2120  SwitchStatement()
2121|
2122  IfStatement()
2123|
2124  WhileStatement()
2125|
2126  DoStatement()
2127|
2128  ForStatement()
2129|
2130  BreakStatement()
2131|
2132  ContinueStatement()
2133|
2134  ReturnStatement()
2135|
2136  ThrowStatement()
2137|
2138  TryStatement()
2139}
2140
2141void LabeledStatement() :
2142{}
2143{
2144  <IDENTIFIER> ":" Statement()
2145}
2146
2147void Block()        :
2148{/*@bgen(jjtree) Block */
2149  BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
2150  boolean jjtc000 = true;
2151  jjtree.openNodeScope(jjtn000);
2152  jjtreeOpenNodeScope(jjtn000);
2153/*@egen*/}
2154{/*@bgen(jjtree) Block */
2155  try {
2156/*@egen*/
2157  "{" ( BlockStatement() )* "}"/*@bgen(jjtree)*/
2158  } catch (Throwable jjte000) {
2159    if (jjtc000) {
2160      jjtree.clearNodeScope(jjtn000);
2161      jjtc000 = false;
2162    } else {
2163      jjtree.popNode();
2164    }
2165    if (jjte000 instanceof RuntimeException) {
2166      throw (RuntimeException)jjte000;
2167    }
2168    if (jjte000 instanceof ParseException) {
2169      throw (ParseException)jjte000;
2170    }
2171    throw (Error)jjte000;
2172  } finally {
2173    if (jjtc000) {
2174      jjtree.closeNodeScope(jjtn000, true);
2175      jjtreeCloseNodeScope(jjtn000);
2176    }
2177  }
2178/*@egen*/
2179}
2180
2181void BlockStatement() :
2182{}
2183{
2184// SYNTACTIC_LOOKAHEAD
2185  LOOKAHEAD( MethodDeclarationLookahead() ) MethodDeclaration()
2186|
2187// SYNTACTIC_LOOKAHEAD
2188  LOOKAHEAD([ "final" ] Type() <IDENTIFIER>)
2189  TypedVariableDeclaration() ";"
2190|
2191  Statement()
2192
2193/* end */
2194
2195|  
2196  // Allow BeanShell imports in any block
2197  ImportDeclaration()
2198}
2199
2200void EmptyStatement() :
2201{}
2202{
2203  ";"
2204}
2205
2206void StatementExpression() :
2207/*
2208 * The last expansion of this production accepts more than the legal
2209 * Java expansions for StatementExpression.
2210 */
2211{ }
2212{
2213  PreIncrementExpression()
2214|
2215  PreDecrementExpression()
2216|
2217// SYNTACTIC_LOOKAHEAD
2218  LOOKAHEAD( PrimaryExpression() AssignmentOperator() )
2219  Assignment() { }
2220|
2221  PostfixExpression()
2222}
2223
2224void SwitchStatement()                  :
2225{/*@bgen(jjtree) SwitchStatement */
2226  BSHSwitchStatement jjtn000 = new BSHSwitchStatement(JJTSWITCHSTATEMENT);
2227  boolean jjtc000 = true;
2228  jjtree.openNodeScope(jjtn000);
2229  jjtreeOpenNodeScope(jjtn000);
2230/*@egen*/}
2231{/*@bgen(jjtree) SwitchStatement */
2232  try {
2233/*@egen*/
2234  "switch" "(" Expression() ")" "{"
2235    ( SwitchLabel() ( BlockStatement() )* )*
2236  "}"/*@bgen(jjtree)*/
2237  } catch (Throwable jjte000) {
2238    if (jjtc000) {
2239      jjtree.clearNodeScope(jjtn000);
2240      jjtc000 = false;
2241    } else {
2242      jjtree.popNode();
2243    }
2244    if (jjte000 instanceof RuntimeException) {
2245      throw (RuntimeException)jjte000;
2246    }
2247    if (jjte000 instanceof ParseException) {
2248      throw (ParseException)jjte000;
2249    }
2250    throw (Error)jjte000;
2251  } finally {
2252    if (jjtc000) {
2253      jjtree.closeNodeScope(jjtn000, true);
2254      jjtreeCloseNodeScope(jjtn000);
2255    }
2256  }
2257/*@egen*/
2258}
2259
2260void SwitchLabel()              :
2261{/*@bgen(jjtree) SwitchLabel */
2262  BSHSwitchLabel jjtn000 = new BSHSwitchLabel(JJTSWITCHLABEL);
2263  boolean jjtc000 = true;
2264  jjtree.openNodeScope(jjtn000);
2265  jjtreeOpenNodeScope(jjtn000);
2266/*@egen*/}
2267{/*@bgen(jjtree) SwitchLabel */
2268  try {
2269/*@egen*/
2270  "case" Expression() ":"
2271|
2272  "default" ":"/*@bgen(jjtree)*/
2273                {
2274                  jjtree.closeNodeScope(jjtn000, true);
2275                  jjtc000 = false;
2276                  jjtreeCloseNodeScope(jjtn000);
2277                }
2278/*@egen*/ { jjtn000.isDefault = true; }/*@bgen(jjtree)*/
2279  } catch (Throwable jjte000) {
2280    if (jjtc000) {
2281      jjtree.clearNodeScope(jjtn000);
2282      jjtc000 = false;
2283    } else {
2284      jjtree.popNode();
2285    }
2286    if (jjte000 instanceof RuntimeException) {
2287      throw (RuntimeException)jjte000;
2288    }
2289    if (jjte000 instanceof ParseException) {
2290      throw (ParseException)jjte000;
2291    }
2292    throw (Error)jjte000;
2293  } finally {
2294    if (jjtc000) {
2295      jjtree.closeNodeScope(jjtn000, true);
2296      jjtreeCloseNodeScope(jjtn000);
2297    }
2298  }
2299/*@egen*/
2300}
2301
2302void IfStatement()              :
2303/*
2304 * The disambiguating algorithm of JavaCC automatically binds dangling
2305 * else's to the innermost if statement.  The LOOKAHEAD specification
2306 * is to tell JavaCC that we know what we are doing.
2307 */
2308{/*@bgen(jjtree) IfStatement */
2309  BSHIfStatement jjtn000 = new BSHIfStatement(JJTIFSTATEMENT);
2310  boolean jjtc000 = true;
2311  jjtree.openNodeScope(jjtn000);
2312  jjtreeOpenNodeScope(jjtn000);
2313/*@egen*/}
2314{/*@bgen(jjtree) IfStatement */
2315  try {
2316/*@egen*/
2317  "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" Statement() ]/*@bgen(jjtree)*/
2318  } catch (Throwable jjte000) {
2319    if (jjtc000) {
2320      jjtree.clearNodeScope(jjtn000);
2321      jjtc000 = false;
2322    } else {
2323      jjtree.popNode();
2324    }
2325    if (jjte000 instanceof RuntimeException) {
2326      throw (RuntimeException)jjte000;
2327    }
2328    if (jjte000 instanceof ParseException) {
2329      throw (ParseException)jjte000;
2330    }
2331    throw (Error)jjte000;
2332  } finally {
2333    if (jjtc000) {
2334      jjtree.closeNodeScope(jjtn000, true);
2335      jjtreeCloseNodeScope(jjtn000);
2336    }
2337  }
2338/*@egen*/
2339}
2340
2341void WhileStatement()                 :
2342{/*@bgen(jjtree) WhileStatement */
2343  BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2344  boolean jjtc000 = true;
2345  jjtree.openNodeScope(jjtn000);
2346  jjtreeOpenNodeScope(jjtn000);
2347/*@egen*/}
2348{/*@bgen(jjtree) WhileStatement */
2349  try {
2350/*@egen*/
2351  "while" "(" Expression() ")" Statement()/*@bgen(jjtree)*/
2352  } catch (Throwable jjte000) {
2353    if (jjtc000) {
2354      jjtree.clearNodeScope(jjtn000);
2355      jjtc000 = false;
2356    } else {
2357      jjtree.popNode();
2358    }
2359    if (jjte000 instanceof RuntimeException) {
2360      throw (RuntimeException)jjte000;
2361    }
2362    if (jjte000 instanceof ParseException) {
2363      throw (ParseException)jjte000;
2364    }
2365    throw (Error)jjte000;
2366  } finally {
2367    if (jjtc000) {
2368      jjtree.closeNodeScope(jjtn000, true);
2369      jjtreeCloseNodeScope(jjtn000);
2370    }
2371  }
2372/*@egen*/
2373}
2374
2375/*
2376	Do statement is just a While statement with a special hook to execute
2377	at least once.
2378*/
2379void DoStatement()                 :
2380{/*@bgen(jjtree) WhileStatement */
2381  BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2382  boolean jjtc000 = true;
2383  jjtree.openNodeScope(jjtn000);
2384  jjtreeOpenNodeScope(jjtn000);
2385/*@egen*/}
2386{/*@bgen(jjtree) WhileStatement */
2387  try {
2388/*@egen*/
2389  "do" Statement() "while" "(" Expression() ")" ";"/*@bgen(jjtree)*/
2390        {
2391          jjtree.closeNodeScope(jjtn000, true);
2392          jjtc000 = false;
2393          jjtreeCloseNodeScope(jjtn000);
2394        }
2395/*@egen*/ 
2396	{ jjtn000.isDoStatement=true;  }/*@bgen(jjtree)*/
2397  } catch (Throwable jjte000) {
2398    if (jjtc000) {
2399      jjtree.clearNodeScope(jjtn000);
2400      jjtc000 = false;
2401    } else {
2402      jjtree.popNode();
2403    }
2404    if (jjte000 instanceof RuntimeException) {
2405      throw (RuntimeException)jjte000;
2406    }
2407    if (jjte000 instanceof ParseException) {
2408      throw (ParseException)jjte000;
2409    }
2410    throw (Error)jjte000;
2411  } finally {
2412    if (jjtc000) {
2413      jjtree.closeNodeScope(jjtn000, true);
2414      jjtreeCloseNodeScope(jjtn000);
2415    }
2416  }
2417/*@egen*/
2418}
2419
2420void ForStatement()               :
2421{/*@bgen(jjtree) ForStatement */
2422  BSHForStatement jjtn000 = new BSHForStatement(JJTFORSTATEMENT);
2423  boolean jjtc000 = true;
2424  jjtree.openNo