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