Package antlr

Source Code of antlr.ANTLRLexer

// $ANTLR 2.7.3rc3: "antlr.g" -> "ANTLRLexer.java"$

package antlr;

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 ANTLRLexer extends antlr.CharScanner implements ANTLRTokenTypes, TokenStream
{

  /**Convert 'c' to an integer char value. */
  public static int escapeCharValue(String cs) {
    //System.out.println("escapeCharValue("+cs+")");
    if ( cs.charAt(1)!='\\' ) return 0;
    switch ( cs.charAt(2) ) {
    case 'b' : return '\b';
    case 'r' : return '\r';
    case 't' : return '\t';
    case 'n' : return '\n';
    case 'f' : return '\f';
    case '"' : return '\"';
    case '\'' :return '\'';
    case '\\' :return '\\';

    case 'u' :
      // Unicode char
      if (cs.length() != 8) {
        return 0;
      }
      else {
        return
          Character.digit(cs.charAt(3), 16) * 16 * 16 * 16 +
          Character.digit(cs.charAt(4), 16) * 16 * 16 +
          Character.digit(cs.charAt(5), 16) * 16 +
          Character.digit(cs.charAt(6), 16);
      }

    case '0' :
    case '1' :
    case '2' :
    case '3' :
      if ( cs.length()>5 && Character.isDigit(cs.charAt(4)) ) {
        return (cs.charAt(2)-'0')*8*8 + (cs.charAt(3)-'0')*8 + (cs.charAt(4)-'0');
      }
      if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) {
        return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0');
      }
      return cs.charAt(2)-'0';

    case '4' :
    case '5' :
    case '6' :
    case '7' :
      if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) {
        return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0');
      }
      return cs.charAt(2)-'0';

    default :
      return 0;
    }
  }

  public static int tokenTypeForCharLiteral(String lit) {
    if ( lit.length()>3 ) {  // does char contain escape?
      return escapeCharValue(lit);
    }
    else {
      return lit.charAt(1);
    }
  }
public ANTLRLexer(InputStream in) {
  this(new ByteBuffer(in));
}
public ANTLRLexer(Reader in) {
  this(new CharBuffer(in));
}
public ANTLRLexer(InputBuffer ib) {
  this(new LexerSharedInputState(ib));
}
public ANTLRLexer(LexerSharedInputState state) {
  super(state);
  caseSensitiveLiterals = true;
  setCaseSensitive(true);
  literals = new Hashtable();
  literals.put(new ANTLRHashString("public", this), new Integer(31));
  literals.put(new ANTLRHashString("class", this), new Integer(10));
  literals.put(new ANTLRHashString("header", this), new Integer(5));
  literals.put(new ANTLRHashString("throws", this), new Integer(37));
  literals.put(new ANTLRHashString("lexclass", this), new Integer(9));
  literals.put(new ANTLRHashString("catch", this), new Integer(40));
  literals.put(new ANTLRHashString("private", this), new Integer(32));
  literals.put(new ANTLRHashString("options", this), new Integer(51));
  literals.put(new ANTLRHashString("extends", this), new Integer(11));
  literals.put(new ANTLRHashString("protected", this), new Integer(30));
  literals.put(new ANTLRHashString("TreeParser", this), new Integer(13));
  literals.put(new ANTLRHashString("Parser", this), new Integer(29));
  literals.put(new ANTLRHashString("Lexer", this), new Integer(12));
  literals.put(new ANTLRHashString("returns", this), new Integer(35));
  literals.put(new ANTLRHashString("charVocabulary", this), new Integer(18));
  literals.put(new ANTLRHashString("tokens", this), new Integer(4));
  literals.put(new ANTLRHashString("exception", this), new Integer(39));
}

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 '/':
        {
          mCOMMENT(true);
          theRetToken=_returnToken;
          break;
        }
        case '<':
        {
          mOPEN_ELEMENT_OPTION(true);
          theRetToken=_returnToken;
          break;
        }
        case '>':
        {
          mCLOSE_ELEMENT_OPTION(true);
          theRetToken=_returnToken;
          break;
        }
        case ',':
        {
          mCOMMA(true);
          theRetToken=_returnToken;
          break;
        }
        case '?':
        {
          mQUESTION(true);
          theRetToken=_returnToken;
          break;
        }
        case '#':
        {
          mTREE_BEGIN(true);
          theRetToken=_returnToken;
          break;
        }
        case '(':
        {
          mLPAREN(true);
          theRetToken=_returnToken;
          break;
        }
        case ')':
        {
          mRPAREN(true);
          theRetToken=_returnToken;
          break;
        }
        case ':':
        {
          mCOLON(true);
          theRetToken=_returnToken;
          break;
        }
        case '*':
        {
          mSTAR(true);
          theRetToken=_returnToken;
          break;
        }
        case '+':
        {
          mPLUS(true);
          theRetToken=_returnToken;
          break;
        }
        case ';':
        {
          mSEMI(true);
          theRetToken=_returnToken;
          break;
        }
        case '^':
        {
          mCARET(true);
          theRetToken=_returnToken;
          break;
        }
        case '!':
        {
          mBANG(true);
          theRetToken=_returnToken;
          break;
        }
        case '|':
        {
          mOR(true);
          theRetToken=_returnToken;
          break;
        }
        case '~':
        {
          mNOT_OP(true);
          theRetToken=_returnToken;
          break;
        }
        case '}':
        {
          mRCURLY(true);
          theRetToken=_returnToken;
          break;
        }
        case '\'':
        {
          mCHAR_LITERAL(true);
          theRetToken=_returnToken;
          break;
        }
        case '"':
        {
          mSTRING_LITERAL(true);
          theRetToken=_returnToken;
          break;
        }
        case '0'case '1'case '2'case '3':
        case '4'case '5'case '6'case '7':
        case '8'case '9':
        {
          mINT(true);
          theRetToken=_returnToken;
          break;
        }
        case '[':
        {
          mARG_ACTION(true);
          theRetToken=_returnToken;
          break;
        }
        case '{':
        {
          mACTION(true);
          theRetToken=_returnToken;
          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':
        {
          mTOKEN_REF(true);
          theRetToken=_returnToken;
          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':
        {
          mRULE_REF(true);
          theRetToken=_returnToken;
          break;
        }
        default:
          if ((LA(1)=='=') && (LA(2)=='>')) {
            mIMPLIES(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='.') && (LA(2)=='.')) {
            mRANGE(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='=') && (true)) {
            mASSIGN(true);
            theRetToken=_returnToken;
          }
          else if ((LA(1)=='.') && (true)) {
            mWILDCARD(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;
   
    {
    switch ( LA(1)) {
    case ' ':
    {
      match(' ');
      break;
    }
    case '\t':
    {
      match('\t');
      break;
    }
    case '\n':
    {
      match('\n');
      newline();
      break;
    }
    default:
      if ((LA(1)=='\r') && (LA(2)=='\n')) {
        match('\r');
        match('\n');
        newline();
      }
      else if ((LA(1)=='\r') && (true)) {
        match('\r');
        newline();
      }
    else {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
    }
    }
    _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 mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = COMMENT;
    int _saveIndex;
    Token t=null;
   
    {
    if ((LA(1)=='/') && (LA(2)=='/')) {
      mSL_COMMENT(false);
    }
    else if ((LA(1)=='/') && (LA(2)=='*')) {
      mML_COMMENT(true);
      t=_returnToken;
      _ttype = t.getType();
    }
    else {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
   
    }
    if ( _ttype != DOC_COMMENT ) _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;
  }
 
  protected 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("//");
    {
    _loop153:
    do {
      if ((_tokenSet_0.member(LA(1)))) {
        {
        match(_tokenSet_0);
        }
      }
      else {
        break _loop153;
      }
     
    } while (true);
    }
    {
    if ((LA(1)=='\r') && (LA(2)=='\n')) {
      match('\r');
      match('\n');
    }
    else if ((LA(1)=='\r') && (true)) {
      match('\r');
    }
    else if ((LA(1)=='\n')) {
      match('\n');
    }
    else {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
   
    }
    newline();
    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 mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ML_COMMENT;
    int _saveIndex;
   
    match("/*");
    {
    if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')))&&( LA(2)!='/' )) {
      match('*');
      _ttype = DOC_COMMENT;
    }
    else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
    }
    else {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
   
    }
    {
    _loop159:
    do {
      // nongreedy exit test
      if ((LA(1)=='*') && (LA(2)=='/')) break _loop159;
      if ((LA(1)=='\r') && (LA(2)=='\n')) {
        match('\r');
        match('\n');
        newline();
      }
      else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        match('\r');
        newline();
      }
      else if ((_tokenSet_0.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        {
        match(_tokenSet_0);
        }
      }
      else if ((LA(1)=='\n')) {
        match('\n');
        newline();
      }
      else {
        break _loop159;
      }
     
    } 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 mOPEN_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = OPEN_ELEMENT_OPTION;
    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 mCLOSE_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = CLOSE_ELEMENT_OPTION;
    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 mTREE_BEGIN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = TREE_BEGIN;
    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 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 mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = COLON;
    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 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 mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ASSIGN;
    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 mIMPLIES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = IMPLIES;
    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 ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
  }
 
  public final void mCARET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = CARET;
    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 mBANG(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = BANG;
    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 mOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = OR;
    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 mWILDCARD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = WILDCARD;
    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 mRANGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = RANGE;
    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 mNOT_OP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = NOT_OP;
    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 mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = CHAR_LITERAL;
    int _saveIndex;
   
    match('\'');
    {
    if ((LA(1)=='\\')) {
      mESC(false);
    }
    else if ((_tokenSet_1.member(LA(1)))) {
      matchNot('\'');
    }
    else {
      throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    }
   
    }
    match('\'');
    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 mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ESC;
    int _saveIndex;
   
    match('\\');
    {
    switch ( LA(1)) {
    case 'n':
    {
      match('n');
      break;
    }
    case 'r':
    {
      match('r');
      break;
    }
    case 't':
    {
      match('t');
      break;
    }
    case 'b':
    {
      match('b');
      break;
    }
    case 'f':
    {
      match('f');
      break;
    }
    case 'w':
    {
      match('w');
      break;
    }
    case 'a':
    {
      match('a');
      break;
    }
    case '"':
    {
      match('"');
      break;
    }
    case '\'':
    {
      match('\'');
      break;
    }
    case '\\':
    {
      match('\\');
      break;
    }
    case '0'case '1'case '2'case '3':
    {
      {
      matchRange('0','3');
      }
      {
      if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        matchRange('0','7');
        {
        if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
          matchRange('0','7');
        }
        else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
        }
        else {
          throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
        }
       
        }
      }
      else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
      }
      else {
        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
      }
     
      }
      break;
    }
    case '4'case '5'case '6'case '7':
    {
      {
      matchRange('4','7');
      }
      {
      if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        matchRange('0','7');
      }
      else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) {
      }
      else {
        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
      }
     
      }
      break;
    }
    case 'u':
    {
      match('u');
      mXDIGIT(false);
      mXDIGIT(false);
      mXDIGIT(false);
      mXDIGIT(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;
  }
 
  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;
   
    match('"');
    {
    _loop184:
    do {
      if ((LA(1)=='\\')) {
        mESC(false);
      }
      else if ((_tokenSet_2.member(LA(1)))) {
        matchNot('"');
      }
      else {
        break _loop184;
      }
     
    } 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;
  }
 
  protected final void mXDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = XDIGIT;
    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':
    {
      matchRange('0','9');
      break;
    }
    case 'a'case 'b'case 'c'case 'd':
    case 'e'case 'f':
    {
      matchRange('a','f');
      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;
  }
 
  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;
  }
 
  public final void mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = INT;
    int _saveIndex;
   
    {
    int _cnt196=0;
    _loop196:
    do {
      if (((LA(1) >= '0' && LA(1) <= '9'))) {
        matchRange('0','9');
      }
      else {
        if ( _cnt196>=1 ) { break _loop196; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
      }
     
      _cnt196++;
    } while (true);
    }
    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 mARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ARG_ACTION;
    int _saveIndex;
   
    mNESTED_ARG_ACTION(false);
    setText(StringUtils.stripFrontBack(getText(), "[", "]"));
    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 mNESTED_ARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = NESTED_ARG_ACTION;
    int _saveIndex;
   
    match('[');
    {
    _loop200:
    do {
      switch ( LA(1)) {
      case '[':
      {
        mNESTED_ARG_ACTION(false);
        break;
      }
      case '\n':
      {
        match('\n');
        newline();
        break;
      }
      case '\'':
      {
        mCHAR_LITERAL(false);
        break;
      }
      case '"':
      {
        mSTRING_LITERAL(false);
        break;
      }
      default:
        if ((LA(1)=='\r') && (LA(2)=='\n')) {
          match('\r');
          match('\n');
          newline();
        }
        else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
          match('\r');
          newline();
        }
        else if ((_tokenSet_3.member(LA(1)))) {
          matchNot(']');
        }
      else {
        break _loop200;
      }
      }
    } 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 mACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = ACTION;
    int _saveIndex;
    int actionLine=getLine(); int actionColumn = getColumn();
   
    mNESTED_ACTION(false);
    {
    if ((LA(1)=='?')) {
      match('?');
      _ttype = SEMPRED;
    }
    else {
    }
   
    }
   
          if ( _ttype==ACTION ) {
            setText(StringUtils.stripFrontBack(getText(), "{", "}"));
          }
          else {
            setText(StringUtils.stripFrontBack(getText(), "{", "}?"));
          }
          CommonToken t = new CommonToken(_ttype,new String(text.getBuffer(),_begin,text.length()-_begin));
          t.setLine(actionLine);      // set action line to start
          t.setColumn(actionColumn);
          _token = t;
       
    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 mNESTED_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = NESTED_ACTION;
    int _saveIndex;
   
    match('{');
    {
    _loop206:
    do {
      // nongreedy exit test
      if ((LA(1)=='}') && (true)) break _loop206;
      if ((LA(1)=='\n'||LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        {
        if ((LA(1)=='\r') && (LA(2)=='\n')) {
          match('\r');
          match('\n');
          newline();
        }
        else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
          match('\r');
          newline();
        }
        else if ((LA(1)=='\n')) {
          match('\n');
          newline();
        }
        else {
          throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
        }
       
        }
      }
      else if ((LA(1)=='{') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        mNESTED_ACTION(false);
      }
      else if ((LA(1)=='\'') && (_tokenSet_4.member(LA(2)))) {
        mCHAR_LITERAL(false);
      }
      else if ((LA(1)=='/') && (LA(2)=='*'||LA(2)=='/')) {
        mCOMMENT(false);
      }
      else if ((LA(1)=='"') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        mSTRING_LITERAL(false);
      }
      else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
        matchNot(EOF_CHAR);
      }
      else {
        break _loop206;
      }
     
    } 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 mTOKEN_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = TOKEN_REF;
    int _saveIndex;
   
    matchRange('A','Z');
    {
    _loop209:
    do {
      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;
      }
      case '0'case '1'case '2'case '3':
      case '4'case '5'case '6'case '7':
      case '8'case '9':
      {
        matchRange('0','9');
        break;
      }
      default:
      {
        break _loop209;
      }
      }
    } while (true);
    }
    _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;
  }
 
  public final void mRULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = RULE_REF;
    int _saveIndex;
   
      int t=0;
   
   
    t=mINTERNAL_RULE_REF(false);
    _ttype=t;
    {
    if (( true )&&(t==LITERAL_options)) {
      mWS_LOOP(false);
      {
      if ((LA(1)=='{')) {
        match('{');
        _ttype = OPTIONS;
      }
      else {
      }
     
      }
    }
    else if (( true )&&(t==LITERAL_tokens)) {
      mWS_LOOP(false);
      {
      if ((LA(1)=='{')) {
        match('{');
        _ttype = TOKENS;
      }
      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 int  mINTERNAL_RULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int t;
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = INTERNAL_RULE_REF;
    int _saveIndex;
   
      t = RULE_REF;
   
   
    matchRange('a','z');
    {
    _loop219:
    do {
      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;
      }
      case '0'case '1'case '2'case '3':
      case '4'case '5'case '6'case '7':
      case '8'case '9':
      {
        matchRange('0','9');
        break;
      }
      default:
      {
        break _loop219;
      }
      }
    } while (true);
    }
    t = testLiteralsTable(t);
    if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
      _token = makeToken(_ttype);
      _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    }
    _returnToken = _token;
    return t;
  }
 
  protected final void mWS_LOOP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = WS_LOOP;
    int _saveIndex;
   
    {
    _loop216:
    do {
      switch ( LA(1)) {
      case '\t'case '\n'case '\r'case ' ':
      {
        mWS(false);
        break;
      }
      case '/':
      {
        mCOMMENT(false);
        break;
      }
      default:
      {
        break _loop216;
      }
      }
    } 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 mWS_OPT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    int _ttype; Token _token=null; int _begin=text.length();
    _ttype = WS_OPT;
    int _saveIndex;
   
    {
    if ((_tokenSet_5.member(LA(1)))) {
      mWS(false);
    }
    else {
    }
   
    }
    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[8];
    data[0]=-9224L;
    for (int i = 1; i<=3; i++) { data[i]=-1L; }
    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]=-549755813896L;
    data[1]=-268435457L;
    for (int i = 2; i<=3; i++) { data[i]=-1L; }
    return data;
  }
  public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
  private static final long[] mk_tokenSet_2() {
    long[] data = new long[8];
    data[0]=-17179869192L;
    data[1]=-268435457L;
    for (int i = 2; i<=3; i++) { data[i]=-1L; }
    return data;
  }
  public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
  private static final long[] mk_tokenSet_3() {
    long[] data = new long[8];
    data[0]=-566935692296L;
    data[1]=-671088641L;
    for (int i = 2; i<=3; i++) { data[i]=-1L; }
    return data;
  }
  public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
  private static final long[] mk_tokenSet_4() {
    long[] data = new long[8];
    data[0]=-549755813896L;
    for (int i = 1; i<=3; i++) { data[i]=-1L; }
    return data;
  }
  public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
  private static final long[] mk_tokenSet_5() {
    long[] data = { 4294977024L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
 
  }
TOP

Related Classes of antlr.ANTLRLexer

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.