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