HQLLexer.java
// $ANTLR 2.7.7 (20060906): "hql.g" -> "HQLLexer.java"$
/*
** Module : HQLParser.java
** HQLParserTokenTypes.java
** HQLLexer.java
** Abstract :
**
** Copyright (c) 2006-2023, Golden Code Development Corporation.
**
** -#- -I- --Date-- --JPRM-- -----------------------------Description-----------------------------
** 001 ECF 20060314 @25235 WARNING, THIS IS A GENERATED FILE!!!
** DO NOT EDIT THIS FILE. The original source file is hql.g!
*/
package com.goldencode.p2j.persist.hql;
import java.util.*;
import java.util.List;
import java.text.*;
import java.io.*;
import antlr.*;
import com.goldencode.p2j.uast.*;
import com.goldencode.p2j.util.logging.*;
import java.io.InputStream;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.TokenStreamRecognitionException;
import antlr.CharStreamException;
import antlr.CharStreamIOException;
import antlr.ANTLRException;
import java.io.Reader;
import java.util.Hashtable;
import antlr.CharScanner;
import antlr.InputBuffer;
import antlr.ByteBuffer;
import antlr.CharBuffer;
import antlr.Token;
import antlr.CommonToken;
import antlr.RecognitionException;
import antlr.NoViableAltForCharException;
import antlr.MismatchedCharException;
import antlr.TokenStream;
import antlr.ANTLRHashString;
import antlr.LexerSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.SemanticException;
/**
* Tokenizes an HQL query statement (input as a stream of characters) into a
* stream of tokens suitable for the {@link HQLParser}.
* <p>
* Each token has an integer token type by which the parser references and
* matches tokens. This is done to make a high performance parser. To make
* this work, the lexer must create a token object when it matches a top
* level rule, this token object includes the token type and the actual text
* found in the original character stream. The lexer's main job is to
* look ahead into the character stream, switch into the top level rule that
* matches some set of characters and when this is complete, to create a
* valid token object and return this to the parser. The lexer thus
* implements a token stream interface from the parser's perspective.
* <p>
* <b>Please note that this is a generated file using ANTLR 2.7.4 and a
* grammar specified in <code>hql.g</code>.</b>
* <p>
* Symbol resolution is the process by which the proper token type is
* assigned to a token created from a match to the generic symbol rule.
* In the lexer, the only symbol resolution that can be done is to match
* with reserved keywords. Reserved keywords are given preference over
* other symbol types in any case where there is a conflict.
* <p>
* Other key design points:
* <ul>
* <li> This grammar has been designed to ignore case. All symbol
* definitions use lowercase characters and ANTLR generates code to
* match both the uppercase and lowercase version of each character.
* This is enabled using the lexer options section.
* <li> The lexer is defined to create a single token of any string. All
* logic for matching string literals is embedded in the lexer.
* <li> At the top level of the lexer, all tokens are one of the
* following types:
* <ul>
* <li> string literals
* <li> whitespace (spaces, tabs, carriage returns, line feeds)
* <li> operators
* <li> integer and decimal literals
* <li> reserved keywords
* <li> user-defined symbols
* </ul>
* <li> The lexer's top level entry point is <code>nextToken</code>. This
* method has a for-loop that uses up to 3 characters of lookahead
* to identify which of the top level token rules to call. To do
* this, each token rule's left-most match characters are "rolled up"
* and tested in this top level rule.
* <li> Whitespace tokens are artificially set to the special "skip" token
* type, which drops them from the token stream seen by the parser.
* This is an important feature that simplifies the parser design.
* </ul>
* <p>
* All token types are defined as integer constants in {@link
* HQLParserTokenTypes} which is an interface that the parser, lexer and
* other related classes all implement. This allows all of these classes to
* directly refer to the token types and share this common set of
* definitions. All top-level lexer rules generate a token of the same name
* in the <code>HQLParserTokenTypes</code> interface.
* <p>
* There is a tokens { } section in the parser where artificial tokens are
* defined (tokens that are not backed by a lexer rule). These tokens are
* also added to the <code>HQLParserTokenTypes</code> interface and can thus
* be referenced directly by the lexer and parser.
*
* @author ECF
* @author GES
*/
public class HQLLexer extends antlr.CharScanner implements HQLParserTokenTypes, TokenStream
{
/** Logger. */
private static final CentralLogger LOG = CentralLogger.get(HQLLexer.class);
/** Map of keywords to symbol tokens */
private static Map keywords = new HashMap();
// Static initializer which populates a keyword map where the symbol text
// (in the mSYMBOL method) can be submitted to the keyword map for a
// lookup. If a match is found, then the token type of the token is set
// based on the token type field stored in the map. This token type will
// override the default token type of SYMBOL. Since all of these keywords
// are not encoded in the matching rules of the grammar itself, there are
// no actual token definitions in the lexer that match these keywords.
static
{
keywords.put( "and", Integer.valueOf(AND) );
keywords.put( "as", Integer.valueOf(AS) );
keywords.put( "case", Integer.valueOf(CASE) );
keywords.put( "cast", Integer.valueOf(CAST) );
keywords.put( "else", Integer.valueOf(ELSE) );
keywords.put( "end", Integer.valueOf(END) );
keywords.put( "escape", Integer.valueOf(ESCAPE) );
keywords.put( "false", Integer.valueOf(BOOL_FALSE) );
keywords.put( "from", Integer.valueOf(FROM) );
keywords.put( "in", Integer.valueOf(IN) );
keywords.put( "is", Integer.valueOf(IS) );
keywords.put( "join", Integer.valueOf(JOIN) );
keywords.put( "like", Integer.valueOf(LIKE) );
keywords.put( "no", Integer.valueOf(BOOL_FALSE) );
keywords.put( "not", Integer.valueOf(NOT) );
keywords.put( "null", Integer.valueOf(NULL) );
keywords.put( "or", Integer.valueOf(OR) );
keywords.put( "select", Integer.valueOf(SELECT) );
keywords.put( "then", Integer.valueOf(THEN) );
keywords.put( "true", Integer.valueOf(BOOL_TRUE) );
keywords.put( "when", Integer.valueOf(WHEN) );
keywords.put( "where", Integer.valueOf(WHERE) );
keywords.put( "yes", Integer.valueOf(BOOL_TRUE) );
}
/**
* Provides a command line interface for an end user to drive and/or test
* the HQLLexer class.
* <p>
* Syntax:
* <pre>
* java HQLLexer <expression>
* </pre>
*
* @param args
* List of command line arguments.
*/
public static void main(String[] args)
{
if (args.length != 1)
{
LOG.severe("Syntax: java HQLLexer <expression>");
System.exit(-1);
}
try
{
StringReader expr = new StringReader(args[0]);
HQLLexer lexer = new HQLLexer(expr);
int maxSymSize = 20;
NumberFormat lfmt = NumberFormat.getInstance();
NumberFormat cfmt = NumberFormat.getInstance();
CommonToken next;
String decode;
lfmt.setMinimumIntegerDigits(5);
lfmt.setGroupingUsed(false);
cfmt.setMinimumIntegerDigits(3);
cfmt.setGroupingUsed(false);
do
{
next = (CommonToken) lexer.nextToken();
decode = HQLParser._tokenNames[next.getType()];
StringBuffer sb = new StringBuffer(decode).append('>');
int trailing = maxSymSize - decode.length();
for (int i = 0; i < trailing; i++)
{
sb.append(' ');
}
System.out.println("[" +
lfmt.format( next.getLine() ) +
":" +
cfmt.format( next.getColumn() ) +
"] <" +
sb.toString() +
" " +
next.getText());
}
while (next.getType() != Token.EOF_TYPE);
}
catch (Exception excpt)
{
LOG.severe("", excpt);
}
}
public HQLLexer(InputStream in) {
this(new ByteBuffer(in));
}
public HQLLexer(Reader in) {
this(new CharBuffer(in));
}
public HQLLexer(InputBuffer ib) {
this(new LexerSharedInputState(ib));
}
public HQLLexer(LexerSharedInputState state) {
super(state);
caseSensitiveLiterals = false;
setCaseSensitive(false);
literals = new Hashtable();
}
public Token nextToken() throws TokenStreamException {
Token theRetToken=null;
tryAgain:
for (;;) {
Token _token = null;
int _ttype = Token.INVALID_TYPE;
resetText();
try { // for char stream error handling
try { // for lexical error handling
switch ( LA(1)) {
case '\t': case '\n': case '\r': case ' ':
{
mWS(true);
theRetToken=_returnToken;
break;
}
case '$': case '_': case 'a': case 'b':
case 'c': case 'd': case 'e': case 'f':
case 'g': case 'h': case 'i': case 'j':
case 'k': case 'l': case 'm': case 'n':
case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v':
case 'w': case 'x': case 'y': case 'z':
{
mSYMBOL(true);
theRetToken=_returnToken;
break;
}
case '|':
{
mCONCAT(true);
theRetToken=_returnToken;
break;
}
case ',':
{
mCOMMA(true);
theRetToken=_returnToken;
break;
}
case '=':
{
mEQUALS(true);
theRetToken=_returnToken;
break;
}
case '!':
{
mNOT_EQ(true);
theRetToken=_returnToken;
break;
}
case '[':
{
mLBRACKET(true);
theRetToken=_returnToken;
break;
}
case ']':
{
mRBRACKET(true);
theRetToken=_returnToken;
break;
}
case '(':
{
mLPARENS(true);
theRetToken=_returnToken;
break;
}
case ')':
{
mRPARENS(true);
theRetToken=_returnToken;
break;
}
case '+':
{
mPLUS(true);
theRetToken=_returnToken;
break;
}
case '-':
{
mMINUS(true);
theRetToken=_returnToken;
break;
}
case '*':
{
mMULTIPLY(true);
theRetToken=_returnToken;
break;
}
case '/':
{
mDIVIDE(true);
theRetToken=_returnToken;
break;
}
case '?':
{
mSUBST(true);
theRetToken=_returnToken;
break;
}
case '.': case '0': case '1': case '2':
case '3': case '4': case '5': case '6':
case '7': case '8': case '9':
{
mNUM_LITERAL(true);
theRetToken=_returnToken;
break;
}
case '\'':
{
mSTRING(true);
theRetToken=_returnToken;
break;
}
default:
if ((LA(1)=='>') && (LA(2)=='=')) {
mGTE(true);
theRetToken=_returnToken;
}
else if ((LA(1)=='<') && (LA(2)=='=')) {
mLTE(true);
theRetToken=_returnToken;
}
else if ((LA(1)=='>') && (true)) {
mGT(true);
theRetToken=_returnToken;
}
else if ((LA(1)=='<') && (true)) {
mLT(true);
theRetToken=_returnToken;
}
else {
if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
}
}
if ( _returnToken==null ) continue tryAgain; // found SKIP token
_ttype = _returnToken.getType();
_returnToken.setType(_ttype);
return _returnToken;
}
catch (RecognitionException e) {
throw new TokenStreamRecognitionException(e);
}
}
catch (CharStreamException cse) {
if ( cse instanceof CharStreamIOException ) {
throw new TokenStreamIOException(((CharStreamIOException)cse).io);
}
else {
throw new TokenStreamException(cse.getMessage());
}
}
}
}
/**
* Matches any amount of whitespace in an expression and sets the token type
* to SKIP. In addition, each newline character causes the lexer's line
* counter to be incremented in order to properly maintain each token's line
* information.
* <p>
* Spaces, tabs and carriage returns and line feeds (newlines) are all
* matched.
* <p>
* This is a top level lexer rule which means that there is an associated
* <code>WS</code> token.
*/
public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = WS;
int _saveIndex;
{
int _cnt79=0;
_loop79:
do {
switch ( LA(1)) {
case ' ':
{
match(' ');
break;
}
case '\t':
{
match('\t');
break;
}
case '\r':
{
match('\r');
break;
}
case '\n':
{
match('\n');
newline();
break;
}
default:
{
if ( _cnt79>=1 ) { break _loop79; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
}
}
_cnt79++;
} while (true);
}
_ttype = Token.SKIP;
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Match a valid symbol name. All symbols must start with an alphabetic character, the "_"
* character or the "$" character. Subsequent characters can be alphanumeric or one of the
* special symbol characters ({@code _} and {@code $}).
* <b>Symbols are matched case-insensitively.</b>
* <p>
* Once a symbol has been found, a keyword lookup occurs. If matched, the the token's type is
* overridden from the default ({@code SYMBOL}) to the artificial token type associated with
* the keyword.
* <p>
* This is a top level lexer rule which means that there is an associated {@code SYMBOL} token.
*/
public final void mSYMBOL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = SYMBOL;
int _saveIndex;
mVALID_1ST_IDENT(false);
{
_loop82:
do {
if ((_tokenSet_0.member(LA(1)))) {
mVALID_SYM_CHAR(false);
}
else {
break _loop82;
}
} while (true);
}
int stype = SYMBOL;
Integer found = (Integer) keywords.get(getText().toLowerCase());
if (found != null)
{
// symbol is a keyword; set the token type accordingly.
stype = found.intValue();
}
_ttype = stype;
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches any character that can appear in the 1st position of a symbol (matches any
* {@code LETTER} or {@code SYM_CHAR}).
*/
protected final void mVALID_1ST_IDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = VALID_1ST_IDENT;
int _saveIndex;
switch ( LA(1)) {
case 'a': case 'b': case 'c': case 'd':
case 'e': case 'f': case 'g': case 'h':
case 'i': case 'j': case 'k': case 'l':
case 'm': case 'n': case 'o': case 'p':
case 'q': case 'r': case 's': case 't':
case 'u': case 'v': case 'w': case 'x':
case 'y': case 'z':
{
mLETTER(false);
break;
}
case '$': case '_':
{
mSYM_CHAR(false);
break;
}
default:
{
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
}
}
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches any single character that can appear in the 2nd or later position
* in a symbol (matches any <code>LETTER, DIGIT or SYM_CHAR</code>). This is
* simply a helper rule to make references easier.
*/
protected final void mVALID_SYM_CHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = VALID_SYM_CHAR;
int _saveIndex;
switch ( LA(1)) {
case 'a': case 'b': case 'c': case 'd':
case 'e': case 'f': case 'g': case 'h':
case 'i': case 'j': case 'k': case 'l':
case 'm': case 'n': case 'o': case 'p':
case 'q': case 'r': case 's': case 't':
case 'u': case 'v': case 'w': case 'x':
case 'y': case 'z':
{
mLETTER(false);
break;
}
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case '8': case '9':
{
mDIGIT(false);
break;
}
case '$': case '_':
{
mSYM_CHAR(false);
break;
}
default:
{
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
}
}
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '||' concatenation operator. This is a top level rule,
* creating a <code>CONCAT</code> token type.
*/
public final void mCONCAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = CONCAT;
int _saveIndex;
match("||");
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the ',' character. This is a top level rule, creating a
* <code>COMMA</code> token type.
*/
public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = COMMA;
int _saveIndex;
match(',');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the "=" string. This is a top level rule, creating an
* <code>EQUALS</code> token type.
*/
public final void mEQUALS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = EQUALS;
int _saveIndex;
match("=");
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the inequality string. This is a top level rule, creating a
* <code>NOT_EQ</code> token type.
*/
public final void mNOT_EQ(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = NOT_EQ;
int _saveIndex;
match("!=");
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '>' character. This is a top level rule, creating a
* <code>GT</code> token type.
*/
public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = GT;
int _saveIndex;
match('>');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '<' character. This is a top level rule, creating a
* <code>LT</code> token type.
*/
public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = LT;
int _saveIndex;
match('<');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '>=' character sequence. This is a top level rule, creating
* a <code>GTE</code> token type.
*/
public final void mGTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = GTE;
int _saveIndex;
match(">=");
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '<=' character sequence. This is a top level rule, creating
* a <code>LTE</code> token type.
*/
public final void mLTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = LTE;
int _saveIndex;
match("<=");
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '[' character. This is a top level rule, creating a
* <code>LBRACKET</code> token type.
*/
public final void mLBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = LBRACKET;
int _saveIndex;
match('[');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the ']' character. This is a top level rule, creating a
* <code>RBRACKET</code> token type.
*/
public final void mRBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = RBRACKET;
int _saveIndex;
match(']');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '(' character. This is a top level rule, creating a
* <code>LPARENS</code> token type.
*/
public final void mLPARENS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = LPARENS;
int _saveIndex;
match('(');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the ')' character. This is a top level rule, creating a
* <code>RPARENS</code> token type.
*/
public final void mRPARENS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = RPARENS;
int _saveIndex;
match(')');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '+' character. This is a top level rule, creating a
* <code>PLUS</code> token type.
*/
public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = PLUS;
int _saveIndex;
match('+');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '-' character. This is a top level rule, creating a
* <code>MINUS</code> token type.
*/
public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = MINUS;
int _saveIndex;
match('-');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '*' character. This is a top level rule, creating a
* <code>MULTIPLY</code> token type.
*/
public final void mMULTIPLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = MULTIPLY;
int _saveIndex;
match('*');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the '/' character. This is a top level rule, creating a
* <code>DIVIDE</code> token type.
*/
public final void mDIVIDE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = DIVIDE;
int _saveIndex;
match('/');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches the query substitution parameter placeholder character. This is
* a question mark (<code>?</code>). This is a top level rule, creating a
* <code>SUBST</code> token type.
*/
public final void mSUBST(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = SUBST;
int _saveIndex;
match('?');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches all forms of valid integer literals and decimal literals.
* Scenarios that are matched:
* <ul>
* <li> Matches a sequence of one or more digits (without a decimal point
* and additional digits) as an integer literal with a
* <code>NUM_LITERAL</code> token type.
* <li> If the literal at previous step can be parsed as integer but cannot fit in 32-bit
* space, it will be set to LONG_LITERAL.
* <li> If the <code>NUM_LITERAL</code> literal cannot be parsed by <code>Long.parseLong</code>
* then it is too large to fit in a 64-bit variable so it will be matched as
* <code>DEC_LITERAL</code>.
* <li> Matches a sequence of one or more digits followed by a '.' but
* no additional digits, as a decimal literal with a
* <code>DEC_LITERAL</code> token type.
* <li> Matches one or more numeric digits followed by a decimal point
* and another sequence of numeric digits as a decimal constant
* with a <code>DEC_LITERAL</code> token type.
* <li> Matches a decimal point followed by a sequence of numeric digits
* as a decimal constant with a <code>DEC_LITERAL</code> token type.
* </ul>
* <p>
* This is a top level rule. The token type defaults to
* <code>NUM_LITERAL</code> and is overridden by specific actions depending
* on the scenario matched.
*/
public final void mNUM_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = NUM_LITERAL;
int _saveIndex;
int ntype = NUM_LITERAL;
{
if ((LA(1)=='.') && ((LA(2) >= '0' && LA(2) <= '9'))) {
match('.');
{
int _cnt103=0;
_loop103:
do {
if (((LA(1) >= '0' && LA(1) <= '9'))) {
mDIGIT(false);
}
else {
if ( _cnt103>=1 ) { break _loop103; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
}
_cnt103++;
} while (true);
}
ntype = DEC_LITERAL;
}
else if ((LA(1)=='.') && (true)) {
match('.');
ntype = DOT;
}
else if (((LA(1) >= '0' && LA(1) <= '9'))) {
{
int _cnt105=0;
_loop105:
do {
if (((LA(1) >= '0' && LA(1) <= '9'))) {
mDIGIT(false);
}
else {
if ( _cnt105>=1 ) { break _loop105; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
}
_cnt105++;
} while (true);
}
{
if ((LA(1)=='.')) {
match('.');
{
_loop108:
do {
if (((LA(1) >= '0' && LA(1) <= '9'))) {
mDIGIT(false);
}
else {
break _loop108;
}
} while (true);
}
ntype = DEC_LITERAL;
}
else {
}
}
}
else {
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
}
}
if (ntype == NUM_LITERAL)
{
try
{
long l = Long.parseLong(getText());
if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE)
{
ntype = LONG_LITERAL;
}
}
catch (NumberFormatException exc)
{
ntype = DEC_LITERAL;
}
}
_ttype = ntype;
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/** Matches any numeric digit: <code>0 - 9</code> */
protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = DIGIT;
int _saveIndex;
matchRange('0','9');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches an opening single quote, arbitrary contents and an ending single
* quote. Two contiguous single quote characters are used to specify a
* one single quote in the output string (it does not terminate the
* string).
* <p>
* Any newlines inside the string are identified and the lexer's internal
* newline counter is properly maintained.
* <p>
* The greedy option does not need to be disabled here as the closure rule
* termination is built into the subrule itself: it accepts anything that
* isn't an unescaped single quote character (see above).
* <p>
* Tabs and spaces are maintained inside strings. Opening and closing single
* quote characters are dropped.
*/
public final void mSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = STRING;
int _saveIndex;
{
match('\'');
{
_loop112:
do {
if ((LA(1)=='\'') && (LA(2)=='\'')) {
match("\'\'");
}
else if ((LA(1)=='\n')) {
match('\n');
newline();
}
else if ((_tokenSet_1.member(LA(1)))) {
matchNot('\'');
}
else {
break _loop112;
}
} while (true);
}
match('\'');
}
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/** Matches any alphabetic character: <code>a - z</code> */
protected final void mLETTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = LETTER;
int _saveIndex;
matchRange('a','z');
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
/**
* Matches all characters that can be made part of a valid user-defined
* symbol (except alphabetic and numeric characters). These are:
* <code>$ _</code>
*/
protected final void mSYM_CHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
int _ttype; Token _token=null; int _begin=text.length();
_ttype = SYM_CHAR;
int _saveIndex;
switch ( LA(1)) {
case '_':
{
match('_');
break;
}
case '$':
{
match('$');
break;
}
default:
{
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
}
}
if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
_token = makeToken(_ttype);
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
}
_returnToken = _token;
}
private static final long[] mk_tokenSet_0() {
long[] data = { 287948969894477824L, 576460745860972544L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = new long[8];
data[0]=-549755814920L;
for (int i = 1; i<=3; i++) { data[i]=-1L; }
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
}