You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cxf.apache.org by dk...@apache.org on 2008/01/08 03:47:59 UTC
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...
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 ...]