Logo Search packages:      
Sourcecode: antlr version File versions

ANTLRLexer.java

// $ANTLR : "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(32));
      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(38));
      literals.put(new ANTLRHashString("lexclass", this), new Integer(9));
      literals.put(new ANTLRHashString("catch", this), new Integer(41));
      literals.put(new ANTLRHashString("private", this), new Integer(33));
      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(31));
      literals.put(new ANTLRHashString("TreeParser", this), new Integer(13));
      literals.put(new ANTLRHashString("Parser", this), new Integer(30));
      literals.put(new ANTLRHashString("Lexer", this), new Integer(12));
      literals.put(new ANTLRHashString("returns", this), new Integer(36));
      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(40));
}

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) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
                        {
                        matchRange('0','9');
                        }
                        {
                        if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
                              matchRange('0','9');
                        }
                        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) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
                        {
                        matchRange('0','9');
                        }
                  }
                  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 _cnt198=0;
            _loop198:
            do {
                  if (((LA(1) >= '0' && LA(1) <= '9'))) {
                        matchRange('0','9');
                  }
                  else {
                        if ( _cnt198>=1 ) { break _loop198; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
                  }
                  
                  _cnt198++;
            } 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('[');
            {
            _loop202:
            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 _loop202;
                  }
                  }
            } 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('{');
            {
            _loop208:
            do {
                  // nongreedy exit test
                  if ((LA(1)=='}') && (true)) break _loop208;
                  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 _loop208;
                  }
                  
            } 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');
            {
            _loop211:
            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 _loop211;
                  }
                  }
            } 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');
            {
            _loop221:
            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 _loop221;
                  }
                  }
            } 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;
            
            {
            _loop218:
            do {
                  switch ( LA(1)) {
                  case '\t':  case '\n':  case '\r':  case ' ':
                  {
                        mWS(false);
                        break;
                  }
                  case '/':
                  {
                        mCOMMENT(false);
                        break;
                  }
                  default:
                  {
                        break _loop218;
                  }
                  }
            } 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());
      
      }

Generated by  Doxygen 1.6.0   Back to index