You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by de...@apache.org on 2007/09/04 14:39:45 UTC
svn commit: r572651 [3/6] - in /webservices/axis2/trunk/java: ./
modules/codegen/src/org/apache/axis2/wsdl/codegen/writer/ modules/corba/
modules/corba/src/ modules/corba/src/org/ modules/corba/src/org/apache/
modules/corba/src/org/apache/axis2/ module...
Added: webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLParser.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLParser.java?rev=572651&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLParser.java (added)
+++ webservices/axis2/trunk/java/modules/corba/src/org/apache/axis2/corba/idl/parser/IDLParser.java Tue Sep 4 05:39:42 2007
@@ -0,0 +1,6977 @@
+// $ANTLR 2.7.6 (2005-12-22): "org.apache.axis2.corba.idl.g" -> "IDLParser.java"$
+
+ package org.apache.axis2.corba.idl.parser;
+
+ import antlr.TokenBuffer;
+import antlr.TokenStreamException;
+ import antlr.Token;
+import antlr.TokenStream;
+import antlr.RecognitionException;
+import antlr.NoViableAltException;
+ import antlr.ParserSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.collections.AST;
+ import antlr.ASTFactory;
+import antlr.ASTPair;
+
+/**
+ * This is a complete parser for the IDL language as defined
+ * by the CORBA 3.0.2 specification. It will allow those who
+ * need an IDL parser to get up-and-running very quickly.
+ * Though IDL's syntax is very similar to C++, it is also
+ * much simpler, due in large part to the fact that it is
+ * a declarative-only language.
+ *
+ * Some things that are not included are: Symbol table construction
+ * (it is not necessary for parsing, btw) and preprocessing (for
+ * IDL compiler #pragma directives). You can use just about any
+ * C or C++ preprocessor, but there is an interesting semantic
+ * issue if you are going to generate code: In C, #include is
+ * a literal include, in IDL, #include is more like Java's import:
+ * It adds definitions to the scope of the parse, but included
+ * definitions are not generated.
+ *
+ * Jim Coker, jcoker@magelang.com
+ * Gary Duzan, gduzan@bbn.com
+ */
+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);
+ recover(ex,_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);
+ recover(ex,_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);
+ recover(ex,_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 synPredMatched111 = false;
+ if (((LA(1)==LITERAL_struct) && (LA(2)==IDENT) && (LA(3)==LCURLY))) {
+ int _m111 = mark();
+ synPredMatched111 = true;
+ inputState.guessing++;
+ try {
+ {
+ struct_type();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched111 = false;
+ }
+ rewind(_m111);
+inputState.guessing--;
+ }
+ if ( synPredMatched111 ) {
+ struct_type();
+ astFactory.addASTChild(currentAST, returnAST);
+ type_dcl_AST = (AST)currentAST.root;
+ }
+ else {
+ boolean synPredMatched113 = false;
+ if (((LA(1)==LITERAL_union) && (LA(2)==IDENT) && (LA(3)==LITERAL_switch))) {
+ int _m113 = mark();
+ synPredMatched113 = true;
+ inputState.guessing++;
+ try {
+ {
+ union_type();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched113 = false;
+ }
+ rewind(_m113);
+inputState.guessing--;
+ }
+ if ( synPredMatched113 ) {
+ 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);
+ recover(ex,_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);
+ recover(ex,_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);
+ recover(ex,_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
+ {
+ switch ( LA(1)) {
+ case LITERAL_abstract:
+ {
+ AST tmp21_AST = null;
+ tmp21_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp21_AST);
+ match(LITERAL_abstract);
+ break;
+ }
+ case LITERAL_local:
+ {
+ AST tmp22_AST = null;
+ tmp22_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp22_AST);
+ match(LITERAL_local);
+ break;
+ }
+ case LITERAL_interface:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ AST tmp23_AST = null;
+ tmp23_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp23_AST);
+ match(LITERAL_interface);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case LCURLY:
+ case COLON:
+ {
+ interface_dcl();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ interf_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_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 tmp24_AST = null;
+ tmp24_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp24_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);
+ recover(ex,_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_11.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);
+ recover(ex,_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 tmp27_AST = null;
+ tmp27_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp27_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);
+ recover(ex,_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 tmp28_AST = null;
+ tmp28_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp28_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);
+ recover(ex,_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);
+ recover(ex,_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 tmp29_AST = null;
+ tmp29_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp29_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);
+ recover(ex,_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);
+ recover(ex,_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 tmp30_AST = null;
+ tmp30_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp30_AST);
+ match(IDENT);
+ identifier_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_12);
+ } 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);
+ recover(ex,_tokenSet_13);
+ } 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
+ interface_header();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(LCURLY);
+ interface_body();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RCURLY);
+ interface_dcl_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_10);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = interface_dcl_AST;
+ }
+
+ public final void interface_header() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST interface_header_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case COLON:
+ {
+ interface_inheritance_spec();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ interface_header_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_14);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = interface_header_AST;
+ }
+
+ public final void interface_body() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST interface_body_AST = null;
+
+ try { // for error handling
+ {
+ _loop29:
+ do {
+ if ((_tokenSet_15.member(LA(1)))) {
+ export();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop29;
+ }
+
+ } while (true);
+ }
+ interface_body_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_13);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = interface_body_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 tmp33_AST = null;
+ tmp33_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp33_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);
+ recover(ex,_tokenSet_14);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = interface_inheritance_spec_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;
+ }
+ case PREPROC_DIRECTIVE:
+ {
+ AST tmp41_AST = null;
+ tmp41_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp41_AST);
+ match(PREPROC_DIRECTIVE);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ export_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } 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);
+ recover(ex,_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 tmp42_AST = null;
+ tmp42_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp42_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);
+ recover(ex,_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);
+ {
+ _loop36:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ scoped_name();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop36;
+ }
+
+ } while (true);
+ }
+ scoped_name_list_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } 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);
+ recover(ex,_tokenSet_18);
+ } 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 tmp44_AST = null;
+ tmp44_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp44_AST);
+ match(SCOPEOP);
+ break;
+ }
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ AST tmp45_AST = null;
+ tmp45_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp45_AST);
+ match(IDENT);
+ {
+ _loop40:
+ do {
+ if ((LA(1)==SCOPEOP)) {
+ match(SCOPEOP);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop40;
+ }
+
+ } while (true);
+ }
+ scoped_name_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_19);
+ } 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
+ AST tmp47_AST = null;
+ tmp47_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp47_AST);
+ match(LITERAL_valuetype);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ value_inheritance_spec();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(LCURLY);
+ {
+ _loop52:
+ do {
+ if ((_tokenSet_20.member(LA(1)))) {
+ value_element();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop52;
+ }
+
+ } while (true);
+ }
+ match(RCURLY);
+ value_dcl_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_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 tmp50_AST = null;
+ tmp50_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp50_AST);
+ match(LITERAL_abstract);
+ AST tmp51_AST = null;
+ tmp51_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp51_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);
+ recover(ex,_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 tmp52_AST = null;
+ tmp52_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp52_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);
+ recover(ex,_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 tmp53_AST = null;
+ tmp53_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp53_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);
+ recover(ex,_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 tmp54_AST = null;
+ tmp54_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp54_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);
+ recover(ex,_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);
+ recover(ex,_tokenSet_21);
+ } 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);
+ {
+ _loop49:
+ do {
+ if ((_tokenSet_15.member(LA(1)))) {
+ export();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop49;
+ }
+
+ } while (true);
+ }
+ match(RCURLY);
+ value_abs_full_dcl_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_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);
+ recover(ex,_tokenSet_14);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = value_inheritance_spec_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 PREPROC_DIRECTIVE:
+ 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);
+ recover(ex,_tokenSet_22);
+ } 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 tmp57_AST = null;
+ tmp57_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp57_AST);
+ match(COLON);
+ {
+ switch ( LA(1)) {
+ case LITERAL_truncatable:
+ {
+ AST tmp58_AST = null;
+ tmp58_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp58_AST);
+ match(LITERAL_truncatable);
+ break;
+ }
+ case SCOPEOP:
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ value_name();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop60:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ value_name();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop60;
+ }
+
+ } while (true);
+ }
+ value_value_inheritance_spec_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } 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 tmp60_AST = null;
+ tmp60_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp60_AST);
+ match(LITERAL_supports);
+ interface_name();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop63:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ interface_name();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop63;
+ }
+
+ } while (true);
+ }
+ value_interface_inheritance_spec_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_14);
+ } 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);
+ recover(ex,_tokenSet_24);
+ } 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 tmp62_AST = null;
+ tmp62_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp62_AST);
+ match(LITERAL_public);
+ break;
+ }
+ case LITERAL_private:
+ {
+ AST tmp63_AST = null;
+ tmp63_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp63_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);
+ recover(ex,_tokenSet_22);
+ } 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 tmp65_AST = null;
+ tmp65_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp65_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);
+ recover(ex,_tokenSet_22);
+ } 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);
+ {
+ _loop124:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ declarator();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop124;
+ }
+
+ } while (true);
+ }
+ declarators_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_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);
+ {
+ _loop74:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ init_param_decl();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop74;
+ }
+
+ } while (true);
+ }
+ init_param_decls_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_25);
+ } 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 tmp71_AST = null;
+ tmp71_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp71_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);
+ recover(ex,_tokenSet_26);
+ } 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);
+ recover(ex,_tokenSet_27);
+ } 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 tmp74_AST = null;
+ tmp74_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp74_AST);
+ match(LITERAL_in);
+ init_param_attribute_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_28);
+ } 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);
+ recover(ex,_tokenSet_29);
+ } 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);
+ recover(ex,_tokenSet_30);
+ } 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 synPredMatched80 = 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_31.member(LA(4))))) {
+ int _m80 = mark();
+ synPredMatched80 = true;
+ inputState.guessing++;
+ try {
+ {
+ integer_type();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched80 = false;
+ }
+ rewind(_m80);
+inputState.guessing--;
+ }
+ if ( synPredMatched80 ) {
+ 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_31.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);
+ recover(ex,_tokenSet_29);
+ } 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);
+ recover(ex,_tokenSet_32);
+ } 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);
+ recover(ex,_tokenSet_33);
+ } 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 tmp75_AST = null;
+ tmp75_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp75_AST);
+ match(LITERAL_char);
+ char_type_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_33);
+ } 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 tmp76_AST = null;
+ tmp76_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp76_AST);
+ match(LITERAL_wchar);
+ wide_char_type_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_34);
+ } 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 tmp77_AST = null;
+ tmp77_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp77_AST);
+ match(LITERAL_boolean);
+ boolean_type_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_33);
+ } 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 tmp78_AST = null;
+ tmp78_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp78_AST);
+ match(LITERAL_float);
+ floating_pt_type_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_double:
+ {
+ AST tmp79_AST = null;
+ tmp79_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp79_AST);
+ match(LITERAL_double);
+ floating_pt_type_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_long:
+ {
+ AST tmp80_AST = null;
+ tmp80_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp80_AST);
+ match(LITERAL_long);
+ 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;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_34);
+ } 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 tmp82_AST = null;
+ tmp82_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp82_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);
+ recover(ex,_tokenSet_34);
+ } 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 tmp85_AST = null;
+ tmp85_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp85_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);
+ recover(ex,_tokenSet_34);
+ } 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 tmp88_AST = null;
+ tmp88_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp88_AST);
+ match(LITERAL_fixed);
+ fixed_pt_const_type_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_29);
+ } 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 tmp89_AST = null;
+ tmp89_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp89_AST);
+ match(LITERAL_octet);
+ octet_type_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_34);
+ } 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);
+ {
+ _loop84:
+ do {
+ if ((LA(1)==OR)) {
+ AST tmp90_AST = null;
+ tmp90_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp90_AST);
+ match(OR);
+ xor_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop84;
+ }
+
+ } while (true);
+ }
+ or_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_32);
+ } 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);
+ {
+ _loop87:
+ do {
+ if ((LA(1)==XOR)) {
+ AST tmp91_AST = null;
+ tmp91_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp91_AST);
+ match(XOR);
+ and_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop87;
+ }
+
+ } while (true);
+ }
+ xor_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_35);
+ } 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);
+ {
+ _loop90:
+ do {
+ if ((LA(1)==AND)) {
+ AST tmp92_AST = null;
+ tmp92_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp92_AST);
+ match(AND);
+ shift_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop90;
+ }
+
+ } while (true);
+ }
+ and_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_36);
+ } 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);
+ {
+ _loop94:
+ do {
+ if ((LA(1)==LSHIFT||LA(1)==RSHIFT)) {
+ {
+ switch ( LA(1)) {
+ case LSHIFT:
+ {
+ AST tmp93_AST = null;
+ tmp93_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp93_AST);
+ match(LSHIFT);
+ break;
+ }
+ case RSHIFT:
+ {
+ AST tmp94_AST = null;
+ tmp94_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp94_AST);
+ match(RSHIFT);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ add_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop94;
+ }
+
+ } while (true);
+ }
+ shift_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_37);
+ } 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);
+ {
+ _loop98:
+ do {
+ if ((LA(1)==PLUS||LA(1)==MINUS)) {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ AST tmp95_AST = null;
+ tmp95_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp95_AST);
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ AST tmp96_AST = null;
+ tmp96_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp96_AST);
+ match(MINUS);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ mult_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop98;
+ }
+
+ } while (true);
+ }
+ add_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_38);
+ } 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);
+ {
+ _loop102:
+ do {
+ if (((LA(1) >= STAR && LA(1) <= MOD))) {
+ {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ AST tmp97_AST = null;
+ tmp97_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp97_AST);
+ match(STAR);
+ break;
+ }
+ case DIV:
+ {
+ AST tmp98_AST = null;
+ tmp98_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp98_AST);
+ match(DIV);
+ break;
+ }
+ case MOD:
+ {
+ AST tmp99_AST = null;
+ tmp99_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp99_AST);
+ match(MOD);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ unary_expr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop102;
+ }
+
+ } while (true);
+ }
+ mult_expr_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_39);
+ } 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 tmp100_AST = null;
+ tmp100_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp100_AST);
+ match(MINUS);
+ break;
+ }
+ case PLUS:
+ {
+ AST tmp101_AST = null;
+ tmp101_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp101_AST);
+ match(PLUS);
+ break;
+ }
+ case TILDE:
+ {
+ AST tmp102_AST = null;
+ tmp102_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp102_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);
+ recover(ex,_tokenSet_40);
+ } 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 tmp103_AST = null;
+ tmp103_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp103_AST);
+ match(LPAREN);
+ const_exp();
+ astFactory.addASTChild(currentAST, returnAST);
+ AST tmp104_AST = null;
+ tmp104_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp104_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);
+ recover(ex,_tokenSet_40);
+ } 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);
+ recover(ex,_tokenSet_40);
+ } 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 tmp105_AST = null;
+ tmp105_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp105_AST);
+ match(INT);
+ integer_literal_AST = (AST)currentAST.root;
+ break;
+ }
+ case OCTAL:
+ {
+ AST tmp106_AST = null;
+ tmp106_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp106_AST);
+ match(OCTAL);
+ integer_literal_AST = (AST)currentAST.root;
+ break;
+ }
+ case HEX:
+ {
+ AST tmp107_AST = null;
+ tmp107_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp107_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);
+ recover(ex,_tokenSet_40);
+ } 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 _cnt282=0;
+ _loop282:
+ do {
+ if ((LA(1)==STRING_LITERAL)) {
+ AST tmp108_AST = null;
+ tmp108_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp108_AST);
+ match(STRING_LITERAL);
+ }
+ else {
+ if ( _cnt282>=1 ) { break _loop282; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt282++;
+ } while (true);
+ }
+ string_literal_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } 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 _cnt285=0;
+ _loop285:
+ do {
+ if ((LA(1)==WIDE_STRING_LITERAL)) {
+ AST tmp109_AST = null;
+ tmp109_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp109_AST);
+ match(WIDE_STRING_LITERAL);
+ }
+ else {
+ if ( _cnt285>=1 ) { break _loop285; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt285++;
+ } while (true);
+ }
+ wide_string_literal_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } 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 tmp110_AST = null;
+ tmp110_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp110_AST);
+ match(CHAR_LITERAL);
+ character_literal_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } 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 tmp111_AST = null;
+ tmp111_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp111_AST);
+ match(WIDE_CHAR_LITERAL);
+ wide_character_literal_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } 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 tmp112_AST = null;
+ tmp112_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp112_AST);
+ match(FIXED);
+ fixed_pt_literal_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } 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);
+ recover(ex,_tokenSet_40);
+ } 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 tmp113_AST = null;
+ tmp113_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp113_AST);
+ match(LITERAL_TRUE);
+ boolean_literal_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_FALSE:
+ {
+ AST tmp114_AST = null;
+ tmp114_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp114_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);
+ recover(ex,_tokenSet_40);
+ } 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);
+ recover(ex,_tokenSet_41);
+ } 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);
+ recover(ex,_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 tmp115_AST = null;
+ tmp115_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp115_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);
+ recover(ex,_tokenSet_21);
+ } 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 tmp118_AST = null;
+ tmp118_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp118_AST);
+ match(LITERAL_union);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
[... 3373 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org