org.apache.cassandra.cql3.Cql_Lexer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-all Show documentation
Show all versions of cassandra-all Show documentation
The Apache Cassandra Project develops a highly scalable second-generation distributed database, bringing together Dynamo's fully distributed design and Bigtable's ColumnFamily-based data model.
// $ANTLR 3.5.2 Lexer.g 2023-12-01 14:10:30
package org.apache.cassandra.cql3;
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")
public class Cql_Lexer extends Lexer {
public static final int EOF=-1;
public static final int T__207=207;
public static final int T__208=208;
public static final int T__209=209;
public static final int T__210=210;
public static final int T__211=211;
public static final int T__212=212;
public static final int T__213=213;
public static final int T__214=214;
public static final int T__215=215;
public static final int T__216=216;
public static final int T__217=217;
public static final int T__218=218;
public static final int T__219=219;
public static final int T__220=220;
public static final int T__221=221;
public static final int T__222=222;
public static final int T__223=223;
public static final int T__224=224;
public static final int T__225=225;
public static final int T__226=226;
public static final int T__227=227;
public static final int T__228=228;
public static final int T__229=229;
public static final int T__230=230;
public static final int A=4;
public static final int B=5;
public static final int BOOLEAN=6;
public static final int C=7;
public static final int COMMENT=8;
public static final int D=9;
public static final int DIGIT=10;
public static final int DURATION=11;
public static final int DURATION_ISO_8601_PERIOD_DESIGNATORS=12;
public static final int DURATION_ISO_8601_TIME_DESIGNATORS=13;
public static final int DURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR=14;
public static final int DURATION_UNIT=15;
public static final int E=16;
public static final int EMPTY_QUOTED_NAME=17;
public static final int EXPONENT=18;
public static final int F=19;
public static final int FLOAT=20;
public static final int G=21;
public static final int H=22;
public static final int HEX=23;
public static final int HEXNUMBER=24;
public static final int I=25;
public static final int IDENT=26;
public static final int INTEGER=27;
public static final int J=28;
public static final int K=29;
public static final int K_ACCESS=30;
public static final int K_ADD=31;
public static final int K_AGGREGATE=32;
public static final int K_AGGREGATES=33;
public static final int K_ALL=34;
public static final int K_ALLOW=35;
public static final int K_ALTER=36;
public static final int K_AND=37;
public static final int K_ANN=38;
public static final int K_APPLY=39;
public static final int K_AS=40;
public static final int K_ASC=41;
public static final int K_ASCII=42;
public static final int K_AUTHORIZE=43;
public static final int K_BATCH=44;
public static final int K_BEGIN=45;
public static final int K_BIGINT=46;
public static final int K_BLOB=47;
public static final int K_BOOLEAN=48;
public static final int K_BY=49;
public static final int K_CALLED=50;
public static final int K_CAST=51;
public static final int K_CIDRS=52;
public static final int K_CLUSTER=53;
public static final int K_CLUSTERING=54;
public static final int K_COLUMNFAMILY=55;
public static final int K_COMPACT=56;
public static final int K_CONTAINS=57;
public static final int K_COUNT=58;
public static final int K_COUNTER=59;
public static final int K_CREATE=60;
public static final int K_CUSTOM=61;
public static final int K_DATACENTERS=62;
public static final int K_DATE=63;
public static final int K_DECIMAL=64;
public static final int K_DEFAULT=65;
public static final int K_DELETE=66;
public static final int K_DESC=67;
public static final int K_DESCRIBE=68;
public static final int K_DISTINCT=69;
public static final int K_DOUBLE=70;
public static final int K_DROP=71;
public static final int K_DURATION=72;
public static final int K_ENTRIES=73;
public static final int K_EXECUTE=74;
public static final int K_EXISTS=75;
public static final int K_FILTERING=76;
public static final int K_FINALFUNC=77;
public static final int K_FLOAT=78;
public static final int K_FROM=79;
public static final int K_FROZEN=80;
public static final int K_FULL=81;
public static final int K_FUNCTION=82;
public static final int K_FUNCTIONS=83;
public static final int K_GRANT=84;
public static final int K_GROUP=85;
public static final int K_HASHED=86;
public static final int K_IDENTITY=87;
public static final int K_IF=88;
public static final int K_IN=89;
public static final int K_INDEX=90;
public static final int K_INET=91;
public static final int K_INITCOND=92;
public static final int K_INPUT=93;
public static final int K_INSERT=94;
public static final int K_INT=95;
public static final int K_INTERNALS=96;
public static final int K_INTO=97;
public static final int K_IS=98;
public static final int K_JSON=99;
public static final int K_KEY=100;
public static final int K_KEYS=101;
public static final int K_KEYSPACE=102;
public static final int K_KEYSPACES=103;
public static final int K_LANGUAGE=104;
public static final int K_LIKE=105;
public static final int K_LIMIT=106;
public static final int K_LIST=107;
public static final int K_LOGIN=108;
public static final int K_MAP=109;
public static final int K_MASKED=110;
public static final int K_MATERIALIZED=111;
public static final int K_MAXWRITETIME=112;
public static final int K_MBEAN=113;
public static final int K_MBEANS=114;
public static final int K_MODIFY=115;
public static final int K_NEGATIVE_INFINITY=116;
public static final int K_NEGATIVE_NAN=117;
public static final int K_NOLOGIN=118;
public static final int K_NORECURSIVE=119;
public static final int K_NOSUPERUSER=120;
public static final int K_NOT=121;
public static final int K_NULL=122;
public static final int K_OF=123;
public static final int K_ON=124;
public static final int K_ONLY=125;
public static final int K_OPTIONS=126;
public static final int K_OR=127;
public static final int K_ORDER=128;
public static final int K_PARTITION=129;
public static final int K_PASSWORD=130;
public static final int K_PER=131;
public static final int K_PERMISSION=132;
public static final int K_PERMISSIONS=133;
public static final int K_POSITIVE_INFINITY=134;
public static final int K_POSITIVE_NAN=135;
public static final int K_PRIMARY=136;
public static final int K_RENAME=137;
public static final int K_REPLACE=138;
public static final int K_RETURNS=139;
public static final int K_REVOKE=140;
public static final int K_ROLE=141;
public static final int K_ROLES=142;
public static final int K_SCHEMA=143;
public static final int K_SELECT=144;
public static final int K_SELECT_MASKED=145;
public static final int K_SET=146;
public static final int K_SFUNC=147;
public static final int K_SMALLINT=148;
public static final int K_STATIC=149;
public static final int K_STORAGE=150;
public static final int K_STYPE=151;
public static final int K_SUPERUSER=152;
public static final int K_TABLES=153;
public static final int K_TEXT=154;
public static final int K_TIME=155;
public static final int K_TIMESTAMP=156;
public static final int K_TIMEUUID=157;
public static final int K_TINYINT=158;
public static final int K_TO=159;
public static final int K_TOKEN=160;
public static final int K_TRIGGER=161;
public static final int K_TRUNCATE=162;
public static final int K_TTL=163;
public static final int K_TUPLE=164;
public static final int K_TYPE=165;
public static final int K_TYPES=166;
public static final int K_UNLOGGED=167;
public static final int K_UNMASK=168;
public static final int K_UNSET=169;
public static final int K_UPDATE=170;
public static final int K_USE=171;
public static final int K_USER=172;
public static final int K_USERS=173;
public static final int K_USING=174;
public static final int K_UUID=175;
public static final int K_VALUES=176;
public static final int K_VARCHAR=177;
public static final int K_VARINT=178;
public static final int K_VECTOR=179;
public static final int K_VIEW=180;
public static final int K_WHERE=181;
public static final int K_WITH=182;
public static final int K_WRITETIME=183;
public static final int L=184;
public static final int LETTER=185;
public static final int M=186;
public static final int MULTILINE_COMMENT=187;
public static final int N=188;
public static final int O=189;
public static final int P=190;
public static final int Q=191;
public static final int QMARK=192;
public static final int QUOTED_NAME=193;
public static final int R=194;
public static final int RANGE=195;
public static final int S=196;
public static final int STRING_LITERAL=197;
public static final int T=198;
public static final int U=199;
public static final int UUID=200;
public static final int V=201;
public static final int W=202;
public static final int WS=203;
public static final int X=204;
public static final int Y=205;
public static final int Z=206;
public static final int Tokens=231;
List tokens = new ArrayList();
public void emit(Token token)
{
state.token = token;
tokens.add(token);
}
public Token nextToken()
{
super.nextToken();
if (tokens.size() == 0)
return new CommonToken(Token.EOF);
return tokens.remove(0);
}
private final List listeners = new ArrayList();
public void addErrorListener(ErrorListener listener)
{
this.listeners.add(listener);
}
public void removeErrorListener(ErrorListener listener)
{
this.listeners.remove(listener);
}
public void displayRecognitionError(String[] tokenNames, RecognitionException e)
{
for (int i = 0, m = listeners.size(); i < m; i++)
listeners.get(i).syntaxError(this, tokenNames, e);
}
// delegates
// delegators
public CqlLexer gCql;
public CqlLexer gParent;
public Lexer[] getDelegates() {
return new Lexer[] {};
}
public Cql_Lexer() {}
public Cql_Lexer(CharStream input, CqlLexer gCql) {
this(input, new RecognizerSharedState(), gCql);
}
public Cql_Lexer(CharStream input, RecognizerSharedState state, CqlLexer gCql) {
super(input,state);
this.gCql = gCql;
gParent = gCql;
}
@Override public String getGrammarFileName() { return "Lexer.g"; }
// $ANTLR start "K_SELECT"
public final void mK_SELECT() throws RecognitionException {
try {
int _type = K_SELECT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:62:9: ( S E L E C T )
// Lexer.g:62:16: S E L E C T
{
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SELECT"
// $ANTLR start "K_FROM"
public final void mK_FROM() throws RecognitionException {
try {
int _type = K_FROM;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:63:7: ( F R O M )
// Lexer.g:63:16: F R O M
{
mF(); if (state.failed) return;
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mM(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FROM"
// $ANTLR start "K_AS"
public final void mK_AS() throws RecognitionException {
try {
int _type = K_AS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:64:5: ( A S )
// Lexer.g:64:16: A S
{
mA(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_AS"
// $ANTLR start "K_WHERE"
public final void mK_WHERE() throws RecognitionException {
try {
int _type = K_WHERE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:65:8: ( W H E R E )
// Lexer.g:65:16: W H E R E
{
mW(); if (state.failed) return;
mH(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_WHERE"
// $ANTLR start "K_AND"
public final void mK_AND() throws RecognitionException {
try {
int _type = K_AND;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:66:6: ( A N D )
// Lexer.g:66:16: A N D
{
mA(); if (state.failed) return;
mN(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_AND"
// $ANTLR start "K_KEY"
public final void mK_KEY() throws RecognitionException {
try {
int _type = K_KEY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:67:6: ( K E Y )
// Lexer.g:67:16: K E Y
{
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_KEY"
// $ANTLR start "K_KEYS"
public final void mK_KEYS() throws RecognitionException {
try {
int _type = K_KEYS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:68:7: ( K E Y S )
// Lexer.g:68:16: K E Y S
{
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mY(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_KEYS"
// $ANTLR start "K_ENTRIES"
public final void mK_ENTRIES() throws RecognitionException {
try {
int _type = K_ENTRIES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:69:10: ( E N T R I E S )
// Lexer.g:69:16: E N T R I E S
{
mE(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ENTRIES"
// $ANTLR start "K_FULL"
public final void mK_FULL() throws RecognitionException {
try {
int _type = K_FULL;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:70:7: ( F U L L )
// Lexer.g:70:16: F U L L
{
mF(); if (state.failed) return;
mU(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FULL"
// $ANTLR start "K_INSERT"
public final void mK_INSERT() throws RecognitionException {
try {
int _type = K_INSERT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:71:9: ( I N S E R T )
// Lexer.g:71:16: I N S E R T
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INSERT"
// $ANTLR start "K_UPDATE"
public final void mK_UPDATE() throws RecognitionException {
try {
int _type = K_UPDATE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:72:9: ( U P D A T E )
// Lexer.g:72:16: U P D A T E
{
mU(); if (state.failed) return;
mP(); if (state.failed) return;
mD(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_UPDATE"
// $ANTLR start "K_WITH"
public final void mK_WITH() throws RecognitionException {
try {
int _type = K_WITH;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:73:7: ( W I T H )
// Lexer.g:73:16: W I T H
{
mW(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mH(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_WITH"
// $ANTLR start "K_LIMIT"
public final void mK_LIMIT() throws RecognitionException {
try {
int _type = K_LIMIT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:74:8: ( L I M I T )
// Lexer.g:74:16: L I M I T
{
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_LIMIT"
// $ANTLR start "K_PER"
public final void mK_PER() throws RecognitionException {
try {
int _type = K_PER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:75:6: ( P E R )
// Lexer.g:75:16: P E R
{
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PER"
// $ANTLR start "K_PARTITION"
public final void mK_PARTITION() throws RecognitionException {
try {
int _type = K_PARTITION;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:76:12: ( P A R T I T I O N )
// Lexer.g:76:16: P A R T I T I O N
{
mP(); if (state.failed) return;
mA(); if (state.failed) return;
mR(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PARTITION"
// $ANTLR start "K_USING"
public final void mK_USING() throws RecognitionException {
try {
int _type = K_USING;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:77:8: ( U S I N G )
// Lexer.g:77:16: U S I N G
{
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mG(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_USING"
// $ANTLR start "K_USE"
public final void mK_USE() throws RecognitionException {
try {
int _type = K_USE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:78:6: ( U S E )
// Lexer.g:78:16: U S E
{
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_USE"
// $ANTLR start "K_DISTINCT"
public final void mK_DISTINCT() throws RecognitionException {
try {
int _type = K_DISTINCT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:79:11: ( D I S T I N C T )
// Lexer.g:79:16: D I S T I N C T
{
mD(); if (state.failed) return;
mI(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DISTINCT"
// $ANTLR start "K_COUNT"
public final void mK_COUNT() throws RecognitionException {
try {
int _type = K_COUNT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:80:8: ( C O U N T )
// Lexer.g:80:16: C O U N T
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_COUNT"
// $ANTLR start "K_SET"
public final void mK_SET() throws RecognitionException {
try {
int _type = K_SET;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:81:6: ( S E T )
// Lexer.g:81:16: S E T
{
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SET"
// $ANTLR start "K_BEGIN"
public final void mK_BEGIN() throws RecognitionException {
try {
int _type = K_BEGIN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:82:8: ( B E G I N )
// Lexer.g:82:16: B E G I N
{
mB(); if (state.failed) return;
mE(); if (state.failed) return;
mG(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BEGIN"
// $ANTLR start "K_UNLOGGED"
public final void mK_UNLOGGED() throws RecognitionException {
try {
int _type = K_UNLOGGED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:83:11: ( U N L O G G E D )
// Lexer.g:83:16: U N L O G G E D
{
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mG(); if (state.failed) return;
mG(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_UNLOGGED"
// $ANTLR start "K_BATCH"
public final void mK_BATCH() throws RecognitionException {
try {
int _type = K_BATCH;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:84:8: ( B A T C H )
// Lexer.g:84:16: B A T C H
{
mB(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mC(); if (state.failed) return;
mH(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BATCH"
// $ANTLR start "K_APPLY"
public final void mK_APPLY() throws RecognitionException {
try {
int _type = K_APPLY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:85:8: ( A P P L Y )
// Lexer.g:85:16: A P P L Y
{
mA(); if (state.failed) return;
mP(); if (state.failed) return;
mP(); if (state.failed) return;
mL(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_APPLY"
// $ANTLR start "K_TRUNCATE"
public final void mK_TRUNCATE() throws RecognitionException {
try {
int _type = K_TRUNCATE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:86:11: ( T R U N C A T E )
// Lexer.g:86:16: T R U N C A T E
{
mT(); if (state.failed) return;
mR(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TRUNCATE"
// $ANTLR start "K_DELETE"
public final void mK_DELETE() throws RecognitionException {
try {
int _type = K_DELETE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:87:9: ( D E L E T E )
// Lexer.g:87:16: D E L E T E
{
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DELETE"
// $ANTLR start "K_IN"
public final void mK_IN() throws RecognitionException {
try {
int _type = K_IN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:88:5: ( I N )
// Lexer.g:88:16: I N
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_IN"
// $ANTLR start "K_CREATE"
public final void mK_CREATE() throws RecognitionException {
try {
int _type = K_CREATE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:89:9: ( C R E A T E )
// Lexer.g:89:16: C R E A T E
{
mC(); if (state.failed) return;
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CREATE"
// $ANTLR start "K_SCHEMA"
public final void mK_SCHEMA() throws RecognitionException {
try {
int _type = K_SCHEMA;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:90:9: ( S C H E M A )
// Lexer.g:90:16: S C H E M A
{
mS(); if (state.failed) return;
mC(); if (state.failed) return;
mH(); if (state.failed) return;
mE(); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SCHEMA"
// $ANTLR start "K_KEYSPACE"
public final void mK_KEYSPACE() throws RecognitionException {
try {
int _type = K_KEYSPACE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:91:11: ( ( K E Y S P A C E | K_SCHEMA ) )
// Lexer.g:91:16: ( K E Y S P A C E | K_SCHEMA )
{
// Lexer.g:91:16: ( K E Y S P A C E | K_SCHEMA )
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0=='K'||LA1_0=='k') ) {
alt1=1;
}
else if ( (LA1_0=='S'||LA1_0=='s') ) {
alt1=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1 :
// Lexer.g:91:18: K E Y S P A C E
{
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mY(); if (state.failed) return;
mS(); if (state.failed) return;
mP(); if (state.failed) return;
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mE(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:92:20: K_SCHEMA
{
mK_SCHEMA(); if (state.failed) return;
}
break;
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_KEYSPACE"
// $ANTLR start "K_KEYSPACES"
public final void mK_KEYSPACES() throws RecognitionException {
try {
int _type = K_KEYSPACES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:93:12: ( K E Y S P A C E S )
// Lexer.g:93:16: K E Y S P A C E S
{
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mY(); if (state.failed) return;
mS(); if (state.failed) return;
mP(); if (state.failed) return;
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_KEYSPACES"
// $ANTLR start "K_COLUMNFAMILY"
public final void mK_COLUMNFAMILY() throws RecognitionException {
try {
int _type = K_COLUMNFAMILY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:94:15: ( ( C O L U M N F A M I L Y | T A B L E ) )
// Lexer.g:94:16: ( C O L U M N F A M I L Y | T A B L E )
{
// Lexer.g:94:16: ( C O L U M N F A M I L Y | T A B L E )
int alt2=2;
int LA2_0 = input.LA(1);
if ( (LA2_0=='C'||LA2_0=='c') ) {
alt2=1;
}
else if ( (LA2_0=='T'||LA2_0=='t') ) {
alt2=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 2, 0, input);
throw nvae;
}
switch (alt2) {
case 1 :
// Lexer.g:94:18: C O L U M N F A M I L Y
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mU(); if (state.failed) return;
mM(); if (state.failed) return;
mN(); if (state.failed) return;
mF(); if (state.failed) return;
mA(); if (state.failed) return;
mM(); if (state.failed) return;
mI(); if (state.failed) return;
mL(); if (state.failed) return;
mY(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:95:20: T A B L E
{
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mB(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
}
break;
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_COLUMNFAMILY"
// $ANTLR start "K_TABLES"
public final void mK_TABLES() throws RecognitionException {
try {
int _type = K_TABLES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:96:9: ( ( C O L U M N F A M I L I E S | T A B L E S ) )
// Lexer.g:96:16: ( C O L U M N F A M I L I E S | T A B L E S )
{
// Lexer.g:96:16: ( C O L U M N F A M I L I E S | T A B L E S )
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0=='C'||LA3_0=='c') ) {
alt3=1;
}
else if ( (LA3_0=='T'||LA3_0=='t') ) {
alt3=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 3, 0, input);
throw nvae;
}
switch (alt3) {
case 1 :
// Lexer.g:96:18: C O L U M N F A M I L I E S
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mU(); if (state.failed) return;
mM(); if (state.failed) return;
mN(); if (state.failed) return;
mF(); if (state.failed) return;
mA(); if (state.failed) return;
mM(); if (state.failed) return;
mI(); if (state.failed) return;
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:97:20: T A B L E S
{
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mB(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TABLES"
// $ANTLR start "K_MATERIALIZED"
public final void mK_MATERIALIZED() throws RecognitionException {
try {
int _type = K_MATERIALIZED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:98:15: ( M A T E R I A L I Z E D )
// Lexer.g:98:16: M A T E R I A L I Z E D
{
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mZ(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MATERIALIZED"
// $ANTLR start "K_VIEW"
public final void mK_VIEW() throws RecognitionException {
try {
int _type = K_VIEW;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:99:7: ( V I E W )
// Lexer.g:99:16: V I E W
{
mV(); if (state.failed) return;
mI(); if (state.failed) return;
mE(); if (state.failed) return;
mW(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_VIEW"
// $ANTLR start "K_INDEX"
public final void mK_INDEX() throws RecognitionException {
try {
int _type = K_INDEX;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:100:8: ( I N D E X )
// Lexer.g:100:16: I N D E X
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mX(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INDEX"
// $ANTLR start "K_CUSTOM"
public final void mK_CUSTOM() throws RecognitionException {
try {
int _type = K_CUSTOM;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:101:9: ( C U S T O M )
// Lexer.g:101:16: C U S T O M
{
mC(); if (state.failed) return;
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mO(); if (state.failed) return;
mM(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CUSTOM"
// $ANTLR start "K_ON"
public final void mK_ON() throws RecognitionException {
try {
int _type = K_ON;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:102:5: ( O N )
// Lexer.g:102:16: O N
{
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ON"
// $ANTLR start "K_TO"
public final void mK_TO() throws RecognitionException {
try {
int _type = K_TO;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:103:5: ( T O )
// Lexer.g:103:16: T O
{
mT(); if (state.failed) return;
mO(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TO"
// $ANTLR start "K_DROP"
public final void mK_DROP() throws RecognitionException {
try {
int _type = K_DROP;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:104:7: ( D R O P )
// Lexer.g:104:16: D R O P
{
mD(); if (state.failed) return;
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mP(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DROP"
// $ANTLR start "K_PRIMARY"
public final void mK_PRIMARY() throws RecognitionException {
try {
int _type = K_PRIMARY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:105:10: ( P R I M A R Y )
// Lexer.g:105:16: P R I M A R Y
{
mP(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mR(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PRIMARY"
// $ANTLR start "K_INTO"
public final void mK_INTO() throws RecognitionException {
try {
int _type = K_INTO;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:106:7: ( I N T O )
// Lexer.g:106:16: I N T O
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mO(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INTO"
// $ANTLR start "K_VALUES"
public final void mK_VALUES() throws RecognitionException {
try {
int _type = K_VALUES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:107:9: ( V A L U E S )
// Lexer.g:107:16: V A L U E S
{
mV(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mU(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_VALUES"
// $ANTLR start "K_TIMESTAMP"
public final void mK_TIMESTAMP() throws RecognitionException {
try {
int _type = K_TIMESTAMP;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:108:12: ( T I M E S T A M P )
// Lexer.g:108:16: T I M E S T A M P
{
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mM(); if (state.failed) return;
mP(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TIMESTAMP"
// $ANTLR start "K_TTL"
public final void mK_TTL() throws RecognitionException {
try {
int _type = K_TTL;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:109:6: ( T T L )
// Lexer.g:109:16: T T L
{
mT(); if (state.failed) return;
mT(); if (state.failed) return;
mL(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TTL"
// $ANTLR start "K_CAST"
public final void mK_CAST() throws RecognitionException {
try {
int _type = K_CAST;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:110:7: ( C A S T )
// Lexer.g:110:16: C A S T
{
mC(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CAST"
// $ANTLR start "K_ALTER"
public final void mK_ALTER() throws RecognitionException {
try {
int _type = K_ALTER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:111:8: ( A L T E R )
// Lexer.g:111:16: A L T E R
{
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ALTER"
// $ANTLR start "K_RENAME"
public final void mK_RENAME() throws RecognitionException {
try {
int _type = K_RENAME;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:112:9: ( R E N A M E )
// Lexer.g:112:16: R E N A M E
{
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mN(); if (state.failed) return;
mA(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_RENAME"
// $ANTLR start "K_ADD"
public final void mK_ADD() throws RecognitionException {
try {
int _type = K_ADD;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:113:6: ( A D D )
// Lexer.g:113:16: A D D
{
mA(); if (state.failed) return;
mD(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ADD"
// $ANTLR start "K_TYPE"
public final void mK_TYPE() throws RecognitionException {
try {
int _type = K_TYPE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:114:7: ( T Y P E )
// Lexer.g:114:16: T Y P E
{
mT(); if (state.failed) return;
mY(); if (state.failed) return;
mP(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TYPE"
// $ANTLR start "K_TYPES"
public final void mK_TYPES() throws RecognitionException {
try {
int _type = K_TYPES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:115:8: ( T Y P E S )
// Lexer.g:115:16: T Y P E S
{
mT(); if (state.failed) return;
mY(); if (state.failed) return;
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TYPES"
// $ANTLR start "K_COMPACT"
public final void mK_COMPACT() throws RecognitionException {
try {
int _type = K_COMPACT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:116:10: ( C O M P A C T )
// Lexer.g:116:16: C O M P A C T
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mM(); if (state.failed) return;
mP(); if (state.failed) return;
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_COMPACT"
// $ANTLR start "K_STORAGE"
public final void mK_STORAGE() throws RecognitionException {
try {
int _type = K_STORAGE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:117:10: ( S T O R A G E )
// Lexer.g:117:16: S T O R A G E
{
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mO(); if (state.failed) return;
mR(); if (state.failed) return;
mA(); if (state.failed) return;
mG(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_STORAGE"
// $ANTLR start "K_ORDER"
public final void mK_ORDER() throws RecognitionException {
try {
int _type = K_ORDER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:118:8: ( O R D E R )
// Lexer.g:118:16: O R D E R
{
mO(); if (state.failed) return;
mR(); if (state.failed) return;
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ORDER"
// $ANTLR start "K_BY"
public final void mK_BY() throws RecognitionException {
try {
int _type = K_BY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:119:5: ( B Y )
// Lexer.g:119:16: B Y
{
mB(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BY"
// $ANTLR start "K_ASC"
public final void mK_ASC() throws RecognitionException {
try {
int _type = K_ASC;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:120:6: ( A S C )
// Lexer.g:120:16: A S C
{
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mC(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ASC"
// $ANTLR start "K_DESC"
public final void mK_DESC() throws RecognitionException {
try {
int _type = K_DESC;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:121:7: ( D E S C )
// Lexer.g:121:16: D E S C
{
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
mC(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DESC"
// $ANTLR start "K_ALLOW"
public final void mK_ALLOW() throws RecognitionException {
try {
int _type = K_ALLOW;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:122:8: ( A L L O W )
// Lexer.g:122:16: A L L O W
{
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mW(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ALLOW"
// $ANTLR start "K_FILTERING"
public final void mK_FILTERING() throws RecognitionException {
try {
int _type = K_FILTERING;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:123:12: ( F I L T E R I N G )
// Lexer.g:123:16: F I L T E R I N G
{
mF(); if (state.failed) return;
mI(); if (state.failed) return;
mL(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mG(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FILTERING"
// $ANTLR start "K_IF"
public final void mK_IF() throws RecognitionException {
try {
int _type = K_IF;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:124:5: ( I F )
// Lexer.g:124:16: I F
{
mI(); if (state.failed) return;
mF(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_IF"
// $ANTLR start "K_IS"
public final void mK_IS() throws RecognitionException {
try {
int _type = K_IS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:125:5: ( I S )
// Lexer.g:125:16: I S
{
mI(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_IS"
// $ANTLR start "K_CONTAINS"
public final void mK_CONTAINS() throws RecognitionException {
try {
int _type = K_CONTAINS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:126:11: ( C O N T A I N S )
// Lexer.g:126:16: C O N T A I N S
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CONTAINS"
// $ANTLR start "K_GROUP"
public final void mK_GROUP() throws RecognitionException {
try {
int _type = K_GROUP;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:127:8: ( G R O U P )
// Lexer.g:127:16: G R O U P
{
mG(); if (state.failed) return;
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mU(); if (state.failed) return;
mP(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_GROUP"
// $ANTLR start "K_CLUSTER"
public final void mK_CLUSTER() throws RecognitionException {
try {
int _type = K_CLUSTER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:128:10: ( C L U S T E R )
// Lexer.g:128:16: C L U S T E R
{
mC(); if (state.failed) return;
mL(); if (state.failed) return;
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CLUSTER"
// $ANTLR start "K_INTERNALS"
public final void mK_INTERNALS() throws RecognitionException {
try {
int _type = K_INTERNALS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:129:12: ( I N T E R N A L S )
// Lexer.g:129:16: I N T E R N A L S
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mN(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INTERNALS"
// $ANTLR start "K_ONLY"
public final void mK_ONLY() throws RecognitionException {
try {
int _type = K_ONLY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:130:7: ( O N L Y )
// Lexer.g:130:16: O N L Y
{
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mL(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ONLY"
// $ANTLR start "K_GRANT"
public final void mK_GRANT() throws RecognitionException {
try {
int _type = K_GRANT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:132:8: ( G R A N T )
// Lexer.g:132:16: G R A N T
{
mG(); if (state.failed) return;
mR(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_GRANT"
// $ANTLR start "K_ALL"
public final void mK_ALL() throws RecognitionException {
try {
int _type = K_ALL;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:133:6: ( A L L )
// Lexer.g:133:16: A L L
{
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ALL"
// $ANTLR start "K_PERMISSION"
public final void mK_PERMISSION() throws RecognitionException {
try {
int _type = K_PERMISSION;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:134:13: ( P E R M I S S I O N )
// Lexer.g:134:16: P E R M I S S I O N
{
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mM(); if (state.failed) return;
mI(); if (state.failed) return;
mS(); if (state.failed) return;
mS(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PERMISSION"
// $ANTLR start "K_PERMISSIONS"
public final void mK_PERMISSIONS() throws RecognitionException {
try {
int _type = K_PERMISSIONS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:135:14: ( P E R M I S S I O N S )
// Lexer.g:135:16: P E R M I S S I O N S
{
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mM(); if (state.failed) return;
mI(); if (state.failed) return;
mS(); if (state.failed) return;
mS(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PERMISSIONS"
// $ANTLR start "K_OF"
public final void mK_OF() throws RecognitionException {
try {
int _type = K_OF;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:136:5: ( O F )
// Lexer.g:136:16: O F
{
mO(); if (state.failed) return;
mF(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_OF"
// $ANTLR start "K_REVOKE"
public final void mK_REVOKE() throws RecognitionException {
try {
int _type = K_REVOKE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:137:9: ( R E V O K E )
// Lexer.g:137:16: R E V O K E
{
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mV(); if (state.failed) return;
mO(); if (state.failed) return;
mK(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_REVOKE"
// $ANTLR start "K_MODIFY"
public final void mK_MODIFY() throws RecognitionException {
try {
int _type = K_MODIFY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:138:9: ( M O D I F Y )
// Lexer.g:138:16: M O D I F Y
{
mM(); if (state.failed) return;
mO(); if (state.failed) return;
mD(); if (state.failed) return;
mI(); if (state.failed) return;
mF(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MODIFY"
// $ANTLR start "K_AUTHORIZE"
public final void mK_AUTHORIZE() throws RecognitionException {
try {
int _type = K_AUTHORIZE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:139:12: ( A U T H O R I Z E )
// Lexer.g:139:16: A U T H O R I Z E
{
mA(); if (state.failed) return;
mU(); if (state.failed) return;
mT(); if (state.failed) return;
mH(); if (state.failed) return;
mO(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mZ(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_AUTHORIZE"
// $ANTLR start "K_DESCRIBE"
public final void mK_DESCRIBE() throws RecognitionException {
try {
int _type = K_DESCRIBE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:140:11: ( D E S C R I B E )
// Lexer.g:140:16: D E S C R I B E
{
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
mC(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mB(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DESCRIBE"
// $ANTLR start "K_EXECUTE"
public final void mK_EXECUTE() throws RecognitionException {
try {
int _type = K_EXECUTE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:141:10: ( E X E C U T E )
// Lexer.g:141:16: E X E C U T E
{
mE(); if (state.failed) return;
mX(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mU(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_EXECUTE"
// $ANTLR start "K_NORECURSIVE"
public final void mK_NORECURSIVE() throws RecognitionException {
try {
int _type = K_NORECURSIVE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:142:14: ( N O R E C U R S I V E )
// Lexer.g:142:16: N O R E C U R S I V E
{
mN(); if (state.failed) return;
mO(); if (state.failed) return;
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mU(); if (state.failed) return;
mR(); if (state.failed) return;
mS(); if (state.failed) return;
mI(); if (state.failed) return;
mV(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NORECURSIVE"
// $ANTLR start "K_MBEAN"
public final void mK_MBEAN() throws RecognitionException {
try {
int _type = K_MBEAN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:143:8: ( M B E A N )
// Lexer.g:143:16: M B E A N
{
mM(); if (state.failed) return;
mB(); if (state.failed) return;
mE(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MBEAN"
// $ANTLR start "K_MBEANS"
public final void mK_MBEANS() throws RecognitionException {
try {
int _type = K_MBEANS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:144:9: ( M B E A N S )
// Lexer.g:144:16: M B E A N S
{
mM(); if (state.failed) return;
mB(); if (state.failed) return;
mE(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MBEANS"
// $ANTLR start "K_USER"
public final void mK_USER() throws RecognitionException {
try {
int _type = K_USER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:146:7: ( U S E R )
// Lexer.g:146:16: U S E R
{
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_USER"
// $ANTLR start "K_USERS"
public final void mK_USERS() throws RecognitionException {
try {
int _type = K_USERS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:147:8: ( U S E R S )
// Lexer.g:147:16: U S E R S
{
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_USERS"
// $ANTLR start "K_ROLE"
public final void mK_ROLE() throws RecognitionException {
try {
int _type = K_ROLE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:148:7: ( R O L E )
// Lexer.g:148:16: R O L E
{
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ROLE"
// $ANTLR start "K_ROLES"
public final void mK_ROLES() throws RecognitionException {
try {
int _type = K_ROLES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:149:8: ( R O L E S )
// Lexer.g:149:16: R O L E S
{
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ROLES"
// $ANTLR start "K_SUPERUSER"
public final void mK_SUPERUSER() throws RecognitionException {
try {
int _type = K_SUPERUSER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:150:12: ( S U P E R U S E R )
// Lexer.g:150:16: S U P E R U S E R
{
mS(); if (state.failed) return;
mU(); if (state.failed) return;
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SUPERUSER"
// $ANTLR start "K_NOSUPERUSER"
public final void mK_NOSUPERUSER() throws RecognitionException {
try {
int _type = K_NOSUPERUSER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:151:14: ( N O S U P E R U S E R )
// Lexer.g:151:16: N O S U P E R U S E R
{
mN(); if (state.failed) return;
mO(); if (state.failed) return;
mS(); if (state.failed) return;
mU(); if (state.failed) return;
mP(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NOSUPERUSER"
// $ANTLR start "K_PASSWORD"
public final void mK_PASSWORD() throws RecognitionException {
try {
int _type = K_PASSWORD;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:152:11: ( P A S S W O R D )
// Lexer.g:152:16: P A S S W O R D
{
mP(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mS(); if (state.failed) return;
mW(); if (state.failed) return;
mO(); if (state.failed) return;
mR(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_PASSWORD"
// $ANTLR start "K_HASHED"
public final void mK_HASHED() throws RecognitionException {
try {
int _type = K_HASHED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:153:9: ( H A S H E D )
// Lexer.g:153:16: H A S H E D
{
mH(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mH(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_HASHED"
// $ANTLR start "K_LOGIN"
public final void mK_LOGIN() throws RecognitionException {
try {
int _type = K_LOGIN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:154:8: ( L O G I N )
// Lexer.g:154:16: L O G I N
{
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mG(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_LOGIN"
// $ANTLR start "K_NOLOGIN"
public final void mK_NOLOGIN() throws RecognitionException {
try {
int _type = K_NOLOGIN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:155:10: ( N O L O G I N )
// Lexer.g:155:16: N O L O G I N
{
mN(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mG(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NOLOGIN"
// $ANTLR start "K_OPTIONS"
public final void mK_OPTIONS() throws RecognitionException {
try {
int _type = K_OPTIONS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:156:10: ( O P T I O N S )
// Lexer.g:156:16: O P T I O N S
{
mO(); if (state.failed) return;
mP(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_OPTIONS"
// $ANTLR start "K_ACCESS"
public final void mK_ACCESS() throws RecognitionException {
try {
int _type = K_ACCESS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:157:9: ( A C C E S S )
// Lexer.g:157:16: A C C E S S
{
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mC(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ACCESS"
// $ANTLR start "K_DATACENTERS"
public final void mK_DATACENTERS() throws RecognitionException {
try {
int _type = K_DATACENTERS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:158:14: ( D A T A C E N T E R S )
// Lexer.g:158:16: D A T A C E N T E R S
{
mD(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mE(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DATACENTERS"
// $ANTLR start "K_CIDRS"
public final void mK_CIDRS() throws RecognitionException {
try {
int _type = K_CIDRS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:159:8: ( C I D R S )
// Lexer.g:159:16: C I D R S
{
mC(); if (state.failed) return;
mI(); if (state.failed) return;
mD(); if (state.failed) return;
mR(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CIDRS"
// $ANTLR start "K_IDENTITY"
public final void mK_IDENTITY() throws RecognitionException {
try {
int _type = K_IDENTITY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:160:11: ( I D E N T I T Y )
// Lexer.g:160:16: I D E N T I T Y
{
mI(); if (state.failed) return;
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_IDENTITY"
// $ANTLR start "K_CLUSTERING"
public final void mK_CLUSTERING() throws RecognitionException {
try {
int _type = K_CLUSTERING;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:162:13: ( C L U S T E R I N G )
// Lexer.g:162:16: C L U S T E R I N G
{
mC(); if (state.failed) return;
mL(); if (state.failed) return;
mU(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mG(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CLUSTERING"
// $ANTLR start "K_ASCII"
public final void mK_ASCII() throws RecognitionException {
try {
int _type = K_ASCII;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:163:8: ( A S C I I )
// Lexer.g:163:16: A S C I I
{
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mC(); if (state.failed) return;
mI(); if (state.failed) return;
mI(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ASCII"
// $ANTLR start "K_BIGINT"
public final void mK_BIGINT() throws RecognitionException {
try {
int _type = K_BIGINT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:164:9: ( B I G I N T )
// Lexer.g:164:16: B I G I N T
{
mB(); if (state.failed) return;
mI(); if (state.failed) return;
mG(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BIGINT"
// $ANTLR start "K_BLOB"
public final void mK_BLOB() throws RecognitionException {
try {
int _type = K_BLOB;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:165:7: ( B L O B )
// Lexer.g:165:16: B L O B
{
mB(); if (state.failed) return;
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mB(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BLOB"
// $ANTLR start "K_BOOLEAN"
public final void mK_BOOLEAN() throws RecognitionException {
try {
int _type = K_BOOLEAN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:166:10: ( B O O L E A N )
// Lexer.g:166:16: B O O L E A N
{
mB(); if (state.failed) return;
mO(); if (state.failed) return;
mO(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_BOOLEAN"
// $ANTLR start "K_COUNTER"
public final void mK_COUNTER() throws RecognitionException {
try {
int _type = K_COUNTER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:167:10: ( C O U N T E R )
// Lexer.g:167:16: C O U N T E R
{
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_COUNTER"
// $ANTLR start "K_DECIMAL"
public final void mK_DECIMAL() throws RecognitionException {
try {
int _type = K_DECIMAL;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:168:10: ( D E C I M A L )
// Lexer.g:168:16: D E C I M A L
{
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DECIMAL"
// $ANTLR start "K_DOUBLE"
public final void mK_DOUBLE() throws RecognitionException {
try {
int _type = K_DOUBLE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:169:9: ( D O U B L E )
// Lexer.g:169:16: D O U B L E
{
mD(); if (state.failed) return;
mO(); if (state.failed) return;
mU(); if (state.failed) return;
mB(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DOUBLE"
// $ANTLR start "K_DURATION"
public final void mK_DURATION() throws RecognitionException {
try {
int _type = K_DURATION;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:170:11: ( D U R A T I O N )
// Lexer.g:170:16: D U R A T I O N
{
mD(); if (state.failed) return;
mU(); if (state.failed) return;
mR(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DURATION"
// $ANTLR start "K_FLOAT"
public final void mK_FLOAT() throws RecognitionException {
try {
int _type = K_FLOAT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:171:8: ( F L O A T )
// Lexer.g:171:16: F L O A T
{
mF(); if (state.failed) return;
mL(); if (state.failed) return;
mO(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FLOAT"
// $ANTLR start "K_INET"
public final void mK_INET() throws RecognitionException {
try {
int _type = K_INET;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:172:7: ( I N E T )
// Lexer.g:172:16: I N E T
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INET"
// $ANTLR start "K_INT"
public final void mK_INT() throws RecognitionException {
try {
int _type = K_INT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:173:6: ( I N T )
// Lexer.g:173:16: I N T
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INT"
// $ANTLR start "K_SMALLINT"
public final void mK_SMALLINT() throws RecognitionException {
try {
int _type = K_SMALLINT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:174:11: ( S M A L L I N T )
// Lexer.g:174:16: S M A L L I N T
{
mS(); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SMALLINT"
// $ANTLR start "K_TINYINT"
public final void mK_TINYINT() throws RecognitionException {
try {
int _type = K_TINYINT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:175:10: ( T I N Y I N T )
// Lexer.g:175:16: T I N Y I N T
{
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mY(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TINYINT"
// $ANTLR start "K_TEXT"
public final void mK_TEXT() throws RecognitionException {
try {
int _type = K_TEXT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:176:7: ( T E X T )
// Lexer.g:176:16: T E X T
{
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mX(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TEXT"
// $ANTLR start "K_UUID"
public final void mK_UUID() throws RecognitionException {
try {
int _type = K_UUID;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:177:7: ( U U I D )
// Lexer.g:177:16: U U I D
{
mU(); if (state.failed) return;
mU(); if (state.failed) return;
mI(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_UUID"
// $ANTLR start "K_VARCHAR"
public final void mK_VARCHAR() throws RecognitionException {
try {
int _type = K_VARCHAR;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:178:10: ( V A R C H A R )
// Lexer.g:178:16: V A R C H A R
{
mV(); if (state.failed) return;
mA(); if (state.failed) return;
mR(); if (state.failed) return;
mC(); if (state.failed) return;
mH(); if (state.failed) return;
mA(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_VARCHAR"
// $ANTLR start "K_VARINT"
public final void mK_VARINT() throws RecognitionException {
try {
int _type = K_VARINT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:179:9: ( V A R I N T )
// Lexer.g:179:16: V A R I N T
{
mV(); if (state.failed) return;
mA(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_VARINT"
// $ANTLR start "K_TIMEUUID"
public final void mK_TIMEUUID() throws RecognitionException {
try {
int _type = K_TIMEUUID;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:180:11: ( T I M E U U I D )
// Lexer.g:180:16: T I M E U U I D
{
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
mU(); if (state.failed) return;
mU(); if (state.failed) return;
mI(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TIMEUUID"
// $ANTLR start "K_TOKEN"
public final void mK_TOKEN() throws RecognitionException {
try {
int _type = K_TOKEN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:181:8: ( T O K E N )
// Lexer.g:181:16: T O K E N
{
mT(); if (state.failed) return;
mO(); if (state.failed) return;
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TOKEN"
// $ANTLR start "K_WRITETIME"
public final void mK_WRITETIME() throws RecognitionException {
try {
int _type = K_WRITETIME;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:182:12: ( W R I T E T I M E )
// Lexer.g:182:16: W R I T E T I M E
{
mW(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_WRITETIME"
// $ANTLR start "K_MAXWRITETIME"
public final void mK_MAXWRITETIME() throws RecognitionException {
try {
int _type = K_MAXWRITETIME;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:183:15: ( M A X W R I T E T I M E )
// Lexer.g:183:16: M A X W R I T E T I M E
{
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mX(); if (state.failed) return;
mW(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MAXWRITETIME"
// $ANTLR start "K_DATE"
public final void mK_DATE() throws RecognitionException {
try {
int _type = K_DATE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:184:7: ( D A T E )
// Lexer.g:184:16: D A T E
{
mD(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DATE"
// $ANTLR start "K_TIME"
public final void mK_TIME() throws RecognitionException {
try {
int _type = K_TIME;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:185:7: ( T I M E )
// Lexer.g:185:16: T I M E
{
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mM(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TIME"
// $ANTLR start "K_NULL"
public final void mK_NULL() throws RecognitionException {
try {
int _type = K_NULL;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:187:7: ( N U L L )
// Lexer.g:187:16: N U L L
{
mN(); if (state.failed) return;
mU(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NULL"
// $ANTLR start "K_NOT"
public final void mK_NOT() throws RecognitionException {
try {
int _type = K_NOT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:188:6: ( N O T )
// Lexer.g:188:16: N O T
{
mN(); if (state.failed) return;
mO(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NOT"
// $ANTLR start "K_EXISTS"
public final void mK_EXISTS() throws RecognitionException {
try {
int _type = K_EXISTS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:189:9: ( E X I S T S )
// Lexer.g:189:16: E X I S T S
{
mE(); if (state.failed) return;
mX(); if (state.failed) return;
mI(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_EXISTS"
// $ANTLR start "K_MAP"
public final void mK_MAP() throws RecognitionException {
try {
int _type = K_MAP;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:191:6: ( M A P )
// Lexer.g:191:16: M A P
{
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mP(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MAP"
// $ANTLR start "K_LIST"
public final void mK_LIST() throws RecognitionException {
try {
int _type = K_LIST;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:192:7: ( L I S T )
// Lexer.g:192:16: L I S T
{
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mS(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_LIST"
// $ANTLR start "K_POSITIVE_NAN"
public final void mK_POSITIVE_NAN() throws RecognitionException {
try {
int _type = K_POSITIVE_NAN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:193:15: ( N A N )
// Lexer.g:193:17: N A N
{
mN(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_POSITIVE_NAN"
// $ANTLR start "K_NEGATIVE_NAN"
public final void mK_NEGATIVE_NAN() throws RecognitionException {
try {
int _type = K_NEGATIVE_NAN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:194:15: ( '-' N A N )
// Lexer.g:194:17: '-' N A N
{
match('-'); if (state.failed) return;
mN(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NEGATIVE_NAN"
// $ANTLR start "K_POSITIVE_INFINITY"
public final void mK_POSITIVE_INFINITY() throws RecognitionException {
try {
int _type = K_POSITIVE_INFINITY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:195:20: ( I N F I N I T Y )
// Lexer.g:195:25: I N F I N I T Y
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mF(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_POSITIVE_INFINITY"
// $ANTLR start "K_NEGATIVE_INFINITY"
public final void mK_NEGATIVE_INFINITY() throws RecognitionException {
try {
int _type = K_NEGATIVE_INFINITY;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:196:20: ( '-' I N F I N I T Y )
// Lexer.g:196:22: '-' I N F I N I T Y
{
match('-'); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mF(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mY(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_NEGATIVE_INFINITY"
// $ANTLR start "K_TUPLE"
public final void mK_TUPLE() throws RecognitionException {
try {
int _type = K_TUPLE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:197:8: ( T U P L E )
// Lexer.g:197:16: T U P L E
{
mT(); if (state.failed) return;
mU(); if (state.failed) return;
mP(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TUPLE"
// $ANTLR start "K_TRIGGER"
public final void mK_TRIGGER() throws RecognitionException {
try {
int _type = K_TRIGGER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:199:10: ( T R I G G E R )
// Lexer.g:199:16: T R I G G E R
{
mT(); if (state.failed) return;
mR(); if (state.failed) return;
mI(); if (state.failed) return;
mG(); if (state.failed) return;
mG(); if (state.failed) return;
mE(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_TRIGGER"
// $ANTLR start "K_STATIC"
public final void mK_STATIC() throws RecognitionException {
try {
int _type = K_STATIC;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:200:9: ( S T A T I C )
// Lexer.g:200:16: S T A T I C
{
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mC(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_STATIC"
// $ANTLR start "K_FROZEN"
public final void mK_FROZEN() throws RecognitionException {
try {
int _type = K_FROZEN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:201:9: ( F R O Z E N )
// Lexer.g:201:16: F R O Z E N
{
mF(); if (state.failed) return;
mR(); if (state.failed) return;
mO(); if (state.failed) return;
mZ(); if (state.failed) return;
mE(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FROZEN"
// $ANTLR start "K_FUNCTION"
public final void mK_FUNCTION() throws RecognitionException {
try {
int _type = K_FUNCTION;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:203:11: ( F U N C T I O N )
// Lexer.g:203:16: F U N C T I O N
{
mF(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FUNCTION"
// $ANTLR start "K_FUNCTIONS"
public final void mK_FUNCTIONS() throws RecognitionException {
try {
int _type = K_FUNCTIONS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:204:12: ( F U N C T I O N S )
// Lexer.g:204:16: F U N C T I O N S
{
mF(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
mI(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FUNCTIONS"
// $ANTLR start "K_AGGREGATE"
public final void mK_AGGREGATE() throws RecognitionException {
try {
int _type = K_AGGREGATE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:205:12: ( A G G R E G A T E )
// Lexer.g:205:16: A G G R E G A T E
{
mA(); if (state.failed) return;
mG(); if (state.failed) return;
mG(); if (state.failed) return;
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mG(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_AGGREGATE"
// $ANTLR start "K_AGGREGATES"
public final void mK_AGGREGATES() throws RecognitionException {
try {
int _type = K_AGGREGATES;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:206:13: ( A G G R E G A T E S )
// Lexer.g:206:16: A G G R E G A T E S
{
mA(); if (state.failed) return;
mG(); if (state.failed) return;
mG(); if (state.failed) return;
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mG(); if (state.failed) return;
mA(); if (state.failed) return;
mT(); if (state.failed) return;
mE(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_AGGREGATES"
// $ANTLR start "K_SFUNC"
public final void mK_SFUNC() throws RecognitionException {
try {
int _type = K_SFUNC;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:207:8: ( S F U N C )
// Lexer.g:207:16: S F U N C
{
mS(); if (state.failed) return;
mF(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SFUNC"
// $ANTLR start "K_STYPE"
public final void mK_STYPE() throws RecognitionException {
try {
int _type = K_STYPE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:208:8: ( S T Y P E )
// Lexer.g:208:16: S T Y P E
{
mS(); if (state.failed) return;
mT(); if (state.failed) return;
mY(); if (state.failed) return;
mP(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_STYPE"
// $ANTLR start "K_FINALFUNC"
public final void mK_FINALFUNC() throws RecognitionException {
try {
int _type = K_FINALFUNC;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:209:12: ( F I N A L F U N C )
// Lexer.g:209:16: F I N A L F U N C
{
mF(); if (state.failed) return;
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mF(); if (state.failed) return;
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mC(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_FINALFUNC"
// $ANTLR start "K_INITCOND"
public final void mK_INITCOND() throws RecognitionException {
try {
int _type = K_INITCOND;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:210:11: ( I N I T C O N D )
// Lexer.g:210:16: I N I T C O N D
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mI(); if (state.failed) return;
mT(); if (state.failed) return;
mC(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INITCOND"
// $ANTLR start "K_RETURNS"
public final void mK_RETURNS() throws RecognitionException {
try {
int _type = K_RETURNS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:211:10: ( R E T U R N S )
// Lexer.g:211:16: R E T U R N S
{
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
mU(); if (state.failed) return;
mR(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_RETURNS"
// $ANTLR start "K_CALLED"
public final void mK_CALLED() throws RecognitionException {
try {
int _type = K_CALLED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:212:9: ( C A L L E D )
// Lexer.g:212:16: C A L L E D
{
mC(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_CALLED"
// $ANTLR start "K_INPUT"
public final void mK_INPUT() throws RecognitionException {
try {
int _type = K_INPUT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:213:8: ( I N P U T )
// Lexer.g:213:16: I N P U T
{
mI(); if (state.failed) return;
mN(); if (state.failed) return;
mP(); if (state.failed) return;
mU(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_INPUT"
// $ANTLR start "K_LANGUAGE"
public final void mK_LANGUAGE() throws RecognitionException {
try {
int _type = K_LANGUAGE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:214:11: ( L A N G U A G E )
// Lexer.g:214:16: L A N G U A G E
{
mL(); if (state.failed) return;
mA(); if (state.failed) return;
mN(); if (state.failed) return;
mG(); if (state.failed) return;
mU(); if (state.failed) return;
mA(); if (state.failed) return;
mG(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_LANGUAGE"
// $ANTLR start "K_OR"
public final void mK_OR() throws RecognitionException {
try {
int _type = K_OR;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:215:5: ( O R )
// Lexer.g:215:16: O R
{
mO(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_OR"
// $ANTLR start "K_REPLACE"
public final void mK_REPLACE() throws RecognitionException {
try {
int _type = K_REPLACE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:216:10: ( R E P L A C E )
// Lexer.g:216:16: R E P L A C E
{
mR(); if (state.failed) return;
mE(); if (state.failed) return;
mP(); if (state.failed) return;
mL(); if (state.failed) return;
mA(); if (state.failed) return;
mC(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_REPLACE"
// $ANTLR start "K_JSON"
public final void mK_JSON() throws RecognitionException {
try {
int _type = K_JSON;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:218:7: ( J S O N )
// Lexer.g:218:16: J S O N
{
mJ(); if (state.failed) return;
mS(); if (state.failed) return;
mO(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_JSON"
// $ANTLR start "K_DEFAULT"
public final void mK_DEFAULT() throws RecognitionException {
try {
int _type = K_DEFAULT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:219:10: ( D E F A U L T )
// Lexer.g:219:16: D E F A U L T
{
mD(); if (state.failed) return;
mE(); if (state.failed) return;
mF(); if (state.failed) return;
mA(); if (state.failed) return;
mU(); if (state.failed) return;
mL(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_DEFAULT"
// $ANTLR start "K_UNSET"
public final void mK_UNSET() throws RecognitionException {
try {
int _type = K_UNSET;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:220:8: ( U N S E T )
// Lexer.g:220:16: U N S E T
{
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mT(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_UNSET"
// $ANTLR start "K_LIKE"
public final void mK_LIKE() throws RecognitionException {
try {
int _type = K_LIKE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:221:7: ( L I K E )
// Lexer.g:221:16: L I K E
{
mL(); if (state.failed) return;
mI(); if (state.failed) return;
mK(); if (state.failed) return;
mE(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_LIKE"
// $ANTLR start "K_MASKED"
public final void mK_MASKED() throws RecognitionException {
try {
int _type = K_MASKED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:223:9: ( M A S K E D )
// Lexer.g:223:16: M A S K E D
{
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_MASKED"
// $ANTLR start "K_UNMASK"
public final void mK_UNMASK() throws RecognitionException {
try {
int _type = K_UNMASK;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:224:9: ( U N M A S K )
// Lexer.g:224:16: U N M A S K
{
mU(); if (state.failed) return;
mN(); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mK(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_UNMASK"
// $ANTLR start "K_SELECT_MASKED"
public final void mK_SELECT_MASKED() throws RecognitionException {
try {
int _type = K_SELECT_MASKED;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:225:16: ( S E L E C T '_' M A S K E D )
// Lexer.g:225:18: S E L E C T '_' M A S K E D
{
mS(); if (state.failed) return;
mE(); if (state.failed) return;
mL(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
match('_'); if (state.failed) return;
mM(); if (state.failed) return;
mA(); if (state.failed) return;
mS(); if (state.failed) return;
mK(); if (state.failed) return;
mE(); if (state.failed) return;
mD(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_SELECT_MASKED"
// $ANTLR start "K_VECTOR"
public final void mK_VECTOR() throws RecognitionException {
try {
int _type = K_VECTOR;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:227:9: ( V E C T O R )
// Lexer.g:227:16: V E C T O R
{
mV(); if (state.failed) return;
mE(); if (state.failed) return;
mC(); if (state.failed) return;
mT(); if (state.failed) return;
mO(); if (state.failed) return;
mR(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_VECTOR"
// $ANTLR start "K_ANN"
public final void mK_ANN() throws RecognitionException {
try {
int _type = K_ANN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:228:6: ( A N N )
// Lexer.g:228:16: A N N
{
mA(); if (state.failed) return;
mN(); if (state.failed) return;
mN(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "K_ANN"
// $ANTLR start "A"
public final void mA() throws RecognitionException {
try {
// Lexer.g:231:11: ( ( 'a' | 'A' ) )
// Lexer.g:
{
if ( input.LA(1)=='A'||input.LA(1)=='a' ) {
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 "A"
// $ANTLR start "B"
public final void mB() throws RecognitionException {
try {
// Lexer.g:232:11: ( ( 'b' | 'B' ) )
// Lexer.g:
{
if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
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 "B"
// $ANTLR start "C"
public final void mC() throws RecognitionException {
try {
// Lexer.g:233:11: ( ( 'c' | 'C' ) )
// Lexer.g:
{
if ( input.LA(1)=='C'||input.LA(1)=='c' ) {
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 "C"
// $ANTLR start "D"
public final void mD() throws RecognitionException {
try {
// Lexer.g:234:11: ( ( 'd' | 'D' ) )
// Lexer.g:
{
if ( input.LA(1)=='D'||input.LA(1)=='d' ) {
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 "D"
// $ANTLR start "E"
public final void mE() throws RecognitionException {
try {
// Lexer.g:235:11: ( ( 'e' | 'E' ) )
// Lexer.g:
{
if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
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 "E"
// $ANTLR start "F"
public final void mF() throws RecognitionException {
try {
// Lexer.g:236:11: ( ( 'f' | 'F' ) )
// Lexer.g:
{
if ( input.LA(1)=='F'||input.LA(1)=='f' ) {
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 "F"
// $ANTLR start "G"
public final void mG() throws RecognitionException {
try {
// Lexer.g:237:11: ( ( 'g' | 'G' ) )
// Lexer.g:
{
if ( input.LA(1)=='G'||input.LA(1)=='g' ) {
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 "G"
// $ANTLR start "H"
public final void mH() throws RecognitionException {
try {
// Lexer.g:238:11: ( ( 'h' | 'H' ) )
// Lexer.g:
{
if ( input.LA(1)=='H'||input.LA(1)=='h' ) {
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 "H"
// $ANTLR start "I"
public final void mI() throws RecognitionException {
try {
// Lexer.g:239:11: ( ( 'i' | 'I' ) )
// Lexer.g:
{
if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
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 "I"
// $ANTLR start "J"
public final void mJ() throws RecognitionException {
try {
// Lexer.g:240:11: ( ( 'j' | 'J' ) )
// Lexer.g:
{
if ( input.LA(1)=='J'||input.LA(1)=='j' ) {
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 "J"
// $ANTLR start "K"
public final void mK() throws RecognitionException {
try {
// Lexer.g:241:11: ( ( 'k' | 'K' ) )
// Lexer.g:
{
if ( input.LA(1)=='K'||input.LA(1)=='k' ) {
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 "K"
// $ANTLR start "L"
public final void mL() throws RecognitionException {
try {
// Lexer.g:242:11: ( ( 'l' | 'L' ) )
// Lexer.g:
{
if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
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 "L"
// $ANTLR start "M"
public final void mM() throws RecognitionException {
try {
// Lexer.g:243:11: ( ( 'm' | 'M' ) )
// Lexer.g:
{
if ( input.LA(1)=='M'||input.LA(1)=='m' ) {
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 "M"
// $ANTLR start "N"
public final void mN() throws RecognitionException {
try {
// Lexer.g:244:11: ( ( 'n' | 'N' ) )
// Lexer.g:
{
if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
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 "N"
// $ANTLR start "O"
public final void mO() throws RecognitionException {
try {
// Lexer.g:245:11: ( ( 'o' | 'O' ) )
// Lexer.g:
{
if ( input.LA(1)=='O'||input.LA(1)=='o' ) {
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 "O"
// $ANTLR start "P"
public final void mP() throws RecognitionException {
try {
// Lexer.g:246:11: ( ( 'p' | 'P' ) )
// Lexer.g:
{
if ( input.LA(1)=='P'||input.LA(1)=='p' ) {
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 "P"
// $ANTLR start "Q"
public final void mQ() throws RecognitionException {
try {
// Lexer.g:247:11: ( ( 'q' | 'Q' ) )
// Lexer.g:
{
if ( input.LA(1)=='Q'||input.LA(1)=='q' ) {
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 "Q"
// $ANTLR start "R"
public final void mR() throws RecognitionException {
try {
// Lexer.g:248:11: ( ( 'r' | 'R' ) )
// Lexer.g:
{
if ( input.LA(1)=='R'||input.LA(1)=='r' ) {
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 "R"
// $ANTLR start "S"
public final void mS() throws RecognitionException {
try {
// Lexer.g:249:11: ( ( 's' | 'S' ) )
// Lexer.g:
{
if ( input.LA(1)=='S'||input.LA(1)=='s' ) {
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 "S"
// $ANTLR start "T"
public final void mT() throws RecognitionException {
try {
// Lexer.g:250:11: ( ( 't' | 'T' ) )
// Lexer.g:
{
if ( input.LA(1)=='T'||input.LA(1)=='t' ) {
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 "T"
// $ANTLR start "U"
public final void mU() throws RecognitionException {
try {
// Lexer.g:251:11: ( ( 'u' | 'U' ) )
// Lexer.g:
{
if ( input.LA(1)=='U'||input.LA(1)=='u' ) {
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 "U"
// $ANTLR start "V"
public final void mV() throws RecognitionException {
try {
// Lexer.g:252:11: ( ( 'v' | 'V' ) )
// Lexer.g:
{
if ( input.LA(1)=='V'||input.LA(1)=='v' ) {
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 "V"
// $ANTLR start "W"
public final void mW() throws RecognitionException {
try {
// Lexer.g:253:11: ( ( 'w' | 'W' ) )
// Lexer.g:
{
if ( input.LA(1)=='W'||input.LA(1)=='w' ) {
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 "W"
// $ANTLR start "X"
public final void mX() throws RecognitionException {
try {
// Lexer.g:254:11: ( ( 'x' | 'X' ) )
// Lexer.g:
{
if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
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 "X"
// $ANTLR start "Y"
public final void mY() throws RecognitionException {
try {
// Lexer.g:255:11: ( ( 'y' | 'Y' ) )
// Lexer.g:
{
if ( input.LA(1)=='Y'||input.LA(1)=='y' ) {
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 "Y"
// $ANTLR start "Z"
public final void mZ() throws RecognitionException {
try {
// Lexer.g:256:11: ( ( 'z' | 'Z' ) )
// Lexer.g:
{
if ( input.LA(1)=='Z'||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 "Z"
// $ANTLR start "STRING_LITERAL"
public final void mSTRING_LITERAL() throws RecognitionException {
try {
int _type = STRING_LITERAL;
int _channel = DEFAULT_TOKEN_CHANNEL;
int c;
StringBuilder txt = new StringBuilder(); // temporary to build pg-style-string
// Lexer.g:263:5: ( ( '\\$' '\\$' ({...}? =>c= . )* '\\$' '\\$' ) | ( '\\'' (c=~ ( '\\'' ) | '\\'' '\\'' )* '\\'' ) )
int alt6=2;
int LA6_0 = input.LA(1);
if ( (LA6_0=='$') ) {
alt6=1;
}
else if ( (LA6_0=='\'') ) {
alt6=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 6, 0, input);
throw nvae;
}
switch (alt6) {
case 1 :
// Lexer.g:265:7: ( '\\$' '\\$' ({...}? =>c= . )* '\\$' '\\$' )
{
// Lexer.g:265:7: ( '\\$' '\\$' ({...}? =>c= . )* '\\$' '\\$' )
// Lexer.g:266:9: '\\$' '\\$' ({...}? =>c= . )* '\\$' '\\$'
{
match('$'); if (state.failed) return;
match('$'); if (state.failed) return;
// Lexer.g:267:9: ({...}? =>c= . )*
loop4:
while (true) {
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0=='$') ) {
int LA4_1 = input.LA(2);
if ( (LA4_1=='$') ) {
int LA4_3 = input.LA(3);
if ( ((LA4_3 >= '\u0000' && LA4_3 <= '\uFFFF')) && (( (input.size() - input.index() > 1)
&& !"$$".equals(input.substring(input.index(), input.index() + 1)) ))) {
alt4=1;
}
}
else if ( ((LA4_1 >= '\u0000' && LA4_1 <= '#')||(LA4_1 >= '%' && LA4_1 <= '\uFFFF')) && (( (input.size() - input.index() > 1)
&& !"$$".equals(input.substring(input.index(), input.index() + 1)) ))) {
alt4=1;
}
}
else if ( ((LA4_0 >= '\u0000' && LA4_0 <= '#')||(LA4_0 >= '%' && LA4_0 <= '\uFFFF')) && (( (input.size() - input.index() > 1)
&& !"$$".equals(input.substring(input.index(), input.index() + 1)) ))) {
alt4=1;
}
switch (alt4) {
case 1 :
// Lexer.g:268:11: {...}? =>c= .
{
if ( !(( (input.size() - input.index() > 1)
&& !"$$".equals(input.substring(input.index(), input.index() + 1)) )) ) {
if (state.backtracking>0) {state.failed=true; return;}
throw new FailedPredicateException(input, "STRING_LITERAL", " (input.size() - input.index() > 1)\n && !\"$$\".equals(input.substring(input.index(), input.index() + 1)) ");
}
c = input.LA(1);
matchAny(); if (state.failed) return;
if ( state.backtracking==0 ) { txt.appendCodePoint(c); }
}
break;
default :
break loop4;
}
}
match('$'); if (state.failed) return;
match('$'); if (state.failed) return;
}
}
break;
case 2 :
// Lexer.g:276:7: ( '\\'' (c=~ ( '\\'' ) | '\\'' '\\'' )* '\\'' )
{
// Lexer.g:276:7: ( '\\'' (c=~ ( '\\'' ) | '\\'' '\\'' )* '\\'' )
// Lexer.g:277:9: '\\'' (c=~ ( '\\'' ) | '\\'' '\\'' )* '\\''
{
match('\''); if (state.failed) return;
// Lexer.g:277:14: (c=~ ( '\\'' ) | '\\'' '\\'' )*
loop5:
while (true) {
int alt5=3;
int LA5_0 = input.LA(1);
if ( (LA5_0=='\'') ) {
int LA5_1 = input.LA(2);
if ( (LA5_1=='\'') ) {
alt5=2;
}
}
else if ( ((LA5_0 >= '\u0000' && LA5_0 <= '&')||(LA5_0 >= '(' && LA5_0 <= '\uFFFF')) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// Lexer.g:277:15: c=~ ( '\\'' )
{
c= input.LA(1);
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;
}
if ( state.backtracking==0 ) { txt.appendCodePoint(c);}
}
break;
case 2 :
// Lexer.g:277:54: '\\'' '\\''
{
match('\''); if (state.failed) return;
match('\''); if (state.failed) return;
if ( state.backtracking==0 ) { txt.appendCodePoint('\''); }
}
break;
default :
break loop5;
}
}
match('\''); if (state.failed) return;
}
}
break;
}
state.type = _type;
state.channel = _channel;
if ( state.backtracking==0 ) { setText(txt.toString()); }
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "STRING_LITERAL"
// $ANTLR start "QUOTED_NAME"
public final void mQUOTED_NAME() throws RecognitionException {
try {
int _type = QUOTED_NAME;
int _channel = DEFAULT_TOKEN_CHANNEL;
int c;
StringBuilder b = new StringBuilder();
// Lexer.g:284:5: ( '\\\"' (c=~ ( '\\\"' ) | '\\\"' '\\\"' )+ '\\\"' )
// Lexer.g:284:7: '\\\"' (c=~ ( '\\\"' ) | '\\\"' '\\\"' )+ '\\\"'
{
match('\"'); if (state.failed) return;
// Lexer.g:284:12: (c=~ ( '\\\"' ) | '\\\"' '\\\"' )+
int cnt7=0;
loop7:
while (true) {
int alt7=3;
int LA7_0 = input.LA(1);
if ( (LA7_0=='\"') ) {
int LA7_1 = input.LA(2);
if ( (LA7_1=='\"') ) {
alt7=2;
}
}
else if ( ((LA7_0 >= '\u0000' && LA7_0 <= '!')||(LA7_0 >= '#' && LA7_0 <= '\uFFFF')) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// Lexer.g:284:13: c=~ ( '\\\"' )
{
c= input.LA(1);
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;
}
if ( state.backtracking==0 ) { b.appendCodePoint(c); }
}
break;
case 2 :
// Lexer.g:284:51: '\\\"' '\\\"'
{
match('\"'); if (state.failed) return;
match('\"'); if (state.failed) return;
if ( state.backtracking==0 ) { b.appendCodePoint('\"'); }
}
break;
default :
if ( cnt7 >= 1 ) break loop7;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(7, input);
throw eee;
}
cnt7++;
}
match('\"'); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
if ( state.backtracking==0 ) { setText(b.toString()); }
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "QUOTED_NAME"
// $ANTLR start "EMPTY_QUOTED_NAME"
public final void mEMPTY_QUOTED_NAME() throws RecognitionException {
try {
int _type = EMPTY_QUOTED_NAME;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:288:5: ( '\\\"' '\\\"' )
// Lexer.g:288:7: '\\\"' '\\\"'
{
match('\"'); if (state.failed) return;
match('\"'); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "EMPTY_QUOTED_NAME"
// $ANTLR start "DIGIT"
public final void mDIGIT() throws RecognitionException {
try {
// Lexer.g:292:5: ( '0' .. '9' )
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 "DIGIT"
// $ANTLR start "LETTER"
public final void mLETTER() throws RecognitionException {
try {
// Lexer.g:296:5: ( ( 'A' .. 'Z' | 'a' .. 'z' ) )
// Lexer.g:
{
if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(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 "LETTER"
// $ANTLR start "HEX"
public final void mHEX() throws RecognitionException {
try {
// Lexer.g:300:5: ( ( 'A' .. 'F' | 'a' .. 'f' | '0' .. '9' ) )
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
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 "HEX"
// $ANTLR start "EXPONENT"
public final void mEXPONENT() throws RecognitionException {
try {
// Lexer.g:304:5: ( E ( '+' | '-' )? ( DIGIT )+ )
// Lexer.g:304:7: E ( '+' | '-' )? ( DIGIT )+
{
mE(); if (state.failed) return;
// Lexer.g:304:9: ( '+' | '-' )?
int alt8=2;
int LA8_0 = input.LA(1);
if ( (LA8_0=='+'||LA8_0=='-') ) {
alt8=1;
}
switch (alt8) {
case 1 :
// Lexer.g:
{
if ( 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;
}
// Lexer.g:304:22: ( DIGIT )+
int cnt9=0;
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt9 >= 1 ) break loop9;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(9, input);
throw eee;
}
cnt9++;
}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "EXPONENT"
// $ANTLR start "DURATION_ISO_8601_PERIOD_DESIGNATORS"
public final void mDURATION_ISO_8601_PERIOD_DESIGNATORS() throws RecognitionException {
try {
// Lexer.g:308:5: ( ( '-' )? 'P' ( DIGIT )+ 'Y' ( ( DIGIT )+ 'M' )? ( ( DIGIT )+ 'D' )? | ( '-' )? 'P' ( DIGIT )+ 'M' ( ( DIGIT )+ 'D' )? | ( '-' )? 'P' ( DIGIT )+ 'D' )
int alt22=3;
alt22 = dfa22.predict(input);
switch (alt22) {
case 1 :
// Lexer.g:308:7: ( '-' )? 'P' ( DIGIT )+ 'Y' ( ( DIGIT )+ 'M' )? ( ( DIGIT )+ 'D' )?
{
// Lexer.g:308:7: ( '-' )?
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0=='-') ) {
alt10=1;
}
switch (alt10) {
case 1 :
// Lexer.g:308:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
// Lexer.g:308:16: ( DIGIT )+
int cnt11=0;
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( ((LA11_0 >= '0' && LA11_0 <= '9')) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt11 >= 1 ) break loop11;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(11, input);
throw eee;
}
cnt11++;
}
match('Y'); if (state.failed) return;
// Lexer.g:308:27: ( ( DIGIT )+ 'M' )?
int alt13=2;
alt13 = dfa13.predict(input);
switch (alt13) {
case 1 :
// Lexer.g:308:28: ( DIGIT )+ 'M'
{
// Lexer.g:308:28: ( DIGIT )+
int cnt12=0;
loop12:
while (true) {
int alt12=2;
int LA12_0 = input.LA(1);
if ( ((LA12_0 >= '0' && LA12_0 <= '9')) ) {
alt12=1;
}
switch (alt12) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt12 >= 1 ) break loop12;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(12, input);
throw eee;
}
cnt12++;
}
match('M'); if (state.failed) return;
}
break;
}
// Lexer.g:308:41: ( ( DIGIT )+ 'D' )?
int alt15=2;
int LA15_0 = input.LA(1);
if ( ((LA15_0 >= '0' && LA15_0 <= '9')) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// Lexer.g:308:42: ( DIGIT )+ 'D'
{
// Lexer.g:308:42: ( DIGIT )+
int cnt14=0;
loop14:
while (true) {
int alt14=2;
int LA14_0 = input.LA(1);
if ( ((LA14_0 >= '0' && LA14_0 <= '9')) ) {
alt14=1;
}
switch (alt14) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt14 >= 1 ) break loop14;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(14, input);
throw eee;
}
cnt14++;
}
match('D'); if (state.failed) return;
}
break;
}
}
break;
case 2 :
// Lexer.g:309:7: ( '-' )? 'P' ( DIGIT )+ 'M' ( ( DIGIT )+ 'D' )?
{
// Lexer.g:309:7: ( '-' )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0=='-') ) {
alt16=1;
}
switch (alt16) {
case 1 :
// Lexer.g:309:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
// Lexer.g:309:16: ( DIGIT )+
int cnt17=0;
loop17:
while (true) {
int alt17=2;
int LA17_0 = input.LA(1);
if ( ((LA17_0 >= '0' && LA17_0 <= '9')) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt17 >= 1 ) break loop17;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(17, input);
throw eee;
}
cnt17++;
}
match('M'); if (state.failed) return;
// Lexer.g:309:27: ( ( DIGIT )+ 'D' )?
int alt19=2;
int LA19_0 = input.LA(1);
if ( ((LA19_0 >= '0' && LA19_0 <= '9')) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// Lexer.g:309:28: ( DIGIT )+ 'D'
{
// Lexer.g:309:28: ( DIGIT )+
int cnt18=0;
loop18:
while (true) {
int alt18=2;
int LA18_0 = input.LA(1);
if ( ((LA18_0 >= '0' && LA18_0 <= '9')) ) {
alt18=1;
}
switch (alt18) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt18 >= 1 ) break loop18;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(18, input);
throw eee;
}
cnt18++;
}
match('D'); if (state.failed) return;
}
break;
}
}
break;
case 3 :
// Lexer.g:310:7: ( '-' )? 'P' ( DIGIT )+ 'D'
{
// Lexer.g:310:7: ( '-' )?
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0=='-') ) {
alt20=1;
}
switch (alt20) {
case 1 :
// Lexer.g:310:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
// Lexer.g:310:16: ( DIGIT )+
int cnt21=0;
loop21:
while (true) {
int alt21=2;
int LA21_0 = input.LA(1);
if ( ((LA21_0 >= '0' && LA21_0 <= '9')) ) {
alt21=1;
}
switch (alt21) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt21 >= 1 ) break loop21;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(21, input);
throw eee;
}
cnt21++;
}
match('D'); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "DURATION_ISO_8601_PERIOD_DESIGNATORS"
// $ANTLR start "DURATION_ISO_8601_TIME_DESIGNATORS"
public final void mDURATION_ISO_8601_TIME_DESIGNATORS() throws RecognitionException {
try {
// Lexer.g:314:5: ( 'T' ( DIGIT )+ 'H' ( ( DIGIT )+ 'M' )? ( ( DIGIT )+ 'S' )? | 'T' ( DIGIT )+ 'M' ( ( DIGIT )+ 'S' )? | 'T' ( DIGIT )+ 'S' )
int alt32=3;
alt32 = dfa32.predict(input);
switch (alt32) {
case 1 :
// Lexer.g:314:7: 'T' ( DIGIT )+ 'H' ( ( DIGIT )+ 'M' )? ( ( DIGIT )+ 'S' )?
{
match('T'); if (state.failed) return;
// Lexer.g:314:11: ( DIGIT )+
int cnt23=0;
loop23:
while (true) {
int alt23=2;
int LA23_0 = input.LA(1);
if ( ((LA23_0 >= '0' && LA23_0 <= '9')) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt23 >= 1 ) break loop23;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(23, input);
throw eee;
}
cnt23++;
}
match('H'); if (state.failed) return;
// Lexer.g:314:22: ( ( DIGIT )+ 'M' )?
int alt25=2;
alt25 = dfa25.predict(input);
switch (alt25) {
case 1 :
// Lexer.g:314:23: ( DIGIT )+ 'M'
{
// Lexer.g:314:23: ( DIGIT )+
int cnt24=0;
loop24:
while (true) {
int alt24=2;
int LA24_0 = input.LA(1);
if ( ((LA24_0 >= '0' && LA24_0 <= '9')) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt24 >= 1 ) break loop24;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(24, input);
throw eee;
}
cnt24++;
}
match('M'); if (state.failed) return;
}
break;
}
// Lexer.g:314:36: ( ( DIGIT )+ 'S' )?
int alt27=2;
int LA27_0 = input.LA(1);
if ( ((LA27_0 >= '0' && LA27_0 <= '9')) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// Lexer.g:314:37: ( DIGIT )+ 'S'
{
// Lexer.g:314:37: ( DIGIT )+
int cnt26=0;
loop26:
while (true) {
int alt26=2;
int LA26_0 = input.LA(1);
if ( ((LA26_0 >= '0' && LA26_0 <= '9')) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt26 >= 1 ) break loop26;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(26, input);
throw eee;
}
cnt26++;
}
match('S'); if (state.failed) return;
}
break;
}
}
break;
case 2 :
// Lexer.g:315:7: 'T' ( DIGIT )+ 'M' ( ( DIGIT )+ 'S' )?
{
match('T'); if (state.failed) return;
// Lexer.g:315:11: ( DIGIT )+
int cnt28=0;
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( ((LA28_0 >= '0' && LA28_0 <= '9')) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt28 >= 1 ) break loop28;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(28, input);
throw eee;
}
cnt28++;
}
match('M'); if (state.failed) return;
// Lexer.g:315:22: ( ( DIGIT )+ 'S' )?
int alt30=2;
int LA30_0 = input.LA(1);
if ( ((LA30_0 >= '0' && LA30_0 <= '9')) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// Lexer.g:315:23: ( DIGIT )+ 'S'
{
// Lexer.g:315:23: ( DIGIT )+
int cnt29=0;
loop29:
while (true) {
int alt29=2;
int LA29_0 = input.LA(1);
if ( ((LA29_0 >= '0' && LA29_0 <= '9')) ) {
alt29=1;
}
switch (alt29) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt29 >= 1 ) break loop29;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(29, input);
throw eee;
}
cnt29++;
}
match('S'); if (state.failed) return;
}
break;
}
}
break;
case 3 :
// Lexer.g:316:7: 'T' ( DIGIT )+ 'S'
{
match('T'); if (state.failed) return;
// Lexer.g:316:11: ( DIGIT )+
int cnt31=0;
loop31:
while (true) {
int alt31=2;
int LA31_0 = input.LA(1);
if ( ((LA31_0 >= '0' && LA31_0 <= '9')) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt31 >= 1 ) break loop31;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(31, input);
throw eee;
}
cnt31++;
}
match('S'); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "DURATION_ISO_8601_TIME_DESIGNATORS"
// $ANTLR start "DURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR"
public final void mDURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR() throws RecognitionException {
try {
// Lexer.g:320:5: ( ( '-' )? 'P' ( DIGIT )+ 'W' )
// Lexer.g:320:7: ( '-' )? 'P' ( DIGIT )+ 'W'
{
// Lexer.g:320:7: ( '-' )?
int alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0=='-') ) {
alt33=1;
}
switch (alt33) {
case 1 :
// Lexer.g:320:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
// Lexer.g:320:16: ( DIGIT )+
int cnt34=0;
loop34:
while (true) {
int alt34=2;
int LA34_0 = input.LA(1);
if ( ((LA34_0 >= '0' && LA34_0 <= '9')) ) {
alt34=1;
}
switch (alt34) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt34 >= 1 ) break loop34;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(34, input);
throw eee;
}
cnt34++;
}
match('W'); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "DURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR"
// $ANTLR start "DURATION_UNIT"
public final void mDURATION_UNIT() throws RecognitionException {
try {
// Lexer.g:324:5: ( Y | M O | W | D | H | M | S | M S | U S | '\\u00B5' S | N S )
int alt35=11;
alt35 = dfa35.predict(input);
switch (alt35) {
case 1 :
// Lexer.g:324:7: Y
{
mY(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:325:7: M O
{
mM(); if (state.failed) return;
mO(); if (state.failed) return;
}
break;
case 3 :
// Lexer.g:326:7: W
{
mW(); if (state.failed) return;
}
break;
case 4 :
// Lexer.g:327:7: D
{
mD(); if (state.failed) return;
}
break;
case 5 :
// Lexer.g:328:7: H
{
mH(); if (state.failed) return;
}
break;
case 6 :
// Lexer.g:329:7: M
{
mM(); if (state.failed) return;
}
break;
case 7 :
// Lexer.g:330:7: S
{
mS(); if (state.failed) return;
}
break;
case 8 :
// Lexer.g:331:7: M S
{
mM(); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
case 9 :
// Lexer.g:332:7: U S
{
mU(); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
case 10 :
// Lexer.g:333:7: '\\u00B5' S
{
match('\u00B5'); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
case 11 :
// Lexer.g:334:7: N S
{
mN(); if (state.failed) return;
mS(); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "DURATION_UNIT"
// $ANTLR start "INTEGER"
public final void mINTEGER() throws RecognitionException {
try {
int _type = INTEGER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:338:5: ( ( '-' )? ( DIGIT )+ )
// Lexer.g:338:7: ( '-' )? ( DIGIT )+
{
// Lexer.g:338:7: ( '-' )?
int alt36=2;
int LA36_0 = input.LA(1);
if ( (LA36_0=='-') ) {
alt36=1;
}
switch (alt36) {
case 1 :
// Lexer.g:338:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
// Lexer.g:338:12: ( DIGIT )+
int cnt37=0;
loop37:
while (true) {
int alt37=2;
int LA37_0 = input.LA(1);
if ( ((LA37_0 >= '0' && LA37_0 <= '9')) ) {
alt37=1;
}
switch (alt37) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt37 >= 1 ) break loop37;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(37, input);
throw eee;
}
cnt37++;
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "INTEGER"
// $ANTLR start "QMARK"
public final void mQMARK() throws RecognitionException {
try {
int _type = QMARK;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:342:5: ( '?' )
// Lexer.g:342:7: '?'
{
match('?'); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "QMARK"
// $ANTLR start "RANGE"
public final void mRANGE() throws RecognitionException {
try {
int _type = RANGE;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:346:5: ( '..' )
// Lexer.g:346:7: '..'
{
match(".."); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "RANGE"
// $ANTLR start "FLOAT"
public final void mFLOAT() throws RecognitionException {
try {
int _type = FLOAT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:354:5: ( ( INTEGER '.' RANGE )=> INTEGER '.' | ( INTEGER RANGE )=> INTEGER | INTEGER ( '.' ( DIGIT )* )? ( EXPONENT )? )
int alt41=3;
int LA41_0 = input.LA(1);
if ( (LA41_0=='-') ) {
int LA41_1 = input.LA(2);
if ( ((LA41_1 >= '0' && LA41_1 <= '9')) ) {
int LA41_3 = input.LA(3);
if ( (LA41_3=='.') && (synpred1_Lexer())) {
alt41=1;
}
else if ( ((LA41_3 >= '0' && LA41_3 <= '9')) && (synpred1_Lexer())) {
alt41=1;
}
else if ( (synpred2_Lexer()) ) {
alt41=2;
}
else if ( (true) ) {
alt41=3;
}
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 41, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else if ( ((LA41_0 >= '0' && LA41_0 <= '9')) ) {
int LA41_2 = input.LA(2);
if ( (LA41_2=='.') && (synpred1_Lexer())) {
alt41=1;
}
else if ( ((LA41_2 >= '0' && LA41_2 <= '9')) && (synpred1_Lexer())) {
alt41=1;
}
else if ( (synpred2_Lexer()) ) {
alt41=2;
}
else if ( (true) ) {
alt41=3;
}
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 41, 0, input);
throw nvae;
}
switch (alt41) {
case 1 :
// Lexer.g:354:7: ( INTEGER '.' RANGE )=> INTEGER '.'
{
mINTEGER(); if (state.failed) return;
match('.'); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:355:7: ( INTEGER RANGE )=> INTEGER
{
mINTEGER(); if (state.failed) return;
if ( state.backtracking==0 ) {_type = INTEGER;}
}
break;
case 3 :
// Lexer.g:356:7: INTEGER ( '.' ( DIGIT )* )? ( EXPONENT )?
{
mINTEGER(); if (state.failed) return;
// Lexer.g:356:15: ( '.' ( DIGIT )* )?
int alt39=2;
int LA39_0 = input.LA(1);
if ( (LA39_0=='.') ) {
alt39=1;
}
switch (alt39) {
case 1 :
// Lexer.g:356:16: '.' ( DIGIT )*
{
match('.'); if (state.failed) return;
// Lexer.g:356:20: ( DIGIT )*
loop38:
while (true) {
int alt38=2;
int LA38_0 = input.LA(1);
if ( ((LA38_0 >= '0' && LA38_0 <= '9')) ) {
alt38=1;
}
switch (alt38) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 loop38;
}
}
}
break;
}
// Lexer.g:356:29: ( EXPONENT )?
int alt40=2;
int LA40_0 = input.LA(1);
if ( (LA40_0=='E'||LA40_0=='e') ) {
alt40=1;
}
switch (alt40) {
case 1 :
// Lexer.g:356:29: EXPONENT
{
mEXPONENT(); if (state.failed) return;
}
break;
}
}
break;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "FLOAT"
// $ANTLR start "BOOLEAN"
public final void mBOOLEAN() throws RecognitionException {
try {
int _type = BOOLEAN;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:363:5: ( T R U E | F A L S E )
int alt42=2;
int LA42_0 = input.LA(1);
if ( (LA42_0=='T'||LA42_0=='t') ) {
alt42=1;
}
else if ( (LA42_0=='F'||LA42_0=='f') ) {
alt42=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 42, 0, input);
throw nvae;
}
switch (alt42) {
case 1 :
// Lexer.g:363:7: T R U E
{
mT(); if (state.failed) return;
mR(); if (state.failed) return;
mU(); if (state.failed) return;
mE(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:363:17: F A L S E
{
mF(); if (state.failed) return;
mA(); if (state.failed) return;
mL(); if (state.failed) return;
mS(); if (state.failed) return;
mE(); if (state.failed) return;
}
break;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "BOOLEAN"
// $ANTLR start "DURATION"
public final void mDURATION() throws RecognitionException {
try {
int _type = DURATION;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:367:5: ( ( '-' )? ( DIGIT )+ DURATION_UNIT ( ( DIGIT )+ DURATION_UNIT )* | ( '-' )? 'P' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT 'T' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT | ( '-' )? 'P' DURATION_ISO_8601_TIME_DESIGNATORS | DURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR | DURATION_ISO_8601_PERIOD_DESIGNATORS ( DURATION_ISO_8601_TIME_DESIGNATORS )? )
int alt50=5;
alt50 = dfa50.predict(input);
switch (alt50) {
case 1 :
// Lexer.g:367:7: ( '-' )? ( DIGIT )+ DURATION_UNIT ( ( DIGIT )+ DURATION_UNIT )*
{
// Lexer.g:367:7: ( '-' )?
int alt43=2;
int LA43_0 = input.LA(1);
if ( (LA43_0=='-') ) {
alt43=1;
}
switch (alt43) {
case 1 :
// Lexer.g:367:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
// Lexer.g:367:12: ( DIGIT )+
int cnt44=0;
loop44:
while (true) {
int alt44=2;
int LA44_0 = input.LA(1);
if ( ((LA44_0 >= '0' && LA44_0 <= '9')) ) {
alt44=1;
}
switch (alt44) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt44 >= 1 ) break loop44;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(44, input);
throw eee;
}
cnt44++;
}
mDURATION_UNIT(); if (state.failed) return;
// Lexer.g:367:33: ( ( DIGIT )+ DURATION_UNIT )*
loop46:
while (true) {
int alt46=2;
int LA46_0 = input.LA(1);
if ( ((LA46_0 >= '0' && LA46_0 <= '9')) ) {
alt46=1;
}
switch (alt46) {
case 1 :
// Lexer.g:367:34: ( DIGIT )+ DURATION_UNIT
{
// Lexer.g:367:34: ( DIGIT )+
int cnt45=0;
loop45:
while (true) {
int alt45=2;
int LA45_0 = input.LA(1);
if ( ((LA45_0 >= '0' && LA45_0 <= '9')) ) {
alt45=1;
}
switch (alt45) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
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 ( cnt45 >= 1 ) break loop45;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(45, input);
throw eee;
}
cnt45++;
}
mDURATION_UNIT(); if (state.failed) return;
}
break;
default :
break loop46;
}
}
}
break;
case 2 :
// Lexer.g:368:7: ( '-' )? 'P' DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT 'T' DIGIT DIGIT ':' DIGIT DIGIT ':' DIGIT DIGIT
{
// Lexer.g:368:7: ( '-' )?
int alt47=2;
int LA47_0 = input.LA(1);
if ( (LA47_0=='-') ) {
alt47=1;
}
switch (alt47) {
case 1 :
// Lexer.g:368:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
match('-'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
match('-'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
match('T'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
match(':'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
match(':'); if (state.failed) return;
mDIGIT(); if (state.failed) return;
mDIGIT(); if (state.failed) return;
}
break;
case 3 :
// Lexer.g:369:7: ( '-' )? 'P' DURATION_ISO_8601_TIME_DESIGNATORS
{
// Lexer.g:369:7: ( '-' )?
int alt48=2;
int LA48_0 = input.LA(1);
if ( (LA48_0=='-') ) {
alt48=1;
}
switch (alt48) {
case 1 :
// Lexer.g:369:7: '-'
{
match('-'); if (state.failed) return;
}
break;
}
match('P'); if (state.failed) return;
mDURATION_ISO_8601_TIME_DESIGNATORS(); if (state.failed) return;
}
break;
case 4 :
// Lexer.g:370:7: DURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR
{
mDURATION_ISO_8601_WEEK_PERIOD_DESIGNATOR(); if (state.failed) return;
}
break;
case 5 :
// Lexer.g:371:7: DURATION_ISO_8601_PERIOD_DESIGNATORS ( DURATION_ISO_8601_TIME_DESIGNATORS )?
{
mDURATION_ISO_8601_PERIOD_DESIGNATORS(); if (state.failed) return;
// Lexer.g:371:44: ( DURATION_ISO_8601_TIME_DESIGNATORS )?
int alt49=2;
int LA49_0 = input.LA(1);
if ( (LA49_0=='T') ) {
alt49=1;
}
switch (alt49) {
case 1 :
// Lexer.g:371:44: DURATION_ISO_8601_TIME_DESIGNATORS
{
mDURATION_ISO_8601_TIME_DESIGNATORS(); if (state.failed) return;
}
break;
}
}
break;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "DURATION"
// $ANTLR start "IDENT"
public final void mIDENT() throws RecognitionException {
try {
int _type = IDENT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:375:5: ( LETTER ( LETTER | DIGIT | '_' )* )
// Lexer.g:375:7: LETTER ( LETTER | DIGIT | '_' )*
{
mLETTER(); if (state.failed) return;
// Lexer.g:375:14: ( LETTER | DIGIT | '_' )*
loop51:
while (true) {
int alt51=2;
int LA51_0 = input.LA(1);
if ( ((LA51_0 >= '0' && LA51_0 <= '9')||(LA51_0 >= 'A' && LA51_0 <= 'Z')||LA51_0=='_'||(LA51_0 >= 'a' && LA51_0 <= 'z')) ) {
alt51=1;
}
switch (alt51) {
case 1 :
// Lexer.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 :
break loop51;
}
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "IDENT"
// $ANTLR start "HEXNUMBER"
public final void mHEXNUMBER() throws RecognitionException {
try {
int _type = HEXNUMBER;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:379:5: ( '0' X ( HEX )* )
// Lexer.g:379:7: '0' X ( HEX )*
{
match('0'); if (state.failed) return;
mX(); if (state.failed) return;
// Lexer.g:379:13: ( HEX )*
loop52:
while (true) {
int alt52=2;
int LA52_0 = input.LA(1);
if ( ((LA52_0 >= '0' && LA52_0 <= '9')||(LA52_0 >= 'A' && LA52_0 <= 'F')||(LA52_0 >= 'a' && LA52_0 <= 'f')) ) {
alt52=1;
}
switch (alt52) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
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 loop52;
}
}
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "HEXNUMBER"
// $ANTLR start "UUID"
public final void mUUID() throws RecognitionException {
try {
int _type = UUID;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:383:5: ( HEX HEX HEX HEX HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX )
// Lexer.g:383:7: HEX HEX HEX HEX HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX
{
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
match('-'); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
match('-'); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
match('-'); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
match('-'); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
mHEX(); if (state.failed) return;
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "UUID"
// $ANTLR start "WS"
public final void mWS() throws RecognitionException {
try {
int _type = WS;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:391:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
// Lexer.g:391:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
{
// Lexer.g:391:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
int cnt53=0;
loop53:
while (true) {
int alt53=2;
int LA53_0 = input.LA(1);
if ( ((LA53_0 >= '\t' && LA53_0 <= '\n')||LA53_0=='\r'||LA53_0==' ') ) {
alt53=1;
}
switch (alt53) {
case 1 :
// Lexer.g:
{
if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||input.LA(1)=='\r'||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 ( cnt53 >= 1 ) break loop53;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(53, input);
throw eee;
}
cnt53++;
}
if ( state.backtracking==0 ) { _channel = HIDDEN; }
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "WS"
// $ANTLR start "COMMENT"
public final void mCOMMENT() throws RecognitionException {
try {
int _type = COMMENT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:395:5: ( ( '--' | '//' ) ( . )* ( '\\n' | '\\r' ) )
// Lexer.g:395:7: ( '--' | '//' ) ( . )* ( '\\n' | '\\r' )
{
// Lexer.g:395:7: ( '--' | '//' )
int alt54=2;
int LA54_0 = input.LA(1);
if ( (LA54_0=='-') ) {
alt54=1;
}
else if ( (LA54_0=='/') ) {
alt54=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 54, 0, input);
throw nvae;
}
switch (alt54) {
case 1 :
// Lexer.g:395:8: '--'
{
match("--"); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:395:15: '//'
{
match("//"); if (state.failed) return;
}
break;
}
// Lexer.g:395:21: ( . )*
loop55:
while (true) {
int alt55=2;
int LA55_0 = input.LA(1);
if ( (LA55_0=='\n'||LA55_0=='\r') ) {
alt55=2;
}
else if ( ((LA55_0 >= '\u0000' && LA55_0 <= '\t')||(LA55_0 >= '\u000B' && LA55_0 <= '\f')||(LA55_0 >= '\u000E' && LA55_0 <= '\uFFFF')) ) {
alt55=1;
}
switch (alt55) {
case 1 :
// Lexer.g:395:21: .
{
matchAny(); if (state.failed) return;
}
break;
default :
break loop55;
}
}
if ( input.LA(1)=='\n'||input.LA(1)=='\r' ) {
input.consume();
state.failed=false;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
MismatchedSetException mse = new MismatchedSetException(null,input);
recover(mse);
throw mse;
}
if ( state.backtracking==0 ) { _channel = HIDDEN; }
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "COMMENT"
// $ANTLR start "MULTILINE_COMMENT"
public final void mMULTILINE_COMMENT() throws RecognitionException {
try {
int _type = MULTILINE_COMMENT;
int _channel = DEFAULT_TOKEN_CHANNEL;
// Lexer.g:399:5: ( '/*' ( . )* '*/' )
// Lexer.g:399:7: '/*' ( . )* '*/'
{
match("/*"); if (state.failed) return;
// Lexer.g:399:12: ( . )*
loop56:
while (true) {
int alt56=2;
int LA56_0 = input.LA(1);
if ( (LA56_0=='*') ) {
int LA56_1 = input.LA(2);
if ( (LA56_1=='/') ) {
alt56=2;
}
else if ( ((LA56_1 >= '\u0000' && LA56_1 <= '.')||(LA56_1 >= '0' && LA56_1 <= '\uFFFF')) ) {
alt56=1;
}
}
else if ( ((LA56_0 >= '\u0000' && LA56_0 <= ')')||(LA56_0 >= '+' && LA56_0 <= '\uFFFF')) ) {
alt56=1;
}
switch (alt56) {
case 1 :
// Lexer.g:399:12: .
{
matchAny(); if (state.failed) return;
}
break;
default :
break loop56;
}
}
match("*/"); if (state.failed) return;
if ( state.backtracking==0 ) { _channel = HIDDEN; }
}
state.type = _type;
state.channel = _channel;
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "MULTILINE_COMMENT"
@Override
public void mTokens() throws RecognitionException {
// Lexer.g:1:8: ( K_SELECT | K_FROM | K_AS | K_WHERE | K_AND | K_KEY | K_KEYS | K_ENTRIES | K_FULL | K_INSERT | K_UPDATE | K_WITH | K_LIMIT | K_PER | K_PARTITION | K_USING | K_USE | K_DISTINCT | K_COUNT | K_SET | K_BEGIN | K_UNLOGGED | K_BATCH | K_APPLY | K_TRUNCATE | K_DELETE | K_IN | K_CREATE | K_SCHEMA | K_KEYSPACE | K_KEYSPACES | K_COLUMNFAMILY | K_TABLES | K_MATERIALIZED | K_VIEW | K_INDEX | K_CUSTOM | K_ON | K_TO | K_DROP | K_PRIMARY | K_INTO | K_VALUES | K_TIMESTAMP | K_TTL | K_CAST | K_ALTER | K_RENAME | K_ADD | K_TYPE | K_TYPES | K_COMPACT | K_STORAGE | K_ORDER | K_BY | K_ASC | K_DESC | K_ALLOW | K_FILTERING | K_IF | K_IS | K_CONTAINS | K_GROUP | K_CLUSTER | K_INTERNALS | K_ONLY | K_GRANT | K_ALL | K_PERMISSION | K_PERMISSIONS | K_OF | K_REVOKE | K_MODIFY | K_AUTHORIZE | K_DESCRIBE | K_EXECUTE | K_NORECURSIVE | K_MBEAN | K_MBEANS | K_USER | K_USERS | K_ROLE | K_ROLES | K_SUPERUSER | K_NOSUPERUSER | K_PASSWORD | K_HASHED | K_LOGIN | K_NOLOGIN | K_OPTIONS | K_ACCESS | K_DATACENTERS | K_CIDRS | K_IDENTITY | K_CLUSTERING | K_ASCII | K_BIGINT | K_BLOB | K_BOOLEAN | K_COUNTER | K_DECIMAL | K_DOUBLE | K_DURATION | K_FLOAT | K_INET | K_INT | K_SMALLINT | K_TINYINT | K_TEXT | K_UUID | K_VARCHAR | K_VARINT | K_TIMEUUID | K_TOKEN | K_WRITETIME | K_MAXWRITETIME | K_DATE | K_TIME | K_NULL | K_NOT | K_EXISTS | K_MAP | K_LIST | K_POSITIVE_NAN | K_NEGATIVE_NAN | K_POSITIVE_INFINITY | K_NEGATIVE_INFINITY | K_TUPLE | K_TRIGGER | K_STATIC | K_FROZEN | K_FUNCTION | K_FUNCTIONS | K_AGGREGATE | K_AGGREGATES | K_SFUNC | K_STYPE | K_FINALFUNC | K_INITCOND | K_RETURNS | K_CALLED | K_INPUT | K_LANGUAGE | K_OR | K_REPLACE | K_JSON | K_DEFAULT | K_UNSET | K_LIKE | K_MASKED | K_UNMASK | K_SELECT_MASKED | K_VECTOR | K_ANN | STRING_LITERAL | QUOTED_NAME | EMPTY_QUOTED_NAME | INTEGER | QMARK | RANGE | FLOAT | BOOLEAN | DURATION | IDENT | HEXNUMBER | UUID | WS | COMMENT | MULTILINE_COMMENT )
int alt57=169;
alt57 = dfa57.predict(input);
switch (alt57) {
case 1 :
// Lexer.g:1:10: K_SELECT
{
mK_SELECT(); if (state.failed) return;
}
break;
case 2 :
// Lexer.g:1:19: K_FROM
{
mK_FROM(); if (state.failed) return;
}
break;
case 3 :
// Lexer.g:1:26: K_AS
{
mK_AS(); if (state.failed) return;
}
break;
case 4 :
// Lexer.g:1:31: K_WHERE
{
mK_WHERE(); if (state.failed) return;
}
break;
case 5 :
// Lexer.g:1:39: K_AND
{
mK_AND(); if (state.failed) return;
}
break;
case 6 :
// Lexer.g:1:45: K_KEY
{
mK_KEY(); if (state.failed) return;
}
break;
case 7 :
// Lexer.g:1:51: K_KEYS
{
mK_KEYS(); if (state.failed) return;
}
break;
case 8 :
// Lexer.g:1:58: K_ENTRIES
{
mK_ENTRIES(); if (state.failed) return;
}
break;
case 9 :
// Lexer.g:1:68: K_FULL
{
mK_FULL(); if (state.failed) return;
}
break;
case 10 :
// Lexer.g:1:75: K_INSERT
{
mK_INSERT(); if (state.failed) return;
}
break;
case 11 :
// Lexer.g:1:84: K_UPDATE
{
mK_UPDATE(); if (state.failed) return;
}
break;
case 12 :
// Lexer.g:1:93: K_WITH
{
mK_WITH(); if (state.failed) return;
}
break;
case 13 :
// Lexer.g:1:100: K_LIMIT
{
mK_LIMIT(); if (state.failed) return;
}
break;
case 14 :
// Lexer.g:1:108: K_PER
{
mK_PER(); if (state.failed) return;
}
break;
case 15 :
// Lexer.g:1:114: K_PARTITION
{
mK_PARTITION(); if (state.failed) return;
}
break;
case 16 :
// Lexer.g:1:126: K_USING
{
mK_USING(); if (state.failed) return;
}
break;
case 17 :
// Lexer.g:1:134: K_USE
{
mK_USE(); if (state.failed) return;
}
break;
case 18 :
// Lexer.g:1:140: K_DISTINCT
{
mK_DISTINCT(); if (state.failed) return;
}
break;
case 19 :
// Lexer.g:1:151: K_COUNT
{
mK_COUNT(); if (state.failed) return;
}
break;
case 20 :
// Lexer.g:1:159: K_SET
{
mK_SET(); if (state.failed) return;
}
break;
case 21 :
// Lexer.g:1:165: K_BEGIN
{
mK_BEGIN(); if (state.failed) return;
}
break;
case 22 :
// Lexer.g:1:173: K_UNLOGGED
{
mK_UNLOGGED(); if (state.failed) return;
}
break;
case 23 :
// Lexer.g:1:184: K_BATCH
{
mK_BATCH(); if (state.failed) return;
}
break;
case 24 :
// Lexer.g:1:192: K_APPLY
{
mK_APPLY(); if (state.failed) return;
}
break;
case 25 :
// Lexer.g:1:200: K_TRUNCATE
{
mK_TRUNCATE(); if (state.failed) return;
}
break;
case 26 :
// Lexer.g:1:211: K_DELETE
{
mK_DELETE(); if (state.failed) return;
}
break;
case 27 :
// Lexer.g:1:220: K_IN
{
mK_IN(); if (state.failed) return;
}
break;
case 28 :
// Lexer.g:1:225: K_CREATE
{
mK_CREATE(); if (state.failed) return;
}
break;
case 29 :
// Lexer.g:1:234: K_SCHEMA
{
mK_SCHEMA(); if (state.failed) return;
}
break;
case 30 :
// Lexer.g:1:243: K_KEYSPACE
{
mK_KEYSPACE(); if (state.failed) return;
}
break;
case 31 :
// Lexer.g:1:254: K_KEYSPACES
{
mK_KEYSPACES(); if (state.failed) return;
}
break;
case 32 :
// Lexer.g:1:266: K_COLUMNFAMILY
{
mK_COLUMNFAMILY(); if (state.failed) return;
}
break;
case 33 :
// Lexer.g:1:281: K_TABLES
{
mK_TABLES(); if (state.failed) return;
}
break;
case 34 :
// Lexer.g:1:290: K_MATERIALIZED
{
mK_MATERIALIZED(); if (state.failed) return;
}
break;
case 35 :
// Lexer.g:1:305: K_VIEW
{
mK_VIEW(); if (state.failed) return;
}
break;
case 36 :
// Lexer.g:1:312: K_INDEX
{
mK_INDEX(); if (state.failed) return;
}
break;
case 37 :
// Lexer.g:1:320: K_CUSTOM
{
mK_CUSTOM(); if (state.failed) return;
}
break;
case 38 :
// Lexer.g:1:329: K_ON
{
mK_ON(); if (state.failed) return;
}
break;
case 39 :
// Lexer.g:1:334: K_TO
{
mK_TO(); if (state.failed) return;
}
break;
case 40 :
// Lexer.g:1:339: K_DROP
{
mK_DROP(); if (state.failed) return;
}
break;
case 41 :
// Lexer.g:1:346: K_PRIMARY
{
mK_PRIMARY(); if (state.failed) return;
}
break;
case 42 :
// Lexer.g:1:356: K_INTO
{
mK_INTO(); if (state.failed) return;
}
break;
case 43 :
// Lexer.g:1:363: K_VALUES
{
mK_VALUES(); if (state.failed) return;
}
break;
case 44 :
// Lexer.g:1:372: K_TIMESTAMP
{
mK_TIMESTAMP(); if (state.failed) return;
}
break;
case 45 :
// Lexer.g:1:384: K_TTL
{
mK_TTL(); if (state.failed) return;
}
break;
case 46 :
// Lexer.g:1:390: K_CAST
{
mK_CAST(); if (state.failed) return;
}
break;
case 47 :
// Lexer.g:1:397: K_ALTER
{
mK_ALTER(); if (state.failed) return;
}
break;
case 48 :
// Lexer.g:1:405: K_RENAME
{
mK_RENAME(); if (state.failed) return;
}
break;
case 49 :
// Lexer.g:1:414: K_ADD
{
mK_ADD(); if (state.failed) return;
}
break;
case 50 :
// Lexer.g:1:420: K_TYPE
{
mK_TYPE(); if (state.failed) return;
}
break;
case 51 :
// Lexer.g:1:427: K_TYPES
{
mK_TYPES(); if (state.failed) return;
}
break;
case 52 :
// Lexer.g:1:435: K_COMPACT
{
mK_COMPACT(); if (state.failed) return;
}
break;
case 53 :
// Lexer.g:1:445: K_STORAGE
{
mK_STORAGE(); if (state.failed) return;
}
break;
case 54 :
// Lexer.g:1:455: K_ORDER
{
mK_ORDER(); if (state.failed) return;
}
break;
case 55 :
// Lexer.g:1:463: K_BY
{
mK_BY(); if (state.failed) return;
}
break;
case 56 :
// Lexer.g:1:468: K_ASC
{
mK_ASC(); if (state.failed) return;
}
break;
case 57 :
// Lexer.g:1:474: K_DESC
{
mK_DESC(); if (state.failed) return;
}
break;
case 58 :
// Lexer.g:1:481: K_ALLOW
{
mK_ALLOW(); if (state.failed) return;
}
break;
case 59 :
// Lexer.g:1:489: K_FILTERING
{
mK_FILTERING(); if (state.failed) return;
}
break;
case 60 :
// Lexer.g:1:501: K_IF
{
mK_IF(); if (state.failed) return;
}
break;
case 61 :
// Lexer.g:1:506: K_IS
{
mK_IS(); if (state.failed) return;
}
break;
case 62 :
// Lexer.g:1:511: K_CONTAINS
{
mK_CONTAINS(); if (state.failed) return;
}
break;
case 63 :
// Lexer.g:1:522: K_GROUP
{
mK_GROUP(); if (state.failed) return;
}
break;
case 64 :
// Lexer.g:1:530: K_CLUSTER
{
mK_CLUSTER(); if (state.failed) return;
}
break;
case 65 :
// Lexer.g:1:540: K_INTERNALS
{
mK_INTERNALS(); if (state.failed) return;
}
break;
case 66 :
// Lexer.g:1:552: K_ONLY
{
mK_ONLY(); if (state.failed) return;
}
break;
case 67 :
// Lexer.g:1:559: K_GRANT
{
mK_GRANT(); if (state.failed) return;
}
break;
case 68 :
// Lexer.g:1:567: K_ALL
{
mK_ALL(); if (state.failed) return;
}
break;
case 69 :
// Lexer.g:1:573: K_PERMISSION
{
mK_PERMISSION(); if (state.failed) return;
}
break;
case 70 :
// Lexer.g:1:586: K_PERMISSIONS
{
mK_PERMISSIONS(); if (state.failed) return;
}
break;
case 71 :
// Lexer.g:1:600: K_OF
{
mK_OF(); if (state.failed) return;
}
break;
case 72 :
// Lexer.g:1:605: K_REVOKE
{
mK_REVOKE(); if (state.failed) return;
}
break;
case 73 :
// Lexer.g:1:614: K_MODIFY
{
mK_MODIFY(); if (state.failed) return;
}
break;
case 74 :
// Lexer.g:1:623: K_AUTHORIZE
{
mK_AUTHORIZE(); if (state.failed) return;
}
break;
case 75 :
// Lexer.g:1:635: K_DESCRIBE
{
mK_DESCRIBE(); if (state.failed) return;
}
break;
case 76 :
// Lexer.g:1:646: K_EXECUTE
{
mK_EXECUTE(); if (state.failed) return;
}
break;
case 77 :
// Lexer.g:1:656: K_NORECURSIVE
{
mK_NORECURSIVE(); if (state.failed) return;
}
break;
case 78 :
// Lexer.g:1:670: K_MBEAN
{
mK_MBEAN(); if (state.failed) return;
}
break;
case 79 :
// Lexer.g:1:678: K_MBEANS
{
mK_MBEANS(); if (state.failed) return;
}
break;
case 80 :
// Lexer.g:1:687: K_USER
{
mK_USER(); if (state.failed) return;
}
break;
case 81 :
// Lexer.g:1:694: K_USERS
{
mK_USERS(); if (state.failed) return;
}
break;
case 82 :
// Lexer.g:1:702: K_ROLE
{
mK_ROLE(); if (state.failed) return;
}
break;
case 83 :
// Lexer.g:1:709: K_ROLES
{
mK_ROLES(); if (state.failed) return;
}
break;
case 84 :
// Lexer.g:1:717: K_SUPERUSER
{
mK_SUPERUSER(); if (state.failed) return;
}
break;
case 85 :
// Lexer.g:1:729: K_NOSUPERUSER
{
mK_NOSUPERUSER(); if (state.failed) return;
}
break;
case 86 :
// Lexer.g:1:743: K_PASSWORD
{
mK_PASSWORD(); if (state.failed) return;
}
break;
case 87 :
// Lexer.g:1:754: K_HASHED
{
mK_HASHED(); if (state.failed) return;
}
break;
case 88 :
// Lexer.g:1:763: K_LOGIN
{
mK_LOGIN(); if (state.failed) return;
}
break;
case 89 :
// Lexer.g:1:771: K_NOLOGIN
{
mK_NOLOGIN(); if (state.failed) return;
}
break;
case 90 :
// Lexer.g:1:781: K_OPTIONS
{
mK_OPTIONS(); if (state.failed) return;
}
break;
case 91 :
// Lexer.g:1:791: K_ACCESS
{
mK_ACCESS(); if (state.failed) return;
}
break;
case 92 :
// Lexer.g:1:800: K_DATACENTERS
{
mK_DATACENTERS(); if (state.failed) return;
}
break;
case 93 :
// Lexer.g:1:814: K_CIDRS
{
mK_CIDRS(); if (state.failed) return;
}
break;
case 94 :
// Lexer.g:1:822: K_IDENTITY
{
mK_IDENTITY(); if (state.failed) return;
}
break;
case 95 :
// Lexer.g:1:833: K_CLUSTERING
{
mK_CLUSTERING(); if (state.failed) return;
}
break;
case 96 :
// Lexer.g:1:846: K_ASCII
{
mK_ASCII(); if (state.failed) return;
}
break;
case 97 :
// Lexer.g:1:854: K_BIGINT
{
mK_BIGINT(); if (state.failed) return;
}
break;
case 98 :
// Lexer.g:1:863: K_BLOB
{
mK_BLOB(); if (state.failed) return;
}
break;
case 99 :
// Lexer.g:1:870: K_BOOLEAN
{
mK_BOOLEAN(); if (state.failed) return;
}
break;
case 100 :
// Lexer.g:1:880: K_COUNTER
{
mK_COUNTER(); if (state.failed) return;
}
break;
case 101 :
// Lexer.g:1:890: K_DECIMAL
{
mK_DECIMAL(); if (state.failed) return;
}
break;
case 102 :
// Lexer.g:1:900: K_DOUBLE
{
mK_DOUBLE(); if (state.failed) return;
}
break;
case 103 :
// Lexer.g:1:909: K_DURATION
{
mK_DURATION(); if (state.failed) return;
}
break;
case 104 :
// Lexer.g:1:920: K_FLOAT
{
mK_FLOAT(); if (state.failed) return;
}
break;
case 105 :
// Lexer.g:1:928: K_INET
{
mK_INET(); if (state.failed) return;
}
break;
case 106 :
// Lexer.g:1:935: K_INT
{
mK_INT(); if (state.failed) return;
}
break;
case 107 :
// Lexer.g:1:941: K_SMALLINT
{
mK_SMALLINT(); if (state.failed) return;
}
break;
case 108 :
// Lexer.g:1:952: K_TINYINT
{
mK_TINYINT(); if (state.failed) return;
}
break;
case 109 :
// Lexer.g:1:962: K_TEXT
{
mK_TEXT(); if (state.failed) return;
}
break;
case 110 :
// Lexer.g:1:969: K_UUID
{
mK_UUID(); if (state.failed) return;
}
break;
case 111 :
// Lexer.g:1:976: K_VARCHAR
{
mK_VARCHAR(); if (state.failed) return;
}
break;
case 112 :
// Lexer.g:1:986: K_VARINT
{
mK_VARINT(); if (state.failed) return;
}
break;
case 113 :
// Lexer.g:1:995: K_TIMEUUID
{
mK_TIMEUUID(); if (state.failed) return;
}
break;
case 114 :
// Lexer.g:1:1006: K_TOKEN
{
mK_TOKEN(); if (state.failed) return;
}
break;
case 115 :
// Lexer.g:1:1014: K_WRITETIME
{
mK_WRITETIME(); if (state.failed) return;
}
break;
case 116 :
// Lexer.g:1:1026: K_MAXWRITETIME
{
mK_MAXWRITETIME(); if (state.failed) return;
}
break;
case 117 :
// Lexer.g:1:1041: K_DATE
{
mK_DATE(); if (state.failed) return;
}
break;
case 118 :
// Lexer.g:1:1048: K_TIME
{
mK_TIME(); if (state.failed) return;
}
break;
case 119 :
// Lexer.g:1:1055: K_NULL
{
mK_NULL(); if (state.failed) return;
}
break;
case 120 :
// Lexer.g:1:1062: K_NOT
{
mK_NOT(); if (state.failed) return;
}
break;
case 121 :
// Lexer.g:1:1068: K_EXISTS
{
mK_EXISTS(); if (state.failed) return;
}
break;
case 122 :
// Lexer.g:1:1077: K_MAP
{
mK_MAP(); if (state.failed) return;
}
break;
case 123 :
// Lexer.g:1:1083: K_LIST
{
mK_LIST(); if (state.failed) return;
}
break;
case 124 :
// Lexer.g:1:1090: K_POSITIVE_NAN
{
mK_POSITIVE_NAN(); if (state.failed) return;
}
break;
case 125 :
// Lexer.g:1:1105: K_NEGATIVE_NAN
{
mK_NEGATIVE_NAN(); if (state.failed) return;
}
break;
case 126 :
// Lexer.g:1:1120: K_POSITIVE_INFINITY
{
mK_POSITIVE_INFINITY(); if (state.failed) return;
}
break;
case 127 :
// Lexer.g:1:1140: K_NEGATIVE_INFINITY
{
mK_NEGATIVE_INFINITY(); if (state.failed) return;
}
break;
case 128 :
// Lexer.g:1:1160: K_TUPLE
{
mK_TUPLE(); if (state.failed) return;
}
break;
case 129 :
// Lexer.g:1:1168: K_TRIGGER
{
mK_TRIGGER(); if (state.failed) return;
}
break;
case 130 :
// Lexer.g:1:1178: K_STATIC
{
mK_STATIC(); if (state.failed) return;
}
break;
case 131 :
// Lexer.g:1:1187: K_FROZEN
{
mK_FROZEN(); if (state.failed) return;
}
break;
case 132 :
// Lexer.g:1:1196: K_FUNCTION
{
mK_FUNCTION(); if (state.failed) return;
}
break;
case 133 :
// Lexer.g:1:1207: K_FUNCTIONS
{
mK_FUNCTIONS(); if (state.failed) return;
}
break;
case 134 :
// Lexer.g:1:1219: K_AGGREGATE
{
mK_AGGREGATE(); if (state.failed) return;
}
break;
case 135 :
// Lexer.g:1:1231: K_AGGREGATES
{
mK_AGGREGATES(); if (state.failed) return;
}
break;
case 136 :
// Lexer.g:1:1244: K_SFUNC
{
mK_SFUNC(); if (state.failed) return;
}
break;
case 137 :
// Lexer.g:1:1252: K_STYPE
{
mK_STYPE(); if (state.failed) return;
}
break;
case 138 :
// Lexer.g:1:1260: K_FINALFUNC
{
mK_FINALFUNC(); if (state.failed) return;
}
break;
case 139 :
// Lexer.g:1:1272: K_INITCOND
{
mK_INITCOND(); if (state.failed) return;
}
break;
case 140 :
// Lexer.g:1:1283: K_RETURNS
{
mK_RETURNS(); if (state.failed) return;
}
break;
case 141 :
// Lexer.g:1:1293: K_CALLED
{
mK_CALLED(); if (state.failed) return;
}
break;
case 142 :
// Lexer.g:1:1302: K_INPUT
{
mK_INPUT(); if (state.failed) return;
}
break;
case 143 :
// Lexer.g:1:1310: K_LANGUAGE
{
mK_LANGUAGE(); if (state.failed) return;
}
break;
case 144 :
// Lexer.g:1:1321: K_OR
{
mK_OR(); if (state.failed) return;
}
break;
case 145 :
// Lexer.g:1:1326: K_REPLACE
{
mK_REPLACE(); if (state.failed) return;
}
break;
case 146 :
// Lexer.g:1:1336: K_JSON
{
mK_JSON(); if (state.failed) return;
}
break;
case 147 :
// Lexer.g:1:1343: K_DEFAULT
{
mK_DEFAULT(); if (state.failed) return;
}
break;
case 148 :
// Lexer.g:1:1353: K_UNSET
{
mK_UNSET(); if (state.failed) return;
}
break;
case 149 :
// Lexer.g:1:1361: K_LIKE
{
mK_LIKE(); if (state.failed) return;
}
break;
case 150 :
// Lexer.g:1:1368: K_MASKED
{
mK_MASKED(); if (state.failed) return;
}
break;
case 151 :
// Lexer.g:1:1377: K_UNMASK
{
mK_UNMASK(); if (state.failed) return;
}
break;
case 152 :
// Lexer.g:1:1386: K_SELECT_MASKED
{
mK_SELECT_MASKED(); if (state.failed) return;
}
break;
case 153 :
// Lexer.g:1:1402: K_VECTOR
{
mK_VECTOR(); if (state.failed) return;
}
break;
case 154 :
// Lexer.g:1:1411: K_ANN
{
mK_ANN(); if (state.failed) return;
}
break;
case 155 :
// Lexer.g:1:1417: STRING_LITERAL
{
mSTRING_LITERAL(); if (state.failed) return;
}
break;
case 156 :
// Lexer.g:1:1432: QUOTED_NAME
{
mQUOTED_NAME(); if (state.failed) return;
}
break;
case 157 :
// Lexer.g:1:1444: EMPTY_QUOTED_NAME
{
mEMPTY_QUOTED_NAME(); if (state.failed) return;
}
break;
case 158 :
// Lexer.g:1:1462: INTEGER
{
mINTEGER(); if (state.failed) return;
}
break;
case 159 :
// Lexer.g:1:1470: QMARK
{
mQMARK(); if (state.failed) return;
}
break;
case 160 :
// Lexer.g:1:1476: RANGE
{
mRANGE(); if (state.failed) return;
}
break;
case 161 :
// Lexer.g:1:1482: FLOAT
{
mFLOAT(); if (state.failed) return;
}
break;
case 162 :
// Lexer.g:1:1488: BOOLEAN
{
mBOOLEAN(); if (state.failed) return;
}
break;
case 163 :
// Lexer.g:1:1496: DURATION
{
mDURATION(); if (state.failed) return;
}
break;
case 164 :
// Lexer.g:1:1505: IDENT
{
mIDENT(); if (state.failed) return;
}
break;
case 165 :
// Lexer.g:1:1511: HEXNUMBER
{
mHEXNUMBER(); if (state.failed) return;
}
break;
case 166 :
// Lexer.g:1:1521: UUID
{
mUUID(); if (state.failed) return;
}
break;
case 167 :
// Lexer.g:1:1526: WS
{
mWS(); if (state.failed) return;
}
break;
case 168 :
// Lexer.g:1:1529: COMMENT
{
mCOMMENT(); if (state.failed) return;
}
break;
case 169 :
// Lexer.g:1:1537: MULTILINE_COMMENT
{
mMULTILINE_COMMENT(); if (state.failed) return;
}
break;
}
}
// $ANTLR start synpred1_Lexer
public final void synpred1_Lexer_fragment() throws RecognitionException {
// Lexer.g:354:7: ( INTEGER '.' RANGE )
// Lexer.g:354:8: INTEGER '.' RANGE
{
mINTEGER(); if (state.failed) return;
match('.'); if (state.failed) return;
mRANGE(); if (state.failed) return;
}
}
// $ANTLR end synpred1_Lexer
// $ANTLR start synpred2_Lexer
public final void synpred2_Lexer_fragment() throws RecognitionException {
// Lexer.g:355:7: ( INTEGER RANGE )
// Lexer.g:355:8: INTEGER RANGE
{
mINTEGER(); if (state.failed) return;
mRANGE(); if (state.failed) return;
}
}
// $ANTLR end synpred2_Lexer
public final boolean synpred2_Lexer() {
state.backtracking++;
int start = input.mark();
try {
synpred2_Lexer_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 synpred1_Lexer() {
state.backtracking++;
int start = input.mark();
try {
synpred1_Lexer_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;
}
protected DFA22 dfa22 = new DFA22(this);
protected DFA13 dfa13 = new DFA13(this);
protected DFA32 dfa32 = new DFA32(this);
protected DFA25 dfa25 = new DFA25(this);
protected DFA35 dfa35 = new DFA35(this);
protected DFA50 dfa50 = new DFA50(this);
protected DFA57 dfa57 = new DFA57(this);
static final String DFA22_eotS =
"\7\uffff";
static final String DFA22_eofS =
"\7\uffff";
static final String DFA22_minS =
"\1\55\1\120\2\60\3\uffff";
static final String DFA22_maxS =
"\2\120\1\71\1\131\3\uffff";
static final String DFA22_acceptS =
"\4\uffff\1\1\1\2\1\3";
static final String DFA22_specialS =
"\7\uffff}>";
static final String[] DFA22_transitionS = {
"\1\1\42\uffff\1\2",
"\1\2",
"\12\3",
"\12\3\12\uffff\1\6\10\uffff\1\5\13\uffff\1\4",
"",
"",
""
};
static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
static final short[][] DFA22_transition;
static {
int numStates = DFA22_transitionS.length;
DFA22_transition = new short[numStates][];
for (int i=0; i= '\u0000' && LA57_25 <= '!')||(LA57_25 >= '#' && LA57_25 <= '\uFFFF')) ) {s = 126;}
if ( s>=0 ) return s;
break;
}
if (state.backtracking>0) {state.failed=true; return -1;}
NoViableAltException nvae =
new NoViableAltException(getDescription(), 57, _s, input);
error(nvae);
throw nvae;
}
}
}