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