org.jdbi/jdbi3-core/3.3.0 : org/jdbi/v3/core/internal/lexer/DefineStatementLexer.java

DefineStatementLexer
http://jdbi.org/: jdbi is designed to provide convenient tabular data access in Java(tm). It uses the Java collections framework for query results, provides a convenient means of externalizing sql statements, and provides named parameter support for any database being used.
Apache License 2.0
// $ANTLR 3.4 org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g 2018-06-14 00:08:12

    package org.jdbi.v3.core.internal.lexer;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class DefineStatementLexer extends Lexer {
    public static final int EOF=-1;
    public static final int COMMENT=4;
    public static final int DEFINE=5;
    public static final int DOUBLE_QUOTE=6;
    public static final int DOUBLE_QUOTED_TEXT=7;
    public static final int ESCAPE=8;
    public static final int ESCAPED_TEXT=9;
    public static final int ESCAPE_QUOTE=10;
    public static final int GT=11;
    public static final int LITERAL=12;
    public static final int LT=13;
    public static final int NAME=14;
    public static final int QUOTE=15;
    public static final int QUOTED_TEXT=16;

      @Override
      public void reportError(RecognitionException e) {
        throw new IllegalArgumentException(e);
      }


    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public DefineStatementLexer() {} 
    public DefineStatementLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public DefineStatementLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g"; }

    public Token nextToken() {
        while (true) {
            if ( input.LA(1)==CharStream.EOF ) {
                Token eof = new CommonToken((CharStream)input,Token.EOF,
                                            Token.DEFAULT_CHANNEL,
                                            input.index(),input.index());
                eof.setLine(getLine());
                eof.setCharPositionInLine(getCharPositionInLine());
                return eof;
            }
            state.token = null;
    	state.channel = Token.DEFAULT_CHANNEL;
            state.tokenStartCharIndex = input.index();
            state.tokenStartCharPositionInLine = input.getCharPositionInLine();
            state.tokenStartLine = input.getLine();
    	state.text = null;
            try {
                int m = input.mark();
                state.backtracking=1; 
                state.failed=false;
                mTokens();
                state.backtracking=0;
                if ( state.failed ) {
                    input.rewind(m);
                    input.consume(); 
                }
                else {
                    emit();
                    return state.token;
                }
            }
            catch (RecognitionException re) {
                // shouldn't happen in backtracking mode, but...
                reportError(re);
                recover(re);
            }
        }
    }

    public void memoize(IntStream input,
    		int ruleIndex,
    		int ruleStartIndex)
    {
    if ( state.backtracking>1 ) super.memoize(input, ruleIndex, ruleStartIndex);
    }

    public boolean alreadyParsedRule(IntStream input, int ruleIndex) {
    if ( state.backtracking>1 ) return super.alreadyParsedRule(input, ruleIndex);
    return false;
    }
    // $ANTLR start "QUOTE"
    public final void mQUOTE() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:15:15: ( '\\'' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:15:17: '\\''
            {
            match('\''); if (state.failed) return ;

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "QUOTE"

    // $ANTLR start "ESCAPE"
    public final void mESCAPE() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:16:16: ( '\\\\' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:16:18: '\\\\'
            {
            match('\\'); if (state.failed) return ;

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESCAPE"

    // $ANTLR start "ESCAPE_QUOTE"
    public final void mESCAPE_QUOTE() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:17:22: ( ESCAPE QUOTE )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:17:24: ESCAPE QUOTE
            {
            mESCAPE(); if (state.failed) return ;


            mQUOTE(); if (state.failed) return ;


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESCAPE_QUOTE"

    // $ANTLR start "DOUBLE_QUOTE"
    public final void mDOUBLE_QUOTE() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:18:22: ( '\"' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:18:24: '\"'
            {
            match('\"'); if (state.failed) return ;

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLE_QUOTE"

    // $ANTLR start "LT"
    public final void mLT() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:19:12: ( '<' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:19:14: '<'
            {
            match('<'); if (state.failed) return ;

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LT"

    // $ANTLR start "GT"
    public final void mGT() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:20:12: ( '>' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:20:14: '>'
            {
            match('>'); if (state.failed) return ;

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "GT"

    // $ANTLR start "NAME"
    public final void mNAME() throws RecognitionException {
        try {
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:21:14: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:
            {
            if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NAME"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:23:8: ( '/*' ( . )* '*/' )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:23:10: '/*' ( . )* '*/'
            {
            match("/*"); if (state.failed) return ;



            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:23:15: ( . )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0=='*') ) {
                    int LA1_1 = input.LA(2);

                    if ( (LA1_1=='/') ) {
                        alt1=2;
                    }
                    else if ( ((LA1_1 >= '\u0000' && LA1_1 <= '.')||(LA1_1 >= '0' && LA1_1 <= '\uFFFF')) ) {
                        alt1=1;
                    }


                }
                else if ( ((LA1_0 >= '\u0000' && LA1_0 <= ')')||(LA1_0 >= '+' && LA1_0 <= '\uFFFF')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:23:15: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            match("*/"); if (state.failed) return ;



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMMENT"

    // $ANTLR start "QUOTED_TEXT"
    public final void mQUOTED_TEXT() throws RecognitionException {
        try {
            int _type = QUOTED_TEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:24:12: ( QUOTE ( ESCAPE_QUOTE |~ QUOTE )* QUOTE )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:24:14: QUOTE ( ESCAPE_QUOTE |~ QUOTE )* QUOTE
            {
            mQUOTE(); if (state.failed) return ;


            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:24:20: ( ESCAPE_QUOTE |~ QUOTE )*
            loop2:
            do {
                int alt2=3;
                int LA2_0 = input.LA(1);

                if ( (LA2_0=='\\') ) {
                    int LA2_2 = input.LA(2);

                    if ( (LA2_2=='\'') ) {
                        int LA2_4 = input.LA(3);

                        if ( ((LA2_4 >= '\u0000' && LA2_4 <= '\uFFFF')) ) {
                            alt2=1;
                        }

                        else {
                            alt2=2;
                        }


                    }
                    else if ( ((LA2_2 >= '\u0000' && LA2_2 <= '&')||(LA2_2 >= '(' && LA2_2 <= '\uFFFF')) ) {
                        alt2=2;
                    }


                }
                else if ( ((LA2_0 >= '\u0000' && LA2_0 <= '&')||(LA2_0 >= '(' && LA2_0 <= '[')||(LA2_0 >= ']' && LA2_0 <= '\uFFFF')) ) {
                    alt2=2;
                }


                switch (alt2) {
            	case 1 :
            	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:24:21: ESCAPE_QUOTE
            	    {
            	    mESCAPE_QUOTE(); if (state.failed) return ;


            	    }
            	    break;
            	case 2 :
            	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:24:36: ~ QUOTE
            	    {
            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\u000E')||(input.LA(1) >= '\u0010' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            mQUOTE(); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "QUOTED_TEXT"

    // $ANTLR start "DOUBLE_QUOTED_TEXT"
    public final void mDOUBLE_QUOTED_TEXT() throws RecognitionException {
        try {
            int _type = DOUBLE_QUOTED_TEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:25:19: ( DOUBLE_QUOTE (~ DOUBLE_QUOTE )+ DOUBLE_QUOTE )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:25:21: DOUBLE_QUOTE (~ DOUBLE_QUOTE )+ DOUBLE_QUOTE
            {
            mDOUBLE_QUOTE(); if (state.failed) return ;


            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:25:34: (~ DOUBLE_QUOTE )+
            int cnt3=0;
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0 >= '\u0000' && LA3_0 <= '!')||(LA3_0 >= '#' && LA3_0 <= '\uFFFF')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:
            	    {
            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);


            mDOUBLE_QUOTE(); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLE_QUOTED_TEXT"

    // $ANTLR start "ESCAPED_TEXT"
    public final void mESCAPED_TEXT() throws RecognitionException {
        try {
            int _type = ESCAPED_TEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:26:14: ( ESCAPE . )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:26:16: ESCAPE .
            {
            mESCAPE(); if (state.failed) return ;


            matchAny(); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESCAPED_TEXT"

    // $ANTLR start "DEFINE"
    public final void mDEFINE() throws RecognitionException {
        try {
            int _type = DEFINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:28:7: ( LT ( NAME )+ GT )
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:28:9: LT ( NAME )+ GT
            {
            mLT(); if (state.failed) return ;


            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:28:12: ( NAME )+
            int cnt4=0;
            loop4:
            do {
                int alt4=2;
                switch ( input.LA(1) ) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'P':
                case 'Q':
                case 'R':
                case 'S':
                case 'T':
                case 'U':
                case 'V':
                case 'W':
                case 'X':
                case 'Y':
                case 'Z':
                case '_':
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'w':
                case 'x':
                case 'y':
                case 'z':
                    {
                    alt4=1;
                    }
                    break;

                }

                switch (alt4) {
            	case 1 :
            	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt4 >= 1 ) break loop4;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(4, input);
                        throw eee;
                }
                cnt4++;
            } while (true);


            mGT(); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DEFINE"

    // $ANTLR start "LITERAL"
    public final void mLITERAL() throws RecognitionException {
        try {
            int _type = LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:30:8: ( ( NAME | ' ' | '\\t' | '\\n' | '\\r' | ',' | '#' | '.' | '@' | '!' | '?' | '=' | ':' | ';' | '(' | ')' | '[' | ']' | '+' | '-' | '%' | '&' | '^' | '|' | '$' | '~' | '{' | '}' | '`' )+ | GT | LT | '*' | '/' )
            int alt6=5;
            switch ( input.LA(1) ) {
            case '\t':
            case '\n':
            case '\r':
            case ' ':
            case '!':
            case '#':
            case '$':
            case '%':
            case '&':
            case '(':
            case ')':
            case '+':
            case ',':
            case '-':
            case '.':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case ':':
            case ';':
            case '=':
            case '?':
            case '@':
            case 'A':
            case 'B':
            case 'C':
            case 'D':
            case 'E':
            case 'F':
            case 'G':
            case 'H':
            case 'I':
            case 'J':
            case 'K':
            case 'L':
            case 'M':
            case 'N':
            case 'O':
            case 'P':
            case 'Q':
            case 'R':
            case 'S':
            case 'T':
            case 'U':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            case 'Z':
            case '[':
            case ']':
            case '^':
            case '_':
            case '`':
            case 'a':
            case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
            case 'g':
            case 'h':
            case 'i':
            case 'j':
            case 'k':
            case 'l':
            case 'm':
            case 'n':
            case 'o':
            case 'p':
            case 'q':
            case 'r':
            case 's':
            case 't':
            case 'u':
            case 'v':
            case 'w':
            case 'x':
            case 'y':
            case 'z':
            case '{':
            case '|':
            case '}':
            case '~':
                {
                alt6=1;
                }
                break;
            case '>':
                {
                alt6=2;
                }
                break;
            case '<':
                {
                alt6=3;
                }
                break;
            case '*':
                {
                alt6=4;
                }
                break;
            case '/':
                {
                alt6=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }

            switch (alt6) {
                case 1 :
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:30:10: ( NAME | ' ' | '\\t' | '\\n' | '\\r' | ',' | '#' | '.' | '@' | '!' | '?' | '=' | ':' | ';' | '(' | ')' | '[' | ']' | '+' | '-' | '%' | '&' | '^' | '|' | '$' | '~' | '{' | '}' | '`' )+
                    {
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:30:10: ( NAME | ' ' | '\\t' | '\\n' | '\\r' | ',' | '#' | '.' | '@' | '!' | '?' | '=' | ':' | ';' | '(' | ')' | '[' | ']' | '+' | '-' | '%' | '&' | '^' | '|' | '$' | '~' | '{' | '}' | '`' )+
                    int cnt5=0;
                    loop5:
                    do {
                        int alt5=2;
                        switch ( input.LA(1) ) {
                        case '\t':
                        case '\n':
                        case '\r':
                        case ' ':
                        case '!':
                        case '#':
                        case '$':
                        case '%':
                        case '&':
                        case '(':
                        case ')':
                        case '+':
                        case ',':
                        case '-':
                        case '.':
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                        case ':':
                        case ';':
                        case '=':
                        case '?':
                        case '@':
                        case 'A':
                        case 'B':
                        case 'C':
                        case 'D':
                        case 'E':
                        case 'F':
                        case 'G':
                        case 'H':
                        case 'I':
                        case 'J':
                        case 'K':
                        case 'L':
                        case 'M':
                        case 'N':
                        case 'O':
                        case 'P':
                        case 'Q':
                        case 'R':
                        case 'S':
                        case 'T':
                        case 'U':
                        case 'V':
                        case 'W':
                        case 'X':
                        case 'Y':
                        case 'Z':
                        case '[':
                        case ']':
                        case '^':
                        case '_':
                        case '`':
                        case 'a':
                        case 'b':
                        case 'c':
                        case 'd':
                        case 'e':
                        case 'f':
                        case 'g':
                        case 'h':
                        case 'i':
                        case 'j':
                        case 'k':
                        case 'l':
                        case 'm':
                        case 'n':
                        case 'o':
                        case 'p':
                        case 'q':
                        case 'r':
                        case 's':
                        case 't':
                        case 'u':
                        case 'v':
                        case 'w':
                        case 'x':
                        case 'y':
                        case 'z':
                        case '{':
                        case '|':
                        case '}':
                        case '~':
                            {
                            alt5=1;
                            }
                            break;

                        }

                        switch (alt5) {
                    	case 1 :
                    	    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:
                    	    {
                    	    if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||input.LA(1)=='\r'||(input.LA(1) >= ' ' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= ')')||(input.LA(1) >= '+' && input.LA(1) <= '.')||(input.LA(1) >= '0' && input.LA(1) <= ';')||input.LA(1)=='='||(input.LA(1) >= '?' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '~') ) {
                    	        input.consume();
                    	        state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt5 >= 1 ) break loop5;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(5, input);
                                throw eee;
                        }
                        cnt5++;
                    } while (true);


                    }
                    break;
                case 2 :
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:31:92: GT
                    {
                    mGT(); if (state.failed) return ;


                    }
                    break;
                case 3 :
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:31:97: LT
                    {
                    mLT(); if (state.failed) return ;


                    }
                    break;
                case 4 :
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:31:102: '*'
                    {
                    match('*'); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:31:108: '/'
                    {
                    match('/'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LITERAL"

    public void mTokens() throws RecognitionException {
        // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:39: ( COMMENT | QUOTED_TEXT | DOUBLE_QUOTED_TEXT | ESCAPED_TEXT | DEFINE | LITERAL )
        int alt7=6;
        switch ( input.LA(1) ) {
        case '/':
            {
            int LA7_1 = input.LA(2);

            if ( (synpred1_DefineStatementLexer()) ) {
                alt7=1;
            }
            else if ( (true) ) {
                alt7=6;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 1, input);

                throw nvae;

            }
            }
            break;
        case '\'':
            {
            alt7=2;
            }
            break;
        case '\"':
            {
            alt7=3;
            }
            break;
        case '\\':
            {
            alt7=4;
            }
            break;
        case '<':
            {
            int LA7_7 = input.LA(2);

            if ( (synpred5_DefineStatementLexer()) ) {
                alt7=5;
            }
            else if ( (true) ) {
                alt7=6;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 7, input);

                throw nvae;

            }
            }
            break;
        case '\t':
        case '\n':
        case '\r':
        case ' ':
        case '!':
        case '#':
        case '$':
        case '%':
        case '&':
        case '(':
        case ')':
        case '*':
        case '+':
        case ',':
        case '-':
        case '.':
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
        case ':':
        case ';':
        case '=':
        case '>':
        case '?':
        case '@':
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'G':
        case 'H':
        case 'I':
        case 'J':
        case 'K':
        case 'L':
        case 'M':
        case 'N':
        case 'O':
        case 'P':
        case 'Q':
        case 'R':
        case 'S':
        case 'T':
        case 'U':
        case 'V':
        case 'W':
        case 'X':
        case 'Y':
        case 'Z':
        case '[':
        case ']':
        case '^':
        case '_':
        case '`':
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
        case 'g':
        case 'h':
        case 'i':
        case 'j':
        case 'k':
        case 'l':
        case 'm':
        case 'n':
        case 'o':
        case 'p':
        case 'q':
        case 'r':
        case 's':
        case 't':
        case 'u':
        case 'v':
        case 'w':
        case 'x':
        case 'y':
        case 'z':
        case '{':
        case '|':
        case '}':
        case '~':
            {
            alt7=6;
            }
            break;
        default:
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 7, 0, input);

            throw nvae;

        }

        switch (alt7) {
            case 1 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:41: COMMENT
                {
                mCOMMENT(); if (state.failed) return ;


                }
                break;
            case 2 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:49: QUOTED_TEXT
                {
                mQUOTED_TEXT(); if (state.failed) return ;


                }
                break;
            case 3 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:61: DOUBLE_QUOTED_TEXT
                {
                mDOUBLE_QUOTED_TEXT(); if (state.failed) return ;


                }
                break;
            case 4 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:80: ESCAPED_TEXT
                {
                mESCAPED_TEXT(); if (state.failed) return ;


                }
                break;
            case 5 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:93: DEFINE
                {
                mDEFINE(); if (state.failed) return ;


                }
                break;
            case 6 :
                // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:100: LITERAL
                {
                mLITERAL(); if (state.failed) return ;


                }
                break;

        }

    }

    // $ANTLR start synpred1_DefineStatementLexer
    public final void synpred1_DefineStatementLexer_fragment() throws RecognitionException {
        // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:41: ( COMMENT )
        // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:41: COMMENT
        {
        mCOMMENT(); if (state.failed) return ;


        }

    }
    // $ANTLR end synpred1_DefineStatementLexer

    // $ANTLR start synpred5_DefineStatementLexer
    public final void synpred5_DefineStatementLexer_fragment() throws RecognitionException {
        // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:93: ( DEFINE )
        // org/jdbi/v3/core/internal/lexer/DefineStatementLexer.g:1:93: DEFINE
        {
        mDEFINE(); if (state.failed) return ;


        }

    }
    // $ANTLR end synpred5_DefineStatementLexer

    public final boolean synpred1_DefineStatementLexer() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred1_DefineStatementLexer_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred5_DefineStatementLexer() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred5_DefineStatementLexer_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


 

}
/

org.jdbi/ jdbi3-core/ 3.3.0/ org/jdbi/v3/core/internal/lexer/DefineStatementLexer.java
