/* | |
* Licensed to the Apache Software Foundation (ASF) under one | |
* or more contributor license agreements. See the NOTICE file | |
* distributed with this work for additional information | |
* regarding copyright ownership. The ASF licenses this file | |
* to you under the Apache License, Version 2.0 (the | |
* "License"); you may not use this file except in compliance | |
* with the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, | |
* software distributed under the License is distributed on an | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
* KIND, either express or implied. See the License for the | |
* specific language governing permissions and limitations | |
* under the License. | |
*/ | |
// $ANTLR 2.7.6 (2005-12-22): "org.apache.axis2.corba.idl.g" -> "IDLLexer.java"$ | |
package org.apache.axis2.corba.idl.parser; | |
import antlr.ANTLRHashString; | |
import antlr.ByteBuffer; | |
import antlr.CharBuffer; | |
import antlr.CharStreamException; | |
import antlr.CharStreamIOException; | |
import antlr.InputBuffer; | |
import antlr.LexerSharedInputState; | |
import antlr.NoViableAltForCharException; | |
import antlr.RecognitionException; | |
import antlr.Token; | |
import antlr.TokenStream; | |
import antlr.TokenStreamException; | |
import antlr.TokenStreamIOException; | |
import antlr.TokenStreamRecognitionException; | |
import antlr.collections.impl.BitSet; | |
import java.io.InputStream; | |
import java.io.Reader; | |
import java.util.Hashtable; | |
public class IDLLexer extends antlr.CharScanner implements IDLTokenTypes, TokenStream | |
{ | |
public IDLLexer(InputStream in) { | |
this(new ByteBuffer(in)); | |
} | |
public IDLLexer(Reader in) { | |
this(new CharBuffer(in)); | |
} | |
public IDLLexer(InputBuffer ib) { | |
this(new LexerSharedInputState(ib)); | |
} | |
public IDLLexer(LexerSharedInputState state) { | |
super(state); | |
caseSensitiveLiterals = true; | |
setCaseSensitive(true); | |
literals = new Hashtable(); | |
literals.put(new ANTLRHashString("switch", this), new Integer(57)); | |
literals.put(new ANTLRHashString("typeprefix", this), new Integer(79)); | |
literals.put(new ANTLRHashString("case", this), new Integer(58)); | |
literals.put(new ANTLRHashString("finder", this), new Integer(94)); | |
literals.put(new ANTLRHashString("manages", this), new Integer(92)); | |
literals.put(new ANTLRHashString("interface", this), new Integer(7)); | |
literals.put(new ANTLRHashString("provides", this), new Integer(85)); | |
literals.put(new ANTLRHashString("exception", this), new Integer(68)); | |
literals.put(new ANTLRHashString("primarykey", this), new Integer(93)); | |
literals.put(new ANTLRHashString("sequence", this), new Integer(61)); | |
literals.put(new ANTLRHashString("uses", this), new Integer(86)); | |
literals.put(new ANTLRHashString("consumes", this), new Integer(90)); | |
literals.put(new ANTLRHashString("void", this), new Integer(70)); | |
literals.put(new ANTLRHashString("factory", this), new Integer(23)); | |
literals.put(new ANTLRHashString("import", this), new Integer(77)); | |
literals.put(new ANTLRHashString("float", this), new Integer(44)); | |
literals.put(new ANTLRHashString("publishes", this), new Integer(89)); | |
literals.put(new ANTLRHashString("private", this), new Integer(22)); | |
literals.put(new ANTLRHashString("boolean", this), new Integer(51)); | |
literals.put(new ANTLRHashString("string", this), new Integer(64)); | |
literals.put(new ANTLRHashString("getraises", this), new Integer(82)); | |
literals.put(new ANTLRHashString("emits", this), new Integer(88)); | |
literals.put(new ANTLRHashString("custom", this), new Integer(8)); | |
literals.put(new ANTLRHashString("component", this), new Integer(84)); | |
literals.put(new ANTLRHashString("context", this), new Integer(74)); | |
literals.put(new ANTLRHashString("octet", this), new Integer(52)); | |
literals.put(new ANTLRHashString("oneway", this), new Integer(69)); | |
literals.put(new ANTLRHashString("long", this), new Integer(46)); | |
literals.put(new ANTLRHashString("ValueBase", this), new Integer(76)); | |
literals.put(new ANTLRHashString("in", this), new Integer(26)); | |
literals.put(new ANTLRHashString("truncatable", this), new Integer(19)); | |
literals.put(new ANTLRHashString("FALSE", this), new Integer(41)); | |
literals.put(new ANTLRHashString("readonly", this), new Integer(80)); | |
literals.put(new ANTLRHashString("typedef", this), new Integer(42)); | |
literals.put(new ANTLRHashString("supports", this), new Integer(20)); | |
literals.put(new ANTLRHashString("short", this), new Integer(47)); | |
literals.put(new ANTLRHashString("TRUE", this), new Integer(40)); | |
literals.put(new ANTLRHashString("fixed", this), new Integer(75)); | |
literals.put(new ANTLRHashString("Object", this), new Integer(54)); | |
literals.put(new ANTLRHashString("enum", this), new Integer(60)); | |
literals.put(new ANTLRHashString("home", this), new Integer(91)); | |
literals.put(new ANTLRHashString("multiple", this), new Integer(87)); | |
literals.put(new ANTLRHashString("attribute", this), new Integer(81)); | |
literals.put(new ANTLRHashString("char", this), new Integer(49)); | |
literals.put(new ANTLRHashString("union", this), new Integer(56)); | |
literals.put(new ANTLRHashString("local", this), new Integer(6)); | |
literals.put(new ANTLRHashString("const", this), new Integer(27)); | |
literals.put(new ANTLRHashString("setraises", this), new Integer(83)); | |
literals.put(new ANTLRHashString("abstract", this), new Integer(5)); | |
literals.put(new ANTLRHashString("valuetype", this), new Integer(9)); | |
literals.put(new ANTLRHashString("inout", this), new Integer(72)); | |
literals.put(new ANTLRHashString("raises", this), new Integer(73)); | |
literals.put(new ANTLRHashString("out", this), new Integer(71)); | |
literals.put(new ANTLRHashString("typeid", this), new Integer(78)); | |
literals.put(new ANTLRHashString("wchar", this), new Integer(50)); | |
literals.put(new ANTLRHashString("any", this), new Integer(53)); | |
literals.put(new ANTLRHashString("double", this), new Integer(45)); | |
literals.put(new ANTLRHashString("default", this), new Integer(59)); | |
literals.put(new ANTLRHashString("eventtype", this), new Integer(10)); | |
literals.put(new ANTLRHashString("wstring", this), new Integer(65)); | |
literals.put(new ANTLRHashString("unsigned", this), new Integer(48)); | |
literals.put(new ANTLRHashString("struct", this), new Integer(55)); | |
literals.put(new ANTLRHashString("public", this), new Integer(21)); | |
literals.put(new ANTLRHashString("module", this), new Integer(11)); | |
literals.put(new ANTLRHashString("native", this), new Integer(43)); | |
} | |
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 ';': | |
{ | |
mSEMI(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '?': | |
{ | |
mQUESTION(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '(': | |
{ | |
mLPAREN(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case ')': | |
{ | |
mRPAREN(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '[': | |
{ | |
mLBRACK(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case ']': | |
{ | |
mRBRACK(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '{': | |
{ | |
mLCURLY(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '}': | |
{ | |
mRCURLY(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '|': | |
{ | |
mOR(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '^': | |
{ | |
mXOR(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '&': | |
{ | |
mAND(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case ',': | |
{ | |
mCOMMA(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '=': | |
{ | |
mASSIGN(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '!': | |
{ | |
mNOT(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '+': | |
{ | |
mPLUS(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '-': | |
{ | |
mMINUS(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '~': | |
{ | |
mTILDE(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '*': | |
{ | |
mSTAR(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '%': | |
{ | |
mMOD(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '\t': case '\n': case '\r': case ' ': | |
{ | |
mWS(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '#': | |
{ | |
mPREPROC_DIRECTIVE(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '\'': | |
{ | |
mCHAR_LITERAL(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '"': | |
{ | |
mSTRING_LITERAL(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '1': case '2': case '3': case '4': | |
case '5': case '6': case '7': case '8': | |
case '9': | |
{ | |
mINT(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
case '_': | |
{ | |
mESCAPED_IDENT(true); | |
theRetToken=_returnToken; | |
break; | |
} | |
default: | |
if ((LA(1)=='<') && (LA(2)=='<')) { | |
mLSHIFT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='>') && (LA(2)=='>')) { | |
mRSHIFT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)==':') && (LA(2)==':')) { | |
mSCOPEOP(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='/') && (LA(2)=='/')) { | |
mSL_COMMENT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='/') && (LA(2)=='*')) { | |
mML_COMMENT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='L') && (LA(2)=='\'')) { | |
mWIDE_CHAR_LITERAL(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='L') && (LA(2)=='"')) { | |
mWIDE_STRING_LITERAL(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='0') && (LA(2)=='X'||LA(2)=='x')) { | |
mHEX(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='.') && ((LA(2) >= '0' && LA(2) <= '9'))) { | |
mFLOAT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)==':') && (true)) { | |
mCOLON(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='.') && (true)) { | |
mDOT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='<') && (true)) { | |
mLT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='>') && (true)) { | |
mGT(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='/') && (true)) { | |
mDIV(true); | |
theRetToken=_returnToken; | |
} | |
else if ((LA(1)=='0') && (true)) { | |
mOCTAL(true); | |
theRetToken=_returnToken; | |
} | |
else if ((_tokenSet_0.member(LA(1))) && (true)) { | |
mIDENT(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(); | |
_ttype = testLiteralsTable(_ttype); | |
_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 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 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 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 mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = LBRACK; | |
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 mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = RBRACK; | |
int _saveIndex; | |
match(']'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = LCURLY; | |
int _saveIndex; | |
match('{'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = RCURLY; | |
int _saveIndex; | |
match('}'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void 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 mXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = XOR; | |
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 mAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = AND; | |
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 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 mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = DOT; | |
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 mNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = NOT; | |
int _saveIndex; | |
match('!'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = LT; | |
int _saveIndex; | |
match('<'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mLSHIFT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = LSHIFT; | |
int _saveIndex; | |
match("<<"); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = GT; | |
int _saveIndex; | |
match('>'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mRSHIFT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = RSHIFT; | |
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 mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = DIV; | |
int _saveIndex; | |
match('/'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = PLUS; | |
int _saveIndex; | |
match('+'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = MINUS; | |
int _saveIndex; | |
match('-'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mTILDE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = TILDE; | |
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 mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = MOD; | |
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 mSCOPEOP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = SCOPEOP; | |
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 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; | |
} | |
case '\r': | |
{ | |
match('\r'); | |
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 mPREPROC_DIRECTIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = PREPROC_DIRECTIVE; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('#'); | |
text.setLength(_saveIndex); | |
{ | |
_loop322: | |
do { | |
if ((_tokenSet_1.member(LA(1)))) { | |
matchNot('\n'); | |
} | |
else { | |
break _loop322; | |
} | |
} while (true); | |
} | |
_saveIndex=text.length(); | |
match('\n'); | |
text.setLength(_saveIndex); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
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; | |
_saveIndex=text.length(); | |
match("//"); | |
text.setLength(_saveIndex); | |
{ | |
_loop325: | |
do { | |
if ((_tokenSet_1.member(LA(1)))) { | |
matchNot('\n'); | |
} | |
else { | |
break _loop325; | |
} | |
} while (true); | |
} | |
match('\n'); | |
_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; | |
_saveIndex=text.length(); | |
match("/*"); | |
text.setLength(_saveIndex); | |
{ | |
_loop333: | |
do { | |
if ((LA(1)=='*') && (_tokenSet_2.member(LA(2)))) { | |
{ | |
int _cnt329=0; | |
_loop329: | |
do { | |
if ((LA(1)=='*')) { | |
match('*'); | |
} | |
else { | |
if ( _cnt329>=1 ) { break _loop329; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt329++; | |
} while (true); | |
} | |
{ | |
if ((LA(1)=='\n')) { | |
match('\n'); | |
newline(); | |
} | |
else if ((_tokenSet_3.member(LA(1)))) { | |
{ | |
match(_tokenSet_3); | |
} | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
else if ((LA(1)=='\n')) { | |
match('\n'); | |
newline(); | |
} | |
else if ((_tokenSet_4.member(LA(1)))) { | |
{ | |
match(_tokenSet_4); | |
} | |
} | |
else { | |
break _loop333; | |
} | |
} while (true); | |
} | |
_saveIndex=text.length(); | |
match("*/"); | |
text.setLength(_saveIndex); | |
_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 mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = CHAR_LITERAL; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('\''); | |
text.setLength(_saveIndex); | |
{ | |
if ((LA(1)=='\\')) { | |
mESC(false); | |
} | |
else if ((_tokenSet_5.member(LA(1)))) { | |
matchNot('\''); | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
_saveIndex=text.length(); | |
match('\''); | |
text.setLength(_saveIndex); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = ESC; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('\\'); | |
text.setLength(_saveIndex); | |
{ | |
switch ( LA(1)) { | |
case 'n': | |
{ | |
match('n'); | |
text.setLength(_begin); text.append("\n"); | |
break; | |
} | |
case 't': | |
{ | |
match('t'); | |
text.setLength(_begin); text.append("\t"); | |
break; | |
} | |
case 'v': | |
{ | |
match('v'); | |
text.setLength(_begin); text.append("\013"); | |
break; | |
} | |
case 'b': | |
{ | |
match('b'); | |
text.setLength(_begin); text.append("\b"); | |
break; | |
} | |
case 'r': | |
{ | |
match('r'); | |
text.setLength(_begin); text.append("\r"); | |
break; | |
} | |
case 'f': | |
{ | |
match('f'); | |
text.setLength(_begin); text.append("\r"); | |
break; | |
} | |
case 'a': | |
{ | |
match('a'); | |
text.setLength(_begin); text.append("\007"); | |
break; | |
} | |
case '\\': | |
{ | |
match('\\'); | |
text.setLength(_begin); text.append("\\"); | |
break; | |
} | |
case '?': | |
{ | |
match('?'); | |
text.setLength(_begin); text.append("?"); | |
break; | |
} | |
case '\'': | |
{ | |
match('\''); | |
text.setLength(_begin); text.append("'"); | |
break; | |
} | |
case '"': | |
{ | |
match('"'); | |
text.setLength(_begin); text.append("\""); | |
break; | |
} | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
{ | |
mOCTDIGIT(false); | |
{ | |
if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mOCTDIGIT(false); | |
{ | |
if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mOCTDIGIT(false); | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
char realc = (char) Integer.valueOf(new String(text.getBuffer(),_begin,text.length()-_begin), 8).intValue(); text.setLength(_begin); text.append(realc); | |
break; | |
} | |
case 'x': | |
{ | |
_saveIndex=text.length(); | |
match('x'); | |
text.setLength(_saveIndex); | |
mHEXDIGIT(false); | |
{ | |
if ((_tokenSet_6.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mHEXDIGIT(false); | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
char realc = (char) Integer.valueOf(new String(text.getBuffer(),_begin,text.length()-_begin), 16).intValue(); text.setLength(_begin); text.append(realc); | |
break; | |
} | |
case 'u': | |
{ | |
_saveIndex=text.length(); | |
match('u'); | |
text.setLength(_saveIndex); | |
mHEXDIGIT(false); | |
{ | |
if ((_tokenSet_6.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mHEXDIGIT(false); | |
{ | |
if ((_tokenSet_6.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mHEXDIGIT(false); | |
{ | |
if ((_tokenSet_6.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) { | |
mHEXDIGIT(false); | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) { | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
char realc = (char) Integer.valueOf(new String(text.getBuffer(),_begin,text.length()-_begin), 16).intValue(); text.setLength(_begin); text.append(realc); | |
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 mWIDE_CHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = WIDE_CHAR_LITERAL; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('L'); | |
text.setLength(_saveIndex); | |
mCHAR_LITERAL(false); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = STRING_LITERAL; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('"'); | |
text.setLength(_saveIndex); | |
{ | |
_loop339: | |
do { | |
if ((LA(1)=='\\')) { | |
mESC(false); | |
} | |
else if ((_tokenSet_7.member(LA(1)))) { | |
matchNot('"'); | |
} | |
else { | |
break _loop339; | |
} | |
} while (true); | |
} | |
_saveIndex=text.length(); | |
match('"'); | |
text.setLength(_saveIndex); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
public final void mWIDE_STRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = WIDE_STRING_LITERAL; | |
int _saveIndex; | |
_saveIndex=text.length(); | |
match('L'); | |
text.setLength(_saveIndex); | |
mSTRING_LITERAL(false); | |
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 mOCTDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = OCTDIGIT; | |
int _saveIndex; | |
matchRange('0','7'); | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
protected final void mHEXDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = HEXDIGIT; | |
int _saveIndex; | |
{ | |
switch ( LA(1)) { | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
case '8': case '9': | |
{ | |
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 mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = VOCAB; | |
int _saveIndex; | |
matchRange('\3','\377'); | |
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 mNONZERODIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = NONZERODIGIT; | |
int _saveIndex; | |
matchRange('1','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 mHEX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = HEX; | |
int _saveIndex; | |
{ | |
if ((LA(1)=='0') && (LA(2)=='x')) { | |
match("0x"); | |
} | |
else if ((LA(1)=='0') && (LA(2)=='X')) { | |
match("0X"); | |
} | |
else { | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
{ | |
int _cnt358=0; | |
_loop358: | |
do { | |
if ((_tokenSet_6.member(LA(1)))) { | |
mHEXDIGIT(false); | |
} | |
else { | |
if ( _cnt358>=1 ) { break _loop358; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt358++; | |
} 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; | |
mNONZERODIGIT(false); | |
{ | |
_loop361: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
break _loop361; | |
} | |
} while (true); | |
} | |
{ | |
switch ( LA(1)) { | |
case '.': | |
{ | |
match('.'); | |
{ | |
_loop364: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
break _loop364; | |
} | |
} while (true); | |
} | |
{ | |
switch ( LA(1)) { | |
case 'E': case 'e': | |
{ | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'e': | |
{ | |
match('e'); | |
break; | |
} | |
case 'E': | |
{ | |
match('E'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
switch ( LA(1)) { | |
case '+': | |
{ | |
match('+'); | |
break; | |
} | |
case '-': | |
{ | |
match('-'); | |
break; | |
} | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
case '8': case '9': | |
{ | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
int _cnt370=0; | |
_loop370: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
if ( _cnt370>=1 ) { break _loop370; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt370++; | |
} while (true); | |
} | |
} | |
_ttype = FLOAT; | |
break; | |
} | |
case 'D': case 'd': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'd': | |
{ | |
match('d'); | |
break; | |
} | |
case 'D': | |
{ | |
match('D'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
_ttype = FIXED; | |
break; | |
} | |
default: | |
{ | |
_ttype = FLOAT; | |
} | |
} | |
} | |
break; | |
} | |
case 'E': case 'e': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'e': | |
{ | |
match('e'); | |
break; | |
} | |
case 'E': | |
{ | |
match('E'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
switch ( LA(1)) { | |
case '+': | |
{ | |
match('+'); | |
break; | |
} | |
case '-': | |
{ | |
match('-'); | |
break; | |
} | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
case '8': case '9': | |
{ | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
int _cnt375=0; | |
_loop375: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
if ( _cnt375>=1 ) { break _loop375; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt375++; | |
} while (true); | |
} | |
_ttype = FLOAT; | |
break; | |
} | |
case 'D': case 'd': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'd': | |
{ | |
match('d'); | |
break; | |
} | |
case 'D': | |
{ | |
match('D'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
_ttype = FIXED; | |
break; | |
} | |
default: | |
{ | |
} | |
} | |
} | |
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 mOCTAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = OCTAL; | |
int _saveIndex; | |
match('0'); | |
{ | |
switch ( LA(1)) { | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
case '8': case '9': | |
{ | |
{ | |
int _cnt380=0; | |
_loop380: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
if ( _cnt380>=1 ) { break _loop380; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt380++; | |
} while (true); | |
} | |
break; | |
} | |
case '.': | |
{ | |
mFLOAT(false); | |
_ttype = FLOAT; | |
break; | |
} | |
case 'D': case 'd': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'd': | |
{ | |
match('d'); | |
break; | |
} | |
case 'D': | |
{ | |
match('D'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
_ttype = FIXED; | |
break; | |
} | |
default: | |
{ | |
_ttype = INT; | |
} | |
} | |
} | |
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 mFLOAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = FLOAT; | |
int _saveIndex; | |
match('.'); | |
{ | |
int _cnt384=0; | |
_loop384: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
if ( _cnt384>=1 ) { break _loop384; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt384++; | |
} while (true); | |
} | |
{ | |
switch ( LA(1)) { | |
case 'E': case 'e': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'e': | |
{ | |
match('e'); | |
break; | |
} | |
case 'E': | |
{ | |
match('E'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
switch ( LA(1)) { | |
case '+': | |
{ | |
match('+'); | |
break; | |
} | |
case '-': | |
{ | |
match('-'); | |
break; | |
} | |
case '0': case '1': case '2': case '3': | |
case '4': case '5': case '6': case '7': | |
case '8': case '9': | |
{ | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
{ | |
int _cnt389=0; | |
_loop389: | |
do { | |
if (((LA(1) >= '0' && LA(1) <= '9'))) { | |
mDIGIT(false); | |
} | |
else { | |
if ( _cnt389>=1 ) { break _loop389; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} | |
} | |
_cnt389++; | |
} while (true); | |
} | |
break; | |
} | |
case 'D': case 'd': | |
{ | |
{ | |
switch ( LA(1)) { | |
case 'd': | |
{ | |
match('d'); | |
break; | |
} | |
case 'D': | |
{ | |
match('D'); | |
break; | |
} | |
default: | |
{ | |
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); | |
} | |
} | |
} | |
_ttype = FIXED; | |
break; | |
} | |
default: | |
{ | |
} | |
} | |
} | |
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 mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = IDENT; | |
int _saveIndex; | |
{ | |
switch ( LA(1)) { | |
case 'a': case 'b': case 'c': case 'd': | |
case 'e': case 'f': case 'g': case 'h': | |
case 'i': case 'j': case 'k': case 'l': | |
case 'm': case 'n': case 'o': case 'p': | |
case 'q': case 'r': case 's': case 't': | |
case 'u': case 'v': case 'w': case 'x': | |
case 'y': case 'z': | |
{ | |
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()); | |
} | |
} | |
} | |
{ | |
_loop394: | |
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 _loop394; | |
} | |
} | |
} 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 mESCAPED_IDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { | |
int _ttype; Token _token=null; int _begin=text.length(); | |
_ttype = ESCAPED_IDENT; | |
int _saveIndex; | |
match('_'); | |
{ | |
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()); | |
} | |
} | |
} | |
{ | |
_loop398: | |
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 _loop398; | |
} | |
} | |
} while (true); | |
} | |
_begin++;_ttype = IDENT; | |
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { | |
_token = makeToken(_ttype); | |
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); | |
} | |
_returnToken = _token; | |
} | |
private static final long[] mk_tokenSet_0() { | |
long[] data = new long[1025]; | |
data[1]=576460743847706622L; | |
return data; | |
} | |
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); | |
private static final long[] mk_tokenSet_1() { | |
long[] data = new long[2048]; | |
data[0]=-1025L; | |
for (int i = 1; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); | |
private static final long[] mk_tokenSet_2() { | |
long[] data = new long[2048]; | |
data[0]=-140737488355329L; | |
for (int i = 1; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); | |
private static final long[] mk_tokenSet_3() { | |
long[] data = new long[2048]; | |
data[0]=-145135534867457L; | |
for (int i = 1; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); | |
private static final long[] mk_tokenSet_4() { | |
long[] data = new long[2048]; | |
data[0]=-4398046512129L; | |
for (int i = 1; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); | |
private static final long[] mk_tokenSet_5() { | |
long[] data = new long[2048]; | |
data[0]=-549755813889L; | |
data[1]=-268435457L; | |
for (int i = 2; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5()); | |
private static final long[] mk_tokenSet_6() { | |
long[] data = new long[1025]; | |
data[0]=287948901175001088L; | |
data[1]=541165879422L; | |
return data; | |
} | |
public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6()); | |
private static final long[] mk_tokenSet_7() { | |
long[] data = new long[2048]; | |
data[0]=-17179869185L; | |
data[1]=-268435457L; | |
for (int i = 2; i<=1022; i++) { data[i]=-1L; } | |
data[1023]=9223372036854775807L; | |
return data; | |
} | |
public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7()); | |
} |