Coverage Report

Coverage Report - org.xembly.XemblyLexer

Classes in this File

Line Coverage

Branch Coverage

Complexity

XemblyLexer

73%

229/311

74%

92/123

5.269

 // $ANTLR 3.5.2 org/xembly/Xembly.g 2018-08-10 07:49:40
 
     package org.xembly;
 
 
 import org.antlr.runtime.*;
 import java.util.Stack;
 import java.util.List;
 import java.util.ArrayList;
 
 @SuppressWarnings("all")
 public class XemblyLexer extends Lexer {
         public static final int EOF=-1;
         public static final int T__10=10;
         public static final int T__11=11;
         public static final int T__12=12;
         public static final int T__13=13;
         public static final int T__14=14;
         public static final int T__15=15;
         public static final int T__16=16;
         public static final int T__17=17;
         public static final int T__18=18;
         public static final int T__19=19;
         public static final int T__20=20;
         public static final int T__21=21;
         public static final int T__22=22;
         public static final int COLON=4;
         public static final int COMMA=5;
         public static final int DIGIT=6;
         public static final int SEMICOLON=7;
         public static final int SPACE=8;
         public static final int TEXT=9;
 
             @Override
             public void emitErrorMessage(String msg) {
                 throw new ParsingException(msg);
             }
 
 
         // delegates
         // delegators
         public Lexer[] getDelegates() {
                 return new Lexer[] {};
         }
 
         public XemblyLexer() {} 
         public XemblyLexer(CharStream input) {
                 this(input, new RecognizerSharedState());
         }
         public XemblyLexer(CharStream input, RecognizerSharedState state) {
                 super(input,state);
         }
         @Override public String getGrammarFileName() { return "org/xembly/Xembly.g"; }
 
         // $ANTLR start "T__10"
         public final void mT__10() throws RecognitionException {
                 try {
                         int _type = T__10;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:12:7: ( 'ADD' )
                         // org/xembly/Xembly.g:12:9: 'ADD'
                         {
                         match("ADD"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__10"
 
         // $ANTLR start "T__11"
         public final void mT__11() throws RecognitionException {
                 try {
                         int _type = T__11;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:13:7: ( 'ADDIF' )
                         // org/xembly/Xembly.g:13:9: 'ADDIF'
                         {
                         match("ADDIF"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__11"
 
         // $ANTLR start "T__12"
         public final void mT__12() throws RecognitionException {
                 try {
                         int _type = T__12;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:14:7: ( 'ATTR' )
                         // org/xembly/Xembly.g:14:9: 'ATTR'
                         {
                         match("ATTR"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__12"
 
         // $ANTLR start "T__13"
         public final void mT__13() throws RecognitionException {
                 try {
                         int _type = T__13;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:15:7: ( 'CDATA' )
                         // org/xembly/Xembly.g:15:9: 'CDATA'
                         {
                         match("CDATA"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__13"
 
         // $ANTLR start "T__14"
         public final void mT__14() throws RecognitionException {
                 try {
                         int _type = T__14;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:16:7: ( 'PI' )
                         // org/xembly/Xembly.g:16:9: 'PI'
                         {
                         match("PI"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__14"
 
         // $ANTLR start "T__15"
         public final void mT__15() throws RecognitionException {
                 try {
                         int _type = T__15;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:17:7: ( 'POP' )
                         // org/xembly/Xembly.g:17:9: 'POP'
                         {
                         match("POP"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__15"
 
         // $ANTLR start "T__16"
         public final void mT__16() throws RecognitionException {
                 try {
                         int _type = T__16;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:18:7: ( 'PUSH' )
                         // org/xembly/Xembly.g:18:9: 'PUSH'
                         {
                         match("PUSH"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__16"
 
         // $ANTLR start "T__17"
         public final void mT__17() throws RecognitionException {
                 try {
                         int _type = T__17;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:19:7: ( 'REMOVE' )
                         // org/xembly/Xembly.g:19:9: 'REMOVE'
                         {
                         match("REMOVE"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__17"
 
         // $ANTLR start "T__18"
         public final void mT__18() throws RecognitionException {
                 try {
                         int _type = T__18;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:20:7: ( 'SET' )
                         // org/xembly/Xembly.g:20:9: 'SET'
                         {
                         match("SET"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__18"
 
         // $ANTLR start "T__19"
         public final void mT__19() throws RecognitionException {
                 try {
                         int _type = T__19;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:21:7: ( 'STRICT' )
                         // org/xembly/Xembly.g:21:9: 'STRICT'
                         {
                         match("STRICT"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__19"
 
         // $ANTLR start "T__20"
         public final void mT__20() throws RecognitionException {
                 try {
                         int _type = T__20;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:22:7: ( 'UP' )
                         // org/xembly/Xembly.g:22:9: 'UP'
                         {
                         match("UP"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__20"
 
         // $ANTLR start "T__21"
         public final void mT__21() throws RecognitionException {
                 try {
                         int _type = T__21;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:23:7: ( 'XPATH' )
                         // org/xembly/Xembly.g:23:9: 'XPATH'
                         {
                         match("XPATH"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__21"
 
         // $ANTLR start "T__22"
         public final void mT__22() throws RecognitionException {
                 try {
                         int _type = T__22;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:24:7: ( 'XSET' )
                         // org/xembly/Xembly.g:24:9: 'XSET'
                         {
                         match("XSET"); 
 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "T__22"
 
         // $ANTLR start "DIGIT"
         public final void mDIGIT() throws RecognitionException {
                 try {
                         int _type = DIGIT;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:179:6: ( '0' .. '9' )
                         // org/xembly/Xembly.g:
                         {
                         if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                                 input.consume();
                         }
                         else {
                                 MismatchedSetException mse = new MismatchedSetException(null,input);
                                 recover(mse);
                                 throw mse;
                         }
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "DIGIT"
 
         // $ANTLR start "COMMA"
         public final void mCOMMA() throws RecognitionException {
                 try {
                         int _type = COMMA;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:180:6: ( ',' )
                         // org/xembly/Xembly.g:180:8: ','
                         {
                         match(','); 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "COMMA"
 
         // $ANTLR start "COLON"
         public final void mCOLON() throws RecognitionException {
                 try {
                         int _type = COLON;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:181:6: ( ':' )
                         // org/xembly/Xembly.g:181:8: ':'
                         {
                         match(':'); 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "COLON"
 
         // $ANTLR start "SEMICOLON"
         public final void mSEMICOLON() throws RecognitionException {
                 try {
                         int _type = SEMICOLON;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:182:10: ( ';' )
                         // org/xembly/Xembly.g:182:12: ';'
                         {
                         match(';'); 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "SEMICOLON"
 
         // $ANTLR start "TEXT"
         public final void mTEXT() throws RecognitionException {
                 try {
                         int _type = TEXT;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:184:5: ( '\"' (~ '\"' )* '\"' | '\\'' (~ '\\'' )* '\\'' )
                         int alt3=2;
                         int LA3_0 = input.LA(1);
                         if ( (LA3_0=='\"') ) {
                                 alt3=1;
                         }
                         else if ( (LA3_0=='\'') ) {
                                 alt3=2;
                         }
 
                         else {
                                 NoViableAltException nvae =
                                         new NoViableAltException("", 3, 0, input);
                                 throw nvae;
                         }
 
                         switch (alt3) {
                                 case 1 :
                                         // org/xembly/Xembly.g:185:5: '\"' (~ '\"' )* '\"'
                                         {
                                         match('\"'); 
                                         // org/xembly/Xembly.g:185:9: (~ '\"' )*
                                         loop1:
                                         while (true) {
                                                 int alt1=2;
                                                 int LA1_0 = input.LA(1);
                                                 if ( ((LA1_0 >= '\u0000' && LA1_0 <= '!')||(LA1_0 >= '#' && LA1_0 <= '\uFFFF')) ) {
                                                         alt1=1;
                                                 }
 
                                                 switch (alt1) {
                                                 case 1 :
                                                         // org/xembly/Xembly.g:
                                                         {
                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
                                                                 input.consume();
                                                         }
                                                         else {
                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
                                                                 recover(mse);
                                                                 throw mse;
                                                         }
                                                         }
                                                         break;
 
                                                 default :
                                                         break loop1;
                                                 }
                                         }
 
                                         match('\"'); 
 
                                                 try {
                                                     this.setText(Arg.unescape(this.getText()));
                                                 } catch (final XmlContentException ex) {
                                                     throw new ParsingException(ex);
                                                 }
                                             
                                         }
                                         break;
                                 case 2 :
                                         // org/xembly/Xembly.g:194:5: '\\'' (~ '\\'' )* '\\''
                                         {
                                         match('\''); 
                                         // org/xembly/Xembly.g:194:10: (~ '\\'' )*
                                         loop2:
                                         while (true) {
                                                 int alt2=2;
                                                 int LA2_0 = input.LA(1);
                                                 if ( ((LA2_0 >= '\u0000' && LA2_0 <= '&')||(LA2_0 >= '(' && LA2_0 <= '\uFFFF')) ) {
                                                         alt2=1;
                                                 }
 
                                                 switch (alt2) {
                                                 case 1 :
                                                         // org/xembly/Xembly.g:
                                                         {
                                                         if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '\uFFFF') ) {
                                                                 input.consume();
                                                         }
                                                         else {
                                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
                                                                 recover(mse);
                                                                 throw mse;
                                                         }
                                                         }
                                                         break;
 
                                                 default :
                                                         break loop2;
                                                 }
                                         }
 
                                         match('\''); 
 
                                                 try {
                                                     this.setText(Arg.unescape(this.getText()));
                                                 } catch (final XmlContentException ex) {
                                                     throw new ParsingException(ex);
                                                 }
                                             
                                         }
                                         break;
 
                         }
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "TEXT"
 
         // $ANTLR start "SPACE"
         public final void mSPACE() throws RecognitionException {
                 try {
                         int _type = SPACE;
                         int _channel = DEFAULT_TOKEN_CHANNEL;
                         // org/xembly/Xembly.g:204:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
                         // org/xembly/Xembly.g:205:5: ( ' ' | '\\t' | '\\n' | '\\r' )+
                         {
                         // org/xembly/Xembly.g:205:5: ( ' ' | '\\t' | '\\n' | '\\r' )+
                         int cnt4=0;
                         loop4:
                         while (true) {
                                 int alt4=2;
                                 int LA4_0 = input.LA(1);
                                 if ( ((LA4_0 >= '\t' && LA4_0 <= '\n')||LA4_0=='\r'||LA4_0==' ') ) {
                                         alt4=1;
                                 }
 
                                 switch (alt4) {
                                 case 1 :
                                         // org/xembly/Xembly.g:
                                         {
                                         if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
                                                 input.consume();
                                         }
                                         else {
                                                 MismatchedSetException mse = new MismatchedSetException(null,input);
                                                 recover(mse);
                                                 throw mse;
                                         }
                                         }
                                         break;
 
                                 default :
                                         if ( cnt4 >= 1 ) break loop4;
                                         EarlyExitException eee = new EarlyExitException(4, input);
                                         throw eee;
                                 }
                                 cnt4++;
                         }
 
                          skip(); 
                         }
 
                         state.type = _type;
                         state.channel = _channel;
                 }
                 finally {
                         // do for sure before leaving
                 }
         }
         // $ANTLR end "SPACE"
 
         @Override
         public void mTokens() throws RecognitionException {
                 // org/xembly/Xembly.g:1:8: ( T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | DIGIT | COMMA | COLON | SEMICOLON | TEXT | SPACE )
                 int alt5=19;
                 switch ( input.LA(1) ) {
                 case 'A':
                         {
                         int LA5_1 = input.LA(2);
                         if ( (LA5_1=='D') ) {
                                 int LA5_14 = input.LA(3);
                                 if ( (LA5_14=='D') ) {
                                         int LA5_23 = input.LA(4);
                                         if ( (LA5_23=='I') ) {
                                                 alt5=2;
                                         }
 
                                         else {
                                                 alt5=1;
                                         }
 
                                 }
 
                                 else {
                                         int nvaeMark = input.mark();
                                         try {
                                                 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
                                                         input.consume();
                                                 }
                                                 NoViableAltException nvae =
                                                         new NoViableAltException("", 5, 14, input);
                                                 throw nvae;
                                         } finally {
                                                 input.rewind(nvaeMark);
                                         }
                                 }
 
                         }
                         else if ( (LA5_1=='T') ) {
                                 alt5=3;
                         }
 
                         else {
                                 int nvaeMark = input.mark();
                                 try {
                                         input.consume();
                                         NoViableAltException nvae =
                                                 new NoViableAltException("", 5, 1, input);
                                         throw nvae;
                                 } finally {
                                         input.rewind(nvaeMark);
                                 }
                         }
 
                         }
                         break;
                 case 'C':
                         {
                         alt5=4;
                         }
                         break;
                 case 'P':
                         {
                         switch ( input.LA(2) ) {
                         case 'I':
                                 {
                                 alt5=5;
                                 }
                                 break;
                         case 'O':
                                 {
                                 alt5=6;
                                 }
                                 break;
                         case 'U':
                                 {
                                 alt5=7;
                                 }
                                 break;
                         default:
                                 int nvaeMark = input.mark();
                                 try {
                                         input.consume();
                                         NoViableAltException nvae =
                                                 new NoViableAltException("", 5, 3, input);
                                         throw nvae;
                                 } finally {
                                         input.rewind(nvaeMark);
                                 }
                         }
                         }
                         break;
                 case 'R':
                         {
                         alt5=8;
                         }
                         break;
                 case 'S':
                         {
                         int LA5_5 = input.LA(2);
                         if ( (LA5_5=='E') ) {
                                 alt5=9;
                         }
                         else if ( (LA5_5=='T') ) {
                                 alt5=10;
                         }
 
                         else {
                                 int nvaeMark = input.mark();
                                 try {
                                         input.consume();
                                         NoViableAltException nvae =
                                                 new NoViableAltException("", 5, 5, input);
                                         throw nvae;
                                 } finally {
                                         input.rewind(nvaeMark);
                                 }
                         }
 
                         }
                         break;
                 case 'U':
                         {
                         alt5=11;
                         }
                         break;
                 case 'X':
                         {
                         int LA5_7 = input.LA(2);
                         if ( (LA5_7=='P') ) {
                                 alt5=12;
                         }
                         else if ( (LA5_7=='S') ) {
                                 alt5=13;
                         }
 
                         else {
                                 int nvaeMark = input.mark();
                                 try {
                                         input.consume();
                                         NoViableAltException nvae =
                                                 new NoViableAltException("", 5, 7, input);
                                         throw nvae;
                                 } finally {
                                         input.rewind(nvaeMark);
                                 }
                         }
 
                         }
                         break;
                 case '0':
                 case '1':
                 case '2':
                 case '3':
                 case '4':
                 case '5':
                 case '6':
                 case '7':
                 case '8':
                 case '9':
                         {
                         alt5=14;
                         }
                         break;
                 case ',':
                         {
                         alt5=15;
                         }
                         break;
                 case ':':
                         {
                         alt5=16;
                         }
                         break;
                 case ';':
                         {
                         alt5=17;
                         }
                         break;
                 case '\"':
                 case '\'':
                         {
                         alt5=18;
                         }
                         break;
                 case '\t':
                 case '\n':
                 case '\r':
                 case ' ':
                         {
                         alt5=19;
                         }
                         break;
                 default:
                         NoViableAltException nvae =
                                 new NoViableAltException("", 5, 0, input);
                         throw nvae;
                 }
                 switch (alt5) {
                         case 1 :
                                 // org/xembly/Xembly.g:1:10: T__10
                                 {
                                 mT__10(); 
 
                                 }
                                 break;
                         case 2 :
                                 // org/xembly/Xembly.g:1:16: T__11
                                 {
                                 mT__11(); 
 
                                 }
                                 break;
                         case 3 :
                                 // org/xembly/Xembly.g:1:22: T__12
                                 {
                                 mT__12(); 
 
                                 }
                                 break;
                         case 4 :
                                 // org/xembly/Xembly.g:1:28: T__13
                                 {
                                 mT__13(); 
 
                                 }
                                 break;
                         case 5 :
                                 // org/xembly/Xembly.g:1:34: T__14
                                 {
                                 mT__14(); 
 
                                 }
                                 break;
                         case 6 :
                                 // org/xembly/Xembly.g:1:40: T__15
                                 {
                                 mT__15(); 
 
                                 }
                                 break;
                         case 7 :
                                 // org/xembly/Xembly.g:1:46: T__16
                                 {
                                 mT__16(); 
 
                                 }
                                 break;
                         case 8 :
                                 // org/xembly/Xembly.g:1:52: T__17
                                 {
                                 mT__17(); 
 
                                 }
                                 break;
                         case 9 :
                                 // org/xembly/Xembly.g:1:58: T__18
                                 {
                                 mT__18(); 
 
                                 }
                                 break;
                         case 10 :
                                 // org/xembly/Xembly.g:1:64: T__19
                                 {
                                 mT__19(); 
 
                                 }
                                 break;
                         case 11 :
                                 // org/xembly/Xembly.g:1:70: T__20
                                 {
                                 mT__20(); 
 
                                 }
                                 break;
                         case 12 :
                                 // org/xembly/Xembly.g:1:76: T__21
                                 {
                                 mT__21(); 
 
                                 }
                                 break;
                         case 13 :
                                 // org/xembly/Xembly.g:1:82: T__22
                                 {
                                 mT__22(); 
 
                                 }
                                 break;
                         case 14 :
                                 // org/xembly/Xembly.g:1:88: DIGIT
                                 {
                                 mDIGIT(); 
 
                                 }
                                 break;
                         case 15 :
                                 // org/xembly/Xembly.g:1:94: COMMA
                                 {
                                 mCOMMA(); 
 
                                 }
                                 break;
                         case 16 :
                                 // org/xembly/Xembly.g:1:100: COLON
                                 {
                                 mCOLON(); 
 
                                 }
                                 break;
                         case 17 :
                                 // org/xembly/Xembly.g:1:106: SEMICOLON
                                 {
                                 mSEMICOLON(); 
 
                                 }
                                 break;
                         case 18 :
                                 // org/xembly/Xembly.g:1:116: TEXT
                                 {
                                 mTEXT(); 
 
                                 }
                                 break;
                         case 19 :
                                 // org/xembly/Xembly.g:1:121: SPACE
                                 {
                                 mSPACE(); 
 
                                 }
                                 break;
 
                 }
         }
 
 
 
 }

1		// $ANTLR 3.5.2 org/xembly/Xembly.g 2018-08-10 07:49:40
2
3		package org.xembly;
4
5
6		import org.antlr.runtime.*;
7		import java.util.Stack;
8		import java.util.List;
9		import java.util.ArrayList;
10
11		@SuppressWarnings("all")
12		public class XemblyLexer extends Lexer {
13		public static final int EOF=-1;
14		public static final int T__10=10;
15		public static final int T__11=11;
16		public static final int T__12=12;
17		public static final int T__13=13;
18		public static final int T__14=14;
19		public static final int T__15=15;
20		public static final int T__16=16;
21		public static final int T__17=17;
22		public static final int T__18=18;
23		public static final int T__19=19;
24		public static final int T__20=20;
25		public static final int T__21=21;
26		public static final int T__22=22;
27		public static final int COLON=4;
28		public static final int COMMA=5;
29		public static final int DIGIT=6;
30		public static final int SEMICOLON=7;
31		public static final int SPACE=8;
32		public static final int TEXT=9;
33
34		@Override
35		public void emitErrorMessage(String msg) {
36	1	throw new ParsingException(msg);
37		}
38
39
40		// delegates
41		// delegators
42		public Lexer[] getDelegates() {
43	0	return new Lexer[] {};
44		}
45
46	0	public XemblyLexer() {}
47		public XemblyLexer(CharStream input) {
48	29	this(input, new RecognizerSharedState());
49	29	}
50		public XemblyLexer(CharStream input, RecognizerSharedState state) {
51	29	super(input,state);
52	29	}
53	0	@Override public String getGrammarFileName() { return "org/xembly/Xembly.g"; }
54
55		// $ANTLR start "T__10"
56		public final void mT__10() throws RecognitionException {
57		try {
58	67	int _type = T__10;
59	67	int _channel = DEFAULT_TOKEN_CHANNEL;
60		// org/xembly/Xembly.g:12:7: ( 'ADD' )
61		// org/xembly/Xembly.g:12:9: 'ADD'
62		{
63	67	match("ADD");
64
65		}
66
67	67	state.type = _type;
68	67	state.channel = _channel;
69		}
70		finally {
71		// do for sure before leaving
72		}
73	67	}
74		// $ANTLR end "T__10"
75
76		// $ANTLR start "T__11"
77		public final void mT__11() throws RecognitionException {
78		try {
79	3	int _type = T__11;
80	3	int _channel = DEFAULT_TOKEN_CHANNEL;
81		// org/xembly/Xembly.g:13:7: ( 'ADDIF' )
82		// org/xembly/Xembly.g:13:9: 'ADDIF'
83		{
84	3	match("ADDIF");
85
86		}
87
88	3	state.type = _type;
89	3	state.channel = _channel;
90		}
91		finally {
92		// do for sure before leaving
93		}
94	3	}
95		// $ANTLR end "T__11"
96
97		// $ANTLR start "T__12"
98		public final void mT__12() throws RecognitionException {
99		try {
100	5	int _type = T__12;
101	5	int _channel = DEFAULT_TOKEN_CHANNEL;
102		// org/xembly/Xembly.g:14:7: ( 'ATTR' )
103		// org/xembly/Xembly.g:14:9: 'ATTR'
104		{
105	5	match("ATTR");
106
107		}
108
109	5	state.type = _type;
110	5	state.channel = _channel;
111		}
112		finally {
113		// do for sure before leaving
114		}
115	5	}
116		// $ANTLR end "T__12"
117
118		// $ANTLR start "T__13"
119		public final void mT__13() throws RecognitionException {
120		try {
121	0	int _type = T__13;
122	0	int _channel = DEFAULT_TOKEN_CHANNEL;
123		// org/xembly/Xembly.g:15:7: ( 'CDATA' )
124		// org/xembly/Xembly.g:15:9: 'CDATA'
125		{
126	0	match("CDATA");
127
128		}
129
130	0	state.type = _type;
131	0	state.channel = _channel;
132		}
133		finally {
134		// do for sure before leaving
135		}
136	0	}
137		// $ANTLR end "T__13"
138
139		// $ANTLR start "T__14"
140		public final void mT__14() throws RecognitionException {
141		try {
142	4	int _type = T__14;
143	4	int _channel = DEFAULT_TOKEN_CHANNEL;
144		// org/xembly/Xembly.g:16:7: ( 'PI' )
145		// org/xembly/Xembly.g:16:9: 'PI'
146		{
147	4	match("PI");
148
149		}
150
151	4	state.type = _type;
152	4	state.channel = _channel;
153		}
154		finally {
155		// do for sure before leaving
156		}
157	4	}
158		// $ANTLR end "T__14"
159
160		// $ANTLR start "T__15"
161		public final void mT__15() throws RecognitionException {
162		try {
163	0	int _type = T__15;
164	0	int _channel = DEFAULT_TOKEN_CHANNEL;
165		// org/xembly/Xembly.g:17:7: ( 'POP' )
166		// org/xembly/Xembly.g:17:9: 'POP'
167		{
168	0	match("POP");
169
170		}
171
172	0	state.type = _type;
173	0	state.channel = _channel;
174		}
175		finally {
176		// do for sure before leaving
177		}
178	0	}
179		// $ANTLR end "T__15"
180
181		// $ANTLR start "T__16"
182		public final void mT__16() throws RecognitionException {
183		try {
184	0	int _type = T__16;
185	0	int _channel = DEFAULT_TOKEN_CHANNEL;
186		// org/xembly/Xembly.g:18:7: ( 'PUSH' )
187		// org/xembly/Xembly.g:18:9: 'PUSH'
188		{
189	0	match("PUSH");
190
191		}
192
193	0	state.type = _type;
194	0	state.channel = _channel;
195		}
196		finally {
197		// do for sure before leaving
198		}
199	0	}
200		// $ANTLR end "T__16"
201
202		// $ANTLR start "T__17"
203		public final void mT__17() throws RecognitionException {
204		try {
205	2	int _type = T__17;
206	2	int _channel = DEFAULT_TOKEN_CHANNEL;
207		// org/xembly/Xembly.g:19:7: ( 'REMOVE' )
208		// org/xembly/Xembly.g:19:9: 'REMOVE'
209		{
210	2	match("REMOVE");
211
212		}
213
214	2	state.type = _type;
215	2	state.channel = _channel;
216		}
217		finally {
218		// do for sure before leaving
219		}
220	2	}
221		// $ANTLR end "T__17"
222
223		// $ANTLR start "T__18"
224		public final void mT__18() throws RecognitionException {
225		try {
226	10	int _type = T__18;
227	10	int _channel = DEFAULT_TOKEN_CHANNEL;
228		// org/xembly/Xembly.g:20:7: ( 'SET' )
229		// org/xembly/Xembly.g:20:9: 'SET'
230		{
231	10	match("SET");
232
233		}
234
235	10	state.type = _type;
236	10	state.channel = _channel;
237		}
238		finally {
239		// do for sure before leaving
240		}
241	10	}
242		// $ANTLR end "T__18"
243
244		// $ANTLR start "T__19"
245		public final void mT__19() throws RecognitionException {
246		try {
247	10	int _type = T__19;
248	10	int _channel = DEFAULT_TOKEN_CHANNEL;
249		// org/xembly/Xembly.g:21:7: ( 'STRICT' )
250		// org/xembly/Xembly.g:21:9: 'STRICT'
251		{
252	10	match("STRICT");
253
254		}
255
256	10	state.type = _type;
257	10	state.channel = _channel;
258		}
259		finally {
260		// do for sure before leaving
261		}
262	10	}
263		// $ANTLR end "T__19"
264
265		// $ANTLR start "T__20"
266		public final void mT__20() throws RecognitionException {
267		try {
268	20	int _type = T__20;
269	20	int _channel = DEFAULT_TOKEN_CHANNEL;
270		// org/xembly/Xembly.g:22:7: ( 'UP' )
271		// org/xembly/Xembly.g:22:9: 'UP'
272		{
273	20	match("UP");
274
275		}
276
277	20	state.type = _type;
278	20	state.channel = _channel;
279		}
280		finally {
281		// do for sure before leaving
282		}
283	20	}
284		// $ANTLR end "T__20"
285
286		// $ANTLR start "T__21"
287		public final void mT__21() throws RecognitionException {
288		try {
289	15	int _type = T__21;
290	15	int _channel = DEFAULT_TOKEN_CHANNEL;
291		// org/xembly/Xembly.g:23:7: ( 'XPATH' )
292		// org/xembly/Xembly.g:23:9: 'XPATH'
293		{
294	15	match("XPATH");
295
296		}
297
298	15	state.type = _type;
299	15	state.channel = _channel;
300		}
301		finally {
302		// do for sure before leaving
303		}
304	15	}
305		// $ANTLR end "T__21"
306
307		// $ANTLR start "T__22"
308		public final void mT__22() throws RecognitionException {
309		try {
310	2	int _type = T__22;
311	2	int _channel = DEFAULT_TOKEN_CHANNEL;
312		// org/xembly/Xembly.g:24:7: ( 'XSET' )
313		// org/xembly/Xembly.g:24:9: 'XSET'
314		{
315	2	match("XSET");
316
317		}
318
319	2	state.type = _type;
320	2	state.channel = _channel;
321		}
322		finally {
323		// do for sure before leaving
324		}
325	2	}
326		// $ANTLR end "T__22"
327
328		// $ANTLR start "DIGIT"
329		public final void mDIGIT() throws RecognitionException {
330		try {
331	4	int _type = DIGIT;
332	4	int _channel = DEFAULT_TOKEN_CHANNEL;
333		// org/xembly/Xembly.g:179:6: ( '0' .. '9' )
334		// org/xembly/Xembly.g:
335		{
336	4	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
337	4	input.consume();
338		}
339		else {
340	0	MismatchedSetException mse = new MismatchedSetException(null,input);
341	0	recover(mse);
342	0	throw mse;
343		}
344		}
345
346	4	state.type = _type;
347	4	state.channel = _channel;
348		}
349		finally {
350		// do for sure before leaving
351		}
352	4	}
353		// $ANTLR end "DIGIT"
354
355		// $ANTLR start "COMMA"
356		public final void mCOMMA() throws RecognitionException {
357		try {
358	5	int _type = COMMA;
359	5	int _channel = DEFAULT_TOKEN_CHANNEL;
360		// org/xembly/Xembly.g:180:6: ( ',' )
361		// org/xembly/Xembly.g:180:8: ','
362		{
363	5	match(',');
364		}
365
366	5	state.type = _type;
367	5	state.channel = _channel;
368		}
369		finally {
370		// do for sure before leaving
371		}
372	5	}
373		// $ANTLR end "COMMA"
374
375		// $ANTLR start "COLON"
376		public final void mCOLON() throws RecognitionException {
377		try {
378	3	int _type = COLON;
379	3	int _channel = DEFAULT_TOKEN_CHANNEL;
380		// org/xembly/Xembly.g:181:6: ( ':' )
381		// org/xembly/Xembly.g:181:8: ':'
382		{
383	3	match(':');
384		}
385
386	3	state.type = _type;
387	3	state.channel = _channel;
388		}
389		finally {
390		// do for sure before leaving
391		}
392	3	}
393		// $ANTLR end "COLON"
394
395		// $ANTLR start "SEMICOLON"
396		public final void mSEMICOLON() throws RecognitionException {
397		try {
398	136	int _type = SEMICOLON;
399	136	int _channel = DEFAULT_TOKEN_CHANNEL;
400		// org/xembly/Xembly.g:182:10: ( ';' )
401		// org/xembly/Xembly.g:182:12: ';'
402		{
403	136	match(';');
404		}
405
406	136	state.type = _type;
407	136	state.channel = _channel;
408		}
409		finally {
410		// do for sure before leaving
411		}
412	136	}
413		// $ANTLR end "SEMICOLON"
414
415		// $ANTLR start "TEXT"
416		public final void mTEXT() throws RecognitionException {
417		try {
418	125	int _type = TEXT;
419	125	int _channel = DEFAULT_TOKEN_CHANNEL;
420		// org/xembly/Xembly.g:184:5: ( '\"' (~ '\"' )* '\"' \| '\\'' (~ '\\'' )* '\\'' )
421	125	int alt3=2;
422	125	int LA3_0 = input.LA(1);
423	125	if ( (LA3_0=='\"') ) {
424	29	alt3=1;
425		}
426	96	else if ( (LA3_0=='\'') ) {
427	96	alt3=2;
428		}
429
430		else {
431	0	NoViableAltException nvae =
432		new NoViableAltException("", 3, 0, input);
433	0	throw nvae;
434		}
435
436	125	switch (alt3) {
437		case 1 :
438		// org/xembly/Xembly.g:185:5: '\"' (~ '\"' )* '\"'
439		{
440	29	match('\"');
441		// org/xembly/Xembly.g:185:9: (~ '\"' )*
442		loop1:
443		while (true) {
444	285	int alt1=2;
445	285	int LA1_0 = input.LA(1);
446	285	if ( ((LA1_0 >= '\u0000' && LA1_0 <= '!')\|\|(LA1_0 >= '#' && LA1_0 <= '\uFFFF')) ) {
447	256	alt1=1;
448		}
449
450	285	switch (alt1) {
451		case 1 :
452		// org/xembly/Xembly.g:
453		{
454	256	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')\|\|(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
455	256	input.consume();
456		}
457		else {
458	0	MismatchedSetException mse = new MismatchedSetException(null,input);
459	0	recover(mse);
460	0	throw mse;
461		}
462		}
463		break;
464
465		default :
466	29	break loop1;
467		}
468	256	}
469
470	29	match('\"');
471
472		try {
473	29	this.setText(Arg.unescape(this.getText()));
474	0	} catch (final XmlContentException ex) {
475	0	throw new ParsingException(ex);
476	29	}
477
478		}
479		break;
480		case 2 :
481		// org/xembly/Xembly.g:194:5: '\\'' (~ '\\'' )* '\\''
482		{
483	96	match('\'');
484		// org/xembly/Xembly.g:194:10: (~ '\\'' )*
485		loop2:
486		while (true) {
487	596	int alt2=2;
488	596	int LA2_0 = input.LA(1);
489	596	if ( ((LA2_0 >= '\u0000' && LA2_0 <= '&')\|\|(LA2_0 >= '(' && LA2_0 <= '\uFFFF')) ) {
490	500	alt2=1;
491		}
492
493	596	switch (alt2) {
494		case 1 :
495		// org/xembly/Xembly.g:
496		{
497	500	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '&')\|\|(input.LA(1) >= '(' && input.LA(1) <= '\uFFFF') ) {
498	500	input.consume();
499		}
500		else {
501	0	MismatchedSetException mse = new MismatchedSetException(null,input);
502	0	recover(mse);
503	0	throw mse;
504		}
505		}
506		break;
507
508		default :
509	96	break loop2;
510		}
511	500	}
512
513	96	match('\'');
514
515		try {
516	96	this.setText(Arg.unescape(this.getText()));
517	2	} catch (final XmlContentException ex) {
518	2	throw new ParsingException(ex);
519	94	}
520
521		}
522		break;
523
524		}
525	123	state.type = _type;
526	123	state.channel = _channel;
527		}
528		finally {
529		// do for sure before leaving
530		}
531	123	}
532		// $ANTLR end "TEXT"
533
534		// $ANTLR start "SPACE"
535		public final void mSPACE() throws RecognitionException {
536		try {
537	199	int _type = SPACE;
538	199	int _channel = DEFAULT_TOKEN_CHANNEL;
539		// org/xembly/Xembly.g:204:5: ( ( ' ' \| '\\t' \| '\\n' \| '\\r' )+ )
540		// org/xembly/Xembly.g:205:5: ( ' ' \| '\\t' \| '\\n' \| '\\r' )+
541		{
542		// org/xembly/Xembly.g:205:5: ( ' ' \| '\\t' \| '\\n' \| '\\r' )+
543	199	int cnt4=0;
544		loop4:
545		while (true) {
546	403	int alt4=2;
547	403	int LA4_0 = input.LA(1);
548	403	if ( ((LA4_0 >= '\t' && LA4_0 <= '\n')\|\|LA4_0=='\r'\|\|LA4_0==' ') ) {
549	204	alt4=1;
550		}
551
552	403	switch (alt4) {
553		case 1 :
554		// org/xembly/Xembly.g:
555		{
556	204	if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')\|\|input.LA(1)=='\r'\|\|input.LA(1)==' ' ) {
557	204	input.consume();
558		}
559		else {
560	0	MismatchedSetException mse = new MismatchedSetException(null,input);
561	0	recover(mse);
562	0	throw mse;
563		}
564		}
565		break;
566
567		default :
568	199	if ( cnt4 >= 1 ) break loop4;
569	0	EarlyExitException eee = new EarlyExitException(4, input);
570	0	throw eee;
571		}
572	204	cnt4++;
573	204	}
574
575	199	skip();
576		}
577
578	199	state.type = _type;
579	199	state.channel = _channel;
580		}
581		finally {
582		// do for sure before leaving
583		}
584	199	}
585		// $ANTLR end "SPACE"
586
587		@Override
588		public void mTokens() throws RecognitionException {
589		// org/xembly/Xembly.g:1:8: ( T__10 \| T__11 \| T__12 \| T__13 \| T__14 \| T__15 \| T__16 \| T__17 \| T__18 \| T__19 \| T__20 \| T__21 \| T__22 \| DIGIT \| COMMA \| COLON \| SEMICOLON \| TEXT \| SPACE )
590	611	int alt5=19;
591	611	switch ( input.LA(1) ) {
592		case 'A':
593		{
594	75	int LA5_1 = input.LA(2);
595	75	if ( (LA5_1=='D') ) {
596	70	int LA5_14 = input.LA(3);
597	70	if ( (LA5_14=='D') ) {
598	70	int LA5_23 = input.LA(4);
599	70	if ( (LA5_23=='I') ) {
600	3	alt5=2;
601		}
602
603		else {
604	67	alt5=1;
605		}
606
607	70	}
608
609		else {
610	0	int nvaeMark = input.mark();
611		try {
612	0	for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
613	0	input.consume();
614		}
615	0	NoViableAltException nvae =
616		new NoViableAltException("", 5, 14, input);
617	0	throw nvae;
618		} finally {
619	0	input.rewind(nvaeMark);
620	0	}
621		}
622
623	70	}
624	5	else if ( (LA5_1=='T') ) {
625	5	alt5=3;
626		}
627
628		else {
629	0	int nvaeMark = input.mark();
630		try {
631	0	input.consume();
632	0	NoViableAltException nvae =
633		new NoViableAltException("", 5, 1, input);
634	0	throw nvae;
635		} finally {
636	0	input.rewind(nvaeMark);
637	0	}
638		}
639
640		}
641	75	break;
642		case 'C':
643		{
644	0	alt5=4;
645		}
646	0	break;
647		case 'P':
648		{
649	4	switch ( input.LA(2) ) {
650		case 'I':
651		{
652	4	alt5=5;
653		}
654	4	break;
655		case 'O':
656		{
657	0	alt5=6;
658		}
659	0	break;
660		case 'U':
661		{
662	0	alt5=7;
663		}
664	0	break;
665		default:
666	0	int nvaeMark = input.mark();
667		try {
668	0	input.consume();
669	0	NoViableAltException nvae =
670		new NoViableAltException("", 5, 3, input);
671	0	throw nvae;
672		} finally {
673	0	input.rewind(nvaeMark);
674	0	}
675		}
676		}
677	4	break;
678		case 'R':
679		{
680	2	alt5=8;
681		}
682	2	break;
683		case 'S':
684		{
685	20	int LA5_5 = input.LA(2);
686	20	if ( (LA5_5=='E') ) {
687	10	alt5=9;
688		}
689	10	else if ( (LA5_5=='T') ) {
690	10	alt5=10;
691		}
692
693		else {
694	0	int nvaeMark = input.mark();
695		try {
696	0	input.consume();
697	0	NoViableAltException nvae =
698		new NoViableAltException("", 5, 5, input);
699	0	throw nvae;
700		} finally {
701	0	input.rewind(nvaeMark);
702	0	}
703		}
704
705		}
706	20	break;
707		case 'U':
708		{
709	20	alt5=11;
710		}
711	20	break;
712		case 'X':
713		{
714	17	int LA5_7 = input.LA(2);
715	17	if ( (LA5_7=='P') ) {
716	15	alt5=12;
717		}
718	2	else if ( (LA5_7=='S') ) {
719	2	alt5=13;
720		}
721
722		else {
723	0	int nvaeMark = input.mark();
724		try {
725	0	input.consume();
726	0	NoViableAltException nvae =
727		new NoViableAltException("", 5, 7, input);
728	0	throw nvae;
729		} finally {
730	0	input.rewind(nvaeMark);
731	0	}
732		}
733
734		}
735	17	break;
736		case '0':
737		case '1':
738		case '2':
739		case '3':
740		case '4':
741		case '5':
742		case '6':
743		case '7':
744		case '8':
745		case '9':
746		{
747	4	alt5=14;
748		}
749	4	break;
750		case ',':
751		{
752	5	alt5=15;
753		}
754	5	break;
755		case ':':
756		{
757	3	alt5=16;
758		}
759	3	break;
760		case ';':
761		{
762	136	alt5=17;
763		}
764	136	break;
765		case '\"':
766		case '\'':
767		{
768	125	alt5=18;
769		}
770	125	break;
771		case '\t':
772		case '\n':
773		case '\r':
774		case ' ':
775		{
776	199	alt5=19;
777		}
778	199	break;
779		default:
780	1	NoViableAltException nvae =
781		new NoViableAltException("", 5, 0, input);
782	1	throw nvae;
783		}
784	610	switch (alt5) {
785		case 1 :
786		// org/xembly/Xembly.g:1:10: T__10
787		{
788	67	mT__10();
789
790		}
791	67	break;
792		case 2 :
793		// org/xembly/Xembly.g:1:16: T__11
794		{
795	3	mT__11();
796
797		}
798	3	break;
799		case 3 :
800		// org/xembly/Xembly.g:1:22: T__12
801		{
802	5	mT__12();
803
804		}
805	5	break;
806		case 4 :
807		// org/xembly/Xembly.g:1:28: T__13
808		{
809	0	mT__13();
810
811		}
812	0	break;
813		case 5 :
814		// org/xembly/Xembly.g:1:34: T__14
815		{
816	4	mT__14();
817
818		}
819	4	break;
820		case 6 :
821		// org/xembly/Xembly.g:1:40: T__15
822		{
823	0	mT__15();
824
825		}
826	0	break;
827		case 7 :
828		// org/xembly/Xembly.g:1:46: T__16
829		{
830	0	mT__16();
831
832		}
833	0	break;
834		case 8 :
835		// org/xembly/Xembly.g:1:52: T__17
836		{
837	2	mT__17();
838
839		}
840	2	break;
841		case 9 :
842		// org/xembly/Xembly.g:1:58: T__18
843		{
844	10	mT__18();
845
846		}
847	10	break;
848		case 10 :
849		// org/xembly/Xembly.g:1:64: T__19
850		{
851	10	mT__19();
852
853		}
854	10	break;
855		case 11 :
856		// org/xembly/Xembly.g:1:70: T__20
857		{
858	20	mT__20();
859
860		}
861	20	break;
862		case 12 :
863		// org/xembly/Xembly.g:1:76: T__21
864		{
865	15	mT__21();
866
867		}
868	15	break;
869		case 13 :
870		// org/xembly/Xembly.g:1:82: T__22
871		{
872	2	mT__22();
873
874		}
875	2	break;
876		case 14 :
877		// org/xembly/Xembly.g:1:88: DIGIT
878		{
879	4	mDIGIT();
880
881		}
882	4	break;
883		case 15 :
884		// org/xembly/Xembly.g:1:94: COMMA
885		{
886	5	mCOMMA();
887
888		}
889	5	break;
890		case 16 :
891		// org/xembly/Xembly.g:1:100: COLON
892		{
893	3	mCOLON();
894
895		}
896	3	break;
897		case 17 :
898		// org/xembly/Xembly.g:1:106: SEMICOLON
899		{
900	136	mSEMICOLON();
901
902		}
903	136	break;
904		case 18 :
905		// org/xembly/Xembly.g:1:116: TEXT
906		{
907	125	mTEXT();
908
909		}
910	123	break;
911		case 19 :
912		// org/xembly/Xembly.g:1:121: SPACE
913		{
914	199	mSPACE();
915
916		}
917		break;
918
919		}
920	608	}
921
922
923
924		}