cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dk...@apache.org
Subject svn commit: r609848 [2/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
Added: incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLParser.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLParser.java?rev=609848&view=auto
==============================================================================
--- incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLParser.java (added)
+++ incubator/cxf/trunk/tools/corba/src/main/generated/org/apache/yoko/tools/processors/idl/IDLParser.java Mon Jan  7 18:47:56 2008
@@ -0,0 +1,7180 @@
+// $ANTLR 2.7.4: "idl.g" -> "IDLParser.java"$
+// Generated
+package org.apache.yoko.tools.processors.idl;
+
+import java.io.*;
+import java.util.Vector;
+import java.util.Hashtable;
+ 
+import antlr.TokenBuffer;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.ANTLRException;
+import antlr.LLkParser;
+import antlr.Token;
+import antlr.TokenStream;
+import antlr.RecognitionException;
+import antlr.NoViableAltException;
+import antlr.MismatchedTokenException;
+import antlr.SemanticException;
+import antlr.ParserSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.collections.AST;
+import java.util.Hashtable;
+import antlr.ASTFactory;
+import antlr.ASTPair;
+import antlr.collections.impl.ASTArray;
+
+@SuppressWarnings("all")
+public class IDLParser extends antlr.LLkParser       implements IDLTokenTypes
+ {
+
+protected IDLParser(TokenBuffer tokenBuf, int k) {
+  super(tokenBuf,k);
+  tokenNames = _tokenNames;
+  buildTokenTypeASTClassMap();
+  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public IDLParser(TokenBuffer tokenBuf) {
+  this(tokenBuf,4);
+}
+
+protected IDLParser(TokenStream lexer, int k) {
+  super(lexer,k);
+  tokenNames = _tokenNames;
+  buildTokenTypeASTClassMap();
+  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public IDLParser(TokenStream lexer) {
+  this(lexer,4);
+}
+
+public IDLParser(ParserSharedInputState state) {
+  super(state,4);
+  tokenNames = _tokenNames;
+  buildTokenTypeASTClassMap();
+  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+	public final void specification() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST specification_AST = null;
+		
+		try {      // for error handling
+			{
+			_loop3:
+			do {
+				if ((LA(1)==LITERAL_import)) {
+					import_dcl();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop3;
+				}
+				
+			} while (true);
+			}
+			{
+			int _cnt5=0;
+			_loop5:
+			do {
+				if ((_tokenSet_0.member(LA(1)))) {
+					definition();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					if ( _cnt5>=1 ) { break _loop5; } else {throw new NoViableAltException(LT(1), getFilename());}
+				}
+				
+				_cnt5++;
+			} while (true);
+			}
+			specification_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_1);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = specification_AST;
+	}
+	
+	public final void import_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST import_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp1_AST = null;
+			tmp1_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp1_AST);
+			match(LITERAL_import);
+			imported_scope();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(SEMI);
+			import_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_2);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = import_dcl_AST;
+	}
+	
+	public final void definition() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST definition_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_typedef:
+			case LITERAL_native:
+			case LITERAL_struct:
+			case LITERAL_union:
+			case LITERAL_enum:
+			{
+				type_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_const:
+			{
+				const_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_exception:
+			{
+				except_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_module:
+			{
+				module();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_typeid:
+			{
+				type_id_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_typeprefix:
+			{
+				type_prefix_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_component:
+			{
+				component();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_home:
+			{
+				home_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			default:
+				boolean synPredMatched10 = false;
+				if ((((LA(1) >= LITERAL_abstract && LA(1) <= LITERAL_interface)) && (LA(2)==LITERAL_interface||LA(2)==IDENT) && (_tokenSet_3.member(LA(3))) && (_tokenSet_4.member(LA(4))))) {
+					int _m10 = mark();
+					synPredMatched10 = true;
+					inputState.guessing++;
+					try {
+						{
+						{
+						switch ( LA(1)) {
+						case LITERAL_abstract:
+						{
+							match(LITERAL_abstract);
+							break;
+						}
+						case LITERAL_local:
+						{
+							match(LITERAL_local);
+							break;
+						}
+						case LITERAL_interface:
+						{
+							break;
+						}
+						default:
+						{
+							throw new NoViableAltException(LT(1), getFilename());
+						}
+						}
+						}
+						match(LITERAL_interface);
+						}
+					}
+					catch (RecognitionException pe) {
+						synPredMatched10 = false;
+					}
+					rewind(_m10);
+					inputState.guessing--;
+				}
+				if ( synPredMatched10 ) {
+					interf();
+					astFactory.addASTChild(currentAST, returnAST);
+					match(SEMI);
+				}
+				else {
+					boolean synPredMatched13 = false;
+					if (((LA(1)==LITERAL_abstract||LA(1)==LITERAL_custom||LA(1)==LITERAL_valuetype) && (LA(2)==LITERAL_valuetype||LA(2)==IDENT) && (_tokenSet_5.member(LA(3))) && (_tokenSet_6.member(LA(4))))) {
+						int _m13 = mark();
+						synPredMatched13 = true;
+						inputState.guessing++;
+						try {
+							{
+							{
+							switch ( LA(1)) {
+							case LITERAL_abstract:
+							{
+								match(LITERAL_abstract);
+								break;
+							}
+							case LITERAL_custom:
+							{
+								match(LITERAL_custom);
+								break;
+							}
+							case LITERAL_valuetype:
+							{
+								break;
+							}
+							default:
+							{
+								throw new NoViableAltException(LT(1), getFilename());
+							}
+							}
+							}
+							match(LITERAL_valuetype);
+							}
+						}
+						catch (RecognitionException pe) {
+							synPredMatched13 = false;
+						}
+						rewind(_m13);
+						inputState.guessing--;
+					}
+					if ( synPredMatched13 ) {
+						value();
+						astFactory.addASTChild(currentAST, returnAST);
+						match(SEMI);
+					}
+					else {
+						boolean synPredMatched16 = false;
+						if (((LA(1)==LITERAL_abstract||LA(1)==LITERAL_custom||LA(1)==LITERAL_eventtype) && (LA(2)==LITERAL_eventtype||LA(2)==IDENT) && (_tokenSet_7.member(LA(3))) && (_tokenSet_8.member(LA(4))))) {
+							int _m16 = mark();
+							synPredMatched16 = true;
+							inputState.guessing++;
+							try {
+								{
+								{
+								switch ( LA(1)) {
+								case LITERAL_abstract:
+								{
+									match(LITERAL_abstract);
+									break;
+								}
+								case LITERAL_custom:
+								{
+									match(LITERAL_custom);
+									break;
+								}
+								case LITERAL_eventtype:
+								{
+									break;
+								}
+								default:
+								{
+									throw new NoViableAltException(LT(1), getFilename());
+								}
+								}
+								}
+								match(LITERAL_eventtype);
+								}
+							}
+							catch (RecognitionException pe) {
+								synPredMatched16 = false;
+							}
+							rewind(_m16);
+							inputState.guessing--;
+						}
+						if ( synPredMatched16 ) {
+							event();
+							astFactory.addASTChild(currentAST, returnAST);
+							match(SEMI);
+						}
+					else {
+						throw new NoViableAltException(LT(1), getFilename());
+					}
+					}}}
+					}
+					definition_AST = (AST)currentAST.root;
+				}
+				catch (RecognitionException ex) {
+					if (inputState.guessing==0) {
+						reportError(ex);
+						consume();
+						consumeUntil(_tokenSet_9);
+					} else {
+					  throw ex;
+					}
+				}
+				returnAST = definition_AST;
+			}
+			
+	public final void type_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST type_dcl_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_typedef:
+			{
+				AST tmp14_AST = null;
+				tmp14_AST = astFactory.create(LT(1));
+				astFactory.makeASTRoot(currentAST, tmp14_AST);
+				match(LITERAL_typedef);
+				type_declarator();
+				astFactory.addASTChild(currentAST, returnAST);
+				type_dcl_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_enum:
+			{
+				enum_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				type_dcl_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_native:
+			{
+				AST tmp15_AST = null;
+				tmp15_AST = astFactory.create(LT(1));
+				astFactory.makeASTRoot(currentAST, tmp15_AST);
+				match(LITERAL_native);
+				simple_declarator();
+				astFactory.addASTChild(currentAST, returnAST);
+				type_dcl_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+				boolean synPredMatched114 = false;
+				if (((LA(1)==LITERAL_struct) && (LA(2)==IDENT) && (LA(3)==LCURLY))) {
+					int _m114 = mark();
+					synPredMatched114 = true;
+					inputState.guessing++;
+					try {
+						{
+						struct_type();
+						}
+					}
+					catch (RecognitionException pe) {
+						synPredMatched114 = false;
+					}
+					rewind(_m114);
+					inputState.guessing--;
+				}
+				if ( synPredMatched114 ) {
+					struct_type();
+					astFactory.addASTChild(currentAST, returnAST);
+					type_dcl_AST = (AST)currentAST.root;
+				}
+				else {
+					boolean synPredMatched116 = false;
+					if (((LA(1)==LITERAL_union) && (LA(2)==IDENT) && (LA(3)==LITERAL_switch))) {
+						int _m116 = mark();
+						synPredMatched116 = true;
+						inputState.guessing++;
+						try {
+							{
+							union_type();
+							}
+						}
+						catch (RecognitionException pe) {
+							synPredMatched116 = false;
+						}
+						rewind(_m116);
+						inputState.guessing--;
+					}
+					if ( synPredMatched116 ) {
+						union_type();
+						astFactory.addASTChild(currentAST, returnAST);
+						type_dcl_AST = (AST)currentAST.root;
+					}
+					else if ((LA(1)==LITERAL_struct||LA(1)==LITERAL_union) && (LA(2)==IDENT) && (LA(3)==SEMI)) {
+						constr_forward_decl();
+						astFactory.addASTChild(currentAST, returnAST);
+						type_dcl_AST = (AST)currentAST.root;
+					}
+				else {
+					throw new NoViableAltException(LT(1), getFilename());
+				}
+				}}
+			}
+			catch (RecognitionException ex) {
+				if (inputState.guessing==0) {
+					reportError(ex);
+					consume();
+					consumeUntil(_tokenSet_10);
+				} else {
+				  throw ex;
+				}
+			}
+			returnAST = type_dcl_AST;
+		}
+		
+	public final void const_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST const_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp16_AST = null;
+			tmp16_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp16_AST);
+			match(LITERAL_const);
+			const_type();
+			astFactory.addASTChild(currentAST, returnAST);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(ASSIGN);
+			const_exp();
+			astFactory.addASTChild(currentAST, returnAST);
+			const_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = const_dcl_AST;
+	}
+	
+	public final void except_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST except_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp18_AST = null;
+			tmp18_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp18_AST);
+			match(LITERAL_exception);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			opt_member_list();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RCURLY);
+			except_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = except_dcl_AST;
+	}
+	
+	public final void interf() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST interf_AST = null;
+		
+		try {      // for error handling
+			{
+			if (((LA(1) >= LITERAL_abstract && LA(1) <= LITERAL_interface)) && (LA(2)==LITERAL_interface||LA(2)==IDENT) && (LA(3)==LCURLY||LA(3)==COLON||LA(3)==IDENT) && (_tokenSet_11.member(LA(4)))) {
+				interface_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+			}
+			else if (((LA(1) >= LITERAL_abstract && LA(1) <= LITERAL_interface)) && (LA(2)==LITERAL_interface||LA(2)==IDENT) && (LA(3)==SEMI||LA(3)==IDENT) && (_tokenSet_12.member(LA(4)))) {
+				forward_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+			}
+			else {
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			
+			}
+			interf_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = interf_AST;
+	}
+	
+	public final void module() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST module_AST = null;
+		AST d_AST = null;
+		
+		try {      // for error handling
+			AST tmp21_AST = null;
+			tmp21_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp21_AST);
+			match(LITERAL_module);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			definition_list();
+			d_AST = (AST)returnAST;
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RCURLY);
+			module_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = module_AST;
+	}
+	
+	public final void value() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_abstract:
+			{
+				value_abs_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LITERAL_custom:
+			{
+				value_custom_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			default:
+				if ((LA(1)==LITERAL_valuetype) && (LA(2)==IDENT) && (LA(3)==LCURLY||LA(3)==COLON||LA(3)==LITERAL_supports)) {
+					value_dcl();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else if ((LA(1)==LITERAL_valuetype) && (LA(2)==IDENT) && (_tokenSet_13.member(LA(3)))) {
+					value_box_dcl();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else if ((LA(1)==LITERAL_valuetype) && (LA(2)==IDENT) && (LA(3)==SEMI)) {
+					value_forward_dcl();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+			else {
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			value_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_AST;
+	}
+	
+	public final void type_id_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST type_id_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp24_AST = null;
+			tmp24_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp24_AST);
+			match(LITERAL_typeid);
+			scoped_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			string_literal();
+			astFactory.addASTChild(currentAST, returnAST);
+			type_id_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = type_id_dcl_AST;
+	}
+	
+	public final void type_prefix_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST type_prefix_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp25_AST = null;
+			tmp25_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp25_AST);
+			match(LITERAL_typeprefix);
+			scoped_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			string_literal();
+			astFactory.addASTChild(currentAST, returnAST);
+			type_prefix_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = type_prefix_dcl_AST;
+	}
+	
+	public final void event() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST event_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_abstract:
+			{
+				event_abs();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LITERAL_custom:
+			{
+				event_custom();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LITERAL_eventtype:
+			{
+				event_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			event_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = event_AST;
+	}
+	
+	public final void component() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST component_AST = null;
+		
+		try {      // for error handling
+			AST tmp26_AST = null;
+			tmp26_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp26_AST);
+			match(LITERAL_component);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			switch ( LA(1)) {
+			case LCURLY:
+			case COLON:
+			case LITERAL_supports:
+			{
+				component_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			component_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = component_AST;
+	}
+	
+	public final void home_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST home_dcl_AST = null;
+		
+		try {      // for error handling
+			home_header();
+			astFactory.addASTChild(currentAST, returnAST);
+			home_body();
+			astFactory.addASTChild(currentAST, returnAST);
+			home_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = home_dcl_AST;
+	}
+	
+	public final void identifier() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST identifier_AST = null;
+		
+		try {      // for error handling
+			AST tmp27_AST = null;
+			tmp27_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp27_AST);
+			match(IDENT);
+			identifier_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_14);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = identifier_AST;
+	}
+	
+	public final void definition_list() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST definition_list_AST = null;
+		
+		try {      // for error handling
+			{
+			int _cnt20=0;
+			_loop20:
+			do {
+				if ((_tokenSet_0.member(LA(1)))) {
+					definition();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
+				}
+				
+				_cnt20++;
+			} while (true);
+			}
+			definition_list_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_15);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = definition_list_AST;
+	}
+	
+	public final void interface_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST interface_dcl_AST = null;
+		
+		try {      // for error handling
+			{
+			{
+			switch ( LA(1)) {
+			case LITERAL_abstract:
+			{
+				AST tmp28_AST = null;
+				tmp28_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp28_AST);
+				match(LITERAL_abstract);
+				break;
+			}
+			case LITERAL_local:
+			{
+				AST tmp29_AST = null;
+				tmp29_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp29_AST);
+				match(LITERAL_local);
+				break;
+			}
+			case LITERAL_interface:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			AST tmp30_AST = null;
+			tmp30_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp30_AST);
+			match(LITERAL_interface);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			switch ( LA(1)) {
+			case COLON:
+			{
+				interface_inheritance_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LCURLY:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			AST tmp31_AST = null;
+			tmp31_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp31_AST);
+			match(LCURLY);
+			interface_body();
+			astFactory.addASTChild(currentAST, returnAST);
+			AST tmp32_AST = null;
+			tmp32_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp32_AST);
+			match(RCURLY);
+			}
+			interface_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = interface_dcl_AST;
+	}
+	
+	public final void forward_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST forward_dcl_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_abstract:
+			{
+				AST tmp33_AST = null;
+				tmp33_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp33_AST);
+				match(LITERAL_abstract);
+				break;
+			}
+			case LITERAL_local:
+			{
+				AST tmp34_AST = null;
+				tmp34_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp34_AST);
+				match(LITERAL_local);
+				break;
+			}
+			case LITERAL_interface:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			AST tmp35_AST = null;
+			tmp35_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp35_AST);
+			match(LITERAL_interface);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			forward_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = forward_dcl_AST;
+	}
+	
+	public final void interface_inheritance_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST interface_inheritance_spec_AST = null;
+		
+		try {      // for error handling
+			AST tmp36_AST = null;
+			tmp36_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp36_AST);
+			match(COLON);
+			scoped_name_list();
+			astFactory.addASTChild(currentAST, returnAST);
+			interface_inheritance_spec_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_16);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = interface_inheritance_spec_AST;
+	}
+	
+	public final void interface_body() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST interface_body_AST = null;
+		
+		try {      // for error handling
+			{
+			_loop31:
+			do {
+				if ((_tokenSet_17.member(LA(1)))) {
+					export();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop31;
+				}
+				
+			} while (true);
+			}
+			interface_body_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_15);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = interface_body_AST;
+	}
+	
+	public final void export() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST export_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_typedef:
+			case LITERAL_native:
+			case LITERAL_struct:
+			case LITERAL_union:
+			case LITERAL_enum:
+			{
+				type_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_const:
+			{
+				const_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_exception:
+			{
+				except_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_readonly:
+			case LITERAL_attribute:
+			{
+				attr_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			case LITERAL_float:
+			case LITERAL_double:
+			case LITERAL_long:
+			case LITERAL_short:
+			case LITERAL_unsigned:
+			case LITERAL_char:
+			case LITERAL_wchar:
+			case LITERAL_boolean:
+			case LITERAL_octet:
+			case LITERAL_any:
+			case LITERAL_Object:
+			case LITERAL_string:
+			case LITERAL_wstring:
+			case LITERAL_oneway:
+			case LITERAL_void:
+			case LITERAL_ValueBase:
+			{
+				op_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_typeid:
+			{
+				type_id_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			case LITERAL_typeprefix:
+			{
+				type_prefix_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(SEMI);
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			export_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_18);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = export_AST;
+	}
+	
+	public final void attr_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST attr_dcl_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_readonly:
+			{
+				readonly_attr_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				attr_dcl_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_attribute:
+			{
+				attr_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				attr_dcl_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = attr_dcl_AST;
+	}
+	
+	public final void op_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST op_dcl_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_oneway:
+			{
+				op_attribute();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			case LITERAL_float:
+			case LITERAL_double:
+			case LITERAL_long:
+			case LITERAL_short:
+			case LITERAL_unsigned:
+			case LITERAL_char:
+			case LITERAL_wchar:
+			case LITERAL_boolean:
+			case LITERAL_octet:
+			case LITERAL_any:
+			case LITERAL_Object:
+			case LITERAL_string:
+			case LITERAL_wstring:
+			case LITERAL_void:
+			case LITERAL_ValueBase:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			op_type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			AST tmp44_AST = null;
+			tmp44_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp44_AST);
+			match(IDENT);
+			parameter_dcls();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			switch ( LA(1)) {
+			case LITERAL_raises:
+			{
+				raises_expr();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SEMI:
+			case LITERAL_context:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			{
+			switch ( LA(1)) {
+			case LITERAL_context:
+			{
+				context_expr();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			op_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = op_dcl_AST;
+	}
+	
+	public final void scoped_name_list() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST scoped_name_list_AST = null;
+		
+		try {      // for error handling
+			scoped_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop38:
+			do {
+				if ((LA(1)==COMMA)) {
+					match(COMMA);
+					scoped_name();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop38;
+				}
+				
+			} while (true);
+			}
+			scoped_name_list_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_19);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = scoped_name_list_AST;
+	}
+	
+	public final void interface_name() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST interface_name_AST = null;
+		
+		try {      // for error handling
+			scoped_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			interface_name_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_20);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = interface_name_AST;
+	}
+	
+	public final void scoped_name() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST scoped_name_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case SCOPEOP:
+			{
+				AST tmp46_AST = null;
+				tmp46_AST = astFactory.create(LT(1));
+				astFactory.makeASTRoot(currentAST, tmp46_AST);
+				match(SCOPEOP);
+				break;
+			}
+			case IDENT:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			AST tmp47_AST = null;
+			tmp47_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp47_AST);
+			match(IDENT);
+			{
+			_loop42:
+			do {
+				if ((LA(1)==SCOPEOP)) {
+					match(SCOPEOP);
+					identifier();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop42;
+				}
+				
+			} while (true);
+			}
+			scoped_name_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_21);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = scoped_name_AST;
+	}
+	
+	public final void value_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_dcl_AST = null;
+		
+		try {      // for error handling
+			value_header();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			{
+			_loop54:
+			do {
+				if ((_tokenSet_22.member(LA(1)))) {
+					value_element();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop54;
+				}
+				
+			} while (true);
+			}
+			match(RCURLY);
+			value_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_dcl_AST;
+	}
+	
+	public final void value_abs_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_abs_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp51_AST = null;
+			tmp51_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp51_AST);
+			match(LITERAL_abstract);
+			AST tmp52_AST = null;
+			tmp52_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp52_AST);
+			match(LITERAL_valuetype);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			switch ( LA(1)) {
+			case LCURLY:
+			case COLON:
+			case LITERAL_supports:
+			{
+				value_abs_full_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			value_abs_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_abs_dcl_AST;
+	}
+	
+	public final void value_box_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_box_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp53_AST = null;
+			tmp53_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp53_AST);
+			match(LITERAL_valuetype);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_box_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_box_dcl_AST;
+	}
+	
+	public final void value_custom_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_custom_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp54_AST = null;
+			tmp54_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp54_AST);
+			match(LITERAL_custom);
+			value_dcl();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_custom_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_custom_dcl_AST;
+	}
+	
+	public final void value_forward_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_forward_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp55_AST = null;
+			tmp55_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp55_AST);
+			match(LITERAL_valuetype);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_forward_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_forward_dcl_AST;
+	}
+	
+	public final void type_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST type_spec_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case SCOPEOP:
+			case IDENT:
+			case LITERAL_float:
+			case LITERAL_double:
+			case LITERAL_long:
+			case LITERAL_short:
+			case LITERAL_unsigned:
+			case LITERAL_char:
+			case LITERAL_wchar:
+			case LITERAL_boolean:
+			case LITERAL_octet:
+			case LITERAL_any:
+			case LITERAL_Object:
+			case LITERAL_sequence:
+			case LITERAL_string:
+			case LITERAL_wstring:
+			case LITERAL_fixed:
+			case LITERAL_ValueBase:
+			{
+				simple_type_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_struct:
+			case LITERAL_union:
+			case LITERAL_enum:
+			{
+				constr_type_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_23);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = type_spec_AST;
+	}
+	
+	public final void value_abs_full_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_abs_full_dcl_AST = null;
+		
+		try {      // for error handling
+			value_inheritance_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			{
+			_loop51:
+			do {
+				if ((_tokenSet_17.member(LA(1)))) {
+					export();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop51;
+				}
+				
+			} while (true);
+			}
+			match(RCURLY);
+			value_abs_full_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_abs_full_dcl_AST;
+	}
+	
+	public final void value_inheritance_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_inheritance_spec_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case COLON:
+			{
+				value_value_inheritance_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LCURLY:
+			case LITERAL_supports:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			{
+			switch ( LA(1)) {
+			case LITERAL_supports:
+			{
+				value_interface_inheritance_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LCURLY:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			value_inheritance_spec_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_16);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_inheritance_spec_AST;
+	}
+	
+	public final void value_header() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_header_AST = null;
+		
+		try {      // for error handling
+			AST tmp58_AST = null;
+			tmp58_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp58_AST);
+			match(LITERAL_valuetype);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_inheritance_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_header_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_16);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_header_AST;
+	}
+	
+	public final void value_element() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_element_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case SCOPEOP:
+			case IDENT:
+			case LITERAL_const:
+			case LITERAL_typedef:
+			case LITERAL_native:
+			case LITERAL_float:
+			case LITERAL_double:
+			case LITERAL_long:
+			case LITERAL_short:
+			case LITERAL_unsigned:
+			case LITERAL_char:
+			case LITERAL_wchar:
+			case LITERAL_boolean:
+			case LITERAL_octet:
+			case LITERAL_any:
+			case LITERAL_Object:
+			case LITERAL_struct:
+			case LITERAL_union:
+			case LITERAL_enum:
+			case LITERAL_string:
+			case LITERAL_wstring:
+			case LITERAL_exception:
+			case LITERAL_oneway:
+			case LITERAL_void:
+			case LITERAL_ValueBase:
+			case LITERAL_typeid:
+			case LITERAL_typeprefix:
+			case LITERAL_readonly:
+			case LITERAL_attribute:
+			{
+				export();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LITERAL_public:
+			case LITERAL_private:
+			{
+				state_member();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case LITERAL_factory:
+			{
+				init_dcl();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			value_element_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_24);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_element_AST;
+	}
+	
+	public final void value_value_inheritance_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_value_inheritance_spec_AST = null;
+		
+		try {      // for error handling
+			AST tmp59_AST = null;
+			tmp59_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp59_AST);
+			match(COLON);
+			{
+			switch ( LA(1)) {
+			case LITERAL_truncatable:
+			{
+				AST tmp60_AST = null;
+				tmp60_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp60_AST);
+				match(LITERAL_truncatable);
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			value_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop63:
+			do {
+				if ((LA(1)==COMMA)) {
+					match(COMMA);
+					value_name();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop63;
+				}
+				
+			} while (true);
+			}
+			value_value_inheritance_spec_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_25);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_value_inheritance_spec_AST;
+	}
+	
+	public final void value_interface_inheritance_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_interface_inheritance_spec_AST = null;
+		
+		try {      // for error handling
+			AST tmp62_AST = null;
+			tmp62_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp62_AST);
+			match(LITERAL_supports);
+			interface_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop66:
+			do {
+				if ((LA(1)==COMMA)) {
+					match(COMMA);
+					interface_name();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop66;
+				}
+				
+			} while (true);
+			}
+			value_interface_inheritance_spec_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_16);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_interface_inheritance_spec_AST;
+	}
+	
+	public final void value_name() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST value_name_AST = null;
+		
+		try {      // for error handling
+			scoped_name();
+			astFactory.addASTChild(currentAST, returnAST);
+			value_name_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_26);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = value_name_AST;
+	}
+	
+	public final void state_member() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST state_member_AST = null;
+		
+		try {      // for error handling
+			{
+			switch ( LA(1)) {
+			case LITERAL_public:
+			{
+				AST tmp64_AST = null;
+				tmp64_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp64_AST);
+				match(LITERAL_public);
+				break;
+			}
+			case LITERAL_private:
+			{
+				AST tmp65_AST = null;
+				tmp65_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp65_AST);
+				match(LITERAL_private);
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			declarators();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(SEMI);
+			state_member_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_24);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = state_member_AST;
+	}
+	
+	public final void init_dcl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST init_dcl_AST = null;
+		
+		try {      // for error handling
+			AST tmp67_AST = null;
+			tmp67_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp67_AST);
+			match(LITERAL_factory);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LPAREN);
+			{
+			switch ( LA(1)) {
+			case LITERAL_in:
+			{
+				init_param_decls();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case RPAREN:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(RPAREN);
+			{
+			switch ( LA(1)) {
+			case LITERAL_raises:
+			{
+				raises_expr();
+				astFactory.addASTChild(currentAST, returnAST);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			init_dcl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_24);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = init_dcl_AST;
+	}
+	
+	public final void declarators() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST declarators_AST = null;
+		
+		try {      // for error handling
+			declarator();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop127:
+			do {
+				if ((LA(1)==COMMA)) {
+					match(COMMA);
+					declarator();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop127;
+				}
+				
+			} while (true);
+			}
+			declarators_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = declarators_AST;
+	}
+	
+	public final void init_param_decls() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST init_param_decls_AST = null;
+		
+		try {      // for error handling
+			init_param_decl();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop77:
+			do {
+				if ((LA(1)==COMMA)) {
+					match(COMMA);
+					init_param_decl();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop77;
+				}
+				
+			} while (true);
+			}
+			init_param_decls_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_27);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = init_param_decls_AST;
+	}
+	
+	public final void raises_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST raises_expr_AST = null;
+		
+		try {      // for error handling
+			AST tmp73_AST = null;
+			tmp73_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp73_AST);
+			match(LITERAL_raises);
+			match(LPAREN);
+			scoped_name_list();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RPAREN);
+			raises_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_28);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = raises_expr_AST;
+	}
+	
+	public final void init_param_decl() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST init_param_decl_AST = null;
+		
+		try {      // for error handling
+			init_param_attribute();
+			astFactory.addASTChild(currentAST, returnAST);
+			param_type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			simple_declarator();
+			astFactory.addASTChild(currentAST, returnAST);
+			init_param_decl_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_29);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = init_param_decl_AST;
+	}
+	
+	public final void init_param_attribute() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST init_param_attribute_AST = null;
+		
+		try {      // for error handling
+			AST tmp76_AST = null;
+			tmp76_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp76_AST);
+			match(LITERAL_in);
+			init_param_attribute_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_30);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = init_param_attribute_AST;
+	}
+	
+	public final void param_type_spec() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST param_type_spec_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_float:
+			case LITERAL_double:
+			case LITERAL_long:
+			case LITERAL_short:
+			case LITERAL_unsigned:
+			case LITERAL_char:
+			case LITERAL_wchar:
+			case LITERAL_boolean:
+			case LITERAL_octet:
+			case LITERAL_any:
+			case LITERAL_Object:
+			case LITERAL_ValueBase:
+			{
+				base_type_spec();
+				astFactory.addASTChild(currentAST, returnAST);
+				param_type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_string:
+			{
+				string_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				param_type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_wstring:
+			{
+				wide_string_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				param_type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			{
+				scoped_name();
+				astFactory.addASTChild(currentAST, returnAST);
+				param_type_spec_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_31);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = param_type_spec_AST;
+	}
+	
+	public final void simple_declarator() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST simple_declarator_AST = null;
+		
+		try {      // for error handling
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			simple_declarator_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_32);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = simple_declarator_AST;
+	}
+	
+	public final void const_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST const_type_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_char:
+			{
+				char_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_wchar:
+			{
+				wide_char_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_boolean:
+			{
+				boolean_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_string:
+			{
+				string_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_wstring:
+			{
+				wide_string_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_fixed:
+			{
+				fixed_pt_const_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			{
+				scoped_name();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_octet:
+			{
+				octet_type();
+				astFactory.addASTChild(currentAST, returnAST);
+				const_type_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+				boolean synPredMatched83 = false;
+				if ((((LA(1) >= LITERAL_long && LA(1) <= LITERAL_unsigned)) && (LA(2)==IDENT||LA(2)==LITERAL_long||LA(2)==LITERAL_short) && (LA(3)==IDENT||LA(3)==ASSIGN||LA(3)==LITERAL_long) && (_tokenSet_33.member(LA(4))))) {
+					int _m83 = mark();
+					synPredMatched83 = true;
+					inputState.guessing++;
+					try {
+						{
+						integer_type();
+						}
+					}
+					catch (RecognitionException pe) {
+						synPredMatched83 = false;
+					}
+					rewind(_m83);
+					inputState.guessing--;
+				}
+				if ( synPredMatched83 ) {
+					integer_type();
+					astFactory.addASTChild(currentAST, returnAST);
+					const_type_AST = (AST)currentAST.root;
+				}
+				else if (((LA(1) >= LITERAL_float && LA(1) <= LITERAL_long)) && (LA(2)==IDENT||LA(2)==LITERAL_double) && (LA(3)==IDENT||LA(3)==ASSIGN) && (_tokenSet_33.member(LA(4)))) {
+					floating_pt_type();
+					astFactory.addASTChild(currentAST, returnAST);
+					const_type_AST = (AST)currentAST.root;
+				}
+			else {
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_31);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = const_type_AST;
+	}
+	
+	public final void const_exp() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST const_exp_AST = null;
+		
+		try {      // for error handling
+			or_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			const_exp_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_34);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = const_exp_AST;
+	}
+	
+	public final void integer_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST integer_type_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_long:
+			case LITERAL_short:
+			{
+				signed_int();
+				astFactory.addASTChild(currentAST, returnAST);
+				integer_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_unsigned:
+			{
+				unsigned_int();
+				astFactory.addASTChild(currentAST, returnAST);
+				integer_type_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_35);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = integer_type_AST;
+	}
+	
+	public final void char_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST char_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp77_AST = null;
+			tmp77_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp77_AST);
+			match(LITERAL_char);
+			char_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_35);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = char_type_AST;
+	}
+	
+	public final void wide_char_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST wide_char_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp78_AST = null;
+			tmp78_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp78_AST);
+			match(LITERAL_wchar);
+			wide_char_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_36);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = wide_char_type_AST;
+	}
+	
+	public final void boolean_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST boolean_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp79_AST = null;
+			tmp79_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp79_AST);
+			match(LITERAL_boolean);
+			boolean_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_35);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = boolean_type_AST;
+	}
+	
+	public final void floating_pt_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST floating_pt_type_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_float:
+			{
+				AST tmp80_AST = null;
+				tmp80_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp80_AST);
+				match(LITERAL_float);
+				floating_pt_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_double:
+			{
+				AST tmp81_AST = null;
+				tmp81_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp81_AST);
+				match(LITERAL_double);
+				floating_pt_type_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_long:
+			{
+				AST tmp82_AST = null;
+				tmp82_AST = astFactory.create(LT(1));
+				astFactory.makeASTRoot(currentAST, tmp82_AST);
+				match(LITERAL_long);
+				AST tmp83_AST = null;
+				tmp83_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp83_AST);
+				match(LITERAL_double);
+				floating_pt_type_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_36);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = floating_pt_type_AST;
+	}
+	
+	public final void string_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST string_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp84_AST = null;
+			tmp84_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp84_AST);
+			match(LITERAL_string);
+			{
+			switch ( LA(1)) {
+			case LT:
+			{
+				match(LT);
+				positive_int_const();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(GT);
+				break;
+			}
+			case SEMI:
+			case COMMA:
+			case IDENT:
+			case GT:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			string_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_36);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = string_type_AST;
+	}
+	
+	public final void wide_string_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST wide_string_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp87_AST = null;
+			tmp87_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp87_AST);
+			match(LITERAL_wstring);
+			{
+			switch ( LA(1)) {
+			case LT:
+			{
+				match(LT);
+				positive_int_const();
+				astFactory.addASTChild(currentAST, returnAST);
+				match(GT);
+				break;
+			}
+			case SEMI:
+			case COMMA:
+			case IDENT:
+			case GT:
+			{
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			wide_string_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_36);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = wide_string_type_AST;
+	}
+	
+	public final void fixed_pt_const_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST fixed_pt_const_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp90_AST = null;
+			tmp90_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp90_AST);
+			match(LITERAL_fixed);
+			fixed_pt_const_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_31);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = fixed_pt_const_type_AST;
+	}
+	
+	public final void octet_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST octet_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp91_AST = null;
+			tmp91_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp91_AST);
+			match(LITERAL_octet);
+			octet_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_36);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = octet_type_AST;
+	}
+	
+	public final void or_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST or_expr_AST = null;
+		
+		try {      // for error handling
+			xor_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop87:
+			do {
+				if ((LA(1)==OR)) {
+					AST tmp92_AST = null;
+					tmp92_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp92_AST);
+					match(OR);
+					xor_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop87;
+				}
+				
+			} while (true);
+			}
+			or_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_34);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = or_expr_AST;
+	}
+	
+	public final void xor_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST xor_expr_AST = null;
+		
+		try {      // for error handling
+			and_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop90:
+			do {
+				if ((LA(1)==XOR)) {
+					AST tmp93_AST = null;
+					tmp93_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp93_AST);
+					match(XOR);
+					and_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop90;
+				}
+				
+			} while (true);
+			}
+			xor_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_37);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = xor_expr_AST;
+	}
+	
+	public final void and_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST and_expr_AST = null;
+		
+		try {      // for error handling
+			shift_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop93:
+			do {
+				if ((LA(1)==AND)) {
+					AST tmp94_AST = null;
+					tmp94_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp94_AST);
+					match(AND);
+					shift_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop93;
+				}
+				
+			} while (true);
+			}
+			and_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_38);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = and_expr_AST;
+	}
+	
+	public final void shift_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST shift_expr_AST = null;
+		
+		try {      // for error handling
+			add_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop97:
+			do {
+				if ((LA(1)==LSHIFT||LA(1)==RSHIFT)) {
+					{
+					switch ( LA(1)) {
+					case LSHIFT:
+					{
+						AST tmp95_AST = null;
+						tmp95_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp95_AST);
+						match(LSHIFT);
+						break;
+					}
+					case RSHIFT:
+					{
+						AST tmp96_AST = null;
+						tmp96_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp96_AST);
+						match(RSHIFT);
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltException(LT(1), getFilename());
+					}
+					}
+					}
+					add_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop97;
+				}
+				
+			} while (true);
+			}
+			shift_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_39);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = shift_expr_AST;
+	}
+	
+	public final void add_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST add_expr_AST = null;
+		
+		try {      // for error handling
+			mult_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop101:
+			do {
+				if ((LA(1)==PLUS||LA(1)==MINUS)) {
+					{
+					switch ( LA(1)) {
+					case PLUS:
+					{
+						AST tmp97_AST = null;
+						tmp97_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp97_AST);
+						match(PLUS);
+						break;
+					}
+					case MINUS:
+					{
+						AST tmp98_AST = null;
+						tmp98_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp98_AST);
+						match(MINUS);
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltException(LT(1), getFilename());
+					}
+					}
+					}
+					mult_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop101;
+				}
+				
+			} while (true);
+			}
+			add_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_40);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = add_expr_AST;
+	}
+	
+	public final void mult_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST mult_expr_AST = null;
+		
+		try {      // for error handling
+			unary_expr();
+			astFactory.addASTChild(currentAST, returnAST);
+			{
+			_loop105:
+			do {
+				if (((LA(1) >= STAR && LA(1) <= MOD))) {
+					{
+					switch ( LA(1)) {
+					case STAR:
+					{
+						AST tmp99_AST = null;
+						tmp99_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp99_AST);
+						match(STAR);
+						break;
+					}
+					case DIV:
+					{
+						AST tmp100_AST = null;
+						tmp100_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp100_AST);
+						match(DIV);
+						break;
+					}
+					case MOD:
+					{
+						AST tmp101_AST = null;
+						tmp101_AST = astFactory.create(LT(1));
+						astFactory.makeASTRoot(currentAST, tmp101_AST);
+						match(MOD);
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltException(LT(1), getFilename());
+					}
+					}
+					}
+					unary_expr();
+					astFactory.addASTChild(currentAST, returnAST);
+				}
+				else {
+					break _loop105;
+				}
+				
+			} while (true);
+			}
+			mult_expr_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_41);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = mult_expr_AST;
+	}
+	
+	public final void unary_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST unary_expr_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case PLUS:
+			case MINUS:
+			case TILDE:
+			{
+				{
+				switch ( LA(1)) {
+				case MINUS:
+				{
+					AST tmp102_AST = null;
+					tmp102_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp102_AST);
+					match(MINUS);
+					break;
+				}
+				case PLUS:
+				{
+					AST tmp103_AST = null;
+					tmp103_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp103_AST);
+					match(PLUS);
+					break;
+				}
+				case TILDE:
+				{
+					AST tmp104_AST = null;
+					tmp104_AST = astFactory.create(LT(1));
+					astFactory.makeASTRoot(currentAST, tmp104_AST);
+					match(TILDE);
+					break;
+				}
+				default:
+				{
+					throw new NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				primary_expr();
+				astFactory.addASTChild(currentAST, returnAST);
+				unary_expr_AST = (AST)currentAST.root;
+				break;
+			}
+			case SCOPEOP:
+			case IDENT:
+			case LPAREN:
+			case LITERAL_TRUE:
+			case LITERAL_FALSE:
+			case INT:
+			case OCTAL:
+			case HEX:
+			case STRING_LITERAL:
+			case WIDE_STRING_LITERAL:
+			case CHAR_LITERAL:
+			case WIDE_CHAR_LITERAL:
+			case FIXED:
+			case FLOAT:
+			{
+				primary_expr();
+				astFactory.addASTChild(currentAST, returnAST);
+				unary_expr_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = unary_expr_AST;
+	}
+	
+	public final void primary_expr() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST primary_expr_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case SCOPEOP:
+			case IDENT:
+			{
+				scoped_name();
+				astFactory.addASTChild(currentAST, returnAST);
+				primary_expr_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_TRUE:
+			case LITERAL_FALSE:
+			case INT:
+			case OCTAL:
+			case HEX:
+			case STRING_LITERAL:
+			case WIDE_STRING_LITERAL:
+			case CHAR_LITERAL:
+			case WIDE_CHAR_LITERAL:
+			case FIXED:
+			case FLOAT:
+			{
+				literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				primary_expr_AST = (AST)currentAST.root;
+				break;
+			}
+			case LPAREN:
+			{
+				AST tmp105_AST = null;
+				tmp105_AST = astFactory.create(LT(1));
+				astFactory.makeASTRoot(currentAST, tmp105_AST);
+				match(LPAREN);
+				const_exp();
+				astFactory.addASTChild(currentAST, returnAST);
+				AST tmp106_AST = null;
+				tmp106_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp106_AST);
+				match(RPAREN);
+				primary_expr_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = primary_expr_AST;
+	}
+	
+	public final void literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST literal_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case INT:
+			case OCTAL:
+			case HEX:
+			{
+				integer_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case STRING_LITERAL:
+			{
+				string_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case WIDE_STRING_LITERAL:
+			{
+				wide_string_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case CHAR_LITERAL:
+			{
+				character_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case WIDE_CHAR_LITERAL:
+			{
+				wide_character_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case FIXED:
+			{
+				fixed_pt_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case FLOAT:
+			{
+				floating_pt_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_TRUE:
+			case LITERAL_FALSE:
+			{
+				boolean_literal();
+				astFactory.addASTChild(currentAST, returnAST);
+				literal_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = literal_AST;
+	}
+	
+	public final void integer_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST integer_literal_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case INT:
+			{
+				AST tmp107_AST = null;
+				tmp107_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp107_AST);
+				match(INT);
+				integer_literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case OCTAL:
+			{
+				AST tmp108_AST = null;
+				tmp108_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp108_AST);
+				match(OCTAL);
+				integer_literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case HEX:
+			{
+				AST tmp109_AST = null;
+				tmp109_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp109_AST);
+				match(HEX);
+				integer_literal_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = integer_literal_AST;
+	}
+	
+	public final void string_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST string_literal_AST = null;
+		
+		try {      // for error handling
+			{
+			int _cnt285=0;
+			_loop285:
+			do {
+				if ((LA(1)==STRING_LITERAL)) {
+					AST tmp110_AST = null;
+					tmp110_AST = astFactory.create(LT(1));
+					astFactory.addASTChild(currentAST, tmp110_AST);
+					match(STRING_LITERAL);
+				}
+				else {
+					if ( _cnt285>=1 ) { break _loop285; } else {throw new NoViableAltException(LT(1), getFilename());}
+				}
+				
+				_cnt285++;
+			} while (true);
+			}
+			string_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = string_literal_AST;
+	}
+	
+	public final void wide_string_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST wide_string_literal_AST = null;
+		
+		try {      // for error handling
+			{
+			int _cnt288=0;
+			_loop288:
+			do {
+				if ((LA(1)==WIDE_STRING_LITERAL)) {
+					AST tmp111_AST = null;
+					tmp111_AST = astFactory.create(LT(1));
+					astFactory.addASTChild(currentAST, tmp111_AST);
+					match(WIDE_STRING_LITERAL);
+				}
+				else {
+					if ( _cnt288>=1 ) { break _loop288; } else {throw new NoViableAltException(LT(1), getFilename());}
+				}
+				
+				_cnt288++;
+			} while (true);
+			}
+			wide_string_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = wide_string_literal_AST;
+	}
+	
+	public final void character_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST character_literal_AST = null;
+		
+		try {      // for error handling
+			AST tmp112_AST = null;
+			tmp112_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp112_AST);
+			match(CHAR_LITERAL);
+			character_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = character_literal_AST;
+	}
+	
+	public final void wide_character_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST wide_character_literal_AST = null;
+		
+		try {      // for error handling
+			AST tmp113_AST = null;
+			tmp113_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp113_AST);
+			match(WIDE_CHAR_LITERAL);
+			wide_character_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = wide_character_literal_AST;
+	}
+	
+	public final void fixed_pt_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST fixed_pt_literal_AST = null;
+		
+		try {      // for error handling
+			AST tmp114_AST = null;
+			tmp114_AST = astFactory.create(LT(1));
+			astFactory.addASTChild(currentAST, tmp114_AST);
+			match(FIXED);
+			fixed_pt_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = fixed_pt_literal_AST;
+	}
+	
+	public final void floating_pt_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST floating_pt_literal_AST = null;
+		Token  f = null;
+		AST f_AST = null;
+		
+		try {      // for error handling
+			f = LT(1);
+			f_AST = astFactory.create(f);
+			astFactory.addASTChild(currentAST, f_AST);
+			match(FLOAT);
+			floating_pt_literal_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = floating_pt_literal_AST;
+	}
+	
+	public final void boolean_literal() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST boolean_literal_AST = null;
+		
+		try {      // for error handling
+			switch ( LA(1)) {
+			case LITERAL_TRUE:
+			{
+				AST tmp115_AST = null;
+				tmp115_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp115_AST);
+				match(LITERAL_TRUE);
+				boolean_literal_AST = (AST)currentAST.root;
+				break;
+			}
+			case LITERAL_FALSE:
+			{
+				AST tmp116_AST = null;
+				tmp116_AST = astFactory.create(LT(1));
+				astFactory.addASTChild(currentAST, tmp116_AST);
+				match(LITERAL_FALSE);
+				boolean_literal_AST = (AST)currentAST.root;
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltException(LT(1), getFilename());
+			}
+			}
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_42);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = boolean_literal_AST;
+	}
+	
+	public final void positive_int_const() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST positive_int_const_AST = null;
+		
+		try {      // for error handling
+			const_exp();
+			astFactory.addASTChild(currentAST, returnAST);
+			positive_int_const_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_43);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = positive_int_const_AST;
+	}
+	
+	public final void type_declarator() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST type_declarator_AST = null;
+		
+		try {      // for error handling
+			type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			declarators();
+			astFactory.addASTChild(currentAST, returnAST);
+			type_declarator_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_10);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = type_declarator_AST;
+	}
+	
+	public final void struct_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST struct_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp117_AST = null;
+			tmp117_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp117_AST);
+			match(LITERAL_struct);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			member_list();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RCURLY);
+			struct_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_23);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = struct_type_AST;
+	}
+	
+	public final void union_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST union_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp120_AST = null;
+			tmp120_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp120_AST);
+			match(LITERAL_union);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LITERAL_switch);
+			match(LPAREN);
+			switch_type_spec();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RPAREN);
+			match(LCURLY);
+			switch_body();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RCURLY);
+			union_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {
+			if (inputState.guessing==0) {
+				reportError(ex);
+				consume();
+				consumeUntil(_tokenSet_23);
+			} else {
+			  throw ex;
+			}
+		}
+		returnAST = union_type_AST;
+	}
+	
+	public final void enum_type() throws RecognitionException, TokenStreamException {
+		
+		returnAST = null;
+		ASTPair currentAST = new ASTPair();
+		AST enum_type_AST = null;
+		
+		try {      // for error handling
+			AST tmp126_AST = null;
+			tmp126_AST = astFactory.create(LT(1));
+			astFactory.makeASTRoot(currentAST, tmp126_AST);
+			match(LITERAL_enum);
+			identifier();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(LCURLY);
+			enumerator_list();
+			astFactory.addASTChild(currentAST, returnAST);
+			match(RCURLY);
+			enum_type_AST = (AST)currentAST.root;
+		}
+		catch (RecognitionException ex) {

[... 3414 lines stripped ...]


Mime
View raw message