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