SQLLexer.java :  » Database-DBMS » Quadcap-Embeddable-Database » com » quadcap » sql » Java Open Source

Java Open Source » Database DBMS » Quadcap Embeddable Database 
Quadcap Embeddable Database » com » quadcap » sql » SQLLexer.java
// $ANTLR 2.7.2a2 (20020112-1): "sql.g" -> "SQLLexer.java"$

package com.quadcap.sql;

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;

public class SQLLexer extends antlr.CharScanner implements SQLTokenTypes, TokenStream
 {
public SQLLexer(InputStream in) {
  this(new ByteBuffer(in));
}
public SQLLexer(Reader in) {
  this(new CharBuffer(in));
}
public SQLLexer(InputBuffer ib) {
  this(new LexerSharedInputState(ib));
}
public SQLLexer(LexerSharedInputState state) {
  super(state);
  caseSensitiveLiterals = false;
  setCaseSensitive(true);
  literals = new Hashtable();
  literals.put(new ANTLRHashString("local", this), new Integer(46));
  literals.put(new ANTLRHashString("sql_tsi_month", this), new Integer(154));
  literals.put(new ANTLRHashString("blob", this), new Integer(72));
  literals.put(new ANTLRHashString("action", this), new Integer(63));
  literals.put(new ANTLRHashString("public", this), new Integer(48));
  literals.put(new ANTLRHashString("smallint", this), new Integer(81));
  literals.put(new ANTLRHashString("between", this), new Integer(116));
  literals.put(new ANTLRHashString("time", this), new Integer(93));
  literals.put(new ANTLRHashString("case", this), new Integer(129));
  literals.put(new ANTLRHashString("option", this), new Integer(37));
  literals.put(new ANTLRHashString("sql_tsi_frac_second", this), new Integer(148));
  literals.put(new ANTLRHashString("tinyint", this), new Integer(82));
  literals.put(new ANTLRHashString("delete", this), new Integer(42));
  literals.put(new ANTLRHashString("transaction", this), new Integer(15));
  literals.put(new ANTLRHashString("end", this), new Integer(133));
  literals.put(new ANTLRHashString("object", this), new Integer(74));
  literals.put(new ANTLRHashString("view", this), new Integer(10));
  literals.put(new ANTLRHashString("system_user", this), new Integer(144));
  literals.put(new ANTLRHashString("initially", this), new Integer(64));
  literals.put(new ANTLRHashString("timestamp", this), new Integer(95));
  literals.put(new ANTLRHashString("insert", this), new Integer(52));
  literals.put(new ANTLRHashString("distinct", this), new Integer(104));
  literals.put(new ANTLRHashString("check", this), new Integer(24));
  literals.put(new ANTLRHashString("binary", this), new Integer(71));
  literals.put(new ANTLRHashString("grant", this), new Integer(47));
  literals.put(new ANTLRHashString("where", this), new Integer(40));
  literals.put(new ANTLRHashString("alter", this), new Integer(19));
  literals.put(new ANTLRHashString("varbinary", this), new Integer(70));
  literals.put(new ANTLRHashString("zone", this), new Integer(94));
  literals.put(new ANTLRHashString("integer", this), new Integer(80));
  literals.put(new ANTLRHashString("sql_tsi_minute", this), new Integer(150));
  literals.put(new ANTLRHashString("then", this), new Integer(131));
  literals.put(new ANTLRHashString("match", this), new Integer(59));
  literals.put(new ANTLRHashString("decimal", this), new Integer(85));
  literals.put(new ANTLRHashString("select", this), new Integer(51));
  literals.put(new ANTLRHashString("cascade", this), new Integer(30));
  literals.put(new ANTLRHashString("to", this), new Integer(33));
  literals.put(new ANTLRHashString("and", this), new Integer(113));
  literals.put(new ANTLRHashString("outer", this), new Integer(181));
  literals.put(new ANTLRHashString("float", this), new Integer(90));
  literals.put(new ANTLRHashString("not", this), new Integer(55));
  literals.put(new ANTLRHashString("constraint", this), new Integer(21));
  literals.put(new ANTLRHashString("interval", this), new Integer(96));
  literals.put(new ANTLRHashString("schema", this), new Integer(7));
  literals.put(new ANTLRHashString("numeric", this), new Integer(86));
  literals.put(new ANTLRHashString("usage", this), new Integer(54));
  literals.put(new ANTLRHashString("date", this), new Integer(92));
  literals.put(new ANTLRHashString("using", this), new Integer(109));
  literals.put(new ANTLRHashString("no", this), new Integer(62));
  literals.put(new ANTLRHashString("key", this), new Integer(57));
  literals.put(new ANTLRHashString("month", this), new Integer(137));
  literals.put(new ANTLRHashString("from", this), new Integer(43));
  literals.put(new ANTLRHashString("bigint", this), new Integer(83));
  literals.put(new ANTLRHashString("null", this), new Integer(56));
  literals.put(new ANTLRHashString("count", this), new Integer(165));
  literals.put(new ANTLRHashString("real", this), new Integer(87));
  literals.put(new ANTLRHashString("add", this), new Integer(20));
  literals.put(new ANTLRHashString("deferrable", this), new Integer(67));
  literals.put(new ANTLRHashString("current_user", this), new Integer(142));
  literals.put(new ANTLRHashString("like", this), new Integer(115));
  literals.put(new ANTLRHashString("natural", this), new Integer(178));
  literals.put(new ANTLRHashString("when", this), new Integer(130));
  literals.put(new ANTLRHashString("inner", this), new Integer(180));
  literals.put(new ANTLRHashString("except", this), new Integer(183));
  literals.put(new ANTLRHashString("sql_tsi_quarter", this), new Integer(155));
  literals.put(new ANTLRHashString("character", this), new Integer(76));
  literals.put(new ANTLRHashString("authorization", this), new Integer(44));
  literals.put(new ANTLRHashString("sql_tsi_day", this), new Integer(152));
  literals.put(new ANTLRHashString("cascaded", this), new Integer(36));
  literals.put(new ANTLRHashString("with", this), new Integer(35));
  literals.put(new ANTLRHashString("set", this), new Integer(31));
  literals.put(new ANTLRHashString("current_time", this), new Integer(146));
  literals.put(new ANTLRHashString("escape", this), new Integer(119));
  literals.put(new ANTLRHashString("only", this), new Integer(99));
  literals.put(new ANTLRHashString("global", this), new Integer(45));
  literals.put(new ANTLRHashString("foreign", this), new Integer(23));
  literals.put(new ANTLRHashString("intersect", this), new Integer(182));
  literals.put(new ANTLRHashString("work", this), new Integer(13));
  literals.put(new ANTLRHashString("**", this), new Integer(120));
  literals.put(new ANTLRHashString("join", this), new Integer(177));
  literals.put(new ANTLRHashString("rollback", this), new Integer(14));
  literals.put(new ANTLRHashString("commit", this), new Integer(12));
  literals.put(new ANTLRHashString("is", this), new Integer(114));
  literals.put(new ANTLRHashString("or", this), new Integer(112));
  literals.put(new ANTLRHashString("any", this), new Integer(173));
  literals.put(new ANTLRHashString("create", this), new Integer(4));
  literals.put(new ANTLRHashString("dec", this), new Integer(84));
  literals.put(new ANTLRHashString("full", this), new Integer(60));
  literals.put(new ANTLRHashString("double", this), new Integer(88));
  literals.put(new ANTLRHashString("min", this), new Integer(162));
  literals.put(new ANTLRHashString("sql_tsi_hour", this), new Integer(151));
  literals.put(new ANTLRHashString("as", this), new Integer(34));
  literals.put(new ANTLRHashString("first", this), new Integer(27));
  literals.put(new ANTLRHashString("by", this), new Integer(101));
  literals.put(new ANTLRHashString("second", this), new Integer(139));
  literals.put(new ANTLRHashString("all", this), new Integer(49));
  literals.put(new ANTLRHashString("union", this), new Integer(179));
  literals.put(new ANTLRHashString("drop", this), new Integer(11));
  literals.put(new ANTLRHashString("order", this), new Integer(100));
  literals.put(new ANTLRHashString("privileges", this), new Integer(50));
  literals.put(new ANTLRHashString("hour", this), new Integer(134));
  literals.put(new ANTLRHashString("primary", this), new Integer(22));
  literals.put(new ANTLRHashString("current_date", this), new Integer(145));
  literals.put(new ANTLRHashString("some", this), new Integer(174));
  literals.put(new ANTLRHashString("values", this), new Integer(108));
  literals.put(new ANTLRHashString("int", this), new Integer(79));
  literals.put(new ANTLRHashString("for", this), new Integer(97));
  literals.put(new ANTLRHashString("boolean", this), new Integer(91));
  literals.put(new ANTLRHashString("cross", this), new Integer(176));
  literals.put(new ANTLRHashString("varchar", this), new Integer(78));
  literals.put(new ANTLRHashString("char", this), new Integer(77));
  literals.put(new ANTLRHashString("bit", this), new Integer(68));
  literals.put(new ANTLRHashString("large", this), new Integer(73));
  literals.put(new ANTLRHashString("index", this), new Integer(6));
  literals.put(new ANTLRHashString("default", this), new Integer(32));
  literals.put(new ANTLRHashString("clob", this), new Integer(75));
  literals.put(new ANTLRHashString("false", this), new Integer(160));
  literals.put(new ANTLRHashString("session_user", this), new Integer(143));
  literals.put(new ANTLRHashString("exists", this), new Integer(118));
  literals.put(new ANTLRHashString("table", this), new Integer(9));
  literals.put(new ANTLRHashString("asc", this), new Integer(102));
  literals.put(new ANTLRHashString("unknown", this), new Integer(167));
  literals.put(new ANTLRHashString("sql_tsi_year", this), new Integer(156));
  literals.put(new ANTLRHashString("minute", this), new Integer(136));
  literals.put(new ANTLRHashString("left", this), new Integer(135));
  literals.put(new ANTLRHashString("day", this), new Integer(158));
  literals.put(new ANTLRHashString("partial", this), new Integer(61));
  literals.put(new ANTLRHashString("desc", this), new Integer(103));
  literals.put(new ANTLRHashString("temporary", this), new Integer(8));
  literals.put(new ANTLRHashString("max", this), new Integer(163));
  literals.put(new ANTLRHashString("sum", this), new Integer(164));
  literals.put(new ANTLRHashString("year", this), new Integer(140));
  literals.put(new ANTLRHashString("on", this), new Integer(16));
  literals.put(new ANTLRHashString("after", this), new Integer(28));
  literals.put(new ANTLRHashString("cast", this), new Integer(157));
  literals.put(new ANTLRHashString("identity", this), new Integer(58));
  literals.put(new ANTLRHashString("restrict", this), new Integer(29));
  literals.put(new ANTLRHashString("into", this), new Integer(166));
  literals.put(new ANTLRHashString("rename", this), new Integer(25));
  literals.put(new ANTLRHashString("sql_tsi_week", this), new Integer(153));
  literals.put(new ANTLRHashString("else", this), new Integer(132));
  literals.put(new ANTLRHashString("right", this), new Integer(138));
  literals.put(new ANTLRHashString("in", this), new Integer(117));
  literals.put(new ANTLRHashString("sql_tsi_second", this), new Integer(149));
  literals.put(new ANTLRHashString("avg", this), new Integer(161));
  literals.put(new ANTLRHashString("precision", this), new Integer(89));
  literals.put(new ANTLRHashString("update", this), new Integer(38));
  literals.put(new ANTLRHashString("true", this), new Integer(159));
  literals.put(new ANTLRHashString("group", this), new Integer(110));
  literals.put(new ANTLRHashString("immediate", this), new Integer(66));
  literals.put(new ANTLRHashString("read", this), new Integer(98));
  literals.put(new ANTLRHashString("having", this), new Integer(106));
  literals.put(new ANTLRHashString("column", this), new Integer(26));
  literals.put(new ANTLRHashString("corresponding", this), new Integer(107));
  literals.put(new ANTLRHashString("user", this), new Integer(141));
  literals.put(new ANTLRHashString("unique", this), new Integer(5));
  literals.put(new ANTLRHashString("references", this), new Integer(53));
  literals.put(new ANTLRHashString("current_timestamp", this), new Integer(147));
  literals.put(new ANTLRHashString("varying", this), new Integer(69));
  literals.put(new ANTLRHashString("deferred", this), new Integer(65));
}

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 '\r':  case ' ':
        {
          mWS(true);
          theRetToken=_returnToken;
          break;
        }
        case '\n':
        {
          mNL(true);
          theRetToken=_returnToken;
          break;
        }
        case '(':
        {
          mLPAREN(true);
          theRetToken=_returnToken;
          break;
        }
        case ')':
        {
          mRPAREN(true);
          theRetToken=_returnToken;
          break;
        }
        case ',':
        {
          mCOMMA(true);
          theRetToken=_returnToken;
          break;
        }
        case '?':
        {
          mQUESTION(true);
          theRetToken=_returnToken;
          break;
        }
        case '+':
        {
          mPLUS(true);
          theRetToken=_returnToken;
          break;
        }
        case '|':
        {
          mCONCAT(true);
          theRetToken=_returnToken;
          break;
        }
        case '=':
        {
          mEQ(true);
          theRetToken=_returnToken;
          break;
        }
        case '*':
        {
          mSTAR(true);
          theRetToken=_returnToken;
          break;
        }
        case '{':
        {
          mLCURLY(true);
          theRetToken=_returnToken;
          break;
        }
        case '}':
        {
          mRCURLY(true);
          theRetToken=_returnToken;
          break;
        }
        case ';':
        {
          mSEMI(true);
          theRetToken=_returnToken;
          break;
        }
        case '\'':
        {
          mSTRING_LITERAL(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':
        {
          mINT_OR_REAL(true);
          theRetToken=_returnToken;
          break;
        }
        default:
          if ((LA(1)=='B') && (LA(2)=='\'') && (LA(3)=='0'||LA(3)=='1') && (LA(4)=='\''||LA(4)=='0'||LA(4)=='1')) {
            mBINSTR(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='X') && (LA(2)=='\'') && (_tokenSet_0.member(LA(3))) && (_tokenSet_1.member(LA(4)))) {
            mHEXSTR(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='-') && (LA(2)=='-')) {
            mSL_COMMENT(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='/') && (LA(2)=='*')) {
            mML_COMMENT(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='<') && (LA(2)=='=')) {
            mLE(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='>') && (LA(2)=='=')) {
            mGE(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='<') && (LA(2)=='>')) {
            mNE(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='-') && (true)) {
            mMINUS(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='<') && (true)) {
            mLT(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='>') && (true)) {
            mGT(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='/') && (true)) {
            mSLASH(true);
            theRetToken=_returnToken;
          }
          else if ((_tokenSet_2.member(LA(1))) && (true) && (true) && (true)) {
            mID(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());
      }
    }
  }
}

  public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = WS;
    int _saveIndex;
    
    {
    int _cnt349=0;
    _loop349:
    do {
      switch ( LA(1)) {
      case ' ':
      {
        match(' ');
        break;
      }
      case '\t':
      {
        match('\t');
        break;
      }
      case '\r':
      {
        match('\r');
        break;
      }
      default:
      {
        if ( _cnt349>=1 ) { break _loop349; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
      }
      }
      _cnt349++;
    } while (true);
    }
    if ( inputState.guessing==0 ) {
      _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;
  }
  
  public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = SL_COMMENT;
    int _saveIndex;
    
    match("--");
    {
    _loop352:
    do {
      if ((_tokenSet_3.member(LA(1)))) {
        matchNot('\n');
      }
      else {
        break _loop352;
      }
      
    } while (true);
    }
    if ( inputState.guessing==0 ) {
      _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;
  }
  
  public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ML_COMMENT;
    int _saveIndex;
    
    match("/*");
    {
    _loop356:
    do {
      if (((LA(1)=='*') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')))&&( LA(2)!='/' )) {
        match('*');
      }
      else if ((LA(1)=='\n')) {
        match('\n');
        if ( inputState.guessing==0 ) {
          newline();
        }
      }
      else if ((_tokenSet_4.member(LA(1)))) {
        {
        match(_tokenSet_4);
        }
      }
      else {
        break _loop356;
      }
      
    } while (true);
    }
    match("*/");
    if ( inputState.guessing==0 ) {
      _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;
  }
  
  public final void mNL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = NL;
    int _saveIndex;
    
    match('\n');
    if ( inputState.guessing==0 ) {
      _ttype = Token.SKIP; newline();
    }
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = LPAREN;
    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;
  }
  
  public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = RPAREN;
    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;
  }
  
  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;
  }
  
  public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = QUESTION;
    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;
  }
  
  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;
  }
  
  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;
  }
  
  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;
  }
  
  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;
  }
  
  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;
  }
  
  public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = LE;
    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;
  }
  
  public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = GE;
    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;
  }
  
  public final void mEQ(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = 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;
  }
  
  public final void mNE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = NE;
    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;
  }
  
  public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = STAR;
    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;
  }
  
  public final void mSLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = SLASH;
    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;
  }
  
  public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = LCURLY;
    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;
  }
  
  public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = RCURLY;
    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;
  }
  
  public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = SEMI;
    int _saveIndex;
    
    match(';');
    if ( inputState.guessing==0 ) {
      _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;
  }
  
  public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = STRING_LITERAL;
    int _saveIndex;
    
    _saveIndex=text.length();
    match('\'');
    text.setLength(_saveIndex);
    {
    _loop379:
    do {
      if ((LA(1)=='\'') && (LA(2)=='\'')) {
        match('\'');
        {
        _saveIndex=text.length();
        match('\'');
        text.setLength(_saveIndex);
        }
      }
      else if ((_tokenSet_5.member(LA(1)))) {
        matchNot('\'');
      }
      else {
        break _loop379;
      }
      
    } while (true);
    }
    _saveIndex=text.length();
    match('\'');
    text.setLength(_saveIndex);
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  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;
  }
  
  protected final void mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = INT;
    int _saveIndex;
    
    {
    int _cnt383=0;
    _loop383:
    do {
      if (((LA(1) >= '0' && LA(1) <= '9'))) {
        mDIGIT(false);
      }
      else {
        if ( _cnt383>=1 ) { break _loop383; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
      }
      
      _cnt383++;
    } while (true);
    }
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  protected final void mREAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = REAL;
    int _saveIndex;
    
    {
    _loop386:
    do {
      if (((LA(1) >= '0' && LA(1) <= '9'))) {
        mDIGIT(false);
      }
      else {
        break _loop386;
      }
      
    } while (true);
    }
    match('.');
    {
    if (((LA(1) >= '0' && LA(1) <= '9'))) {
      mINT(false);
      {
      if ((LA(1)=='E'||LA(1)=='e')) {
        {
        switch ( LA(1)) {
        case 'E':
        {
          match('E');
          break;
        }
        case 'e':
        {
          match('e');
          break;
        }
        default:
        {
          throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        {
        switch ( LA(1)) {
        case '-':
        {
          match('-');
          break;
        }
        case '+':
        {
          match('+');
          break;
        }
        case '0':  case '1':  case '2':  case '3':
        case '4':  case '5':  case '6':  case '7':
        case '8':  case '9':
        {
          break;
        }
        default:
        {
          throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        mINT(false);
      }
      else {
      }
      
      }
    }
    else {
    }
    
    }
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  protected final void mEXP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = EXP;
    int _saveIndex;
    
    mINT(false);
    {
    switch ( LA(1)) {
    case 'E':
    {
      match('E');
      break;
    }
    case 'e':
    {
      match('e');
      break;
    }
    default:
    {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
    }
    }
    {
    switch ( LA(1)) {
    case '-':
    {
      match('-');
      break;
    }
    case '+':
    {
      match('+');
      break;
    }
    case '0':  case '1':  case '2':  case '3':
    case '4':  case '5':  case '6':  case '7':
    case '8':  case '9':
    {
      break;
    }
    default:
    {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
    }
    }
    mINT(false);
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  public final void mINT_OR_REAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = INT_OR_REAL;
    int _saveIndex;
    
    boolean synPredMatched401 = false;
    if ((((LA(1) >= '0' && LA(1) <= '9')) && (_tokenSet_6.member(LA(2))) && (_tokenSet_7.member(LA(3))) && (true))) {
      int _m401 = mark();
      synPredMatched401 = true;
      inputState.guessing++;
      try {
        {
        mINT(false);
        {
        switch ( LA(1)) {
        case 'E':
        {
          match('E');
          break;
        }
        case 'e':
        {
          match('e');
          break;
        }
        default:
        {
          throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        mINT(false);
        }
      }
      catch (RecognitionException pe) {
        synPredMatched401 = false;
      }
      rewind(_m401);
      inputState.guessing--;
    }
    if ( synPredMatched401 ) {
      mEXP(false);
      if ( inputState.guessing==0 ) {
        _ttype = REAL;
      }
    }
    else {
      boolean synPredMatched404 = false;
      if ((((LA(1) >= '0' && LA(1) <= '9')) && (_tokenSet_6.member(LA(2))) && (_tokenSet_7.member(LA(3))) && (true))) {
        int _m404 = mark();
        synPredMatched404 = true;
        inputState.guessing++;
        try {
          {
          mINT(false);
          {
          switch ( LA(1)) {
          case 'E':
          {
            match('E');
            break;
          }
          case 'e':
          {
            match('e');
            break;
          }
          default:
          {
            throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
          }
          }
          }
          match('-');
          mINT(false);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched404 = false;
        }
        rewind(_m404);
        inputState.guessing--;
      }
      if ( synPredMatched404 ) {
        mEXP(false);
        if ( inputState.guessing==0 ) {
          _ttype = REAL;
        }
      }
      else {
        boolean synPredMatched407 = false;
        if ((((LA(1) >= '0' && LA(1) <= '9')) && (_tokenSet_6.member(LA(2))) && (_tokenSet_7.member(LA(3))) && (true))) {
          int _m407 = mark();
          synPredMatched407 = true;
          inputState.guessing++;
          try {
            {
            mINT(false);
            {
            switch ( LA(1)) {
            case 'E':
            {
              match('E');
              break;
            }
            case 'e':
            {
              match('e');
              break;
            }
            default:
            {
              throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
            }
            }
            }
            match('+');
            mINT(false);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched407 = false;
          }
          rewind(_m407);
          inputState.guessing--;
        }
        if ( synPredMatched407 ) {
          mEXP(false);
          if ( inputState.guessing==0 ) {
            _ttype = REAL;
          }
        }
        else {
          boolean synPredMatched396 = false;
          if (((_tokenSet_8.member(LA(1))) && (true) && (true) && (true))) {
            int _m396 = mark();
            synPredMatched396 = true;
            inputState.guessing++;
            try {
              {
              mINT(false);
              match('.');
              }
            }
            catch (RecognitionException pe) {
              synPredMatched396 = false;
            }
            rewind(_m396);
            inputState.guessing--;
          }
          if ( synPredMatched396 ) {
            mREAL(false);
            if ( inputState.guessing==0 ) {
              _ttype = REAL;
            }
          }
          else {
            boolean synPredMatched398 = false;
            if (((_tokenSet_8.member(LA(1))) && (true) && (true) && (true))) {
              int _m398 = mark();
              synPredMatched398 = true;
              inputState.guessing++;
              try {
                {
                match('.');
                mINT(false);
                }
              }
              catch (RecognitionException pe) {
                synPredMatched398 = false;
              }
              rewind(_m398);
              inputState.guessing--;
            }
            if ( synPredMatched398 ) {
              mREAL(false);
              if ( inputState.guessing==0 ) {
                _ttype = REAL;
              }
            }
            else {
              boolean synPredMatched409 = false;
              if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
                int _m409 = mark();
                synPredMatched409 = true;
                inputState.guessing++;
                try {
                  {
                  mINT(false);
                  }
                }
                catch (RecognitionException pe) {
                  synPredMatched409 = false;
                }
                rewind(_m409);
                inputState.guessing--;
              }
              if ( synPredMatched409 ) {
                mINT(false);
                if ( inputState.guessing==0 ) {
                  _ttype = INT;
                }
              }
              else {
                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;
            }
            
  protected final void mHEXDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = HEXDIGIT;
    int _saveIndex;
    
    switch ( LA(1)) {
    case '0':  case '1':  case '2':  case '3':
    case '4':  case '5':  case '6':  case '7':
    case '8':  case '9':
    {
      mDIGIT(false);
      break;
    }
    case 'A':  case 'B':  case 'C':  case 'D':
    case 'E':  case 'F':
    {
      matchRange('A','F');
      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;
  }
  
  public final void mBINSTR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = BINSTR;
    int _saveIndex;
    
    match('B');
    match('\'');
    {
    int _cnt413=0;
    _loop413:
    do {
      switch ( LA(1)) {
      case '0':
      {
        match('0');
        break;
      }
      case '1':
      {
        match('1');
        break;
      }
      default:
      {
        if ( _cnt413>=1 ) { break _loop413; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
      }
      }
      _cnt413++;
    } 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;
  }
  
  public final void mHEXSTR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = HEXSTR;
    int _saveIndex;
    
    match('X');
    match('\'');
    {
    int _cnt416=0;
    _loop416:
    do {
      if ((_tokenSet_0.member(LA(1)))) {
        mHEXDIGIT(false);
      }
      else {
        if ( _cnt416>=1 ) { break _loop416; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
      }
      
      _cnt416++;
    } 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;
  }
  
  public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ID;
    int _saveIndex;
    
    mIDTERM(false);
    {
    if ((LA(1)=='.')) {
      match('.');
      {
      switch ( LA(1)) {
      case '*':
      {
        match('*');
        break;
      }
      case '"':  case 'A':  case 'B':  case 'C':
      case 'D':  case 'E':  case 'F':  case 'G':
      case 'H':  case 'I':  case 'J':  case 'K':
      case 'L':  case 'M':  case 'N':  case 'O':
      case 'P':  case 'Q':  case 'R':  case 'S':
      case 'T':  case 'U':  case 'V':  case 'W':
      case 'X':  case 'Y':  case 'Z':  case '_':
      case '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':
      {
        {
        mIDTERM(false);
        {
        if ((LA(1)=='.')) {
          match('.');
          {
          switch ( LA(1)) {
          case '*':
          {
            match('*');
            break;
          }
          case '"':  case 'A':  case 'B':  case 'C':
          case 'D':  case 'E':  case 'F':  case 'G':
          case 'H':  case 'I':  case 'J':  case 'K':
          case 'L':  case 'M':  case 'N':  case 'O':
          case 'P':  case 'Q':  case 'R':  case 'S':
          case 'T':  case 'U':  case 'V':  case 'W':
          case 'X':  case 'Y':  case 'Z':  case '_':
          case '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':
          {
            mIDTERM(false);
            break;
          }
          default:
          {
            throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
          }
          }
          }
        }
        else {
        }
        
        }
        }
        break;
      }
      default:
      {
        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
      }
      }
      }
    }
    else {
    }
    
    }
    _ttype = testLiteralsTable(_ttype);
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  protected final void mIDTERM(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = IDTERM;
    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':  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':
    {
      mSIMPID(false);
      break;
    }
    case '"':
    {
      mCASEID(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;
  }
  
  protected final void mIDCHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = IDCHAR;
    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':
    {
      matchRange('a','z');
      break;
    }
    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':
    {
      matchRange('A','Z');
      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;
  }
  
  protected final void mIDCHAR2(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = IDCHAR2;
    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':  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':
    {
      mIDCHAR(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;
    }
    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;
  }
  
  protected final void mSIMPID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = SIMPID;
    int _saveIndex;
    
    mIDCHAR(false);
    {
    _loop428:
    do {
      if ((_tokenSet_9.member(LA(1)))) {
        mIDCHAR2(false);
      }
      else {
        break _loop428;
      }
      
    } while (true);
    }
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
  
  protected final void mCASEID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = CASEID;
    int _saveIndex;
    
    match('"');
    {
    _loop432:
    do {
      if ((LA(1)=='"') && (LA(2)=='"')) {
        match('"');
        {
        _saveIndex=text.length();
        match('"');
        text.setLength(_saveIndex);
        }
      }
      else if ((_tokenSet_10.member(LA(1)))) {
        matchNot('"');
      }
      else {
        break _loop432;
      }
      
    } 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;
  }
  
  
  private static final long[] mk_tokenSet_0() {
    long[] data = new long[1025];
    data[0]=287948901175001088L;
    data[1]=126L;
    for (int i = 2; i<=1024; i++) { data[i]=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[1025];
    data[0]=287949450930814976L;
    data[1]=126L;
    for (int i = 2; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
  private static final long[] mk_tokenSet_2() {
    long[] data = new long[1025];
    data[0]=17179869184L;
    data[1]=576460745995190270L;
    for (int i = 2; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
  private static final long[] mk_tokenSet_3() {
    long[] data = new long[2048];
    data[0]=-1025L;
    for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    data[1023]=9223372036854775807L;
    for (int i = 1024; i<=2047; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
  private static final long[] mk_tokenSet_4() {
    long[] data = new long[2048];
    data[0]=-4398046512129L;
    for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    data[1023]=9223372036854775807L;
    for (int i = 1024; i<=2047; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
  private static final long[] mk_tokenSet_5() {
    long[] data = new long[2048];
    data[0]=-549755813889L;
    for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    data[1023]=9223372036854775807L;
    for (int i = 1024; i<=2047; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
  private static final long[] mk_tokenSet_6() {
    long[] data = new long[1025];
    data[0]=287948901175001088L;
    data[1]=137438953504L;
    for (int i = 2; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
  private static final long[] mk_tokenSet_7() {
    long[] data = new long[1025];
    data[0]=287992881640112128L;
    data[1]=137438953504L;
    for (int i = 2; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
  private static final long[] mk_tokenSet_8() {
    long[] data = new long[1025];
    data[0]=288019269919178752L;
    for (int i = 1; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
  private static final long[] mk_tokenSet_9() {
    long[] data = new long[1025];
    data[0]=287948901175001088L;
    data[1]=576460745995190270L;
    for (int i = 2; i<=1024; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
  private static final long[] mk_tokenSet_10() {
    long[] data = new long[2048];
    data[0]=-17179869185L;
    for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    data[1023]=9223372036854775807L;
    for (int i = 1024; i<=2047; i++) { data[i]=0L; }
    return data;
  }
  public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
  
  }
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.