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