Source Code Cross Referenced for N3AntlrLexer.java in  » RSS-RDF » Jena-2.5.5 » com » hp » hpl » jena » n3 » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » RSS RDF » Jena 2.5.5 » com.hp.hpl.jena.n3 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.