0001: /* Generated By:JJTree&JavaCC: Do not edit this line. CSSParser.java */
0002: package org.netbeans.modules.css.parser;
0003:
0004: import java.util.*;
0005:
0006: public class CSSParser/*@bgen(jjtree)*/implements
0007: CSSParserTreeConstants, CSSParserConstants {/*@bgen(jjtree)*/
0008: protected JJTCSSParserState jjtree = new JJTCSSParserState();
0009: private ArrayList errors = new ArrayList();
0010:
0011: public CSSParser() {
0012: this ((CharStream) null);
0013: }
0014:
0015: public List errors() {
0016: return errors;
0017: }
0018:
0019: final public SimpleNode styleSheet() throws ParseException {
0020: /*@bgen(jjtree) styleSheet */
0021: SimpleNode jjtn000 = new SimpleNode(JJTSTYLESHEET);
0022: boolean jjtc000 = true;
0023: jjtree.openNodeScope(jjtn000);
0024: jjtn000.jjtSetFirstToken(getToken(1));
0025: try {
0026: styleSheetRuleList();
0027: jjtree.closeNodeScope(jjtn000, true);
0028: jjtc000 = false;
0029: jjtn000.jjtSetLastToken(getToken(0));
0030: {
0031: if (true)
0032: return jjtn000;
0033: }
0034: } catch (Throwable jjte000) {
0035: if (jjtc000) {
0036: jjtree.clearNodeScope(jjtn000);
0037: jjtc000 = false;
0038: } else {
0039: jjtree.popNode();
0040: }
0041: if (jjte000 instanceof RuntimeException) {
0042: {
0043: if (true)
0044: throw (RuntimeException) jjte000;
0045: }
0046: }
0047: if (jjte000 instanceof ParseException) {
0048: {
0049: if (true)
0050: throw (ParseException) jjte000;
0051: }
0052: }
0053: {
0054: if (true)
0055: throw (Error) jjte000;
0056: }
0057: } finally {
0058: if (jjtc000) {
0059: jjtree.closeNodeScope(jjtn000, true);
0060: jjtn000.jjtSetLastToken(getToken(0));
0061: }
0062: }
0063: throw new Error("Missing return statement in function");
0064: }
0065:
0066: final public void styleSheetRuleList() throws ParseException {
0067: /*@bgen(jjtree) styleSheetRuleList */
0068: SimpleNode jjtn000 = new SimpleNode(JJTSTYLESHEETRULELIST);
0069: boolean jjtc000 = true;
0070: jjtree.openNodeScope(jjtn000);
0071: jjtn000.jjtSetFirstToken(getToken(1));
0072: try {
0073: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0074: case CHARSET_SYM:
0075: charsetRule();
0076: break;
0077: default:
0078: jj_la1[0] = jj_gen;
0079: ;
0080: }
0081: label_1: while (true) {
0082: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0083: case S:
0084: case CDO:
0085: case CDC:
0086: ;
0087: break;
0088: default:
0089: jj_la1[1] = jj_gen;
0090: break label_1;
0091: }
0092: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0093: case S:
0094: jj_consume_token(S);
0095: break;
0096: case CDO:
0097: jj_consume_token(CDO);
0098: break;
0099: case CDC:
0100: jj_consume_token(CDC);
0101: break;
0102: default:
0103: jj_la1[2] = jj_gen;
0104: jj_consume_token(-1);
0105: throw new ParseException();
0106: }
0107: }
0108: label_2: while (true) {
0109: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0110: case IMPORT_SYM:
0111: ;
0112: break;
0113: default:
0114: jj_la1[3] = jj_gen;
0115: break label_2;
0116: }
0117: importRule();
0118: label_3: while (true) {
0119: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0120: case S:
0121: case CDO:
0122: case CDC:
0123: ;
0124: break;
0125: default:
0126: jj_la1[4] = jj_gen;
0127: break label_3;
0128: }
0129: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0130: case S:
0131: jj_consume_token(S);
0132: break;
0133: case CDO:
0134: jj_consume_token(CDO);
0135: break;
0136: case CDC:
0137: jj_consume_token(CDC);
0138: break;
0139: default:
0140: jj_la1[5] = jj_gen;
0141: jj_consume_token(-1);
0142: throw new ParseException();
0143: }
0144: }
0145: }
0146: label_4: while (true) {
0147: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0148: case DOT:
0149: case COLON:
0150: case ASTERISK:
0151: case LSQUARE:
0152: case HASH:
0153: case PAGE_SYM:
0154: case MEDIA_SYM:
0155: case FONT_FACE_SYM:
0156: case ATKEYWORD:
0157: case IDENT:
0158: ;
0159: break;
0160: default:
0161: jj_la1[6] = jj_gen;
0162: break label_4;
0163: }
0164: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0165: case DOT:
0166: case COLON:
0167: case ASTERISK:
0168: case LSQUARE:
0169: case HASH:
0170: case IDENT:
0171: styleRule();
0172: break;
0173: case MEDIA_SYM:
0174: mediaRule();
0175: break;
0176: case PAGE_SYM:
0177: pageRule();
0178: break;
0179: case FONT_FACE_SYM:
0180: fontFaceRule();
0181: break;
0182: case ATKEYWORD:
0183: unknownRule();
0184: break;
0185: default:
0186: jj_la1[7] = jj_gen;
0187: jj_consume_token(-1);
0188: throw new ParseException();
0189: }
0190: label_5: while (true) {
0191: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0192: case S:
0193: case CDO:
0194: case CDC:
0195: ;
0196: break;
0197: default:
0198: jj_la1[8] = jj_gen;
0199: break label_5;
0200: }
0201: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0202: case S:
0203: jj_consume_token(S);
0204: break;
0205: case CDO:
0206: jj_consume_token(CDO);
0207: break;
0208: case CDC:
0209: jj_consume_token(CDC);
0210: break;
0211: default:
0212: jj_la1[9] = jj_gen;
0213: jj_consume_token(-1);
0214: throw new ParseException();
0215: }
0216: }
0217: }
0218: } catch (Throwable jjte000) {
0219: if (jjtc000) {
0220: jjtree.clearNodeScope(jjtn000);
0221: jjtc000 = false;
0222: } else {
0223: jjtree.popNode();
0224: }
0225: if (jjte000 instanceof RuntimeException) {
0226: {
0227: if (true)
0228: throw (RuntimeException) jjte000;
0229: }
0230: }
0231: if (jjte000 instanceof ParseException) {
0232: {
0233: if (true)
0234: throw (ParseException) jjte000;
0235: }
0236: }
0237: {
0238: if (true)
0239: throw (Error) jjte000;
0240: }
0241: } finally {
0242: if (jjtc000) {
0243: jjtree.closeNodeScope(jjtn000, true);
0244: jjtn000.jjtSetLastToken(getToken(0));
0245: }
0246: }
0247: }
0248:
0249: //
0250: // This is used by ASTStyleSheet.insertRule to parse a single rule
0251: //
0252: final public void styleSheetRuleSingle() throws ParseException {
0253: /*@bgen(jjtree) styleSheetRuleSingle */
0254: SimpleNode jjtn000 = new SimpleNode(JJTSTYLESHEETRULESINGLE);
0255: boolean jjtc000 = true;
0256: jjtree.openNodeScope(jjtn000);
0257: jjtn000.jjtSetFirstToken(getToken(1));
0258: try {
0259: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0260: case CHARSET_SYM:
0261: charsetRule();
0262: break;
0263: case IMPORT_SYM:
0264: importRule();
0265: break;
0266: case DOT:
0267: case COLON:
0268: case ASTERISK:
0269: case LSQUARE:
0270: case HASH:
0271: case IDENT:
0272: styleRule();
0273: break;
0274: case MEDIA_SYM:
0275: mediaRule();
0276: break;
0277: case PAGE_SYM:
0278: pageRule();
0279: break;
0280: case FONT_FACE_SYM:
0281: fontFaceRule();
0282: break;
0283: case ATKEYWORD:
0284: unknownRule();
0285: break;
0286: default:
0287: jj_la1[10] = jj_gen;
0288: jj_consume_token(-1);
0289: throw new ParseException();
0290: }
0291: } catch (Throwable jjte000) {
0292: if (jjtc000) {
0293: jjtree.clearNodeScope(jjtn000);
0294: jjtc000 = false;
0295: } else {
0296: jjtree.popNode();
0297: }
0298: if (jjte000 instanceof RuntimeException) {
0299: {
0300: if (true)
0301: throw (RuntimeException) jjte000;
0302: }
0303: }
0304: if (jjte000 instanceof ParseException) {
0305: {
0306: if (true)
0307: throw (ParseException) jjte000;
0308: }
0309: }
0310: {
0311: if (true)
0312: throw (Error) jjte000;
0313: }
0314: } finally {
0315: if (jjtc000) {
0316: jjtree.closeNodeScope(jjtn000, true);
0317: jjtn000.jjtSetLastToken(getToken(0));
0318: }
0319: }
0320: }
0321:
0322: final public void charsetRule() throws ParseException {
0323: /*@bgen(jjtree) charsetRule */
0324: SimpleNode jjtn000 = new SimpleNode(JJTCHARSETRULE);
0325: boolean jjtc000 = true;
0326: jjtree.openNodeScope(jjtn000);
0327: jjtn000.jjtSetFirstToken(getToken(1));
0328: try {
0329: jj_consume_token(CHARSET_SYM);
0330: label_6: while (true) {
0331: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0332: case S:
0333: ;
0334: break;
0335: default:
0336: jj_la1[11] = jj_gen;
0337: break label_6;
0338: }
0339: jj_consume_token(S);
0340: }
0341: jj_consume_token(STRING);
0342: label_7: while (true) {
0343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0344: case S:
0345: ;
0346: break;
0347: default:
0348: jj_la1[12] = jj_gen;
0349: break label_7;
0350: }
0351: jj_consume_token(S);
0352: }
0353: jj_consume_token(SEMICOLON);
0354: } finally {
0355: if (jjtc000) {
0356: jjtree.closeNodeScope(jjtn000, true);
0357: jjtn000.jjtSetLastToken(getToken(0));
0358: }
0359: }
0360: }
0361:
0362: final public void unknownRule() throws ParseException {
0363: /*@bgen(jjtree) unknownRule */
0364: SimpleNode jjtn000 = new SimpleNode(JJTUNKNOWNRULE);
0365: boolean jjtc000 = true;
0366: jjtree.openNodeScope(jjtn000);
0367: jjtn000.jjtSetFirstToken(getToken(1));
0368: try {
0369: jj_consume_token(ATKEYWORD);
0370: skip();
0371: } finally {
0372: if (jjtc000) {
0373: jjtree.closeNodeScope(jjtn000, true);
0374: jjtn000.jjtSetLastToken(getToken(0));
0375: }
0376: }
0377: }
0378:
0379: final public void importRule() throws ParseException {
0380: /*@bgen(jjtree) importRule */
0381: SimpleNode jjtn000 = new SimpleNode(JJTIMPORTRULE);
0382: boolean jjtc000 = true;
0383: jjtree.openNodeScope(jjtn000);
0384: jjtn000.jjtSetFirstToken(getToken(1));
0385: try {
0386: jj_consume_token(IMPORT_SYM);
0387: label_8: while (true) {
0388: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0389: case S:
0390: ;
0391: break;
0392: default:
0393: jj_la1[13] = jj_gen;
0394: break label_8;
0395: }
0396: jj_consume_token(S);
0397: }
0398: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0399: case STRING:
0400: jj_consume_token(STRING);
0401: break;
0402: case URI:
0403: jj_consume_token(URI);
0404: break;
0405: default:
0406: jj_la1[14] = jj_gen;
0407: jj_consume_token(-1);
0408: throw new ParseException();
0409: }
0410: label_9: while (true) {
0411: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0412: case S:
0413: ;
0414: break;
0415: default:
0416: jj_la1[15] = jj_gen;
0417: break label_9;
0418: }
0419: jj_consume_token(S);
0420: }
0421: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0422: case IDENT:
0423: mediaList();
0424: break;
0425: default:
0426: jj_la1[16] = jj_gen;
0427: ;
0428: }
0429: jj_consume_token(SEMICOLON);
0430: } catch (Throwable jjte000) {
0431: if (jjtc000) {
0432: jjtree.clearNodeScope(jjtn000);
0433: jjtc000 = false;
0434: } else {
0435: jjtree.popNode();
0436: }
0437: if (jjte000 instanceof RuntimeException) {
0438: {
0439: if (true)
0440: throw (RuntimeException) jjte000;
0441: }
0442: }
0443: if (jjte000 instanceof ParseException) {
0444: {
0445: if (true)
0446: throw (ParseException) jjte000;
0447: }
0448: }
0449: {
0450: if (true)
0451: throw (Error) jjte000;
0452: }
0453: } finally {
0454: if (jjtc000) {
0455: jjtree.closeNodeScope(jjtn000, true);
0456: jjtn000.jjtSetLastToken(getToken(0));
0457: }
0458: }
0459: }
0460:
0461: final public void mediaRule() throws ParseException {
0462: /*@bgen(jjtree) mediaRule */
0463: SimpleNode jjtn000 = new SimpleNode(JJTMEDIARULE);
0464: boolean jjtc000 = true;
0465: jjtree.openNodeScope(jjtn000);
0466: jjtn000.jjtSetFirstToken(getToken(1));
0467: try {
0468: jj_consume_token(MEDIA_SYM);
0469: label_10: while (true) {
0470: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0471: case S:
0472: ;
0473: break;
0474: default:
0475: jj_la1[17] = jj_gen;
0476: break label_10;
0477: }
0478: jj_consume_token(S);
0479: }
0480: mediaList();
0481: jj_consume_token(LBRACE);
0482: label_11: while (true) {
0483: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0484: case S:
0485: ;
0486: break;
0487: default:
0488: jj_la1[18] = jj_gen;
0489: break label_11;
0490: }
0491: jj_consume_token(S);
0492: }
0493: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0494: case DOT:
0495: case COLON:
0496: case ASTERISK:
0497: case LSQUARE:
0498: case HASH:
0499: case PAGE_SYM:
0500: case ATKEYWORD:
0501: case IDENT:
0502: mediaRuleList();
0503: break;
0504: default:
0505: jj_la1[19] = jj_gen;
0506: ;
0507: }
0508: jj_consume_token(RBRACE);
0509: } catch (Throwable jjte000) {
0510: if (jjtc000) {
0511: jjtree.clearNodeScope(jjtn000);
0512: jjtc000 = false;
0513: } else {
0514: jjtree.popNode();
0515: }
0516: if (jjte000 instanceof RuntimeException) {
0517: {
0518: if (true)
0519: throw (RuntimeException) jjte000;
0520: }
0521: }
0522: if (jjte000 instanceof ParseException) {
0523: {
0524: if (true)
0525: throw (ParseException) jjte000;
0526: }
0527: }
0528: {
0529: if (true)
0530: throw (Error) jjte000;
0531: }
0532: } finally {
0533: if (jjtc000) {
0534: jjtree.closeNodeScope(jjtn000, true);
0535: jjtn000.jjtSetLastToken(getToken(0));
0536: }
0537: }
0538: }
0539:
0540: final public void mediaList() throws ParseException {
0541: /*@bgen(jjtree) mediaList */
0542: SimpleNode jjtn000 = new SimpleNode(JJTMEDIALIST);
0543: boolean jjtc000 = true;
0544: jjtree.openNodeScope(jjtn000);
0545: jjtn000.jjtSetFirstToken(getToken(1));
0546: try {
0547: medium();
0548: label_12: while (true) {
0549: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0550: case COMMA:
0551: ;
0552: break;
0553: default:
0554: jj_la1[20] = jj_gen;
0555: break label_12;
0556: }
0557: jj_consume_token(COMMA);
0558: label_13: while (true) {
0559: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0560: case S:
0561: ;
0562: break;
0563: default:
0564: jj_la1[21] = jj_gen;
0565: break label_13;
0566: }
0567: jj_consume_token(S);
0568: }
0569: medium();
0570: }
0571: } catch (Throwable jjte000) {
0572: if (jjtc000) {
0573: jjtree.clearNodeScope(jjtn000);
0574: jjtc000 = false;
0575: } else {
0576: jjtree.popNode();
0577: }
0578: if (jjte000 instanceof RuntimeException) {
0579: {
0580: if (true)
0581: throw (RuntimeException) jjte000;
0582: }
0583: }
0584: if (jjte000 instanceof ParseException) {
0585: {
0586: if (true)
0587: throw (ParseException) jjte000;
0588: }
0589: }
0590: {
0591: if (true)
0592: throw (Error) jjte000;
0593: }
0594: } finally {
0595: if (jjtc000) {
0596: jjtree.closeNodeScope(jjtn000, true);
0597: jjtn000.jjtSetLastToken(getToken(0));
0598: }
0599: }
0600: }
0601:
0602: final public void mediaRuleList() throws ParseException {
0603: /*@bgen(jjtree) mediaRuleList */
0604: SimpleNode jjtn000 = new SimpleNode(JJTMEDIARULELIST);
0605: boolean jjtc000 = true;
0606: jjtree.openNodeScope(jjtn000);
0607: jjtn000.jjtSetFirstToken(getToken(1));
0608: try {
0609: label_14: while (true) {
0610: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0611: case DOT:
0612: case COLON:
0613: case ASTERISK:
0614: case LSQUARE:
0615: case HASH:
0616: case IDENT:
0617: styleRule();
0618: break;
0619: case PAGE_SYM:
0620: pageRule();
0621: break;
0622: case ATKEYWORD:
0623: unknownRule();
0624: break;
0625: default:
0626: jj_la1[22] = jj_gen;
0627: jj_consume_token(-1);
0628: throw new ParseException();
0629: }
0630: label_15: while (true) {
0631: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0632: case S:
0633: ;
0634: break;
0635: default:
0636: jj_la1[23] = jj_gen;
0637: break label_15;
0638: }
0639: jj_consume_token(S);
0640: }
0641: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0642: case DOT:
0643: case COLON:
0644: case ASTERISK:
0645: case LSQUARE:
0646: case HASH:
0647: case PAGE_SYM:
0648: case ATKEYWORD:
0649: case IDENT:
0650: ;
0651: break;
0652: default:
0653: jj_la1[24] = jj_gen;
0654: break label_14;
0655: }
0656: }
0657: } catch (Throwable jjte000) {
0658: if (jjtc000) {
0659: jjtree.clearNodeScope(jjtn000);
0660: jjtc000 = false;
0661: } else {
0662: jjtree.popNode();
0663: }
0664: if (jjte000 instanceof RuntimeException) {
0665: {
0666: if (true)
0667: throw (RuntimeException) jjte000;
0668: }
0669: }
0670: if (jjte000 instanceof ParseException) {
0671: {
0672: if (true)
0673: throw (ParseException) jjte000;
0674: }
0675: }
0676: {
0677: if (true)
0678: throw (Error) jjte000;
0679: }
0680: } finally {
0681: if (jjtc000) {
0682: jjtree.closeNodeScope(jjtn000, true);
0683: jjtn000.jjtSetLastToken(getToken(0));
0684: }
0685: }
0686: }
0687:
0688: final public void mediaRuleSingle() throws ParseException {
0689: /*@bgen(jjtree) mediaRuleSingle */
0690: SimpleNode jjtn000 = new SimpleNode(JJTMEDIARULESINGLE);
0691: boolean jjtc000 = true;
0692: jjtree.openNodeScope(jjtn000);
0693: jjtn000.jjtSetFirstToken(getToken(1));
0694: try {
0695: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0696: case DOT:
0697: case COLON:
0698: case ASTERISK:
0699: case LSQUARE:
0700: case HASH:
0701: case IDENT:
0702: styleRule();
0703: break;
0704: case PAGE_SYM:
0705: pageRule();
0706: break;
0707: case ATKEYWORD:
0708: unknownRule();
0709: break;
0710: default:
0711: jj_la1[25] = jj_gen;
0712: jj_consume_token(-1);
0713: throw new ParseException();
0714: }
0715: } catch (Throwable jjte000) {
0716: if (jjtc000) {
0717: jjtree.clearNodeScope(jjtn000);
0718: jjtc000 = false;
0719: } else {
0720: jjtree.popNode();
0721: }
0722: if (jjte000 instanceof RuntimeException) {
0723: {
0724: if (true)
0725: throw (RuntimeException) jjte000;
0726: }
0727: }
0728: if (jjte000 instanceof ParseException) {
0729: {
0730: if (true)
0731: throw (ParseException) jjte000;
0732: }
0733: }
0734: {
0735: if (true)
0736: throw (Error) jjte000;
0737: }
0738: } finally {
0739: if (jjtc000) {
0740: jjtree.closeNodeScope(jjtn000, true);
0741: jjtn000.jjtSetLastToken(getToken(0));
0742: }
0743: }
0744: }
0745:
0746: final public void medium() throws ParseException {
0747: /*@bgen(jjtree) medium */
0748: SimpleNode jjtn000 = new SimpleNode(JJTMEDIUM);
0749: boolean jjtc000 = true;
0750: jjtree.openNodeScope(jjtn000);
0751: jjtn000.jjtSetFirstToken(getToken(1));
0752: try {
0753: jj_consume_token(IDENT);
0754: label_16: while (true) {
0755: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0756: case S:
0757: ;
0758: break;
0759: default:
0760: jj_la1[26] = jj_gen;
0761: break label_16;
0762: }
0763: jj_consume_token(S);
0764: }
0765: } finally {
0766: if (jjtc000) {
0767: jjtree.closeNodeScope(jjtn000, true);
0768: jjtn000.jjtSetLastToken(getToken(0));
0769: }
0770: }
0771: }
0772:
0773: final public void pageRule() throws ParseException {
0774: /*@bgen(jjtree) pageRule */
0775: SimpleNode jjtn000 = new SimpleNode(JJTPAGERULE);
0776: boolean jjtc000 = true;
0777: jjtree.openNodeScope(jjtn000);
0778: jjtn000.jjtSetFirstToken(getToken(1));
0779: Token t = null;
0780: String s = null;
0781: boolean start = false;
0782: try {
0783: jj_consume_token(PAGE_SYM);
0784: label_17: while (true) {
0785: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0786: case S:
0787: ;
0788: break;
0789: default:
0790: jj_la1[27] = jj_gen;
0791: break label_17;
0792: }
0793: jj_consume_token(S);
0794: }
0795: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0796: case COLON:
0797: case IDENT:
0798: if (jj_2_1(2)) {
0799: t = jj_consume_token(IDENT);
0800: label_18: while (true) {
0801: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0802: case S:
0803: ;
0804: break;
0805: default:
0806: jj_la1[28] = jj_gen;
0807: break label_18;
0808: }
0809: jj_consume_token(S);
0810: }
0811: } else {
0812: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0813: case IDENT:
0814: jj_consume_token(IDENT);
0815: pseudoPage();
0816: label_19: while (true) {
0817: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0818: case S:
0819: ;
0820: break;
0821: default:
0822: jj_la1[29] = jj_gen;
0823: break label_19;
0824: }
0825: jj_consume_token(S);
0826: }
0827: break;
0828: case COLON:
0829: pseudoPage();
0830: label_20: while (true) {
0831: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0832: case S:
0833: ;
0834: break;
0835: default:
0836: jj_la1[30] = jj_gen;
0837: break label_20;
0838: }
0839: jj_consume_token(S);
0840: }
0841: break;
0842: default:
0843: jj_la1[31] = jj_gen;
0844: jj_consume_token(-1);
0845: throw new ParseException();
0846: }
0847: }
0848: break;
0849: default:
0850: jj_la1[32] = jj_gen;
0851: ;
0852: }
0853: jj_consume_token(LBRACE);
0854: label_21: while (true) {
0855: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0856: case S:
0857: ;
0858: break;
0859: default:
0860: jj_la1[33] = jj_gen;
0861: break label_21;
0862: }
0863: jj_consume_token(S);
0864: }
0865: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0866: case IDENT:
0867: declaration();
0868: break;
0869: default:
0870: jj_la1[34] = jj_gen;
0871: ;
0872: }
0873: label_22: while (true) {
0874: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0875: case SEMICOLON:
0876: ;
0877: break;
0878: default:
0879: jj_la1[35] = jj_gen;
0880: break label_22;
0881: }
0882: jj_consume_token(SEMICOLON);
0883: label_23: while (true) {
0884: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0885: case S:
0886: ;
0887: break;
0888: default:
0889: jj_la1[36] = jj_gen;
0890: break label_23;
0891: }
0892: jj_consume_token(S);
0893: }
0894: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0895: case IDENT:
0896: declaration();
0897: break;
0898: default:
0899: jj_la1[37] = jj_gen;
0900: ;
0901: }
0902: }
0903: jj_consume_token(RBRACE);
0904: } catch (Throwable jjte000) {
0905: if (jjtc000) {
0906: jjtree.clearNodeScope(jjtn000);
0907: jjtc000 = false;
0908: } else {
0909: jjtree.popNode();
0910: }
0911: if (jjte000 instanceof RuntimeException) {
0912: {
0913: if (true)
0914: throw (RuntimeException) jjte000;
0915: }
0916: }
0917: if (jjte000 instanceof ParseException) {
0918: {
0919: if (true)
0920: throw (ParseException) jjte000;
0921: }
0922: }
0923: {
0924: if (true)
0925: throw (Error) jjte000;
0926: }
0927: } finally {
0928: if (jjtc000) {
0929: jjtree.closeNodeScope(jjtn000, true);
0930: jjtn000.jjtSetLastToken(getToken(0));
0931: }
0932: }
0933: }
0934:
0935: //
0936: // pseudoPage
0937: // : ':' IDENT
0938: // ;
0939: //
0940: final public void pseudoPage() throws ParseException {
0941: /*@bgen(jjtree) pseudoPage */
0942: SimpleNode jjtn000 = new SimpleNode(JJTPSEUDOPAGE);
0943: boolean jjtc000 = true;
0944: jjtree.openNodeScope(jjtn000);
0945: jjtn000.jjtSetFirstToken(getToken(1));
0946: try {
0947: jj_consume_token(COLON);
0948: jj_consume_token(IDENT);
0949: } finally {
0950: if (jjtc000) {
0951: jjtree.closeNodeScope(jjtn000, true);
0952: jjtn000.jjtSetLastToken(getToken(0));
0953: }
0954: }
0955: }
0956:
0957: //
0958: // font_face
0959: // : FONT_FACE_SYM S*
0960: // '{' S* declaration [ ';' S* declaration ]* '}' S*
0961: // ;
0962: //
0963: final public void fontFaceRule() throws ParseException {
0964: /*@bgen(jjtree) fontFaceRule */
0965: SimpleNode jjtn000 = new SimpleNode(JJTFONTFACERULE);
0966: boolean jjtc000 = true;
0967: jjtree.openNodeScope(jjtn000);
0968: jjtn000.jjtSetFirstToken(getToken(1));
0969: try {
0970: jj_consume_token(FONT_FACE_SYM);
0971: label_24: while (true) {
0972: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0973: case S:
0974: ;
0975: break;
0976: default:
0977: jj_la1[38] = jj_gen;
0978: break label_24;
0979: }
0980: jj_consume_token(S);
0981: }
0982: jj_consume_token(LBRACE);
0983: label_25: while (true) {
0984: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0985: case S:
0986: ;
0987: break;
0988: default:
0989: jj_la1[39] = jj_gen;
0990: break label_25;
0991: }
0992: jj_consume_token(S);
0993: }
0994: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0995: case IDENT:
0996: declaration();
0997: break;
0998: default:
0999: jj_la1[40] = jj_gen;
1000: ;
1001: }
1002: label_26: while (true) {
1003: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1004: case SEMICOLON:
1005: ;
1006: break;
1007: default:
1008: jj_la1[41] = jj_gen;
1009: break label_26;
1010: }
1011: jj_consume_token(SEMICOLON);
1012: label_27: while (true) {
1013: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1014: case S:
1015: ;
1016: break;
1017: default:
1018: jj_la1[42] = jj_gen;
1019: break label_27;
1020: }
1021: jj_consume_token(S);
1022: }
1023: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1024: case IDENT:
1025: declaration();
1026: break;
1027: default:
1028: jj_la1[43] = jj_gen;
1029: ;
1030: }
1031: }
1032: jj_consume_token(RBRACE);
1033: } catch (Throwable jjte000) {
1034: if (jjtc000) {
1035: jjtree.clearNodeScope(jjtn000);
1036: jjtc000 = false;
1037: } else {
1038: jjtree.popNode();
1039: }
1040: if (jjte000 instanceof RuntimeException) {
1041: {
1042: if (true)
1043: throw (RuntimeException) jjte000;
1044: }
1045: }
1046: if (jjte000 instanceof ParseException) {
1047: {
1048: if (true)
1049: throw (ParseException) jjte000;
1050: }
1051: }
1052: {
1053: if (true)
1054: throw (Error) jjte000;
1055: }
1056: } finally {
1057: if (jjtc000) {
1058: jjtree.closeNodeScope(jjtn000, true);
1059: jjtn000.jjtSetLastToken(getToken(0));
1060: }
1061: }
1062: }
1063:
1064: //
1065: // operator
1066: // : '/' S* | ',' S* |
1067: // ;
1068: //
1069: final public void operator() throws ParseException {
1070: /*@bgen(jjtree) operator */
1071: SimpleNode jjtn000 = new SimpleNode(JJTOPERATOR);
1072: boolean jjtc000 = true;
1073: jjtree.openNodeScope(jjtn000);
1074: jjtn000.jjtSetFirstToken(getToken(1));
1075: try {
1076: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1077: case SLASH:
1078: jj_consume_token(SLASH);
1079: label_28: while (true) {
1080: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1081: case S:
1082: ;
1083: break;
1084: default:
1085: jj_la1[44] = jj_gen;
1086: break label_28;
1087: }
1088: jj_consume_token(S);
1089: }
1090: break;
1091: case COMMA:
1092: jj_consume_token(COMMA);
1093: label_29: while (true) {
1094: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1095: case S:
1096: ;
1097: break;
1098: default:
1099: jj_la1[45] = jj_gen;
1100: break label_29;
1101: }
1102: jj_consume_token(S);
1103: }
1104: break;
1105: default:
1106: jj_la1[46] = jj_gen;
1107: jj_consume_token(-1);
1108: throw new ParseException();
1109: }
1110: } finally {
1111: if (jjtc000) {
1112: jjtree.closeNodeScope(jjtn000, true);
1113: jjtn000.jjtSetLastToken(getToken(0));
1114: }
1115: }
1116: }
1117:
1118: //
1119: // combinator
1120: // : '+' S* | '>' S* |
1121: // ;
1122: //
1123: final public void combinator() throws ParseException {
1124: /*@bgen(jjtree) combinator */
1125: SimpleNode jjtn000 = new SimpleNode(JJTCOMBINATOR);
1126: boolean jjtc000 = true;
1127: jjtree.openNodeScope(jjtn000);
1128: jjtn000.jjtSetFirstToken(getToken(1));
1129: try {
1130: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1131: case PLUS:
1132: jj_consume_token(PLUS);
1133: label_30: while (true) {
1134: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1135: case S:
1136: ;
1137: break;
1138: default:
1139: jj_la1[47] = jj_gen;
1140: break label_30;
1141: }
1142: jj_consume_token(S);
1143: }
1144: break;
1145: case GT:
1146: jj_consume_token(GT);
1147: label_31: while (true) {
1148: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1149: case S:
1150: ;
1151: break;
1152: default:
1153: jj_la1[48] = jj_gen;
1154: break label_31;
1155: }
1156: jj_consume_token(S);
1157: }
1158: break;
1159: case S:
1160: jj_consume_token(S);
1161: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1162: case PLUS:
1163: case GT:
1164: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1165: case PLUS:
1166: jj_consume_token(PLUS);
1167: break;
1168: case GT:
1169: jj_consume_token(GT);
1170: break;
1171: default:
1172: jj_la1[49] = jj_gen;
1173: jj_consume_token(-1);
1174: throw new ParseException();
1175: }
1176: label_32: while (true) {
1177: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1178: case S:
1179: ;
1180: break;
1181: default:
1182: jj_la1[50] = jj_gen;
1183: break label_32;
1184: }
1185: jj_consume_token(S);
1186: }
1187: break;
1188: default:
1189: jj_la1[51] = jj_gen;
1190: ;
1191: }
1192: break;
1193: default:
1194: jj_la1[52] = jj_gen;
1195: jj_consume_token(-1);
1196: throw new ParseException();
1197: }
1198: } finally {
1199: if (jjtc000) {
1200: jjtree.closeNodeScope(jjtn000, true);
1201: jjtn000.jjtSetLastToken(getToken(0));
1202: }
1203: }
1204: }
1205:
1206: //
1207: // unary_operator
1208: // : '-' | '+'
1209: // ;
1210: //
1211: final public void unaryOperator() throws ParseException {
1212: /*@bgen(jjtree) unaryOperator */
1213: SimpleNode jjtn000 = new SimpleNode(JJTUNARYOPERATOR);
1214: boolean jjtc000 = true;
1215: jjtree.openNodeScope(jjtn000);
1216: jjtn000.jjtSetFirstToken(getToken(1));
1217: try {
1218: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1219: case MINUS:
1220: jj_consume_token(MINUS);
1221: break;
1222: case PLUS:
1223: jj_consume_token(PLUS);
1224: break;
1225: default:
1226: jj_la1[53] = jj_gen;
1227: jj_consume_token(-1);
1228: throw new ParseException();
1229: }
1230: } finally {
1231: if (jjtc000) {
1232: jjtree.closeNodeScope(jjtn000, true);
1233: jjtn000.jjtSetLastToken(getToken(0));
1234: }
1235: }
1236: }
1237:
1238: //
1239: // property
1240: // : IDENT S*
1241: // ;
1242: //
1243: final public void property() throws ParseException {
1244: /*@bgen(jjtree) property */
1245: SimpleNode jjtn000 = new SimpleNode(JJTPROPERTY);
1246: boolean jjtc000 = true;
1247: jjtree.openNodeScope(jjtn000);
1248: jjtn000.jjtSetFirstToken(getToken(1));
1249: try {
1250: jj_consume_token(IDENT);
1251: label_33: while (true) {
1252: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1253: case S:
1254: ;
1255: break;
1256: default:
1257: jj_la1[54] = jj_gen;
1258: break label_33;
1259: }
1260: jj_consume_token(S);
1261: }
1262: } finally {
1263: if (jjtc000) {
1264: jjtree.closeNodeScope(jjtn000, true);
1265: jjtn000.jjtSetLastToken(getToken(0));
1266: }
1267: }
1268: }
1269:
1270: //
1271: // ruleset
1272: // : selector [ ',' S* selector ]*
1273: // '{' S* declaration [ ';' S* declaration ]* '}' S*
1274: // ;
1275: //
1276:
1277: //TODO marek: resolve the error reporting and recovery in styleRule()
1278: final public void styleRule() throws ParseException {
1279: /*@bgen(jjtree) styleRule */
1280: SimpleNode jjtn000 = new SimpleNode(JJTSTYLERULE);
1281: boolean jjtc000 = true;
1282: jjtree.openNodeScope(jjtn000);
1283: jjtn000.jjtSetFirstToken(getToken(1));
1284: try {
1285: try {
1286: selectorList();
1287: jj_consume_token(LBRACE);
1288: label_34: while (true) {
1289: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1290: case S:
1291: ;
1292: break;
1293: default:
1294: jj_la1[55] = jj_gen;
1295: break label_34;
1296: }
1297: jj_consume_token(S);
1298: }
1299: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1300: case IDENT:
1301: declaration();
1302: break;
1303: default:
1304: jj_la1[56] = jj_gen;
1305: ;
1306: }
1307: label_35: while (true) {
1308: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1309: case SEMICOLON:
1310: ;
1311: break;
1312: default:
1313: jj_la1[57] = jj_gen;
1314: break label_35;
1315: }
1316: jj_consume_token(SEMICOLON);
1317: label_36: while (true) {
1318: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1319: case S:
1320: ;
1321: break;
1322: default:
1323: jj_la1[58] = jj_gen;
1324: break label_36;
1325: }
1326: jj_consume_token(S);
1327: }
1328: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1329: case IDENT:
1330: declaration();
1331: break;
1332: default:
1333: jj_la1[59] = jj_gen;
1334: ;
1335: }
1336: }
1337: jj_consume_token(RBRACE);
1338: } catch (ParseException e) {
1339: reportError(e);
1340: error_skipblock();
1341: }
1342: } catch (Throwable jjte000) {
1343: if (jjtc000) {
1344: jjtree.clearNodeScope(jjtn000);
1345: jjtc000 = false;
1346: } else {
1347: jjtree.popNode();
1348: }
1349: if (jjte000 instanceof RuntimeException) {
1350: {
1351: if (true)
1352: throw (RuntimeException) jjte000;
1353: }
1354: }
1355: if (jjte000 instanceof ParseException) {
1356: {
1357: if (true)
1358: throw (ParseException) jjte000;
1359: }
1360: }
1361: {
1362: if (true)
1363: throw (Error) jjte000;
1364: }
1365: } finally {
1366: if (jjtc000) {
1367: jjtree.closeNodeScope(jjtn000, true);
1368: jjtn000.jjtSetLastToken(getToken(0));
1369: }
1370: }
1371: }
1372:
1373: final public void selectorList() throws ParseException {
1374: /*@bgen(jjtree) selectorList */
1375: SimpleNode jjtn000 = new SimpleNode(JJTSELECTORLIST);
1376: boolean jjtc000 = true;
1377: jjtree.openNodeScope(jjtn000);
1378: jjtn000.jjtSetFirstToken(getToken(1));
1379: try {
1380: try {
1381: selector();
1382: label_37: while (true) {
1383: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1384: case COMMA:
1385: ;
1386: break;
1387: default:
1388: jj_la1[60] = jj_gen;
1389: break label_37;
1390: }
1391: jj_consume_token(COMMA);
1392: label_38: while (true) {
1393: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1394: case S:
1395: ;
1396: break;
1397: default:
1398: jj_la1[61] = jj_gen;
1399: break label_38;
1400: }
1401: jj_consume_token(S);
1402: }
1403: selector();
1404: }
1405: } catch (ParseException e) {
1406: reportError(e);
1407: }
1408: } catch (Throwable jjte000) {
1409: if (jjtc000) {
1410: jjtree.clearNodeScope(jjtn000);
1411: jjtc000 = false;
1412: } else {
1413: jjtree.popNode();
1414: }
1415: if (jjte000 instanceof RuntimeException) {
1416: {
1417: if (true)
1418: throw (RuntimeException) jjte000;
1419: }
1420: }
1421: if (jjte000 instanceof ParseException) {
1422: {
1423: if (true)
1424: throw (ParseException) jjte000;
1425: }
1426: }
1427: {
1428: if (true)
1429: throw (Error) jjte000;
1430: }
1431: } finally {
1432: if (jjtc000) {
1433: jjtree.closeNodeScope(jjtn000, true);
1434: jjtn000.jjtSetLastToken(getToken(0));
1435: }
1436: }
1437: }
1438:
1439: //
1440: // selector
1441: // : simple_selector [ combinator simple_selector ]*
1442: // ;
1443: //
1444: final public void selector() throws ParseException {
1445: /*@bgen(jjtree) selector */
1446: SimpleNode jjtn000 = new SimpleNode(JJTSELECTOR);
1447: boolean jjtc000 = true;
1448: jjtree.openNodeScope(jjtn000);
1449: jjtn000.jjtSetFirstToken(getToken(1));
1450: try {
1451: try {
1452: simpleSelector();
1453: label_39: while (true) {
1454: if (jj_2_2(2)) {
1455: ;
1456: } else {
1457: break label_39;
1458: }
1459: combinator();
1460: simpleSelector();
1461: }
1462: label_40: while (true) {
1463: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1464: case S:
1465: ;
1466: break;
1467: default:
1468: jj_la1[62] = jj_gen;
1469: break label_40;
1470: }
1471: jj_consume_token(S);
1472: }
1473: } catch (ParseException e) {
1474: reportError(e);
1475: skipSelector();
1476: }
1477: } catch (Throwable jjte000) {
1478: if (jjtc000) {
1479: jjtree.clearNodeScope(jjtn000);
1480: jjtc000 = false;
1481: } else {
1482: jjtree.popNode();
1483: }
1484: if (jjte000 instanceof RuntimeException) {
1485: {
1486: if (true)
1487: throw (RuntimeException) jjte000;
1488: }
1489: }
1490: if (jjte000 instanceof ParseException) {
1491: {
1492: if (true)
1493: throw (ParseException) jjte000;
1494: }
1495: }
1496: {
1497: if (true)
1498: throw (Error) jjte000;
1499: }
1500: } finally {
1501: if (jjtc000) {
1502: jjtree.closeNodeScope(jjtn000, true);
1503: jjtn000.jjtSetLastToken(getToken(0));
1504: }
1505: }
1506: }
1507:
1508: //
1509: // simple_selector
1510: // : element_name? [ HASH | class | attrib | pseudo ]* S*
1511: // ;
1512: //
1513: final public void simpleSelector() throws ParseException {
1514: /*@bgen(jjtree) simpleSelector */
1515: SimpleNode jjtn000 = new SimpleNode(JJTSIMPLESELECTOR);
1516: boolean jjtc000 = true;
1517: jjtree.openNodeScope(jjtn000);
1518: jjtn000.jjtSetFirstToken(getToken(1));
1519: try {
1520: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1521: case ASTERISK:
1522: case IDENT:
1523: elementName();
1524: label_41: while (true) {
1525: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1526: case DOT:
1527: case COLON:
1528: case LSQUARE:
1529: case HASH:
1530: ;
1531: break;
1532: default:
1533: jj_la1[63] = jj_gen;
1534: break label_41;
1535: }
1536: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1537: case HASH:
1538: hash();
1539: break;
1540: case DOT:
1541: _class();
1542: break;
1543: case LSQUARE:
1544: attrib();
1545: break;
1546: case COLON:
1547: pseudo();
1548: break;
1549: default:
1550: jj_la1[64] = jj_gen;
1551: jj_consume_token(-1);
1552: throw new ParseException();
1553: }
1554: }
1555: break;
1556: case DOT:
1557: case COLON:
1558: case LSQUARE:
1559: case HASH:
1560: label_42: while (true) {
1561: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1562: case HASH:
1563: hash();
1564: break;
1565: case DOT:
1566: _class();
1567: break;
1568: case LSQUARE:
1569: attrib();
1570: break;
1571: case COLON:
1572: pseudo();
1573: break;
1574: default:
1575: jj_la1[65] = jj_gen;
1576: jj_consume_token(-1);
1577: throw new ParseException();
1578: }
1579: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1580: case DOT:
1581: case COLON:
1582: case LSQUARE:
1583: case HASH:
1584: ;
1585: break;
1586: default:
1587: jj_la1[66] = jj_gen;
1588: break label_42;
1589: }
1590: }
1591: break;
1592: default:
1593: jj_la1[67] = jj_gen;
1594: jj_consume_token(-1);
1595: throw new ParseException();
1596: }
1597: } catch (Throwable jjte000) {
1598: if (jjtc000) {
1599: jjtree.clearNodeScope(jjtn000);
1600: jjtc000 = false;
1601: } else {
1602: jjtree.popNode();
1603: }
1604: if (jjte000 instanceof RuntimeException) {
1605: {
1606: if (true)
1607: throw (RuntimeException) jjte000;
1608: }
1609: }
1610: if (jjte000 instanceof ParseException) {
1611: {
1612: if (true)
1613: throw (ParseException) jjte000;
1614: }
1615: }
1616: {
1617: if (true)
1618: throw (Error) jjte000;
1619: }
1620: } finally {
1621: if (jjtc000) {
1622: jjtree.closeNodeScope(jjtn000, true);
1623: jjtn000.jjtSetLastToken(getToken(0));
1624: }
1625: }
1626: }
1627:
1628: //
1629: // class
1630: // : '.' IDENT
1631: // ;
1632: //
1633: final public void _class() throws ParseException {
1634: /*@bgen(jjtree) _class */
1635: SimpleNode jjtn000 = new SimpleNode(JJT_CLASS);
1636: boolean jjtc000 = true;
1637: jjtree.openNodeScope(jjtn000);
1638: jjtn000.jjtSetFirstToken(getToken(1));
1639: try {
1640: jj_consume_token(DOT);
1641: jj_consume_token(IDENT);
1642: } finally {
1643: if (jjtc000) {
1644: jjtree.closeNodeScope(jjtn000, true);
1645: jjtn000.jjtSetLastToken(getToken(0));
1646: }
1647: }
1648: }
1649:
1650: //
1651: // element_name
1652: // : IDENT | '*'
1653: // ;
1654: //
1655: final public void elementName() throws ParseException {
1656: /*@bgen(jjtree) elementName */
1657: SimpleNode jjtn000 = new SimpleNode(JJTELEMENTNAME);
1658: boolean jjtc000 = true;
1659: jjtree.openNodeScope(jjtn000);
1660: jjtn000.jjtSetFirstToken(getToken(1));
1661: try {
1662: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1663: case IDENT:
1664: jj_consume_token(IDENT);
1665: break;
1666: case ASTERISK:
1667: jj_consume_token(ASTERISK);
1668: break;
1669: default:
1670: jj_la1[68] = jj_gen;
1671: jj_consume_token(-1);
1672: throw new ParseException();
1673: }
1674: } finally {
1675: if (jjtc000) {
1676: jjtree.closeNodeScope(jjtn000, true);
1677: jjtn000.jjtSetLastToken(getToken(0));
1678: }
1679: }
1680: }
1681:
1682: //
1683: // attrib
1684: // : '[' S* IDENT S* [ [ '=' | INCLUDES | DASHMATCH ] S*
1685: // [ IDENT | STRING ] S* ]? ']'
1686: // ;
1687: //
1688: final public void attrib() throws ParseException {
1689: /*@bgen(jjtree) attrib */
1690: SimpleNode jjtn000 = new SimpleNode(JJTATTRIB);
1691: boolean jjtc000 = true;
1692: jjtree.openNodeScope(jjtn000);
1693: jjtn000.jjtSetFirstToken(getToken(1));
1694: try {
1695: jj_consume_token(LSQUARE);
1696: label_43: while (true) {
1697: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1698: case S:
1699: ;
1700: break;
1701: default:
1702: jj_la1[69] = jj_gen;
1703: break label_43;
1704: }
1705: jj_consume_token(S);
1706: }
1707: jj_consume_token(IDENT);
1708: label_44: while (true) {
1709: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1710: case S:
1711: ;
1712: break;
1713: default:
1714: jj_la1[70] = jj_gen;
1715: break label_44;
1716: }
1717: jj_consume_token(S);
1718: }
1719: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1720: case EQUALS:
1721: case INCLUDES:
1722: case DASHMATCH:
1723: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1724: case EQUALS:
1725: jj_consume_token(EQUALS);
1726: break;
1727: case INCLUDES:
1728: jj_consume_token(INCLUDES);
1729: break;
1730: case DASHMATCH:
1731: jj_consume_token(DASHMATCH);
1732: break;
1733: default:
1734: jj_la1[71] = jj_gen;
1735: jj_consume_token(-1);
1736: throw new ParseException();
1737: }
1738: label_45: while (true) {
1739: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1740: case S:
1741: ;
1742: break;
1743: default:
1744: jj_la1[72] = jj_gen;
1745: break label_45;
1746: }
1747: jj_consume_token(S);
1748: }
1749: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1750: case IDENT:
1751: jj_consume_token(IDENT);
1752: break;
1753: case STRING:
1754: jj_consume_token(STRING);
1755: break;
1756: default:
1757: jj_la1[73] = jj_gen;
1758: jj_consume_token(-1);
1759: throw new ParseException();
1760: }
1761: label_46: while (true) {
1762: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1763: case S:
1764: ;
1765: break;
1766: default:
1767: jj_la1[74] = jj_gen;
1768: break label_46;
1769: }
1770: jj_consume_token(S);
1771: }
1772: break;
1773: default:
1774: jj_la1[75] = jj_gen;
1775: ;
1776: }
1777: jj_consume_token(RSQUARE);
1778: } finally {
1779: if (jjtc000) {
1780: jjtree.closeNodeScope(jjtn000, true);
1781: jjtn000.jjtSetLastToken(getToken(0));
1782: }
1783: }
1784: }
1785:
1786: //
1787: // pseudo
1788: // : ':' [ IDENT | FUNCTION S* IDENT S* ')' ]
1789: // ;
1790: //
1791: final public void pseudo() throws ParseException {
1792: /*@bgen(jjtree) pseudo */
1793: SimpleNode jjtn000 = new SimpleNode(JJTPSEUDO);
1794: boolean jjtc000 = true;
1795: jjtree.openNodeScope(jjtn000);
1796: jjtn000.jjtSetFirstToken(getToken(1));
1797: try {
1798: jj_consume_token(COLON);
1799: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1800: case IDENT:
1801: jj_consume_token(IDENT);
1802: break;
1803: case FUNCTION:
1804: jj_consume_token(FUNCTION);
1805: label_47: while (true) {
1806: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1807: case S:
1808: ;
1809: break;
1810: default:
1811: jj_la1[76] = jj_gen;
1812: break label_47;
1813: }
1814: jj_consume_token(S);
1815: }
1816: jj_consume_token(IDENT);
1817: label_48: while (true) {
1818: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1819: case S:
1820: ;
1821: break;
1822: default:
1823: jj_la1[77] = jj_gen;
1824: break label_48;
1825: }
1826: jj_consume_token(S);
1827: }
1828: jj_consume_token(RROUND);
1829: break;
1830: default:
1831: jj_la1[78] = jj_gen;
1832: jj_consume_token(-1);
1833: throw new ParseException();
1834: }
1835: } finally {
1836: if (jjtc000) {
1837: jjtree.closeNodeScope(jjtn000, true);
1838: jjtn000.jjtSetLastToken(getToken(0));
1839: }
1840: }
1841: }
1842:
1843: final public void hash() throws ParseException {
1844: /*@bgen(jjtree) hash */
1845: SimpleNode jjtn000 = new SimpleNode(JJTHASH);
1846: boolean jjtc000 = true;
1847: jjtree.openNodeScope(jjtn000);
1848: jjtn000.jjtSetFirstToken(getToken(1));
1849: try {
1850: jj_consume_token(HASH);
1851: } finally {
1852: if (jjtc000) {
1853: jjtree.closeNodeScope(jjtn000, true);
1854: jjtn000.jjtSetLastToken(getToken(0));
1855: }
1856: }
1857: }
1858:
1859: final public void styleDeclaration() throws ParseException {
1860: /*@bgen(jjtree) styleDeclaration */
1861: SimpleNode jjtn000 = new SimpleNode(JJTSTYLEDECLARATION);
1862: boolean jjtc000 = true;
1863: jjtree.openNodeScope(jjtn000);
1864: jjtn000.jjtSetFirstToken(getToken(1));
1865: try {
1866: jj_consume_token(LBRACE);
1867: label_49: while (true) {
1868: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1869: case S:
1870: ;
1871: break;
1872: default:
1873: jj_la1[79] = jj_gen;
1874: break label_49;
1875: }
1876: jj_consume_token(S);
1877: }
1878: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1879: case IDENT:
1880: declaration();
1881: break;
1882: default:
1883: jj_la1[80] = jj_gen;
1884: ;
1885: }
1886: label_50: while (true) {
1887: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1888: case SEMICOLON:
1889: ;
1890: break;
1891: default:
1892: jj_la1[81] = jj_gen;
1893: break label_50;
1894: }
1895: jj_consume_token(SEMICOLON);
1896: label_51: while (true) {
1897: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1898: case S:
1899: ;
1900: break;
1901: default:
1902: jj_la1[82] = jj_gen;
1903: break label_51;
1904: }
1905: jj_consume_token(S);
1906: }
1907: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1908: case IDENT:
1909: declaration();
1910: break;
1911: default:
1912: jj_la1[83] = jj_gen;
1913: ;
1914: }
1915: }
1916: jj_consume_token(RBRACE);
1917: } catch (Throwable jjte000) {
1918: if (jjtc000) {
1919: jjtree.clearNodeScope(jjtn000);
1920: jjtc000 = false;
1921: } else {
1922: jjtree.popNode();
1923: }
1924: if (jjte000 instanceof RuntimeException) {
1925: {
1926: if (true)
1927: throw (RuntimeException) jjte000;
1928: }
1929: }
1930: if (jjte000 instanceof ParseException) {
1931: {
1932: if (true)
1933: throw (ParseException) jjte000;
1934: }
1935: }
1936: {
1937: if (true)
1938: throw (Error) jjte000;
1939: }
1940: } finally {
1941: if (jjtc000) {
1942: jjtree.closeNodeScope(jjtn000, true);
1943: jjtn000.jjtSetLastToken(getToken(0));
1944: }
1945: }
1946: }
1947:
1948: //
1949: // declaration
1950: // : property ':' S* expr prio?
1951: // |
1952: // ;
1953: //
1954: final public void declaration() throws ParseException {
1955: /*@bgen(jjtree) declaration */
1956: SimpleNode jjtn000 = new SimpleNode(JJTDECLARATION);
1957: boolean jjtc000 = true;
1958: jjtree.openNodeScope(jjtn000);
1959: jjtn000.jjtSetFirstToken(getToken(1));
1960: try {
1961: try {
1962: property();
1963: jj_consume_token(COLON);
1964: label_52: while (true) {
1965: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1966: case S:
1967: ;
1968: break;
1969: default:
1970: jj_la1[84] = jj_gen;
1971: break label_52;
1972: }
1973: jj_consume_token(S);
1974: }
1975: expr();
1976: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1977: case IMPORTANT_SYM:
1978: prio();
1979: break;
1980: default:
1981: jj_la1[85] = jj_gen;
1982: ;
1983: }
1984: } catch (ParseException e) {
1985: reportError(e);
1986: error_skipdecl(); //recovery
1987:
1988: }
1989: } catch (Throwable jjte000) {
1990: if (jjtc000) {
1991: jjtree.clearNodeScope(jjtn000);
1992: jjtc000 = false;
1993: } else {
1994: jjtree.popNode();
1995: }
1996: if (jjte000 instanceof RuntimeException) {
1997: {
1998: if (true)
1999: throw (RuntimeException) jjte000;
2000: }
2001: }
2002: if (jjte000 instanceof ParseException) {
2003: {
2004: if (true)
2005: throw (ParseException) jjte000;
2006: }
2007: }
2008: {
2009: if (true)
2010: throw (Error) jjte000;
2011: }
2012: } finally {
2013: if (jjtc000) {
2014: jjtree.closeNodeScope(jjtn000, true);
2015: jjtn000.jjtSetLastToken(getToken(0));
2016: }
2017: }
2018: }
2019:
2020: //
2021: // prio
2022: // : IMPORTANT_SYM S*
2023: // ;
2024: //
2025: final public void prio() throws ParseException {
2026: /*@bgen(jjtree) prio */
2027: SimpleNode jjtn000 = new SimpleNode(JJTPRIO);
2028: boolean jjtc000 = true;
2029: jjtree.openNodeScope(jjtn000);
2030: jjtn000.jjtSetFirstToken(getToken(1));
2031: try {
2032: jj_consume_token(IMPORTANT_SYM);
2033: label_53: while (true) {
2034: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2035: case S:
2036: ;
2037: break;
2038: default:
2039: jj_la1[86] = jj_gen;
2040: break label_53;
2041: }
2042: jj_consume_token(S);
2043: }
2044: } finally {
2045: if (jjtc000) {
2046: jjtree.closeNodeScope(jjtn000, true);
2047: jjtn000.jjtSetLastToken(getToken(0));
2048: }
2049: }
2050: }
2051:
2052: //
2053: // expr
2054: // : term [ operator term ]*
2055: // ;
2056: //
2057: // TODO: Deal with the operator
2058: //
2059: final public void expr() throws ParseException {
2060: /*@bgen(jjtree) expr */
2061: SimpleNode jjtn000 = new SimpleNode(JJTEXPR);
2062: boolean jjtc000 = true;
2063: jjtree.openNodeScope(jjtn000);
2064: jjtn000.jjtSetFirstToken(getToken(1));
2065: try {
2066: term();
2067: label_54: while (true) {
2068: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2069: case COMMA:
2070: case SLASH:
2071: case PLUS:
2072: case MINUS:
2073: case HASH:
2074: case STRING:
2075: case URI:
2076: case INHERIT:
2077: case EMS:
2078: case EXS:
2079: case LENGTH_PX:
2080: case LENGTH_CM:
2081: case LENGTH_MM:
2082: case LENGTH_IN:
2083: case LENGTH_PT:
2084: case LENGTH_PC:
2085: case ANGLE_DEG:
2086: case ANGLE_RAD:
2087: case ANGLE_GRAD:
2088: case TIME_MS:
2089: case TIME_S:
2090: case FREQ_HZ:
2091: case FREQ_KHZ:
2092: case DIMEN:
2093: case PERCENTAGE:
2094: case NUMBER:
2095: case RGB:
2096: case FUNCTION:
2097: case IDENT:
2098: case UNICODERANGE:
2099: ;
2100: break;
2101: default:
2102: jj_la1[87] = jj_gen;
2103: break label_54;
2104: }
2105: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2106: case COMMA:
2107: case SLASH:
2108: operator();
2109: break;
2110: default:
2111: jj_la1[88] = jj_gen;
2112: ;
2113: }
2114: term();
2115: }
2116: } catch (Throwable jjte000) {
2117: if (jjtc000) {
2118: jjtree.clearNodeScope(jjtn000);
2119: jjtc000 = false;
2120: } else {
2121: jjtree.popNode();
2122: }
2123: if (jjte000 instanceof RuntimeException) {
2124: {
2125: if (true)
2126: throw (RuntimeException) jjte000;
2127: }
2128: }
2129: if (jjte000 instanceof ParseException) {
2130: {
2131: if (true)
2132: throw (ParseException) jjte000;
2133: }
2134: }
2135: {
2136: if (true)
2137: throw (Error) jjte000;
2138: }
2139: } finally {
2140: if (jjtc000) {
2141: jjtree.closeNodeScope(jjtn000, true);
2142: jjtn000.jjtSetLastToken(getToken(0));
2143: }
2144: }
2145: }
2146:
2147: //
2148: // term
2149: // : unary_operator?
2150: // [ NUMBER S* | PERCENTAGE S* | LENGTH S* | EMS S* | EXS S* | ANGLE S* |
2151: // TIME S* | FREQ S* | function ]
2152: // | STRING S* | IDENT S* | URI S* | RGB S* | UNICODERANGE S* | hexcolor
2153: // ;
2154: //
2155: final public void term() throws ParseException {
2156: /*@bgen(jjtree) term */
2157: SimpleNode jjtn000 = new SimpleNode(JJTTERM);
2158: boolean jjtc000 = true;
2159: jjtree.openNodeScope(jjtn000);
2160: jjtn000.jjtSetFirstToken(getToken(1));
2161: try {
2162: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2163: case PLUS:
2164: case MINUS:
2165: unaryOperator();
2166: break;
2167: default:
2168: jj_la1[89] = jj_gen;
2169: ;
2170: }
2171: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2172: case EMS:
2173: case EXS:
2174: case LENGTH_PX:
2175: case LENGTH_CM:
2176: case LENGTH_MM:
2177: case LENGTH_IN:
2178: case LENGTH_PT:
2179: case LENGTH_PC:
2180: case ANGLE_DEG:
2181: case ANGLE_RAD:
2182: case ANGLE_GRAD:
2183: case TIME_MS:
2184: case TIME_S:
2185: case FREQ_HZ:
2186: case FREQ_KHZ:
2187: case PERCENTAGE:
2188: case NUMBER:
2189: case FUNCTION:
2190: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2191: case NUMBER:
2192: jj_consume_token(NUMBER);
2193: break;
2194: case PERCENTAGE:
2195: jj_consume_token(PERCENTAGE);
2196: break;
2197: case LENGTH_PX:
2198: jj_consume_token(LENGTH_PX);
2199: break;
2200: case LENGTH_CM:
2201: jj_consume_token(LENGTH_CM);
2202: break;
2203: case LENGTH_MM:
2204: jj_consume_token(LENGTH_MM);
2205: break;
2206: case LENGTH_IN:
2207: jj_consume_token(LENGTH_IN);
2208: break;
2209: case LENGTH_PT:
2210: jj_consume_token(LENGTH_PT);
2211: break;
2212: case LENGTH_PC:
2213: jj_consume_token(LENGTH_PC);
2214: break;
2215: case EMS:
2216: jj_consume_token(EMS);
2217: break;
2218: case EXS:
2219: jj_consume_token(EXS);
2220: break;
2221: case ANGLE_DEG:
2222: jj_consume_token(ANGLE_DEG);
2223: break;
2224: case ANGLE_RAD:
2225: jj_consume_token(ANGLE_RAD);
2226: break;
2227: case ANGLE_GRAD:
2228: jj_consume_token(ANGLE_GRAD);
2229: break;
2230: case TIME_MS:
2231: jj_consume_token(TIME_MS);
2232: break;
2233: case TIME_S:
2234: jj_consume_token(TIME_S);
2235: break;
2236: case FREQ_HZ:
2237: jj_consume_token(FREQ_HZ);
2238: break;
2239: case FREQ_KHZ:
2240: jj_consume_token(FREQ_KHZ);
2241: break;
2242: case FUNCTION:
2243: function();
2244: break;
2245: default:
2246: jj_la1[90] = jj_gen;
2247: jj_consume_token(-1);
2248: throw new ParseException();
2249: }
2250: break;
2251: case STRING:
2252: jj_consume_token(STRING);
2253: break;
2254: case IDENT:
2255: jj_consume_token(IDENT);
2256: break;
2257: case URI:
2258: jj_consume_token(URI);
2259: break;
2260: case UNICODERANGE:
2261: jj_consume_token(UNICODERANGE);
2262: break;
2263: case RGB:
2264: rgb();
2265: break;
2266: case HASH:
2267: hexcolor();
2268: break;
2269: case DIMEN:
2270: jj_consume_token(DIMEN);
2271: break;
2272: case INHERIT:
2273: jj_consume_token(INHERIT);
2274: break;
2275: default:
2276: jj_la1[91] = jj_gen;
2277: jj_consume_token(-1);
2278: throw new ParseException();
2279: }
2280: label_55: while (true) {
2281: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2282: case S:
2283: ;
2284: break;
2285: default:
2286: jj_la1[92] = jj_gen;
2287: break label_55;
2288: }
2289: jj_consume_token(S);
2290: }
2291: } catch (Throwable jjte000) {
2292: if (jjtc000) {
2293: jjtree.clearNodeScope(jjtn000);
2294: jjtc000 = false;
2295: } else {
2296: jjtree.popNode();
2297: }
2298: if (jjte000 instanceof RuntimeException) {
2299: {
2300: if (true)
2301: throw (RuntimeException) jjte000;
2302: }
2303: }
2304: if (jjte000 instanceof ParseException) {
2305: {
2306: if (true)
2307: throw (ParseException) jjte000;
2308: }
2309: }
2310: {
2311: if (true)
2312: throw (Error) jjte000;
2313: }
2314: } finally {
2315: if (jjtc000) {
2316: jjtree.closeNodeScope(jjtn000, true);
2317: jjtn000.jjtSetLastToken(getToken(0));
2318: }
2319: }
2320: }
2321:
2322: //
2323: // function
2324: // : FUNCTION S* expr ')' S*
2325: // ;
2326: //
2327: final public void function() throws ParseException {
2328: /*@bgen(jjtree) function */
2329: SimpleNode jjtn000 = new SimpleNode(JJTFUNCTION);
2330: boolean jjtc000 = true;
2331: jjtree.openNodeScope(jjtn000);
2332: jjtn000.jjtSetFirstToken(getToken(1));
2333: try {
2334: jj_consume_token(FUNCTION);
2335: label_56: while (true) {
2336: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2337: case S:
2338: ;
2339: break;
2340: default:
2341: jj_la1[93] = jj_gen;
2342: break label_56;
2343: }
2344: jj_consume_token(S);
2345: }
2346: expr();
2347: jj_consume_token(RROUND);
2348: } catch (Throwable jjte000) {
2349: if (jjtc000) {
2350: jjtree.clearNodeScope(jjtn000);
2351: jjtc000 = false;
2352: } else {
2353: jjtree.popNode();
2354: }
2355: if (jjte000 instanceof RuntimeException) {
2356: {
2357: if (true)
2358: throw (RuntimeException) jjte000;
2359: }
2360: }
2361: if (jjte000 instanceof ParseException) {
2362: {
2363: if (true)
2364: throw (ParseException) jjte000;
2365: }
2366: }
2367: {
2368: if (true)
2369: throw (Error) jjte000;
2370: }
2371: } finally {
2372: if (jjtc000) {
2373: jjtree.closeNodeScope(jjtn000, true);
2374: jjtn000.jjtSetLastToken(getToken(0));
2375: }
2376: }
2377: }
2378:
2379: //
2380: // rgb
2381: // : RGB S* expr ')' S*
2382: // ;
2383: //
2384: final public void rgb() throws ParseException {
2385: /*@bgen(jjtree) rgb */
2386: SimpleNode jjtn000 = new SimpleNode(JJTRGB);
2387: boolean jjtc000 = true;
2388: jjtree.openNodeScope(jjtn000);
2389: jjtn000.jjtSetFirstToken(getToken(1));
2390: try {
2391: jj_consume_token(RGB);
2392: label_57: while (true) {
2393: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2394: case S:
2395: ;
2396: break;
2397: default:
2398: jj_la1[94] = jj_gen;
2399: break label_57;
2400: }
2401: jj_consume_token(S);
2402: }
2403: expr();
2404: jj_consume_token(RROUND);
2405: } catch (Throwable jjte000) {
2406: if (jjtc000) {
2407: jjtree.clearNodeScope(jjtn000);
2408: jjtc000 = false;
2409: } else {
2410: jjtree.popNode();
2411: }
2412: if (jjte000 instanceof RuntimeException) {
2413: {
2414: if (true)
2415: throw (RuntimeException) jjte000;
2416: }
2417: }
2418: if (jjte000 instanceof ParseException) {
2419: {
2420: if (true)
2421: throw (ParseException) jjte000;
2422: }
2423: }
2424: {
2425: if (true)
2426: throw (Error) jjte000;
2427: }
2428: } finally {
2429: if (jjtc000) {
2430: jjtree.closeNodeScope(jjtn000, true);
2431: jjtn000.jjtSetLastToken(getToken(0));
2432: }
2433: }
2434: }
2435:
2436: //
2437: // hexcolor
2438: // : HASH S*
2439: // ;
2440: //
2441: final public void hexcolor() throws ParseException {
2442: /*@bgen(jjtree) hexcolor */
2443: SimpleNode jjtn000 = new SimpleNode(JJTHEXCOLOR);
2444: boolean jjtc000 = true;
2445: jjtree.openNodeScope(jjtn000);
2446: jjtn000.jjtSetFirstToken(getToken(1));
2447: try {
2448: jj_consume_token(HASH);
2449: label_58: while (true) {
2450: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2451: case S:
2452: ;
2453: break;
2454: default:
2455: jj_la1[95] = jj_gen;
2456: break label_58;
2457: }
2458: jj_consume_token(S);
2459: }
2460: } finally {
2461: if (jjtc000) {
2462: jjtree.closeNodeScope(jjtn000, true);
2463: jjtn000.jjtSetLastToken(getToken(0));
2464: }
2465: }
2466: }
2467:
2468: void reportError(ParseException pe) throws ParseException {
2469: /*@bgen(jjtree) reportError */
2470: SimpleNode jjtn000 = new SimpleNode(JJTREPORTERROR);
2471: boolean jjtc000 = true;
2472: jjtree.openNodeScope(jjtn000);
2473: jjtn000.jjtSetFirstToken(getToken(1));
2474: try {
2475: errors.add(pe);/*@bgen(jjtree)*/
2476: } finally {
2477: if (jjtc000) {
2478: jjtree.closeNodeScope(jjtn000, true);
2479: jjtn000.jjtSetLastToken(getToken(0));
2480: }
2481: }
2482: }
2483:
2484: void skipSelector() throws ParseException {
2485: /*@bgen(jjtree) skipSelector */
2486: SimpleNode jjtn000 = new SimpleNode(JJTSKIPSELECTOR);
2487: boolean jjtc000 = true;
2488: jjtree.openNodeScope(jjtn000);
2489: jjtn000.jjtSetFirstToken(getToken(1));
2490: try {
2491: Token t = getToken(1);
2492: while (t.kind != COMMA && t.kind != SEMICOLON
2493: && t.kind != LBRACE && t.kind != EOF) {
2494: getNextToken();
2495: t = getToken(1);
2496: }/*@bgen(jjtree)*/
2497: } finally {
2498: if (jjtc000) {
2499: jjtree.closeNodeScope(jjtn000, true);
2500: jjtn000.jjtSetLastToken(getToken(0));
2501: }
2502: }
2503: }
2504:
2505: String skip() throws ParseException {
2506: /*@bgen(jjtree) skip */
2507: SimpleNode jjtn000 = new SimpleNode(JJTSKIP);
2508: boolean jjtc000 = true;
2509: jjtree.openNodeScope(jjtn000);
2510: jjtn000.jjtSetFirstToken(getToken(1));
2511: try {
2512: StringBuffer sb = new StringBuffer();
2513: int nesting = 0;
2514: Token t = getToken(0);
2515: if (t.image != null) {
2516: sb.append(t.image);
2517: }
2518: do {
2519: t = getNextToken();
2520: if (t.kind == EOF)
2521: break;
2522: sb.append(t.image);
2523: if (t.kind == LBRACE)
2524: nesting++;
2525: else if (t.kind == RBRACE)
2526: nesting--;
2527: else if (t.kind == SEMICOLON && nesting <= 0)
2528: break;
2529: } while ((t.kind != RBRACE) || (nesting > 0));
2530:
2531: return sb.toString();/*@bgen(jjtree)*/
2532: } finally {
2533: if (jjtc000) {
2534: jjtree.closeNodeScope(jjtn000, true);
2535: jjtn000.jjtSetLastToken(getToken(0));
2536: }
2537: }
2538: }
2539:
2540: void error_skipblock() throws ParseException {
2541: /*@bgen(jjtree) error_skipblock */
2542: SimpleNode jjtn000 = new SimpleNode(JJTERROR_SKIPBLOCK);
2543: boolean jjtc000 = true;
2544: jjtree.openNodeScope(jjtn000);
2545: jjtn000.jjtSetFirstToken(getToken(1));
2546: try {
2547: ParseException e = generateParseException();
2548: //System.err.println( "** error_skipblock **\n" + e.toString() );
2549:
2550: Token t;
2551: int nesting = 0;
2552: do {
2553: t = getNextToken();
2554: if (t.kind == LBRACE)
2555: nesting++;
2556: else if (t.kind == RBRACE)
2557: nesting--;
2558: else if (t.kind == EOF)
2559: break;
2560: } while ((t.kind != RBRACE) || (nesting > 0));/*@bgen(jjtree)*/
2561: } finally {
2562: if (jjtc000) {
2563: jjtree.closeNodeScope(jjtn000, true);
2564: jjtn000.jjtSetLastToken(getToken(0));
2565: }
2566: }
2567: }
2568:
2569: void error_skipdecl() throws ParseException {
2570: /*@bgen(jjtree) error_skipdecl */
2571: SimpleNode jjtn000 = new SimpleNode(JJTERROR_SKIPDECL);
2572: boolean jjtc000 = true;
2573: jjtree.openNodeScope(jjtn000);
2574: jjtn000.jjtSetFirstToken(getToken(1));
2575: try {
2576: ParseException e = generateParseException();
2577: //System.err.println("** error_skipdecl **\n" + e.toString());
2578:
2579: Token t = getToken(1);
2580: while (t.kind != SEMICOLON && t.kind != RBRACE
2581: && t.kind != EOF) {
2582: getNextToken();
2583: t = getToken(1);
2584: }/*@bgen(jjtree)*/
2585: } finally {
2586: if (jjtc000) {
2587: jjtree.closeNodeScope(jjtn000, true);
2588: jjtn000.jjtSetLastToken(getToken(0));
2589: }
2590: }
2591: }
2592:
2593: private boolean jj_2_1(int xla) {
2594: jj_la = xla;
2595: jj_lastpos = jj_scanpos = token;
2596: try {
2597: return !jj_3_1();
2598: } catch (LookaheadSuccess ls) {
2599: return true;
2600: } finally {
2601: jj_save(0, xla);
2602: }
2603: }
2604:
2605: private boolean jj_2_2(int xla) {
2606: jj_la = xla;
2607: jj_lastpos = jj_scanpos = token;
2608: try {
2609: return !jj_3_2();
2610: } catch (LookaheadSuccess ls) {
2611: return true;
2612: } finally {
2613: jj_save(1, xla);
2614: }
2615: }
2616:
2617: private boolean jj_3R_74() {
2618: if (jj_scan_token(DOT))
2619: return true;
2620: return false;
2621: }
2622:
2623: private boolean jj_3R_72() {
2624: if (jj_3R_76())
2625: return true;
2626: return false;
2627: }
2628:
2629: private boolean jj_3R_71() {
2630: if (jj_3R_75())
2631: return true;
2632: return false;
2633: }
2634:
2635: private boolean jj_3R_70() {
2636: if (jj_3R_74())
2637: return true;
2638: return false;
2639: }
2640:
2641: private boolean jj_3R_68() {
2642: Token xsp;
2643: xsp = jj_scanpos;
2644: if (jj_3R_69()) {
2645: jj_scanpos = xsp;
2646: if (jj_3R_70()) {
2647: jj_scanpos = xsp;
2648: if (jj_3R_71()) {
2649: jj_scanpos = xsp;
2650: if (jj_3R_72())
2651: return true;
2652: }
2653: }
2654: }
2655: return false;
2656: }
2657:
2658: private boolean jj_3R_69() {
2659: if (jj_3R_73())
2660: return true;
2661: return false;
2662: }
2663:
2664: private boolean jj_3R_65() {
2665: Token xsp;
2666: if (jj_3R_68())
2667: return true;
2668: while (true) {
2669: xsp = jj_scanpos;
2670: if (jj_3R_68()) {
2671: jj_scanpos = xsp;
2672: break;
2673: }
2674: }
2675: return false;
2676: }
2677:
2678: private boolean jj_3R_66() {
2679: Token xsp;
2680: xsp = jj_scanpos;
2681: if (jj_scan_token(13)) {
2682: jj_scanpos = xsp;
2683: if (jj_scan_token(16))
2684: return true;
2685: }
2686: return false;
2687: }
2688:
2689: private boolean jj_3R_75() {
2690: if (jj_scan_token(LSQUARE))
2691: return true;
2692: return false;
2693: }
2694:
2695: private boolean jj_3R_73() {
2696: if (jj_scan_token(HASH))
2697: return true;
2698: return false;
2699: }
2700:
2701: private boolean jj_3R_64() {
2702: if (jj_3R_67())
2703: return true;
2704: return false;
2705: }
2706:
2707: private boolean jj_3R_63() {
2708: if (jj_scan_token(S))
2709: return true;
2710: Token xsp;
2711: xsp = jj_scanpos;
2712: if (jj_3R_66())
2713: jj_scanpos = xsp;
2714: return false;
2715: }
2716:
2717: private boolean jj_3R_62() {
2718: if (jj_scan_token(GT))
2719: return true;
2720: Token xsp;
2721: while (true) {
2722: xsp = jj_scanpos;
2723: if (jj_scan_token(1)) {
2724: jj_scanpos = xsp;
2725: break;
2726: }
2727: }
2728: return false;
2729: }
2730:
2731: private boolean jj_3R_61() {
2732: if (jj_scan_token(PLUS))
2733: return true;
2734: Token xsp;
2735: while (true) {
2736: xsp = jj_scanpos;
2737: if (jj_scan_token(1)) {
2738: jj_scanpos = xsp;
2739: break;
2740: }
2741: }
2742: return false;
2743: }
2744:
2745: private boolean jj_3R_60() {
2746: Token xsp;
2747: xsp = jj_scanpos;
2748: if (jj_3R_64()) {
2749: jj_scanpos = xsp;
2750: if (jj_3R_65())
2751: return true;
2752: }
2753: return false;
2754: }
2755:
2756: private boolean jj_3R_59() {
2757: Token xsp;
2758: xsp = jj_scanpos;
2759: if (jj_3R_61()) {
2760: jj_scanpos = xsp;
2761: if (jj_3R_62()) {
2762: jj_scanpos = xsp;
2763: if (jj_3R_63())
2764: return true;
2765: }
2766: }
2767: return false;
2768: }
2769:
2770: private boolean jj_3_1() {
2771: if (jj_scan_token(IDENT))
2772: return true;
2773: Token xsp;
2774: while (true) {
2775: xsp = jj_scanpos;
2776: if (jj_scan_token(1)) {
2777: jj_scanpos = xsp;
2778: break;
2779: }
2780: }
2781: return false;
2782: }
2783:
2784: private boolean jj_3R_67() {
2785: Token xsp;
2786: xsp = jj_scanpos;
2787: if (jj_scan_token(56)) {
2788: jj_scanpos = xsp;
2789: if (jj_scan_token(11))
2790: return true;
2791: }
2792: return false;
2793: }
2794:
2795: private boolean jj_3R_76() {
2796: if (jj_scan_token(COLON))
2797: return true;
2798: return false;
2799: }
2800:
2801: private boolean jj_3_2() {
2802: if (jj_3R_59())
2803: return true;
2804: if (jj_3R_60())
2805: return true;
2806: return false;
2807: }
2808:
2809: /** Generated Token Manager. */
2810: public CSSParserTokenManager token_source;
2811: /** Current token. */
2812: public Token token;
2813: /** Next token. */
2814: public Token jj_nt;
2815: private int jj_ntk;
2816: private Token jj_scanpos, jj_lastpos;
2817: private int jj_la;
2818: /** Whether we are looking ahead. */
2819: private boolean jj_lookingAhead = false;
2820: private boolean jj_semLA;
2821: private int jj_gen;
2822: final private int[] jj_la1 = new int[96];
2823: static private int[] jj_la1_0;
2824: static private int[] jj_la1_1;
2825: static private int[] jj_la1_2;
2826: static {
2827: jj_la1_init_0();
2828: jj_la1_init_1();
2829: jj_la1_init_2();
2830: }
2831:
2832: private static void jj_la1_init_0() {
2833: jj_la1_0 = new int[] { 0x0, 0x3000002, 0x3000002, 0x10000000,
2834: 0x3000002, 0x3000002, 0xe00a0d00, 0xe00a0d00,
2835: 0x3000002, 0x3000002, 0xf00a0d00, 0x2, 0x2, 0x2,
2836: 0x900000, 0x2, 0x0, 0x2, 0x2, 0x200a0d00, 0x80, 0x2,
2837: 0x200a0d00, 0x2, 0x200a0d00, 0x200a0d00, 0x2, 0x2, 0x2,
2838: 0x2, 0x2, 0x400, 0x400, 0x2, 0x0, 0x200, 0x2, 0x0, 0x2,
2839: 0x2, 0x0, 0x200, 0x2, 0x0, 0x2, 0x2, 0x1080, 0x2, 0x2,
2840: 0x12000, 0x2, 0x12000, 0x12002, 0x6000, 0x2, 0x2, 0x0,
2841: 0x200, 0x2, 0x0, 0x80, 0x2, 0x2, 0xa0500, 0xa0500,
2842: 0xa0500, 0xa0500, 0xa0d00, 0x800, 0x2, 0x2, 0xc008000,
2843: 0x2, 0x100000, 0x2, 0xc008000, 0x2, 0x2, 0x0, 0x2, 0x0,
2844: 0x200, 0x2, 0x0, 0x2, 0x0, 0x2, 0x987080, 0x1080,
2845: 0x6000, 0x0, 0x980000, 0x2, 0x2, 0x2, 0x2, };
2846: }
2847:
2848: private static void jj_la1_init_1() {
2849: jj_la1_1 = new int[] { 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000002,
2850: 0x1000002, 0x0, 0x0, 0x1000003, 0x0, 0x0, 0x0, 0x0,
2851: 0x0, 0x1000000, 0x0, 0x0, 0x1000002, 0x0, 0x0,
2852: 0x1000002, 0x0, 0x1000002, 0x1000002, 0x0, 0x0, 0x0,
2853: 0x0, 0x0, 0x1000000, 0x1000000, 0x0, 0x1000000, 0x0,
2854: 0x0, 0x1000000, 0x0, 0x0, 0x1000000, 0x0, 0x0,
2855: 0x1000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2856: 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x0, 0x1000000, 0x0,
2857: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x1000000,
2858: 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x0, 0x0, 0x0,
2859: 0x1800000, 0x0, 0x1000000, 0x0, 0x0, 0x1000000, 0x0,
2860: 0x4, 0x0, 0x9fffff8, 0x0, 0x0, 0xb7fff0, 0x9fffff8,
2861: 0x0, 0x0, 0x0, 0x0, };
2862: }
2863:
2864: private static void jj_la1_init_2() {
2865: jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2866: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2867: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2868: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2869: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2870: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2871: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2872: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2873: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
2874: }
2875:
2876: final private JJCalls[] jj_2_rtns = new JJCalls[2];
2877: private boolean jj_rescan = false;
2878: private int jj_gc = 0;
2879:
2880: /** Constructor with user supplied CharStream. */
2881: public CSSParser(CharStream stream) {
2882: token_source = new CSSParserTokenManager(stream);
2883: token = new Token();
2884: jj_ntk = -1;
2885: jj_gen = 0;
2886: for (int i = 0; i < 96; i++)
2887: jj_la1[i] = -1;
2888: for (int i = 0; i < jj_2_rtns.length; i++)
2889: jj_2_rtns[i] = new JJCalls();
2890: }
2891:
2892: /** Reinitialise. */
2893: public void ReInit(CharStream stream) {
2894: token_source.ReInit(stream);
2895: token = new Token();
2896: jj_ntk = -1;
2897: jj_lookingAhead = false;
2898: jjtree.reset();
2899: jj_gen = 0;
2900: for (int i = 0; i < 96; i++)
2901: jj_la1[i] = -1;
2902: for (int i = 0; i < jj_2_rtns.length; i++)
2903: jj_2_rtns[i] = new JJCalls();
2904: }
2905:
2906: /** Constructor with generated Token Manager. */
2907: public CSSParser(CSSParserTokenManager tm) {
2908: token_source = tm;
2909: token = new Token();
2910: jj_ntk = -1;
2911: jj_gen = 0;
2912: for (int i = 0; i < 96; i++)
2913: jj_la1[i] = -1;
2914: for (int i = 0; i < jj_2_rtns.length; i++)
2915: jj_2_rtns[i] = new JJCalls();
2916: }
2917:
2918: /** Reinitialise. */
2919: public void ReInit(CSSParserTokenManager tm) {
2920: token_source = tm;
2921: token = new Token();
2922: jj_ntk = -1;
2923: jjtree.reset();
2924: jj_gen = 0;
2925: for (int i = 0; i < 96; i++)
2926: jj_la1[i] = -1;
2927: for (int i = 0; i < jj_2_rtns.length; i++)
2928: jj_2_rtns[i] = new JJCalls();
2929: }
2930:
2931: private Token jj_consume_token(int kind) throws ParseException {
2932: Token oldToken;
2933: if ((oldToken = token).next != null)
2934: token = token.next;
2935: else
2936: token = token.next = token_source.getNextToken();
2937: jj_ntk = -1;
2938: if (token.kind == kind) {
2939: jj_gen++;
2940: if (++jj_gc > 100) {
2941: jj_gc = 0;
2942: for (int i = 0; i < jj_2_rtns.length; i++) {
2943: JJCalls c = jj_2_rtns[i];
2944: while (c != null) {
2945: if (c.gen < jj_gen)
2946: c.first = null;
2947: c = c.next;
2948: }
2949: }
2950: }
2951: return token;
2952: }
2953: token = oldToken;
2954: jj_kind = kind;
2955: throw generateParseException();
2956: }
2957:
2958: static private final class LookaheadSuccess extends java.lang.Error {
2959: }
2960:
2961: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2962:
2963: private boolean jj_scan_token(int kind) {
2964: if (jj_scanpos == jj_lastpos) {
2965: jj_la--;
2966: if (jj_scanpos.next == null) {
2967: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
2968: .getNextToken();
2969: } else {
2970: jj_lastpos = jj_scanpos = jj_scanpos.next;
2971: }
2972: } else {
2973: jj_scanpos = jj_scanpos.next;
2974: }
2975: if (jj_rescan) {
2976: int i = 0;
2977: Token tok = token;
2978: while (tok != null && tok != jj_scanpos) {
2979: i++;
2980: tok = tok.next;
2981: }
2982: if (tok != null)
2983: jj_add_error_token(kind, i);
2984: }
2985: if (jj_scanpos.kind != kind)
2986: return true;
2987: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2988: throw jj_ls;
2989: return false;
2990: }
2991:
2992: /** Get the next Token. */
2993: final public Token getNextToken() {
2994: if (token.next != null)
2995: token = token.next;
2996: else
2997: token = token.next = token_source.getNextToken();
2998: jj_ntk = -1;
2999: jj_gen++;
3000: return token;
3001: }
3002:
3003: /** Get the specific Token. */
3004: final public Token getToken(int index) {
3005: Token t = jj_lookingAhead ? jj_scanpos : token;
3006: for (int i = 0; i < index; i++) {
3007: if (t.next != null)
3008: t = t.next;
3009: else
3010: t = t.next = token_source.getNextToken();
3011: }
3012: return t;
3013: }
3014:
3015: private int jj_ntk() {
3016: if ((jj_nt = token.next) == null)
3017: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3018: else
3019: return (jj_ntk = jj_nt.kind);
3020: }
3021:
3022: private java.util.List jj_expentries = new java.util.ArrayList();
3023: private int[] jj_expentry;
3024: private int jj_kind = -1;
3025: private int[] jj_lasttokens = new int[100];
3026: private int jj_endpos;
3027:
3028: private void jj_add_error_token(int kind, int pos) {
3029: if (pos >= 100)
3030: return;
3031: if (pos == jj_endpos + 1) {
3032: jj_lasttokens[jj_endpos++] = kind;
3033: } else if (jj_endpos != 0) {
3034: jj_expentry = new int[jj_endpos];
3035: for (int i = 0; i < jj_endpos; i++) {
3036: jj_expentry[i] = jj_lasttokens[i];
3037: }
3038: jj_entries_loop: for (java.util.Iterator it = jj_expentries
3039: .iterator(); it.hasNext();) {
3040: int[] oldentry = (int[]) (it.next());
3041: if (oldentry.length == jj_expentry.length) {
3042: for (int i = 0; i < jj_expentry.length; i++) {
3043: if (oldentry[i] != jj_expentry[i]) {
3044: continue jj_entries_loop;
3045: }
3046: }
3047: jj_expentries.add(jj_expentry);
3048: break jj_entries_loop;
3049: }
3050: }
3051: if (pos != 0)
3052: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3053: }
3054: }
3055:
3056: /** Generate ParseException. */
3057: public ParseException generateParseException() {
3058: jj_expentries.clear();
3059: boolean[] la1tokens = new boolean[78];
3060: if (jj_kind >= 0) {
3061: la1tokens[jj_kind] = true;
3062: jj_kind = -1;
3063: }
3064: for (int i = 0; i < 96; i++) {
3065: if (jj_la1[i] == jj_gen) {
3066: for (int j = 0; j < 32; j++) {
3067: if ((jj_la1_0[i] & (1 << j)) != 0) {
3068: la1tokens[j] = true;
3069: }
3070: if ((jj_la1_1[i] & (1 << j)) != 0) {
3071: la1tokens[32 + j] = true;
3072: }
3073: if ((jj_la1_2[i] & (1 << j)) != 0) {
3074: la1tokens[64 + j] = true;
3075: }
3076: }
3077: }
3078: }
3079: for (int i = 0; i < 78; i++) {
3080: if (la1tokens[i]) {
3081: jj_expentry = new int[1];
3082: jj_expentry[0] = i;
3083: jj_expentries.add(jj_expentry);
3084: }
3085: }
3086: jj_endpos = 0;
3087: jj_rescan_token();
3088: jj_add_error_token(0, 0);
3089: int[][] exptokseq = new int[jj_expentries.size()][];
3090: for (int i = 0; i < jj_expentries.size(); i++) {
3091: exptokseq[i] = (int[]) jj_expentries.get(i);
3092: }
3093: return new ParseException(token, exptokseq, tokenImage);
3094: }
3095:
3096: /** Enable tracing. */
3097: final public void enable_tracing() {
3098: }
3099:
3100: /** Disable tracing. */
3101: final public void disable_tracing() {
3102: }
3103:
3104: private void jj_rescan_token() {
3105: jj_rescan = true;
3106: for (int i = 0; i < 2; i++) {
3107: try {
3108: JJCalls p = jj_2_rtns[i];
3109: do {
3110: if (p.gen > jj_gen) {
3111: jj_la = p.arg;
3112: jj_lastpos = jj_scanpos = p.first;
3113: switch (i) {
3114: case 0:
3115: jj_3_1();
3116: break;
3117: case 1:
3118: jj_3_2();
3119: break;
3120: }
3121: }
3122: p = p.next;
3123: } while (p != null);
3124: } catch (LookaheadSuccess ls) {
3125: }
3126: }
3127: jj_rescan = false;
3128: }
3129:
3130: private void jj_save(int index, int xla) {
3131: JJCalls p = jj_2_rtns[index];
3132: while (p.gen > jj_gen) {
3133: if (p.next == null) {
3134: p = p.next = new JJCalls();
3135: break;
3136: }
3137: p = p.next;
3138: }
3139: p.gen = jj_gen + xla - jj_la;
3140: p.first = token;
3141: p.arg = xla;
3142: }
3143:
3144: static final class JJCalls {
3145: int gen;
3146: Token first;
3147: int arg;
3148: JJCalls next;
3149: }
3150:
3151: }
|