You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by br...@apache.org on 2011/07/29 16:21:09 UTC
svn commit: r1152233 [6/9] - in /cassandra/trunk: conf/ src/gen-java/
src/gen-java/org/ src/gen-java/org/apache/
src/gen-java/org/apache/cassandra/ src/gen-java/org/apache/cassandra/cli/
src/gen-java/org/apache/cassandra/cql/ src/java/org/apache/cassan...
Added: cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java
URL: http://svn.apache.org/viewvc/cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java?rev=1152233&view=auto
==============================================================================
--- cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java (added)
+++ cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java Fri Jul 29 14:21:06 2011
@@ -0,0 +1,4305 @@
+// $ANTLR 3.2 Sep 23, 2009 12:02:23 /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g 2011-07-28 15:11:06
+
+ package org.apache.cassandra.cql;
+ import org.apache.cassandra.thrift.InvalidRequestException;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+public class CqlLexer extends Lexer {
+ public static final int LETTER=75;
+ public static final int K_CREATE=32;
+ public static final int EOF=-1;
+ public static final int K_PRIMARY=37;
+ public static final int T__93=93;
+ public static final int T__94=94;
+ public static final int T__91=91;
+ public static final int K_USE=4;
+ public static final int T__92=92;
+ public static final int K_VALUES=23;
+ public static final int STRING_LITERAL=9;
+ public static final int T__90=90;
+ public static final int K_ON=41;
+ public static final int K_USING=11;
+ public static final int K_ADD=45;
+ public static final int K_KEY=38;
+ public static final int K_TRUNCATE=47;
+ public static final int COMMENT=78;
+ public static final int T__99=99;
+ public static final int T__98=98;
+ public static final int T__97=97;
+ public static final int T__96=96;
+ public static final int T__95=95;
+ public static final int D=61;
+ public static final int E=49;
+ public static final int F=53;
+ public static final int G=67;
+ public static final int K_TYPE=44;
+ public static final int K_KEYSPACE=33;
+ public static final int T__80=80;
+ public static final int K_COUNT=7;
+ public static final int A=59;
+ public static final int T__81=81;
+ public static final int T__82=82;
+ public static final int B=70;
+ public static final int C=51;
+ public static final int T__83=83;
+ public static final int L=50;
+ public static final int M=56;
+ public static final int N=60;
+ public static final int O=55;
+ public static final int H=58;
+ public static final int I=64;
+ public static final int J=72;
+ public static final int K_UPDATE=29;
+ public static final int K=62;
+ public static final int U=65;
+ public static final int T=52;
+ public static final int W=57;
+ public static final int V=69;
+ public static final int Q=68;
+ public static final int P=66;
+ public static final int S=48;
+ public static final int R=54;
+ public static final int T__85=85;
+ public static final int T__84=84;
+ public static final int T__87=87;
+ public static final int T__86=86;
+ public static final int K_TTL=25;
+ public static final int T__89=89;
+ public static final int Y=63;
+ public static final int X=71;
+ public static final int T__88=88;
+ public static final int Z=73;
+ public static final int K_INDEX=40;
+ public static final int K_REVERSED=17;
+ public static final int K_INSERT=21;
+ public static final int WS=77;
+ public static final int K_APPLY=28;
+ public static final int K_TIMESTAMP=24;
+ public static final int K_AND=19;
+ public static final int K_LEVEL=13;
+ public static final int K_BATCH=27;
+ public static final int UUID=46;
+ public static final int K_DELETE=31;
+ public static final int FLOAT=39;
+ public static final int K_SELECT=6;
+ public static final int K_LIMIT=15;
+ public static final int K_ALTER=43;
+ public static final int K_SET=30;
+ public static final int K_WHERE=14;
+ public static final int MULTILINE_COMMENT=79;
+ public static final int HEX=76;
+ public static final int K_INTO=22;
+ public static final int T__103=103;
+ public static final int T__104=104;
+ public static final int IDENT=5;
+ public static final int DIGIT=74;
+ public static final int K_FIRST=16;
+ public static final int K_BEGIN=26;
+ public static final int INTEGER=10;
+ public static final int RANGEOP=18;
+ public static final int K_CONSISTENCY=12;
+ public static final int COMPIDENT=35;
+ public static final int K_WITH=34;
+ public static final int T__102=102;
+ public static final int T__101=101;
+ public static final int K_IN=20;
+ public static final int T__100=100;
+ public static final int K_FROM=8;
+ public static final int K_COLUMNFAMILY=36;
+ public static final int K_DROP=42;
+
+ List<Token> tokens = new ArrayList<Token>();
+
+ public void emit(Token token) {
+ state.token = token;
+ tokens.add(token);
+ }
+
+ public Token nextToken() {
+ super.nextToken();
+ if (tokens.size() == 0)
+ return Token.EOF_TOKEN;
+ return tokens.remove(0);
+ }
+
+ private List<String> recognitionErrors = new ArrayList<String>();
+
+ public void displayRecognitionError(String[] tokenNames, RecognitionException e)
+ {
+ String hdr = getErrorHeader(e);
+ String msg = getErrorMessage(e, tokenNames);
+ recognitionErrors.add(hdr + " " + msg);
+ }
+
+ public List<String> getRecognitionErrors()
+ {
+ return recognitionErrors;
+ }
+
+ public void throwLastRecognitionError() throws InvalidRequestException
+ {
+ if (recognitionErrors.size() > 0)
+ throw new InvalidRequestException(recognitionErrors.get((recognitionErrors.size()-1)));
+ }
+
+
+ // delegates
+ // delegators
+
+ public CqlLexer() {;}
+ public CqlLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public CqlLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "/home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g"; }
+
+ // $ANTLR start "T__80"
+ public final void mT__80() throws RecognitionException {
+ try {
+ int _type = T__80;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:47:7: ( '(' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:47:9: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__80"
+
+ // $ANTLR start "T__81"
+ public final void mT__81() throws RecognitionException {
+ try {
+ int _type = T__81;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:48:7: ( ')' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:48:9: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__81"
+
+ // $ANTLR start "T__82"
+ public final void mT__82() throws RecognitionException {
+ try {
+ int _type = T__82;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:49:7: ( ',' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:49:9: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__82"
+
+ // $ANTLR start "T__83"
+ public final void mT__83() throws RecognitionException {
+ try {
+ int _type = T__83;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:50:7: ( '\\*' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:50:9: '\\*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__83"
+
+ // $ANTLR start "T__84"
+ public final void mT__84() throws RecognitionException {
+ try {
+ int _type = T__84;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:51:7: ( ';' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:51:9: ';'
+ {
+ match(';');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__84"
+
+ // $ANTLR start "T__85"
+ public final void mT__85() throws RecognitionException {
+ try {
+ int _type = T__85;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:52:7: ( '=' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:52:9: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__85"
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:53:7: ( 'bytea' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:53:9: 'bytea'
+ {
+ match("bytea");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "T__87"
+ public final void mT__87() throws RecognitionException {
+ try {
+ int _type = T__87;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:54:7: ( 'ascii' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:54:9: 'ascii'
+ {
+ match("ascii");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__87"
+
+ // $ANTLR start "T__88"
+ public final void mT__88() throws RecognitionException {
+ try {
+ int _type = T__88;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:55:7: ( 'text' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:55:9: 'text'
+ {
+ match("text");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__88"
+
+ // $ANTLR start "T__89"
+ public final void mT__89() throws RecognitionException {
+ try {
+ int _type = T__89;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:56:7: ( 'varchar' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:56:9: 'varchar'
+ {
+ match("varchar");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__89"
+
+ // $ANTLR start "T__90"
+ public final void mT__90() throws RecognitionException {
+ try {
+ int _type = T__90;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:57:7: ( 'int' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:57:9: 'int'
+ {
+ match("int");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__90"
+
+ // $ANTLR start "T__91"
+ public final void mT__91() throws RecognitionException {
+ try {
+ int _type = T__91;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:58:7: ( 'varint' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:58:9: 'varint'
+ {
+ match("varint");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__91"
+
+ // $ANTLR start "T__92"
+ public final void mT__92() throws RecognitionException {
+ try {
+ int _type = T__92;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:59:7: ( 'bigint' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:59:9: 'bigint'
+ {
+ match("bigint");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__92"
+
+ // $ANTLR start "T__93"
+ public final void mT__93() throws RecognitionException {
+ try {
+ int _type = T__93;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:60:7: ( 'uuid' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:60:9: 'uuid'
+ {
+ match("uuid");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__93"
+
+ // $ANTLR start "T__94"
+ public final void mT__94() throws RecognitionException {
+ try {
+ int _type = T__94;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:61:7: ( 'counter' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:61:9: 'counter'
+ {
+ match("counter");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__94"
+
+ // $ANTLR start "T__95"
+ public final void mT__95() throws RecognitionException {
+ try {
+ int _type = T__95;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:62:7: ( 'boolean' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:62:9: 'boolean'
+ {
+ match("boolean");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__95"
+
+ // $ANTLR start "T__96"
+ public final void mT__96() throws RecognitionException {
+ try {
+ int _type = T__96;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:63:7: ( 'date' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:63:9: 'date'
+ {
+ match("date");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__96"
+
+ // $ANTLR start "T__97"
+ public final void mT__97() throws RecognitionException {
+ try {
+ int _type = T__97;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:64:7: ( 'float' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:64:9: 'float'
+ {
+ match("float");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__97"
+
+ // $ANTLR start "T__98"
+ public final void mT__98() throws RecognitionException {
+ try {
+ int _type = T__98;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:65:7: ( 'double' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:65:9: 'double'
+ {
+ match("double");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__98"
+
+ // $ANTLR start "T__99"
+ public final void mT__99() throws RecognitionException {
+ try {
+ int _type = T__99;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:66:7: ( '+' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:66:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__99"
+
+ // $ANTLR start "T__100"
+ public final void mT__100() throws RecognitionException {
+ try {
+ int _type = T__100;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:67:8: ( '-' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:67:10: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__100"
+
+ // $ANTLR start "T__101"
+ public final void mT__101() throws RecognitionException {
+ try {
+ int _type = T__101;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:68:8: ( '<' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:68:10: '<'
+ {
+ match('<');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__101"
+
+ // $ANTLR start "T__102"
+ public final void mT__102() throws RecognitionException {
+ try {
+ int _type = T__102;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:69:8: ( '<=' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:69:10: '<='
+ {
+ match("<=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__102"
+
+ // $ANTLR start "T__103"
+ public final void mT__103() throws RecognitionException {
+ try {
+ int _type = T__103;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:70:8: ( '>=' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:70:10: '>='
+ {
+ match(">=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__103"
+
+ // $ANTLR start "T__104"
+ public final void mT__104() throws RecognitionException {
+ try {
+ int _type = T__104;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:71:8: ( '>' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:71:10: '>'
+ {
+ match('>');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__104"
+
+ // $ANTLR start "K_SELECT"
+ public final void mK_SELECT() throws RecognitionException {
+ try {
+ int _type = K_SELECT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:480:9: ( S E L E C T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:480:16: S E L E C T
+ {
+ mS();
+ mE();
+ mL();
+ mE();
+ mC();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:481:7: ( F R O M )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:481:16: F R O M
+ {
+ mF();
+ mR();
+ mO();
+ mM();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_FROM"
+
+ // $ANTLR start "K_WHERE"
+ public final void mK_WHERE() throws RecognitionException {
+ try {
+ int _type = K_WHERE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:482:8: ( W H E R E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:482:16: W H E R E
+ {
+ mW();
+ mH();
+ mE();
+ mR();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:483:6: ( A N D )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:483:16: A N D
+ {
+ mA();
+ mN();
+ mD();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:484:6: ( K E Y )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:484:16: K E Y
+ {
+ mK();
+ mE();
+ mY();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_KEY"
+
+ // $ANTLR start "K_INSERT"
+ public final void mK_INSERT() throws RecognitionException {
+ try {
+ int _type = K_INSERT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:485:9: ( I N S E R T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:485:16: I N S E R T
+ {
+ mI();
+ mN();
+ mS();
+ mE();
+ mR();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:486:9: ( U P D A T E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:486:16: U P D A T E
+ {
+ mU();
+ mP();
+ mD();
+ mA();
+ mT();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:487:7: ( W I T H )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:487:16: W I T H
+ {
+ mW();
+ mI();
+ mT();
+ mH();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:488:8: ( L I M I T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:488:16: L I M I T
+ {
+ mL();
+ mI();
+ mM();
+ mI();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_LIMIT"
+
+ // $ANTLR start "K_USING"
+ public final void mK_USING() throws RecognitionException {
+ try {
+ int _type = K_USING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:489:8: ( U S I N G )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:489:16: U S I N G
+ {
+ mU();
+ mS();
+ mI();
+ mN();
+ mG();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_USING"
+
+ // $ANTLR start "K_CONSISTENCY"
+ public final void mK_CONSISTENCY() throws RecognitionException {
+ try {
+ int _type = K_CONSISTENCY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:490:14: ( C O N S I S T E N C Y )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:490:16: C O N S I S T E N C Y
+ {
+ mC();
+ mO();
+ mN();
+ mS();
+ mI();
+ mS();
+ mT();
+ mE();
+ mN();
+ mC();
+ mY();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_CONSISTENCY"
+
+ // $ANTLR start "K_LEVEL"
+ public final void mK_LEVEL() throws RecognitionException {
+ try {
+ int _type = K_LEVEL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:8: ( ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:16: ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M )
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:16: ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M )
+ int alt1=6;
+ switch ( input.LA(1) ) {
+ case 'O':
+ case 'o':
+ {
+ alt1=1;
+ }
+ break;
+ case 'Q':
+ case 'q':
+ {
+ alt1=2;
+ }
+ break;
+ case 'A':
+ case 'a':
+ {
+ int LA1_3 = input.LA(2);
+
+ if ( (LA1_3=='L'||LA1_3=='l') ) {
+ alt1=3;
+ }
+ else if ( (LA1_3=='N'||LA1_3=='n') ) {
+ alt1=4;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 3, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case 'L':
+ case 'l':
+ {
+ alt1=5;
+ }
+ break;
+ case 'E':
+ case 'e':
+ {
+ alt1=6;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt1) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:18: O N E
+ {
+ mO();
+ mN();
+ mE();
+
+ }
+ break;
+ case 2 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:492:18: Q U O R U M
+ {
+ mQ();
+ mU();
+ mO();
+ mR();
+ mU();
+ mM();
+
+ }
+ break;
+ case 3 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:493:18: A L L
+ {
+ mA();
+ mL();
+ mL();
+
+ }
+ break;
+ case 4 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:494:18: A N Y
+ {
+ mA();
+ mN();
+ mY();
+
+ }
+ break;
+ case 5 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:495:18: L O C A L '_' Q U O R U M
+ {
+ mL();
+ mO();
+ mC();
+ mA();
+ mL();
+ match('_');
+ mQ();
+ mU();
+ mO();
+ mR();
+ mU();
+ mM();
+
+ }
+ break;
+ case 6 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:496:18: E A C H '_' Q U O R U M
+ {
+ mE();
+ mA();
+ mC();
+ mH();
+ match('_');
+ mQ();
+ mU();
+ mO();
+ mR();
+ mU();
+ mM();
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_LEVEL"
+
+ // $ANTLR start "K_USE"
+ public final void mK_USE() throws RecognitionException {
+ try {
+ int _type = K_USE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:499:6: ( U S E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:499:16: U S E
+ {
+ mU();
+ mS();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_USE"
+
+ // $ANTLR start "K_FIRST"
+ public final void mK_FIRST() throws RecognitionException {
+ try {
+ int _type = K_FIRST;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:500:8: ( F I R S T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:500:16: F I R S T
+ {
+ mF();
+ mI();
+ mR();
+ mS();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_FIRST"
+
+ // $ANTLR start "K_REVERSED"
+ public final void mK_REVERSED() throws RecognitionException {
+ try {
+ int _type = K_REVERSED;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:501:11: ( R E V E R S E D )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:501:16: R E V E R S E D
+ {
+ mR();
+ mE();
+ mV();
+ mE();
+ mR();
+ mS();
+ mE();
+ mD();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_REVERSED"
+
+ // $ANTLR start "K_COUNT"
+ public final void mK_COUNT() throws RecognitionException {
+ try {
+ int _type = K_COUNT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:502:8: ( C O U N T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:502:16: C O U N T
+ {
+ mC();
+ mO();
+ mU();
+ mN();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:503:6: ( S E T )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:503:16: S E T
+ {
+ mS();
+ mE();
+ mT();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:504:8: ( B E G I N )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:504:16: B E G I N
+ {
+ mB();
+ mE();
+ mG();
+ mI();
+ mN();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_BEGIN"
+
+ // $ANTLR start "K_APPLY"
+ public final void mK_APPLY() throws RecognitionException {
+ try {
+ int _type = K_APPLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:505:8: ( A P P L Y )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:505:16: A P P L Y
+ {
+ mA();
+ mP();
+ mP();
+ mL();
+ mY();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_APPLY"
+
+ // $ANTLR start "K_BATCH"
+ public final void mK_BATCH() throws RecognitionException {
+ try {
+ int _type = K_BATCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:506:8: ( B A T C H )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:506:16: B A T C H
+ {
+ mB();
+ mA();
+ mT();
+ mC();
+ mH();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_BATCH"
+
+ // $ANTLR start "K_TRUNCATE"
+ public final void mK_TRUNCATE() throws RecognitionException {
+ try {
+ int _type = K_TRUNCATE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:507:11: ( T R U N C A T E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:507:16: T R U N C A T E
+ {
+ mT();
+ mR();
+ mU();
+ mN();
+ mC();
+ mA();
+ mT();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:508:9: ( D E L E T E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:508:16: D E L E T E
+ {
+ mD();
+ mE();
+ mL();
+ mE();
+ mT();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:509:5: ( I N )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:509:16: I N
+ {
+ mI();
+ mN();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:510:9: ( C R E A T E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:510:16: C R E A T E
+ {
+ mC();
+ mR();
+ mE();
+ mA();
+ mT();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_CREATE"
+
+ // $ANTLR start "K_KEYSPACE"
+ public final void mK_KEYSPACE() throws RecognitionException {
+ try {
+ int _type = K_KEYSPACE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:11: ( ( K E Y S P A C E | S C H E M A ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:16: ( K E Y S P A C E | S C H E M A )
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:16: ( K E Y S P A C E | S C H E M A )
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0=='K'||LA2_0=='k') ) {
+ alt2=1;
+ }
+ else if ( (LA2_0=='S'||LA2_0=='s') ) {
+ alt2=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+ switch (alt2) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:18: K E Y S P A C E
+ {
+ mK();
+ mE();
+ mY();
+ mS();
+ mP();
+ mA();
+ mC();
+ mE();
+
+ }
+ break;
+ case 2 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:512:20: S C H E M A
+ {
+ mS();
+ mC();
+ mH();
+ mE();
+ mM();
+ mA();
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_KEYSPACE"
+
+ // $ANTLR start "K_COLUMNFAMILY"
+ public final void mK_COLUMNFAMILY() throws RecognitionException {
+ try {
+ int _type = K_COLUMNFAMILY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:15: ( ( C O L U M N F A M I L Y | T A B L E ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:16: ( C O L U M N F A M I L Y | T A B L E )
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:16: ( C O L U M N F A M I L Y | T A B L E )
+ 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 {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:18: C O L U M N F A M I L Y
+ {
+ mC();
+ mO();
+ mL();
+ mU();
+ mM();
+ mN();
+ mF();
+ mA();
+ mM();
+ mI();
+ mL();
+ mY();
+
+ }
+ break;
+ case 2 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:514:20: T A B L E
+ {
+ mT();
+ mA();
+ mB();
+ mL();
+ mE();
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_COLUMNFAMILY"
+
+ // $ANTLR start "K_INDEX"
+ public final void mK_INDEX() throws RecognitionException {
+ try {
+ int _type = K_INDEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:515:8: ( I N D E X )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:515:16: I N D E X
+ {
+ mI();
+ mN();
+ mD();
+ mE();
+ mX();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_INDEX"
+
+ // $ANTLR start "K_ON"
+ public final void mK_ON() throws RecognitionException {
+ try {
+ int _type = K_ON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:516:5: ( O N )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:516:16: O N
+ {
+ mO();
+ mN();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_ON"
+
+ // $ANTLR start "K_DROP"
+ public final void mK_DROP() throws RecognitionException {
+ try {
+ int _type = K_DROP;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:517:7: ( D R O P )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:517:16: D R O P
+ {
+ mD();
+ mR();
+ mO();
+ mP();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:518:10: ( P R I M A R Y )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:518:16: P R I M A R Y
+ {
+ mP();
+ mR();
+ mI();
+ mM();
+ mA();
+ mR();
+ mY();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:519:7: ( I N T O )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:519:16: I N T O
+ {
+ mI();
+ mN();
+ mT();
+ mO();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:520:9: ( V A L U E S )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:520:16: V A L U E S
+ {
+ mV();
+ mA();
+ mL();
+ mU();
+ mE();
+ mS();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:521:12: ( T I M E S T A M P )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:521:16: T I M E S T A M P
+ {
+ mT();
+ mI();
+ mM();
+ mE();
+ mS();
+ mT();
+ mA();
+ mM();
+ mP();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:522:6: ( T T L )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:522:16: T T L
+ {
+ mT();
+ mT();
+ mL();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_TTL"
+
+ // $ANTLR start "K_ALTER"
+ public final void mK_ALTER() throws RecognitionException {
+ try {
+ int _type = K_ALTER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:523:8: ( A L T E R )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:523:16: A L T E R
+ {
+ mA();
+ mL();
+ mT();
+ mE();
+ mR();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_ALTER"
+
+ // $ANTLR start "K_ADD"
+ public final void mK_ADD() throws RecognitionException {
+ try {
+ int _type = K_ADD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:524:6: ( A D D )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:524:16: A D D
+ {
+ mA();
+ mD();
+ mD();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $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;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:525:7: ( T Y P E )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:525:16: T Y P E
+ {
+ mT();
+ mY();
+ mP();
+ mE();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K_TYPE"
+
+ // $ANTLR start "A"
+ public final void mA() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:528:11: ( ( 'a' | 'A' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:528:13: ( 'a' | 'A' )
+ {
+ if ( input.LA(1)=='A'||input.LA(1)=='a' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "A"
+
+ // $ANTLR start "B"
+ public final void mB() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:529:11: ( ( 'b' | 'B' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:529:13: ( 'b' | 'B' )
+ {
+ if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "B"
+
+ // $ANTLR start "C"
+ public final void mC() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:530:11: ( ( 'c' | 'C' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:530:13: ( 'c' | 'C' )
+ {
+ if ( input.LA(1)=='C'||input.LA(1)=='c' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "C"
+
+ // $ANTLR start "D"
+ public final void mD() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:531:11: ( ( 'd' | 'D' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:531:13: ( 'd' | 'D' )
+ {
+ if ( input.LA(1)=='D'||input.LA(1)=='d' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "D"
+
+ // $ANTLR start "E"
+ public final void mE() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:532:11: ( ( 'e' | 'E' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:532:13: ( 'e' | 'E' )
+ {
+ if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "E"
+
+ // $ANTLR start "F"
+ public final void mF() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:533:11: ( ( 'f' | 'F' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:533:13: ( 'f' | 'F' )
+ {
+ if ( input.LA(1)=='F'||input.LA(1)=='f' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "F"
+
+ // $ANTLR start "G"
+ public final void mG() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:534:11: ( ( 'g' | 'G' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:534:13: ( 'g' | 'G' )
+ {
+ if ( input.LA(1)=='G'||input.LA(1)=='g' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "G"
+
+ // $ANTLR start "H"
+ public final void mH() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:535:11: ( ( 'h' | 'H' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:535:13: ( 'h' | 'H' )
+ {
+ if ( input.LA(1)=='H'||input.LA(1)=='h' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "H"
+
+ // $ANTLR start "I"
+ public final void mI() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:536:11: ( ( 'i' | 'I' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:536:13: ( 'i' | 'I' )
+ {
+ if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "I"
+
+ // $ANTLR start "J"
+ public final void mJ() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:537:11: ( ( 'j' | 'J' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:537:13: ( 'j' | 'J' )
+ {
+ if ( input.LA(1)=='J'||input.LA(1)=='j' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "J"
+
+ // $ANTLR start "K"
+ public final void mK() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:538:11: ( ( 'k' | 'K' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:538:13: ( 'k' | 'K' )
+ {
+ if ( input.LA(1)=='K'||input.LA(1)=='k' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "K"
+
+ // $ANTLR start "L"
+ public final void mL() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:539:11: ( ( 'l' | 'L' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:539:13: ( 'l' | 'L' )
+ {
+ if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "L"
+
+ // $ANTLR start "M"
+ public final void mM() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:540:11: ( ( 'm' | 'M' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:540:13: ( 'm' | 'M' )
+ {
+ if ( input.LA(1)=='M'||input.LA(1)=='m' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "M"
+
+ // $ANTLR start "N"
+ public final void mN() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:541:11: ( ( 'n' | 'N' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:541:13: ( 'n' | 'N' )
+ {
+ if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "N"
+
+ // $ANTLR start "O"
+ public final void mO() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:542:11: ( ( 'o' | 'O' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:542:13: ( 'o' | 'O' )
+ {
+ if ( input.LA(1)=='O'||input.LA(1)=='o' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "O"
+
+ // $ANTLR start "P"
+ public final void mP() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:543:11: ( ( 'p' | 'P' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:543:13: ( 'p' | 'P' )
+ {
+ if ( input.LA(1)=='P'||input.LA(1)=='p' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "P"
+
+ // $ANTLR start "Q"
+ public final void mQ() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:544:11: ( ( 'q' | 'Q' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:544:13: ( 'q' | 'Q' )
+ {
+ if ( input.LA(1)=='Q'||input.LA(1)=='q' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "Q"
+
+ // $ANTLR start "R"
+ public final void mR() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:545:11: ( ( 'r' | 'R' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:545:13: ( 'r' | 'R' )
+ {
+ if ( input.LA(1)=='R'||input.LA(1)=='r' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "R"
+
+ // $ANTLR start "S"
+ public final void mS() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:546:11: ( ( 's' | 'S' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:546:13: ( 's' | 'S' )
+ {
+ if ( input.LA(1)=='S'||input.LA(1)=='s' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "S"
+
+ // $ANTLR start "T"
+ public final void mT() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:547:11: ( ( 't' | 'T' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:547:13: ( 't' | 'T' )
+ {
+ if ( input.LA(1)=='T'||input.LA(1)=='t' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T"
+
+ // $ANTLR start "U"
+ public final void mU() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:548:11: ( ( 'u' | 'U' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:548:13: ( 'u' | 'U' )
+ {
+ if ( input.LA(1)=='U'||input.LA(1)=='u' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "U"
+
+ // $ANTLR start "V"
+ public final void mV() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:549:11: ( ( 'v' | 'V' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:549:13: ( 'v' | 'V' )
+ {
+ if ( input.LA(1)=='V'||input.LA(1)=='v' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "V"
+
+ // $ANTLR start "W"
+ public final void mW() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:550:11: ( ( 'w' | 'W' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:550:13: ( 'w' | 'W' )
+ {
+ if ( input.LA(1)=='W'||input.LA(1)=='w' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "W"
+
+ // $ANTLR start "X"
+ public final void mX() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:551:11: ( ( 'x' | 'X' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:551:13: ( 'x' | 'X' )
+ {
+ if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "X"
+
+ // $ANTLR start "Y"
+ public final void mY() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:552:11: ( ( 'y' | 'Y' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:552:13: ( 'y' | 'Y' )
+ {
+ if ( input.LA(1)=='Y'||input.LA(1)=='y' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "Y"
+
+ // $ANTLR start "Z"
+ public final void mZ() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:553:11: ( ( 'z' | 'Z' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:553:13: ( 'z' | 'Z' )
+ {
+ if ( input.LA(1)=='Z'||input.LA(1)=='z' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $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;
+
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:556:5: ( '\\'' (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )* '\\'' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:556:7: '\\'' (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )* '\\''
+ {
+ match('\'');
+ StringBuilder b = new StringBuilder();
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:558:7: (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )*
+ loop4:
+ do {
+ int alt4=3;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='\'') ) {
+ int LA4_1 = input.LA(2);
+
+ if ( (LA4_1=='\'') ) {
+ alt4=2;
+ }
+
+
+ }
+ else if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='\uFFFF')) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:558:9: c=~ ( '\\'' | '\\r' | '\\n' )
+ {
+ c= input.LA(1);
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ b.appendCodePoint(c);
+
+ }
+ break;
+ case 2 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:559:9: '\\'' '\\''
+ {
+ match('\'');
+ match('\'');
+ b.appendCodePoint('\'');
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+ match('\'');
+ setText(b.toString());
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "STRING_LITERAL"
+
+ // $ANTLR start "DIGIT"
+ public final void mDIGIT() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:566:5: ( '0' .. '9' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:566:7: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "DIGIT"
+
+ // $ANTLR start "LETTER"
+ public final void mLETTER() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:570:5: ( ( 'A' .. 'Z' | 'a' .. 'z' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:570:7: ( 'A' .. 'Z' | 'a' .. 'z' )
+ {
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "LETTER"
+
+ // $ANTLR start "HEX"
+ public final void mHEX() throws RecognitionException {
+ try {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:574:5: ( ( 'A' .. 'F' | 'a' .. 'f' | '0' .. '9' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:574:7: ( 'A' .. 'F' | 'a' .. 'f' | '0' .. '9' )
+ {
+ 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();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "HEX"
+
+ // $ANTLR start "RANGEOP"
+ public final void mRANGEOP() throws RecognitionException {
+ try {
+ int _type = RANGEOP;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:578:5: ( '..' )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:578:7: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RANGEOP"
+
+ // $ANTLR start "INTEGER"
+ public final void mINTEGER() throws RecognitionException {
+ try {
+ int _type = INTEGER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:5: ( ( '-' )? ( DIGIT )+ )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: ( '-' )? ( DIGIT )+
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: ( '-' )?
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='-') ) {
+ alt5=1;
+ }
+ switch (alt5) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: '-'
+ {
+ match('-');
+
+ }
+ break;
+
+ }
+
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:12: ( DIGIT )+
+ int cnt6=0;
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( ((LA6_0>='0' && LA6_0<='9')) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:12: DIGIT
+ {
+ mDIGIT();
+
+ }
+ break;
+
+ default :
+ if ( cnt6 >= 1 ) break loop6;
+ EarlyExitException eee =
+ new EarlyExitException(6, input);
+ throw eee;
+ }
+ cnt6++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "INTEGER"
+
+ // $ANTLR start "FLOAT"
+ public final void mFLOAT() throws RecognitionException {
+ try {
+ int _type = FLOAT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ CommonToken d=null;
+ CommonToken r=null;
+
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:589:5: (d= INTEGER r= RANGEOP | INTEGER '.' INTEGER )
+ int alt7=2;
+ alt7 = dfa7.predict(input);
+ switch (alt7) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:589:7: d= INTEGER r= RANGEOP
+ {
+ int dStart1863 = getCharIndex();
+ mINTEGER();
+ d = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, dStart1863, getCharIndex()-1);
+ int rStart1867 = getCharIndex();
+ mRANGEOP();
+ r = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, rStart1867, getCharIndex()-1);
+
+ d.setType(INTEGER);
+ emit(d);
+ r.setType(RANGEOP);
+ emit(r);
+
+
+ }
+ break;
+ case 2 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:596:9: INTEGER '.' INTEGER
+ {
+ mINTEGER();
+ match('.');
+ mINTEGER();
+
+ }
+ break;
+
+ }
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "FLOAT"
+
+ // $ANTLR start "IDENT"
+ public final void mIDENT() throws RecognitionException {
+ try {
+ int _type = IDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:5: ( LETTER ( LETTER | DIGIT | '_' )* )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:7: LETTER ( LETTER | DIGIT | '_' )*
+ {
+ mLETTER();
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:14: ( LETTER | DIGIT | '_' )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.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();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "IDENT"
+
+ // $ANTLR start "COMPIDENT"
+ public final void mCOMPIDENT() throws RecognitionException {
+ try {
+ int _type = COMPIDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:5: ( IDENT ( ':' IDENT )* )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:7: IDENT ( ':' IDENT )*
+ {
+ mIDENT();
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:13: ( ':' IDENT )*
+ loop9:
+ do {
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==':') ) {
+ alt9=1;
+ }
+
+
+ switch (alt9) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:15: ':' IDENT
+ {
+ match(':');
+ mIDENT();
+
+ }
+ break;
+
+ default :
+ break loop9;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "COMPIDENT"
+
+ // $ANTLR start "UUID"
+ public final void mUUID() throws RecognitionException {
+ try {
+ int _type = UUID;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:608: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 )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:608: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();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ match('-');
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ match('-');
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ match('-');
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ match('-');
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+ mHEX();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "UUID"
+
+ // $ANTLR start "WS"
+ public final void mWS() throws RecognitionException {
+ try {
+ int _type = WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
+ int cnt10=0;
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt10 >= 1 ) break loop10;
+ EarlyExitException eee =
+ new EarlyExitException(10, input);
+ throw eee;
+ }
+ cnt10++;
+ } while (true);
+
+ _channel = HIDDEN;
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "WS"
+
+ // $ANTLR start "COMMENT"
+ public final void mCOMMENT() throws RecognitionException {
+ try {
+ int _type = COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:5: ( ( '--' | '//' ) ( . )* ( '\\n' | '\\r' ) )
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:7: ( '--' | '//' ) ( . )* ( '\\n' | '\\r' )
+ {
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:7: ( '--' | '//' )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='-') ) {
+ alt11=1;
+ }
+ else if ( (LA11_0=='/') ) {
+ alt11=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+ switch (alt11) {
+ case 1 :
+ // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:8: '--'
+ {
+ match("--");
+
+
+ }
[... 1382 lines stripped ...]