0001: // $ANTLR 2.7.2: "src/com/hp/hpl/jena/n3/n3.g" -> "N3AntlrLexer.java"$
0002:
0003: package com.hp.hpl.jena.n3;
0004:
0005: import antlr.TokenStreamRecognitionException;
0006:
0007: import java.io.InputStream;
0008: import antlr.TokenStreamException;
0009: import antlr.TokenStreamIOException;
0010: import antlr.CharStreamException;
0011: import antlr.CharStreamIOException;
0012: import java.io.Reader;
0013: import java.util.Hashtable;
0014: import antlr.InputBuffer;
0015: import antlr.ByteBuffer;
0016: import antlr.CharBuffer;
0017: import antlr.Token;
0018: import antlr.RecognitionException;
0019: import antlr.NoViableAltForCharException;
0020: import antlr.TokenStream;
0021: import antlr.LexerSharedInputState;
0022: import antlr.collections.impl.BitSet;
0023:
0024: public class N3AntlrLexer extends antlr.CharScanner implements
0025: N3AntlrParserTokenTypes, TokenStream {
0026: public N3AntlrLexer(InputStream in) {
0027: this (new ByteBuffer(in));
0028: }
0029:
0030: public N3AntlrLexer(Reader in) {
0031: this (new CharBuffer(in));
0032: }
0033:
0034: public N3AntlrLexer(InputBuffer ib) {
0035: this (new LexerSharedInputState(ib));
0036: }
0037:
0038: public N3AntlrLexer(LexerSharedInputState state) {
0039: super (state);
0040: caseSensitiveLiterals = true;
0041: setCaseSensitive(true);
0042: literals = new Hashtable();
0043: }
0044:
0045: public Token nextToken() throws TokenStreamException {
0046: Token theRetToken = null;
0047: tryAgain: for (;;) {
0048: Token _token = null;
0049: int _ttype = Token.INVALID_TYPE;
0050: resetText();
0051: try { // for char stream error handling
0052: try { // for lexical error handling
0053: switch (LA(1)) {
0054: case '?': {
0055: mUVAR(true);
0056: theRetToken = _returnToken;
0057: break;
0058: }
0059: case '"':
0060: case '\'': {
0061: mSTRING(true);
0062: theRetToken = _returnToken;
0063: break;
0064: }
0065: case '.': {
0066: mSEP_OR_PATH(true);
0067: theRetToken = _returnToken;
0068: break;
0069: }
0070: case '(': {
0071: mLPAREN(true);
0072: theRetToken = _returnToken;
0073: break;
0074: }
0075: case ')': {
0076: mRPAREN(true);
0077: theRetToken = _returnToken;
0078: break;
0079: }
0080: case '[': {
0081: mLBRACK(true);
0082: theRetToken = _returnToken;
0083: break;
0084: }
0085: case ']': {
0086: mRBRACK(true);
0087: theRetToken = _returnToken;
0088: break;
0089: }
0090: case '{': {
0091: mLCURLY(true);
0092: theRetToken = _returnToken;
0093: break;
0094: }
0095: case '}': {
0096: mRCURLY(true);
0097: theRetToken = _returnToken;
0098: break;
0099: }
0100: case ';': {
0101: mSEMI(true);
0102: theRetToken = _returnToken;
0103: break;
0104: }
0105: case ',': {
0106: mCOMMA(true);
0107: theRetToken = _returnToken;
0108: break;
0109: }
0110: case '!': {
0111: mPATH(true);
0112: theRetToken = _returnToken;
0113: break;
0114: }
0115: case '#': {
0116: mSL_COMMENT(true);
0117: theRetToken = _returnToken;
0118: break;
0119: }
0120: case '\t':
0121: case '\n':
0122: case '\u000c':
0123: case '\r':
0124: case ' ': {
0125: mWS(true);
0126: theRetToken = _returnToken;
0127: break;
0128: }
0129: default:
0130: if ((LA(1) == '<')
0131: && (_tokenSet_0.member(LA(2)))) {
0132: mURI_OR_IMPLIES(true);
0133: theRetToken = _returnToken;
0134: } else if ((LA(1) == '@')
0135: && (_tokenSet_1.member(LA(2)))) {
0136: mAT_WORD(true);
0137: theRetToken = _returnToken;
0138: } else if ((LA(1) == '^') && (LA(2) == '^')) {
0139: mDATATYPE(true);
0140: theRetToken = _returnToken;
0141: } else if ((LA(1) == '=') && (LA(2) == '>')) {
0142: mARROW_R(true);
0143: theRetToken = _returnToken;
0144: } else if ((LA(1) == '>') && (LA(2) == '-')) {
0145: mARROW_PATH_L(true);
0146: theRetToken = _returnToken;
0147: } else if ((LA(1) == '-') && (LA(2) == '>')) {
0148: mARROW_PATH_R(true);
0149: theRetToken = _returnToken;
0150: } else if ((_tokenSet_2.member(LA(1))) && (true)) {
0151: mTHING(true);
0152: theRetToken = _returnToken;
0153: } else if ((LA(1) == '<') && (true)) {
0154: mLANGLE(true);
0155: theRetToken = _returnToken;
0156: } else if ((LA(1) == '>') && (true)) {
0157: mRANGLE(true);
0158: theRetToken = _returnToken;
0159: } else if ((LA(1) == '@') && (true)) {
0160: mAT(true);
0161: theRetToken = _returnToken;
0162: } else if ((LA(1) == '^') && (true)) {
0163: mRPATH(true);
0164: theRetToken = _returnToken;
0165: } else if ((LA(1) == '=') && (true)) {
0166: mEQUAL(true);
0167: theRetToken = _returnToken;
0168: } else {
0169: if (LA(1) == EOF_CHAR) {
0170: uponEOF();
0171: _returnToken = makeToken(Token.EOF_TYPE);
0172: } else {
0173: throw new NoViableAltForCharException(
0174: (char) LA(1), getFilename(),
0175: getLine(), getColumn());
0176: }
0177: }
0178: }
0179: if (_returnToken == null)
0180: continue tryAgain; // found SKIP token
0181: _ttype = _returnToken.getType();
0182: _ttype = testLiteralsTable(_ttype);
0183: _returnToken.setType(_ttype);
0184: return _returnToken;
0185: } catch (RecognitionException e) {
0186: throw new TokenStreamRecognitionException(e);
0187: }
0188: } catch (CharStreamException cse) {
0189: if (cse instanceof CharStreamIOException) {
0190: throw new TokenStreamIOException(
0191: ((CharStreamIOException) cse).io);
0192: } else {
0193: throw new TokenStreamException(cse.getMessage());
0194: }
0195: }
0196: }
0197: }
0198:
0199: public final void mTHING(boolean _createToken)
0200: throws RecognitionException, CharStreamException,
0201: TokenStreamException {
0202: int _ttype;
0203: Token _token = null;
0204: int _begin = text.length();
0205: _ttype = THING;
0206: int _saveIndex;
0207:
0208: boolean synPredMatched61 = false;
0209: if (((LA(1) == 'h') && (LA(2) == 'a') && (LA(3) == 's'))) {
0210: int _m61 = mark();
0211: synPredMatched61 = true;
0212: inputState.guessing++;
0213: try {
0214: {
0215: match("has");
0216: mNON_ANC(false);
0217: }
0218: } catch (RecognitionException pe) {
0219: synPredMatched61 = false;
0220: }
0221: rewind(_m61);
0222: inputState.guessing--;
0223: }
0224: if (synPredMatched61) {
0225: match("has");
0226: if (inputState.guessing == 0) {
0227: _ttype = KW_HAS;
0228: }
0229: } else {
0230: boolean synPredMatched65 = false;
0231: if (((LA(1) == 't') && (LA(2) == 'h') && (LA(3) == 'i'))) {
0232: int _m65 = mark();
0233: synPredMatched65 = true;
0234: inputState.guessing++;
0235: try {
0236: {
0237: match("this");
0238: mNON_ANC(false);
0239: }
0240: } catch (RecognitionException pe) {
0241: synPredMatched65 = false;
0242: }
0243: rewind(_m65);
0244: inputState.guessing--;
0245: }
0246: if (synPredMatched65) {
0247: match("this");
0248: if (inputState.guessing == 0) {
0249: _ttype = KW_THIS;
0250: }
0251: } else {
0252: boolean synPredMatched57 = false;
0253: if (((LA(1) == ':') && (LA(2) == '-') && (true))) {
0254: int _m57 = mark();
0255: synPredMatched57 = true;
0256: inputState.guessing++;
0257: try {
0258: {
0259: mCOLON(false);
0260: match('-');
0261: }
0262: } catch (RecognitionException pe) {
0263: synPredMatched57 = false;
0264: }
0265: rewind(_m57);
0266: inputState.guessing--;
0267: }
0268: if (synPredMatched57) {
0269: match(":-");
0270: if (inputState.guessing == 0) {
0271: _ttype = NAME_OP;
0272: }
0273: } else {
0274: boolean synPredMatched63 = false;
0275: if (((LA(1) == 'o') && (LA(2) == 'f') && (true))) {
0276: int _m63 = mark();
0277: synPredMatched63 = true;
0278: inputState.guessing++;
0279: try {
0280: {
0281: match("of");
0282: mNON_ANC(false);
0283: }
0284: } catch (RecognitionException pe) {
0285: synPredMatched63 = false;
0286: }
0287: rewind(_m63);
0288: inputState.guessing--;
0289: }
0290: if (synPredMatched63) {
0291: match("of");
0292: if (inputState.guessing == 0) {
0293: _ttype = KW_OF;
0294: }
0295: } else {
0296: boolean synPredMatched69 = false;
0297: if (((LA(1) == 'i') && (LA(2) == 's') && (true))) {
0298: int _m69 = mark();
0299: synPredMatched69 = true;
0300: inputState.guessing++;
0301: try {
0302: {
0303: match("is");
0304: mNON_ANC(false);
0305: }
0306: } catch (RecognitionException pe) {
0307: synPredMatched69 = false;
0308: }
0309: rewind(_m69);
0310: inputState.guessing--;
0311: }
0312: if (synPredMatched69) {
0313: match("is");
0314: if (inputState.guessing == 0) {
0315: _ttype = KW_IS;
0316: }
0317: } else {
0318: boolean synPredMatched49 = false;
0319: if (((_tokenSet_3.member(LA(1))) && (true) && (true))) {
0320: int _m49 = mark();
0321: synPredMatched49 = true;
0322: inputState.guessing++;
0323: try {
0324: {
0325: mNSNAME(false);
0326: mCOLON(false);
0327: mLNAME(false);
0328: }
0329: } catch (RecognitionException pe) {
0330: synPredMatched49 = false;
0331: }
0332: rewind(_m49);
0333: inputState.guessing--;
0334: }
0335: if (synPredMatched49) {
0336: mNSNAME(false);
0337: mCOLON(false);
0338: mLNAME(false);
0339: if (inputState.guessing == 0) {
0340: _ttype = QNAME;
0341: }
0342: } else {
0343: boolean synPredMatched51 = false;
0344: if (((LA(1) == ':') && (true) && (true))) {
0345: int _m51 = mark();
0346: synPredMatched51 = true;
0347: inputState.guessing++;
0348: try {
0349: {
0350: mCOLON(false);
0351: mLNAME(false);
0352: }
0353: } catch (RecognitionException pe) {
0354: synPredMatched51 = false;
0355: }
0356: rewind(_m51);
0357: inputState.guessing--;
0358: }
0359: if (synPredMatched51) {
0360: mCOLON(false);
0361: mLNAME(false);
0362: if (inputState.guessing == 0) {
0363: _ttype = QNAME;
0364: }
0365: } else {
0366: boolean synPredMatched53 = false;
0367: if (((_tokenSet_3.member(LA(1))) && (true) && (true))) {
0368: int _m53 = mark();
0369: synPredMatched53 = true;
0370: inputState.guessing++;
0371: try {
0372: {
0373: mNSNAME(false);
0374: mCOLON(false);
0375: }
0376: } catch (RecognitionException pe) {
0377: synPredMatched53 = false;
0378: }
0379: rewind(_m53);
0380: inputState.guessing--;
0381: }
0382: if (synPredMatched53) {
0383: mNSNAME(false);
0384: mCOLON(false);
0385: if (inputState.guessing == 0) {
0386: _ttype = QNAME;
0387: }
0388: } else {
0389: boolean synPredMatched55 = false;
0390: if (((LA(1) == ':') && (true) && (true))) {
0391: int _m55 = mark();
0392: synPredMatched55 = true;
0393: inputState.guessing++;
0394: try {
0395: {
0396: mCOLON(false);
0397: }
0398: } catch (RecognitionException pe) {
0399: synPredMatched55 = false;
0400: }
0401: rewind(_m55);
0402: inputState.guessing--;
0403: }
0404: if (synPredMatched55) {
0405: mCOLON(false);
0406: if (inputState.guessing == 0) {
0407: _ttype = QNAME;
0408: }
0409: } else {
0410: boolean synPredMatched59 = false;
0411: if (((_tokenSet_4
0412: .member(LA(1))) && (true) && (true))) {
0413: int _m59 = mark();
0414: synPredMatched59 = true;
0415: inputState.guessing++;
0416: try {
0417: {
0418: mNUMBER(false);
0419: }
0420: } catch (RecognitionException pe) {
0421: synPredMatched59 = false;
0422: }
0423: rewind(_m59);
0424: inputState.guessing--;
0425: }
0426: if (synPredMatched59) {
0427: mNUMBER(false);
0428: if (inputState.guessing == 0) {
0429: _ttype = NUMBER;
0430: }
0431: } else {
0432: boolean synPredMatched67 = false;
0433: if (((LA(1) == 'a') && (true) && (true))) {
0434: int _m67 = mark();
0435: synPredMatched67 = true;
0436: inputState.guessing++;
0437: try {
0438: {
0439: match("a");
0440: mNON_ANC(false);
0441: }
0442: } catch (RecognitionException pe) {
0443: synPredMatched67 = false;
0444: }
0445: rewind(_m67);
0446: inputState.guessing--;
0447: }
0448: if (synPredMatched67) {
0449: match("a");
0450: if (inputState.guessing == 0) {
0451: _ttype = KW_A;
0452: }
0453: } else {
0454: throw new NoViableAltForCharException(
0455: (char) LA(1),
0456: getFilename(),
0457: getLine(),
0458: getColumn());
0459: }
0460: }
0461: }
0462: }
0463: }
0464: }
0465: }
0466: }
0467: }
0468: }
0469: }
0470: if (_createToken && _token == null && _ttype != Token.SKIP) {
0471: _token = makeToken(_ttype);
0472: _token.setText(new String(text.getBuffer(), _begin, text
0473: .length()
0474: - _begin));
0475: }
0476: _returnToken = _token;
0477: }
0478:
0479: protected final void mNSNAME(boolean _createToken)
0480: throws RecognitionException, CharStreamException,
0481: TokenStreamException {
0482: int _ttype;
0483: Token _token = null;
0484: int _begin = text.length();
0485: _ttype = NSNAME;
0486: int _saveIndex;
0487:
0488: mXNAME(false);
0489: if (_createToken && _token == null && _ttype != Token.SKIP) {
0490: _token = makeToken(_ttype);
0491: _token.setText(new String(text.getBuffer(), _begin, text
0492: .length()
0493: - _begin));
0494: }
0495: _returnToken = _token;
0496: }
0497:
0498: protected final void mCOLON(boolean _createToken)
0499: throws RecognitionException, CharStreamException,
0500: TokenStreamException {
0501: int _ttype;
0502: Token _token = null;
0503: int _begin = text.length();
0504: _ttype = COLON;
0505: int _saveIndex;
0506:
0507: match(':');
0508: if (_createToken && _token == null && _ttype != Token.SKIP) {
0509: _token = makeToken(_ttype);
0510: _token.setText(new String(text.getBuffer(), _begin, text
0511: .length()
0512: - _begin));
0513: }
0514: _returnToken = _token;
0515: }
0516:
0517: protected final void mLNAME(boolean _createToken)
0518: throws RecognitionException, CharStreamException,
0519: TokenStreamException {
0520: int _ttype;
0521: Token _token = null;
0522: int _begin = text.length();
0523: _ttype = LNAME;
0524: int _saveIndex;
0525:
0526: mXNAME(false);
0527: if (_createToken && _token == null && _ttype != Token.SKIP) {
0528: _token = makeToken(_ttype);
0529: _token.setText(new String(text.getBuffer(), _begin, text
0530: .length()
0531: - _begin));
0532: }
0533: _returnToken = _token;
0534: }
0535:
0536: protected final void mNUMBER(boolean _createToken)
0537: throws RecognitionException, CharStreamException,
0538: TokenStreamException {
0539: int _ttype;
0540: Token _token = null;
0541: int _begin = text.length();
0542: _ttype = NUMBER;
0543: int _saveIndex;
0544:
0545: {
0546: switch (LA(1)) {
0547: case '+': {
0548: match('+');
0549: break;
0550: }
0551: case '-': {
0552: match('-');
0553: break;
0554: }
0555: case '0':
0556: case '1':
0557: case '2':
0558: case '3':
0559: case '4':
0560: case '5':
0561: case '6':
0562: case '7':
0563: case '8':
0564: case '9': {
0565: break;
0566: }
0567: default: {
0568: throw new NoViableAltForCharException((char) LA(1),
0569: getFilename(), getLine(), getColumn());
0570: }
0571: }
0572: }
0573: {
0574: int _cnt117 = 0;
0575: _loop117: do {
0576: if (((LA(1) >= '0' && LA(1) <= '9'))) {
0577: matchRange('0', '9');
0578: } else {
0579: if (_cnt117 >= 1) {
0580: break _loop117;
0581: } else {
0582: throw new NoViableAltForCharException(
0583: (char) LA(1), getFilename(), getLine(),
0584: getColumn());
0585: }
0586: }
0587:
0588: _cnt117++;
0589: } while (true);
0590: }
0591: {
0592: boolean synPredMatched121 = false;
0593: if (((LA(1) == '.'))) {
0594: int _m121 = mark();
0595: synPredMatched121 = true;
0596: inputState.guessing++;
0597: try {
0598: {
0599: mDOT(false);
0600: {
0601: matchRange('0', '9');
0602: }
0603: }
0604: } catch (RecognitionException pe) {
0605: synPredMatched121 = false;
0606: }
0607: rewind(_m121);
0608: inputState.guessing--;
0609: }
0610: if (synPredMatched121) {
0611: mDOT(false);
0612: {
0613: int _cnt123 = 0;
0614: _loop123: do {
0615: if (((LA(1) >= '0' && LA(1) <= '9'))) {
0616: matchRange('0', '9');
0617: } else {
0618: if (_cnt123 >= 1) {
0619: break _loop123;
0620: } else {
0621: throw new NoViableAltForCharException(
0622: (char) LA(1), getFilename(),
0623: getLine(), getColumn());
0624: }
0625: }
0626:
0627: _cnt123++;
0628: } while (true);
0629: }
0630: } else {
0631: }
0632:
0633: }
0634: {
0635: if ((LA(1) == 'E' || LA(1) == 'e')) {
0636: {
0637: switch (LA(1)) {
0638: case 'e': {
0639: match('e');
0640: break;
0641: }
0642: case 'E': {
0643: match('E');
0644: break;
0645: }
0646: default: {
0647: throw new NoViableAltForCharException(
0648: (char) LA(1), getFilename(), getLine(),
0649: getColumn());
0650: }
0651: }
0652: }
0653: {
0654: switch (LA(1)) {
0655: case '+': {
0656: match('+');
0657: break;
0658: }
0659: case '-': {
0660: match('-');
0661: break;
0662: }
0663: case '0':
0664: case '1':
0665: case '2':
0666: case '3':
0667: case '4':
0668: case '5':
0669: case '6':
0670: case '7':
0671: case '8':
0672: case '9': {
0673: break;
0674: }
0675: default: {
0676: throw new NoViableAltForCharException(
0677: (char) LA(1), getFilename(), getLine(),
0678: getColumn());
0679: }
0680: }
0681: }
0682: {
0683: int _cnt128 = 0;
0684: _loop128: do {
0685: if (((LA(1) >= '0' && LA(1) <= '9'))) {
0686: matchRange('0', '9');
0687: } else {
0688: if (_cnt128 >= 1) {
0689: break _loop128;
0690: } else {
0691: throw new NoViableAltForCharException(
0692: (char) LA(1), getFilename(),
0693: getLine(), getColumn());
0694: }
0695: }
0696:
0697: _cnt128++;
0698: } while (true);
0699: }
0700: } else {
0701: }
0702:
0703: }
0704: if (_createToken && _token == null && _ttype != Token.SKIP) {
0705: _token = makeToken(_ttype);
0706: _token.setText(new String(text.getBuffer(), _begin, text
0707: .length()
0708: - _begin));
0709: }
0710: _returnToken = _token;
0711: }
0712:
0713: protected final void mNON_ANC(boolean _createToken)
0714: throws RecognitionException, CharStreamException,
0715: TokenStreamException {
0716: int _ttype;
0717: Token _token = null;
0718: int _begin = text.length();
0719: _ttype = NON_ANC;
0720: int _saveIndex;
0721:
0722: {
0723: match(_tokenSet_5);
0724: }
0725: if (_createToken && _token == null && _ttype != Token.SKIP) {
0726: _token = makeToken(_ttype);
0727: _token.setText(new String(text.getBuffer(), _begin, text
0728: .length()
0729: - _begin));
0730: }
0731: _returnToken = _token;
0732: }
0733:
0734: public final void mURI_OR_IMPLIES(boolean _createToken)
0735: throws RecognitionException, CharStreamException,
0736: TokenStreamException {
0737: int _ttype;
0738: Token _token = null;
0739: int _begin = text.length();
0740: _ttype = URI_OR_IMPLIES;
0741: int _saveIndex;
0742:
0743: boolean synPredMatched74 = false;
0744: if (((LA(1) == '<') && (LA(2) == '=') && (LA(3) == '>'))) {
0745: int _m74 = mark();
0746: synPredMatched74 = true;
0747: inputState.guessing++;
0748: try {
0749: {
0750: mARROW_MEANS(false);
0751: }
0752: } catch (RecognitionException pe) {
0753: synPredMatched74 = false;
0754: }
0755: rewind(_m74);
0756: inputState.guessing--;
0757: }
0758: if (synPredMatched74) {
0759: mARROW_MEANS(false);
0760: if (inputState.guessing == 0) {
0761: _ttype = ARROW_MEANS;
0762: }
0763: } else {
0764: boolean synPredMatched72 = false;
0765: if (((LA(1) == '<') && (LA(2) == '=') && (true))) {
0766: int _m72 = mark();
0767: synPredMatched72 = true;
0768: inputState.guessing++;
0769: try {
0770: {
0771: mARROW_L(false);
0772: }
0773: } catch (RecognitionException pe) {
0774: synPredMatched72 = false;
0775: }
0776: rewind(_m72);
0777: inputState.guessing--;
0778: }
0779: if (synPredMatched72) {
0780: mARROW_L(false);
0781: if (inputState.guessing == 0) {
0782: _ttype = ARROW_L;
0783: }
0784: } else if ((LA(1) == '<') && (_tokenSet_0.member(LA(2)))
0785: && (true)) {
0786: mURIREF(false);
0787: if (inputState.guessing == 0) {
0788: _ttype = URIREF;
0789: }
0790: } else {
0791: throw new NoViableAltForCharException((char) LA(1),
0792: getFilename(), getLine(), getColumn());
0793: }
0794: }
0795: if (_createToken && _token == null && _ttype != Token.SKIP) {
0796: _token = makeToken(_ttype);
0797: _token.setText(new String(text.getBuffer(), _begin, text
0798: .length()
0799: - _begin));
0800: }
0801: _returnToken = _token;
0802: }
0803:
0804: protected final void mARROW_L(boolean _createToken)
0805: throws RecognitionException, CharStreamException,
0806: TokenStreamException {
0807: int _ttype;
0808: Token _token = null;
0809: int _begin = text.length();
0810: _ttype = ARROW_L;
0811: int _saveIndex;
0812:
0813: match("<=");
0814: if (_createToken && _token == null && _ttype != Token.SKIP) {
0815: _token = makeToken(_ttype);
0816: _token.setText(new String(text.getBuffer(), _begin, text
0817: .length()
0818: - _begin));
0819: }
0820: _returnToken = _token;
0821: }
0822:
0823: protected final void mARROW_MEANS(boolean _createToken)
0824: throws RecognitionException, CharStreamException,
0825: TokenStreamException {
0826: int _ttype;
0827: Token _token = null;
0828: int _begin = text.length();
0829: _ttype = ARROW_MEANS;
0830: int _saveIndex;
0831:
0832: match("<=>");
0833: if (_createToken && _token == null && _ttype != Token.SKIP) {
0834: _token = makeToken(_ttype);
0835: _token.setText(new String(text.getBuffer(), _begin, text
0836: .length()
0837: - _begin));
0838: }
0839: _returnToken = _token;
0840: }
0841:
0842: protected final void mURIREF(boolean _createToken)
0843: throws RecognitionException, CharStreamException,
0844: TokenStreamException {
0845: int _ttype;
0846: Token _token = null;
0847: int _begin = text.length();
0848: _ttype = URIREF;
0849: int _saveIndex;
0850:
0851: _saveIndex = text.length();
0852: mLANGLE(false);
0853: text.setLength(_saveIndex);
0854: {
0855: _loop78: do {
0856: // nongreedy exit test
0857: if ((LA(1) == '>') && (true))
0858: break _loop78;
0859: if ((_tokenSet_0.member(LA(1)))
0860: && (_tokenSet_0.member(LA(2)))) {
0861: {
0862: match(_tokenSet_0);
0863: }
0864: } else {
0865: break _loop78;
0866: }
0867:
0868: } while (true);
0869: }
0870: _saveIndex = text.length();
0871: mRANGLE(false);
0872: text.setLength(_saveIndex);
0873: if (_createToken && _token == null && _ttype != Token.SKIP) {
0874: _token = makeToken(_ttype);
0875: _token.setText(new String(text.getBuffer(), _begin, text
0876: .length()
0877: - _begin));
0878: }
0879: _returnToken = _token;
0880: }
0881:
0882: public final void mLANGLE(boolean _createToken)
0883: throws RecognitionException, CharStreamException,
0884: TokenStreamException {
0885: int _ttype;
0886: Token _token = null;
0887: int _begin = text.length();
0888: _ttype = LANGLE;
0889: int _saveIndex;
0890:
0891: match('<');
0892: if (_createToken && _token == null && _ttype != Token.SKIP) {
0893: _token = makeToken(_ttype);
0894: _token.setText(new String(text.getBuffer(), _begin, text
0895: .length()
0896: - _begin));
0897: }
0898: _returnToken = _token;
0899: }
0900:
0901: public final void mRANGLE(boolean _createToken)
0902: throws RecognitionException, CharStreamException,
0903: TokenStreamException {
0904: int _ttype;
0905: Token _token = null;
0906: int _begin = text.length();
0907: _ttype = RANGLE;
0908: int _saveIndex;
0909:
0910: match('>');
0911: if (_createToken && _token == null && _ttype != Token.SKIP) {
0912: _token = makeToken(_ttype);
0913: _token.setText(new String(text.getBuffer(), _begin, text
0914: .length()
0915: - _begin));
0916: }
0917: _returnToken = _token;
0918: }
0919:
0920: protected final void mURICHAR(boolean _createToken)
0921: throws RecognitionException, CharStreamException,
0922: TokenStreamException {
0923: int _ttype;
0924: Token _token = null;
0925: int _begin = text.length();
0926: _ttype = URICHAR;
0927: int _saveIndex;
0928:
0929: switch (LA(1)) {
0930: case '0':
0931: case '1':
0932: case '2':
0933: case '3':
0934: case '4':
0935: case '5':
0936: case '6':
0937: case '7':
0938: case '8':
0939: case '9':
0940: case 'A':
0941: case 'B':
0942: case 'C':
0943: case 'D':
0944: case 'E':
0945: case 'F':
0946: case 'G':
0947: case 'H':
0948: case 'I':
0949: case 'J':
0950: case 'K':
0951: case 'L':
0952: case 'M':
0953: case 'N':
0954: case 'O':
0955: case 'P':
0956: case 'Q':
0957: case 'R':
0958: case 'S':
0959: case 'T':
0960: case 'U':
0961: case 'V':
0962: case 'W':
0963: case 'X':
0964: case 'Y':
0965: case 'Z':
0966: case 'a':
0967: case 'b':
0968: case 'c':
0969: case 'd':
0970: case 'e':
0971: case 'f':
0972: case 'g':
0973: case 'h':
0974: case 'i':
0975: case 'j':
0976: case 'k':
0977: case 'l':
0978: case 'm':
0979: case 'n':
0980: case 'o':
0981: case 'p':
0982: case 'q':
0983: case 'r':
0984: case 's':
0985: case 't':
0986: case 'u':
0987: case 'v':
0988: case 'w':
0989: case 'x':
0990: case 'y':
0991: case 'z': {
0992: mALPHANUMERIC(false);
0993: break;
0994: }
0995: case '-': {
0996: match('-');
0997: break;
0998: }
0999: case '_': {
1000: match('_');
1001: break;
1002: }
1003: case '.': {
1004: match('.');
1005: break;
1006: }
1007: case '!': {
1008: match('!');
1009: break;
1010: }
1011: case '~': {
1012: match('~');
1013: break;
1014: }
1015: case '*': {
1016: match('*');
1017: break;
1018: }
1019: case '\'': {
1020: match("'");
1021: break;
1022: }
1023: case '(': {
1024: match('(');
1025: break;
1026: }
1027: case ')': {
1028: match(')');
1029: break;
1030: }
1031: case ';': {
1032: match(';');
1033: break;
1034: }
1035: case '/': {
1036: match('/');
1037: break;
1038: }
1039: case '?': {
1040: match('?');
1041: break;
1042: }
1043: case ':': {
1044: match(':');
1045: break;
1046: }
1047: case '@': {
1048: match('@');
1049: break;
1050: }
1051: case '&': {
1052: match('&');
1053: break;
1054: }
1055: case '=': {
1056: match('=');
1057: break;
1058: }
1059: case '+': {
1060: match('+');
1061: break;
1062: }
1063: case '$': {
1064: match('$');
1065: break;
1066: }
1067: case ',': {
1068: match(',');
1069: break;
1070: }
1071: case '{': {
1072: match('{');
1073: break;
1074: }
1075: case '}': {
1076: match('}');
1077: break;
1078: }
1079: case '|': {
1080: match('|');
1081: break;
1082: }
1083: case '\\': {
1084: match('\\');
1085: break;
1086: }
1087: case '^': {
1088: match('^');
1089: break;
1090: }
1091: case '[': {
1092: match('[');
1093: break;
1094: }
1095: case ']': {
1096: match(']');
1097: break;
1098: }
1099: case '`': {
1100: match('`');
1101: break;
1102: }
1103: case '%': {
1104: match('%');
1105: break;
1106: }
1107: case '#': {
1108: match('#');
1109: break;
1110: }
1111: case '"': {
1112: match('"');
1113: break;
1114: }
1115: case ' ': {
1116: match(' ');
1117: break;
1118: }
1119: default: {
1120: throw new NoViableAltForCharException((char) LA(1),
1121: getFilename(), getLine(), getColumn());
1122: }
1123: }
1124: if (_createToken && _token == null && _ttype != Token.SKIP) {
1125: _token = makeToken(_ttype);
1126: _token.setText(new String(text.getBuffer(), _begin, text
1127: .length()
1128: - _begin));
1129: }
1130: _returnToken = _token;
1131: }
1132:
1133: protected final void mALPHANUMERIC(boolean _createToken)
1134: throws RecognitionException, CharStreamException,
1135: TokenStreamException {
1136: int _ttype;
1137: Token _token = null;
1138: int _begin = text.length();
1139: _ttype = ALPHANUMERIC;
1140: int _saveIndex;
1141:
1142: {
1143: switch (LA(1)) {
1144: case 'A':
1145: case 'B':
1146: case 'C':
1147: case 'D':
1148: case 'E':
1149: case 'F':
1150: case 'G':
1151: case 'H':
1152: case 'I':
1153: case 'J':
1154: case 'K':
1155: case 'L':
1156: case 'M':
1157: case 'N':
1158: case 'O':
1159: case 'P':
1160: case 'Q':
1161: case 'R':
1162: case 'S':
1163: case 'T':
1164: case 'U':
1165: case 'V':
1166: case 'W':
1167: case 'X':
1168: case 'Y':
1169: case 'Z':
1170: case 'a':
1171: case 'b':
1172: case 'c':
1173: case 'd':
1174: case 'e':
1175: case 'f':
1176: case 'g':
1177: case 'h':
1178: case 'i':
1179: case 'j':
1180: case 'k':
1181: case 'l':
1182: case 'm':
1183: case 'n':
1184: case 'o':
1185: case 'p':
1186: case 'q':
1187: case 'r':
1188: case 's':
1189: case 't':
1190: case 'u':
1191: case 'v':
1192: case 'w':
1193: case 'x':
1194: case 'y':
1195: case 'z': {
1196: mALPHA(false);
1197: break;
1198: }
1199: case '0':
1200: case '1':
1201: case '2':
1202: case '3':
1203: case '4':
1204: case '5':
1205: case '6':
1206: case '7':
1207: case '8':
1208: case '9': {
1209: mNUMERIC(false);
1210: break;
1211: }
1212: default: {
1213: throw new NoViableAltForCharException((char) LA(1),
1214: getFilename(), getLine(), getColumn());
1215: }
1216: }
1217: }
1218: if (_createToken && _token == null && _ttype != Token.SKIP) {
1219: _token = makeToken(_ttype);
1220: _token.setText(new String(text.getBuffer(), _begin, text
1221: .length()
1222: - _begin));
1223: }
1224: _returnToken = _token;
1225: }
1226:
1227: public final void mUVAR(boolean _createToken)
1228: throws RecognitionException, CharStreamException,
1229: TokenStreamException {
1230: int _ttype;
1231: Token _token = null;
1232: int _begin = text.length();
1233: _ttype = UVAR;
1234: int _saveIndex;
1235:
1236: mQUESTION(false);
1237: {
1238: int _cnt82 = 0;
1239: _loop82: do {
1240: if ((_tokenSet_6.member(LA(1)))) {
1241: mALPHANUMERIC(false);
1242: } else {
1243: if (_cnt82 >= 1) {
1244: break _loop82;
1245: } else {
1246: throw new NoViableAltForCharException(
1247: (char) LA(1), getFilename(), getLine(),
1248: getColumn());
1249: }
1250: }
1251:
1252: _cnt82++;
1253: } while (true);
1254: }
1255: if (_createToken && _token == null && _ttype != Token.SKIP) {
1256: _token = makeToken(_ttype);
1257: _token.setText(new String(text.getBuffer(), _begin, text
1258: .length()
1259: - _begin));
1260: }
1261: _returnToken = _token;
1262: }
1263:
1264: protected final void mQUESTION(boolean _createToken)
1265: throws RecognitionException, CharStreamException,
1266: TokenStreamException {
1267: int _ttype;
1268: Token _token = null;
1269: int _begin = text.length();
1270: _ttype = QUESTION;
1271: int _saveIndex;
1272:
1273: match('?');
1274: if (_createToken && _token == null && _ttype != Token.SKIP) {
1275: _token = makeToken(_ttype);
1276: _token.setText(new String(text.getBuffer(), _begin, text
1277: .length()
1278: - _begin));
1279: }
1280: _returnToken = _token;
1281: }
1282:
1283: public final void mAT_WORD(boolean _createToken)
1284: throws RecognitionException, CharStreamException,
1285: TokenStreamException {
1286: int _ttype;
1287: Token _token = null;
1288: int _begin = text.length();
1289: _ttype = AT_WORD;
1290: int _saveIndex;
1291: Token a = null;
1292:
1293: boolean synPredMatched85 = false;
1294: if (((LA(1) == '@') && (LA(2) == 'p') && (LA(3) == 'r'))) {
1295: int _m85 = mark();
1296: synPredMatched85 = true;
1297: inputState.guessing++;
1298: try {
1299: {
1300: mAT(false);
1301: match("prefix");
1302: }
1303: } catch (RecognitionException pe) {
1304: synPredMatched85 = false;
1305: }
1306: rewind(_m85);
1307: inputState.guessing--;
1308: }
1309: if (synPredMatched85) {
1310: mAT(false);
1311: match("prefix");
1312: if (inputState.guessing == 0) {
1313: _ttype = AT_PREFIX;
1314: }
1315: } else {
1316: boolean synPredMatched88 = false;
1317: if (((LA(1) == '@') && (_tokenSet_1.member(LA(2))) && (true))) {
1318: int _m88 = mark();
1319: synPredMatched88 = true;
1320: inputState.guessing++;
1321: try {
1322: {
1323: mAT(false);
1324: {
1325: mALPHA(false);
1326: }
1327: }
1328: } catch (RecognitionException pe) {
1329: synPredMatched88 = false;
1330: }
1331: rewind(_m88);
1332: inputState.guessing--;
1333: }
1334: if (synPredMatched88) {
1335: mAT(false);
1336: {
1337: int _cnt_a = 0;
1338: a: do {
1339: if ((_tokenSet_1.member(LA(1)))) {
1340: mALPHA(false);
1341: } else {
1342: if (_cnt_a >= 1) {
1343: break a;
1344: } else {
1345: throw new NoViableAltForCharException(
1346: (char) LA(1), getFilename(),
1347: getLine(), getColumn());
1348: }
1349: }
1350:
1351: _cnt_a++;
1352: } while (true);
1353: }
1354: {
1355: if ((LA(1) == '-')) {
1356: match("-");
1357: {
1358: _loop93: do {
1359: if ((_tokenSet_1.member(LA(1)))) {
1360: mALPHA(false);
1361: } else {
1362: break _loop93;
1363: }
1364:
1365: } while (true);
1366: }
1367: } else {
1368: }
1369:
1370: }
1371: if (inputState.guessing == 0) {
1372: _ttype = AT_LANG;
1373: }
1374: } else {
1375: throw new NoViableAltForCharException((char) LA(1),
1376: getFilename(), getLine(), getColumn());
1377: }
1378: }
1379: if (_createToken && _token == null && _ttype != Token.SKIP) {
1380: _token = makeToken(_ttype);
1381: _token.setText(new String(text.getBuffer(), _begin, text
1382: .length()
1383: - _begin));
1384: }
1385: _returnToken = _token;
1386: }
1387:
1388: public final void mAT(boolean _createToken)
1389: throws RecognitionException, CharStreamException,
1390: TokenStreamException {
1391: int _ttype;
1392: Token _token = null;
1393: int _begin = text.length();
1394: _ttype = AT;
1395: int _saveIndex;
1396:
1397: match('@');
1398: if (_createToken && _token == null && _ttype != Token.SKIP) {
1399: _token = makeToken(_ttype);
1400: _token.setText(new String(text.getBuffer(), _begin, text
1401: .length()
1402: - _begin));
1403: }
1404: _returnToken = _token;
1405: }
1406:
1407: protected final void mALPHA(boolean _createToken)
1408: throws RecognitionException, CharStreamException,
1409: TokenStreamException {
1410: int _ttype;
1411: Token _token = null;
1412: int _begin = text.length();
1413: _ttype = ALPHA;
1414: int _saveIndex;
1415:
1416: switch (LA(1)) {
1417: case 'A':
1418: case 'B':
1419: case 'C':
1420: case 'D':
1421: case 'E':
1422: case 'F':
1423: case 'G':
1424: case 'H':
1425: case 'I':
1426: case 'J':
1427: case 'K':
1428: case 'L':
1429: case 'M':
1430: case 'N':
1431: case 'O':
1432: case 'P':
1433: case 'Q':
1434: case 'R':
1435: case 'S':
1436: case 'T':
1437: case 'U':
1438: case 'V':
1439: case 'W':
1440: case 'X':
1441: case 'Y':
1442: case 'Z': {
1443: {
1444: matchRange('A', 'Z');
1445: }
1446: break;
1447: }
1448: case 'a':
1449: case 'b':
1450: case 'c':
1451: case 'd':
1452: case 'e':
1453: case 'f':
1454: case 'g':
1455: case 'h':
1456: case 'i':
1457: case 'j':
1458: case 'k':
1459: case 'l':
1460: case 'm':
1461: case 'n':
1462: case 'o':
1463: case 'p':
1464: case 'q':
1465: case 'r':
1466: case 's':
1467: case 't':
1468: case 'u':
1469: case 'v':
1470: case 'w':
1471: case 'x':
1472: case 'y':
1473: case 'z': {
1474: {
1475: matchRange('a', 'z');
1476: }
1477: break;
1478: }
1479: default: {
1480: throw new NoViableAltForCharException((char) LA(1),
1481: getFilename(), getLine(), getColumn());
1482: }
1483: }
1484: if (_createToken && _token == null && _ttype != Token.SKIP) {
1485: _token = makeToken(_ttype);
1486: _token.setText(new String(text.getBuffer(), _begin, text
1487: .length()
1488: - _begin));
1489: }
1490: _returnToken = _token;
1491: }
1492:
1493: protected final void mXNAMECHAR(boolean _createToken)
1494: throws RecognitionException, CharStreamException,
1495: TokenStreamException {
1496: int _ttype;
1497: Token _token = null;
1498: int _begin = text.length();
1499: _ttype = XNAMECHAR;
1500: int _saveIndex;
1501:
1502: {
1503: switch (LA(1)) {
1504: case 'A':
1505: case 'B':
1506: case 'C':
1507: case 'D':
1508: case 'E':
1509: case 'F':
1510: case 'G':
1511: case 'H':
1512: case 'I':
1513: case 'J':
1514: case 'K':
1515: case 'L':
1516: case 'M':
1517: case 'N':
1518: case 'O':
1519: case 'P':
1520: case 'Q':
1521: case 'R':
1522: case 'S':
1523: case 'T':
1524: case 'U':
1525: case 'V':
1526: case 'W':
1527: case 'X':
1528: case 'Y':
1529: case 'Z': {
1530: {
1531: matchRange('A', 'Z');
1532: }
1533: break;
1534: }
1535: case '_': {
1536: match('_');
1537: break;
1538: }
1539: case '-': {
1540: match('-');
1541: break;
1542: }
1543: case 'a':
1544: case 'b':
1545: case 'c':
1546: case 'd':
1547: case 'e':
1548: case 'f':
1549: case 'g':
1550: case 'h':
1551: case 'i':
1552: case 'j':
1553: case 'k':
1554: case 'l':
1555: case 'm':
1556: case 'n':
1557: case 'o':
1558: case 'p':
1559: case 'q':
1560: case 'r':
1561: case 's':
1562: case 't':
1563: case 'u':
1564: case 'v':
1565: case 'w':
1566: case 'x':
1567: case 'y':
1568: case 'z': {
1569: {
1570: matchRange('a', 'z');
1571: }
1572: break;
1573: }
1574: case '\u0370':
1575: case '\u0371':
1576: case '\u0372':
1577: case '\u0373':
1578: case '\u0374':
1579: case '\u0375':
1580: case '\u0376':
1581: case '\u0377':
1582: case '\u0378':
1583: case '\u0379':
1584: case '\u037a':
1585: case '\u037b':
1586: case '\u037c':
1587: case '\u037d': {
1588: {
1589: matchRange('\u0370', '\u037D');
1590: }
1591: break;
1592: }
1593: case '\u200c':
1594: case '\u200d': {
1595: {
1596: matchRange('\u200C', '\u200D');
1597: }
1598: break;
1599: }
1600: case '0':
1601: case '1':
1602: case '2':
1603: case '3':
1604: case '4':
1605: case '5':
1606: case '6':
1607: case '7':
1608: case '8':
1609: case '9': {
1610: {
1611: matchRange('0', '9');
1612: }
1613: break;
1614: }
1615: case '\u0300':
1616: case '\u0301':
1617: case '\u0302':
1618: case '\u0303':
1619: case '\u0304':
1620: case '\u0305':
1621: case '\u0306':
1622: case '\u0307':
1623: case '\u0308':
1624: case '\u0309':
1625: case '\u030a':
1626: case '\u030b':
1627: case '\u030c':
1628: case '\u030d':
1629: case '\u030e':
1630: case '\u030f':
1631: case '\u0310':
1632: case '\u0311':
1633: case '\u0312':
1634: case '\u0313':
1635: case '\u0314':
1636: case '\u0315':
1637: case '\u0316':
1638: case '\u0317':
1639: case '\u0318':
1640: case '\u0319':
1641: case '\u031a':
1642: case '\u031b':
1643: case '\u031c':
1644: case '\u031d':
1645: case '\u031e':
1646: case '\u031f':
1647: case '\u0320':
1648: case '\u0321':
1649: case '\u0322':
1650: case '\u0323':
1651: case '\u0324':
1652: case '\u0325':
1653: case '\u0326':
1654: case '\u0327':
1655: case '\u0328':
1656: case '\u0329':
1657: case '\u032a':
1658: case '\u032b':
1659: case '\u032c':
1660: case '\u032d':
1661: case '\u032e':
1662: case '\u032f':
1663: case '\u0330':
1664: case '\u0331':
1665: case '\u0332':
1666: case '\u0333':
1667: case '\u0334':
1668: case '\u0335':
1669: case '\u0336':
1670: case '\u0337':
1671: case '\u0338':
1672: case '\u0339':
1673: case '\u033a':
1674: case '\u033b':
1675: case '\u033c':
1676: case '\u033d':
1677: case '\u033e':
1678: case '\u033f':
1679: case '\u0340':
1680: case '\u0341':
1681: case '\u0342':
1682: case '\u0343':
1683: case '\u0344':
1684: case '\u0345':
1685: case '\u0346':
1686: case '\u0347':
1687: case '\u0348':
1688: case '\u0349':
1689: case '\u034a':
1690: case '\u034b':
1691: case '\u034c':
1692: case '\u034d':
1693: case '\u034e':
1694: case '\u034f':
1695: case '\u0350':
1696: case '\u0351':
1697: case '\u0352':
1698: case '\u0353':
1699: case '\u0354':
1700: case '\u0355':
1701: case '\u0356':
1702: case '\u0357':
1703: case '\u0358':
1704: case '\u0359':
1705: case '\u035a':
1706: case '\u035b':
1707: case '\u035c':
1708: case '\u035d':
1709: case '\u035e':
1710: case '\u035f':
1711: case '\u0360':
1712: case '\u0361':
1713: case '\u0362':
1714: case '\u0363':
1715: case '\u0364':
1716: case '\u0365':
1717: case '\u0366':
1718: case '\u0367':
1719: case '\u0368':
1720: case '\u0369':
1721: case '\u036a':
1722: case '\u036b':
1723: case '\u036c':
1724: case '\u036d':
1725: case '\u036e':
1726: case '\u036f': {
1727: {
1728: matchRange('\u0300', '\u036F');
1729: }
1730: break;
1731: }
1732: case '\u203f':
1733: case '\u2040': {
1734: {
1735: matchRange('\u203F', '\u2040');
1736: }
1737: break;
1738: }
1739: case '\u00b7': {
1740: match('\u00B7');
1741: break;
1742: }
1743: default:
1744: if (((LA(1) >= '\u00c0' && LA(1) <= '\u02ff'))) {
1745: {
1746: matchRange('\u00C0', '\u02FF');
1747: }
1748: } else if (((LA(1) >= '\u037f' && LA(1) <= '\u1fff'))) {
1749: {
1750: matchRange('\u037F', '\u1FFF');
1751: }
1752: } else if (((LA(1) >= '\u2070' && LA(1) <= '\u218f'))) {
1753: {
1754: matchRange('\u2070', '\u218F');
1755: }
1756: } else if (((LA(1) >= '\u2c00' && LA(1) <= '\u2fef'))) {
1757: {
1758: matchRange('\u2C00', '\u2FEF');
1759: }
1760: } else if (((LA(1) >= '\u3001' && LA(1) <= '\ud7ff'))) {
1761: {
1762: matchRange('\u3001', '\uD7FF');
1763: }
1764: } else if (((LA(1) >= '\uf900' && LA(1) <= '\ufffe'))) {
1765: {
1766: matchRange('\uF900', '\uFFFE');
1767: }
1768: } else {
1769: throw new NoViableAltForCharException((char) LA(1),
1770: getFilename(), getLine(), getColumn());
1771: }
1772: }
1773: }
1774: if (_createToken && _token == null && _ttype != Token.SKIP) {
1775: _token = makeToken(_ttype);
1776: _token.setText(new String(text.getBuffer(), _begin, text
1777: .length()
1778: - _begin));
1779: }
1780: _returnToken = _token;
1781: }
1782:
1783: protected final void mXNAME(boolean _createToken)
1784: throws RecognitionException, CharStreamException,
1785: TokenStreamException {
1786: int _ttype;
1787: Token _token = null;
1788: int _begin = text.length();
1789: _ttype = XNAME;
1790: int _saveIndex;
1791:
1792: {
1793: _loop111: do {
1794: if ((_tokenSet_7.member(LA(1)))) {
1795: mXNAMECHAR(false);
1796: } else {
1797: break _loop111;
1798: }
1799:
1800: } while (true);
1801: }
1802: if (_createToken && _token == null && _ttype != Token.SKIP) {
1803: _token = makeToken(_ttype);
1804: _token.setText(new String(text.getBuffer(), _begin, text
1805: .length()
1806: - _begin));
1807: }
1808: _returnToken = _token;
1809: }
1810:
1811: protected final void mDOT(boolean _createToken)
1812: throws RecognitionException, CharStreamException,
1813: TokenStreamException {
1814: int _ttype;
1815: Token _token = null;
1816: int _begin = text.length();
1817: _ttype = DOT;
1818: int _saveIndex;
1819:
1820: match('.');
1821: if (_createToken && _token == null && _ttype != Token.SKIP) {
1822: _token = makeToken(_ttype);
1823: _token.setText(new String(text.getBuffer(), _begin, text
1824: .length()
1825: - _begin));
1826: }
1827: _returnToken = _token;
1828: }
1829:
1830: public final void mSTRING(boolean _createToken)
1831: throws RecognitionException, CharStreamException,
1832: TokenStreamException {
1833: int _ttype;
1834: Token _token = null;
1835: int _begin = text.length();
1836: _ttype = STRING;
1837: int _saveIndex;
1838:
1839: {
1840: switch (LA(1)) {
1841: case '\'': {
1842: mSTRING1(false);
1843: break;
1844: }
1845: case '"': {
1846: mSTRING2(false);
1847: break;
1848: }
1849: default: {
1850: throw new NoViableAltForCharException((char) LA(1),
1851: getFilename(), getLine(), getColumn());
1852: }
1853: }
1854: }
1855: if (_createToken && _token == null && _ttype != Token.SKIP) {
1856: _token = makeToken(_ttype);
1857: _token.setText(new String(text.getBuffer(), _begin, text
1858: .length()
1859: - _begin));
1860: }
1861: _returnToken = _token;
1862: }
1863:
1864: protected final void mSTRING1(boolean _createToken)
1865: throws RecognitionException, CharStreamException,
1866: TokenStreamException {
1867: int _ttype;
1868: Token _token = null;
1869: int _begin = text.length();
1870: _ttype = STRING1;
1871: int _saveIndex;
1872:
1873: boolean synPredMatched189 = false;
1874: if (((LA(1) == '\'') && (LA(2) == '\'') && (LA(3) == '\''))) {
1875: int _m189 = mark();
1876: synPredMatched189 = true;
1877: inputState.guessing++;
1878: try {
1879: {
1880: mQUOTE3S(false);
1881: }
1882: } catch (RecognitionException pe) {
1883: synPredMatched189 = false;
1884: }
1885: rewind(_m189);
1886: inputState.guessing--;
1887: }
1888: if (synPredMatched189) {
1889: _saveIndex = text.length();
1890: mQUOTE3S(false);
1891: text.setLength(_saveIndex);
1892: {
1893: _loop194: do {
1894: // nongreedy exit test
1895: if ((LA(1) == '\'') && (LA(2) == '\'')
1896: && (LA(3) == '\''))
1897: break _loop194;
1898: boolean synPredMatched192 = false;
1899: if (((LA(1) == '\n' || LA(1) == '\r')
1900: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')))) {
1901: int _m192 = mark();
1902: synPredMatched192 = true;
1903: inputState.guessing++;
1904: try {
1905: {
1906: mNL(false);
1907: }
1908: } catch (RecognitionException pe) {
1909: synPredMatched192 = false;
1910: }
1911: rewind(_m192);
1912: inputState.guessing--;
1913: }
1914: if (synPredMatched192) {
1915: mNL(false);
1916: } else if ((_tokenSet_8.member(LA(1)))
1917: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe'))
1918: && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe'))) {
1919: {
1920: match(_tokenSet_8);
1921: }
1922: } else if ((LA(1) == '\\')) {
1923: mESCAPE(false);
1924: } else {
1925: break _loop194;
1926: }
1927:
1928: } while (true);
1929: }
1930: _saveIndex = text.length();
1931: mQUOTE3S(false);
1932: text.setLength(_saveIndex);
1933: } else if ((LA(1) == '\'')
1934: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true)) {
1935: _saveIndex = text.length();
1936: match('\'');
1937: text.setLength(_saveIndex);
1938: {
1939: _loop196: do {
1940: // nongreedy exit test
1941: if ((LA(1) == '\'') && (true))
1942: break _loop196;
1943: if ((_tokenSet_8.member(LA(1)))
1944: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe'))) {
1945: matchNot('\\');
1946: } else if ((LA(1) == '\\')) {
1947: mESCAPE(false);
1948: } else {
1949: break _loop196;
1950: }
1951:
1952: } while (true);
1953: }
1954: _saveIndex = text.length();
1955: match('\'');
1956: text.setLength(_saveIndex);
1957: } else {
1958: throw new NoViableAltForCharException((char) LA(1),
1959: getFilename(), getLine(), getColumn());
1960: }
1961:
1962: if (_createToken && _token == null && _ttype != Token.SKIP) {
1963: _token = makeToken(_ttype);
1964: _token.setText(new String(text.getBuffer(), _begin, text
1965: .length()
1966: - _begin));
1967: }
1968: _returnToken = _token;
1969: }
1970:
1971: protected final void mSTRING2(boolean _createToken)
1972: throws RecognitionException, CharStreamException,
1973: TokenStreamException {
1974: int _ttype;
1975: Token _token = null;
1976: int _begin = text.length();
1977: _ttype = STRING2;
1978: int _saveIndex;
1979:
1980: boolean synPredMatched199 = false;
1981: if (((LA(1) == '"') && (LA(2) == '"') && (LA(3) == '"'))) {
1982: int _m199 = mark();
1983: synPredMatched199 = true;
1984: inputState.guessing++;
1985: try {
1986: {
1987: mQUOTE3D(false);
1988: }
1989: } catch (RecognitionException pe) {
1990: synPredMatched199 = false;
1991: }
1992: rewind(_m199);
1993: inputState.guessing--;
1994: }
1995: if (synPredMatched199) {
1996: _saveIndex = text.length();
1997: mQUOTE3D(false);
1998: text.setLength(_saveIndex);
1999: {
2000: _loop204: do {
2001: // nongreedy exit test
2002: if ((LA(1) == '"') && (LA(2) == '"')
2003: && (LA(3) == '"'))
2004: break _loop204;
2005: boolean synPredMatched202 = false;
2006: if (((LA(1) == '\n' || LA(1) == '\r')
2007: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')))) {
2008: int _m202 = mark();
2009: synPredMatched202 = true;
2010: inputState.guessing++;
2011: try {
2012: {
2013: mNL(false);
2014: }
2015: } catch (RecognitionException pe) {
2016: synPredMatched202 = false;
2017: }
2018: rewind(_m202);
2019: inputState.guessing--;
2020: }
2021: if (synPredMatched202) {
2022: mNL(false);
2023: } else if ((_tokenSet_8.member(LA(1)))
2024: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe'))
2025: && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe'))) {
2026: {
2027: match(_tokenSet_8);
2028: }
2029: } else if ((LA(1) == '\\')) {
2030: mESCAPE(false);
2031: } else {
2032: break _loop204;
2033: }
2034:
2035: } while (true);
2036: }
2037: _saveIndex = text.length();
2038: mQUOTE3D(false);
2039: text.setLength(_saveIndex);
2040: } else if ((LA(1) == '"')
2041: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true)) {
2042: _saveIndex = text.length();
2043: match('"');
2044: text.setLength(_saveIndex);
2045: {
2046: _loop206: do {
2047: // nongreedy exit test
2048: if ((LA(1) == '"') && (true))
2049: break _loop206;
2050: if ((_tokenSet_8.member(LA(1)))
2051: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe'))) {
2052: matchNot('\\');
2053: } else if ((LA(1) == '\\')) {
2054: mESCAPE(false);
2055: } else {
2056: break _loop206;
2057: }
2058:
2059: } while (true);
2060: }
2061: _saveIndex = text.length();
2062: match('"');
2063: text.setLength(_saveIndex);
2064: } else {
2065: throw new NoViableAltForCharException((char) LA(1),
2066: getFilename(), getLine(), getColumn());
2067: }
2068:
2069: if (_createToken && _token == null && _ttype != Token.SKIP) {
2070: _token = makeToken(_ttype);
2071: _token.setText(new String(text.getBuffer(), _begin, text
2072: .length()
2073: - _begin));
2074: }
2075: _returnToken = _token;
2076: }
2077:
2078: public final void mSEP_OR_PATH(boolean _createToken)
2079: throws RecognitionException, CharStreamException,
2080: TokenStreamException {
2081: int _ttype;
2082: Token _token = null;
2083: int _begin = text.length();
2084: _ttype = SEP_OR_PATH;
2085: int _saveIndex;
2086:
2087: boolean synPredMatched134 = false;
2088: if (((LA(1) == '.') && (true) && (true))) {
2089: int _m134 = mark();
2090: synPredMatched134 = true;
2091: inputState.guessing++;
2092: try {
2093: {
2094: mDOT(false);
2095: {
2096: switch (LA(1)) {
2097: case 'A':
2098: case 'B':
2099: case 'C':
2100: case 'D':
2101: case 'E':
2102: case 'F':
2103: case 'G':
2104: case 'H':
2105: case 'I':
2106: case 'J':
2107: case 'K':
2108: case 'L':
2109: case 'M':
2110: case 'N':
2111: case 'O':
2112: case 'P':
2113: case 'Q':
2114: case 'R':
2115: case 'S':
2116: case 'T':
2117: case 'U':
2118: case 'V':
2119: case 'W':
2120: case 'X':
2121: case 'Y':
2122: case 'Z':
2123: case 'a':
2124: case 'b':
2125: case 'c':
2126: case 'd':
2127: case 'e':
2128: case 'f':
2129: case 'g':
2130: case 'h':
2131: case 'i':
2132: case 'j':
2133: case 'k':
2134: case 'l':
2135: case 'm':
2136: case 'n':
2137: case 'o':
2138: case 'p':
2139: case 'q':
2140: case 'r':
2141: case 's':
2142: case 't':
2143: case 'u':
2144: case 'v':
2145: case 'w':
2146: case 'x':
2147: case 'y':
2148: case 'z': {
2149: mALPHA(false);
2150: break;
2151: }
2152: case '_': {
2153: match('_');
2154: break;
2155: }
2156: case ':': {
2157: mCOLON(false);
2158: break;
2159: }
2160: case '<': {
2161: mLANGLE(false);
2162: break;
2163: }
2164: default: {
2165: throw new NoViableAltForCharException(
2166: (char) LA(1), getFilename(),
2167: getLine(), getColumn());
2168: }
2169: }
2170: }
2171: }
2172: } catch (RecognitionException pe) {
2173: synPredMatched134 = false;
2174: }
2175: rewind(_m134);
2176: inputState.guessing--;
2177: }
2178: if (synPredMatched134) {
2179: mDOT(false);
2180: if (inputState.guessing == 0) {
2181: _ttype = PATH;
2182: }
2183: } else if ((LA(1) == '.') && (true) && (true)) {
2184: mDOT(false);
2185: if (inputState.guessing == 0) {
2186: _ttype = SEP;
2187: }
2188: } else {
2189: throw new NoViableAltForCharException((char) LA(1),
2190: getFilename(), getLine(), getColumn());
2191: }
2192:
2193: if (_createToken && _token == null && _ttype != Token.SKIP) {
2194: _token = makeToken(_ttype);
2195: _token.setText(new String(text.getBuffer(), _begin, text
2196: .length()
2197: - _begin));
2198: }
2199: _returnToken = _token;
2200: }
2201:
2202: public final void mLPAREN(boolean _createToken)
2203: throws RecognitionException, CharStreamException,
2204: TokenStreamException {
2205: int _ttype;
2206: Token _token = null;
2207: int _begin = text.length();
2208: _ttype = LPAREN;
2209: int _saveIndex;
2210:
2211: match('(');
2212: if (_createToken && _token == null && _ttype != Token.SKIP) {
2213: _token = makeToken(_ttype);
2214: _token.setText(new String(text.getBuffer(), _begin, text
2215: .length()
2216: - _begin));
2217: }
2218: _returnToken = _token;
2219: }
2220:
2221: public final void mRPAREN(boolean _createToken)
2222: throws RecognitionException, CharStreamException,
2223: TokenStreamException {
2224: int _ttype;
2225: Token _token = null;
2226: int _begin = text.length();
2227: _ttype = RPAREN;
2228: int _saveIndex;
2229:
2230: match(')');
2231: if (_createToken && _token == null && _ttype != Token.SKIP) {
2232: _token = makeToken(_ttype);
2233: _token.setText(new String(text.getBuffer(), _begin, text
2234: .length()
2235: - _begin));
2236: }
2237: _returnToken = _token;
2238: }
2239:
2240: public final void mLBRACK(boolean _createToken)
2241: throws RecognitionException, CharStreamException,
2242: TokenStreamException {
2243: int _ttype;
2244: Token _token = null;
2245: int _begin = text.length();
2246: _ttype = LBRACK;
2247: int _saveIndex;
2248:
2249: match('[');
2250: if (_createToken && _token == null && _ttype != Token.SKIP) {
2251: _token = makeToken(_ttype);
2252: _token.setText(new String(text.getBuffer(), _begin, text
2253: .length()
2254: - _begin));
2255: }
2256: _returnToken = _token;
2257: }
2258:
2259: public final void mRBRACK(boolean _createToken)
2260: throws RecognitionException, CharStreamException,
2261: TokenStreamException {
2262: int _ttype;
2263: Token _token = null;
2264: int _begin = text.length();
2265: _ttype = RBRACK;
2266: int _saveIndex;
2267:
2268: match(']');
2269: if (_createToken && _token == null && _ttype != Token.SKIP) {
2270: _token = makeToken(_ttype);
2271: _token.setText(new String(text.getBuffer(), _begin, text
2272: .length()
2273: - _begin));
2274: }
2275: _returnToken = _token;
2276: }
2277:
2278: public final void mLCURLY(boolean _createToken)
2279: throws RecognitionException, CharStreamException,
2280: TokenStreamException {
2281: int _ttype;
2282: Token _token = null;
2283: int _begin = text.length();
2284: _ttype = LCURLY;
2285: int _saveIndex;
2286:
2287: match('{');
2288: if (_createToken && _token == null && _ttype != Token.SKIP) {
2289: _token = makeToken(_ttype);
2290: _token.setText(new String(text.getBuffer(), _begin, text
2291: .length()
2292: - _begin));
2293: }
2294: _returnToken = _token;
2295: }
2296:
2297: public final void mRCURLY(boolean _createToken)
2298: throws RecognitionException, CharStreamException,
2299: TokenStreamException {
2300: int _ttype;
2301: Token _token = null;
2302: int _begin = text.length();
2303: _ttype = RCURLY;
2304: int _saveIndex;
2305:
2306: match('}');
2307: if (_createToken && _token == null && _ttype != Token.SKIP) {
2308: _token = makeToken(_ttype);
2309: _token.setText(new String(text.getBuffer(), _begin, text
2310: .length()
2311: - _begin));
2312: }
2313: _returnToken = _token;
2314: }
2315:
2316: public final void mSEMI(boolean _createToken)
2317: throws RecognitionException, CharStreamException,
2318: TokenStreamException {
2319: int _ttype;
2320: Token _token = null;
2321: int _begin = text.length();
2322: _ttype = SEMI;
2323: int _saveIndex;
2324:
2325: match(';');
2326: if (_createToken && _token == null && _ttype != Token.SKIP) {
2327: _token = makeToken(_ttype);
2328: _token.setText(new String(text.getBuffer(), _begin, text
2329: .length()
2330: - _begin));
2331: }
2332: _returnToken = _token;
2333: }
2334:
2335: public final void mCOMMA(boolean _createToken)
2336: throws RecognitionException, CharStreamException,
2337: TokenStreamException {
2338: int _ttype;
2339: Token _token = null;
2340: int _begin = text.length();
2341: _ttype = COMMA;
2342: int _saveIndex;
2343:
2344: match(',');
2345: if (_createToken && _token == null && _ttype != Token.SKIP) {
2346: _token = makeToken(_ttype);
2347: _token.setText(new String(text.getBuffer(), _begin, text
2348: .length()
2349: - _begin));
2350: }
2351: _returnToken = _token;
2352: }
2353:
2354: public final void mPATH(boolean _createToken)
2355: throws RecognitionException, CharStreamException,
2356: TokenStreamException {
2357: int _ttype;
2358: Token _token = null;
2359: int _begin = text.length();
2360: _ttype = PATH;
2361: int _saveIndex;
2362:
2363: match('!');
2364: if (_createToken && _token == null && _ttype != Token.SKIP) {
2365: _token = makeToken(_ttype);
2366: _token.setText(new String(text.getBuffer(), _begin, text
2367: .length()
2368: - _begin));
2369: }
2370: _returnToken = _token;
2371: }
2372:
2373: public final void mRPATH(boolean _createToken)
2374: throws RecognitionException, CharStreamException,
2375: TokenStreamException {
2376: int _ttype;
2377: Token _token = null;
2378: int _begin = text.length();
2379: _ttype = RPATH;
2380: int _saveIndex;
2381:
2382: match('^');
2383: if (_createToken && _token == null && _ttype != Token.SKIP) {
2384: _token = makeToken(_ttype);
2385: _token.setText(new String(text.getBuffer(), _begin, text
2386: .length()
2387: - _begin));
2388: }
2389: _returnToken = _token;
2390: }
2391:
2392: public final void mDATATYPE(boolean _createToken)
2393: throws RecognitionException, CharStreamException,
2394: TokenStreamException {
2395: int _ttype;
2396: Token _token = null;
2397: int _begin = text.length();
2398: _ttype = DATATYPE;
2399: int _saveIndex;
2400:
2401: match("^^");
2402: if (_createToken && _token == null && _ttype != Token.SKIP) {
2403: _token = makeToken(_ttype);
2404: _token.setText(new String(text.getBuffer(), _begin, text
2405: .length()
2406: - _begin));
2407: }
2408: _returnToken = _token;
2409: }
2410:
2411: protected final void mNAME_IT(boolean _createToken)
2412: throws RecognitionException, CharStreamException,
2413: TokenStreamException {
2414: int _ttype;
2415: Token _token = null;
2416: int _begin = text.length();
2417: _ttype = NAME_IT;
2418: int _saveIndex;
2419:
2420: match(":-");
2421: if (_createToken && _token == null && _ttype != Token.SKIP) {
2422: _token = makeToken(_ttype);
2423: _token.setText(new String(text.getBuffer(), _begin, text
2424: .length()
2425: - _begin));
2426: }
2427: _returnToken = _token;
2428: }
2429:
2430: public final void mARROW_R(boolean _createToken)
2431: throws RecognitionException, CharStreamException,
2432: TokenStreamException {
2433: int _ttype;
2434: Token _token = null;
2435: int _begin = text.length();
2436: _ttype = ARROW_R;
2437: int _saveIndex;
2438:
2439: match("=>");
2440: if (_createToken && _token == null && _ttype != Token.SKIP) {
2441: _token = makeToken(_ttype);
2442: _token.setText(new String(text.getBuffer(), _begin, text
2443: .length()
2444: - _begin));
2445: }
2446: _returnToken = _token;
2447: }
2448:
2449: public final void mARROW_PATH_L(boolean _createToken)
2450: throws RecognitionException, CharStreamException,
2451: TokenStreamException {
2452: int _ttype;
2453: Token _token = null;
2454: int _begin = text.length();
2455: _ttype = ARROW_PATH_L;
2456: int _saveIndex;
2457:
2458: match(">-");
2459: if (_createToken && _token == null && _ttype != Token.SKIP) {
2460: _token = makeToken(_ttype);
2461: _token.setText(new String(text.getBuffer(), _begin, text
2462: .length()
2463: - _begin));
2464: }
2465: _returnToken = _token;
2466: }
2467:
2468: public final void mARROW_PATH_R(boolean _createToken)
2469: throws RecognitionException, CharStreamException,
2470: TokenStreamException {
2471: int _ttype;
2472: Token _token = null;
2473: int _begin = text.length();
2474: _ttype = ARROW_PATH_R;
2475: int _saveIndex;
2476:
2477: match("->");
2478: if (_createToken && _token == null && _ttype != Token.SKIP) {
2479: _token = makeToken(_ttype);
2480: _token.setText(new String(text.getBuffer(), _begin, text
2481: .length()
2482: - _begin));
2483: }
2484: _returnToken = _token;
2485: }
2486:
2487: public final void mEQUAL(boolean _createToken)
2488: throws RecognitionException, CharStreamException,
2489: TokenStreamException {
2490: int _ttype;
2491: Token _token = null;
2492: int _begin = text.length();
2493: _ttype = EQUAL;
2494: int _saveIndex;
2495:
2496: match("=");
2497: if (_createToken && _token == null && _ttype != Token.SKIP) {
2498: _token = makeToken(_ttype);
2499: _token.setText(new String(text.getBuffer(), _begin, text
2500: .length()
2501: - _begin));
2502: }
2503: _returnToken = _token;
2504: }
2505:
2506: public final void mSL_COMMENT(boolean _createToken)
2507: throws RecognitionException, CharStreamException,
2508: TokenStreamException {
2509: int _ttype;
2510: Token _token = null;
2511: int _begin = text.length();
2512: _ttype = SL_COMMENT;
2513: int _saveIndex;
2514:
2515: match("#");
2516: {
2517: _loop162: do {
2518: if ((_tokenSet_0.member(LA(1)))) {
2519: {
2520: match(_tokenSet_0);
2521: }
2522: } else {
2523: break _loop162;
2524: }
2525:
2526: } while (true);
2527: }
2528: {
2529: if ((LA(1) == '\n' || LA(1) == '\r')) {
2530: mNL(false);
2531: } else {
2532: }
2533:
2534: }
2535: if (inputState.guessing == 0) {
2536: _ttype = Token.SKIP;
2537: }
2538: if (_createToken && _token == null && _ttype != Token.SKIP) {
2539: _token = makeToken(_ttype);
2540: _token.setText(new String(text.getBuffer(), _begin, text
2541: .length()
2542: - _begin));
2543: }
2544: _returnToken = _token;
2545: }
2546:
2547: protected final void mNL(boolean _createToken)
2548: throws RecognitionException, CharStreamException,
2549: TokenStreamException {
2550: int _ttype;
2551: Token _token = null;
2552: int _begin = text.length();
2553: _ttype = NL;
2554: int _saveIndex;
2555:
2556: boolean synPredMatched169 = false;
2557: if (((LA(1) == '\r') && (LA(2) == '\n') && (true))) {
2558: int _m169 = mark();
2559: synPredMatched169 = true;
2560: inputState.guessing++;
2561: try {
2562: {
2563: mNL1(false);
2564: }
2565: } catch (RecognitionException pe) {
2566: synPredMatched169 = false;
2567: }
2568: rewind(_m169);
2569: inputState.guessing--;
2570: }
2571: if (synPredMatched169) {
2572: mNL1(false);
2573: } else {
2574: boolean synPredMatched171 = false;
2575: if (((LA(1) == '\n'))) {
2576: int _m171 = mark();
2577: synPredMatched171 = true;
2578: inputState.guessing++;
2579: try {
2580: {
2581: mNL2(false);
2582: }
2583: } catch (RecognitionException pe) {
2584: synPredMatched171 = false;
2585: }
2586: rewind(_m171);
2587: inputState.guessing--;
2588: }
2589: if (synPredMatched171) {
2590: mNL2(false);
2591: } else {
2592: boolean synPredMatched173 = false;
2593: if (((LA(1) == '\r') && (true) && (true))) {
2594: int _m173 = mark();
2595: synPredMatched173 = true;
2596: inputState.guessing++;
2597: try {
2598: {
2599: mNL3(false);
2600: }
2601: } catch (RecognitionException pe) {
2602: synPredMatched173 = false;
2603: }
2604: rewind(_m173);
2605: inputState.guessing--;
2606: }
2607: if (synPredMatched173) {
2608: mNL3(false);
2609: } else {
2610: throw new NoViableAltForCharException((char) LA(1),
2611: getFilename(), getLine(), getColumn());
2612: }
2613: }
2614: }
2615: if (_createToken && _token == null && _ttype != Token.SKIP) {
2616: _token = makeToken(_ttype);
2617: _token.setText(new String(text.getBuffer(), _begin, text
2618: .length()
2619: - _begin));
2620: }
2621: _returnToken = _token;
2622: }
2623:
2624: protected final void mNL1(boolean _createToken)
2625: throws RecognitionException, CharStreamException,
2626: TokenStreamException {
2627: int _ttype;
2628: Token _token = null;
2629: int _begin = text.length();
2630: _ttype = NL1;
2631: int _saveIndex;
2632:
2633: match("\r\n");
2634: if (inputState.guessing == 0) {
2635: newline();
2636: }
2637: if (_createToken && _token == null && _ttype != Token.SKIP) {
2638: _token = makeToken(_ttype);
2639: _token.setText(new String(text.getBuffer(), _begin, text
2640: .length()
2641: - _begin));
2642: }
2643: _returnToken = _token;
2644: }
2645:
2646: protected final void mNL2(boolean _createToken)
2647: throws RecognitionException, CharStreamException,
2648: TokenStreamException {
2649: int _ttype;
2650: Token _token = null;
2651: int _begin = text.length();
2652: _ttype = NL2;
2653: int _saveIndex;
2654:
2655: match("\n");
2656: if (inputState.guessing == 0) {
2657: newline();
2658: }
2659: if (_createToken && _token == null && _ttype != Token.SKIP) {
2660: _token = makeToken(_ttype);
2661: _token.setText(new String(text.getBuffer(), _begin, text
2662: .length()
2663: - _begin));
2664: }
2665: _returnToken = _token;
2666: }
2667:
2668: protected final void mNL3(boolean _createToken)
2669: throws RecognitionException, CharStreamException,
2670: TokenStreamException {
2671: int _ttype;
2672: Token _token = null;
2673: int _begin = text.length();
2674: _ttype = NL3;
2675: int _saveIndex;
2676:
2677: match("\r");
2678: if (inputState.guessing == 0) {
2679: newline();
2680: }
2681: if (_createToken && _token == null && _ttype != Token.SKIP) {
2682: _token = makeToken(_ttype);
2683: _token.setText(new String(text.getBuffer(), _begin, text
2684: .length()
2685: - _begin));
2686: }
2687: _returnToken = _token;
2688: }
2689:
2690: public final void mWS(boolean _createToken)
2691: throws RecognitionException, CharStreamException,
2692: TokenStreamException {
2693: int _ttype;
2694: Token _token = null;
2695: int _begin = text.length();
2696: _ttype = WS;
2697: int _saveIndex;
2698:
2699: {
2700: switch (LA(1)) {
2701: case ' ': {
2702: match(' ');
2703: break;
2704: }
2705: case '\t': {
2706: match('\t');
2707: break;
2708: }
2709: case '\u000c': {
2710: match('\f');
2711: break;
2712: }
2713: case '\n':
2714: case '\r': {
2715: mNL(false);
2716: break;
2717: }
2718: default: {
2719: throw new NoViableAltForCharException((char) LA(1),
2720: getFilename(), getLine(), getColumn());
2721: }
2722: }
2723: }
2724: if (inputState.guessing == 0) {
2725: _ttype = Token.SKIP;
2726: }
2727: if (_createToken && _token == null && _ttype != Token.SKIP) {
2728: _token = makeToken(_ttype);
2729: _token.setText(new String(text.getBuffer(), _begin, text
2730: .length()
2731: - _begin));
2732: }
2733: _returnToken = _token;
2734: }
2735:
2736: protected final void mNWS(boolean _createToken)
2737: throws RecognitionException, CharStreamException,
2738: TokenStreamException {
2739: int _ttype;
2740: Token _token = null;
2741: int _begin = text.length();
2742: _ttype = NWS;
2743: int _saveIndex;
2744:
2745: {
2746: match(_tokenSet_9);
2747: }
2748: if (_createToken && _token == null && _ttype != Token.SKIP) {
2749: _token = makeToken(_ttype);
2750: _token.setText(new String(text.getBuffer(), _begin, text
2751: .length()
2752: - _begin));
2753: }
2754: _returnToken = _token;
2755: }
2756:
2757: protected final void mNUMERIC(boolean _createToken)
2758: throws RecognitionException, CharStreamException,
2759: TokenStreamException {
2760: int _ttype;
2761: Token _token = null;
2762: int _begin = text.length();
2763: _ttype = NUMERIC;
2764: int _saveIndex;
2765:
2766: {
2767: matchRange('0', '9');
2768: }
2769: if (_createToken && _token == null && _ttype != Token.SKIP) {
2770: _token = makeToken(_ttype);
2771: _token.setText(new String(text.getBuffer(), _begin, text
2772: .length()
2773: - _begin));
2774: }
2775: _returnToken = _token;
2776: }
2777:
2778: protected final void mQUOTE3S(boolean _createToken)
2779: throws RecognitionException, CharStreamException,
2780: TokenStreamException {
2781: int _ttype;
2782: Token _token = null;
2783: int _begin = text.length();
2784: _ttype = QUOTE3S;
2785: int _saveIndex;
2786:
2787: match("'''");
2788: if (_createToken && _token == null && _ttype != Token.SKIP) {
2789: _token = makeToken(_ttype);
2790: _token.setText(new String(text.getBuffer(), _begin, text
2791: .length()
2792: - _begin));
2793: }
2794: _returnToken = _token;
2795: }
2796:
2797: protected final void mESCAPE(boolean _createToken)
2798: throws RecognitionException, CharStreamException,
2799: TokenStreamException {
2800: int _ttype;
2801: Token _token = null;
2802: int _begin = text.length();
2803: _ttype = ESCAPE;
2804: int _saveIndex;
2805: char ch = '\0';
2806:
2807: _saveIndex = text.length();
2808: match('\\');
2809: text.setLength(_saveIndex);
2810: {
2811: boolean synPredMatched212 = false;
2812: if (((_tokenSet_10.member(LA(1)))
2813: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true))) {
2814: int _m212 = mark();
2815: synPredMatched212 = true;
2816: inputState.guessing++;
2817: try {
2818: {
2819: mESC_CHAR(false);
2820: }
2821: } catch (RecognitionException pe) {
2822: synPredMatched212 = false;
2823: }
2824: rewind(_m212);
2825: inputState.guessing--;
2826: }
2827: if (synPredMatched212) {
2828: mESC_CHAR(false);
2829: } else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe'))
2830: && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe'))
2831: && (true)) {
2832: ch = LA(1);
2833: matchNot(EOF_CHAR);
2834: if (inputState.guessing == 0) {
2835: text.setLength(_begin);
2836: text.append("\\" + ch);
2837: }
2838: } else {
2839: throw new NoViableAltForCharException((char) LA(1),
2840: getFilename(), getLine(), getColumn());
2841: }
2842:
2843: }
2844: if (_createToken && _token == null && _ttype != Token.SKIP) {
2845: _token = makeToken(_ttype);
2846: _token.setText(new String(text.getBuffer(), _begin, text
2847: .length()
2848: - _begin));
2849: }
2850: _returnToken = _token;
2851: }
2852:
2853: protected final void mQUOTE3D(boolean _createToken)
2854: throws RecognitionException, CharStreamException,
2855: TokenStreamException {
2856: int _ttype;
2857: Token _token = null;
2858: int _begin = text.length();
2859: _ttype = QUOTE3D;
2860: int _saveIndex;
2861:
2862: match('"');
2863: match('"');
2864: match('"');
2865: if (_createToken && _token == null && _ttype != Token.SKIP) {
2866: _token = makeToken(_ttype);
2867: _token.setText(new String(text.getBuffer(), _begin, text
2868: .length()
2869: - _begin));
2870: }
2871: _returnToken = _token;
2872: }
2873:
2874: protected final void mESC_CHAR(boolean _createToken)
2875: throws RecognitionException, CharStreamException,
2876: TokenStreamException {
2877: int _ttype;
2878: Token _token = null;
2879: int _begin = text.length();
2880: _ttype = ESC_CHAR;
2881: int _saveIndex;
2882: Token h = null;
2883:
2884: {
2885: switch (LA(1)) {
2886: case 'n': {
2887: match('n');
2888: if (inputState.guessing == 0) {
2889: text.setLength(_begin);
2890: text.append("\n");
2891: }
2892: break;
2893: }
2894: case 'r': {
2895: match('r');
2896: if (inputState.guessing == 0) {
2897: text.setLength(_begin);
2898: text.append("\r");
2899: }
2900: break;
2901: }
2902: case 'b': {
2903: match('b');
2904: if (inputState.guessing == 0) {
2905: text.setLength(_begin);
2906: text.append("\b");
2907: }
2908: break;
2909: }
2910: case 't': {
2911: match('t');
2912: if (inputState.guessing == 0) {
2913: text.setLength(_begin);
2914: text.append("\t");
2915: }
2916: break;
2917: }
2918: case 'f': {
2919: match('f');
2920: if (inputState.guessing == 0) {
2921: text.setLength(_begin);
2922: text.append("\f");
2923: }
2924: break;
2925: }
2926: case 'v': {
2927: match('v');
2928: if (inputState.guessing == 0) {
2929: text.setLength(_begin);
2930: text.append("\f");
2931: }
2932: break;
2933: }
2934: case 'a': {
2935: match('a');
2936: if (inputState.guessing == 0) {
2937: text.setLength(_begin);
2938: text.append("\007");
2939: }
2940: break;
2941: }
2942: case 'u': {
2943: match('u');
2944: mHEX4(true);
2945: h = _returnToken;
2946: if (inputState.guessing == 0) {
2947:
2948: char ch = (char) Integer.parseInt(h.getText(), 16);
2949: text.setLength(_begin);
2950: text.append(ch);
2951:
2952: }
2953: break;
2954: }
2955: case '"': {
2956: match('"');
2957: if (inputState.guessing == 0) {
2958: text.setLength(_begin);
2959: text.append("\"");
2960: }
2961: break;
2962: }
2963: case '\\': {
2964: match('\\');
2965: if (inputState.guessing == 0) {
2966: text.setLength(_begin);
2967: text.append("\\");
2968: }
2969: break;
2970: }
2971: case '\'': {
2972: match('\'');
2973: if (inputState.guessing == 0) {
2974: text.setLength(_begin);
2975: text.append("'");
2976: }
2977: break;
2978: }
2979: default: {
2980: throw new NoViableAltForCharException((char) LA(1),
2981: getFilename(), getLine(), getColumn());
2982: }
2983: }
2984: }
2985: if (_createToken && _token == null && _ttype != Token.SKIP) {
2986: _token = makeToken(_ttype);
2987: _token.setText(new String(text.getBuffer(), _begin, text
2988: .length()
2989: - _begin));
2990: }
2991: _returnToken = _token;
2992: }
2993:
2994: protected final void mHEX4(boolean _createToken)
2995: throws RecognitionException, CharStreamException,
2996: TokenStreamException {
2997: int _ttype;
2998: Token _token = null;
2999: int _begin = text.length();
3000: _ttype = HEX4;
3001: int _saveIndex;
3002:
3003: mHEX_DIGIT(false);
3004: mHEX_DIGIT(false);
3005: mHEX_DIGIT(false);
3006: mHEX_DIGIT(false);
3007: if (_createToken && _token == null && _ttype != Token.SKIP) {
3008: _token = makeToken(_ttype);
3009: _token.setText(new String(text.getBuffer(), _begin, text
3010: .length()
3011: - _begin));
3012: }
3013: _returnToken = _token;
3014: }
3015:
3016: protected final void mHEX_DIGIT(boolean _createToken)
3017: throws RecognitionException, CharStreamException,
3018: TokenStreamException {
3019: int _ttype;
3020: Token _token = null;
3021: int _begin = text.length();
3022: _ttype = HEX_DIGIT;
3023: int _saveIndex;
3024:
3025: {
3026: switch (LA(1)) {
3027: case '0':
3028: case '1':
3029: case '2':
3030: case '3':
3031: case '4':
3032: case '5':
3033: case '6':
3034: case '7':
3035: case '8':
3036: case '9': {
3037: matchRange('0', '9');
3038: break;
3039: }
3040: case 'A':
3041: case 'B':
3042: case 'C':
3043: case 'D':
3044: case 'E':
3045: case 'F': {
3046: matchRange('A', 'F');
3047: break;
3048: }
3049: case 'a':
3050: case 'b':
3051: case 'c':
3052: case 'd':
3053: case 'e':
3054: case 'f': {
3055: matchRange('a', 'f');
3056: break;
3057: }
3058: default: {
3059: throw new NoViableAltForCharException((char) LA(1),
3060: getFilename(), getLine(), getColumn());
3061: }
3062: }
3063: }
3064: if (_createToken && _token == null && _ttype != Token.SKIP) {
3065: _token = makeToken(_ttype);
3066: _token.setText(new String(text.getBuffer(), _begin, text
3067: .length()
3068: - _begin));
3069: }
3070: _returnToken = _token;
3071: }
3072:
3073: private static final long[] mk_tokenSet_0() {
3074: long[] data = new long[2048];
3075: data[0] = -9217L;
3076: for (int i = 1; i <= 1022; i++) {
3077: data[i] = -1L;
3078: }
3079: data[1023] = 9223372036854775807L;
3080: return data;
3081: }
3082:
3083: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
3084:
3085: private static final long[] mk_tokenSet_1() {
3086: long[] data = new long[1025];
3087: data[1] = 576460743847706622L;
3088: return data;
3089: }
3090:
3091: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
3092:
3093: private static final long[] mk_tokenSet_2() {
3094: long[] data = new long[3988];
3095: data[0] = 576223257791823872L;
3096: data[1] = 576460745995190270L;
3097: data[2] = 36028797018963968L;
3098: for (int i = 3; i <= 12; i++) {
3099: data[i] = -1L;
3100: }
3101: data[13] = -4611686018427387905L;
3102: for (int i = 14; i <= 127; i++) {
3103: data[i] = -1L;
3104: }
3105: data[128] = -9223372036854763520L;
3106: data[129] = -281474976710655L;
3107: for (int i = 130; i <= 133; i++) {
3108: data[i] = -1L;
3109: }
3110: data[134] = 65535L;
3111: for (int i = 176; i <= 190; i++) {
3112: data[i] = -1L;
3113: }
3114: data[191] = 281474976710655L;
3115: data[192] = -2L;
3116: for (int i = 193; i <= 863; i++) {
3117: data[i] = -1L;
3118: }
3119: for (int i = 996; i <= 1022; i++) {
3120: data[i] = -1L;
3121: }
3122: data[1023] = 9223372036854775807L;
3123: return data;
3124: }
3125:
3126: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
3127:
3128: private static final long[] mk_tokenSet_3() {
3129: long[] data = new long[3988];
3130: data[0] = 576214461698801664L;
3131: data[1] = 576460745995190270L;
3132: data[2] = 36028797018963968L;
3133: for (int i = 3; i <= 12; i++) {
3134: data[i] = -1L;
3135: }
3136: data[13] = -4611686018427387905L;
3137: for (int i = 14; i <= 127; i++) {
3138: data[i] = -1L;
3139: }
3140: data[128] = -9223372036854763520L;
3141: data[129] = -281474976710655L;
3142: for (int i = 130; i <= 133; i++) {
3143: data[i] = -1L;
3144: }
3145: data[134] = 65535L;
3146: for (int i = 176; i <= 190; i++) {
3147: data[i] = -1L;
3148: }
3149: data[191] = 281474976710655L;
3150: data[192] = -2L;
3151: for (int i = 193; i <= 863; i++) {
3152: data[i] = -1L;
3153: }
3154: for (int i = 996; i <= 1022; i++) {
3155: data[i] = -1L;
3156: }
3157: data[1023] = 9223372036854775807L;
3158: return data;
3159: }
3160:
3161: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
3162:
3163: private static final long[] mk_tokenSet_4() {
3164: long[] data = new long[1025];
3165: data[0] = 287992881640112128L;
3166: return data;
3167: }
3168:
3169: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
3170:
3171: private static final long[] mk_tokenSet_5() {
3172: long[] data = new long[2048];
3173: data[0] = -576179277326712833L;
3174: data[1] = -576460743847706623L;
3175: for (int i = 2; i <= 1022; i++) {
3176: data[i] = -1L;
3177: }
3178: data[1023] = 9223372036854775807L;
3179: return data;
3180: }
3181:
3182: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
3183:
3184: private static final long[] mk_tokenSet_6() {
3185: long[] data = new long[1025];
3186: data[0] = 287948901175001088L;
3187: data[1] = 576460743847706622L;
3188: return data;
3189: }
3190:
3191: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
3192:
3193: private static final long[] mk_tokenSet_7() {
3194: long[] data = new long[3988];
3195: data[0] = 287984085547089920L;
3196: data[1] = 576460745995190270L;
3197: data[2] = 36028797018963968L;
3198: for (int i = 3; i <= 12; i++) {
3199: data[i] = -1L;
3200: }
3201: data[13] = -4611686018427387905L;
3202: for (int i = 14; i <= 127; i++) {
3203: data[i] = -1L;
3204: }
3205: data[128] = -9223372036854763520L;
3206: data[129] = -281474976710655L;
3207: for (int i = 130; i <= 133; i++) {
3208: data[i] = -1L;
3209: }
3210: data[134] = 65535L;
3211: for (int i = 176; i <= 190; i++) {
3212: data[i] = -1L;
3213: }
3214: data[191] = 281474976710655L;
3215: data[192] = -2L;
3216: for (int i = 193; i <= 863; i++) {
3217: data[i] = -1L;
3218: }
3219: for (int i = 996; i <= 1022; i++) {
3220: data[i] = -1L;
3221: }
3222: data[1023] = 9223372036854775807L;
3223: return data;
3224: }
3225:
3226: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
3227:
3228: private static final long[] mk_tokenSet_8() {
3229: long[] data = new long[2048];
3230: data[0] = -1L;
3231: data[1] = -268435457L;
3232: for (int i = 2; i <= 1022; i++) {
3233: data[i] = -1L;
3234: }
3235: data[1023] = 9223372036854775807L;
3236: return data;
3237: }
3238:
3239: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
3240:
3241: private static final long[] mk_tokenSet_9() {
3242: long[] data = new long[2048];
3243: data[0] = -4294981121L;
3244: for (int i = 1; i <= 1022; i++) {
3245: data[i] = -1L;
3246: }
3247: data[1023] = 9223372036854775807L;
3248: return data;
3249: }
3250:
3251: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
3252:
3253: private static final long[] mk_tokenSet_10() {
3254: long[] data = new long[1025];
3255: data[0] = 566935683072L;
3256: data[1] = 32721766958759936L;
3257: return data;
3258: }
3259:
3260: public static final BitSet _tokenSet_10 = new BitSet(
3261: mk_tokenSet_10());
3262:
3263: }
|