cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dk...@apache.org
Subject svn commit: r609848 [1/7] - in /incubator/cxf/trunk/tools/corba: ./ src/main/generated/ src/main/generated/org/ src/main/generated/org/apache/ src/main/generated/org/apache/yoko/ src/main/generated/org/apache/yoko/tools/ src/main/generated/org/apache/y...
Date Tue, 08 Jan 2008 02:47:59 GMT
Author: dkulp
Date: Mon Jan  7 18:47:56 2008
New Revision: 609848

URL: http://svn.apache.org/viewvc?rev=609848&view=rev
Log:
Get the corba tooling tests all building and passing

Added:
    incubator/cxf/trunk/tools/corba/src/main/generated/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java   (with props)
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLParser.java   (with props)
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLTokenTypes.java   (with props)
    incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLTokenTypes.txt   (with props)
Modified:
    incubator/cxf/trunk/tools/corba/pom.xml
    incubator/cxf/trunk/tools/corba/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToProcessor.java
    incubator/cxf/trunk/tools/corba/src/test/java/org/apache/yoko/tools/WSDLToIDLTest.java
    incubator/cxf/trunk/tools/corba/src/test/java/org/apache/yoko/tools/processors/IDLToWSDLGenerationTest.java
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/Array.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/HelloWorld.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Anonarray.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Anonboundedsequence.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Anonsequence.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Anonstring.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Anonstring_unbounded.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Array.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Attributes.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_ConstScopename.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Declarators.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Exception.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Exception_DiffNS.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_ForwardInterfaceArray.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_ForwardInterfaceSequence.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_ForwardInterfaceTypedef.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Inheritance.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_LogicalLPT.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_LogicalLT.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_ObjectRef.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Octet.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_OptionsPT.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_OptionsSchema.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_RecursiveStruct.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_RecursiveUnion.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_String.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_Typedef.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_base64Binary_sequence_octet.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_hexBinary_sequence_octet.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_scopedString.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/expected_sequence_octet_corba_typemap_tns.wsdl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/included.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idl/inheritance.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idlpreprocessor/B.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idlpreprocessor/C-resolved.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/idlpreprocessor/C.idl
    incubator/cxf/trunk/tools/corba/src/test/resources/toolspecs/idl2wsdl.xml
    incubator/cxf/trunk/tools/corba/src/test/resources/toolspecs/wsdl2idl.xml

Modified: incubator/cxf/trunk/tools/corba/pom.xml
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/tools/corba/pom.xml?rev=609848&r1=609847&r2=609848&view=diff
==============================================================================
--- incubator/cxf/trunk/tools/corba/pom.xml (original)
+++ incubator/cxf/trunk/tools/corba/pom.xml Mon Jan  7 18:47:56 2008
@@ -62,7 +62,7 @@
         <dependency>
             <groupId>antlr</groupId>
             <artifactId>antlr</artifactId>
-            <version>2.7.5</version>
+            <version>2.7.7</version>
         </dependency>
         <dependency>
             <groupId>org.apache.ws.commons.schema</groupId>
@@ -78,28 +78,29 @@
         </dependency>
     </dependencies>
 
-
     <build>
         <plugins>
             <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-antlr-plugin</artifactId>
-                <version>2.0-beta-1</version>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <version>1.0</version>
                 <executions>
                     <execution>
+                        <id>add-source</id>
                         <phase>generate-sources</phase>
-                        <configuration>
-                            <outputDirectory>${basedir}/target/generated/src/main/java</outputDirectory>
-                            <grammars>idl.g</grammars>
-                            <sourceDirectory>${basedir}/src/main/java/org/apache/yoko/tools/processors/idl</sourceDirectory>
-                        </configuration>
                         <goals>
-                            <goal>generate</goal>
+                            <goal>add-source</goal>
                         </goals>
+                        <configuration>
+                            <sources>
+                                <source>${basedir}/src/main/generated</source>
+                            </sources>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>
         </plugins>
     </build>
+
 </project>
 

Added: incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java?rev=609848&view=auto
==============================================================================
--- incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java (added)
+++ incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java Mon Jan  7 18:47:56 2008
@@ -0,0 +1,1951 @@
+// $ANTLR 2.7.4: "idl.g" -> "IDLLexer.java"$
+// Generated
+package org.apache.yoko.tools.processors.idl;
+
+import java.io.*;
+import java.util.Vector;
+import java.util.Hashtable;
+ 
+import java.io.InputStream;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.TokenStreamRecognitionException;
+import antlr.CharStreamException;
+import antlr.CharStreamIOException;
+import antlr.ANTLRException;
+import java.io.Reader;
+import java.util.Hashtable;
+import antlr.CharScanner;
+import antlr.InputBuffer;
+import antlr.ByteBuffer;
+import antlr.CharBuffer;
+import antlr.Token;
+import antlr.CommonToken;
+import antlr.RecognitionException;
+import antlr.NoViableAltForCharException;
+import antlr.MismatchedCharException;
+import antlr.TokenStream;
+import antlr.ANTLRHashString;
+import antlr.LexerSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.SemanticException;
+
+@SuppressWarnings({"unchecked", "unused"})
+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(56));
+	literals.put(new ANTLRHashString("typeprefix", this), new Integer(78));
+	literals.put(new ANTLRHashString("case", this), new Integer(57));
+	literals.put(new ANTLRHashString("finder", this), new Integer(93));
+	literals.put(new ANTLRHashString("manages", this), new Integer(91));
+	literals.put(new ANTLRHashString("interface", this), new Integer(7));
+	literals.put(new ANTLRHashString("provides", this), new Integer(84));
+	literals.put(new ANTLRHashString("exception", this), new Integer(67));
+	literals.put(new ANTLRHashString("primarykey", this), new Integer(92));
+	literals.put(new ANTLRHashString("sequence", this), new Integer(60));
+	literals.put(new ANTLRHashString("uses", this), new Integer(85));
+	literals.put(new ANTLRHashString("consumes", this), new Integer(89));
+	literals.put(new ANTLRHashString("void", this), new Integer(69));
+	literals.put(new ANTLRHashString("factory", this), new Integer(22));
+	literals.put(new ANTLRHashString("import", this), new Integer(76));
+	literals.put(new ANTLRHashString("float", this), new Integer(43));
+	literals.put(new ANTLRHashString("publishes", this), new Integer(88));
+	literals.put(new ANTLRHashString("private", this), new Integer(21));
+	literals.put(new ANTLRHashString("boolean", this), new Integer(50));
+	literals.put(new ANTLRHashString("string", this), new Integer(63));
+	literals.put(new ANTLRHashString("getraises", this), new Integer(81));
+	literals.put(new ANTLRHashString("emits", this), new Integer(87));
+	literals.put(new ANTLRHashString("custom", this), new Integer(8));
+	literals.put(new ANTLRHashString("component", this), new Integer(83));
+	literals.put(new ANTLRHashString("context", this), new Integer(73));
+	literals.put(new ANTLRHashString("octet", this), new Integer(51));
+	literals.put(new ANTLRHashString("oneway", this), new Integer(68));
+	literals.put(new ANTLRHashString("long", this), new Integer(45));
+	literals.put(new ANTLRHashString("ValueBase", this), new Integer(75));
+	literals.put(new ANTLRHashString("in", this), new Integer(25));
+	literals.put(new ANTLRHashString("truncatable", this), new Integer(18));
+	literals.put(new ANTLRHashString("FALSE", this), new Integer(40));
+	literals.put(new ANTLRHashString("readonly", this), new Integer(79));
+	literals.put(new ANTLRHashString("typedef", this), new Integer(41));
+	literals.put(new ANTLRHashString("supports", this), new Integer(19));
+	literals.put(new ANTLRHashString("short", this), new Integer(46));
+	literals.put(new ANTLRHashString("TRUE", this), new Integer(39));
+	literals.put(new ANTLRHashString("fixed", this), new Integer(74));
+	literals.put(new ANTLRHashString("Object", this), new Integer(53));
+	literals.put(new ANTLRHashString("enum", this), new Integer(59));
+	literals.put(new ANTLRHashString("home", this), new Integer(90));
+	literals.put(new ANTLRHashString("multiple", this), new Integer(86));
+	literals.put(new ANTLRHashString("attribute", this), new Integer(80));
+	literals.put(new ANTLRHashString("char", this), new Integer(48));
+	literals.put(new ANTLRHashString("union", this), new Integer(55));
+	literals.put(new ANTLRHashString("local", this), new Integer(6));
+	literals.put(new ANTLRHashString("const", this), new Integer(26));
+	literals.put(new ANTLRHashString("setraises", this), new Integer(82));
+	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(71));
+	literals.put(new ANTLRHashString("raises", this), new Integer(72));
+	literals.put(new ANTLRHashString("out", this), new Integer(70));
+	literals.put(new ANTLRHashString("typeid", this), new Integer(77));
+	literals.put(new ANTLRHashString("wchar", this), new Integer(49));
+	literals.put(new ANTLRHashString("any", this), new Integer(52));
+	literals.put(new ANTLRHashString("double", this), new Integer(44));
+	literals.put(new ANTLRHashString("default", this), new Integer(58));
+	literals.put(new ANTLRHashString("eventtype", this), new Integer(10));
+	literals.put(new ANTLRHashString("wstring", this), new Integer(64));
+	literals.put(new ANTLRHashString("unsigned", this), new Integer(47));
+	literals.put(new ANTLRHashString("struct", this), new Integer(54));
+	literals.put(new ANTLRHashString("public", this), new Integer(20));
+	literals.put(new ANTLRHashString("module", this), new Integer(11));
+	literals.put(new ANTLRHashString("native", this), new Integer(42));
+}
+
+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);
+		{
+		_loop325:
+		do {
+			if ((_tokenSet_1.member(LA(1)))) {
+				matchNot('\n');
+			}
+			else {
+				break _loop325;
+			}
+			
+		} while (true);
+		}
+		_saveIndex=text.length();
+		match('\n');
+		text.setLength(_saveIndex);
+		_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 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);
+		{
+		_loop328:
+		do {
+			if ((_tokenSet_1.member(LA(1)))) {
+				matchNot('\n');
+			}
+			else {
+				break _loop328;
+			}
+			
+		} 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);
+		{
+		_loop336:
+		do {
+			if ((LA(1)=='*') && (_tokenSet_2.member(LA(2)))) {
+				{
+				int _cnt332=0;
+				_loop332:
+				do {
+					if ((LA(1)=='*')) {
+						match('*');
+					}
+					else {
+						if ( _cnt332>=1 ) { break _loop332; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+					}
+					
+					_cnt332++;
+				} 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 _loop336;
+			}
+			
+		} 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);
+		{
+		_loop342:
+		do {
+			if ((LA(1)=='\\')) {
+				mESC(false);
+			}
+			else if ((_tokenSet_7.member(LA(1)))) {
+				matchNot('"');
+			}
+			else {
+				break _loop342;
+			}
+			
+		} 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 _cnt361=0;
+		_loop361:
+		do {
+			if ((_tokenSet_6.member(LA(1)))) {
+				mHEXDIGIT(false);
+			}
+			else {
+				if ( _cnt361>=1 ) { break _loop361; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+			}
+			
+			_cnt361++;
+		} 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);
+		{
+		_loop364:
+		do {
+			if (((LA(1) >= '0' && LA(1) <= '9'))) {
+				mDIGIT(false);
+			}
+			else {
+				break _loop364;
+			}
+			
+		} while (true);
+		}
+		{
+		switch ( LA(1)) {
+		case '.':
+		{
+			match('.');
+			{
+			_loop367:
+			do {
+				if (((LA(1) >= '0' && LA(1) <= '9'))) {
+					mDIGIT(false);
+				}
+				else {
+					break _loop367;
+				}
+				
+			} 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 _cnt373=0;
+				_loop373:
+				do {
+					if (((LA(1) >= '0' && LA(1) <= '9'))) {
+						mDIGIT(false);
+					}
+					else {
+						if ( _cnt373>=1 ) { break _loop373; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+					}
+					
+					_cnt373++;
+				} 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 _cnt378=0;
+			_loop378:
+			do {
+				if (((LA(1) >= '0' && LA(1) <= '9'))) {
+					mDIGIT(false);
+				}
+				else {
+					if ( _cnt378>=1 ) { break _loop378; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+				}
+				
+				_cnt378++;
+			} 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 _cnt383=0;
+			_loop383:
+			do {
+				if (((LA(1) >= '0' && LA(1) <= '9'))) {
+					mDIGIT(false);
+				}
+				else {
+					if ( _cnt383>=1 ) { break _loop383; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+				}
+				
+				_cnt383++;
+			} 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 _cnt387=0;
+		_loop387:
+		do {
+			if (((LA(1) >= '0' && LA(1) <= '9'))) {
+				mDIGIT(false);
+			}
+			else {
+				if ( _cnt387>=1 ) { break _loop387; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+			}
+			
+			_cnt387++;
+		} 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 _cnt392=0;
+			_loop392:
+			do {
+				if (((LA(1) >= '0' && LA(1) <= '9'))) {
+					mDIGIT(false);
+				}
+				else {
+					if ( _cnt392>=1 ) { break _loop392; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+				}
+				
+				_cnt392++;
+			} 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());
+		}
+		}
+		}
+		{
+		_loop397:
+		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 _loop397;
+			}
+			}
+		} 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());
+		}
+		}
+		}
+		{
+		_loop401:
+		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 _loop401;
+			}
+			}
+		} 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());
+	
+	}

Propchange: incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLLexer.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date



Mime
View raw message