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