axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dee...@apache.org
Subject svn commit: r572651 [2/6] - in /webservices/axis2/trunk/java: ./ modules/codegen/src/org/apache/axis2/wsdl/codegen/writer/ modules/corba/ modules/corba/src/ modules/corba/src/org/ modules/corba/src/org/apache/ modules/corba/src/org/apache/axis2/ module...
Date Tue, 04 Sep 2007 12:39:45 GMT
Added: webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLLexer.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLLexer.java?rev=572651&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLLexer.java (added)
+++ webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLLexer.java Tue Sep  4 05:39:42 2007
@@ -0,0 +1,1943 @@
+// $ANTLR 2.7.6 (2005-12-22): "org.apache.axis2.corba.idl.g" -> "IDLLexer.java"$
+
+  package org.apache.axis2.corba.idl.parser;
+
+  import java.util.Hashtable;
+ 
+import java.io.InputStream;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.TokenStreamRecognitionException;
+import antlr.CharStreamException;
+import antlr.CharStreamIOException;
+
+  import java.io.Reader;
+
+  import antlr.InputBuffer;
+import antlr.ByteBuffer;
+import antlr.CharBuffer;
+import antlr.Token;
+  import antlr.RecognitionException;
+import antlr.NoViableAltForCharException;
+  import antlr.TokenStream;
+import antlr.ANTLRHashString;
+import antlr.LexerSharedInputState;
+import antlr.collections.impl.BitSet;
+
+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());
+	
+	}



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message