0001: // $ANTLR : "preproc.g" -> "PreprocessorLexer.java"$
0002:
0003: package antlr.preprocessor;
0004:
0005: import java.io.InputStream;
0006: import antlr.TokenStreamException;
0007: import antlr.TokenStreamIOException;
0008: import antlr.TokenStreamRecognitionException;
0009: import antlr.CharStreamException;
0010: import antlr.CharStreamIOException;
0011: import antlr.ANTLRException;
0012: import java.io.Reader;
0013: import java.util.Hashtable;
0014: import antlr.CharScanner;
0015: import antlr.InputBuffer;
0016: import antlr.ByteBuffer;
0017: import antlr.CharBuffer;
0018: import antlr.Token;
0019: import antlr.CommonToken;
0020: import antlr.RecognitionException;
0021: import antlr.NoViableAltForCharException;
0022: import antlr.MismatchedCharException;
0023: import antlr.TokenStream;
0024: import antlr.ANTLRHashString;
0025: import antlr.LexerSharedInputState;
0026: import antlr.collections.impl.BitSet;
0027: import antlr.SemanticException;
0028:
0029: public class PreprocessorLexer extends antlr.CharScanner implements
0030: PreprocessorTokenTypes, TokenStream {
0031: public PreprocessorLexer(InputStream in) {
0032: this (new ByteBuffer(in));
0033: }
0034:
0035: public PreprocessorLexer(Reader in) {
0036: this (new CharBuffer(in));
0037: }
0038:
0039: public PreprocessorLexer(InputBuffer ib) {
0040: this (new LexerSharedInputState(ib));
0041: }
0042:
0043: public PreprocessorLexer(LexerSharedInputState state) {
0044: super (state);
0045: caseSensitiveLiterals = true;
0046: setCaseSensitive(true);
0047: literals = new Hashtable();
0048: literals.put(new ANTLRHashString("public", this ), new Integer(
0049: 18));
0050: literals
0051: .put(new ANTLRHashString("class", this ), new Integer(8));
0052: literals.put(new ANTLRHashString("throws", this ), new Integer(
0053: 23));
0054: literals.put(new ANTLRHashString("catch", this ),
0055: new Integer(26));
0056: literals.put(new ANTLRHashString("private", this ), new Integer(
0057: 17));
0058: literals.put(new ANTLRHashString("extends", this ), new Integer(
0059: 10));
0060: literals.put(new ANTLRHashString("protected", this ),
0061: new Integer(16));
0062: literals.put(new ANTLRHashString("returns", this ), new Integer(
0063: 21));
0064: literals.put(new ANTLRHashString("tokens", this ),
0065: new Integer(4));
0066: literals.put(new ANTLRHashString("exception", this ),
0067: new Integer(25));
0068: }
0069:
0070: public Token nextToken() throws TokenStreamException {
0071: Token theRetToken = null;
0072: tryAgain: for (;;) {
0073: Token _token = null;
0074: int _ttype = Token.INVALID_TYPE;
0075: resetText();
0076: try { // for char stream error handling
0077: try { // for lexical error handling
0078: switch (LA(1)) {
0079: case ':': {
0080: mRULE_BLOCK(true);
0081: theRetToken = _returnToken;
0082: break;
0083: }
0084: case '\t':
0085: case '\n':
0086: case '\r':
0087: case ' ': {
0088: mWS(true);
0089: theRetToken = _returnToken;
0090: break;
0091: }
0092: case '/': {
0093: mCOMMENT(true);
0094: theRetToken = _returnToken;
0095: break;
0096: }
0097: case '{': {
0098: mACTION(true);
0099: theRetToken = _returnToken;
0100: break;
0101: }
0102: case '"': {
0103: mSTRING_LITERAL(true);
0104: theRetToken = _returnToken;
0105: break;
0106: }
0107: case '\'': {
0108: mCHAR_LITERAL(true);
0109: theRetToken = _returnToken;
0110: break;
0111: }
0112: case '!': {
0113: mBANG(true);
0114: theRetToken = _returnToken;
0115: break;
0116: }
0117: case ';': {
0118: mSEMI(true);
0119: theRetToken = _returnToken;
0120: break;
0121: }
0122: case ',': {
0123: mCOMMA(true);
0124: theRetToken = _returnToken;
0125: break;
0126: }
0127: case '}': {
0128: mRCURLY(true);
0129: theRetToken = _returnToken;
0130: break;
0131: }
0132: case ')': {
0133: mRPAREN(true);
0134: theRetToken = _returnToken;
0135: break;
0136: }
0137: case 'A':
0138: case 'B':
0139: case 'C':
0140: case 'D':
0141: case 'E':
0142: case 'F':
0143: case 'G':
0144: case 'H':
0145: case 'I':
0146: case 'J':
0147: case 'K':
0148: case 'L':
0149: case 'M':
0150: case 'N':
0151: case 'O':
0152: case 'P':
0153: case 'Q':
0154: case 'R':
0155: case 'S':
0156: case 'T':
0157: case 'U':
0158: case 'V':
0159: case 'W':
0160: case 'X':
0161: case 'Y':
0162: case 'Z':
0163: case '_':
0164: case 'a':
0165: case 'b':
0166: case 'c':
0167: case 'd':
0168: case 'e':
0169: case 'f':
0170: case 'g':
0171: case 'h':
0172: case 'i':
0173: case 'j':
0174: case 'k':
0175: case 'l':
0176: case 'm':
0177: case 'n':
0178: case 'o':
0179: case 'p':
0180: case 'q':
0181: case 'r':
0182: case 's':
0183: case 't':
0184: case 'u':
0185: case 'v':
0186: case 'w':
0187: case 'x':
0188: case 'y':
0189: case 'z': {
0190: mID_OR_KEYWORD(true);
0191: theRetToken = _returnToken;
0192: break;
0193: }
0194: case '=': {
0195: mASSIGN_RHS(true);
0196: theRetToken = _returnToken;
0197: break;
0198: }
0199: case '[': {
0200: mARG_ACTION(true);
0201: theRetToken = _returnToken;
0202: break;
0203: }
0204: default:
0205: if ((LA(1) == '(')
0206: && (_tokenSet_0.member(LA(2)))) {
0207: mSUBRULE_BLOCK(true);
0208: theRetToken = _returnToken;
0209: } else if ((LA(1) == '(') && (true)) {
0210: mLPAREN(true);
0211: theRetToken = _returnToken;
0212: } else {
0213: if (LA(1) == EOF_CHAR) {
0214: uponEOF();
0215: _returnToken = makeToken(Token.EOF_TYPE);
0216: } else {
0217: throw new NoViableAltForCharException(
0218: (char) LA(1), getFilename(),
0219: getLine(), getColumn());
0220: }
0221: }
0222: }
0223: if (_returnToken == null)
0224: continue tryAgain; // found SKIP token
0225: _ttype = _returnToken.getType();
0226: _ttype = testLiteralsTable(_ttype);
0227: _returnToken.setType(_ttype);
0228: return _returnToken;
0229: } catch (RecognitionException e) {
0230: throw new TokenStreamRecognitionException(e);
0231: }
0232: } catch (CharStreamException cse) {
0233: if (cse instanceof CharStreamIOException) {
0234: throw new TokenStreamIOException(
0235: ((CharStreamIOException) cse).io);
0236: } else {
0237: throw new TokenStreamException(cse.getMessage());
0238: }
0239: }
0240: }
0241: }
0242:
0243: public final void mRULE_BLOCK(boolean _createToken)
0244: throws RecognitionException, CharStreamException,
0245: TokenStreamException {
0246: int _ttype;
0247: Token _token = null;
0248: int _begin = text.length();
0249: _ttype = RULE_BLOCK;
0250: int _saveIndex;
0251:
0252: match(':');
0253: {
0254: if ((_tokenSet_1.member(LA(1)))
0255: && (_tokenSet_2.member(LA(2)))) {
0256: _saveIndex = text.length();
0257: mWS(false);
0258: text.setLength(_saveIndex);
0259: } else if ((_tokenSet_2.member(LA(1))) && (true)) {
0260: } else {
0261: throw new NoViableAltForCharException((char) LA(1),
0262: getFilename(), getLine(), getColumn());
0263: }
0264:
0265: }
0266: mALT(false);
0267: {
0268: switch (LA(1)) {
0269: case '\t':
0270: case '\n':
0271: case '\r':
0272: case ' ': {
0273: _saveIndex = text.length();
0274: mWS(false);
0275: text.setLength(_saveIndex);
0276: break;
0277: }
0278: case ';':
0279: case '|': {
0280: break;
0281: }
0282: default: {
0283: throw new NoViableAltForCharException((char) LA(1),
0284: getFilename(), getLine(), getColumn());
0285: }
0286: }
0287: }
0288: {
0289: _loop306: do {
0290: if ((LA(1) == '|')) {
0291: match('|');
0292: {
0293: if ((_tokenSet_1.member(LA(1)))
0294: && (_tokenSet_2.member(LA(2)))) {
0295: _saveIndex = text.length();
0296: mWS(false);
0297: text.setLength(_saveIndex);
0298: } else if ((_tokenSet_2.member(LA(1))) && (true)) {
0299: } else {
0300: throw new NoViableAltForCharException(
0301: (char) LA(1), getFilename(),
0302: getLine(), getColumn());
0303: }
0304:
0305: }
0306: mALT(false);
0307: {
0308: switch (LA(1)) {
0309: case '\t':
0310: case '\n':
0311: case '\r':
0312: case ' ': {
0313: _saveIndex = text.length();
0314: mWS(false);
0315: text.setLength(_saveIndex);
0316: break;
0317: }
0318: case ';':
0319: case '|': {
0320: break;
0321: }
0322: default: {
0323: throw new NoViableAltForCharException(
0324: (char) LA(1), getFilename(),
0325: getLine(), getColumn());
0326: }
0327: }
0328: }
0329: } else {
0330: break _loop306;
0331: }
0332:
0333: } while (true);
0334: }
0335: match(';');
0336: if (_createToken && _token == null && _ttype != Token.SKIP) {
0337: _token = makeToken(_ttype);
0338: _token.setText(new String(text.getBuffer(), _begin, text
0339: .length()
0340: - _begin));
0341: }
0342: _returnToken = _token;
0343: }
0344:
0345: public final void mWS(boolean _createToken)
0346: throws RecognitionException, CharStreamException,
0347: TokenStreamException {
0348: int _ttype;
0349: Token _token = null;
0350: int _begin = text.length();
0351: _ttype = WS;
0352: int _saveIndex;
0353:
0354: {
0355: int _cnt348 = 0;
0356: _loop348: do {
0357: if ((LA(1) == ' ') && (true)) {
0358: match(' ');
0359: } else if ((LA(1) == '\t') && (true)) {
0360: match('\t');
0361: } else if ((LA(1) == '\n' || LA(1) == '\r') && (true)) {
0362: mNEWLINE(false);
0363: } else {
0364: if (_cnt348 >= 1) {
0365: break _loop348;
0366: } else {
0367: throw new NoViableAltForCharException(
0368: (char) LA(1), getFilename(), getLine(),
0369: getColumn());
0370: }
0371: }
0372:
0373: _cnt348++;
0374: } while (true);
0375: }
0376: _ttype = Token.SKIP;
0377: if (_createToken && _token == null && _ttype != Token.SKIP) {
0378: _token = makeToken(_ttype);
0379: _token.setText(new String(text.getBuffer(), _begin, text
0380: .length()
0381: - _begin));
0382: }
0383: _returnToken = _token;
0384: }
0385:
0386: protected final void mALT(boolean _createToken)
0387: throws RecognitionException, CharStreamException,
0388: TokenStreamException {
0389: int _ttype;
0390: Token _token = null;
0391: int _begin = text.length();
0392: _ttype = ALT;
0393: int _saveIndex;
0394:
0395: {
0396: _loop317: do {
0397: if ((_tokenSet_3.member(LA(1)))
0398: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0399: mELEMENT(false);
0400: } else {
0401: break _loop317;
0402: }
0403:
0404: } while (true);
0405: }
0406: if (_createToken && _token == null && _ttype != Token.SKIP) {
0407: _token = makeToken(_ttype);
0408: _token.setText(new String(text.getBuffer(), _begin, text
0409: .length()
0410: - _begin));
0411: }
0412: _returnToken = _token;
0413: }
0414:
0415: public final void mSUBRULE_BLOCK(boolean _createToken)
0416: throws RecognitionException, CharStreamException,
0417: TokenStreamException {
0418: int _ttype;
0419: Token _token = null;
0420: int _begin = text.length();
0421: _ttype = SUBRULE_BLOCK;
0422: int _saveIndex;
0423:
0424: match('(');
0425: {
0426: if ((_tokenSet_1.member(LA(1)))
0427: && (_tokenSet_0.member(LA(2)))) {
0428: mWS(false);
0429: } else if ((_tokenSet_0.member(LA(1))) && (true)) {
0430: } else {
0431: throw new NoViableAltForCharException((char) LA(1),
0432: getFilename(), getLine(), getColumn());
0433: }
0434:
0435: }
0436: mALT(false);
0437: {
0438: _loop312: do {
0439: if ((_tokenSet_4.member(LA(1)))
0440: && (_tokenSet_0.member(LA(2)))) {
0441: {
0442: switch (LA(1)) {
0443: case '\t':
0444: case '\n':
0445: case '\r':
0446: case ' ': {
0447: mWS(false);
0448: break;
0449: }
0450: case '|': {
0451: break;
0452: }
0453: default: {
0454: throw new NoViableAltForCharException(
0455: (char) LA(1), getFilename(),
0456: getLine(), getColumn());
0457: }
0458: }
0459: }
0460: match('|');
0461: {
0462: if ((_tokenSet_1.member(LA(1)))
0463: && (_tokenSet_0.member(LA(2)))) {
0464: mWS(false);
0465: } else if ((_tokenSet_0.member(LA(1))) && (true)) {
0466: } else {
0467: throw new NoViableAltForCharException(
0468: (char) LA(1), getFilename(),
0469: getLine(), getColumn());
0470: }
0471:
0472: }
0473: mALT(false);
0474: } else {
0475: break _loop312;
0476: }
0477:
0478: } while (true);
0479: }
0480: {
0481: switch (LA(1)) {
0482: case '\t':
0483: case '\n':
0484: case '\r':
0485: case ' ': {
0486: mWS(false);
0487: break;
0488: }
0489: case ')': {
0490: break;
0491: }
0492: default: {
0493: throw new NoViableAltForCharException((char) LA(1),
0494: getFilename(), getLine(), getColumn());
0495: }
0496: }
0497: }
0498: match(')');
0499: {
0500: if ((LA(1) == '=') && (LA(2) == '>')) {
0501: match("=>");
0502: } else if ((LA(1) == '*') && (true)) {
0503: match('*');
0504: } else if ((LA(1) == '+') && (true)) {
0505: match('+');
0506: } else if ((LA(1) == '?') && (true)) {
0507: match('?');
0508: } else {
0509: }
0510:
0511: }
0512: if (_createToken && _token == null && _ttype != Token.SKIP) {
0513: _token = makeToken(_ttype);
0514: _token.setText(new String(text.getBuffer(), _begin, text
0515: .length()
0516: - _begin));
0517: }
0518: _returnToken = _token;
0519: }
0520:
0521: protected final void mELEMENT(boolean _createToken)
0522: throws RecognitionException, CharStreamException,
0523: TokenStreamException {
0524: int _ttype;
0525: Token _token = null;
0526: int _begin = text.length();
0527: _ttype = ELEMENT;
0528: int _saveIndex;
0529:
0530: switch (LA(1)) {
0531: case '/': {
0532: mCOMMENT(false);
0533: break;
0534: }
0535: case '{': {
0536: mACTION(false);
0537: break;
0538: }
0539: case '"': {
0540: mSTRING_LITERAL(false);
0541: break;
0542: }
0543: case '\'': {
0544: mCHAR_LITERAL(false);
0545: break;
0546: }
0547: case '(': {
0548: mSUBRULE_BLOCK(false);
0549: break;
0550: }
0551: case '\n':
0552: case '\r': {
0553: mNEWLINE(false);
0554: break;
0555: }
0556: default:
0557: if ((_tokenSet_5.member(LA(1)))) {
0558: {
0559: match(_tokenSet_5);
0560: }
0561: } else {
0562: throw new NoViableAltForCharException((char) LA(1),
0563: getFilename(), getLine(), getColumn());
0564: }
0565: }
0566: if (_createToken && _token == null && _ttype != Token.SKIP) {
0567: _token = makeToken(_ttype);
0568: _token.setText(new String(text.getBuffer(), _begin, text
0569: .length()
0570: - _begin));
0571: }
0572: _returnToken = _token;
0573: }
0574:
0575: public final void mCOMMENT(boolean _createToken)
0576: throws RecognitionException, CharStreamException,
0577: TokenStreamException {
0578: int _ttype;
0579: Token _token = null;
0580: int _begin = text.length();
0581: _ttype = COMMENT;
0582: int _saveIndex;
0583:
0584: {
0585: if ((LA(1) == '/') && (LA(2) == '/')) {
0586: mSL_COMMENT(false);
0587: } else if ((LA(1) == '/') && (LA(2) == '*')) {
0588: mML_COMMENT(false);
0589: } else {
0590: throw new NoViableAltForCharException((char) LA(1),
0591: getFilename(), getLine(), getColumn());
0592: }
0593:
0594: }
0595: _ttype = Token.SKIP;
0596: if (_createToken && _token == null && _ttype != Token.SKIP) {
0597: _token = makeToken(_ttype);
0598: _token.setText(new String(text.getBuffer(), _begin, text
0599: .length()
0600: - _begin));
0601: }
0602: _returnToken = _token;
0603: }
0604:
0605: public final void mACTION(boolean _createToken)
0606: throws RecognitionException, CharStreamException,
0607: TokenStreamException {
0608: int _ttype;
0609: Token _token = null;
0610: int _begin = text.length();
0611: _ttype = ACTION;
0612: int _saveIndex;
0613:
0614: match('{');
0615: {
0616: _loop378: do {
0617: // nongreedy exit test
0618: if ((LA(1) == '}') && (true))
0619: break _loop378;
0620: if ((LA(1) == '\n' || LA(1) == '\r')
0621: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0622: mNEWLINE(false);
0623: } else if ((LA(1) == '{')
0624: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0625: mACTION(false);
0626: } else if ((LA(1) == '\'')
0627: && (_tokenSet_6.member(LA(2)))) {
0628: mCHAR_LITERAL(false);
0629: } else if ((LA(1) == '/')
0630: && (LA(2) == '*' || LA(2) == '/')) {
0631: mCOMMENT(false);
0632: } else if ((LA(1) == '"')
0633: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0634: mSTRING_LITERAL(false);
0635: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
0636: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0637: matchNot(EOF_CHAR);
0638: } else {
0639: break _loop378;
0640: }
0641:
0642: } while (true);
0643: }
0644: match('}');
0645: if (_createToken && _token == null && _ttype != Token.SKIP) {
0646: _token = makeToken(_ttype);
0647: _token.setText(new String(text.getBuffer(), _begin, text
0648: .length()
0649: - _begin));
0650: }
0651: _returnToken = _token;
0652: }
0653:
0654: public final void mSTRING_LITERAL(boolean _createToken)
0655: throws RecognitionException, CharStreamException,
0656: TokenStreamException {
0657: int _ttype;
0658: Token _token = null;
0659: int _begin = text.length();
0660: _ttype = STRING_LITERAL;
0661: int _saveIndex;
0662:
0663: match('"');
0664: {
0665: _loop363: do {
0666: if ((LA(1) == '\\')) {
0667: mESC(false);
0668: } else if ((_tokenSet_7.member(LA(1)))) {
0669: matchNot('"');
0670: } else {
0671: break _loop363;
0672: }
0673:
0674: } while (true);
0675: }
0676: match('"');
0677: if (_createToken && _token == null && _ttype != Token.SKIP) {
0678: _token = makeToken(_ttype);
0679: _token.setText(new String(text.getBuffer(), _begin, text
0680: .length()
0681: - _begin));
0682: }
0683: _returnToken = _token;
0684: }
0685:
0686: public final void mCHAR_LITERAL(boolean _createToken)
0687: throws RecognitionException, CharStreamException,
0688: TokenStreamException {
0689: int _ttype;
0690: Token _token = null;
0691: int _begin = text.length();
0692: _ttype = CHAR_LITERAL;
0693: int _saveIndex;
0694:
0695: match('\'');
0696: {
0697: if ((LA(1) == '\\')) {
0698: mESC(false);
0699: } else if ((_tokenSet_8.member(LA(1)))) {
0700: matchNot('\'');
0701: } else {
0702: throw new NoViableAltForCharException((char) LA(1),
0703: getFilename(), getLine(), getColumn());
0704: }
0705:
0706: }
0707: match('\'');
0708: if (_createToken && _token == null && _ttype != Token.SKIP) {
0709: _token = makeToken(_ttype);
0710: _token.setText(new String(text.getBuffer(), _begin, text
0711: .length()
0712: - _begin));
0713: }
0714: _returnToken = _token;
0715: }
0716:
0717: protected final void mNEWLINE(boolean _createToken)
0718: throws RecognitionException, CharStreamException,
0719: TokenStreamException {
0720: int _ttype;
0721: Token _token = null;
0722: int _begin = text.length();
0723: _ttype = NEWLINE;
0724: int _saveIndex;
0725:
0726: {
0727: if ((LA(1) == '\r') && (LA(2) == '\n')) {
0728: match('\r');
0729: match('\n');
0730: newline();
0731: } else if ((LA(1) == '\r') && (true)) {
0732: match('\r');
0733: newline();
0734: } else if ((LA(1) == '\n')) {
0735: match('\n');
0736: newline();
0737: } else {
0738: throw new NoViableAltForCharException((char) LA(1),
0739: getFilename(), getLine(), getColumn());
0740: }
0741:
0742: }
0743: if (_createToken && _token == null && _ttype != Token.SKIP) {
0744: _token = makeToken(_ttype);
0745: _token.setText(new String(text.getBuffer(), _begin, text
0746: .length()
0747: - _begin));
0748: }
0749: _returnToken = _token;
0750: }
0751:
0752: public final void mBANG(boolean _createToken)
0753: throws RecognitionException, CharStreamException,
0754: TokenStreamException {
0755: int _ttype;
0756: Token _token = null;
0757: int _begin = text.length();
0758: _ttype = BANG;
0759: int _saveIndex;
0760:
0761: match('!');
0762: if (_createToken && _token == null && _ttype != Token.SKIP) {
0763: _token = makeToken(_ttype);
0764: _token.setText(new String(text.getBuffer(), _begin, text
0765: .length()
0766: - _begin));
0767: }
0768: _returnToken = _token;
0769: }
0770:
0771: public final void mSEMI(boolean _createToken)
0772: throws RecognitionException, CharStreamException,
0773: TokenStreamException {
0774: int _ttype;
0775: Token _token = null;
0776: int _begin = text.length();
0777: _ttype = SEMI;
0778: int _saveIndex;
0779:
0780: match(';');
0781: if (_createToken && _token == null && _ttype != Token.SKIP) {
0782: _token = makeToken(_ttype);
0783: _token.setText(new String(text.getBuffer(), _begin, text
0784: .length()
0785: - _begin));
0786: }
0787: _returnToken = _token;
0788: }
0789:
0790: public final void mCOMMA(boolean _createToken)
0791: throws RecognitionException, CharStreamException,
0792: TokenStreamException {
0793: int _ttype;
0794: Token _token = null;
0795: int _begin = text.length();
0796: _ttype = COMMA;
0797: int _saveIndex;
0798:
0799: match(',');
0800: if (_createToken && _token == null && _ttype != Token.SKIP) {
0801: _token = makeToken(_ttype);
0802: _token.setText(new String(text.getBuffer(), _begin, text
0803: .length()
0804: - _begin));
0805: }
0806: _returnToken = _token;
0807: }
0808:
0809: public final void mRCURLY(boolean _createToken)
0810: throws RecognitionException, CharStreamException,
0811: TokenStreamException {
0812: int _ttype;
0813: Token _token = null;
0814: int _begin = text.length();
0815: _ttype = RCURLY;
0816: int _saveIndex;
0817:
0818: match('}');
0819: if (_createToken && _token == null && _ttype != Token.SKIP) {
0820: _token = makeToken(_ttype);
0821: _token.setText(new String(text.getBuffer(), _begin, text
0822: .length()
0823: - _begin));
0824: }
0825: _returnToken = _token;
0826: }
0827:
0828: public final void mLPAREN(boolean _createToken)
0829: throws RecognitionException, CharStreamException,
0830: TokenStreamException {
0831: int _ttype;
0832: Token _token = null;
0833: int _begin = text.length();
0834: _ttype = LPAREN;
0835: int _saveIndex;
0836:
0837: match('(');
0838: if (_createToken && _token == null && _ttype != Token.SKIP) {
0839: _token = makeToken(_ttype);
0840: _token.setText(new String(text.getBuffer(), _begin, text
0841: .length()
0842: - _begin));
0843: }
0844: _returnToken = _token;
0845: }
0846:
0847: public final void mRPAREN(boolean _createToken)
0848: throws RecognitionException, CharStreamException,
0849: TokenStreamException {
0850: int _ttype;
0851: Token _token = null;
0852: int _begin = text.length();
0853: _ttype = RPAREN;
0854: int _saveIndex;
0855:
0856: match(')');
0857: if (_createToken && _token == null && _ttype != Token.SKIP) {
0858: _token = makeToken(_ttype);
0859: _token.setText(new String(text.getBuffer(), _begin, text
0860: .length()
0861: - _begin));
0862: }
0863: _returnToken = _token;
0864: }
0865:
0866: /** This rule picks off keywords in the lexer that need to be
0867: * handled specially. For example, "header" is the start
0868: * of the header action (used to distinguish between options
0869: * block and an action). We do not want "header" to go back
0870: * to the parser as a simple keyword...it must pick off
0871: * the action afterwards.
0872: */
0873: public final void mID_OR_KEYWORD(boolean _createToken)
0874: throws RecognitionException, CharStreamException,
0875: TokenStreamException {
0876: int _ttype;
0877: Token _token = null;
0878: int _begin = text.length();
0879: _ttype = ID_OR_KEYWORD;
0880: int _saveIndex;
0881: Token id = null;
0882:
0883: mID(true);
0884: id = _returnToken;
0885: _ttype = id.getType();
0886: {
0887: if (((_tokenSet_9.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')))
0888: && (id.getText().equals("header"))) {
0889: {
0890: if ((_tokenSet_1.member(LA(1)))
0891: && (_tokenSet_9.member(LA(2)))) {
0892: mWS(false);
0893: } else if ((_tokenSet_9.member(LA(1)))
0894: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
0895: } else {
0896: throw new NoViableAltForCharException(
0897: (char) LA(1), getFilename(), getLine(),
0898: getColumn());
0899: }
0900:
0901: }
0902: {
0903: switch (LA(1)) {
0904: case '"': {
0905: mSTRING_LITERAL(false);
0906: break;
0907: }
0908: case '\t':
0909: case '\n':
0910: case '\r':
0911: case ' ':
0912: case '/':
0913: case '{': {
0914: break;
0915: }
0916: default: {
0917: throw new NoViableAltForCharException(
0918: (char) LA(1), getFilename(), getLine(),
0919: getColumn());
0920: }
0921: }
0922: }
0923: {
0924: _loop331: do {
0925: switch (LA(1)) {
0926: case '\t':
0927: case '\n':
0928: case '\r':
0929: case ' ': {
0930: mWS(false);
0931: break;
0932: }
0933: case '/': {
0934: mCOMMENT(false);
0935: break;
0936: }
0937: default: {
0938: break _loop331;
0939: }
0940: }
0941: } while (true);
0942: }
0943: mACTION(false);
0944: _ttype = HEADER_ACTION;
0945: } else if (((_tokenSet_10.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')))
0946: && (id.getText().equals("tokens"))) {
0947: {
0948: _loop333: do {
0949: switch (LA(1)) {
0950: case '\t':
0951: case '\n':
0952: case '\r':
0953: case ' ': {
0954: mWS(false);
0955: break;
0956: }
0957: case '/': {
0958: mCOMMENT(false);
0959: break;
0960: }
0961: default: {
0962: break _loop333;
0963: }
0964: }
0965: } while (true);
0966: }
0967: mCURLY_BLOCK_SCARF(false);
0968: _ttype = TOKENS_SPEC;
0969: } else if (((_tokenSet_10.member(LA(1))) && (true))
0970: && (id.getText().equals("options"))) {
0971: {
0972: _loop335: do {
0973: switch (LA(1)) {
0974: case '\t':
0975: case '\n':
0976: case '\r':
0977: case ' ': {
0978: mWS(false);
0979: break;
0980: }
0981: case '/': {
0982: mCOMMENT(false);
0983: break;
0984: }
0985: default: {
0986: break _loop335;
0987: }
0988: }
0989: } while (true);
0990: }
0991: match('{');
0992: _ttype = OPTIONS_START;
0993: } else {
0994: }
0995:
0996: }
0997: if (_createToken && _token == null && _ttype != Token.SKIP) {
0998: _token = makeToken(_ttype);
0999: _token.setText(new String(text.getBuffer(), _begin, text
1000: .length()
1001: - _begin));
1002: }
1003: _returnToken = _token;
1004: }
1005:
1006: protected final void mID(boolean _createToken)
1007: throws RecognitionException, CharStreamException,
1008: TokenStreamException {
1009: int _ttype;
1010: Token _token = null;
1011: int _begin = text.length();
1012: _ttype = ID;
1013: int _saveIndex;
1014:
1015: {
1016: switch (LA(1)) {
1017: case 'a':
1018: case 'b':
1019: case 'c':
1020: case 'd':
1021: case 'e':
1022: case 'f':
1023: case 'g':
1024: case 'h':
1025: case 'i':
1026: case 'j':
1027: case 'k':
1028: case 'l':
1029: case 'm':
1030: case 'n':
1031: case 'o':
1032: case 'p':
1033: case 'q':
1034: case 'r':
1035: case 's':
1036: case 't':
1037: case 'u':
1038: case 'v':
1039: case 'w':
1040: case 'x':
1041: case 'y':
1042: case 'z': {
1043: matchRange('a', 'z');
1044: break;
1045: }
1046: case 'A':
1047: case 'B':
1048: case 'C':
1049: case 'D':
1050: case 'E':
1051: case 'F':
1052: case 'G':
1053: case 'H':
1054: case 'I':
1055: case 'J':
1056: case 'K':
1057: case 'L':
1058: case 'M':
1059: case 'N':
1060: case 'O':
1061: case 'P':
1062: case 'Q':
1063: case 'R':
1064: case 'S':
1065: case 'T':
1066: case 'U':
1067: case 'V':
1068: case 'W':
1069: case 'X':
1070: case 'Y':
1071: case 'Z': {
1072: matchRange('A', 'Z');
1073: break;
1074: }
1075: case '_': {
1076: match('_');
1077: break;
1078: }
1079: default: {
1080: throw new NoViableAltForCharException((char) LA(1),
1081: getFilename(), getLine(), getColumn());
1082: }
1083: }
1084: }
1085: {
1086: _loop342: do {
1087: switch (LA(1)) {
1088: case 'a':
1089: case 'b':
1090: case 'c':
1091: case 'd':
1092: case 'e':
1093: case 'f':
1094: case 'g':
1095: case 'h':
1096: case 'i':
1097: case 'j':
1098: case 'k':
1099: case 'l':
1100: case 'm':
1101: case 'n':
1102: case 'o':
1103: case 'p':
1104: case 'q':
1105: case 'r':
1106: case 's':
1107: case 't':
1108: case 'u':
1109: case 'v':
1110: case 'w':
1111: case 'x':
1112: case 'y':
1113: case 'z': {
1114: matchRange('a', 'z');
1115: break;
1116: }
1117: case 'A':
1118: case 'B':
1119: case 'C':
1120: case 'D':
1121: case 'E':
1122: case 'F':
1123: case 'G':
1124: case 'H':
1125: case 'I':
1126: case 'J':
1127: case 'K':
1128: case 'L':
1129: case 'M':
1130: case 'N':
1131: case 'O':
1132: case 'P':
1133: case 'Q':
1134: case 'R':
1135: case 'S':
1136: case 'T':
1137: case 'U':
1138: case 'V':
1139: case 'W':
1140: case 'X':
1141: case 'Y':
1142: case 'Z': {
1143: matchRange('A', 'Z');
1144: break;
1145: }
1146: case '_': {
1147: match('_');
1148: break;
1149: }
1150: case '0':
1151: case '1':
1152: case '2':
1153: case '3':
1154: case '4':
1155: case '5':
1156: case '6':
1157: case '7':
1158: case '8':
1159: case '9': {
1160: matchRange('0', '9');
1161: break;
1162: }
1163: default: {
1164: break _loop342;
1165: }
1166: }
1167: } while (true);
1168: }
1169: _ttype = testLiteralsTable(new String(text.getBuffer(), _begin,
1170: text.length() - _begin), _ttype);
1171: if (_createToken && _token == null && _ttype != Token.SKIP) {
1172: _token = makeToken(_ttype);
1173: _token.setText(new String(text.getBuffer(), _begin, text
1174: .length()
1175: - _begin));
1176: }
1177: _returnToken = _token;
1178: }
1179:
1180: protected final void mCURLY_BLOCK_SCARF(boolean _createToken)
1181: throws RecognitionException, CharStreamException,
1182: TokenStreamException {
1183: int _ttype;
1184: Token _token = null;
1185: int _begin = text.length();
1186: _ttype = CURLY_BLOCK_SCARF;
1187: int _saveIndex;
1188:
1189: match('{');
1190: {
1191: _loop338: do {
1192: // nongreedy exit test
1193: if ((LA(1) == '}') && (true))
1194: break _loop338;
1195: if ((LA(1) == '\n' || LA(1) == '\r')
1196: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1197: mNEWLINE(false);
1198: } else if ((LA(1) == '"')
1199: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1200: mSTRING_LITERAL(false);
1201: } else if ((LA(1) == '\'')
1202: && (_tokenSet_6.member(LA(2)))) {
1203: mCHAR_LITERAL(false);
1204: } else if ((LA(1) == '/')
1205: && (LA(2) == '*' || LA(2) == '/')) {
1206: mCOMMENT(false);
1207: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
1208: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1209: matchNot(EOF_CHAR);
1210: } else {
1211: break _loop338;
1212: }
1213:
1214: } while (true);
1215: }
1216: match('}');
1217: if (_createToken && _token == null && _ttype != Token.SKIP) {
1218: _token = makeToken(_ttype);
1219: _token.setText(new String(text.getBuffer(), _begin, text
1220: .length()
1221: - _begin));
1222: }
1223: _returnToken = _token;
1224: }
1225:
1226: public final void mASSIGN_RHS(boolean _createToken)
1227: throws RecognitionException, CharStreamException,
1228: TokenStreamException {
1229: int _ttype;
1230: Token _token = null;
1231: int _begin = text.length();
1232: _ttype = ASSIGN_RHS;
1233: int _saveIndex;
1234:
1235: _saveIndex = text.length();
1236: match('=');
1237: text.setLength(_saveIndex);
1238: {
1239: _loop345: do {
1240: // nongreedy exit test
1241: if ((LA(1) == ';') && (true))
1242: break _loop345;
1243: if ((LA(1) == '"')
1244: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1245: mSTRING_LITERAL(false);
1246: } else if ((LA(1) == '\'')
1247: && (_tokenSet_6.member(LA(2)))) {
1248: mCHAR_LITERAL(false);
1249: } else if ((LA(1) == '\n' || LA(1) == '\r')
1250: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1251: mNEWLINE(false);
1252: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
1253: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1254: matchNot(EOF_CHAR);
1255: } else {
1256: break _loop345;
1257: }
1258:
1259: } while (true);
1260: }
1261: match(';');
1262: if (_createToken && _token == null && _ttype != Token.SKIP) {
1263: _token = makeToken(_ttype);
1264: _token.setText(new String(text.getBuffer(), _begin, text
1265: .length()
1266: - _begin));
1267: }
1268: _returnToken = _token;
1269: }
1270:
1271: protected final void mSL_COMMENT(boolean _createToken)
1272: throws RecognitionException, CharStreamException,
1273: TokenStreamException {
1274: int _ttype;
1275: Token _token = null;
1276: int _begin = text.length();
1277: _ttype = SL_COMMENT;
1278: int _saveIndex;
1279:
1280: match("//");
1281: {
1282: _loop355: do {
1283: // nongreedy exit test
1284: if ((LA(1) == '\n' || LA(1) == '\r') && (true))
1285: break _loop355;
1286: if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
1287: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1288: matchNot(EOF_CHAR);
1289: } else {
1290: break _loop355;
1291: }
1292:
1293: } while (true);
1294: }
1295: mNEWLINE(false);
1296: if (_createToken && _token == null && _ttype != Token.SKIP) {
1297: _token = makeToken(_ttype);
1298: _token.setText(new String(text.getBuffer(), _begin, text
1299: .length()
1300: - _begin));
1301: }
1302: _returnToken = _token;
1303: }
1304:
1305: protected final void mML_COMMENT(boolean _createToken)
1306: throws RecognitionException, CharStreamException,
1307: TokenStreamException {
1308: int _ttype;
1309: Token _token = null;
1310: int _begin = text.length();
1311: _ttype = ML_COMMENT;
1312: int _saveIndex;
1313:
1314: match("/*");
1315: {
1316: _loop358: do {
1317: // nongreedy exit test
1318: if ((LA(1) == '*') && (LA(2) == '/'))
1319: break _loop358;
1320: if ((LA(1) == '\n' || LA(1) == '\r')
1321: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1322: mNEWLINE(false);
1323: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
1324: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1325: matchNot(EOF_CHAR);
1326: } else {
1327: break _loop358;
1328: }
1329:
1330: } while (true);
1331: }
1332: match("*/");
1333: if (_createToken && _token == null && _ttype != Token.SKIP) {
1334: _token = makeToken(_ttype);
1335: _token.setText(new String(text.getBuffer(), _begin, text
1336: .length()
1337: - _begin));
1338: }
1339: _returnToken = _token;
1340: }
1341:
1342: protected final void mESC(boolean _createToken)
1343: throws RecognitionException, CharStreamException,
1344: TokenStreamException {
1345: int _ttype;
1346: Token _token = null;
1347: int _begin = text.length();
1348: _ttype = ESC;
1349: int _saveIndex;
1350:
1351: match('\\');
1352: {
1353: switch (LA(1)) {
1354: case 'n': {
1355: match('n');
1356: break;
1357: }
1358: case 'r': {
1359: match('r');
1360: break;
1361: }
1362: case 't': {
1363: match('t');
1364: break;
1365: }
1366: case 'b': {
1367: match('b');
1368: break;
1369: }
1370: case 'f': {
1371: match('f');
1372: break;
1373: }
1374: case 'w': {
1375: match('w');
1376: break;
1377: }
1378: case 'a': {
1379: match('a');
1380: break;
1381: }
1382: case '"': {
1383: match('"');
1384: break;
1385: }
1386: case '\'': {
1387: match('\'');
1388: break;
1389: }
1390: case '\\': {
1391: match('\\');
1392: break;
1393: }
1394: case '0':
1395: case '1':
1396: case '2':
1397: case '3': {
1398: {
1399: matchRange('0', '3');
1400: }
1401: {
1402: if (((LA(1) >= '0' && LA(1) <= '9'))
1403: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1404: mDIGIT(false);
1405: {
1406: if (((LA(1) >= '0' && LA(1) <= '9'))
1407: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1408: mDIGIT(false);
1409: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
1410: } else {
1411: throw new NoViableAltForCharException(
1412: (char) LA(1), getFilename(),
1413: getLine(), getColumn());
1414: }
1415:
1416: }
1417: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
1418: } else {
1419: throw new NoViableAltForCharException(
1420: (char) LA(1), getFilename(), getLine(),
1421: getColumn());
1422: }
1423:
1424: }
1425: break;
1426: }
1427: case '4':
1428: case '5':
1429: case '6':
1430: case '7': {
1431: {
1432: matchRange('4', '7');
1433: }
1434: {
1435: if (((LA(1) >= '0' && LA(1) <= '9'))
1436: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1437: mDIGIT(false);
1438: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
1439: } else {
1440: throw new NoViableAltForCharException(
1441: (char) LA(1), getFilename(), getLine(),
1442: getColumn());
1443: }
1444:
1445: }
1446: break;
1447: }
1448: case 'u': {
1449: match('u');
1450: mXDIGIT(false);
1451: mXDIGIT(false);
1452: mXDIGIT(false);
1453: mXDIGIT(false);
1454: break;
1455: }
1456: default: {
1457: throw new NoViableAltForCharException((char) LA(1),
1458: getFilename(), getLine(), getColumn());
1459: }
1460: }
1461: }
1462: if (_createToken && _token == null && _ttype != Token.SKIP) {
1463: _token = makeToken(_ttype);
1464: _token.setText(new String(text.getBuffer(), _begin, text
1465: .length()
1466: - _begin));
1467: }
1468: _returnToken = _token;
1469: }
1470:
1471: protected final void mDIGIT(boolean _createToken)
1472: throws RecognitionException, CharStreamException,
1473: TokenStreamException {
1474: int _ttype;
1475: Token _token = null;
1476: int _begin = text.length();
1477: _ttype = DIGIT;
1478: int _saveIndex;
1479:
1480: matchRange('0', '9');
1481: if (_createToken && _token == null && _ttype != Token.SKIP) {
1482: _token = makeToken(_ttype);
1483: _token.setText(new String(text.getBuffer(), _begin, text
1484: .length()
1485: - _begin));
1486: }
1487: _returnToken = _token;
1488: }
1489:
1490: protected final void mXDIGIT(boolean _createToken)
1491: throws RecognitionException, CharStreamException,
1492: TokenStreamException {
1493: int _ttype;
1494: Token _token = null;
1495: int _begin = text.length();
1496: _ttype = XDIGIT;
1497: int _saveIndex;
1498:
1499: switch (LA(1)) {
1500: case '0':
1501: case '1':
1502: case '2':
1503: case '3':
1504: case '4':
1505: case '5':
1506: case '6':
1507: case '7':
1508: case '8':
1509: case '9': {
1510: matchRange('0', '9');
1511: break;
1512: }
1513: case 'a':
1514: case 'b':
1515: case 'c':
1516: case 'd':
1517: case 'e':
1518: case 'f': {
1519: matchRange('a', 'f');
1520: break;
1521: }
1522: case 'A':
1523: case 'B':
1524: case 'C':
1525: case 'D':
1526: case 'E':
1527: case 'F': {
1528: matchRange('A', 'F');
1529: break;
1530: }
1531: default: {
1532: throw new NoViableAltForCharException((char) LA(1),
1533: getFilename(), getLine(), getColumn());
1534: }
1535: }
1536: if (_createToken && _token == null && _ttype != Token.SKIP) {
1537: _token = makeToken(_ttype);
1538: _token.setText(new String(text.getBuffer(), _begin, text
1539: .length()
1540: - _begin));
1541: }
1542: _returnToken = _token;
1543: }
1544:
1545: public final void mARG_ACTION(boolean _createToken)
1546: throws RecognitionException, CharStreamException,
1547: TokenStreamException {
1548: int _ttype;
1549: Token _token = null;
1550: int _begin = text.length();
1551: _ttype = ARG_ACTION;
1552: int _saveIndex;
1553:
1554: match('[');
1555: {
1556: _loop375: do {
1557: // nongreedy exit test
1558: if ((LA(1) == ']') && (true))
1559: break _loop375;
1560: if ((LA(1) == '[')
1561: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1562: mARG_ACTION(false);
1563: } else if ((LA(1) == '\n' || LA(1) == '\r')
1564: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1565: mNEWLINE(false);
1566: } else if ((LA(1) == '\'')
1567: && (_tokenSet_6.member(LA(2)))) {
1568: mCHAR_LITERAL(false);
1569: } else if ((LA(1) == '"')
1570: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1571: mSTRING_LITERAL(false);
1572: } else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff'))
1573: && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
1574: matchNot(EOF_CHAR);
1575: } else {
1576: break _loop375;
1577: }
1578:
1579: } while (true);
1580: }
1581: match(']');
1582: if (_createToken && _token == null && _ttype != Token.SKIP) {
1583: _token = makeToken(_ttype);
1584: _token.setText(new String(text.getBuffer(), _begin, text
1585: .length()
1586: - _begin));
1587: }
1588: _returnToken = _token;
1589: }
1590:
1591: private static final long[] mk_tokenSet_0() {
1592: long[] data = new long[8];
1593: data[0] = -576460752303423496L;
1594: for (int i = 1; i <= 3; i++) {
1595: data[i] = -1L;
1596: }
1597: return data;
1598: }
1599:
1600: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1601:
1602: private static final long[] mk_tokenSet_1() {
1603: long[] data = { 4294977024L, 0L, 0L, 0L, 0L };
1604: return data;
1605: }
1606:
1607: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1608:
1609: private static final long[] mk_tokenSet_2() {
1610: long[] data = new long[8];
1611: data[0] = -2199023255560L;
1612: for (int i = 1; i <= 3; i++) {
1613: data[i] = -1L;
1614: }
1615: return data;
1616: }
1617:
1618: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1619:
1620: private static final long[] mk_tokenSet_3() {
1621: long[] data = new long[8];
1622: data[0] = -576462951326679048L;
1623: for (int i = 1; i <= 3; i++) {
1624: data[i] = -1L;
1625: }
1626: return data;
1627: }
1628:
1629: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1630:
1631: private static final long[] mk_tokenSet_4() {
1632: long[] data = { 4294977024L, 1152921504606846976L, 0L, 0L, 0L };
1633: return data;
1634: }
1635:
1636: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1637:
1638: private static final long[] mk_tokenSet_5() {
1639: long[] data = new long[8];
1640: data[0] = -576605355262354440L;
1641: data[1] = -576460752303423489L;
1642: for (int i = 2; i <= 3; i++) {
1643: data[i] = -1L;
1644: }
1645: return data;
1646: }
1647:
1648: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1649:
1650: private static final long[] mk_tokenSet_6() {
1651: long[] data = new long[8];
1652: data[0] = -549755813896L;
1653: for (int i = 1; i <= 3; i++) {
1654: data[i] = -1L;
1655: }
1656: return data;
1657: }
1658:
1659: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1660:
1661: private static final long[] mk_tokenSet_7() {
1662: long[] data = new long[8];
1663: data[0] = -17179869192L;
1664: data[1] = -268435457L;
1665: for (int i = 2; i <= 3; i++) {
1666: data[i] = -1L;
1667: }
1668: return data;
1669: }
1670:
1671: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
1672:
1673: private static final long[] mk_tokenSet_8() {
1674: long[] data = new long[8];
1675: data[0] = -549755813896L;
1676: data[1] = -268435457L;
1677: for (int i = 2; i <= 3; i++) {
1678: data[i] = -1L;
1679: }
1680: return data;
1681: }
1682:
1683: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
1684:
1685: private static final long[] mk_tokenSet_9() {
1686: long[] data = { 140758963201536L, 576460752303423488L, 0L, 0L,
1687: 0L };
1688: return data;
1689: }
1690:
1691: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
1692:
1693: private static final long[] mk_tokenSet_10() {
1694: long[] data = { 140741783332352L, 576460752303423488L, 0L, 0L,
1695: 0L };
1696: return data;
1697: }
1698:
1699: public static final BitSet _tokenSet_10 = new BitSet(
1700: mk_tokenSet_10());
1701:
1702: }
|