0001: /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
0002: package org.gjt.sp.jedit.bsh;
0003:
0004: import java.io.*;
0005:
0006: /**
0007: This is the BeanShell parser. It is used internally by the Interpreter
0008: class (which is probably what you are looking for). The parser knows
0009: only how to parse the structure of the language, it does not understand
0010: names, commands, etc.
0011: <p>
0012: You can use the Parser from the command line to do basic structural
0013: validation of BeanShell files without actually executing them. e.g.
0014: <code><pre>
0015: java bsh.Parser [ -p ] file [ file ] [ ... ]
0016: </pre></code>
0017: <p>
0018: The -p option causes the abstract syntax to be printed.
0019: <p>
0020:
0021: From code you'd use the Parser like this:
0022: <p
0023: <code><pre>
0024: Parser parser = new Parser(in);
0025: while( !(eof=parser.Line()) ) {
0026: SimpleNode node = parser.popNode();
0027: // use the node, etc. (See bsh.BSH* classes)
0028: }
0029: </pre></code>
0030: */
0031: public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants,
0032: ParserConstants {/*@bgen(jjtree)*/
0033: protected JJTParserState jjtree = new JJTParserState();
0034: boolean retainComments = false;
0035:
0036: public void setRetainComments(boolean b) {
0037: retainComments = b;
0038: }
0039:
0040: void jjtreeOpenNodeScope(Node n) {
0041: ((SimpleNode) n).firstToken = getToken(1);
0042: }
0043:
0044: void jjtreeCloseNodeScope(Node n) {
0045: ((SimpleNode) n).lastToken = getToken(0);
0046: }
0047:
0048: /**
0049: Re-initialize the input stream and token source.
0050: */
0051: void reInitInput(Reader in) {
0052: ReInit(in);
0053: }
0054:
0055: public SimpleNode popNode() {
0056: if (jjtree.nodeArity() > 0) // number of child nodes
0057: return (SimpleNode) jjtree.popNode();
0058: else
0059: return null;
0060: }
0061:
0062: /**
0063: Explicitly re-initialize just the token reader.
0064: This seems to be necessary to avoid certain looping errors when
0065: reading bogus input. See Interpreter.
0066: */
0067: void reInitTokenInput(Reader in) {
0068: jj_input_stream.ReInit(in, jj_input_stream.getEndLine(),
0069: jj_input_stream.getEndColumn());
0070: }
0071:
0072: public static void main(String[] args) throws IOException,
0073: ParseException {
0074: boolean print = false;
0075: int i = 0;
0076: if (args[0].equals("-p")) {
0077: i++;
0078: print = true;
0079: }
0080: for (; i < args.length; i++) {
0081: Reader in = new FileReader(args[i]);
0082: Parser parser = new Parser(in);
0083: parser.setRetainComments(true);
0084: while (!parser.Line()/*eof*/)
0085: if (print)
0086: System.out.println(parser.popNode());
0087: }
0088: }
0089:
0090: /**
0091: Lookahead for the enhanced for statement.
0092: Expect "for" "(" and then see whether we hit ":" or a ";" first.
0093: */
0094: boolean isRegularForStatement() {
0095: int curTok = 1;
0096: Token tok;
0097: tok = getToken(curTok++);
0098: if (tok.kind != FOR)
0099: return false;
0100: tok = getToken(curTok++);
0101: if (tok.kind != LPAREN)
0102: return false;
0103: while (true) {
0104: tok = getToken(curTok++);
0105: switch (tok.kind) {
0106: case COLON:
0107: return false;
0108: case SEMICOLON:
0109: return true;
0110: case EOF:
0111: return false;
0112: }
0113: }
0114: }
0115:
0116: /**
0117: Generate a ParseException with the specified message, pointing to the
0118: current token.
0119: The auto-generated Parser.generateParseException() method does not
0120: provide line number info, therefore we do this.
0121: */
0122: ParseException createParseException(String message) {
0123: Token errortok = token;
0124: int line = errortok.beginLine, column = errortok.beginColumn;
0125: String mess = (errortok.kind == 0) ? tokenImage[0]
0126: : errortok.image;
0127: return new ParseException("Parse error at line " + line
0128: + ", column " + column + " : " + message);
0129: }
0130:
0131: /*
0132: Thanks to Sreenivasa Viswanadha for suggesting how to get rid of expensive
0133: lookahead here.
0134: */
0135: final public boolean Line() throws ParseException {
0136: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0137: case 0:
0138: jj_consume_token(0);
0139: Interpreter.debug("End of File!");
0140: {
0141: if (true)
0142: return true;
0143: }
0144: break;
0145: default:
0146: if (jj_2_1(1)) {
0147: BlockStatement();
0148: {
0149: if (true)
0150: return false;
0151: }
0152: } else {
0153: jj_consume_token(-1);
0154: throw new ParseException();
0155: }
0156: }
0157: throw new Error("Missing return statement in function");
0158: }
0159:
0160: /*****************************************
0161: * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
0162: *****************************************/
0163:
0164: /*
0165: Gather modifiers for a class, method, or field.
0166: I lookahead is true then we are being called as part of a lookahead and we
0167: should not enforce any rules. Otherwise we validate based on context
0168: (field, method, class)
0169: */
0170: final public Modifiers Modifiers(int context, boolean lookahead)
0171: throws ParseException {
0172: Modifiers mods = null;
0173: label_1: while (true) {
0174: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0175: case ABSTRACT:
0176: case FINAL:
0177: case NATIVE:
0178: case PRIVATE:
0179: case PROTECTED:
0180: case PUBLIC:
0181: case STATIC:
0182: case STRICTFP:
0183: case SYNCHRONIZED:
0184: case TRANSIENT:
0185: case VOLATILE:
0186: ;
0187: break;
0188: default:
0189: break label_1;
0190: }
0191: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0192: case PRIVATE:
0193: jj_consume_token(PRIVATE);
0194: break;
0195: case PROTECTED:
0196: jj_consume_token(PROTECTED);
0197: break;
0198: case PUBLIC:
0199: jj_consume_token(PUBLIC);
0200: break;
0201: case SYNCHRONIZED:
0202: jj_consume_token(SYNCHRONIZED);
0203: break;
0204: case FINAL:
0205: jj_consume_token(FINAL);
0206: break;
0207: case NATIVE:
0208: jj_consume_token(NATIVE);
0209: break;
0210: case TRANSIENT:
0211: jj_consume_token(TRANSIENT);
0212: break;
0213: case VOLATILE:
0214: jj_consume_token(VOLATILE);
0215: break;
0216: case ABSTRACT:
0217: jj_consume_token(ABSTRACT);
0218: break;
0219: case STATIC:
0220: jj_consume_token(STATIC);
0221: break;
0222: case STRICTFP:
0223: jj_consume_token(STRICTFP);
0224: break;
0225: default:
0226: jj_consume_token(-1);
0227: throw new ParseException();
0228: }
0229: if (!lookahead)
0230: try {
0231: if (mods == null)
0232: mods = new Modifiers();
0233: mods.addModifier(context, getToken(0).image);
0234: } catch (IllegalStateException e) {
0235: {
0236: if (true)
0237: throw createParseException(e.getMessage());
0238: }
0239: }
0240: }
0241: {
0242: if (true)
0243: return mods;
0244: }
0245: throw new Error("Missing return statement in function");
0246: }
0247:
0248: /**
0249: */
0250: final public void ClassDeclaration() throws ParseException {
0251: /*@bgen(jjtree) ClassDeclaration */
0252: BSHClassDeclaration jjtn000 = new BSHClassDeclaration(
0253: JJTCLASSDECLARATION);
0254: boolean jjtc000 = true;
0255: jjtree.openNodeScope(jjtn000);
0256: jjtreeOpenNodeScope(jjtn000);
0257: Modifiers mods;
0258: Token name;
0259: int numInterfaces;
0260: try {
0261: mods = Modifiers(Modifiers.CLASS, false);
0262: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0263: case CLASS:
0264: jj_consume_token(CLASS);
0265: break;
0266: case INTERFACE:
0267: jj_consume_token(INTERFACE);
0268: jjtn000.isInterface = true;
0269: break;
0270: default:
0271: jj_consume_token(-1);
0272: throw new ParseException();
0273: }
0274: name = jj_consume_token(IDENTIFIER);
0275: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0276: case EXTENDS:
0277: jj_consume_token(EXTENDS);
0278: AmbiguousName();
0279: jjtn000.extend = true;
0280: break;
0281: default:
0282: ;
0283: }
0284: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0285: case IMPLEMENTS:
0286: jj_consume_token(IMPLEMENTS);
0287: numInterfaces = NameList();
0288: jjtn000.numInterfaces = numInterfaces;
0289: break;
0290: default:
0291: ;
0292: }
0293: Block();
0294: jjtree.closeNodeScope(jjtn000, true);
0295: jjtc000 = false;
0296: jjtreeCloseNodeScope(jjtn000);
0297: jjtn000.modifiers = mods;
0298: jjtn000.name = name.image;
0299: } catch (Throwable jjte000) {
0300: if (jjtc000) {
0301: jjtree.clearNodeScope(jjtn000);
0302: jjtc000 = false;
0303: } else {
0304: jjtree.popNode();
0305: }
0306: if (jjte000 instanceof RuntimeException) {
0307: {
0308: if (true)
0309: throw (RuntimeException) jjte000;
0310: }
0311: }
0312: if (jjte000 instanceof ParseException) {
0313: {
0314: if (true)
0315: throw (ParseException) jjte000;
0316: }
0317: }
0318: {
0319: if (true)
0320: throw (Error) jjte000;
0321: }
0322: } finally {
0323: if (jjtc000) {
0324: jjtree.closeNodeScope(jjtn000, true);
0325: jjtreeCloseNodeScope(jjtn000);
0326: }
0327: }
0328: }
0329:
0330: final public void MethodDeclaration() throws ParseException {
0331: /*@bgen(jjtree) MethodDeclaration */
0332: BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(
0333: JJTMETHODDECLARATION);
0334: boolean jjtc000 = true;
0335: jjtree.openNodeScope(jjtn000);
0336: jjtreeOpenNodeScope(jjtn000);
0337: Token t = null;
0338: Modifiers mods;
0339: int count;
0340: try {
0341: mods = Modifiers(Modifiers.METHOD, false);
0342: jjtn000.modifiers = mods;
0343: if (jj_2_2(2147483647)) {
0344: t = jj_consume_token(IDENTIFIER);
0345: jjtn000.name = t.image;
0346: } else {
0347: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0348: case BOOLEAN:
0349: case BYTE:
0350: case CHAR:
0351: case DOUBLE:
0352: case FLOAT:
0353: case INT:
0354: case LONG:
0355: case SHORT:
0356: case VOID:
0357: case IDENTIFIER:
0358: ReturnType();
0359: t = jj_consume_token(IDENTIFIER);
0360: jjtn000.name = t.image;
0361: break;
0362: default:
0363: jj_consume_token(-1);
0364: throw new ParseException();
0365: }
0366: }
0367: FormalParameters();
0368: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0369: case THROWS:
0370: jj_consume_token(THROWS);
0371: count = NameList();
0372: jjtn000.numThrows = count;
0373: break;
0374: default:
0375: ;
0376: }
0377: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0378: case LBRACE:
0379: Block();
0380: break;
0381: case SEMICOLON:
0382: jj_consume_token(SEMICOLON);
0383: break;
0384: default:
0385: jj_consume_token(-1);
0386: throw new ParseException();
0387: }
0388: } catch (Throwable jjte000) {
0389: if (jjtc000) {
0390: jjtree.clearNodeScope(jjtn000);
0391: jjtc000 = false;
0392: } else {
0393: jjtree.popNode();
0394: }
0395: if (jjte000 instanceof RuntimeException) {
0396: {
0397: if (true)
0398: throw (RuntimeException) jjte000;
0399: }
0400: }
0401: if (jjte000 instanceof ParseException) {
0402: {
0403: if (true)
0404: throw (ParseException) jjte000;
0405: }
0406: }
0407: {
0408: if (true)
0409: throw (Error) jjte000;
0410: }
0411: } finally {
0412: if (jjtc000) {
0413: jjtree.closeNodeScope(jjtn000, true);
0414: jjtreeCloseNodeScope(jjtn000);
0415: }
0416: }
0417: }
0418:
0419: final public void PackageDeclaration() throws ParseException {
0420: /*@bgen(jjtree) PackageDeclaration */
0421: BSHPackageDeclaration jjtn000 = new BSHPackageDeclaration(
0422: JJTPACKAGEDECLARATION);
0423: boolean jjtc000 = true;
0424: jjtree.openNodeScope(jjtn000);
0425: jjtreeOpenNodeScope(jjtn000);
0426: try {
0427: jj_consume_token(PACKAGE);
0428: AmbiguousName();
0429: } catch (Throwable jjte000) {
0430: if (jjtc000) {
0431: jjtree.clearNodeScope(jjtn000);
0432: jjtc000 = false;
0433: } else {
0434: jjtree.popNode();
0435: }
0436: if (jjte000 instanceof RuntimeException) {
0437: {
0438: if (true)
0439: throw (RuntimeException) jjte000;
0440: }
0441: }
0442: if (jjte000 instanceof ParseException) {
0443: {
0444: if (true)
0445: throw (ParseException) jjte000;
0446: }
0447: }
0448: {
0449: if (true)
0450: throw (Error) jjte000;
0451: }
0452: } finally {
0453: if (jjtc000) {
0454: jjtree.closeNodeScope(jjtn000, true);
0455: jjtreeCloseNodeScope(jjtn000);
0456: }
0457: }
0458: }
0459:
0460: final public void ImportDeclaration() throws ParseException {
0461: /*@bgen(jjtree) ImportDeclaration */
0462: BSHImportDeclaration jjtn000 = new BSHImportDeclaration(
0463: JJTIMPORTDECLARATION);
0464: boolean jjtc000 = true;
0465: jjtree.openNodeScope(jjtn000);
0466: jjtreeOpenNodeScope(jjtn000);
0467: Token s = null;
0468: Token t = null;
0469: try {
0470: if (jj_2_3(3)) {
0471: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0472: case STATIC:
0473: s = jj_consume_token(STATIC);
0474: break;
0475: default:
0476: ;
0477: }
0478: jj_consume_token(IMPORT);
0479: AmbiguousName();
0480: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0481: case DOT:
0482: t = jj_consume_token(DOT);
0483: jj_consume_token(STAR);
0484: break;
0485: default:
0486: ;
0487: }
0488: jj_consume_token(SEMICOLON);
0489: jjtree.closeNodeScope(jjtn000, true);
0490: jjtc000 = false;
0491: jjtreeCloseNodeScope(jjtn000);
0492: if (s != null)
0493: jjtn000.staticImport = true;
0494: if (t != null)
0495: jjtn000.importPackage = true;
0496: } else {
0497: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0498: case IMPORT:
0499: jj_consume_token(IMPORT);
0500: jj_consume_token(STAR);
0501: jj_consume_token(SEMICOLON);
0502: jjtree.closeNodeScope(jjtn000, true);
0503: jjtc000 = false;
0504: jjtreeCloseNodeScope(jjtn000);
0505: jjtn000.super Import = true;
0506: break;
0507: default:
0508: jj_consume_token(-1);
0509: throw new ParseException();
0510: }
0511: }
0512: } catch (Throwable jjte000) {
0513: if (jjtc000) {
0514: jjtree.clearNodeScope(jjtn000);
0515: jjtc000 = false;
0516: } else {
0517: jjtree.popNode();
0518: }
0519: if (jjte000 instanceof RuntimeException) {
0520: {
0521: if (true)
0522: throw (RuntimeException) jjte000;
0523: }
0524: }
0525: if (jjte000 instanceof ParseException) {
0526: {
0527: if (true)
0528: throw (ParseException) jjte000;
0529: }
0530: }
0531: {
0532: if (true)
0533: throw (Error) jjte000;
0534: }
0535: } finally {
0536: if (jjtc000) {
0537: jjtree.closeNodeScope(jjtn000, true);
0538: jjtreeCloseNodeScope(jjtn000);
0539: }
0540: }
0541: }
0542:
0543: final public void VariableDeclarator() throws ParseException {
0544: /*@bgen(jjtree) VariableDeclarator */
0545: BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(
0546: JJTVARIABLEDECLARATOR);
0547: boolean jjtc000 = true;
0548: jjtree.openNodeScope(jjtn000);
0549: jjtreeOpenNodeScope(jjtn000);
0550: Token t;
0551: try {
0552: t = jj_consume_token(IDENTIFIER);
0553: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0554: case ASSIGN:
0555: jj_consume_token(ASSIGN);
0556: VariableInitializer();
0557: break;
0558: default:
0559: ;
0560: }
0561: jjtree.closeNodeScope(jjtn000, true);
0562: jjtc000 = false;
0563: jjtreeCloseNodeScope(jjtn000);
0564: jjtn000.name = t.image;
0565: } catch (Throwable jjte000) {
0566: if (jjtc000) {
0567: jjtree.clearNodeScope(jjtn000);
0568: jjtc000 = false;
0569: } else {
0570: jjtree.popNode();
0571: }
0572: if (jjte000 instanceof RuntimeException) {
0573: {
0574: if (true)
0575: throw (RuntimeException) jjte000;
0576: }
0577: }
0578: if (jjte000 instanceof ParseException) {
0579: {
0580: if (true)
0581: throw (ParseException) jjte000;
0582: }
0583: }
0584: {
0585: if (true)
0586: throw (Error) jjte000;
0587: }
0588: } finally {
0589: if (jjtc000) {
0590: jjtree.closeNodeScope(jjtn000, true);
0591: jjtreeCloseNodeScope(jjtn000);
0592: }
0593: }
0594: }
0595:
0596: /*
0597: this originally handled postfix array dimensions...
0598:
0599: void VariableDeclaratorId() #VariableDeclaratorId :
0600: { Token t; }
0601: {
0602: t=<IDENTIFIER> { jjtThis.name = t.image; }
0603: ( "[" "]" { jjtThis.addUndefinedDimension(); } )*
0604: }
0605: */
0606: final public void VariableInitializer() throws ParseException {
0607: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0608: case LBRACE:
0609: ArrayInitializer();
0610: break;
0611: case BOOLEAN:
0612: case BYTE:
0613: case CHAR:
0614: case DOUBLE:
0615: case FALSE:
0616: case FLOAT:
0617: case INT:
0618: case LONG:
0619: case NEW:
0620: case NULL:
0621: case SHORT:
0622: case TRUE:
0623: case VOID:
0624: case INTEGER_LITERAL:
0625: case FLOATING_POINT_LITERAL:
0626: case CHARACTER_LITERAL:
0627: case STRING_LITERAL:
0628: case IDENTIFIER:
0629: case LPAREN:
0630: case BANG:
0631: case TILDE:
0632: case INCR:
0633: case DECR:
0634: case PLUS:
0635: case MINUS:
0636: Expression();
0637: break;
0638: default:
0639: jj_consume_token(-1);
0640: throw new ParseException();
0641: }
0642: }
0643:
0644: final public void ArrayInitializer() throws ParseException {
0645: /*@bgen(jjtree) ArrayInitializer */
0646: BSHArrayInitializer jjtn000 = new BSHArrayInitializer(
0647: JJTARRAYINITIALIZER);
0648: boolean jjtc000 = true;
0649: jjtree.openNodeScope(jjtn000);
0650: jjtreeOpenNodeScope(jjtn000);
0651: try {
0652: jj_consume_token(LBRACE);
0653: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0654: case BOOLEAN:
0655: case BYTE:
0656: case CHAR:
0657: case DOUBLE:
0658: case FALSE:
0659: case FLOAT:
0660: case INT:
0661: case LONG:
0662: case NEW:
0663: case NULL:
0664: case SHORT:
0665: case TRUE:
0666: case VOID:
0667: case INTEGER_LITERAL:
0668: case FLOATING_POINT_LITERAL:
0669: case CHARACTER_LITERAL:
0670: case STRING_LITERAL:
0671: case IDENTIFIER:
0672: case LPAREN:
0673: case LBRACE:
0674: case BANG:
0675: case TILDE:
0676: case INCR:
0677: case DECR:
0678: case PLUS:
0679: case MINUS:
0680: VariableInitializer();
0681: label_2: while (true) {
0682: if (jj_2_4(2)) {
0683: ;
0684: } else {
0685: break label_2;
0686: }
0687: jj_consume_token(COMMA);
0688: VariableInitializer();
0689: }
0690: break;
0691: default:
0692: ;
0693: }
0694: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0695: case COMMA:
0696: jj_consume_token(COMMA);
0697: break;
0698: default:
0699: ;
0700: }
0701: jj_consume_token(RBRACE);
0702: } catch (Throwable jjte000) {
0703: if (jjtc000) {
0704: jjtree.clearNodeScope(jjtn000);
0705: jjtc000 = false;
0706: } else {
0707: jjtree.popNode();
0708: }
0709: if (jjte000 instanceof RuntimeException) {
0710: {
0711: if (true)
0712: throw (RuntimeException) jjte000;
0713: }
0714: }
0715: if (jjte000 instanceof ParseException) {
0716: {
0717: if (true)
0718: throw (ParseException) jjte000;
0719: }
0720: }
0721: {
0722: if (true)
0723: throw (Error) jjte000;
0724: }
0725: } finally {
0726: if (jjtc000) {
0727: jjtree.closeNodeScope(jjtn000, true);
0728: jjtreeCloseNodeScope(jjtn000);
0729: }
0730: }
0731: }
0732:
0733: final public void FormalParameters() throws ParseException {
0734: /*@bgen(jjtree) FormalParameters */
0735: BSHFormalParameters jjtn000 = new BSHFormalParameters(
0736: JJTFORMALPARAMETERS);
0737: boolean jjtc000 = true;
0738: jjtree.openNodeScope(jjtn000);
0739: jjtreeOpenNodeScope(jjtn000);
0740: try {
0741: jj_consume_token(LPAREN);
0742: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0743: case BOOLEAN:
0744: case BYTE:
0745: case CHAR:
0746: case DOUBLE:
0747: case FLOAT:
0748: case INT:
0749: case LONG:
0750: case SHORT:
0751: case IDENTIFIER:
0752: FormalParameter();
0753: label_3: while (true) {
0754: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0755: case COMMA:
0756: ;
0757: break;
0758: default:
0759: break label_3;
0760: }
0761: jj_consume_token(COMMA);
0762: FormalParameter();
0763: }
0764: break;
0765: default:
0766: ;
0767: }
0768: jj_consume_token(RPAREN);
0769: } catch (Throwable jjte000) {
0770: if (jjtc000) {
0771: jjtree.clearNodeScope(jjtn000);
0772: jjtc000 = false;
0773: } else {
0774: jjtree.popNode();
0775: }
0776: if (jjte000 instanceof RuntimeException) {
0777: {
0778: if (true)
0779: throw (RuntimeException) jjte000;
0780: }
0781: }
0782: if (jjte000 instanceof ParseException) {
0783: {
0784: if (true)
0785: throw (ParseException) jjte000;
0786: }
0787: }
0788: {
0789: if (true)
0790: throw (Error) jjte000;
0791: }
0792: } finally {
0793: if (jjtc000) {
0794: jjtree.closeNodeScope(jjtn000, true);
0795: jjtreeCloseNodeScope(jjtn000);
0796: }
0797: }
0798: }
0799:
0800: final public void FormalParameter() throws ParseException {
0801: /*@bgen(jjtree) FormalParameter */
0802: BSHFormalParameter jjtn000 = new BSHFormalParameter(
0803: JJTFORMALPARAMETER);
0804: boolean jjtc000 = true;
0805: jjtree.openNodeScope(jjtn000);
0806: jjtreeOpenNodeScope(jjtn000);
0807: Token t;
0808: try {
0809: if (jj_2_5(2)) {
0810: Type();
0811: t = jj_consume_token(IDENTIFIER);
0812: jjtree.closeNodeScope(jjtn000, true);
0813: jjtc000 = false;
0814: jjtreeCloseNodeScope(jjtn000);
0815: jjtn000.name = t.image;
0816: } else {
0817: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0818: case IDENTIFIER:
0819: t = jj_consume_token(IDENTIFIER);
0820: jjtree.closeNodeScope(jjtn000, true);
0821: jjtc000 = false;
0822: jjtreeCloseNodeScope(jjtn000);
0823: jjtn000.name = t.image;
0824: break;
0825: default:
0826: jj_consume_token(-1);
0827: throw new ParseException();
0828: }
0829: }
0830: } catch (Throwable jjte000) {
0831: if (jjtc000) {
0832: jjtree.clearNodeScope(jjtn000);
0833: jjtc000 = false;
0834: } else {
0835: jjtree.popNode();
0836: }
0837: if (jjte000 instanceof RuntimeException) {
0838: {
0839: if (true)
0840: throw (RuntimeException) jjte000;
0841: }
0842: }
0843: if (jjte000 instanceof ParseException) {
0844: {
0845: if (true)
0846: throw (ParseException) jjte000;
0847: }
0848: }
0849: {
0850: if (true)
0851: throw (Error) jjte000;
0852: }
0853: } finally {
0854: if (jjtc000) {
0855: jjtree.closeNodeScope(jjtn000, true);
0856: jjtreeCloseNodeScope(jjtn000);
0857: }
0858: }
0859: }
0860:
0861: /*
0862: Type, name and expression syntax follows.
0863: */
0864: final public void Type() throws ParseException {
0865: /*@bgen(jjtree) Type */
0866: BSHType jjtn000 = new BSHType(JJTTYPE);
0867: boolean jjtc000 = true;
0868: jjtree.openNodeScope(jjtn000);
0869: jjtreeOpenNodeScope(jjtn000);
0870: try {
0871: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0872: case BOOLEAN:
0873: case BYTE:
0874: case CHAR:
0875: case DOUBLE:
0876: case FLOAT:
0877: case INT:
0878: case LONG:
0879: case SHORT:
0880: PrimitiveType();
0881: break;
0882: case IDENTIFIER:
0883: AmbiguousName();
0884: break;
0885: default:
0886: jj_consume_token(-1);
0887: throw new ParseException();
0888: }
0889: label_4: while (true) {
0890: if (jj_2_6(2)) {
0891: ;
0892: } else {
0893: break label_4;
0894: }
0895: jj_consume_token(LBRACKET);
0896: jj_consume_token(RBRACKET);
0897: jjtn000.addArrayDimension();
0898: }
0899: } catch (Throwable jjte000) {
0900: if (jjtc000) {
0901: jjtree.clearNodeScope(jjtn000);
0902: jjtc000 = false;
0903: } else {
0904: jjtree.popNode();
0905: }
0906: if (jjte000 instanceof RuntimeException) {
0907: {
0908: if (true)
0909: throw (RuntimeException) jjte000;
0910: }
0911: }
0912: if (jjte000 instanceof ParseException) {
0913: {
0914: if (true)
0915: throw (ParseException) jjte000;
0916: }
0917: }
0918: {
0919: if (true)
0920: throw (Error) jjte000;
0921: }
0922: } finally {
0923: if (jjtc000) {
0924: jjtree.closeNodeScope(jjtn000, true);
0925: jjtreeCloseNodeScope(jjtn000);
0926: }
0927: }
0928: }
0929:
0930: /*
0931: Originally called ResultType in the grammar
0932: */
0933: final public void ReturnType() throws ParseException {
0934: /*@bgen(jjtree) ReturnType */
0935: BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
0936: boolean jjtc000 = true;
0937: jjtree.openNodeScope(jjtn000);
0938: jjtreeOpenNodeScope(jjtn000);
0939: try {
0940: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0941: case VOID:
0942: jj_consume_token(VOID);
0943: jjtree.closeNodeScope(jjtn000, true);
0944: jjtc000 = false;
0945: jjtreeCloseNodeScope(jjtn000);
0946: jjtn000.isVoid = true;
0947: break;
0948: case BOOLEAN:
0949: case BYTE:
0950: case CHAR:
0951: case DOUBLE:
0952: case FLOAT:
0953: case INT:
0954: case LONG:
0955: case SHORT:
0956: case IDENTIFIER:
0957: Type();
0958: break;
0959: default:
0960: jj_consume_token(-1);
0961: throw new ParseException();
0962: }
0963: } catch (Throwable jjte000) {
0964: if (jjtc000) {
0965: jjtree.clearNodeScope(jjtn000);
0966: jjtc000 = false;
0967: } else {
0968: jjtree.popNode();
0969: }
0970: if (jjte000 instanceof RuntimeException) {
0971: {
0972: if (true)
0973: throw (RuntimeException) jjte000;
0974: }
0975: }
0976: if (jjte000 instanceof ParseException) {
0977: {
0978: if (true)
0979: throw (ParseException) jjte000;
0980: }
0981: }
0982: {
0983: if (true)
0984: throw (Error) jjte000;
0985: }
0986: } finally {
0987: if (jjtc000) {
0988: jjtree.closeNodeScope(jjtn000, true);
0989: jjtreeCloseNodeScope(jjtn000);
0990: }
0991: }
0992: }
0993:
0994: final public void PrimitiveType() throws ParseException {
0995: /*@bgen(jjtree) PrimitiveType */
0996: BSHPrimitiveType jjtn000 = new BSHPrimitiveType(
0997: JJTPRIMITIVETYPE);
0998: boolean jjtc000 = true;
0999: jjtree.openNodeScope(jjtn000);
1000: jjtreeOpenNodeScope(jjtn000);
1001: try {
1002: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1003: case BOOLEAN:
1004: jj_consume_token(BOOLEAN);
1005: jjtree.closeNodeScope(jjtn000, true);
1006: jjtc000 = false;
1007: jjtreeCloseNodeScope(jjtn000);
1008: jjtn000.type = Boolean.TYPE;
1009: break;
1010: case CHAR:
1011: jj_consume_token(CHAR);
1012: jjtree.closeNodeScope(jjtn000, true);
1013: jjtc000 = false;
1014: jjtreeCloseNodeScope(jjtn000);
1015: jjtn000.type = Character.TYPE;
1016: break;
1017: case BYTE:
1018: jj_consume_token(BYTE);
1019: jjtree.closeNodeScope(jjtn000, true);
1020: jjtc000 = false;
1021: jjtreeCloseNodeScope(jjtn000);
1022: jjtn000.type = Byte.TYPE;
1023: break;
1024: case SHORT:
1025: jj_consume_token(SHORT);
1026: jjtree.closeNodeScope(jjtn000, true);
1027: jjtc000 = false;
1028: jjtreeCloseNodeScope(jjtn000);
1029: jjtn000.type = Short.TYPE;
1030: break;
1031: case INT:
1032: jj_consume_token(INT);
1033: jjtree.closeNodeScope(jjtn000, true);
1034: jjtc000 = false;
1035: jjtreeCloseNodeScope(jjtn000);
1036: jjtn000.type = Integer.TYPE;
1037: break;
1038: case LONG:
1039: jj_consume_token(LONG);
1040: jjtree.closeNodeScope(jjtn000, true);
1041: jjtc000 = false;
1042: jjtreeCloseNodeScope(jjtn000);
1043: jjtn000.type = Long.TYPE;
1044: break;
1045: case FLOAT:
1046: jj_consume_token(FLOAT);
1047: jjtree.closeNodeScope(jjtn000, true);
1048: jjtc000 = false;
1049: jjtreeCloseNodeScope(jjtn000);
1050: jjtn000.type = Float.TYPE;
1051: break;
1052: case DOUBLE:
1053: jj_consume_token(DOUBLE);
1054: jjtree.closeNodeScope(jjtn000, true);
1055: jjtc000 = false;
1056: jjtreeCloseNodeScope(jjtn000);
1057: jjtn000.type = Double.TYPE;
1058: break;
1059: default:
1060: jj_consume_token(-1);
1061: throw new ParseException();
1062: }
1063: } finally {
1064: if (jjtc000) {
1065: jjtree.closeNodeScope(jjtn000, true);
1066: jjtreeCloseNodeScope(jjtn000);
1067: }
1068: }
1069: }
1070:
1071: final public void AmbiguousName() throws ParseException {
1072: /*@bgen(jjtree) AmbiguousName */
1073: BSHAmbiguousName jjtn000 = new BSHAmbiguousName(
1074: JJTAMBIGUOUSNAME);
1075: boolean jjtc000 = true;
1076: jjtree.openNodeScope(jjtn000);
1077: jjtreeOpenNodeScope(jjtn000);
1078: Token t;
1079: StringBuffer s;
1080: try {
1081: t = jj_consume_token(IDENTIFIER);
1082: s = new StringBuffer(t.image);
1083: label_5: while (true) {
1084: if (jj_2_7(2)) {
1085: ;
1086: } else {
1087: break label_5;
1088: }
1089: jj_consume_token(DOT);
1090: t = jj_consume_token(IDENTIFIER);
1091: s.append("." + t.image);
1092: }
1093: jjtree.closeNodeScope(jjtn000, true);
1094: jjtc000 = false;
1095: jjtreeCloseNodeScope(jjtn000);
1096: jjtn000.text = s.toString();
1097: } finally {
1098: if (jjtc000) {
1099: jjtree.closeNodeScope(jjtn000, true);
1100: jjtreeCloseNodeScope(jjtn000);
1101: }
1102: }
1103: }
1104:
1105: final public int NameList() throws ParseException {
1106: int count = 0;
1107: AmbiguousName();
1108: ++count;
1109: label_6: while (true) {
1110: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1111: case COMMA:
1112: ;
1113: break;
1114: default:
1115: break label_6;
1116: }
1117: jj_consume_token(COMMA);
1118: AmbiguousName();
1119: ++count;
1120: }
1121: {
1122: if (true)
1123: return count;
1124: }
1125: throw new Error("Missing return statement in function");
1126: }
1127:
1128: /*
1129: * Expression syntax follows.
1130: */
1131: final public void Expression() throws ParseException {
1132: if (jj_2_8(2147483647)) {
1133: Assignment();
1134: } else {
1135: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1136: case BOOLEAN:
1137: case BYTE:
1138: case CHAR:
1139: case DOUBLE:
1140: case FALSE:
1141: case FLOAT:
1142: case INT:
1143: case LONG:
1144: case NEW:
1145: case NULL:
1146: case SHORT:
1147: case TRUE:
1148: case VOID:
1149: case INTEGER_LITERAL:
1150: case FLOATING_POINT_LITERAL:
1151: case CHARACTER_LITERAL:
1152: case STRING_LITERAL:
1153: case IDENTIFIER:
1154: case LPAREN:
1155: case BANG:
1156: case TILDE:
1157: case INCR:
1158: case DECR:
1159: case PLUS:
1160: case MINUS:
1161: ConditionalExpression();
1162: break;
1163: default:
1164: jj_consume_token(-1);
1165: throw new ParseException();
1166: }
1167: }
1168: }
1169:
1170: final public void Assignment() throws ParseException {
1171: /*@bgen(jjtree) Assignment */
1172: BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
1173: boolean jjtc000 = true;
1174: jjtree.openNodeScope(jjtn000);
1175: jjtreeOpenNodeScope(jjtn000);
1176: int op;
1177: try {
1178: PrimaryExpression();
1179: op = AssignmentOperator();
1180: jjtn000.operator = op;
1181: Expression();
1182: } catch (Throwable jjte000) {
1183: if (jjtc000) {
1184: jjtree.clearNodeScope(jjtn000);
1185: jjtc000 = false;
1186: } else {
1187: jjtree.popNode();
1188: }
1189: if (jjte000 instanceof RuntimeException) {
1190: {
1191: if (true)
1192: throw (RuntimeException) jjte000;
1193: }
1194: }
1195: if (jjte000 instanceof ParseException) {
1196: {
1197: if (true)
1198: throw (ParseException) jjte000;
1199: }
1200: }
1201: {
1202: if (true)
1203: throw (Error) jjte000;
1204: }
1205: } finally {
1206: if (jjtc000) {
1207: jjtree.closeNodeScope(jjtn000, true);
1208: jjtreeCloseNodeScope(jjtn000);
1209: }
1210: }
1211: }
1212:
1213: final public int AssignmentOperator() throws ParseException {
1214: Token t;
1215: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1216: case ASSIGN:
1217: jj_consume_token(ASSIGN);
1218: break;
1219: case STARASSIGN:
1220: jj_consume_token(STARASSIGN);
1221: break;
1222: case SLASHASSIGN:
1223: jj_consume_token(SLASHASSIGN);
1224: break;
1225: case MODASSIGN:
1226: jj_consume_token(MODASSIGN);
1227: break;
1228: case PLUSASSIGN:
1229: jj_consume_token(PLUSASSIGN);
1230: break;
1231: case MINUSASSIGN:
1232: jj_consume_token(MINUSASSIGN);
1233: break;
1234: case ANDASSIGN:
1235: jj_consume_token(ANDASSIGN);
1236: break;
1237: case XORASSIGN:
1238: jj_consume_token(XORASSIGN);
1239: break;
1240: case ORASSIGN:
1241: jj_consume_token(ORASSIGN);
1242: break;
1243: case LSHIFTASSIGN:
1244: jj_consume_token(LSHIFTASSIGN);
1245: break;
1246: case LSHIFTASSIGNX:
1247: jj_consume_token(LSHIFTASSIGNX);
1248: break;
1249: case RSIGNEDSHIFTASSIGN:
1250: jj_consume_token(RSIGNEDSHIFTASSIGN);
1251: break;
1252: case RSIGNEDSHIFTASSIGNX:
1253: jj_consume_token(RSIGNEDSHIFTASSIGNX);
1254: break;
1255: case RUNSIGNEDSHIFTASSIGN:
1256: jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1257: break;
1258: case RUNSIGNEDSHIFTASSIGNX:
1259: jj_consume_token(RUNSIGNEDSHIFTASSIGNX);
1260: break;
1261: default:
1262: jj_consume_token(-1);
1263: throw new ParseException();
1264: }
1265: t = getToken(0);
1266: {
1267: if (true)
1268: return t.kind;
1269: }
1270: throw new Error("Missing return statement in function");
1271: }
1272:
1273: final public void ConditionalExpression() throws ParseException {
1274: ConditionalOrExpression();
1275: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1276: case HOOK:
1277: jj_consume_token(HOOK);
1278: Expression();
1279: jj_consume_token(COLON);
1280: BSHTernaryExpression jjtn001 = new BSHTernaryExpression(
1281: JJTTERNARYEXPRESSION);
1282: boolean jjtc001 = true;
1283: jjtree.openNodeScope(jjtn001);
1284: jjtreeOpenNodeScope(jjtn001);
1285: try {
1286: ConditionalExpression();
1287: } catch (Throwable jjte001) {
1288: if (jjtc001) {
1289: jjtree.clearNodeScope(jjtn001);
1290: jjtc001 = false;
1291: } else {
1292: jjtree.popNode();
1293: }
1294: if (jjte001 instanceof RuntimeException) {
1295: {
1296: if (true)
1297: throw (RuntimeException) jjte001;
1298: }
1299: }
1300: if (jjte001 instanceof ParseException) {
1301: {
1302: if (true)
1303: throw (ParseException) jjte001;
1304: }
1305: }
1306: {
1307: if (true)
1308: throw (Error) jjte001;
1309: }
1310: } finally {
1311: if (jjtc001) {
1312: jjtree.closeNodeScope(jjtn001, 3);
1313: jjtreeCloseNodeScope(jjtn001);
1314: }
1315: }
1316: break;
1317: default:
1318: ;
1319: }
1320: }
1321:
1322: final public void ConditionalOrExpression() throws ParseException {
1323: Token t = null;
1324: ConditionalAndExpression();
1325: label_7: while (true) {
1326: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1327: case BOOL_OR:
1328: case BOOL_ORX:
1329: ;
1330: break;
1331: default:
1332: break label_7;
1333: }
1334: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1335: case BOOL_OR:
1336: t = jj_consume_token(BOOL_OR);
1337: break;
1338: case BOOL_ORX:
1339: t = jj_consume_token(BOOL_ORX);
1340: break;
1341: default:
1342: jj_consume_token(-1);
1343: throw new ParseException();
1344: }
1345: ConditionalAndExpression();
1346: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1347: JJTBINARYEXPRESSION);
1348: boolean jjtc001 = true;
1349: jjtree.openNodeScope(jjtn001);
1350: jjtreeOpenNodeScope(jjtn001);
1351: try {
1352: jjtree.closeNodeScope(jjtn001, 2);
1353: jjtc001 = false;
1354: jjtreeCloseNodeScope(jjtn001);
1355: jjtn001.kind = t.kind;
1356: } finally {
1357: if (jjtc001) {
1358: jjtree.closeNodeScope(jjtn001, 2);
1359: jjtreeCloseNodeScope(jjtn001);
1360: }
1361: }
1362: }
1363: }
1364:
1365: final public void ConditionalAndExpression() throws ParseException {
1366: Token t = null;
1367: InclusiveOrExpression();
1368: label_8: while (true) {
1369: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1370: case BOOL_AND:
1371: case BOOL_ANDX:
1372: ;
1373: break;
1374: default:
1375: break label_8;
1376: }
1377: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1378: case BOOL_AND:
1379: t = jj_consume_token(BOOL_AND);
1380: break;
1381: case BOOL_ANDX:
1382: t = jj_consume_token(BOOL_ANDX);
1383: break;
1384: default:
1385: jj_consume_token(-1);
1386: throw new ParseException();
1387: }
1388: InclusiveOrExpression();
1389: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1390: JJTBINARYEXPRESSION);
1391: boolean jjtc001 = true;
1392: jjtree.openNodeScope(jjtn001);
1393: jjtreeOpenNodeScope(jjtn001);
1394: try {
1395: jjtree.closeNodeScope(jjtn001, 2);
1396: jjtc001 = false;
1397: jjtreeCloseNodeScope(jjtn001);
1398: jjtn001.kind = t.kind;
1399: } finally {
1400: if (jjtc001) {
1401: jjtree.closeNodeScope(jjtn001, 2);
1402: jjtreeCloseNodeScope(jjtn001);
1403: }
1404: }
1405: }
1406: }
1407:
1408: final public void InclusiveOrExpression() throws ParseException {
1409: Token t = null;
1410: ExclusiveOrExpression();
1411: label_9: while (true) {
1412: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1413: case BIT_OR:
1414: case BIT_ORX:
1415: ;
1416: break;
1417: default:
1418: break label_9;
1419: }
1420: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1421: case BIT_OR:
1422: t = jj_consume_token(BIT_OR);
1423: break;
1424: case BIT_ORX:
1425: t = jj_consume_token(BIT_ORX);
1426: break;
1427: default:
1428: jj_consume_token(-1);
1429: throw new ParseException();
1430: }
1431: ExclusiveOrExpression();
1432: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1433: JJTBINARYEXPRESSION);
1434: boolean jjtc001 = true;
1435: jjtree.openNodeScope(jjtn001);
1436: jjtreeOpenNodeScope(jjtn001);
1437: try {
1438: jjtree.closeNodeScope(jjtn001, 2);
1439: jjtc001 = false;
1440: jjtreeCloseNodeScope(jjtn001);
1441: jjtn001.kind = t.kind;
1442: } finally {
1443: if (jjtc001) {
1444: jjtree.closeNodeScope(jjtn001, 2);
1445: jjtreeCloseNodeScope(jjtn001);
1446: }
1447: }
1448: }
1449: }
1450:
1451: final public void ExclusiveOrExpression() throws ParseException {
1452: Token t = null;
1453: AndExpression();
1454: label_10: while (true) {
1455: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1456: case XOR:
1457: ;
1458: break;
1459: default:
1460: break label_10;
1461: }
1462: t = jj_consume_token(XOR);
1463: AndExpression();
1464: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1465: JJTBINARYEXPRESSION);
1466: boolean jjtc001 = true;
1467: jjtree.openNodeScope(jjtn001);
1468: jjtreeOpenNodeScope(jjtn001);
1469: try {
1470: jjtree.closeNodeScope(jjtn001, 2);
1471: jjtc001 = false;
1472: jjtreeCloseNodeScope(jjtn001);
1473: jjtn001.kind = t.kind;
1474: } finally {
1475: if (jjtc001) {
1476: jjtree.closeNodeScope(jjtn001, 2);
1477: jjtreeCloseNodeScope(jjtn001);
1478: }
1479: }
1480: }
1481: }
1482:
1483: final public void AndExpression() throws ParseException {
1484: Token t = null;
1485: EqualityExpression();
1486: label_11: while (true) {
1487: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1488: case BIT_AND:
1489: case BIT_ANDX:
1490: ;
1491: break;
1492: default:
1493: break label_11;
1494: }
1495: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1496: case BIT_AND:
1497: t = jj_consume_token(BIT_AND);
1498: break;
1499: case BIT_ANDX:
1500: t = jj_consume_token(BIT_ANDX);
1501: break;
1502: default:
1503: jj_consume_token(-1);
1504: throw new ParseException();
1505: }
1506: EqualityExpression();
1507: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1508: JJTBINARYEXPRESSION);
1509: boolean jjtc001 = true;
1510: jjtree.openNodeScope(jjtn001);
1511: jjtreeOpenNodeScope(jjtn001);
1512: try {
1513: jjtree.closeNodeScope(jjtn001, 2);
1514: jjtc001 = false;
1515: jjtreeCloseNodeScope(jjtn001);
1516: jjtn001.kind = t.kind;
1517: } finally {
1518: if (jjtc001) {
1519: jjtree.closeNodeScope(jjtn001, 2);
1520: jjtreeCloseNodeScope(jjtn001);
1521: }
1522: }
1523: }
1524: }
1525:
1526: final public void EqualityExpression() throws ParseException {
1527: Token t = null;
1528: InstanceOfExpression();
1529: label_12: while (true) {
1530: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1531: case EQ:
1532: case NE:
1533: ;
1534: break;
1535: default:
1536: break label_12;
1537: }
1538: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1539: case EQ:
1540: t = jj_consume_token(EQ);
1541: break;
1542: case NE:
1543: t = jj_consume_token(NE);
1544: break;
1545: default:
1546: jj_consume_token(-1);
1547: throw new ParseException();
1548: }
1549: InstanceOfExpression();
1550: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1551: JJTBINARYEXPRESSION);
1552: boolean jjtc001 = true;
1553: jjtree.openNodeScope(jjtn001);
1554: jjtreeOpenNodeScope(jjtn001);
1555: try {
1556: jjtree.closeNodeScope(jjtn001, 2);
1557: jjtc001 = false;
1558: jjtreeCloseNodeScope(jjtn001);
1559: jjtn001.kind = t.kind;
1560: } finally {
1561: if (jjtc001) {
1562: jjtree.closeNodeScope(jjtn001, 2);
1563: jjtreeCloseNodeScope(jjtn001);
1564: }
1565: }
1566: }
1567: }
1568:
1569: final public void InstanceOfExpression() throws ParseException {
1570: Token t = null;
1571: RelationalExpression();
1572: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1573: case INSTANCEOF:
1574: t = jj_consume_token(INSTANCEOF);
1575: Type();
1576: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1577: JJTBINARYEXPRESSION);
1578: boolean jjtc001 = true;
1579: jjtree.openNodeScope(jjtn001);
1580: jjtreeOpenNodeScope(jjtn001);
1581: try {
1582: jjtree.closeNodeScope(jjtn001, 2);
1583: jjtc001 = false;
1584: jjtreeCloseNodeScope(jjtn001);
1585: jjtn001.kind = t.kind;
1586: } finally {
1587: if (jjtc001) {
1588: jjtree.closeNodeScope(jjtn001, 2);
1589: jjtreeCloseNodeScope(jjtn001);
1590: }
1591: }
1592: break;
1593: default:
1594: ;
1595: }
1596: }
1597:
1598: final public void RelationalExpression() throws ParseException {
1599: Token t = null;
1600: ShiftExpression();
1601: label_13: while (true) {
1602: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1603: case GT:
1604: case GTX:
1605: case LT:
1606: case LTX:
1607: case LE:
1608: case LEX:
1609: case GE:
1610: case GEX:
1611: ;
1612: break;
1613: default:
1614: break label_13;
1615: }
1616: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1617: case LT:
1618: t = jj_consume_token(LT);
1619: break;
1620: case LTX:
1621: t = jj_consume_token(LTX);
1622: break;
1623: case GT:
1624: t = jj_consume_token(GT);
1625: break;
1626: case GTX:
1627: t = jj_consume_token(GTX);
1628: break;
1629: case LE:
1630: t = jj_consume_token(LE);
1631: break;
1632: case LEX:
1633: t = jj_consume_token(LEX);
1634: break;
1635: case GE:
1636: t = jj_consume_token(GE);
1637: break;
1638: case GEX:
1639: t = jj_consume_token(GEX);
1640: break;
1641: default:
1642: jj_consume_token(-1);
1643: throw new ParseException();
1644: }
1645: ShiftExpression();
1646: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1647: JJTBINARYEXPRESSION);
1648: boolean jjtc001 = true;
1649: jjtree.openNodeScope(jjtn001);
1650: jjtreeOpenNodeScope(jjtn001);
1651: try {
1652: jjtree.closeNodeScope(jjtn001, 2);
1653: jjtc001 = false;
1654: jjtreeCloseNodeScope(jjtn001);
1655: jjtn001.kind = t.kind;
1656: } finally {
1657: if (jjtc001) {
1658: jjtree.closeNodeScope(jjtn001, 2);
1659: jjtreeCloseNodeScope(jjtn001);
1660: }
1661: }
1662: }
1663: }
1664:
1665: final public void ShiftExpression() throws ParseException {
1666: Token t = null;
1667: AdditiveExpression();
1668: label_14: while (true) {
1669: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1670: case LSHIFT:
1671: case LSHIFTX:
1672: case RSIGNEDSHIFT:
1673: case RSIGNEDSHIFTX:
1674: case RUNSIGNEDSHIFT:
1675: case RUNSIGNEDSHIFTX:
1676: ;
1677: break;
1678: default:
1679: break label_14;
1680: }
1681: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1682: case LSHIFT:
1683: t = jj_consume_token(LSHIFT);
1684: break;
1685: case LSHIFTX:
1686: t = jj_consume_token(LSHIFTX);
1687: break;
1688: case RSIGNEDSHIFT:
1689: t = jj_consume_token(RSIGNEDSHIFT);
1690: break;
1691: case RSIGNEDSHIFTX:
1692: t = jj_consume_token(RSIGNEDSHIFTX);
1693: break;
1694: case RUNSIGNEDSHIFT:
1695: t = jj_consume_token(RUNSIGNEDSHIFT);
1696: break;
1697: case RUNSIGNEDSHIFTX:
1698: t = jj_consume_token(RUNSIGNEDSHIFTX);
1699: break;
1700: default:
1701: jj_consume_token(-1);
1702: throw new ParseException();
1703: }
1704: AdditiveExpression();
1705: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1706: JJTBINARYEXPRESSION);
1707: boolean jjtc001 = true;
1708: jjtree.openNodeScope(jjtn001);
1709: jjtreeOpenNodeScope(jjtn001);
1710: try {
1711: jjtree.closeNodeScope(jjtn001, 2);
1712: jjtc001 = false;
1713: jjtreeCloseNodeScope(jjtn001);
1714: jjtn001.kind = t.kind;
1715: } finally {
1716: if (jjtc001) {
1717: jjtree.closeNodeScope(jjtn001, 2);
1718: jjtreeCloseNodeScope(jjtn001);
1719: }
1720: }
1721: }
1722: }
1723:
1724: final public void AdditiveExpression() throws ParseException {
1725: Token t = null;
1726: MultiplicativeExpression();
1727: label_15: while (true) {
1728: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1729: case PLUS:
1730: case MINUS:
1731: ;
1732: break;
1733: default:
1734: break label_15;
1735: }
1736: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1737: case PLUS:
1738: t = jj_consume_token(PLUS);
1739: break;
1740: case MINUS:
1741: t = jj_consume_token(MINUS);
1742: break;
1743: default:
1744: jj_consume_token(-1);
1745: throw new ParseException();
1746: }
1747: MultiplicativeExpression();
1748: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1749: JJTBINARYEXPRESSION);
1750: boolean jjtc001 = true;
1751: jjtree.openNodeScope(jjtn001);
1752: jjtreeOpenNodeScope(jjtn001);
1753: try {
1754: jjtree.closeNodeScope(jjtn001, 2);
1755: jjtc001 = false;
1756: jjtreeCloseNodeScope(jjtn001);
1757: jjtn001.kind = t.kind;
1758: } finally {
1759: if (jjtc001) {
1760: jjtree.closeNodeScope(jjtn001, 2);
1761: jjtreeCloseNodeScope(jjtn001);
1762: }
1763: }
1764: }
1765: }
1766:
1767: final public void MultiplicativeExpression() throws ParseException {
1768: Token t = null;
1769: UnaryExpression();
1770: label_16: while (true) {
1771: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1772: case STAR:
1773: case SLASH:
1774: case MOD:
1775: ;
1776: break;
1777: default:
1778: break label_16;
1779: }
1780: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1781: case STAR:
1782: t = jj_consume_token(STAR);
1783: break;
1784: case SLASH:
1785: t = jj_consume_token(SLASH);
1786: break;
1787: case MOD:
1788: t = jj_consume_token(MOD);
1789: break;
1790: default:
1791: jj_consume_token(-1);
1792: throw new ParseException();
1793: }
1794: UnaryExpression();
1795: BSHBinaryExpression jjtn001 = new BSHBinaryExpression(
1796: JJTBINARYEXPRESSION);
1797: boolean jjtc001 = true;
1798: jjtree.openNodeScope(jjtn001);
1799: jjtreeOpenNodeScope(jjtn001);
1800: try {
1801: jjtree.closeNodeScope(jjtn001, 2);
1802: jjtc001 = false;
1803: jjtreeCloseNodeScope(jjtn001);
1804: jjtn001.kind = t.kind;
1805: } finally {
1806: if (jjtc001) {
1807: jjtree.closeNodeScope(jjtn001, 2);
1808: jjtreeCloseNodeScope(jjtn001);
1809: }
1810: }
1811: }
1812: }
1813:
1814: final public void UnaryExpression() throws ParseException {
1815: Token t = null;
1816: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1817: case PLUS:
1818: case MINUS:
1819: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1820: case PLUS:
1821: t = jj_consume_token(PLUS);
1822: break;
1823: case MINUS:
1824: t = jj_consume_token(MINUS);
1825: break;
1826: default:
1827: jj_consume_token(-1);
1828: throw new ParseException();
1829: }
1830: UnaryExpression();
1831: BSHUnaryExpression jjtn001 = new BSHUnaryExpression(
1832: JJTUNARYEXPRESSION);
1833: boolean jjtc001 = true;
1834: jjtree.openNodeScope(jjtn001);
1835: jjtreeOpenNodeScope(jjtn001);
1836: try {
1837: jjtree.closeNodeScope(jjtn001, 1);
1838: jjtc001 = false;
1839: jjtreeCloseNodeScope(jjtn001);
1840: jjtn001.kind = t.kind;
1841: } finally {
1842: if (jjtc001) {
1843: jjtree.closeNodeScope(jjtn001, 1);
1844: jjtreeCloseNodeScope(jjtn001);
1845: }
1846: }
1847: break;
1848: case INCR:
1849: PreIncrementExpression();
1850: break;
1851: case DECR:
1852: PreDecrementExpression();
1853: break;
1854: case BOOLEAN:
1855: case BYTE:
1856: case CHAR:
1857: case DOUBLE:
1858: case FALSE:
1859: case FLOAT:
1860: case INT:
1861: case LONG:
1862: case NEW:
1863: case NULL:
1864: case SHORT:
1865: case TRUE:
1866: case VOID:
1867: case INTEGER_LITERAL:
1868: case FLOATING_POINT_LITERAL:
1869: case CHARACTER_LITERAL:
1870: case STRING_LITERAL:
1871: case IDENTIFIER:
1872: case LPAREN:
1873: case BANG:
1874: case TILDE:
1875: UnaryExpressionNotPlusMinus();
1876: break;
1877: default:
1878: jj_consume_token(-1);
1879: throw new ParseException();
1880: }
1881: }
1882:
1883: final public void PreIncrementExpression() throws ParseException {
1884: Token t = null;
1885: t = jj_consume_token(INCR);
1886: PrimaryExpression();
1887: BSHUnaryExpression jjtn001 = new BSHUnaryExpression(
1888: JJTUNARYEXPRESSION);
1889: boolean jjtc001 = true;
1890: jjtree.openNodeScope(jjtn001);
1891: jjtreeOpenNodeScope(jjtn001);
1892: try {
1893: jjtree.closeNodeScope(jjtn001, 1);
1894: jjtc001 = false;
1895: jjtreeCloseNodeScope(jjtn001);
1896: jjtn001.kind = t.kind;
1897: } finally {
1898: if (jjtc001) {
1899: jjtree.closeNodeScope(jjtn001, 1);
1900: jjtreeCloseNodeScope(jjtn001);
1901: }
1902: }
1903: }
1904:
1905: final public void PreDecrementExpression() throws ParseException {
1906: Token t = null;
1907: t = jj_consume_token(DECR);
1908: PrimaryExpression();
1909: BSHUnaryExpression jjtn001 = new BSHUnaryExpression(
1910: JJTUNARYEXPRESSION);
1911: boolean jjtc001 = true;
1912: jjtree.openNodeScope(jjtn001);
1913: jjtreeOpenNodeScope(jjtn001);
1914: try {
1915: jjtree.closeNodeScope(jjtn001, 1);
1916: jjtc001 = false;
1917: jjtreeCloseNodeScope(jjtn001);
1918: jjtn001.kind = t.kind;
1919: } finally {
1920: if (jjtc001) {
1921: jjtree.closeNodeScope(jjtn001, 1);
1922: jjtreeCloseNodeScope(jjtn001);
1923: }
1924: }
1925: }
1926:
1927: final public void UnaryExpressionNotPlusMinus()
1928: throws ParseException {
1929: Token t = null;
1930: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1931: case BANG:
1932: case TILDE:
1933: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1934: case TILDE:
1935: t = jj_consume_token(TILDE);
1936: break;
1937: case BANG:
1938: t = jj_consume_token(BANG);
1939: break;
1940: default:
1941: jj_consume_token(-1);
1942: throw new ParseException();
1943: }
1944: UnaryExpression();
1945: BSHUnaryExpression jjtn001 = new BSHUnaryExpression(
1946: JJTUNARYEXPRESSION);
1947: boolean jjtc001 = true;
1948: jjtree.openNodeScope(jjtn001);
1949: jjtreeOpenNodeScope(jjtn001);
1950: try {
1951: jjtree.closeNodeScope(jjtn001, 1);
1952: jjtc001 = false;
1953: jjtreeCloseNodeScope(jjtn001);
1954: jjtn001.kind = t.kind;
1955: } finally {
1956: if (jjtc001) {
1957: jjtree.closeNodeScope(jjtn001, 1);
1958: jjtreeCloseNodeScope(jjtn001);
1959: }
1960: }
1961: break;
1962: default:
1963: if (jj_2_9(2147483647)) {
1964: CastExpression();
1965: } else {
1966: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1967: case BOOLEAN:
1968: case BYTE:
1969: case CHAR:
1970: case DOUBLE:
1971: case FALSE:
1972: case FLOAT:
1973: case INT:
1974: case LONG:
1975: case NEW:
1976: case NULL:
1977: case SHORT:
1978: case TRUE:
1979: case VOID:
1980: case INTEGER_LITERAL:
1981: case FLOATING_POINT_LITERAL:
1982: case CHARACTER_LITERAL:
1983: case STRING_LITERAL:
1984: case IDENTIFIER:
1985: case LPAREN:
1986: PostfixExpression();
1987: break;
1988: default:
1989: jj_consume_token(-1);
1990: throw new ParseException();
1991: }
1992: }
1993: }
1994: }
1995:
1996: // This production is to determine lookahead only.
1997: final public void CastLookahead() throws ParseException {
1998: if (jj_2_10(2)) {
1999: jj_consume_token(LPAREN);
2000: PrimitiveType();
2001: } else if (jj_2_11(2147483647)) {
2002: jj_consume_token(LPAREN);
2003: AmbiguousName();
2004: jj_consume_token(LBRACKET);
2005: jj_consume_token(RBRACKET);
2006: } else {
2007: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2008: case LPAREN:
2009: jj_consume_token(LPAREN);
2010: AmbiguousName();
2011: jj_consume_token(RPAREN);
2012: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2013: case TILDE:
2014: jj_consume_token(TILDE);
2015: break;
2016: case BANG:
2017: jj_consume_token(BANG);
2018: break;
2019: case LPAREN:
2020: jj_consume_token(LPAREN);
2021: break;
2022: case IDENTIFIER:
2023: jj_consume_token(IDENTIFIER);
2024: break;
2025: case NEW:
2026: jj_consume_token(NEW);
2027: break;
2028: case FALSE:
2029: case NULL:
2030: case TRUE:
2031: case VOID:
2032: case INTEGER_LITERAL:
2033: case FLOATING_POINT_LITERAL:
2034: case CHARACTER_LITERAL:
2035: case STRING_LITERAL:
2036: Literal();
2037: break;
2038: default:
2039: jj_consume_token(-1);
2040: throw new ParseException();
2041: }
2042: break;
2043: default:
2044: jj_consume_token(-1);
2045: throw new ParseException();
2046: }
2047: }
2048: }
2049:
2050: final public void PostfixExpression() throws ParseException {
2051: Token t = null;
2052: if (jj_2_12(2147483647)) {
2053: PrimaryExpression();
2054: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2055: case INCR:
2056: t = jj_consume_token(INCR);
2057: break;
2058: case DECR:
2059: t = jj_consume_token(DECR);
2060: break;
2061: default:
2062: jj_consume_token(-1);
2063: throw new ParseException();
2064: }
2065: BSHUnaryExpression jjtn001 = new BSHUnaryExpression(
2066: JJTUNARYEXPRESSION);
2067: boolean jjtc001 = true;
2068: jjtree.openNodeScope(jjtn001);
2069: jjtreeOpenNodeScope(jjtn001);
2070: try {
2071: jjtree.closeNodeScope(jjtn001, 1);
2072: jjtc001 = false;
2073: jjtreeCloseNodeScope(jjtn001);
2074: jjtn001.kind = t.kind;
2075: jjtn001.postfix = true;
2076: } finally {
2077: if (jjtc001) {
2078: jjtree.closeNodeScope(jjtn001, 1);
2079: jjtreeCloseNodeScope(jjtn001);
2080: }
2081: }
2082: } else {
2083: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2084: case BOOLEAN:
2085: case BYTE:
2086: case CHAR:
2087: case DOUBLE:
2088: case FALSE:
2089: case FLOAT:
2090: case INT:
2091: case LONG:
2092: case NEW:
2093: case NULL:
2094: case SHORT:
2095: case TRUE:
2096: case VOID:
2097: case INTEGER_LITERAL:
2098: case FLOATING_POINT_LITERAL:
2099: case CHARACTER_LITERAL:
2100: case STRING_LITERAL:
2101: case IDENTIFIER:
2102: case LPAREN:
2103: PrimaryExpression();
2104: break;
2105: default:
2106: jj_consume_token(-1);
2107: throw new ParseException();
2108: }
2109: }
2110: }
2111:
2112: final public void CastExpression() throws ParseException {
2113: /*@bgen(jjtree) CastExpression */
2114: BSHCastExpression jjtn000 = new BSHCastExpression(
2115: JJTCASTEXPRESSION);
2116: boolean jjtc000 = true;
2117: jjtree.openNodeScope(jjtn000);
2118: jjtreeOpenNodeScope(jjtn000);
2119: try {
2120: if (jj_2_13(2147483647)) {
2121: jj_consume_token(LPAREN);
2122: Type();
2123: jj_consume_token(RPAREN);
2124: UnaryExpression();
2125: } else {
2126: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2127: case LPAREN:
2128: jj_consume_token(LPAREN);
2129: Type();
2130: jj_consume_token(RPAREN);
2131: UnaryExpressionNotPlusMinus();
2132: break;
2133: default:
2134: jj_consume_token(-1);
2135: throw new ParseException();
2136: }
2137: }
2138: } catch (Throwable jjte000) {
2139: if (jjtc000) {
2140: jjtree.clearNodeScope(jjtn000);
2141: jjtc000 = false;
2142: } else {
2143: jjtree.popNode();
2144: }
2145: if (jjte000 instanceof RuntimeException) {
2146: {
2147: if (true)
2148: throw (RuntimeException) jjte000;
2149: }
2150: }
2151: if (jjte000 instanceof ParseException) {
2152: {
2153: if (true)
2154: throw (ParseException) jjte000;
2155: }
2156: }
2157: {
2158: if (true)
2159: throw (Error) jjte000;
2160: }
2161: } finally {
2162: if (jjtc000) {
2163: jjtree.closeNodeScope(jjtn000, true);
2164: jjtreeCloseNodeScope(jjtn000);
2165: }
2166: }
2167: }
2168:
2169: final public void PrimaryExpression() throws ParseException {
2170: /*@bgen(jjtree) PrimaryExpression */
2171: BSHPrimaryExpression jjtn000 = new BSHPrimaryExpression(
2172: JJTPRIMARYEXPRESSION);
2173: boolean jjtc000 = true;
2174: jjtree.openNodeScope(jjtn000);
2175: jjtreeOpenNodeScope(jjtn000);
2176: try {
2177: PrimaryPrefix();
2178: label_17: while (true) {
2179: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2180: case LBRACE:
2181: case LBRACKET:
2182: case DOT:
2183: ;
2184: break;
2185: default:
2186: break label_17;
2187: }
2188: PrimarySuffix();
2189: }
2190: } catch (Throwable jjte000) {
2191: if (jjtc000) {
2192: jjtree.clearNodeScope(jjtn000);
2193: jjtc000 = false;
2194: } else {
2195: jjtree.popNode();
2196: }
2197: if (jjte000 instanceof RuntimeException) {
2198: {
2199: if (true)
2200: throw (RuntimeException) jjte000;
2201: }
2202: }
2203: if (jjte000 instanceof ParseException) {
2204: {
2205: if (true)
2206: throw (ParseException) jjte000;
2207: }
2208: }
2209: {
2210: if (true)
2211: throw (Error) jjte000;
2212: }
2213: } finally {
2214: if (jjtc000) {
2215: jjtree.closeNodeScope(jjtn000, true);
2216: jjtreeCloseNodeScope(jjtn000);
2217: }
2218: }
2219: }
2220:
2221: final public void MethodInvocation() throws ParseException {
2222: /*@bgen(jjtree) MethodInvocation */
2223: BSHMethodInvocation jjtn000 = new BSHMethodInvocation(
2224: JJTMETHODINVOCATION);
2225: boolean jjtc000 = true;
2226: jjtree.openNodeScope(jjtn000);
2227: jjtreeOpenNodeScope(jjtn000);
2228: try {
2229: AmbiguousName();
2230: Arguments();
2231: } catch (Throwable jjte000) {
2232: if (jjtc000) {
2233: jjtree.clearNodeScope(jjtn000);
2234: jjtc000 = false;
2235: } else {
2236: jjtree.popNode();
2237: }
2238: if (jjte000 instanceof RuntimeException) {
2239: {
2240: if (true)
2241: throw (RuntimeException) jjte000;
2242: }
2243: }
2244: if (jjte000 instanceof ParseException) {
2245: {
2246: if (true)
2247: throw (ParseException) jjte000;
2248: }
2249: }
2250: {
2251: if (true)
2252: throw (Error) jjte000;
2253: }
2254: } finally {
2255: if (jjtc000) {
2256: jjtree.closeNodeScope(jjtn000, true);
2257: jjtreeCloseNodeScope(jjtn000);
2258: }
2259: }
2260: }
2261:
2262: final public void PrimaryPrefix() throws ParseException {
2263: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2264: case FALSE:
2265: case NULL:
2266: case TRUE:
2267: case VOID:
2268: case INTEGER_LITERAL:
2269: case FLOATING_POINT_LITERAL:
2270: case CHARACTER_LITERAL:
2271: case STRING_LITERAL:
2272: Literal();
2273: break;
2274: case LPAREN:
2275: jj_consume_token(LPAREN);
2276: Expression();
2277: jj_consume_token(RPAREN);
2278: break;
2279: case NEW:
2280: AllocationExpression();
2281: break;
2282: default:
2283: if (jj_2_14(2147483647)) {
2284: MethodInvocation();
2285: } else if (jj_2_15(2147483647)) {
2286: Type();
2287: } else {
2288: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2289: case IDENTIFIER:
2290: AmbiguousName();
2291: break;
2292: default:
2293: jj_consume_token(-1);
2294: throw new ParseException();
2295: }
2296: }
2297: }
2298: }
2299:
2300: final public void PrimarySuffix() throws ParseException {
2301: /*@bgen(jjtree) PrimarySuffix */
2302: BSHPrimarySuffix jjtn000 = new BSHPrimarySuffix(
2303: JJTPRIMARYSUFFIX);
2304: boolean jjtc000 = true;
2305: jjtree.openNodeScope(jjtn000);
2306: jjtreeOpenNodeScope(jjtn000);
2307: Token t = null;
2308: try {
2309: if (jj_2_16(2)) {
2310: jj_consume_token(DOT);
2311: jj_consume_token(CLASS);
2312: jjtree.closeNodeScope(jjtn000, true);
2313: jjtc000 = false;
2314: jjtreeCloseNodeScope(jjtn000);
2315: jjtn000.operation = BSHPrimarySuffix.CLASS;
2316: } else {
2317: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2318: case LBRACKET:
2319: jj_consume_token(LBRACKET);
2320: Expression();
2321: jj_consume_token(RBRACKET);
2322: jjtree.closeNodeScope(jjtn000, true);
2323: jjtc000 = false;
2324: jjtreeCloseNodeScope(jjtn000);
2325: jjtn000.operation = BSHPrimarySuffix.INDEX;
2326: break;
2327: case DOT:
2328: jj_consume_token(DOT);
2329: t = jj_consume_token(IDENTIFIER);
2330: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2331: case LPAREN:
2332: Arguments();
2333: break;
2334: default:
2335: ;
2336: }
2337: jjtree.closeNodeScope(jjtn000, true);
2338: jjtc000 = false;
2339: jjtreeCloseNodeScope(jjtn000);
2340: jjtn000.operation = BSHPrimarySuffix.NAME;
2341: jjtn000.field = t.image;
2342: break;
2343: case LBRACE:
2344: jj_consume_token(LBRACE);
2345: Expression();
2346: jj_consume_token(RBRACE);
2347: jjtree.closeNodeScope(jjtn000, true);
2348: jjtc000 = false;
2349: jjtreeCloseNodeScope(jjtn000);
2350: jjtn000.operation = BSHPrimarySuffix.PROPERTY;
2351: break;
2352: default:
2353: jj_consume_token(-1);
2354: throw new ParseException();
2355: }
2356: }
2357: } catch (Throwable jjte000) {
2358: if (jjtc000) {
2359: jjtree.clearNodeScope(jjtn000);
2360: jjtc000 = false;
2361: } else {
2362: jjtree.popNode();
2363: }
2364: if (jjte000 instanceof RuntimeException) {
2365: {
2366: if (true)
2367: throw (RuntimeException) jjte000;
2368: }
2369: }
2370: if (jjte000 instanceof ParseException) {
2371: {
2372: if (true)
2373: throw (ParseException) jjte000;
2374: }
2375: }
2376: {
2377: if (true)
2378: throw (Error) jjte000;
2379: }
2380: } finally {
2381: if (jjtc000) {
2382: jjtree.closeNodeScope(jjtn000, true);
2383: jjtreeCloseNodeScope(jjtn000);
2384: }
2385: }
2386: }
2387:
2388: final public void Literal() throws ParseException {
2389: /*@bgen(jjtree) Literal */
2390: BSHLiteral jjtn000 = new BSHLiteral(JJTLITERAL);
2391: boolean jjtc000 = true;
2392: jjtree.openNodeScope(jjtn000);
2393: jjtreeOpenNodeScope(jjtn000);
2394: Token x;
2395: boolean b;
2396: String literal;
2397: char ch;
2398: try {
2399: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2400: case INTEGER_LITERAL:
2401: x = jj_consume_token(INTEGER_LITERAL);
2402: jjtree.closeNodeScope(jjtn000, true);
2403: jjtc000 = false;
2404: jjtreeCloseNodeScope(jjtn000);
2405: literal = x.image;
2406: ch = literal.charAt(literal.length() - 1);
2407: if (ch == 'l' || ch == 'L') {
2408: literal = literal
2409: .substring(0, literal.length() - 1);
2410:
2411: // This really should be Long.decode, but there isn't one. As a result,
2412: // hex and octal literals ending in 'l' or 'L' don't work.
2413: jjtn000.value = new Primitive(new Long(literal)
2414: .longValue());
2415: } else
2416: try {
2417: jjtn000.value = new Primitive(Integer.decode(
2418: literal).intValue());
2419: } catch (NumberFormatException e) {
2420: {
2421: if (true)
2422: throw createParseException("Error or number too big for integer type: "
2423: + literal);
2424: }
2425: }
2426: break;
2427: case FLOATING_POINT_LITERAL:
2428: x = jj_consume_token(FLOATING_POINT_LITERAL);
2429: jjtree.closeNodeScope(jjtn000, true);
2430: jjtc000 = false;
2431: jjtreeCloseNodeScope(jjtn000);
2432: literal = x.image;
2433: ch = literal.charAt(literal.length() - 1);
2434: if (ch == 'f' || ch == 'F') {
2435: literal = literal
2436: .substring(0, literal.length() - 1);
2437: jjtn000.value = new Primitive(new Float(literal)
2438: .floatValue());
2439: } else {
2440: if (ch == 'd' || ch == 'D')
2441: literal = literal.substring(0,
2442: literal.length() - 1);
2443:
2444: jjtn000.value = new Primitive(new Double(literal)
2445: .doubleValue());
2446: }
2447: break;
2448: case CHARACTER_LITERAL:
2449: x = jj_consume_token(CHARACTER_LITERAL);
2450: jjtree.closeNodeScope(jjtn000, true);
2451: jjtc000 = false;
2452: jjtreeCloseNodeScope(jjtn000);
2453: try {
2454: jjtn000.charSetup(x.image.substring(1, x.image
2455: .length() - 1));
2456: } catch (Exception e) {
2457: {
2458: if (true)
2459: throw createParseException("Error parsing character: "
2460: + x.image);
2461: }
2462: }
2463: break;
2464: case STRING_LITERAL:
2465: x = jj_consume_token(STRING_LITERAL);
2466: jjtree.closeNodeScope(jjtn000, true);
2467: jjtc000 = false;
2468: jjtreeCloseNodeScope(jjtn000);
2469: try {
2470: jjtn000.stringSetup(x.image.substring(1, x.image
2471: .length() - 1));
2472: } catch (Exception e) {
2473: {
2474: if (true)
2475: throw createParseException("Error parsing string: "
2476: + x.image);
2477: }
2478: }
2479: break;
2480: case FALSE:
2481: case TRUE:
2482: b = BooleanLiteral();
2483: jjtree.closeNodeScope(jjtn000, true);
2484: jjtc000 = false;
2485: jjtreeCloseNodeScope(jjtn000);
2486: jjtn000.value = new Primitive(b);
2487: break;
2488: case NULL:
2489: NullLiteral();
2490: jjtree.closeNodeScope(jjtn000, true);
2491: jjtc000 = false;
2492: jjtreeCloseNodeScope(jjtn000);
2493: jjtn000.value = Primitive.NULL;
2494: break;
2495: case VOID:
2496: VoidLiteral();
2497: jjtree.closeNodeScope(jjtn000, true);
2498: jjtc000 = false;
2499: jjtreeCloseNodeScope(jjtn000);
2500: jjtn000.value = Primitive.VOID;
2501: break;
2502: default:
2503: jj_consume_token(-1);
2504: throw new ParseException();
2505: }
2506: } catch (Throwable jjte000) {
2507: if (jjtc000) {
2508: jjtree.clearNodeScope(jjtn000);
2509: jjtc000 = false;
2510: } else {
2511: jjtree.popNode();
2512: }
2513: if (jjte000 instanceof RuntimeException) {
2514: {
2515: if (true)
2516: throw (RuntimeException) jjte000;
2517: }
2518: }
2519: if (jjte000 instanceof ParseException) {
2520: {
2521: if (true)
2522: throw (ParseException) jjte000;
2523: }
2524: }
2525: {
2526: if (true)
2527: throw (Error) jjte000;
2528: }
2529: } finally {
2530: if (jjtc000) {
2531: jjtree.closeNodeScope(jjtn000, true);
2532: jjtreeCloseNodeScope(jjtn000);
2533: }
2534: }
2535: }
2536:
2537: final public boolean BooleanLiteral() throws ParseException {
2538: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2539: case TRUE:
2540: jj_consume_token(TRUE);
2541: {
2542: if (true)
2543: return true;
2544: }
2545: break;
2546: case FALSE:
2547: jj_consume_token(FALSE);
2548: {
2549: if (true)
2550: return false;
2551: }
2552: break;
2553: default:
2554: jj_consume_token(-1);
2555: throw new ParseException();
2556: }
2557: throw new Error("Missing return statement in function");
2558: }
2559:
2560: final public void NullLiteral() throws ParseException {
2561: jj_consume_token(NULL);
2562: }
2563:
2564: final public void VoidLiteral() throws ParseException {
2565: jj_consume_token(VOID);
2566: }
2567:
2568: final public void Arguments() throws ParseException {
2569: /*@bgen(jjtree) Arguments */
2570: BSHArguments jjtn000 = new BSHArguments(JJTARGUMENTS);
2571: boolean jjtc000 = true;
2572: jjtree.openNodeScope(jjtn000);
2573: jjtreeOpenNodeScope(jjtn000);
2574: try {
2575: jj_consume_token(LPAREN);
2576: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2577: case BOOLEAN:
2578: case BYTE:
2579: case CHAR:
2580: case DOUBLE:
2581: case FALSE:
2582: case FLOAT:
2583: case INT:
2584: case LONG:
2585: case NEW:
2586: case NULL:
2587: case SHORT:
2588: case TRUE:
2589: case VOID:
2590: case INTEGER_LITERAL:
2591: case FLOATING_POINT_LITERAL:
2592: case CHARACTER_LITERAL:
2593: case STRING_LITERAL:
2594: case IDENTIFIER:
2595: case LPAREN:
2596: case BANG:
2597: case TILDE:
2598: case INCR:
2599: case DECR:
2600: case PLUS:
2601: case MINUS:
2602: ArgumentList();
2603: break;
2604: default:
2605: ;
2606: }
2607: jj_consume_token(RPAREN);
2608: } catch (Throwable jjte000) {
2609: if (jjtc000) {
2610: jjtree.clearNodeScope(jjtn000);
2611: jjtc000 = false;
2612: } else {
2613: jjtree.popNode();
2614: }
2615: if (jjte000 instanceof RuntimeException) {
2616: {
2617: if (true)
2618: throw (RuntimeException) jjte000;
2619: }
2620: }
2621: if (jjte000 instanceof ParseException) {
2622: {
2623: if (true)
2624: throw (ParseException) jjte000;
2625: }
2626: }
2627: {
2628: if (true)
2629: throw (Error) jjte000;
2630: }
2631: } finally {
2632: if (jjtc000) {
2633: jjtree.closeNodeScope(jjtn000, true);
2634: jjtreeCloseNodeScope(jjtn000);
2635: }
2636: }
2637: }
2638:
2639: // leave these on the stack for Arguments() to handle
2640: final public void ArgumentList() throws ParseException {
2641: Expression();
2642: label_18: while (true) {
2643: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2644: case COMMA:
2645: ;
2646: break;
2647: default:
2648: break label_18;
2649: }
2650: jj_consume_token(COMMA);
2651: Expression();
2652: }
2653: }
2654:
2655: final public void AllocationExpression() throws ParseException {
2656: /*@bgen(jjtree) AllocationExpression */
2657: BSHAllocationExpression jjtn000 = new BSHAllocationExpression(
2658: JJTALLOCATIONEXPRESSION);
2659: boolean jjtc000 = true;
2660: jjtree.openNodeScope(jjtn000);
2661: jjtreeOpenNodeScope(jjtn000);
2662: try {
2663: if (jj_2_18(2)) {
2664: jj_consume_token(NEW);
2665: PrimitiveType();
2666: ArrayDimensions();
2667: } else {
2668: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2669: case NEW:
2670: jj_consume_token(NEW);
2671: AmbiguousName();
2672: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2673: case LBRACKET:
2674: ArrayDimensions();
2675: break;
2676: case LPAREN:
2677: Arguments();
2678: if (jj_2_17(2)) {
2679: Block();
2680: } else {
2681: ;
2682: }
2683: break;
2684: default:
2685: jj_consume_token(-1);
2686: throw new ParseException();
2687: }
2688: break;
2689: default:
2690: jj_consume_token(-1);
2691: throw new ParseException();
2692: }
2693: }
2694: } catch (Throwable jjte000) {
2695: if (jjtc000) {
2696: jjtree.clearNodeScope(jjtn000);
2697: jjtc000 = false;
2698: } else {
2699: jjtree.popNode();
2700: }
2701: if (jjte000 instanceof RuntimeException) {
2702: {
2703: if (true)
2704: throw (RuntimeException) jjte000;
2705: }
2706: }
2707: if (jjte000 instanceof ParseException) {
2708: {
2709: if (true)
2710: throw (ParseException) jjte000;
2711: }
2712: }
2713: {
2714: if (true)
2715: throw (Error) jjte000;
2716: }
2717: } finally {
2718: if (jjtc000) {
2719: jjtree.closeNodeScope(jjtn000, true);
2720: jjtreeCloseNodeScope(jjtn000);
2721: }
2722: }
2723: }
2724:
2725: final public void ArrayDimensions() throws ParseException {
2726: /*@bgen(jjtree) ArrayDimensions */
2727: BSHArrayDimensions jjtn000 = new BSHArrayDimensions(
2728: JJTARRAYDIMENSIONS);
2729: boolean jjtc000 = true;
2730: jjtree.openNodeScope(jjtn000);
2731: jjtreeOpenNodeScope(jjtn000);
2732: try {
2733: if (jj_2_21(2)) {
2734: label_19: while (true) {
2735: jj_consume_token(LBRACKET);
2736: Expression();
2737: jj_consume_token(RBRACKET);
2738: jjtn000.addDefinedDimension();
2739: if (jj_2_19(2)) {
2740: ;
2741: } else {
2742: break label_19;
2743: }
2744: }
2745: label_20: while (true) {
2746: if (jj_2_20(2)) {
2747: ;
2748: } else {
2749: break label_20;
2750: }
2751: jj_consume_token(LBRACKET);
2752: jj_consume_token(RBRACKET);
2753: jjtn000.addUndefinedDimension();
2754: }
2755: } else {
2756: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2757: case LBRACKET:
2758: label_21: while (true) {
2759: jj_consume_token(LBRACKET);
2760: jj_consume_token(RBRACKET);
2761: jjtn000.addUndefinedDimension();
2762: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2763: case LBRACKET:
2764: ;
2765: break;
2766: default:
2767: break label_21;
2768: }
2769: }
2770: ArrayInitializer();
2771: break;
2772: default:
2773: jj_consume_token(-1);
2774: throw new ParseException();
2775: }
2776: }
2777: } catch (Throwable jjte000) {
2778: if (jjtc000) {
2779: jjtree.clearNodeScope(jjtn000);
2780: jjtc000 = false;
2781: } else {
2782: jjtree.popNode();
2783: }
2784: if (jjte000 instanceof RuntimeException) {
2785: {
2786: if (true)
2787: throw (RuntimeException) jjte000;
2788: }
2789: }
2790: if (jjte000 instanceof ParseException) {
2791: {
2792: if (true)
2793: throw (ParseException) jjte000;
2794: }
2795: }
2796: {
2797: if (true)
2798: throw (Error) jjte000;
2799: }
2800: } finally {
2801: if (jjtc000) {
2802: jjtree.closeNodeScope(jjtn000, true);
2803: jjtreeCloseNodeScope(jjtn000);
2804: }
2805: }
2806: }
2807:
2808: /*
2809: * Statement syntax follows.
2810: */
2811: final public void Statement() throws ParseException {
2812: if (jj_2_22(2)) {
2813: LabeledStatement();
2814: } else {
2815: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2816: case LBRACE:
2817: Block();
2818: break;
2819: case SEMICOLON:
2820: EmptyStatement();
2821: break;
2822: case BOOLEAN:
2823: case BYTE:
2824: case CHAR:
2825: case DOUBLE:
2826: case FALSE:
2827: case FLOAT:
2828: case INT:
2829: case LONG:
2830: case NEW:
2831: case NULL:
2832: case SHORT:
2833: case TRUE:
2834: case VOID:
2835: case INTEGER_LITERAL:
2836: case FLOATING_POINT_LITERAL:
2837: case CHARACTER_LITERAL:
2838: case STRING_LITERAL:
2839: case IDENTIFIER:
2840: case LPAREN:
2841: case BANG:
2842: case TILDE:
2843: case INCR:
2844: case DECR:
2845: case PLUS:
2846: case MINUS:
2847: StatementExpression();
2848: jj_consume_token(SEMICOLON);
2849: break;
2850: case SWITCH:
2851: SwitchStatement();
2852: break;
2853: case IF:
2854: IfStatement();
2855: break;
2856: case WHILE:
2857: WhileStatement();
2858: break;
2859: case DO:
2860: DoStatement();
2861: break;
2862: default:
2863: if (isRegularForStatement()) {
2864: ForStatement();
2865: } else {
2866: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2867: case FOR:
2868: EnhancedForStatement();
2869: break;
2870: case BREAK:
2871: BreakStatement();
2872: break;
2873: case CONTINUE:
2874: ContinueStatement();
2875: break;
2876: case RETURN:
2877: ReturnStatement();
2878: break;
2879: case SYNCHRONIZED:
2880: SynchronizedStatement();
2881: break;
2882: case THROW:
2883: ThrowStatement();
2884: break;
2885: case TRY:
2886: TryStatement();
2887: break;
2888: default:
2889: jj_consume_token(-1);
2890: throw new ParseException();
2891: }
2892: }
2893: }
2894: }
2895: }
2896:
2897: final public void LabeledStatement() throws ParseException {
2898: jj_consume_token(IDENTIFIER);
2899: jj_consume_token(COLON);
2900: Statement();
2901: }
2902:
2903: final public void Block() throws ParseException {
2904: /*@bgen(jjtree) Block */
2905: BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
2906: boolean jjtc000 = true;
2907: jjtree.openNodeScope(jjtn000);
2908: jjtreeOpenNodeScope(jjtn000);
2909: try {
2910: jj_consume_token(LBRACE);
2911: label_22: while (true) {
2912: if (jj_2_23(1)) {
2913: ;
2914: } else {
2915: break label_22;
2916: }
2917: BlockStatement();
2918: }
2919: jj_consume_token(RBRACE);
2920: } catch (Throwable jjte000) {
2921: if (jjtc000) {
2922: jjtree.clearNodeScope(jjtn000);
2923: jjtc000 = false;
2924: } else {
2925: jjtree.popNode();
2926: }
2927: if (jjte000 instanceof RuntimeException) {
2928: {
2929: if (true)
2930: throw (RuntimeException) jjte000;
2931: }
2932: }
2933: if (jjte000 instanceof ParseException) {
2934: {
2935: if (true)
2936: throw (ParseException) jjte000;
2937: }
2938: }
2939: {
2940: if (true)
2941: throw (Error) jjte000;
2942: }
2943: } finally {
2944: if (jjtc000) {
2945: jjtree.closeNodeScope(jjtn000, true);
2946: jjtreeCloseNodeScope(jjtn000);
2947: }
2948: }
2949: }
2950:
2951: final public void BlockStatement() throws ParseException {
2952: if (jj_2_24(2147483647)) {
2953: ClassDeclaration();
2954: } else if (jj_2_25(2147483647)) {
2955: MethodDeclaration();
2956: } else if (jj_2_26(2147483647)) {
2957: MethodDeclaration();
2958: } else if (jj_2_27(2147483647)) {
2959: TypedVariableDeclaration();
2960: jj_consume_token(SEMICOLON);
2961: } else if (jj_2_28(1)) {
2962: Statement();
2963: } else {
2964: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2965: case IMPORT:
2966: case STATIC:
2967: ImportDeclaration();
2968: break;
2969: case PACKAGE:
2970: PackageDeclaration();
2971: break;
2972: case FORMAL_COMMENT:
2973: FormalComment();
2974: break;
2975: default:
2976: jj_consume_token(-1);
2977: throw new ParseException();
2978: }
2979: }
2980: }
2981:
2982: final public void FormalComment() throws ParseException {
2983: /*@bgen(jjtree) #FormalComment( retainComments) */
2984: BSHFormalComment jjtn000 = new BSHFormalComment(
2985: JJTFORMALCOMMENT);
2986: boolean jjtc000 = true;
2987: jjtree.openNodeScope(jjtn000);
2988: jjtreeOpenNodeScope(jjtn000);
2989: Token t;
2990: try {
2991: t = jj_consume_token(FORMAL_COMMENT);
2992: jjtree.closeNodeScope(jjtn000, retainComments);
2993: jjtc000 = false;
2994: jjtreeCloseNodeScope(jjtn000);
2995: jjtn000.text = t.image;
2996: } finally {
2997: if (jjtc000) {
2998: jjtree.closeNodeScope(jjtn000, retainComments);
2999: jjtreeCloseNodeScope(jjtn000);
3000: }
3001: }
3002: }
3003:
3004: final public void EmptyStatement() throws ParseException {
3005: jj_consume_token(SEMICOLON);
3006: }
3007:
3008: final public void StatementExpression() throws ParseException {
3009: Expression();
3010: }
3011:
3012: final public void SwitchStatement() throws ParseException {
3013: /*@bgen(jjtree) SwitchStatement */
3014: BSHSwitchStatement jjtn000 = new BSHSwitchStatement(
3015: JJTSWITCHSTATEMENT);
3016: boolean jjtc000 = true;
3017: jjtree.openNodeScope(jjtn000);
3018: jjtreeOpenNodeScope(jjtn000);
3019: try {
3020: jj_consume_token(SWITCH);
3021: jj_consume_token(LPAREN);
3022: Expression();
3023: jj_consume_token(RPAREN);
3024: jj_consume_token(LBRACE);
3025: label_23: while (true) {
3026: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3027: case CASE:
3028: case _DEFAULT:
3029: ;
3030: break;
3031: default:
3032: break label_23;
3033: }
3034: SwitchLabel();
3035: label_24: while (true) {
3036: if (jj_2_29(1)) {
3037: ;
3038: } else {
3039: break label_24;
3040: }
3041: BlockStatement();
3042: }
3043: }
3044: jj_consume_token(RBRACE);
3045: } catch (Throwable jjte000) {
3046: if (jjtc000) {
3047: jjtree.clearNodeScope(jjtn000);
3048: jjtc000 = false;
3049: } else {
3050: jjtree.popNode();
3051: }
3052: if (jjte000 instanceof RuntimeException) {
3053: {
3054: if (true)
3055: throw (RuntimeException) jjte000;
3056: }
3057: }
3058: if (jjte000 instanceof ParseException) {
3059: {
3060: if (true)
3061: throw (ParseException) jjte000;
3062: }
3063: }
3064: {
3065: if (true)
3066: throw (Error) jjte000;
3067: }
3068: } finally {
3069: if (jjtc000) {
3070: jjtree.closeNodeScope(jjtn000, true);
3071: jjtreeCloseNodeScope(jjtn000);
3072: }
3073: }
3074: }
3075:
3076: final public void SwitchLabel() throws ParseException {
3077: /*@bgen(jjtree) SwitchLabel */
3078: BSHSwitchLabel jjtn000 = new BSHSwitchLabel(JJTSWITCHLABEL);
3079: boolean jjtc000 = true;
3080: jjtree.openNodeScope(jjtn000);
3081: jjtreeOpenNodeScope(jjtn000);
3082: try {
3083: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3084: case CASE:
3085: jj_consume_token(CASE);
3086: Expression();
3087: jj_consume_token(COLON);
3088: break;
3089: case _DEFAULT:
3090: jj_consume_token(_DEFAULT);
3091: jj_consume_token(COLON);
3092: jjtree.closeNodeScope(jjtn000, true);
3093: jjtc000 = false;
3094: jjtreeCloseNodeScope(jjtn000);
3095: jjtn000.isDefault = true;
3096: break;
3097: default:
3098: jj_consume_token(-1);
3099: throw new ParseException();
3100: }
3101: } catch (Throwable jjte000) {
3102: if (jjtc000) {
3103: jjtree.clearNodeScope(jjtn000);
3104: jjtc000 = false;
3105: } else {
3106: jjtree.popNode();
3107: }
3108: if (jjte000 instanceof RuntimeException) {
3109: {
3110: if (true)
3111: throw (RuntimeException) jjte000;
3112: }
3113: }
3114: if (jjte000 instanceof ParseException) {
3115: {
3116: if (true)
3117: throw (ParseException) jjte000;
3118: }
3119: }
3120: {
3121: if (true)
3122: throw (Error) jjte000;
3123: }
3124: } finally {
3125: if (jjtc000) {
3126: jjtree.closeNodeScope(jjtn000, true);
3127: jjtreeCloseNodeScope(jjtn000);
3128: }
3129: }
3130: }
3131:
3132: final public void IfStatement() throws ParseException {
3133: /*@bgen(jjtree) IfStatement */
3134: BSHIfStatement jjtn000 = new BSHIfStatement(JJTIFSTATEMENT);
3135: boolean jjtc000 = true;
3136: jjtree.openNodeScope(jjtn000);
3137: jjtreeOpenNodeScope(jjtn000);
3138: try {
3139: jj_consume_token(IF);
3140: jj_consume_token(LPAREN);
3141: Expression();
3142: jj_consume_token(RPAREN);
3143: Statement();
3144: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3145: case ELSE:
3146: jj_consume_token(ELSE);
3147: Statement();
3148: break;
3149: default:
3150: ;
3151: }
3152: } catch (Throwable jjte000) {
3153: if (jjtc000) {
3154: jjtree.clearNodeScope(jjtn000);
3155: jjtc000 = false;
3156: } else {
3157: jjtree.popNode();
3158: }
3159: if (jjte000 instanceof RuntimeException) {
3160: {
3161: if (true)
3162: throw (RuntimeException) jjte000;
3163: }
3164: }
3165: if (jjte000 instanceof ParseException) {
3166: {
3167: if (true)
3168: throw (ParseException) jjte000;
3169: }
3170: }
3171: {
3172: if (true)
3173: throw (Error) jjte000;
3174: }
3175: } finally {
3176: if (jjtc000) {
3177: jjtree.closeNodeScope(jjtn000, true);
3178: jjtreeCloseNodeScope(jjtn000);
3179: }
3180: }
3181: }
3182:
3183: final public void WhileStatement() throws ParseException {
3184: /*@bgen(jjtree) WhileStatement */
3185: BSHWhileStatement jjtn000 = new BSHWhileStatement(
3186: JJTWHILESTATEMENT);
3187: boolean jjtc000 = true;
3188: jjtree.openNodeScope(jjtn000);
3189: jjtreeOpenNodeScope(jjtn000);
3190: try {
3191: jj_consume_token(WHILE);
3192: jj_consume_token(LPAREN);
3193: Expression();
3194: jj_consume_token(RPAREN);
3195: Statement();
3196: } catch (Throwable jjte000) {
3197: if (jjtc000) {
3198: jjtree.clearNodeScope(jjtn000);
3199: jjtc000 = false;
3200: } else {
3201: jjtree.popNode();
3202: }
3203: if (jjte000 instanceof RuntimeException) {
3204: {
3205: if (true)
3206: throw (RuntimeException) jjte000;
3207: }
3208: }
3209: if (jjte000 instanceof ParseException) {
3210: {
3211: if (true)
3212: throw (ParseException) jjte000;
3213: }
3214: }
3215: {
3216: if (true)
3217: throw (Error) jjte000;
3218: }
3219: } finally {
3220: if (jjtc000) {
3221: jjtree.closeNodeScope(jjtn000, true);
3222: jjtreeCloseNodeScope(jjtn000);
3223: }
3224: }
3225: }
3226:
3227: /*
3228: Do statement is just a While statement with a special hook to execute
3229: at least once.
3230: */
3231: final public void DoStatement() throws ParseException {
3232: /*@bgen(jjtree) WhileStatement */
3233: BSHWhileStatement jjtn000 = new BSHWhileStatement(
3234: JJTWHILESTATEMENT);
3235: boolean jjtc000 = true;
3236: jjtree.openNodeScope(jjtn000);
3237: jjtreeOpenNodeScope(jjtn000);
3238: try {
3239: jj_consume_token(DO);
3240: Statement();
3241: jj_consume_token(WHILE);
3242: jj_consume_token(LPAREN);
3243: Expression();
3244: jj_consume_token(RPAREN);
3245: jj_consume_token(SEMICOLON);
3246: jjtree.closeNodeScope(jjtn000, true);
3247: jjtc000 = false;
3248: jjtreeCloseNodeScope(jjtn000);
3249: jjtn000.isDoStatement = true;
3250: } catch (Throwable jjte000) {
3251: if (jjtc000) {
3252: jjtree.clearNodeScope(jjtn000);
3253: jjtc000 = false;
3254: } else {
3255: jjtree.popNode();
3256: }
3257: if (jjte000 instanceof RuntimeException) {
3258: {
3259: if (true)
3260: throw (RuntimeException) jjte000;
3261: }
3262: }
3263: if (jjte000 instanceof ParseException) {
3264: {
3265: if (true)
3266: throw (ParseException) jjte000;
3267: }
3268: }
3269: {
3270: if (true)
3271: throw (Error) jjte000;
3272: }
3273: } finally {
3274: if (jjtc000) {
3275: jjtree.closeNodeScope(jjtn000, true);
3276: jjtreeCloseNodeScope(jjtn000);
3277: }
3278: }
3279: }
3280:
3281: final public void ForStatement() throws ParseException {
3282: /*@bgen(jjtree) ForStatement */
3283: BSHForStatement jjtn000 = new BSHForStatement(JJTFORSTATEMENT);
3284: boolean jjtc000 = true;
3285: jjtree.openNodeScope(jjtn000);
3286: jjtreeOpenNodeScope(jjtn000);
3287: Token t = null;
3288: try {
3289: jj_consume_token(FOR);
3290: jj_consume_token(LPAREN);
3291: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3292: case ABSTRACT:
3293: case BOOLEAN:
3294: case BYTE:
3295: case CHAR:
3296: case DOUBLE:
3297: case FALSE:
3298: case FINAL:
3299: case FLOAT:
3300: case INT:
3301: case LONG:
3302: case NATIVE:
3303: case NEW:
3304: case NULL:
3305: case PRIVATE:
3306: case PROTECTED:
3307: case PUBLIC:
3308: case SHORT:
3309: case STATIC:
3310: case STRICTFP:
3311: case SYNCHRONIZED:
3312: case TRANSIENT:
3313: case TRUE:
3314: case VOID:
3315: case VOLATILE:
3316: case INTEGER_LITERAL:
3317: case FLOATING_POINT_LITERAL:
3318: case CHARACTER_LITERAL:
3319: case STRING_LITERAL:
3320: case IDENTIFIER:
3321: case LPAREN:
3322: case BANG:
3323: case TILDE:
3324: case INCR:
3325: case DECR:
3326: case PLUS:
3327: case MINUS:
3328: ForInit();
3329: jjtn000.hasForInit = true;
3330: break;
3331: default:
3332: ;
3333: }
3334: jj_consume_token(SEMICOLON);
3335: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3336: case BOOLEAN:
3337: case BYTE:
3338: case CHAR:
3339: case DOUBLE:
3340: case FALSE:
3341: case FLOAT:
3342: case INT:
3343: case LONG:
3344: case NEW:
3345: case NULL:
3346: case SHORT:
3347: case TRUE:
3348: case VOID:
3349: case INTEGER_LITERAL:
3350: case FLOATING_POINT_LITERAL:
3351: case CHARACTER_LITERAL:
3352: case STRING_LITERAL:
3353: case IDENTIFIER:
3354: case LPAREN:
3355: case BANG:
3356: case TILDE:
3357: case INCR:
3358: case DECR:
3359: case PLUS:
3360: case MINUS:
3361: Expression();
3362: jjtn000.hasExpression = true;
3363: break;
3364: default:
3365: ;
3366: }
3367: jj_consume_token(SEMICOLON);
3368: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3369: case BOOLEAN:
3370: case BYTE:
3371: case CHAR:
3372: case DOUBLE:
3373: case FALSE:
3374: case FLOAT:
3375: case INT:
3376: case LONG:
3377: case NEW:
3378: case NULL:
3379: case SHORT:
3380: case TRUE:
3381: case VOID:
3382: case INTEGER_LITERAL:
3383: case FLOATING_POINT_LITERAL:
3384: case CHARACTER_LITERAL:
3385: case STRING_LITERAL:
3386: case IDENTIFIER:
3387: case LPAREN:
3388: case BANG:
3389: case TILDE:
3390: case INCR:
3391: case DECR:
3392: case PLUS:
3393: case MINUS:
3394: ForUpdate();
3395: jjtn000.hasForUpdate = true;
3396: break;
3397: default:
3398: ;
3399: }
3400: jj_consume_token(RPAREN);
3401: Statement();
3402: } catch (Throwable jjte000) {
3403: if (jjtc000) {
3404: jjtree.clearNodeScope(jjtn000);
3405: jjtc000 = false;
3406: } else {
3407: jjtree.popNode();
3408: }
3409: if (jjte000 instanceof RuntimeException) {
3410: {
3411: if (true)
3412: throw (RuntimeException) jjte000;
3413: }
3414: }
3415: if (jjte000 instanceof ParseException) {
3416: {
3417: if (true)
3418: throw (ParseException) jjte000;
3419: }
3420: }
3421: {
3422: if (true)
3423: throw (Error) jjte000;
3424: }
3425: } finally {
3426: if (jjtc000) {
3427: jjtree.closeNodeScope(jjtn000, true);
3428: jjtreeCloseNodeScope(jjtn000);
3429: }
3430: }
3431: }
3432:
3433: /*
3434: The new JDK1.5 enhanced for statement.
3435: e.g. for( int a : arrayOfInts ) { }
3436: We also support loose typing of the iterator var for BeanShell
3437: e.g. for( a : arrayOfInts ) { }
3438: */
3439: final public void EnhancedForStatement() throws ParseException {
3440: /*@bgen(jjtree) EnhancedForStatement */
3441: BSHEnhancedForStatement jjtn000 = new BSHEnhancedForStatement(
3442: JJTENHANCEDFORSTATEMENT);
3443: boolean jjtc000 = true;
3444: jjtree.openNodeScope(jjtn000);
3445: jjtreeOpenNodeScope(jjtn000);
3446: Token t = null;
3447: try {
3448: if (jj_2_30(4)) {
3449: jj_consume_token(FOR);
3450: jj_consume_token(LPAREN);
3451: t = jj_consume_token(IDENTIFIER);
3452: jj_consume_token(COLON);
3453: Expression();
3454: jj_consume_token(RPAREN);
3455: Statement();
3456: jjtree.closeNodeScope(jjtn000, true);
3457: jjtc000 = false;
3458: jjtreeCloseNodeScope(jjtn000);
3459: jjtn000.varName = t.image;
3460: } else {
3461: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3462: case FOR:
3463: jj_consume_token(FOR);
3464: jj_consume_token(LPAREN);
3465: Type();
3466: t = jj_consume_token(IDENTIFIER);
3467: jj_consume_token(COLON);
3468: Expression();
3469: jj_consume_token(RPAREN);
3470: Statement();
3471: jjtree.closeNodeScope(jjtn000, true);
3472: jjtc000 = false;
3473: jjtreeCloseNodeScope(jjtn000);
3474: jjtn000.varName = t.image;
3475: break;
3476: default:
3477: jj_consume_token(-1);
3478: throw new ParseException();
3479: }
3480: }
3481: } catch (Throwable jjte000) {
3482: if (jjtc000) {
3483: jjtree.clearNodeScope(jjtn000);
3484: jjtc000 = false;
3485: } else {
3486: jjtree.popNode();
3487: }
3488: if (jjte000 instanceof RuntimeException) {
3489: {
3490: if (true)
3491: throw (RuntimeException) jjte000;
3492: }
3493: }
3494: if (jjte000 instanceof ParseException) {
3495: {
3496: if (true)
3497: throw (ParseException) jjte000;
3498: }
3499: }
3500: {
3501: if (true)
3502: throw (Error) jjte000;
3503: }
3504: } finally {
3505: if (jjtc000) {
3506: jjtree.closeNodeScope(jjtn000, true);
3507: jjtreeCloseNodeScope(jjtn000);
3508: }
3509: }
3510: }
3511:
3512: final public void ForInit() throws ParseException {
3513: Token t = null;
3514: if (jj_2_31(2147483647)) {
3515: TypedVariableDeclaration();
3516: } else {
3517: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3518: case BOOLEAN:
3519: case BYTE:
3520: case CHAR:
3521: case DOUBLE:
3522: case FALSE:
3523: case FLOAT:
3524: case INT:
3525: case LONG:
3526: case NEW:
3527: case NULL:
3528: case SHORT:
3529: case TRUE:
3530: case VOID:
3531: case INTEGER_LITERAL:
3532: case FLOATING_POINT_LITERAL:
3533: case CHARACTER_LITERAL:
3534: case STRING_LITERAL:
3535: case IDENTIFIER:
3536: case LPAREN:
3537: case BANG:
3538: case TILDE:
3539: case INCR:
3540: case DECR:
3541: case PLUS:
3542: case MINUS:
3543: StatementExpressionList();
3544: break;
3545: default:
3546: jj_consume_token(-1);
3547: throw new ParseException();
3548: }
3549: }
3550: }
3551:
3552: /**
3553: Declared a typed variable.
3554: Untyped variables are not declared per-se but are handled by the part
3555: of the grammar that deals with assignments.
3556: */
3557: final public void TypedVariableDeclaration() throws ParseException {
3558: /*@bgen(jjtree) TypedVariableDeclaration */
3559: BSHTypedVariableDeclaration jjtn000 = new BSHTypedVariableDeclaration(
3560: JJTTYPEDVARIABLEDECLARATION);
3561: boolean jjtc000 = true;
3562: jjtree.openNodeScope(jjtn000);
3563: jjtreeOpenNodeScope(jjtn000);
3564: Token t = null;
3565: Modifiers mods;
3566: try {
3567: mods = Modifiers(Modifiers.FIELD, false);
3568: Type();
3569: VariableDeclarator();
3570: label_25: while (true) {
3571: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3572: case COMMA:
3573: ;
3574: break;
3575: default:
3576: break label_25;
3577: }
3578: jj_consume_token(COMMA);
3579: VariableDeclarator();
3580: }
3581: jjtree.closeNodeScope(jjtn000, true);
3582: jjtc000 = false;
3583: jjtreeCloseNodeScope(jjtn000);
3584: jjtn000.modifiers = mods;
3585: } catch (Throwable jjte000) {
3586: if (jjtc000) {
3587: jjtree.clearNodeScope(jjtn000);
3588: jjtc000 = false;
3589: } else {
3590: jjtree.popNode();
3591: }
3592: if (jjte000 instanceof RuntimeException) {
3593: {
3594: if (true)
3595: throw (RuntimeException) jjte000;
3596: }
3597: }
3598: if (jjte000 instanceof ParseException) {
3599: {
3600: if (true)
3601: throw (ParseException) jjte000;
3602: }
3603: }
3604: {
3605: if (true)
3606: throw (Error) jjte000;
3607: }
3608: } finally {
3609: if (jjtc000) {
3610: jjtree.closeNodeScope(jjtn000, true);
3611: jjtreeCloseNodeScope(jjtn000);
3612: }
3613: }
3614: }
3615:
3616: final public void StatementExpressionList() throws ParseException {
3617: /*@bgen(jjtree) StatementExpressionList */
3618: BSHStatementExpressionList jjtn000 = new BSHStatementExpressionList(
3619: JJTSTATEMENTEXPRESSIONLIST);
3620: boolean jjtc000 = true;
3621: jjtree.openNodeScope(jjtn000);
3622: jjtreeOpenNodeScope(jjtn000);
3623: try {
3624: StatementExpression();
3625: label_26: while (true) {
3626: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3627: case COMMA:
3628: ;
3629: break;
3630: default:
3631: break label_26;
3632: }
3633: jj_consume_token(COMMA);
3634: StatementExpression();
3635: }
3636: } catch (Throwable jjte000) {
3637: if (jjtc000) {
3638: jjtree.clearNodeScope(jjtn000);
3639: jjtc000 = false;
3640: } else {
3641: jjtree.popNode();
3642: }
3643: if (jjte000 instanceof RuntimeException) {
3644: {
3645: if (true)
3646: throw (RuntimeException) jjte000;
3647: }
3648: }
3649: if (jjte000 instanceof ParseException) {
3650: {
3651: if (true)
3652: throw (ParseException) jjte000;
3653: }
3654: }
3655: {
3656: if (true)
3657: throw (Error) jjte000;
3658: }
3659: } finally {
3660: if (jjtc000) {
3661: jjtree.closeNodeScope(jjtn000, true);
3662: jjtreeCloseNodeScope(jjtn000);
3663: }
3664: }
3665: }
3666:
3667: final public void ForUpdate() throws ParseException {
3668: StatementExpressionList();
3669: }
3670:
3671: final public void BreakStatement() throws ParseException {
3672: /*@bgen(jjtree) ReturnStatement */
3673: BSHReturnStatement jjtn000 = new BSHReturnStatement(
3674: JJTRETURNSTATEMENT);
3675: boolean jjtc000 = true;
3676: jjtree.openNodeScope(jjtn000);
3677: jjtreeOpenNodeScope(jjtn000);
3678: try {
3679: jj_consume_token(BREAK);
3680: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3681: case IDENTIFIER:
3682: jj_consume_token(IDENTIFIER);
3683: break;
3684: default:
3685: ;
3686: }
3687: jj_consume_token(SEMICOLON);
3688: jjtree.closeNodeScope(jjtn000, true);
3689: jjtc000 = false;
3690: jjtreeCloseNodeScope(jjtn000);
3691: jjtn000.kind = BREAK;
3692: } finally {
3693: if (jjtc000) {
3694: jjtree.closeNodeScope(jjtn000, true);
3695: jjtreeCloseNodeScope(jjtn000);
3696: }
3697: }
3698: }
3699:
3700: final public void ContinueStatement() throws ParseException {
3701: /*@bgen(jjtree) ReturnStatement */
3702: BSHReturnStatement jjtn000 = new BSHReturnStatement(
3703: JJTRETURNSTATEMENT);
3704: boolean jjtc000 = true;
3705: jjtree.openNodeScope(jjtn000);
3706: jjtreeOpenNodeScope(jjtn000);
3707: try {
3708: jj_consume_token(CONTINUE);
3709: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3710: case IDENTIFIER:
3711: jj_consume_token(IDENTIFIER);
3712: break;
3713: default:
3714: ;
3715: }
3716: jj_consume_token(SEMICOLON);
3717: jjtree.closeNodeScope(jjtn000, true);
3718: jjtc000 = false;
3719: jjtreeCloseNodeScope(jjtn000);
3720: jjtn000.kind = CONTINUE;
3721: } finally {
3722: if (jjtc000) {
3723: jjtree.closeNodeScope(jjtn000, true);
3724: jjtreeCloseNodeScope(jjtn000);
3725: }
3726: }
3727: }
3728:
3729: final public void ReturnStatement() throws ParseException {
3730: /*@bgen(jjtree) ReturnStatement */
3731: BSHReturnStatement jjtn000 = new BSHReturnStatement(
3732: JJTRETURNSTATEMENT);
3733: boolean jjtc000 = true;
3734: jjtree.openNodeScope(jjtn000);
3735: jjtreeOpenNodeScope(jjtn000);
3736: try {
3737: jj_consume_token(RETURN);
3738: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3739: case BOOLEAN:
3740: case BYTE:
3741: case CHAR:
3742: case DOUBLE:
3743: case FALSE:
3744: case FLOAT:
3745: case INT:
3746: case LONG:
3747: case NEW:
3748: case NULL:
3749: case SHORT:
3750: case TRUE:
3751: case VOID:
3752: case INTEGER_LITERAL:
3753: case FLOATING_POINT_LITERAL:
3754: case CHARACTER_LITERAL:
3755: case STRING_LITERAL:
3756: case IDENTIFIER:
3757: case LPAREN:
3758: case BANG:
3759: case TILDE:
3760: case INCR:
3761: case DECR:
3762: case PLUS:
3763: case MINUS:
3764: Expression();
3765: break;
3766: default:
3767: ;
3768: }
3769: jj_consume_token(SEMICOLON);
3770: jjtree.closeNodeScope(jjtn000, true);
3771: jjtc000 = false;
3772: jjtreeCloseNodeScope(jjtn000);
3773: jjtn000.kind = RETURN;
3774: } catch (Throwable jjte000) {
3775: if (jjtc000) {
3776: jjtree.clearNodeScope(jjtn000);
3777: jjtc000 = false;
3778: } else {
3779: jjtree.popNode();
3780: }
3781: if (jjte000 instanceof RuntimeException) {
3782: {
3783: if (true)
3784: throw (RuntimeException) jjte000;
3785: }
3786: }
3787: if (jjte000 instanceof ParseException) {
3788: {
3789: if (true)
3790: throw (ParseException) jjte000;
3791: }
3792: }
3793: {
3794: if (true)
3795: throw (Error) jjte000;
3796: }
3797: } finally {
3798: if (jjtc000) {
3799: jjtree.closeNodeScope(jjtn000, true);
3800: jjtreeCloseNodeScope(jjtn000);
3801: }
3802: }
3803: }
3804:
3805: final public void SynchronizedStatement() throws ParseException {
3806: /*@bgen(jjtree) Block */
3807: BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
3808: boolean jjtc000 = true;
3809: jjtree.openNodeScope(jjtn000);
3810: jjtreeOpenNodeScope(jjtn000);
3811: try {
3812: jj_consume_token(SYNCHRONIZED);
3813: jj_consume_token(LPAREN);
3814: Expression();
3815: jj_consume_token(RPAREN);
3816: Block();
3817: jjtree.closeNodeScope(jjtn000, true);
3818: jjtc000 = false;
3819: jjtreeCloseNodeScope(jjtn000);
3820: jjtn000.isSynchronized = true;
3821: } catch (Throwable jjte000) {
3822: if (jjtc000) {
3823: jjtree.clearNodeScope(jjtn000);
3824: jjtc000 = false;
3825: } else {
3826: jjtree.popNode();
3827: }
3828: if (jjte000 instanceof RuntimeException) {
3829: {
3830: if (true)
3831: throw (RuntimeException) jjte000;
3832: }
3833: }
3834: if (jjte000 instanceof ParseException) {
3835: {
3836: if (true)
3837: throw (ParseException) jjte000;
3838: }
3839: }
3840: {
3841: if (true)
3842: throw (Error) jjte000;
3843: }
3844: } finally {
3845: if (jjtc000) {
3846: jjtree.closeNodeScope(jjtn000, true);
3847: jjtreeCloseNodeScope(jjtn000);
3848: }
3849: }
3850: }
3851:
3852: final public void ThrowStatement() throws ParseException {
3853: /*@bgen(jjtree) ThrowStatement */
3854: BSHThrowStatement jjtn000 = new BSHThrowStatement(
3855: JJTTHROWSTATEMENT);
3856: boolean jjtc000 = true;
3857: jjtree.openNodeScope(jjtn000);
3858: jjtreeOpenNodeScope(jjtn000);
3859: try {
3860: jj_consume_token(THROW);
3861: Expression();
3862: jj_consume_token(SEMICOLON);
3863: } catch (Throwable jjte000) {
3864: if (jjtc000) {
3865: jjtree.clearNodeScope(jjtn000);
3866: jjtc000 = false;
3867: } else {
3868: jjtree.popNode();
3869: }
3870: if (jjte000 instanceof RuntimeException) {
3871: {
3872: if (true)
3873: throw (RuntimeException) jjte000;
3874: }
3875: }
3876: if (jjte000 instanceof ParseException) {
3877: {
3878: if (true)
3879: throw (ParseException) jjte000;
3880: }
3881: }
3882: {
3883: if (true)
3884: throw (Error) jjte000;
3885: }
3886: } finally {
3887: if (jjtc000) {
3888: jjtree.closeNodeScope(jjtn000, true);
3889: jjtreeCloseNodeScope(jjtn000);
3890: }
3891: }
3892: }
3893:
3894: final public void TryStatement() throws ParseException {
3895: /*@bgen(jjtree) TryStatement */
3896: BSHTryStatement jjtn000 = new BSHTryStatement(JJTTRYSTATEMENT);
3897: boolean jjtc000 = true;
3898: jjtree.openNodeScope(jjtn000);
3899: jjtreeOpenNodeScope(jjtn000);
3900: boolean closed = false;
3901: try {
3902: jj_consume_token(TRY);
3903: Block();
3904: label_27: while (true) {
3905: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3906: case CATCH:
3907: ;
3908: break;
3909: default:
3910: break label_27;
3911: }
3912: jj_consume_token(CATCH);
3913: jj_consume_token(LPAREN);
3914: FormalParameter();
3915: jj_consume_token(RPAREN);
3916: Block();
3917: closed = true;
3918: }
3919: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3920: case FINALLY:
3921: jj_consume_token(FINALLY);
3922: Block();
3923: closed = true;
3924: break;
3925: default:
3926: ;
3927: }
3928: jjtree.closeNodeScope(jjtn000, true);
3929: jjtc000 = false;
3930: jjtreeCloseNodeScope(jjtn000);
3931: if (!closed) {
3932: if (true)
3933: throw generateParseException();
3934: }
3935: } catch (Throwable jjte000) {
3936: if (jjtc000) {
3937: jjtree.clearNodeScope(jjtn000);
3938: jjtc000 = false;
3939: } else {
3940: jjtree.popNode();
3941: }
3942: if (jjte000 instanceof RuntimeException) {
3943: {
3944: if (true)
3945: throw (RuntimeException) jjte000;
3946: }
3947: }
3948: if (jjte000 instanceof ParseException) {
3949: {
3950: if (true)
3951: throw (ParseException) jjte000;
3952: }
3953: }
3954: {
3955: if (true)
3956: throw (Error) jjte000;
3957: }
3958: } finally {
3959: if (jjtc000) {
3960: jjtree.closeNodeScope(jjtn000, true);
3961: jjtreeCloseNodeScope(jjtn000);
3962: }
3963: }
3964: }
3965:
3966: final private boolean jj_2_1(int xla) {
3967: jj_la = xla;
3968: jj_lastpos = jj_scanpos = token;
3969: try {
3970: return !jj_3_1();
3971: } catch (LookaheadSuccess ls) {
3972: return true;
3973: }
3974: }
3975:
3976: final private boolean jj_2_2(int xla) {
3977: jj_la = xla;
3978: jj_lastpos = jj_scanpos = token;
3979: try {
3980: return !jj_3_2();
3981: } catch (LookaheadSuccess ls) {
3982: return true;
3983: }
3984: }
3985:
3986: final private boolean jj_2_3(int xla) {
3987: jj_la = xla;
3988: jj_lastpos = jj_scanpos = token;
3989: try {
3990: return !jj_3_3();
3991: } catch (LookaheadSuccess ls) {
3992: return true;
3993: }
3994: }
3995:
3996: final private boolean jj_2_4(int xla) {
3997: jj_la = xla;
3998: jj_lastpos = jj_scanpos = token;
3999: try {
4000: return !jj_3_4();
4001: } catch (LookaheadSuccess ls) {
4002: return true;
4003: }
4004: }
4005:
4006: final private boolean jj_2_5(int xla) {
4007: jj_la = xla;
4008: jj_lastpos = jj_scanpos = token;
4009: try {
4010: return !jj_3_5();
4011: } catch (LookaheadSuccess ls) {
4012: return true;
4013: }
4014: }
4015:
4016: final private boolean jj_2_6(int xla) {
4017: jj_la = xla;
4018: jj_lastpos = jj_scanpos = token;
4019: try {
4020: return !jj_3_6();
4021: } catch (LookaheadSuccess ls) {
4022: return true;
4023: }
4024: }
4025:
4026: final private boolean jj_2_7(int xla) {
4027: jj_la = xla;
4028: jj_lastpos = jj_scanpos = token;
4029: try {
4030: return !jj_3_7();
4031: } catch (LookaheadSuccess ls) {
4032: return true;
4033: }
4034: }
4035:
4036: final private boolean jj_2_8(int xla) {
4037: jj_la = xla;
4038: jj_lastpos = jj_scanpos = token;
4039: try {
4040: return !jj_3_8();
4041: } catch (LookaheadSuccess ls) {
4042: return true;
4043: }
4044: }
4045:
4046: final private boolean jj_2_9(int xla) {
4047: jj_la = xla;
4048: jj_lastpos = jj_scanpos = token;
4049: try {
4050: return !jj_3_9();
4051: } catch (LookaheadSuccess ls) {
4052: return true;
4053: }
4054: }
4055:
4056: final private boolean jj_2_10(int xla) {
4057: jj_la = xla;
4058: jj_lastpos = jj_scanpos = token;
4059: try {
4060: return !jj_3_10();
4061: } catch (LookaheadSuccess ls) {
4062: return true;
4063: }
4064: }
4065:
4066: final private boolean jj_2_11(int xla) {
4067: jj_la = xla;
4068: jj_lastpos = jj_scanpos = token;
4069: try {
4070: return !jj_3_11();
4071: } catch (LookaheadSuccess ls) {
4072: return true;
4073: }
4074: }
4075:
4076: final private boolean jj_2_12(int xla) {
4077: jj_la = xla;
4078: jj_lastpos = jj_scanpos = token;
4079: try {
4080: return !jj_3_12();
4081: } catch (LookaheadSuccess ls) {
4082: return true;
4083: }
4084: }
4085:
4086: final private boolean jj_2_13(int xla) {
4087: jj_la = xla;
4088: jj_lastpos = jj_scanpos = token;
4089: try {
4090: return !jj_3_13();
4091: } catch (LookaheadSuccess ls) {
4092: return true;
4093: }
4094: }
4095:
4096: final private boolean jj_2_14(int xla) {
4097: jj_la = xla;
4098: jj_lastpos = jj_scanpos = token;
4099: try {
4100: return !jj_3_14();
4101: } catch (LookaheadSuccess ls) {
4102: return true;
4103: }
4104: }
4105:
4106: final private boolean jj_2_15(int xla) {
4107: jj_la = xla;
4108: jj_lastpos = jj_scanpos = token;
4109: try {
4110: return !jj_3_15();
4111: } catch (LookaheadSuccess ls) {
4112: return true;
4113: }
4114: }
4115:
4116: final private boolean jj_2_16(int xla) {
4117: jj_la = xla;
4118: jj_lastpos = jj_scanpos = token;
4119: try {
4120: return !jj_3_16();
4121: } catch (LookaheadSuccess ls) {
4122: return true;
4123: }
4124: }
4125:
4126: final private boolean jj_2_17(int xla) {
4127: jj_la = xla;
4128: jj_lastpos = jj_scanpos = token;
4129: try {
4130: return !jj_3_17();
4131: } catch (LookaheadSuccess ls) {
4132: return true;
4133: }
4134: }
4135:
4136: final private boolean jj_2_18(int xla) {
4137: jj_la = xla;
4138: jj_lastpos = jj_scanpos = token;
4139: try {
4140: return !jj_3_18();
4141: } catch (LookaheadSuccess ls) {
4142: return true;
4143: }
4144: }
4145:
4146: final private boolean jj_2_19(int xla) {
4147: jj_la = xla;
4148: jj_lastpos = jj_scanpos = token;
4149: try {
4150: return !jj_3_19();
4151: } catch (LookaheadSuccess ls) {
4152: return true;
4153: }
4154: }
4155:
4156: final private boolean jj_2_20(int xla) {
4157: jj_la = xla;
4158: jj_lastpos = jj_scanpos = token;
4159: try {
4160: return !jj_3_20();
4161: } catch (LookaheadSuccess ls) {
4162: return true;
4163: }
4164: }
4165:
4166: final private boolean jj_2_21(int xla) {
4167: jj_la = xla;
4168: jj_lastpos = jj_scanpos = token;
4169: try {
4170: return !jj_3_21();
4171: } catch (LookaheadSuccess ls) {
4172: return true;
4173: }
4174: }
4175:
4176: final private boolean jj_2_22(int xla) {
4177: jj_la = xla;
4178: jj_lastpos = jj_scanpos = token;
4179: try {
4180: return !jj_3_22();
4181: } catch (LookaheadSuccess ls) {
4182: return true;
4183: }
4184: }
4185:
4186: final private boolean jj_2_23(int xla) {
4187: jj_la = xla;
4188: jj_lastpos = jj_scanpos = token;
4189: try {
4190: return !jj_3_23();
4191: } catch (LookaheadSuccess ls) {
4192: return true;
4193: }
4194: }
4195:
4196: final private boolean jj_2_24(int xla) {
4197: jj_la = xla;
4198: jj_lastpos = jj_scanpos = token;
4199: try {
4200: return !jj_3_24();
4201: } catch (LookaheadSuccess ls) {
4202: return true;
4203: }
4204: }
4205:
4206: final private boolean jj_2_25(int xla) {
4207: jj_la = xla;
4208: jj_lastpos = jj_scanpos = token;
4209: try {
4210: return !jj_3_25();
4211: } catch (LookaheadSuccess ls) {
4212: return true;
4213: }
4214: }
4215:
4216: final private boolean jj_2_26(int xla) {
4217: jj_la = xla;
4218: jj_lastpos = jj_scanpos = token;
4219: try {
4220: return !jj_3_26();
4221: } catch (LookaheadSuccess ls) {
4222: return true;
4223: }
4224: }
4225:
4226: final private boolean jj_2_27(int xla) {
4227: jj_la = xla;
4228: jj_lastpos = jj_scanpos = token;
4229: try {
4230: return !jj_3_27();
4231: } catch (LookaheadSuccess ls) {
4232: return true;
4233: }
4234: }
4235:
4236: final private boolean jj_2_28(int xla) {
4237: jj_la = xla;
4238: jj_lastpos = jj_scanpos = token;
4239: try {
4240: return !jj_3_28();
4241: } catch (LookaheadSuccess ls) {
4242: return true;
4243: }
4244: }
4245:
4246: final private boolean jj_2_29(int xla) {
4247: jj_la = xla;
4248: jj_lastpos = jj_scanpos = token;
4249: try {
4250: return !jj_3_29();
4251: } catch (LookaheadSuccess ls) {
4252: return true;
4253: }
4254: }
4255:
4256: final private boolean jj_2_30(int xla) {
4257: jj_la = xla;
4258: jj_lastpos = jj_scanpos = token;
4259: try {
4260: return !jj_3_30();
4261: } catch (LookaheadSuccess ls) {
4262: return true;
4263: }
4264: }
4265:
4266: final private boolean jj_2_31(int xla) {
4267: jj_la = xla;
4268: jj_lastpos = jj_scanpos = token;
4269: try {
4270: return !jj_3_31();
4271: } catch (LookaheadSuccess ls) {
4272: return true;
4273: }
4274: }
4275:
4276: final private boolean jj_3R_46() {
4277: if (jj_3R_91())
4278: return true;
4279: return false;
4280: }
4281:
4282: final private boolean jj_3R_28() {
4283: Token xsp;
4284: xsp = jj_scanpos;
4285: if (jj_3R_46()) {
4286: jj_scanpos = xsp;
4287: if (jj_3R_47()) {
4288: jj_scanpos = xsp;
4289: if (jj_3R_48()) {
4290: jj_scanpos = xsp;
4291: if (jj_3R_49()) {
4292: jj_scanpos = xsp;
4293: if (jj_3_28()) {
4294: jj_scanpos = xsp;
4295: if (jj_3R_50()) {
4296: jj_scanpos = xsp;
4297: if (jj_3R_51()) {
4298: jj_scanpos = xsp;
4299: if (jj_3R_52())
4300: return true;
4301: }
4302: }
4303: }
4304: }
4305: }
4306: }
4307: }
4308: return false;
4309: }
4310:
4311: final private boolean jj_3_23() {
4312: if (jj_3R_28())
4313: return true;
4314: return false;
4315: }
4316:
4317: final private boolean jj_3R_161() {
4318: if (jj_3R_164())
4319: return true;
4320: Token xsp;
4321: while (true) {
4322: xsp = jj_scanpos;
4323: if (jj_3R_169()) {
4324: jj_scanpos = xsp;
4325: break;
4326: }
4327: }
4328: return false;
4329: }
4330:
4331: final private boolean jj_3R_38() {
4332: if (jj_scan_token(LBRACE))
4333: return true;
4334: Token xsp;
4335: while (true) {
4336: xsp = jj_scanpos;
4337: if (jj_3_23()) {
4338: jj_scanpos = xsp;
4339: break;
4340: }
4341: }
4342: if (jj_scan_token(RBRACE))
4343: return true;
4344: return false;
4345: }
4346:
4347: final private boolean jj_3R_158() {
4348: if (jj_3R_161())
4349: return true;
4350: Token xsp;
4351: while (true) {
4352: xsp = jj_scanpos;
4353: if (jj_3R_167()) {
4354: jj_scanpos = xsp;
4355: break;
4356: }
4357: }
4358: return false;
4359: }
4360:
4361: final private boolean jj_3R_40() {
4362: if (jj_scan_token(IDENTIFIER))
4363: return true;
4364: if (jj_scan_token(COLON))
4365: return true;
4366: if (jj_3R_45())
4367: return true;
4368: return false;
4369: }
4370:
4371: final private boolean jj_3R_156() {
4372: if (jj_scan_token(HOOK))
4373: return true;
4374: if (jj_3R_39())
4375: return true;
4376: if (jj_scan_token(COLON))
4377: return true;
4378: if (jj_3R_108())
4379: return true;
4380: return false;
4381: }
4382:
4383: final private boolean jj_3R_165() {
4384: Token xsp;
4385: xsp = jj_scanpos;
4386: if (jj_scan_token(108)) {
4387: jj_scanpos = xsp;
4388: if (jj_scan_token(109))
4389: return true;
4390: }
4391: if (jj_3R_158())
4392: return true;
4393: return false;
4394: }
4395:
4396: final private boolean jj_3R_153() {
4397: if (jj_3R_158())
4398: return true;
4399: Token xsp;
4400: while (true) {
4401: xsp = jj_scanpos;
4402: if (jj_3R_165()) {
4403: jj_scanpos = xsp;
4404: break;
4405: }
4406: }
4407: return false;
4408: }
4409:
4410: final private boolean jj_3R_90() {
4411: if (jj_3R_124())
4412: return true;
4413: return false;
4414: }
4415:
4416: final private boolean jj_3R_89() {
4417: if (jj_3R_123())
4418: return true;
4419: return false;
4420: }
4421:
4422: final private boolean jj_3R_88() {
4423: if (jj_3R_122())
4424: return true;
4425: return false;
4426: }
4427:
4428: final private boolean jj_3R_162() {
4429: Token xsp;
4430: xsp = jj_scanpos;
4431: if (jj_scan_token(98)) {
4432: jj_scanpos = xsp;
4433: if (jj_scan_token(99))
4434: return true;
4435: }
4436: if (jj_3R_153())
4437: return true;
4438: return false;
4439: }
4440:
4441: final private boolean jj_3R_87() {
4442: if (jj_3R_121())
4443: return true;
4444: return false;
4445: }
4446:
4447: final private boolean jj_3R_148() {
4448: if (jj_3R_153())
4449: return true;
4450: Token xsp;
4451: while (true) {
4452: xsp = jj_scanpos;
4453: if (jj_3R_162()) {
4454: jj_scanpos = xsp;
4455: break;
4456: }
4457: }
4458: return false;
4459: }
4460:
4461: final private boolean jj_3R_86() {
4462: if (jj_3R_120())
4463: return true;
4464: return false;
4465: }
4466:
4467: final private boolean jj_3R_85() {
4468: if (jj_3R_119())
4469: return true;
4470: return false;
4471: }
4472:
4473: final private boolean jj_3R_84() {
4474: if (jj_3R_118())
4475: return true;
4476: return false;
4477: }
4478:
4479: final private boolean jj_3R_159() {
4480: Token xsp;
4481: xsp = jj_scanpos;
4482: if (jj_scan_token(96)) {
4483: jj_scanpos = xsp;
4484: if (jj_scan_token(97))
4485: return true;
4486: }
4487: if (jj_3R_148())
4488: return true;
4489: return false;
4490: }
4491:
4492: final private boolean jj_3R_83() {
4493: if (jj_3R_117())
4494: return true;
4495: return false;
4496: }
4497:
4498: final private boolean jj_3R_135() {
4499: if (jj_3R_148())
4500: return true;
4501: Token xsp;
4502: while (true) {
4503: xsp = jj_scanpos;
4504: if (jj_3R_159()) {
4505: jj_scanpos = xsp;
4506: break;
4507: }
4508: }
4509: return false;
4510: }
4511:
4512: final private boolean jj_3R_82() {
4513: if (jj_3R_116())
4514: return true;
4515: return false;
4516: }
4517:
4518: final private boolean jj_3R_81() {
4519: if (jj_3R_115())
4520: return true;
4521: return false;
4522: }
4523:
4524: final private boolean jj_3R_80() {
4525: if (jj_3R_114())
4526: return true;
4527: return false;
4528: }
4529:
4530: final private boolean jj_3R_108() {
4531: if (jj_3R_135())
4532: return true;
4533: Token xsp;
4534: xsp = jj_scanpos;
4535: if (jj_3R_156())
4536: jj_scanpos = xsp;
4537: return false;
4538: }
4539:
4540: final private boolean jj_3R_79() {
4541: if (jj_3R_113())
4542: return true;
4543: return false;
4544: }
4545:
4546: final private boolean jj_3R_78() {
4547: if (jj_3R_112())
4548: return true;
4549: if (jj_scan_token(SEMICOLON))
4550: return true;
4551: return false;
4552: }
4553:
4554: final private boolean jj_3_17() {
4555: if (jj_3R_38())
4556: return true;
4557: return false;
4558: }
4559:
4560: final private boolean jj_3R_77() {
4561: if (jj_3R_38())
4562: return true;
4563: return false;
4564: }
4565:
4566: final private boolean jj_3R_45() {
4567: Token xsp;
4568: xsp = jj_scanpos;
4569: if (jj_3_22()) {
4570: jj_scanpos = xsp;
4571: if (jj_3R_77()) {
4572: jj_scanpos = xsp;
4573: if (jj_scan_token(78)) {
4574: jj_scanpos = xsp;
4575: if (jj_3R_78()) {
4576: jj_scanpos = xsp;
4577: if (jj_3R_79()) {
4578: jj_scanpos = xsp;
4579: if (jj_3R_80()) {
4580: jj_scanpos = xsp;
4581: if (jj_3R_81()) {
4582: jj_scanpos = xsp;
4583: if (jj_3R_82()) {
4584: jj_scanpos = xsp;
4585: lookingAhead = true;
4586: jj_semLA = isRegularForStatement();
4587: lookingAhead = false;
4588: if (!jj_semLA || jj_3R_83()) {
4589: jj_scanpos = xsp;
4590: if (jj_3R_84()) {
4591: jj_scanpos = xsp;
4592: if (jj_3R_85()) {
4593: jj_scanpos = xsp;
4594: if (jj_3R_86()) {
4595: jj_scanpos = xsp;
4596: if (jj_3R_87()) {
4597: jj_scanpos = xsp;
4598: if (jj_3R_88()) {
4599: jj_scanpos = xsp;
4600: if (jj_3R_89()) {
4601: jj_scanpos = xsp;
4602: if (jj_3R_90())
4603: return true;
4604: }
4605: }
4606: }
4607: }
4608: }
4609: }
4610: }
4611: }
4612: }
4613: }
4614: }
4615: }
4616: }
4617: }
4618: }
4619: return false;
4620: }
4621:
4622: final private boolean jj_3_22() {
4623: if (jj_3R_40())
4624: return true;
4625: return false;
4626: }
4627:
4628: final private boolean jj_3R_34() {
4629: Token xsp;
4630: xsp = jj_scanpos;
4631: if (jj_scan_token(81)) {
4632: jj_scanpos = xsp;
4633: if (jj_scan_token(120)) {
4634: jj_scanpos = xsp;
4635: if (jj_scan_token(121)) {
4636: jj_scanpos = xsp;
4637: if (jj_scan_token(127)) {
4638: jj_scanpos = xsp;
4639: if (jj_scan_token(118)) {
4640: jj_scanpos = xsp;
4641: if (jj_scan_token(119)) {
4642: jj_scanpos = xsp;
4643: if (jj_scan_token(122)) {
4644: jj_scanpos = xsp;
4645: if (jj_scan_token(126)) {
4646: jj_scanpos = xsp;
4647: if (jj_scan_token(124)) {
4648: jj_scanpos = xsp;
4649: if (jj_scan_token(128)) {
4650: jj_scanpos = xsp;
4651: if (jj_scan_token(129)) {
4652: jj_scanpos = xsp;
4653: if (jj_scan_token(130)) {
4654: jj_scanpos = xsp;
4655: if (jj_scan_token(131)) {
4656: jj_scanpos = xsp;
4657: if (jj_scan_token(132)) {
4658: jj_scanpos = xsp;
4659: if (jj_scan_token(133))
4660: return true;
4661: }
4662: }
4663: }
4664: }
4665: }
4666: }
4667: }
4668: }
4669: }
4670: }
4671: }
4672: }
4673: }
4674: }
4675: return false;
4676: }
4677:
4678: final private boolean jj_3R_111() {
4679: if (jj_scan_token(COMMA))
4680: return true;
4681: if (jj_3R_29())
4682: return true;
4683: return false;
4684: }
4685:
4686: final private boolean jj_3R_160() {
4687: if (jj_scan_token(LBRACKET))
4688: return true;
4689: if (jj_scan_token(RBRACKET))
4690: return true;
4691: return false;
4692: }
4693:
4694: final private boolean jj_3R_152() {
4695: if (jj_3R_69())
4696: return true;
4697: Token xsp;
4698: xsp = jj_scanpos;
4699: if (jj_3_17())
4700: jj_scanpos = xsp;
4701: return false;
4702: }
4703:
4704: final private boolean jj_3R_157() {
4705: Token xsp;
4706: if (jj_3R_160())
4707: return true;
4708: while (true) {
4709: xsp = jj_scanpos;
4710: if (jj_3R_160()) {
4711: jj_scanpos = xsp;
4712: break;
4713: }
4714: }
4715: if (jj_3R_97())
4716: return true;
4717: return false;
4718: }
4719:
4720: final private boolean jj_3_8() {
4721: if (jj_3R_33())
4722: return true;
4723: if (jj_3R_34())
4724: return true;
4725: return false;
4726: }
4727:
4728: final private boolean jj_3_20() {
4729: if (jj_scan_token(LBRACKET))
4730: return true;
4731: if (jj_scan_token(RBRACKET))
4732: return true;
4733: return false;
4734: }
4735:
4736: final private boolean jj_3R_151() {
4737: if (jj_3R_150())
4738: return true;
4739: return false;
4740: }
4741:
4742: final private boolean jj_3_19() {
4743: if (jj_scan_token(LBRACKET))
4744: return true;
4745: if (jj_3R_39())
4746: return true;
4747: if (jj_scan_token(RBRACKET))
4748: return true;
4749: return false;
4750: }
4751:
4752: final private boolean jj_3R_107() {
4753: if (jj_3R_33())
4754: return true;
4755: if (jj_3R_34())
4756: return true;
4757: if (jj_3R_39())
4758: return true;
4759: return false;
4760: }
4761:
4762: final private boolean jj_3_21() {
4763: Token xsp;
4764: if (jj_3_19())
4765: return true;
4766: while (true) {
4767: xsp = jj_scanpos;
4768: if (jj_3_19()) {
4769: jj_scanpos = xsp;
4770: break;
4771: }
4772: }
4773: while (true) {
4774: xsp = jj_scanpos;
4775: if (jj_3_20()) {
4776: jj_scanpos = xsp;
4777: break;
4778: }
4779: }
4780: return false;
4781: }
4782:
4783: final private boolean jj_3R_150() {
4784: Token xsp;
4785: xsp = jj_scanpos;
4786: if (jj_3_21()) {
4787: jj_scanpos = xsp;
4788: if (jj_3R_157())
4789: return true;
4790: }
4791: return false;
4792: }
4793:
4794: final private boolean jj_3R_71() {
4795: if (jj_3R_108())
4796: return true;
4797: return false;
4798: }
4799:
4800: final private boolean jj_3R_39() {
4801: Token xsp;
4802: xsp = jj_scanpos;
4803: if (jj_3R_70()) {
4804: jj_scanpos = xsp;
4805: if (jj_3R_71())
4806: return true;
4807: }
4808: return false;
4809: }
4810:
4811: final private boolean jj_3R_70() {
4812: if (jj_3R_107())
4813: return true;
4814: return false;
4815: }
4816:
4817: final private boolean jj_3R_145() {
4818: if (jj_scan_token(NEW))
4819: return true;
4820: if (jj_3R_29())
4821: return true;
4822: Token xsp;
4823: xsp = jj_scanpos;
4824: if (jj_3R_151()) {
4825: jj_scanpos = xsp;
4826: if (jj_3R_152())
4827: return true;
4828: }
4829: return false;
4830: }
4831:
4832: final private boolean jj_3_18() {
4833: if (jj_scan_token(NEW))
4834: return true;
4835: if (jj_3R_36())
4836: return true;
4837: if (jj_3R_150())
4838: return true;
4839: return false;
4840: }
4841:
4842: final private boolean jj_3R_130() {
4843: Token xsp;
4844: xsp = jj_scanpos;
4845: if (jj_3_18()) {
4846: jj_scanpos = xsp;
4847: if (jj_3R_145())
4848: return true;
4849: }
4850: return false;
4851: }
4852:
4853: final private boolean jj_3R_147() {
4854: if (jj_scan_token(COMMA))
4855: return true;
4856: if (jj_3R_39())
4857: return true;
4858: return false;
4859: }
4860:
4861: final private boolean jj_3R_76() {
4862: if (jj_3R_29())
4863: return true;
4864: Token xsp;
4865: while (true) {
4866: xsp = jj_scanpos;
4867: if (jj_3R_111()) {
4868: jj_scanpos = xsp;
4869: break;
4870: }
4871: }
4872: return false;
4873: }
4874:
4875: final private boolean jj_3R_134() {
4876: if (jj_3R_39())
4877: return true;
4878: Token xsp;
4879: while (true) {
4880: xsp = jj_scanpos;
4881: if (jj_3R_147()) {
4882: jj_scanpos = xsp;
4883: break;
4884: }
4885: }
4886: return false;
4887: }
4888:
4889: final private boolean jj_3R_106() {
4890: if (jj_3R_134())
4891: return true;
4892: return false;
4893: }
4894:
4895: final private boolean jj_3_7() {
4896: if (jj_scan_token(DOT))
4897: return true;
4898: if (jj_scan_token(IDENTIFIER))
4899: return true;
4900: return false;
4901: }
4902:
4903: final private boolean jj_3R_69() {
4904: if (jj_scan_token(LPAREN))
4905: return true;
4906: Token xsp;
4907: xsp = jj_scanpos;
4908: if (jj_3R_106())
4909: jj_scanpos = xsp;
4910: if (jj_scan_token(RPAREN))
4911: return true;
4912: return false;
4913: }
4914:
4915: final private boolean jj_3R_29() {
4916: if (jj_scan_token(IDENTIFIER))
4917: return true;
4918: Token xsp;
4919: while (true) {
4920: xsp = jj_scanpos;
4921: if (jj_3_7()) {
4922: jj_scanpos = xsp;
4923: break;
4924: }
4925: }
4926: return false;
4927: }
4928:
4929: final private boolean jj_3R_68() {
4930: if (jj_scan_token(DOUBLE))
4931: return true;
4932: return false;
4933: }
4934:
4935: final private boolean jj_3R_67() {
4936: if (jj_scan_token(FLOAT))
4937: return true;
4938: return false;
4939: }
4940:
4941: final private boolean jj_3R_155() {
4942: if (jj_scan_token(FALSE))
4943: return true;
4944: return false;
4945: }
4946:
4947: final private boolean jj_3R_66() {
4948: if (jj_scan_token(LONG))
4949: return true;
4950: return false;
4951: }
4952:
4953: final private boolean jj_3R_65() {
4954: if (jj_scan_token(INT))
4955: return true;
4956: return false;
4957: }
4958:
4959: final private boolean jj_3R_154() {
4960: if (jj_scan_token(TRUE))
4961: return true;
4962: return false;
4963: }
4964:
4965: final private boolean jj_3R_149() {
4966: Token xsp;
4967: xsp = jj_scanpos;
4968: if (jj_3R_154()) {
4969: jj_scanpos = xsp;
4970: if (jj_3R_155())
4971: return true;
4972: }
4973: return false;
4974: }
4975:
4976: final private boolean jj_3R_64() {
4977: if (jj_scan_token(SHORT))
4978: return true;
4979: return false;
4980: }
4981:
4982: final private boolean jj_3R_56() {
4983: if (jj_3R_29())
4984: return true;
4985: return false;
4986: }
4987:
4988: final private boolean jj_3R_63() {
4989: if (jj_scan_token(BYTE))
4990: return true;
4991: return false;
4992: }
4993:
4994: final private boolean jj_3R_62() {
4995: if (jj_scan_token(CHAR))
4996: return true;
4997: return false;
4998: }
4999:
5000: final private boolean jj_3R_61() {
5001: if (jj_scan_token(BOOLEAN))
5002: return true;
5003: return false;
5004: }
5005:
5006: final private boolean jj_3R_36() {
5007: Token xsp;
5008: xsp = jj_scanpos;
5009: if (jj_3R_61()) {
5010: jj_scanpos = xsp;
5011: if (jj_3R_62()) {
5012: jj_scanpos = xsp;
5013: if (jj_3R_63()) {
5014: jj_scanpos = xsp;
5015: if (jj_3R_64()) {
5016: jj_scanpos = xsp;
5017: if (jj_3R_65()) {
5018: jj_scanpos = xsp;
5019: if (jj_3R_66()) {
5020: jj_scanpos = xsp;
5021: if (jj_3R_67()) {
5022: jj_scanpos = xsp;
5023: if (jj_3R_68())
5024: return true;
5025: }
5026: }
5027: }
5028: }
5029: }
5030: }
5031: }
5032: return false;
5033: }
5034:
5035: final private boolean jj_3R_144() {
5036: if (jj_scan_token(57))
5037: return true;
5038: return false;
5039: }
5040:
5041: final private boolean jj_3R_74() {
5042: if (jj_3R_32())
5043: return true;
5044: return false;
5045: }
5046:
5047: final private boolean jj_3R_42() {
5048: Token xsp;
5049: xsp = jj_scanpos;
5050: if (jj_3R_73()) {
5051: jj_scanpos = xsp;
5052: if (jj_3R_74())
5053: return true;
5054: }
5055: return false;
5056: }
5057:
5058: final private boolean jj_3R_73() {
5059: if (jj_scan_token(VOID))
5060: return true;
5061: return false;
5062: }
5063:
5064: final private boolean jj_3R_143() {
5065: if (jj_scan_token(41))
5066: return true;
5067: return false;
5068: }
5069:
5070: final private boolean jj_3_6() {
5071: if (jj_scan_token(LBRACKET))
5072: return true;
5073: if (jj_scan_token(RBRACKET))
5074: return true;
5075: return false;
5076: }
5077:
5078: final private boolean jj_3R_142() {
5079: if (jj_3R_149())
5080: return true;
5081: return false;
5082: }
5083:
5084: final private boolean jj_3R_55() {
5085: if (jj_3R_36())
5086: return true;
5087: return false;
5088: }
5089:
5090: final private boolean jj_3R_110() {
5091: if (jj_scan_token(COMMA))
5092: return true;
5093: if (jj_3R_109())
5094: return true;
5095: return false;
5096: }
5097:
5098: final private boolean jj_3R_141() {
5099: if (jj_scan_token(STRING_LITERAL))
5100: return true;
5101: return false;
5102: }
5103:
5104: final private boolean jj_3R_32() {
5105: Token xsp;
5106: xsp = jj_scanpos;
5107: if (jj_3R_55()) {
5108: jj_scanpos = xsp;
5109: if (jj_3R_56())
5110: return true;
5111: }
5112: while (true) {
5113: xsp = jj_scanpos;
5114: if (jj_3_6()) {
5115: jj_scanpos = xsp;
5116: break;
5117: }
5118: }
5119: return false;
5120: }
5121:
5122: final private boolean jj_3R_140() {
5123: if (jj_scan_token(CHARACTER_LITERAL))
5124: return true;
5125: return false;
5126: }
5127:
5128: final private boolean jj_3R_190() {
5129: if (jj_scan_token(FINALLY))
5130: return true;
5131: if (jj_3R_38())
5132: return true;
5133: return false;
5134: }
5135:
5136: final private boolean jj_3_4() {
5137: if (jj_scan_token(COMMA))
5138: return true;
5139: if (jj_3R_31())
5140: return true;
5141: return false;
5142: }
5143:
5144: final private boolean jj_3R_189() {
5145: if (jj_scan_token(CATCH))
5146: return true;
5147: if (jj_scan_token(LPAREN))
5148: return true;
5149: if (jj_3R_109())
5150: return true;
5151: if (jj_scan_token(RPAREN))
5152: return true;
5153: if (jj_3R_38())
5154: return true;
5155: return false;
5156: }
5157:
5158: final private boolean jj_3R_136() {
5159: if (jj_scan_token(IDENTIFIER))
5160: return true;
5161: return false;
5162: }
5163:
5164: final private boolean jj_3_5() {
5165: if (jj_3R_32())
5166: return true;
5167: if (jj_scan_token(IDENTIFIER))
5168: return true;
5169: return false;
5170: }
5171:
5172: final private boolean jj_3R_75() {
5173: if (jj_3R_109())
5174: return true;
5175: Token xsp;
5176: while (true) {
5177: xsp = jj_scanpos;
5178: if (jj_3R_110()) {
5179: jj_scanpos = xsp;
5180: break;
5181: }
5182: }
5183: return false;
5184: }
5185:
5186: final private boolean jj_3R_109() {
5187: Token xsp;
5188: xsp = jj_scanpos;
5189: if (jj_3_5()) {
5190: jj_scanpos = xsp;
5191: if (jj_3R_136())
5192: return true;
5193: }
5194: return false;
5195: }
5196:
5197: final private boolean jj_3R_124() {
5198: if (jj_scan_token(TRY))
5199: return true;
5200: if (jj_3R_38())
5201: return true;
5202: Token xsp;
5203: while (true) {
5204: xsp = jj_scanpos;
5205: if (jj_3R_189()) {
5206: jj_scanpos = xsp;
5207: break;
5208: }
5209: }
5210: xsp = jj_scanpos;
5211: if (jj_3R_190())
5212: jj_scanpos = xsp;
5213: return false;
5214: }
5215:
5216: final private boolean jj_3R_43() {
5217: if (jj_scan_token(LPAREN))
5218: return true;
5219: Token xsp;
5220: xsp = jj_scanpos;
5221: if (jj_3R_75())
5222: jj_scanpos = xsp;
5223: if (jj_scan_token(RPAREN))
5224: return true;
5225: return false;
5226: }
5227:
5228: final private boolean jj_3R_163() {
5229: if (jj_3R_31())
5230: return true;
5231: Token xsp;
5232: while (true) {
5233: xsp = jj_scanpos;
5234: if (jj_3_4()) {
5235: jj_scanpos = xsp;
5236: break;
5237: }
5238: }
5239: return false;
5240: }
5241:
5242: final private boolean jj_3R_139() {
5243: if (jj_scan_token(FLOATING_POINT_LITERAL))
5244: return true;
5245: return false;
5246: }
5247:
5248: final private boolean jj_3R_97() {
5249: if (jj_scan_token(LBRACE))
5250: return true;
5251: Token xsp;
5252: xsp = jj_scanpos;
5253: if (jj_3R_163())
5254: jj_scanpos = xsp;
5255: xsp = jj_scanpos;
5256: if (jj_scan_token(79))
5257: jj_scanpos = xsp;
5258: if (jj_scan_token(RBRACE))
5259: return true;
5260: return false;
5261: }
5262:
5263: final private boolean jj_3R_30() {
5264: if (jj_scan_token(DOT))
5265: return true;
5266: if (jj_scan_token(STAR))
5267: return true;
5268: return false;
5269: }
5270:
5271: final private boolean jj_3R_123() {
5272: if (jj_scan_token(THROW))
5273: return true;
5274: if (jj_3R_39())
5275: return true;
5276: if (jj_scan_token(SEMICOLON))
5277: return true;
5278: return false;
5279: }
5280:
5281: final private boolean jj_3R_180() {
5282: if (jj_scan_token(ASSIGN))
5283: return true;
5284: if (jj_3R_31())
5285: return true;
5286: return false;
5287: }
5288:
5289: final private boolean jj_3R_54() {
5290: if (jj_3R_39())
5291: return true;
5292: return false;
5293: }
5294:
5295: final private boolean jj_3R_188() {
5296: if (jj_3R_39())
5297: return true;
5298: return false;
5299: }
5300:
5301: final private boolean jj_3R_53() {
5302: if (jj_3R_97())
5303: return true;
5304: return false;
5305: }
5306:
5307: final private boolean jj_3R_31() {
5308: Token xsp;
5309: xsp = jj_scanpos;
5310: if (jj_3R_53()) {
5311: jj_scanpos = xsp;
5312: if (jj_3R_54())
5313: return true;
5314: }
5315: return false;
5316: }
5317:
5318: final private boolean jj_3R_122() {
5319: if (jj_scan_token(SYNCHRONIZED))
5320: return true;
5321: if (jj_scan_token(LPAREN))
5322: return true;
5323: if (jj_3R_39())
5324: return true;
5325: if (jj_scan_token(RPAREN))
5326: return true;
5327: if (jj_3R_38())
5328: return true;
5329: return false;
5330: }
5331:
5332: final private boolean jj_3R_177() {
5333: if (jj_scan_token(COMMA))
5334: return true;
5335: if (jj_3R_176())
5336: return true;
5337: return false;
5338: }
5339:
5340: final private boolean jj_3R_210() {
5341: if (jj_scan_token(COMMA))
5342: return true;
5343: if (jj_3R_112())
5344: return true;
5345: return false;
5346: }
5347:
5348: final private boolean jj_3R_121() {
5349: if (jj_scan_token(RETURN))
5350: return true;
5351: Token xsp;
5352: xsp = jj_scanpos;
5353: if (jj_3R_188())
5354: jj_scanpos = xsp;
5355: if (jj_scan_token(SEMICOLON))
5356: return true;
5357: return false;
5358: }
5359:
5360: final private boolean jj_3R_129() {
5361: Token xsp;
5362: xsp = jj_scanpos;
5363: if (jj_3R_138()) {
5364: jj_scanpos = xsp;
5365: if (jj_3R_139()) {
5366: jj_scanpos = xsp;
5367: if (jj_3R_140()) {
5368: jj_scanpos = xsp;
5369: if (jj_3R_141()) {
5370: jj_scanpos = xsp;
5371: if (jj_3R_142()) {
5372: jj_scanpos = xsp;
5373: if (jj_3R_143()) {
5374: jj_scanpos = xsp;
5375: if (jj_3R_144())
5376: return true;
5377: }
5378: }
5379: }
5380: }
5381: }
5382: }
5383: return false;
5384: }
5385:
5386: final private boolean jj_3R_138() {
5387: if (jj_scan_token(INTEGER_LITERAL))
5388: return true;
5389: return false;
5390: }
5391:
5392: final private boolean jj_3R_146() {
5393: if (jj_3R_69())
5394: return true;
5395: return false;
5396: }
5397:
5398: final private boolean jj_3R_176() {
5399: if (jj_scan_token(IDENTIFIER))
5400: return true;
5401: Token xsp;
5402: xsp = jj_scanpos;
5403: if (jj_3R_180())
5404: jj_scanpos = xsp;
5405: return false;
5406: }
5407:
5408: final private boolean jj_3R_105() {
5409: if (jj_3R_129())
5410: return true;
5411: return false;
5412: }
5413:
5414: final private boolean jj_3R_120() {
5415: if (jj_scan_token(CONTINUE))
5416: return true;
5417: Token xsp;
5418: xsp = jj_scanpos;
5419: if (jj_scan_token(69))
5420: jj_scanpos = xsp;
5421: if (jj_scan_token(SEMICOLON))
5422: return true;
5423: return false;
5424: }
5425:
5426: final private boolean jj_3R_119() {
5427: if (jj_scan_token(BREAK))
5428: return true;
5429: Token xsp;
5430: xsp = jj_scanpos;
5431: if (jj_scan_token(69))
5432: jj_scanpos = xsp;
5433: if (jj_scan_token(SEMICOLON))
5434: return true;
5435: return false;
5436: }
5437:
5438: final private boolean jj_3R_195() {
5439: if (jj_3R_205())
5440: return true;
5441: return false;
5442: }
5443:
5444: final private boolean jj_3R_128() {
5445: if (jj_scan_token(IMPORT))
5446: return true;
5447: if (jj_scan_token(STAR))
5448: return true;
5449: if (jj_scan_token(SEMICOLON))
5450: return true;
5451: return false;
5452: }
5453:
5454: final private boolean jj_3R_133() {
5455: if (jj_scan_token(LBRACE))
5456: return true;
5457: if (jj_3R_39())
5458: return true;
5459: if (jj_scan_token(RBRACE))
5460: return true;
5461: return false;
5462: }
5463:
5464: final private boolean jj_3R_205() {
5465: if (jj_3R_112())
5466: return true;
5467: Token xsp;
5468: while (true) {
5469: xsp = jj_scanpos;
5470: if (jj_3R_210()) {
5471: jj_scanpos = xsp;
5472: break;
5473: }
5474: }
5475: return false;
5476: }
5477:
5478: final private boolean jj_3R_132() {
5479: if (jj_scan_token(DOT))
5480: return true;
5481: if (jj_scan_token(IDENTIFIER))
5482: return true;
5483: Token xsp;
5484: xsp = jj_scanpos;
5485: if (jj_3R_146())
5486: jj_scanpos = xsp;
5487: return false;
5488: }
5489:
5490: final private boolean jj_3_3() {
5491: Token xsp;
5492: xsp = jj_scanpos;
5493: if (jj_scan_token(48))
5494: jj_scanpos = xsp;
5495: if (jj_scan_token(IMPORT))
5496: return true;
5497: if (jj_3R_29())
5498: return true;
5499: xsp = jj_scanpos;
5500: if (jj_3R_30())
5501: jj_scanpos = xsp;
5502: if (jj_scan_token(SEMICOLON))
5503: return true;
5504: return false;
5505: }
5506:
5507: final private boolean jj_3R_94() {
5508: Token xsp;
5509: xsp = jj_scanpos;
5510: if (jj_3_3()) {
5511: jj_scanpos = xsp;
5512: if (jj_3R_128())
5513: return true;
5514: }
5515: return false;
5516: }
5517:
5518: final private boolean jj_3R_93() {
5519: if (jj_3R_41())
5520: return true;
5521: if (jj_3R_32())
5522: return true;
5523: if (jj_3R_176())
5524: return true;
5525: Token xsp;
5526: while (true) {
5527: xsp = jj_scanpos;
5528: if (jj_3R_177()) {
5529: jj_scanpos = xsp;
5530: break;
5531: }
5532: }
5533: return false;
5534: }
5535:
5536: final private boolean jj_3R_131() {
5537: if (jj_scan_token(LBRACKET))
5538: return true;
5539: if (jj_3R_39())
5540: return true;
5541: if (jj_scan_token(RBRACKET))
5542: return true;
5543: return false;
5544: }
5545:
5546: final private boolean jj_3R_95() {
5547: if (jj_scan_token(PACKAGE))
5548: return true;
5549: if (jj_3R_29())
5550: return true;
5551: return false;
5552: }
5553:
5554: final private boolean jj_3_2() {
5555: if (jj_scan_token(IDENTIFIER))
5556: return true;
5557: if (jj_scan_token(LPAREN))
5558: return true;
5559: return false;
5560: }
5561:
5562: final private boolean jj_3R_175() {
5563: if (jj_3R_38())
5564: return true;
5565: return false;
5566: }
5567:
5568: final private boolean jj_3_16() {
5569: if (jj_scan_token(DOT))
5570: return true;
5571: if (jj_scan_token(CLASS))
5572: return true;
5573: return false;
5574: }
5575:
5576: final private boolean jj_3R_104() {
5577: Token xsp;
5578: xsp = jj_scanpos;
5579: if (jj_3_16()) {
5580: jj_scanpos = xsp;
5581: if (jj_3R_131()) {
5582: jj_scanpos = xsp;
5583: if (jj_3R_132()) {
5584: jj_scanpos = xsp;
5585: if (jj_3R_133())
5586: return true;
5587: }
5588: }
5589: }
5590: return false;
5591: }
5592:
5593: final private boolean jj_3R_174() {
5594: if (jj_scan_token(THROWS))
5595: return true;
5596: if (jj_3R_76())
5597: return true;
5598: return false;
5599: }
5600:
5601: final private boolean jj_3_15() {
5602: if (jj_3R_32())
5603: return true;
5604: if (jj_scan_token(DOT))
5605: return true;
5606: if (jj_scan_token(CLASS))
5607: return true;
5608: return false;
5609: }
5610:
5611: final private boolean jj_3_31() {
5612: if (jj_3R_41())
5613: return true;
5614: if (jj_3R_32())
5615: return true;
5616: if (jj_scan_token(IDENTIFIER))
5617: return true;
5618: return false;
5619: }
5620:
5621: final private boolean jj_3_14() {
5622: if (jj_3R_37())
5623: return true;
5624: return false;
5625: }
5626:
5627: final private boolean jj_3R_126() {
5628: if (jj_scan_token(IDENTIFIER))
5629: return true;
5630: return false;
5631: }
5632:
5633: final private boolean jj_3R_127() {
5634: if (jj_3R_42())
5635: return true;
5636: if (jj_scan_token(IDENTIFIER))
5637: return true;
5638: return false;
5639: }
5640:
5641: final private boolean jj_3R_92() {
5642: if (jj_3R_41())
5643: return true;
5644: Token xsp;
5645: xsp = jj_scanpos;
5646: if (jj_3R_126()) {
5647: jj_scanpos = xsp;
5648: if (jj_3R_127())
5649: return true;
5650: }
5651: if (jj_3R_43())
5652: return true;
5653: xsp = jj_scanpos;
5654: if (jj_3R_174())
5655: jj_scanpos = xsp;
5656: xsp = jj_scanpos;
5657: if (jj_3R_175()) {
5658: jj_scanpos = xsp;
5659: if (jj_scan_token(78))
5660: return true;
5661: }
5662: return false;
5663: }
5664:
5665: final private boolean jj_3R_204() {
5666: if (jj_3R_205())
5667: return true;
5668: return false;
5669: }
5670:
5671: final private boolean jj_3R_103() {
5672: if (jj_3R_29())
5673: return true;
5674: return false;
5675: }
5676:
5677: final private boolean jj_3R_203() {
5678: if (jj_3R_93())
5679: return true;
5680: return false;
5681: }
5682:
5683: final private boolean jj_3R_194() {
5684: Token xsp;
5685: xsp = jj_scanpos;
5686: if (jj_3R_203()) {
5687: jj_scanpos = xsp;
5688: if (jj_3R_204())
5689: return true;
5690: }
5691: return false;
5692: }
5693:
5694: final private boolean jj_3R_102() {
5695: if (jj_3R_32())
5696: return true;
5697: return false;
5698: }
5699:
5700: final private boolean jj_3R_58() {
5701: if (jj_3R_104())
5702: return true;
5703: return false;
5704: }
5705:
5706: final private boolean jj_3R_125() {
5707: if (jj_scan_token(INTERFACE))
5708: return true;
5709: return false;
5710: }
5711:
5712: final private boolean jj_3R_101() {
5713: if (jj_3R_37())
5714: return true;
5715: return false;
5716: }
5717:
5718: final private boolean jj_3R_100() {
5719: if (jj_3R_130())
5720: return true;
5721: return false;
5722: }
5723:
5724: final private boolean jj_3R_99() {
5725: if (jj_scan_token(LPAREN))
5726: return true;
5727: if (jj_3R_39())
5728: return true;
5729: if (jj_scan_token(RPAREN))
5730: return true;
5731: return false;
5732: }
5733:
5734: final private boolean jj_3R_137() {
5735: if (jj_scan_token(FOR))
5736: return true;
5737: if (jj_scan_token(LPAREN))
5738: return true;
5739: if (jj_3R_32())
5740: return true;
5741: if (jj_scan_token(IDENTIFIER))
5742: return true;
5743: if (jj_scan_token(COLON))
5744: return true;
5745: if (jj_3R_39())
5746: return true;
5747: if (jj_scan_token(RPAREN))
5748: return true;
5749: if (jj_3R_45())
5750: return true;
5751: return false;
5752: }
5753:
5754: final private boolean jj_3R_184() {
5755: if (jj_scan_token(ELSE))
5756: return true;
5757: if (jj_3R_45())
5758: return true;
5759: return false;
5760: }
5761:
5762: final private boolean jj_3R_173() {
5763: if (jj_scan_token(IMPLEMENTS))
5764: return true;
5765: if (jj_3R_76())
5766: return true;
5767: return false;
5768: }
5769:
5770: final private boolean jj_3R_57() {
5771: Token xsp;
5772: xsp = jj_scanpos;
5773: if (jj_3R_98()) {
5774: jj_scanpos = xsp;
5775: if (jj_3R_99()) {
5776: jj_scanpos = xsp;
5777: if (jj_3R_100()) {
5778: jj_scanpos = xsp;
5779: if (jj_3R_101()) {
5780: jj_scanpos = xsp;
5781: if (jj_3R_102()) {
5782: jj_scanpos = xsp;
5783: if (jj_3R_103())
5784: return true;
5785: }
5786: }
5787: }
5788: }
5789: }
5790: return false;
5791: }
5792:
5793: final private boolean jj_3R_98() {
5794: if (jj_3R_129())
5795: return true;
5796: return false;
5797: }
5798:
5799: final private boolean jj_3R_172() {
5800: if (jj_scan_token(EXTENDS))
5801: return true;
5802: if (jj_3R_29())
5803: return true;
5804: return false;
5805: }
5806:
5807: final private boolean jj_3_30() {
5808: if (jj_scan_token(FOR))
5809: return true;
5810: if (jj_scan_token(LPAREN))
5811: return true;
5812: if (jj_scan_token(IDENTIFIER))
5813: return true;
5814: if (jj_scan_token(COLON))
5815: return true;
5816: if (jj_3R_39())
5817: return true;
5818: if (jj_scan_token(RPAREN))
5819: return true;
5820: if (jj_3R_45())
5821: return true;
5822: return false;
5823: }
5824:
5825: final private boolean jj_3R_118() {
5826: Token xsp;
5827: xsp = jj_scanpos;
5828: if (jj_3_30()) {
5829: jj_scanpos = xsp;
5830: if (jj_3R_137())
5831: return true;
5832: }
5833: return false;
5834: }
5835:
5836: final private boolean jj_3R_37() {
5837: if (jj_3R_29())
5838: return true;
5839: if (jj_3R_69())
5840: return true;
5841: return false;
5842: }
5843:
5844: final private boolean jj_3R_185() {
5845: if (jj_3R_194())
5846: return true;
5847: return false;
5848: }
5849:
5850: final private boolean jj_3R_91() {
5851: if (jj_3R_41())
5852: return true;
5853: Token xsp;
5854: xsp = jj_scanpos;
5855: if (jj_scan_token(13)) {
5856: jj_scanpos = xsp;
5857: if (jj_3R_125())
5858: return true;
5859: }
5860: if (jj_scan_token(IDENTIFIER))
5861: return true;
5862: xsp = jj_scanpos;
5863: if (jj_3R_172())
5864: jj_scanpos = xsp;
5865: xsp = jj_scanpos;
5866: if (jj_3R_173())
5867: jj_scanpos = xsp;
5868: if (jj_3R_38())
5869: return true;
5870: return false;
5871: }
5872:
5873: final private boolean jj_3_13() {
5874: if (jj_scan_token(LPAREN))
5875: return true;
5876: if (jj_3R_36())
5877: return true;
5878: return false;
5879: }
5880:
5881: final private boolean jj_3R_187() {
5882: if (jj_3R_195())
5883: return true;
5884: return false;
5885: }
5886:
5887: final private boolean jj_3R_186() {
5888: if (jj_3R_39())
5889: return true;
5890: return false;
5891: }
5892:
5893: final private boolean jj_3R_33() {
5894: if (jj_3R_57())
5895: return true;
5896: Token xsp;
5897: while (true) {
5898: xsp = jj_scanpos;
5899: if (jj_3R_58()) {
5900: jj_scanpos = xsp;
5901: break;
5902: }
5903: }
5904: return false;
5905: }
5906:
5907: final private boolean jj_3R_217() {
5908: if (jj_scan_token(LPAREN))
5909: return true;
5910: if (jj_3R_32())
5911: return true;
5912: if (jj_scan_token(RPAREN))
5913: return true;
5914: if (jj_3R_208())
5915: return true;
5916: return false;
5917: }
5918:
5919: final private boolean jj_3R_216() {
5920: if (jj_scan_token(LPAREN))
5921: return true;
5922: if (jj_3R_32())
5923: return true;
5924: if (jj_scan_token(RPAREN))
5925: return true;
5926: if (jj_3R_191())
5927: return true;
5928: return false;
5929: }
5930:
5931: final private boolean jj_3R_117() {
5932: if (jj_scan_token(FOR))
5933: return true;
5934: if (jj_scan_token(LPAREN))
5935: return true;
5936: Token xsp;
5937: xsp = jj_scanpos;
5938: if (jj_3R_185())
5939: jj_scanpos = xsp;
5940: if (jj_scan_token(SEMICOLON))
5941: return true;
5942: xsp = jj_scanpos;
5943: if (jj_3R_186())
5944: jj_scanpos = xsp;
5945: if (jj_scan_token(SEMICOLON))
5946: return true;
5947: xsp = jj_scanpos;
5948: if (jj_3R_187())
5949: jj_scanpos = xsp;
5950: if (jj_scan_token(RPAREN))
5951: return true;
5952: if (jj_3R_45())
5953: return true;
5954: return false;
5955: }
5956:
5957: final private boolean jj_3R_214() {
5958: Token xsp;
5959: xsp = jj_scanpos;
5960: if (jj_3R_216()) {
5961: jj_scanpos = xsp;
5962: if (jj_3R_217())
5963: return true;
5964: }
5965: return false;
5966: }
5967:
5968: final private boolean jj_3_12() {
5969: if (jj_3R_33())
5970: return true;
5971: Token xsp;
5972: xsp = jj_scanpos;
5973: if (jj_scan_token(100)) {
5974: jj_scanpos = xsp;
5975: if (jj_scan_token(101))
5976: return true;
5977: }
5978: return false;
5979: }
5980:
5981: final private boolean jj_3R_219() {
5982: if (jj_3R_33())
5983: return true;
5984: return false;
5985: }
5986:
5987: final private boolean jj_3R_116() {
5988: if (jj_scan_token(DO))
5989: return true;
5990: if (jj_3R_45())
5991: return true;
5992: if (jj_scan_token(WHILE))
5993: return true;
5994: if (jj_scan_token(LPAREN))
5995: return true;
5996: if (jj_3R_39())
5997: return true;
5998: if (jj_scan_token(RPAREN))
5999: return true;
6000: if (jj_scan_token(SEMICOLON))
6001: return true;
6002: return false;
6003: }
6004:
6005: final private boolean jj_3_11() {
6006: if (jj_scan_token(LPAREN))
6007: return true;
6008: if (jj_3R_29())
6009: return true;
6010: if (jj_scan_token(LBRACKET))
6011: return true;
6012: return false;
6013: }
6014:
6015: final private boolean jj_3R_218() {
6016: if (jj_3R_33())
6017: return true;
6018: Token xsp;
6019: xsp = jj_scanpos;
6020: if (jj_scan_token(100)) {
6021: jj_scanpos = xsp;
6022: if (jj_scan_token(101))
6023: return true;
6024: }
6025: return false;
6026: }
6027:
6028: final private boolean jj_3R_215() {
6029: Token xsp;
6030: xsp = jj_scanpos;
6031: if (jj_3R_218()) {
6032: jj_scanpos = xsp;
6033: if (jj_3R_219())
6034: return true;
6035: }
6036: return false;
6037: }
6038:
6039: final private boolean jj_3R_72() {
6040: Token xsp;
6041: xsp = jj_scanpos;
6042: if (jj_scan_token(43)) {
6043: jj_scanpos = xsp;
6044: if (jj_scan_token(44)) {
6045: jj_scanpos = xsp;
6046: if (jj_scan_token(45)) {
6047: jj_scanpos = xsp;
6048: if (jj_scan_token(51)) {
6049: jj_scanpos = xsp;
6050: if (jj_scan_token(27)) {
6051: jj_scanpos = xsp;
6052: if (jj_scan_token(39)) {
6053: jj_scanpos = xsp;
6054: if (jj_scan_token(52)) {
6055: jj_scanpos = xsp;
6056: if (jj_scan_token(58)) {
6057: jj_scanpos = xsp;
6058: if (jj_scan_token(10)) {
6059: jj_scanpos = xsp;
6060: if (jj_scan_token(48)) {
6061: jj_scanpos = xsp;
6062: if (jj_scan_token(49))
6063: return true;
6064: }
6065: }
6066: }
6067: }
6068: }
6069: }
6070: }
6071: }
6072: }
6073: }
6074: return false;
6075: }
6076:
6077: final private boolean jj_3R_115() {
6078: if (jj_scan_token(WHILE))
6079: return true;
6080: if (jj_scan_token(LPAREN))
6081: return true;
6082: if (jj_3R_39())
6083: return true;
6084: if (jj_scan_token(RPAREN))
6085: return true;
6086: if (jj_3R_45())
6087: return true;
6088: return false;
6089: }
6090:
6091: final private boolean jj_3R_60() {
6092: if (jj_scan_token(LPAREN))
6093: return true;
6094: if (jj_3R_29())
6095: return true;
6096: if (jj_scan_token(RPAREN))
6097: return true;
6098: Token xsp;
6099: xsp = jj_scanpos;
6100: if (jj_scan_token(87)) {
6101: jj_scanpos = xsp;
6102: if (jj_scan_token(86)) {
6103: jj_scanpos = xsp;
6104: if (jj_scan_token(72)) {
6105: jj_scanpos = xsp;
6106: if (jj_scan_token(69)) {
6107: jj_scanpos = xsp;
6108: if (jj_scan_token(40)) {
6109: jj_scanpos = xsp;
6110: if (jj_3R_105())
6111: return true;
6112: }
6113: }
6114: }
6115: }
6116: }
6117: return false;
6118: }
6119:
6120: final private boolean jj_3R_59() {
6121: if (jj_scan_token(LPAREN))
6122: return true;
6123: if (jj_3R_29())
6124: return true;
6125: if (jj_scan_token(LBRACKET))
6126: return true;
6127: if (jj_scan_token(RBRACKET))
6128: return true;
6129: return false;
6130: }
6131:
6132: final private boolean jj_3_9() {
6133: if (jj_3R_35())
6134: return true;
6135: return false;
6136: }
6137:
6138: final private boolean jj_3_29() {
6139: if (jj_3R_28())
6140: return true;
6141: return false;
6142: }
6143:
6144: final private boolean jj_3R_114() {
6145: if (jj_scan_token(IF))
6146: return true;
6147: if (jj_scan_token(LPAREN))
6148: return true;
6149: if (jj_3R_39())
6150: return true;
6151: if (jj_scan_token(RPAREN))
6152: return true;
6153: if (jj_3R_45())
6154: return true;
6155: Token xsp;
6156: xsp = jj_scanpos;
6157: if (jj_3R_184())
6158: jj_scanpos = xsp;
6159: return false;
6160: }
6161:
6162: final private boolean jj_3R_41() {
6163: Token xsp;
6164: while (true) {
6165: xsp = jj_scanpos;
6166: if (jj_3R_72()) {
6167: jj_scanpos = xsp;
6168: break;
6169: }
6170: }
6171: return false;
6172: }
6173:
6174: final private boolean jj_3R_35() {
6175: Token xsp;
6176: xsp = jj_scanpos;
6177: if (jj_3_10()) {
6178: jj_scanpos = xsp;
6179: if (jj_3R_59()) {
6180: jj_scanpos = xsp;
6181: if (jj_3R_60())
6182: return true;
6183: }
6184: }
6185: return false;
6186: }
6187:
6188: final private boolean jj_3_10() {
6189: if (jj_scan_token(LPAREN))
6190: return true;
6191: if (jj_3R_36())
6192: return true;
6193: return false;
6194: }
6195:
6196: final private boolean jj_3R_213() {
6197: if (jj_3R_215())
6198: return true;
6199: return false;
6200: }
6201:
6202: final private boolean jj_3R_212() {
6203: if (jj_3R_214())
6204: return true;
6205: return false;
6206: }
6207:
6208: final private boolean jj_3R_202() {
6209: if (jj_scan_token(_DEFAULT))
6210: return true;
6211: if (jj_scan_token(COLON))
6212: return true;
6213: return false;
6214: }
6215:
6216: final private boolean jj_3R_211() {
6217: Token xsp;
6218: xsp = jj_scanpos;
6219: if (jj_scan_token(87)) {
6220: jj_scanpos = xsp;
6221: if (jj_scan_token(86))
6222: return true;
6223: }
6224: if (jj_3R_191())
6225: return true;
6226: return false;
6227: }
6228:
6229: final private boolean jj_3R_208() {
6230: Token xsp;
6231: xsp = jj_scanpos;
6232: if (jj_3R_211()) {
6233: jj_scanpos = xsp;
6234: if (jj_3R_212()) {
6235: jj_scanpos = xsp;
6236: if (jj_3R_213())
6237: return true;
6238: }
6239: }
6240: return false;
6241: }
6242:
6243: final private boolean jj_3R_201() {
6244: if (jj_scan_token(CASE))
6245: return true;
6246: if (jj_3R_39())
6247: return true;
6248: if (jj_scan_token(COLON))
6249: return true;
6250: return false;
6251: }
6252:
6253: final private boolean jj_3R_193() {
6254: Token xsp;
6255: xsp = jj_scanpos;
6256: if (jj_3R_201()) {
6257: jj_scanpos = xsp;
6258: if (jj_3R_202())
6259: return true;
6260: }
6261: return false;
6262: }
6263:
6264: final private boolean jj_3R_183() {
6265: if (jj_3R_193())
6266: return true;
6267: Token xsp;
6268: while (true) {
6269: xsp = jj_scanpos;
6270: if (jj_3_29()) {
6271: jj_scanpos = xsp;
6272: break;
6273: }
6274: }
6275: return false;
6276: }
6277:
6278: final private boolean jj_3R_207() {
6279: if (jj_scan_token(DECR))
6280: return true;
6281: if (jj_3R_33())
6282: return true;
6283: return false;
6284: }
6285:
6286: final private boolean jj_3_1() {
6287: if (jj_3R_28())
6288: return true;
6289: return false;
6290: }
6291:
6292: final private boolean jj_3R_113() {
6293: if (jj_scan_token(SWITCH))
6294: return true;
6295: if (jj_scan_token(LPAREN))
6296: return true;
6297: if (jj_3R_39())
6298: return true;
6299: if (jj_scan_token(RPAREN))
6300: return true;
6301: if (jj_scan_token(LBRACE))
6302: return true;
6303: Token xsp;
6304: while (true) {
6305: xsp = jj_scanpos;
6306: if (jj_3R_183()) {
6307: jj_scanpos = xsp;
6308: break;
6309: }
6310: }
6311: if (jj_scan_token(RBRACE))
6312: return true;
6313: return false;
6314: }
6315:
6316: final private boolean jj_3R_209() {
6317: Token xsp;
6318: xsp = jj_scanpos;
6319: if (jj_scan_token(104)) {
6320: jj_scanpos = xsp;
6321: if (jj_scan_token(105)) {
6322: jj_scanpos = xsp;
6323: if (jj_scan_token(111))
6324: return true;
6325: }
6326: }
6327: if (jj_3R_191())
6328: return true;
6329: return false;
6330: }
6331:
6332: final private boolean jj_3R_206() {
6333: if (jj_scan_token(INCR))
6334: return true;
6335: if (jj_3R_33())
6336: return true;
6337: return false;
6338: }
6339:
6340: final private boolean jj_3R_199() {
6341: if (jj_3R_208())
6342: return true;
6343: return false;
6344: }
6345:
6346: final private boolean jj_3R_198() {
6347: if (jj_3R_207())
6348: return true;
6349: return false;
6350: }
6351:
6352: final private boolean jj_3R_197() {
6353: if (jj_3R_206())
6354: return true;
6355: return false;
6356: }
6357:
6358: final private boolean jj_3R_196() {
6359: Token xsp;
6360: xsp = jj_scanpos;
6361: if (jj_scan_token(102)) {
6362: jj_scanpos = xsp;
6363: if (jj_scan_token(103))
6364: return true;
6365: }
6366: if (jj_3R_191())
6367: return true;
6368: return false;
6369: }
6370:
6371: final private boolean jj_3R_191() {
6372: Token xsp;
6373: xsp = jj_scanpos;
6374: if (jj_3R_196()) {
6375: jj_scanpos = xsp;
6376: if (jj_3R_197()) {
6377: jj_scanpos = xsp;
6378: if (jj_3R_198()) {
6379: jj_scanpos = xsp;
6380: if (jj_3R_199())
6381: return true;
6382: }
6383: }
6384: }
6385: return false;
6386: }
6387:
6388: final private boolean jj_3R_44() {
6389: if (jj_scan_token(THROWS))
6390: return true;
6391: if (jj_3R_76())
6392: return true;
6393: return false;
6394: }
6395:
6396: final private boolean jj_3R_112() {
6397: if (jj_3R_39())
6398: return true;
6399: return false;
6400: }
6401:
6402: final private boolean jj_3R_181() {
6403: if (jj_3R_191())
6404: return true;
6405: Token xsp;
6406: while (true) {
6407: xsp = jj_scanpos;
6408: if (jj_3R_209()) {
6409: jj_scanpos = xsp;
6410: break;
6411: }
6412: }
6413: return false;
6414: }
6415:
6416: final private boolean jj_3R_200() {
6417: Token xsp;
6418: xsp = jj_scanpos;
6419: if (jj_scan_token(102)) {
6420: jj_scanpos = xsp;
6421: if (jj_scan_token(103))
6422: return true;
6423: }
6424: if (jj_3R_181())
6425: return true;
6426: return false;
6427: }
6428:
6429: final private boolean jj_3R_178() {
6430: if (jj_3R_181())
6431: return true;
6432: Token xsp;
6433: while (true) {
6434: xsp = jj_scanpos;
6435: if (jj_3R_200()) {
6436: jj_scanpos = xsp;
6437: break;
6438: }
6439: }
6440: return false;
6441: }
6442:
6443: final private boolean jj_3R_96() {
6444: if (jj_scan_token(FORMAL_COMMENT))
6445: return true;
6446: return false;
6447: }
6448:
6449: final private boolean jj_3R_192() {
6450: Token xsp;
6451: xsp = jj_scanpos;
6452: if (jj_scan_token(112)) {
6453: jj_scanpos = xsp;
6454: if (jj_scan_token(113)) {
6455: jj_scanpos = xsp;
6456: if (jj_scan_token(114)) {
6457: jj_scanpos = xsp;
6458: if (jj_scan_token(115)) {
6459: jj_scanpos = xsp;
6460: if (jj_scan_token(116)) {
6461: jj_scanpos = xsp;
6462: if (jj_scan_token(117))
6463: return true;
6464: }
6465: }
6466: }
6467: }
6468: }
6469: if (jj_3R_178())
6470: return true;
6471: return false;
6472: }
6473:
6474: final private boolean jj_3R_171() {
6475: Token xsp;
6476: xsp = jj_scanpos;
6477: if (jj_scan_token(90)) {
6478: jj_scanpos = xsp;
6479: if (jj_scan_token(95))
6480: return true;
6481: }
6482: if (jj_3R_166())
6483: return true;
6484: return false;
6485: }
6486:
6487: final private boolean jj_3R_170() {
6488: if (jj_3R_178())
6489: return true;
6490: Token xsp;
6491: while (true) {
6492: xsp = jj_scanpos;
6493: if (jj_3R_192()) {
6494: jj_scanpos = xsp;
6495: break;
6496: }
6497: }
6498: return false;
6499: }
6500:
6501: final private boolean jj_3R_52() {
6502: if (jj_3R_96())
6503: return true;
6504: return false;
6505: }
6506:
6507: final private boolean jj_3R_182() {
6508: Token xsp;
6509: xsp = jj_scanpos;
6510: if (jj_scan_token(84)) {
6511: jj_scanpos = xsp;
6512: if (jj_scan_token(85)) {
6513: jj_scanpos = xsp;
6514: if (jj_scan_token(82)) {
6515: jj_scanpos = xsp;
6516: if (jj_scan_token(83)) {
6517: jj_scanpos = xsp;
6518: if (jj_scan_token(91)) {
6519: jj_scanpos = xsp;
6520: if (jj_scan_token(92)) {
6521: jj_scanpos = xsp;
6522: if (jj_scan_token(93)) {
6523: jj_scanpos = xsp;
6524: if (jj_scan_token(94))
6525: return true;
6526: }
6527: }
6528: }
6529: }
6530: }
6531: }
6532: }
6533: if (jj_3R_170())
6534: return true;
6535: return false;
6536: }
6537:
6538: final private boolean jj_3_27() {
6539: if (jj_3R_41())
6540: return true;
6541: if (jj_3R_32())
6542: return true;
6543: if (jj_scan_token(IDENTIFIER))
6544: return true;
6545: return false;
6546: }
6547:
6548: final private boolean jj_3R_51() {
6549: if (jj_3R_95())
6550: return true;
6551: return false;
6552: }
6553:
6554: final private boolean jj_3R_168() {
6555: if (jj_3R_170())
6556: return true;
6557: Token xsp;
6558: while (true) {
6559: xsp = jj_scanpos;
6560: if (jj_3R_182()) {
6561: jj_scanpos = xsp;
6562: break;
6563: }
6564: }
6565: return false;
6566: }
6567:
6568: final private boolean jj_3R_50() {
6569: if (jj_3R_94())
6570: return true;
6571: return false;
6572: }
6573:
6574: final private boolean jj_3_26() {
6575: if (jj_3R_41())
6576: return true;
6577: if (jj_scan_token(IDENTIFIER))
6578: return true;
6579: if (jj_3R_43())
6580: return true;
6581: Token xsp;
6582: xsp = jj_scanpos;
6583: if (jj_3R_44())
6584: jj_scanpos = xsp;
6585: if (jj_scan_token(LBRACE))
6586: return true;
6587: return false;
6588: }
6589:
6590: final private boolean jj_3R_179() {
6591: if (jj_scan_token(INSTANCEOF))
6592: return true;
6593: if (jj_3R_32())
6594: return true;
6595: return false;
6596: }
6597:
6598: final private boolean jj_3_28() {
6599: if (jj_3R_45())
6600: return true;
6601: return false;
6602: }
6603:
6604: final private boolean jj_3R_166() {
6605: if (jj_3R_168())
6606: return true;
6607: Token xsp;
6608: xsp = jj_scanpos;
6609: if (jj_3R_179())
6610: jj_scanpos = xsp;
6611: return false;
6612: }
6613:
6614: final private boolean jj_3_25() {
6615: if (jj_3R_41())
6616: return true;
6617: if (jj_3R_42())
6618: return true;
6619: if (jj_scan_token(IDENTIFIER))
6620: return true;
6621: if (jj_scan_token(LPAREN))
6622: return true;
6623: return false;
6624: }
6625:
6626: final private boolean jj_3R_49() {
6627: if (jj_3R_93())
6628: return true;
6629: if (jj_scan_token(SEMICOLON))
6630: return true;
6631: return false;
6632: }
6633:
6634: final private boolean jj_3_24() {
6635: if (jj_3R_41())
6636: return true;
6637: Token xsp;
6638: xsp = jj_scanpos;
6639: if (jj_scan_token(13)) {
6640: jj_scanpos = xsp;
6641: if (jj_scan_token(37))
6642: return true;
6643: }
6644: return false;
6645: }
6646:
6647: final private boolean jj_3R_167() {
6648: if (jj_scan_token(XOR))
6649: return true;
6650: if (jj_3R_161())
6651: return true;
6652: return false;
6653: }
6654:
6655: final private boolean jj_3R_48() {
6656: if (jj_3R_92())
6657: return true;
6658: return false;
6659: }
6660:
6661: final private boolean jj_3R_164() {
6662: if (jj_3R_166())
6663: return true;
6664: Token xsp;
6665: while (true) {
6666: xsp = jj_scanpos;
6667: if (jj_3R_171()) {
6668: jj_scanpos = xsp;
6669: break;
6670: }
6671: }
6672: return false;
6673: }
6674:
6675: final private boolean jj_3R_47() {
6676: if (jj_3R_92())
6677: return true;
6678: return false;
6679: }
6680:
6681: final private boolean jj_3R_169() {
6682: Token xsp;
6683: xsp = jj_scanpos;
6684: if (jj_scan_token(106)) {
6685: jj_scanpos = xsp;
6686: if (jj_scan_token(107))
6687: return true;
6688: }
6689: if (jj_3R_164())
6690: return true;
6691: return false;
6692: }
6693:
6694: public ParserTokenManager token_source;
6695: JavaCharStream jj_input_stream;
6696: public Token token, jj_nt;
6697: private int jj_ntk;
6698: private Token jj_scanpos, jj_lastpos;
6699: private int jj_la;
6700: public boolean lookingAhead = false;
6701: private boolean jj_semLA;
6702:
6703: public Parser(java.io.InputStream stream) {
6704: jj_input_stream = new JavaCharStream(stream, 1, 1);
6705: token_source = new ParserTokenManager(jj_input_stream);
6706: token = new Token();
6707: jj_ntk = -1;
6708: }
6709:
6710: public void ReInit(java.io.InputStream stream) {
6711: jj_input_stream.ReInit(stream, 1, 1);
6712: token_source.ReInit(jj_input_stream);
6713: token = new Token();
6714: jj_ntk = -1;
6715: jjtree.reset();
6716: }
6717:
6718: public Parser(java.io.Reader stream) {
6719: jj_input_stream = new JavaCharStream(stream, 1, 1);
6720: token_source = new ParserTokenManager(jj_input_stream);
6721: token = new Token();
6722: jj_ntk = -1;
6723: }
6724:
6725: public void ReInit(java.io.Reader stream) {
6726: jj_input_stream.ReInit(stream, 1, 1);
6727: token_source.ReInit(jj_input_stream);
6728: token = new Token();
6729: jj_ntk = -1;
6730: jjtree.reset();
6731: }
6732:
6733: public Parser(ParserTokenManager tm) {
6734: token_source = tm;
6735: token = new Token();
6736: jj_ntk = -1;
6737: }
6738:
6739: public void ReInit(ParserTokenManager tm) {
6740: token_source = tm;
6741: token = new Token();
6742: jj_ntk = -1;
6743: jjtree.reset();
6744: }
6745:
6746: final private Token jj_consume_token(int kind)
6747: throws ParseException {
6748: Token oldToken;
6749: if ((oldToken = token).next != null)
6750: token = token.next;
6751: else
6752: token = token.next = token_source.getNextToken();
6753: jj_ntk = -1;
6754: if (token.kind == kind) {
6755: return token;
6756: }
6757: token = oldToken;
6758: throw generateParseException();
6759: }
6760:
6761: static private final class LookaheadSuccess extends java.lang.Error {
6762: }
6763:
6764: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
6765:
6766: final private boolean jj_scan_token(int kind) {
6767: if (jj_scanpos == jj_lastpos) {
6768: jj_la--;
6769: if (jj_scanpos.next == null) {
6770: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
6771: .getNextToken();
6772: } else {
6773: jj_lastpos = jj_scanpos = jj_scanpos.next;
6774: }
6775: } else {
6776: jj_scanpos = jj_scanpos.next;
6777: }
6778: if (jj_scanpos.kind != kind)
6779: return true;
6780: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6781: throw jj_ls;
6782: return false;
6783: }
6784:
6785: final public Token getNextToken() {
6786: if (token.next != null)
6787: token = token.next;
6788: else
6789: token = token.next = token_source.getNextToken();
6790: jj_ntk = -1;
6791: return token;
6792: }
6793:
6794: final public Token getToken(int index) {
6795: Token t = lookingAhead ? jj_scanpos : token;
6796: for (int i = 0; i < index; i++) {
6797: if (t.next != null)
6798: t = t.next;
6799: else
6800: t = t.next = token_source.getNextToken();
6801: }
6802: return t;
6803: }
6804:
6805: final private int jj_ntk() {
6806: if ((jj_nt = token.next) == null)
6807: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
6808: else
6809: return (jj_ntk = jj_nt.kind);
6810: }
6811:
6812: public ParseException generateParseException() {
6813: Token errortok = token.next;
6814: int line = errortok.beginLine, column = errortok.beginColumn;
6815: String mess = (errortok.kind == 0) ? tokenImage[0]
6816: : errortok.image;
6817: return new ParseException("Parse error at line " + line
6818: + ", column " + column + ". Encountered: " + mess);
6819: }
6820:
6821: final public void enable_tracing() {
6822: }
6823:
6824: final public void disable_tracing() {
6825: }
6826:
6827: }
|