Logo Search packages:      
Sourcecode: antlr version File versions

ANTLRTokdefLexer.java

// $ANTLR : "tokdef.g" -> "ANTLRTokdefLexer.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 ANTLRTokdefLexer extends antlr.CharScanner implements ANTLRTokdefParserTokenTypes, TokenStream
 {
public ANTLRTokdefLexer(InputStream in) {
      this(new ByteBuffer(in));
}
public ANTLRTokdefLexer(Reader in) {
      this(new CharBuffer(in));
}
public ANTLRTokdefLexer(InputBuffer ib) {
      this(new LexerSharedInputState(ib));
}
public ANTLRTokdefLexer(LexerSharedInputState state) {
      super(state);
      caseSensitiveLiterals = true;
      setCaseSensitive(true);
      literals = new Hashtable();
}

public Token nextToken() throws TokenStreamException {
      Token theRetToken=null;
tryAgain:
      for (;;) {
            Token _token = null;
            int _ttype = Token.INVALID_TYPE;
            resetText();
            try {   // for char stream error handling
                  try {   // for lexical error handling
                        switch ( LA(1)) {
                        case '\t':  case '\n':  case '\r':  case ' ':
                        {
                              mWS(true);
                              theRetToken=_returnToken;
                              break;
                        }
                        case '(':
                        {
                              mLPAREN(true);
                              theRetToken=_returnToken;
                              break;
                        }
                        case ')':
                        {
                              mRPAREN(true);
                              theRetToken=_returnToken;
                              break;
                        }
                        case '=':
                        {
                              mASSIGN(true);
                              theRetToken=_returnToken;
                              break;
                        }
                        case '"':
                        {
                              mSTRING(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':  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':
                        {
                              mID(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;
                        }
                        default:
                              if ((LA(1)=='/') && (LA(2)=='/')) {
                                    mSL_COMMENT(true);
                                    theRetToken=_returnToken;
                              }
                              else if ((LA(1)=='/') && (LA(2)=='*')) {
                                    mML_COMMENT(true);
                                    theRetToken=_returnToken;
                              }
                        else {
                              if (LA(1)==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 '\r':
            {
                  match('\r');
                  {
                  if ((LA(1)=='\n')) {
                        match('\n');
                  }
                  else {
                  }
                  
                  }
                  newline();
                  break;
            }
            case '\n':
            {
                  match('\n');
                  newline();
                  break;
            }
            default:
            {
                  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 mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = SL_COMMENT;
            int _saveIndex;
            
            match("//");
            {
            _loop236:
            do {
                  if ((_tokenSet_0.member(LA(1)))) {
                        {
                        match(_tokenSet_0);
                        }
                  }
                  else {
                        break _loop236;
                  }
                  
            } while (true);
            }
            {
            switch ( LA(1)) {
            case '\n':
            {
                  match('\n');
                  break;
            }
            case '\r':
            {
                  match('\r');
                  {
                  if ((LA(1)=='\n')) {
                        match('\n');
                  }
                  else {
                  }
                  
                  }
                  break;
            }
            default:
            {
                  throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
            }
            }
            }
            _ttype = Token.SKIP; newline();
            if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
                  _token = makeToken(_ttype);
                  _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
            }
            _returnToken = _token;
      }
      
      public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = ML_COMMENT;
            int _saveIndex;
            
            match("/*");
            {
            _loop241:
            do {
                  if ((LA(1)=='*') && (_tokenSet_1.member(LA(2)))) {
                        match('*');
                        matchNot('/');
                  }
                  else if ((LA(1)=='\n')) {
                        match('\n');
                        newline();
                  }
                  else if ((_tokenSet_2.member(LA(1)))) {
                        matchNot('*');
                  }
                  else {
                        break _loop241;
                  }
                  
            } while (true);
            }
            match("*/");
            _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 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 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 mSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = STRING;
            int _saveIndex;
            
            match('"');
            {
            _loop247:
            do {
                  if ((LA(1)=='\\')) {
                        mESC(false);
                  }
                  else if ((_tokenSet_3.member(LA(1)))) {
                        matchNot('"');
                  }
                  else {
                        break _loop247;
                  }
                  
            } 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 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 '"':
            {
                  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'))) {
                        mDIGIT(false);
                        {
                        if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) {
                              mDIGIT(false);
                        }
                        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'))) {
                        mDIGIT(false);
                  }
                  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;
      }
      
      protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = DIGIT;
            int _saveIndex;
            
            matchRange('0','9');
            if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
                  _token = makeToken(_ttype);
                  _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
            }
            _returnToken = _token;
      }
      
      protected final void 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;
      }
      
      public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = ID;
            int _saveIndex;
            
            {
            switch ( LA(1)) {
            case 'a':  case 'b':  case 'c':  case 'd':
            case 'e':  case 'f':  case 'g':  case 'h':
            case 'i':  case 'j':  case 'k':  case 'l':
            case 'm':  case 'n':  case 'o':  case 'p':
            case 'q':  case 'r':  case 's':  case 't':
            case 'u':  case 'v':  case 'w':  case 'x':
            case 'y':  case 'z':
            {
                  matchRange('a','z');
                  break;
            }
            case 'A':  case 'B':  case 'C':  case 'D':
            case 'E':  case 'F':  case 'G':  case 'H':
            case 'I':  case 'J':  case 'K':  case 'L':
            case 'M':  case 'N':  case 'O':  case 'P':
            case 'Q':  case 'R':  case 'S':  case 'T':
            case 'U':  case 'V':  case 'W':  case 'X':
            case 'Y':  case 'Z':
            {
                  matchRange('A','Z');
                  break;
            }
            default:
            {
                  throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
            }
            }
            }
            {
            _loop260:
            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 _loop260;
                  }
                  }
            } 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 mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
            int _ttype; Token _token=null; int _begin=text.length();
            _ttype = INT;
            int _saveIndex;
            
            {
            int _cnt263=0;
            _loop263:
            do {
                  if (((LA(1) >= '0' && LA(1) <= '9'))) {
                        mDIGIT(false);
                  }
                  else {
                        if ( _cnt263>=1 ) { break _loop263; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
                  }
                  
                  _cnt263++;
            } while (true);
            }
            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]=-140737488355336L;
            for (int i = 1; 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]=-4398046512136L;
            for (int i = 1; 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]=-17179869192L;
            data[1]=-268435457L;
            for (int i = 2; i<=3; i++) { data[i]=-1L; }
            return data;
      }
      public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
      
      }

Generated by  Doxygen 1.6.0   Back to index