Source Code of processing.app.preproc.StdCParser

// $ANTLR 2.7.2: "StdCParser.g" -> "StdCParser.java"$


package processing.app.preproc;
import java.io.*;


import antlr.CommonAST;
import antlr.DumpASTVisitor;


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;


public class StdCParser extends antlr.LLkParser       implements STDCTokenTypes
 {


    // Suppport C++-style single-line comments?
    public static boolean CPPComments = true;


    // access to symbol table
    public CSymbolTable symbolTable = new CSymbolTable();


    // source for names to unnamed scopes
    protected int unnamedScopeCounter = 0;


    public boolean isTypedefName(String name) {
      boolean returnValue = false;
      TNode node = symbolTable.lookupNameInCurrentScope(name);
      for (; node != null; node = (TNode) node.getNextSibling() ) {
        if(node.getType() == LITERAL_typedef) {
            returnValue = true;
            break;
        }
      }
      return returnValue;
    }




    public String getAScopeName() {
      return "" + (unnamedScopeCounter++);
    }


    public void pushScope(String scopeName) {
      symbolTable.pushScope(scopeName);
    }


    public void popScope() {
      symbolTable.popScope();
    }


        int traceDepth = 0;
        public void reportError(RecognitionException ex) {
          try {
            System.err.println("ANTLR Parsing Error: "+ex + " token name:" + tokenNames[LA(1)]);
            ex.printStackTrace(System.err);
          }
    catch (TokenStreamException e) {
            System.err.println("ANTLR Parsing Error: "+ex);
            ex.printStackTrace(System.err);              
          }
        }
        public void reportError(String s) {
            System.err.println("ANTLR Parsing Error from String: " + s);
        }
        public void reportWarning(String s) {
            System.err.println("ANTLR Parsing Warning from String: " + s);
        }
        public void match(int t) throws MismatchedTokenException {
          boolean debugging = false;
          
          if ( debugging ) {
           for (int x=0; x<traceDepth; x++) System.out.print(" ");
           try {
            System.out.println("Match("+tokenNames[t]+") with LA(1)="+
                tokenNames[LA(1)] + ((inputState.guessing>0)?" [inputState.guessing "+ inputState.guessing + "]":""));
           }
           catch (TokenStreamException e) {
            System.out.println("Match("+tokenNames[t]+") " + ((inputState.guessing>0)?" [inputState.guessing "+ inputState.guessing + "]":""));


           }
    
          }
          try {
            if ( LA(1)!=t ) {
                if ( debugging ){
                    for (int x=0; x<traceDepth; x++) System.out.print(" ");
                    System.out.println("token mismatch: "+tokenNames[LA(1)]
                                + "!="+tokenNames[t]);
                }
          throw new MismatchedTokenException(tokenNames, LT(1), t, false, getFilename());


            } else {
                // mark token as consumed -- fetch next token deferred until LA/LT
                consume();
            }
          }
          catch (TokenStreamException e) {
          }
    
        }
        public void traceIn(String rname) {
          traceDepth += 1;
          for (int x=0; x<traceDepth; x++) System.out.print(" ");
          try {
            System.out.println("> "+rname+"; LA(1)==("+ tokenNames[LT(1).getType()] 
                + ") " + LT(1).getText() + " [inputState.guessing "+ inputState.guessing + "]");
          }
          catch (TokenStreamException e) {
          }
        }
        public void traceOut(String rname) {
          for (int x=0; x<traceDepth; x++) System.out.print(" ");
          try {
            System.out.println("< "+rname+"; LA(1)==("+ tokenNames[LT(1).getType()] 
                + ") "+LT(1).getText() + " [inputState.guessing "+ inputState.guessing + "]");
          }
          catch (TokenStreamException e) {
          }
          traceDepth -= 1;
        }
    


protected StdCParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


public StdCParser(TokenBuffer tokenBuf) {
  this(tokenBuf,2);
}


protected StdCParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


public StdCParser(TokenStream lexer) {
  this(lexer,2);
}


public StdCParser(ParserSharedInputState state) {
  super(state,2);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


  public final void translationUnit() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode translationUnit_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_typedef:
      case LITERAL_asm:
      case LITERAL_volatile:
      case LITERAL_struct:
      case LITERAL_union:
      case LITERAL_enum:
      case LITERAL_auto:
      case LITERAL_register:
      case LITERAL_extern:
      case LITERAL_static:
      case LITERAL_const:
      case LITERAL_void:
      case LITERAL_char:
      case LITERAL_short:
      case LITERAL_int:
      case LITERAL_long:
      case LITERAL_float:
      case LITERAL_double:
      case LITERAL_signed:
      case LITERAL_unsigned:
      case ID:
      case STAR:
      case LPAREN:
      {
        externalList();
        astFactory.addASTChild(currentAST, returnAST);
        translationUnit_AST = (TNode)currentAST.root;
        break;
      }
      case EOF:
      {
        if ( inputState.guessing==0 ) {
          
          System.err.println ( "Empty source file!" );
          
        }
        translationUnit_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = translationUnit_AST;
  }
  
  public final void externalList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode externalList_AST = null;
    
    try {      // for error handling
      {
      int _cnt4=0;
      _loop4:
      do {
        if ((_tokenSet_1.member(LA(1)))) {
          externalDef();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt4>=1 ) { break _loop4; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt4++;
      } while (true);
      }
      externalList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = externalList_AST;
  }
  
  public final void externalDef() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode externalDef_AST = null;
    
    try {      // for error handling
      boolean synPredMatched7 = false;
      if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
        int _m7 = mark();
        synPredMatched7 = true;
        inputState.guessing++;
        try {
          {
          if ((LA(1)==LITERAL_typedef) && (true)) {
            match(LITERAL_typedef);
          }
          else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
            declaration();
          }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
          
          }
        }
        catch (RecognitionException pe) {
          synPredMatched7 = false;
        }
        rewind(_m7);
        inputState.guessing--;
      }
      if ( synPredMatched7 ) {
        declaration();
        astFactory.addASTChild(currentAST, returnAST);
        externalDef_AST = (TNode)currentAST.root;
      }
      else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
        functionDef();
        astFactory.addASTChild(currentAST, returnAST);
        externalDef_AST = (TNode)currentAST.root;
      }
      else if ((LA(1)==LITERAL_asm)) {
        asm_expr();
        astFactory.addASTChild(currentAST, returnAST);
        externalDef_AST = (TNode)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_6);
      } else {
        throw ex;
      }
    }
    returnAST = externalDef_AST;
  }
  
  public final void declaration() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode declaration_AST = null;
    TNode ds_AST = null;
    AST ds1 = null;
    
    try {      // for error handling
      declSpecifiers();
      ds_AST = (TNode)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        ds1 = astFactory.dupList(ds_AST);
      }
      {
      switch ( LA(1)) {
      case ID:
      case STAR:
      case LPAREN:
      {
        initDeclList(ds1);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case SEMI:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(SEMI);
      if ( inputState.guessing==0 ) {
        declaration_AST = (TNode)currentAST.root;
        declaration_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NDeclaration)).add(declaration_AST));
        currentAST.root = declaration_AST;
        currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
          declaration_AST.getFirstChild() : declaration_AST;
        currentAST.advanceChildToEnd();
      }
      declaration_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_7);
      } else {
        throw ex;
      }
    }
    returnAST = declaration_AST;
  }
  
  public final void functionDef() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode functionDef_AST = null;
    TNode ds_AST = null;
    TNode d_AST = null;
    String declName;
    
    try {      // for error handling
      {
      boolean synPredMatched94 = false;
      if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))) {
        int _m94 = mark();
        synPredMatched94 = true;
        inputState.guessing++;
        try {
          {
          functionDeclSpecifiers();
          }
        }
        catch (RecognitionException pe) {
          synPredMatched94 = false;
        }
        rewind(_m94);
        inputState.guessing--;
      }
      if ( synPredMatched94 ) {
        functionDeclSpecifiers();
        ds_AST = (TNode)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      declName=declarator(true);
      d_AST = (TNode)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        
        AST d2, ds2;
        d2 = astFactory.dupList(d_AST);
        ds2 = astFactory.dupList(ds_AST);
        symbolTable.add(declName, (TNode)astFactory.make( (new ASTArray(3)).add(null).add(ds2).add(d2)));
        pushScope(declName);
        
      }
      {
      _loop96:
      do {
        if ((_tokenSet_2.member(LA(1)))) {
          declaration();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop96;
        }
        
      } while (true);
      }
      {
      switch ( LA(1)) {
      case VARARGS:
      {
        TNode tmp2_AST = null;
        tmp2_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp2_AST);
        match(VARARGS);
        break;
      }
      case LCURLY:
      case SEMI:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      _loop99:
      do {
        if ((LA(1)==SEMI)) {
          match(SEMI);
        }
        else {
          break _loop99;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        popScope();
      }
      compoundStatement(declName);
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        functionDef_AST = (TNode)currentAST.root;
        functionDef_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NFunctionDef)).add(functionDef_AST));
        currentAST.root = functionDef_AST;
        currentAST.child = functionDef_AST!=null &&functionDef_AST.getFirstChild()!=null ?
          functionDef_AST.getFirstChild() : functionDef_AST;
        currentAST.advanceChildToEnd();
      }
      functionDef_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_6);
      } else {
        throw ex;
      }
    }
    returnAST = functionDef_AST;
  }
  
  public final void asm_expr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode asm_expr_AST = null;
    
    try {      // for error handling
      TNode tmp4_AST = null;
      tmp4_AST = (TNode)astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp4_AST);
      match(LITERAL_asm);
      {
      switch ( LA(1)) {
      case LITERAL_volatile:
      {
        TNode tmp5_AST = null;
        tmp5_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp5_AST);
        match(LITERAL_volatile);
        break;
      }
      case LCURLY:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(LCURLY);
      expr();
      astFactory.addASTChild(currentAST, returnAST);
      match(RCURLY);
      match(SEMI);
      asm_expr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_6);
      } else {
        throw ex;
      }
    }
    returnAST = asm_expr_AST;
  }
  
  public final void expr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode expr_AST = null;
    Token  c = null;
    TNode c_AST = null;
    
    try {      // for error handling
      assignExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop129:
      do {
        if ((LA(1)==COMMA) && (_tokenSet_11.member(LA(2)))) {
          c = LT(1);
          c_AST = (TNode)astFactory.create(c);
          astFactory.makeASTRoot(currentAST, c_AST);
          match(COMMA);
          if ( inputState.guessing==0 ) {
            c_AST.setType(NCommaExpr);
          }
          assignExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop129;
        }
        
      } while (true);
      }
      expr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_12);
      } else {
        throw ex;
      }
    }
    returnAST = expr_AST;
  }
  
  public final void declSpecifiers() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode declSpecifiers_AST = null;
    TNode s_AST = null;
    int specCount=0;
    
    try {      // for error handling
      {
      int _cnt16=0;
      _loop16:
      do {
        switch ( LA(1)) {
        case LITERAL_typedef:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_extern:
        case LITERAL_static:
        {
          storageClassSpecifier();
          s_AST = (TNode)returnAST;
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case LITERAL_volatile:
        case LITERAL_const:
        {
          typeQualifier();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        default:
          boolean synPredMatched15 = false;
          if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
            int _m15 = mark();
            synPredMatched15 = true;
            inputState.guessing++;
            try {
              {
              if ((LA(1)==LITERAL_struct) && (true)) {
                match(LITERAL_struct);
              }
              else if ((LA(1)==LITERAL_union) && (true)) {
                match(LITERAL_union);
              }
              else if ((LA(1)==LITERAL_enum) && (true)) {
                match(LITERAL_enum);
              }
              else if ((_tokenSet_13.member(LA(1))) && (true)) {
                typeSpecifier(specCount);
              }
              else {
                throw new NoViableAltException(LT(1), getFilename());
              }
              
              }
            }
            catch (RecognitionException pe) {
              synPredMatched15 = false;
            }
            rewind(_m15);
            inputState.guessing--;
          }
          if ( synPredMatched15 ) {
            specCount=typeSpecifier(specCount);
            astFactory.addASTChild(currentAST, returnAST);
          }
        else {
          if ( _cnt16>=1 ) { break _loop16; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        }
        _cnt16++;
      } while (true);
      }
      declSpecifiers_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_15);
      } else {
        throw ex;
      }
    }
    returnAST = declSpecifiers_AST;
  }
  
  public final void initDeclList(
    AST declarationSpecifiers
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode initDeclList_AST = null;
    
    try {      // for error handling
      initDecl(declarationSpecifiers);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop56:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          initDecl(declarationSpecifiers);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop56;
        }
        
      } while (true);
      }
      initDeclList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_16);
      } else {
        throw ex;
      }
    }
    returnAST = initDeclList_AST;
  }
  
  public final void storageClassSpecifier() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode storageClassSpecifier_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_auto:
      {
        TNode tmp10_AST = null;
        tmp10_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp10_AST);
        match(LITERAL_auto);
        storageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_register:
      {
        TNode tmp11_AST = null;
        tmp11_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp11_AST);
        match(LITERAL_register);
        storageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_typedef:
      {
        TNode tmp12_AST = null;
        tmp12_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp12_AST);
        match(LITERAL_typedef);
        storageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_extern:
      case LITERAL_static:
      {
        functionStorageClassSpecifier();
        astFactory.addASTChild(currentAST, returnAST);
        storageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_17);
      } else {
        throw ex;
      }
    }
    returnAST = storageClassSpecifier_AST;
  }
  
  public final void typeQualifier() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode typeQualifier_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_const:
      {
        TNode tmp13_AST = null;
        tmp13_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp13_AST);
        match(LITERAL_const);
        typeQualifier_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_volatile:
      {
        TNode tmp14_AST = null;
        tmp14_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp14_AST);
        match(LITERAL_volatile);
        typeQualifier_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = typeQualifier_AST;
  }
  
  public final int  typeSpecifier(
    int specCount
  ) throws RecognitionException, TokenStreamException {
    int retSpecCount;
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode typeSpecifier_AST = null;
    retSpecCount = specCount + 1;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case LITERAL_void:
      {
        TNode tmp15_AST = null;
        tmp15_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp15_AST);
        match(LITERAL_void);
        break;
      }
      case LITERAL_char:
      {
        TNode tmp16_AST = null;
        tmp16_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp16_AST);
        match(LITERAL_char);
        break;
      }
      case LITERAL_short:
      {
        TNode tmp17_AST = null;
        tmp17_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp17_AST);
        match(LITERAL_short);
        break;
      }
      case LITERAL_int:
      {
        TNode tmp18_AST = null;
        tmp18_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp18_AST);
        match(LITERAL_int);
        break;
      }
      case LITERAL_long:
      {
        TNode tmp19_AST = null;
        tmp19_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp19_AST);
        match(LITERAL_long);
        break;
      }
      case LITERAL_float:
      {
        TNode tmp20_AST = null;
        tmp20_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp20_AST);
        match(LITERAL_float);
        break;
      }
      case LITERAL_double:
      {
        TNode tmp21_AST = null;
        tmp21_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp21_AST);
        match(LITERAL_double);
        break;
      }
      case LITERAL_signed:
      {
        TNode tmp22_AST = null;
        tmp22_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp22_AST);
        match(LITERAL_signed);
        break;
      }
      case LITERAL_unsigned:
      {
        TNode tmp23_AST = null;
        tmp23_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp23_AST);
        match(LITERAL_unsigned);
        break;
      }
      case LITERAL_struct:
      case LITERAL_union:
      {
        structOrUnionSpecifier();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case LITERAL_enum:
      {
        enumSpecifier();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      default:
        if (((LA(1)==ID))&&( specCount == 0 )) {
          typedefName();
          astFactory.addASTChild(currentAST, returnAST);
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      typeSpecifier_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = typeSpecifier_AST;
    return retSpecCount;
  }
  
  public final void functionStorageClassSpecifier() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode functionStorageClassSpecifier_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_extern:
      {
        TNode tmp24_AST = null;
        tmp24_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp24_AST);
        match(LITERAL_extern);
        functionStorageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_static:
      {
        TNode tmp25_AST = null;
        tmp25_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp25_AST);
        match(LITERAL_static);
        functionStorageClassSpecifier_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_17);
      } else {
        throw ex;
      }
    }
    returnAST = functionStorageClassSpecifier_AST;
  }
  
  public final void structOrUnionSpecifier() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structOrUnionSpecifier_AST = null;
    TNode sou_AST = null;
    Token  i = null;
    TNode i_AST = null;
    Token  l = null;
    TNode l_AST = null;
    Token  l1 = null;
    TNode l1_AST = null;
    String scopeName;
    
    try {      // for error handling
      structOrUnion();
      sou_AST = (TNode)returnAST;
      {
      boolean synPredMatched26 = false;
      if (((LA(1)==ID) && (LA(2)==LCURLY))) {
        int _m26 = mark();
        synPredMatched26 = true;
        inputState.guessing++;
        try {
          {
          match(ID);
          match(LCURLY);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched26 = false;
        }
        rewind(_m26);
        inputState.guessing--;
      }
      if ( synPredMatched26 ) {
        i = LT(1);
        i_AST = (TNode)astFactory.create(i);
        astFactory.addASTChild(currentAST, i_AST);
        match(ID);
        l = LT(1);
        l_AST = (TNode)astFactory.create(l);
        astFactory.addASTChild(currentAST, l_AST);
        match(LCURLY);
        if ( inputState.guessing==0 ) {
          
          scopeName = sou_AST.getText() + " " + i_AST.getText();
          l_AST.setText(scopeName);
          pushScope(scopeName);
          
        }
        structDeclarationList();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          popScope();
        }
        match(RCURLY);
      }
      else if ((LA(1)==LCURLY)) {
        l1 = LT(1);
        l1_AST = (TNode)astFactory.create(l1);
        astFactory.addASTChild(currentAST, l1_AST);
        match(LCURLY);
        if ( inputState.guessing==0 ) {
          
          scopeName = getAScopeName();
          l1_AST.setText(scopeName);
          pushScope(scopeName);
          
        }
        structDeclarationList();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          popScope();
        }
        match(RCURLY);
      }
      else if ((LA(1)==ID) && (_tokenSet_18.member(LA(2)))) {
        TNode tmp28_AST = null;
        tmp28_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp28_AST);
        match(ID);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      if ( inputState.guessing==0 ) {
        structOrUnionSpecifier_AST = (TNode)currentAST.root;
        
        structOrUnionSpecifier_AST = (TNode)astFactory.make( (new ASTArray(2)).add(sou_AST).add(structOrUnionSpecifier_AST));
        
        currentAST.root = structOrUnionSpecifier_AST;
        currentAST.child = structOrUnionSpecifier_AST!=null &&structOrUnionSpecifier_AST.getFirstChild()!=null ?
          structOrUnionSpecifier_AST.getFirstChild() : structOrUnionSpecifier_AST;
        currentAST.advanceChildToEnd();
      }
      structOrUnionSpecifier_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = structOrUnionSpecifier_AST;
  }
  
  public final void enumSpecifier() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode enumSpecifier_AST = null;
    Token  i = null;
    TNode i_AST = null;
    
    try {      // for error handling
      TNode tmp29_AST = null;
      tmp29_AST = (TNode)astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp29_AST);
      match(LITERAL_enum);
      {
      boolean synPredMatched48 = false;
      if (((LA(1)==ID) && (LA(2)==LCURLY))) {
        int _m48 = mark();
        synPredMatched48 = true;
        inputState.guessing++;
        try {
          {
          match(ID);
          match(LCURLY);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched48 = false;
        }
        rewind(_m48);
        inputState.guessing--;
      }
      if ( synPredMatched48 ) {
        i = LT(1);
        i_AST = (TNode)astFactory.create(i);
        astFactory.addASTChild(currentAST, i_AST);
        match(ID);
        TNode tmp30_AST = null;
        tmp30_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp30_AST);
        match(LCURLY);
        enumList(i.getText());
        astFactory.addASTChild(currentAST, returnAST);
        match(RCURLY);
      }
      else if ((LA(1)==LCURLY)) {
        TNode tmp32_AST = null;
        tmp32_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp32_AST);
        match(LCURLY);
        enumList("anonymous");
        astFactory.addASTChild(currentAST, returnAST);
        match(RCURLY);
      }
      else if ((LA(1)==ID) && (_tokenSet_18.member(LA(2)))) {
        TNode tmp34_AST = null;
        tmp34_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp34_AST);
        match(ID);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      enumSpecifier_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = enumSpecifier_AST;
  }
  
  public final void typedefName() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode typedefName_AST = null;
    Token  i = null;
    TNode i_AST = null;
    
    try {      // for error handling
      if (!( isTypedefName ( LT(1).getText() ) ))
        throw new SemanticException(" isTypedefName ( LT(1).getText() ) ");
      i = LT(1);
      i_AST = (TNode)astFactory.create(i);
      astFactory.addASTChild(currentAST, i_AST);
      match(ID);
      if ( inputState.guessing==0 ) {
        typedefName_AST = (TNode)currentAST.root;
        typedefName_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NTypedefName)).add(i_AST));
        currentAST.root = typedefName_AST;
        currentAST.child = typedefName_AST!=null &&typedefName_AST.getFirstChild()!=null ?
          typedefName_AST.getFirstChild() : typedefName_AST;
        currentAST.advanceChildToEnd();
      }
      typedefName_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = typedefName_AST;
  }
  
  public final void structOrUnion() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structOrUnion_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_struct:
      {
        TNode tmp35_AST = null;
        tmp35_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp35_AST);
        match(LITERAL_struct);
        structOrUnion_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_union:
      {
        TNode tmp36_AST = null;
        tmp36_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp36_AST);
        match(LITERAL_union);
        structOrUnion_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_19);
      } else {
        throw ex;
      }
    }
    returnAST = structOrUnion_AST;
  }
  
  public final void structDeclarationList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structDeclarationList_AST = null;
    
    try {      // for error handling
      {
      int _cnt30=0;
      _loop30:
      do {
        if ((_tokenSet_20.member(LA(1)))) {
          structDeclaration();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt30>=1 ) { break _loop30; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt30++;
      } while (true);
      }
      structDeclarationList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = structDeclarationList_AST;
  }
  
  public final void structDeclaration() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structDeclaration_AST = null;
    
    try {      // for error handling
      specifierQualifierList();
      astFactory.addASTChild(currentAST, returnAST);
      structDeclaratorList();
      astFactory.addASTChild(currentAST, returnAST);
      {
      int _cnt33=0;
      _loop33:
      do {
        if ((LA(1)==SEMI)) {
          match(SEMI);
        }
        else {
          if ( _cnt33>=1 ) { break _loop33; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt33++;
      } while (true);
      }
      structDeclaration_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_22);
      } else {
        throw ex;
      }
    }
    returnAST = structDeclaration_AST;
  }
  
  public final void specifierQualifierList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode specifierQualifierList_AST = null;
    int specCount = 0;
    
    try {      // for error handling
      {
      int _cnt38=0;
      _loop38:
      do {
        boolean synPredMatched37 = false;
        if (((_tokenSet_13.member(LA(1))) && (_tokenSet_23.member(LA(2))))) {
          int _m37 = mark();
          synPredMatched37 = true;
          inputState.guessing++;
          try {
            {
            if ((LA(1)==LITERAL_struct) && (true)) {
              match(LITERAL_struct);
            }
            else if ((LA(1)==LITERAL_union) && (true)) {
              match(LITERAL_union);
            }
            else if ((LA(1)==LITERAL_enum) && (true)) {
              match(LITERAL_enum);
            }
            else if ((_tokenSet_13.member(LA(1))) && (true)) {
              typeSpecifier(specCount);
            }
            else {
              throw new NoViableAltException(LT(1), getFilename());
            }
            
            }
          }
          catch (RecognitionException pe) {
            synPredMatched37 = false;
          }
          rewind(_m37);
          inputState.guessing--;
        }
        if ( synPredMatched37 ) {
          specCount=typeSpecifier(specCount);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else if ((LA(1)==LITERAL_volatile||LA(1)==LITERAL_const)) {
          typeQualifier();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt38>=1 ) { break _loop38; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt38++;
      } while (true);
      }
      specifierQualifierList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_24);
      } else {
        throw ex;
      }
    }
    returnAST = specifierQualifierList_AST;
  }
  
  public final void structDeclaratorList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structDeclaratorList_AST = null;
    
    try {      // for error handling
      structDeclarator();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop41:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          structDeclarator();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop41;
        }
        
      } while (true);
      }
      structDeclaratorList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_16);
      } else {
        throw ex;
      }
    }
    returnAST = structDeclaratorList_AST;
  }
  
  public final void structDeclarator() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode structDeclarator_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case COLON:
      {
        TNode tmp39_AST = null;
        tmp39_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp39_AST);
        match(COLON);
        constExpr();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case ID:
      case STAR:
      case LPAREN:
      {
        declarator(false);
        astFactory.addASTChild(currentAST, returnAST);
        {
        switch ( LA(1)) {
        case COLON:
        {
          TNode tmp40_AST = null;
          tmp40_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp40_AST);
          match(COLON);
          constExpr();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case SEMI:
        case COMMA:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        structDeclarator_AST = (TNode)currentAST.root;
        structDeclarator_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NStructDeclarator)).add(structDeclarator_AST));
        currentAST.root = structDeclarator_AST;
        currentAST.child = structDeclarator_AST!=null &&structDeclarator_AST.getFirstChild()!=null ?
          structDeclarator_AST.getFirstChild() : structDeclarator_AST;
        currentAST.advanceChildToEnd();
      }
      structDeclarator_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_25);
      } else {
        throw ex;
      }
    }
    returnAST = structDeclarator_AST;
  }
  
  public final void constExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode constExpr_AST = null;
    
    try {      // for error handling
      conditionalExpr();
      astFactory.addASTChild(currentAST, returnAST);
      constExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_26);
      } else {
        throw ex;
      }
    }
    returnAST = constExpr_AST;
  }
  
  public final String  declarator(
    boolean isFunctionDefinition
  ) throws RecognitionException, TokenStreamException {
    String declName;
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode declarator_AST = null;
    Token  id = null;
    TNode id_AST = null;
    TNode p_AST = null;
    TNode i_AST = null;
    declName = "";
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case STAR:
      {
        pointerGroup();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case ID:
      case LPAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case ID:
      {
        id = LT(1);
        id_AST = (TNode)astFactory.create(id);
        astFactory.addASTChild(currentAST, id_AST);
        match(ID);
        if ( inputState.guessing==0 ) {
          declName = id.getText();
        }
        break;
      }
      case LPAREN:
      {
        TNode tmp41_AST = null;
        tmp41_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp41_AST);
        match(LPAREN);
        declName=declarator(false);
        astFactory.addASTChild(currentAST, returnAST);
        TNode tmp42_AST = null;
        tmp42_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp42_AST);
        match(RPAREN);
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      _loop82:
      do {
        switch ( LA(1)) {
        case LPAREN:
        {
          TNode tmp43_AST = null;
          tmp43_AST = (TNode)astFactory.create(LT(1));
          match(LPAREN);
          if ( inputState.guessing==0 ) {
            
            if (isFunctionDefinition) {
            pushScope(declName);
            }
            else {
            pushScope("!"+declName); 
            }
            
          }
          {
          boolean synPredMatched79 = false;
          if (((_tokenSet_2.member(LA(1))) && (_tokenSet_27.member(LA(2))))) {
            int _m79 = mark();
            synPredMatched79 = true;
            inputState.guessing++;
            try {
              {
              declSpecifiers();
              }
            }
            catch (RecognitionException pe) {
              synPredMatched79 = false;
            }
            rewind(_m79);
            inputState.guessing--;
          }
          if ( synPredMatched79 ) {
            parameterTypeList();
            p_AST = (TNode)returnAST;
            if ( inputState.guessing==0 ) {
              declarator_AST = (TNode)currentAST.root;
              
              declarator_AST = (TNode)astFactory.make( (new ASTArray(3)).add(null).add(declarator_AST).add((TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NParameterTypeList)).add(p_AST))));
              
              currentAST.root = declarator_AST;
              currentAST.child = declarator_AST!=null &&declarator_AST.getFirstChild()!=null ?
                declarator_AST.getFirstChild() : declarator_AST;
              currentAST.advanceChildToEnd();
            }
          }
          else if ((LA(1)==ID||LA(1)==RPAREN) && (_tokenSet_28.member(LA(2)))) {
            {
            switch ( LA(1)) {
            case ID:
            {
              idList();
              i_AST = (TNode)returnAST;
              break;
            }
            case RPAREN:
            {
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            if ( inputState.guessing==0 ) {
              declarator_AST = (TNode)currentAST.root;
              
              declarator_AST = (TNode)astFactory.make( (new ASTArray(3)).add(null).add(declarator_AST).add((TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NParameterTypeList)).add(i_AST))));
              
              currentAST.root = declarator_AST;
              currentAST.child = declarator_AST!=null &&declarator_AST.getFirstChild()!=null ?
                declarator_AST.getFirstChild() : declarator_AST;
              currentAST.advanceChildToEnd();
            }
          }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
          
          }
          if ( inputState.guessing==0 ) {
            
            popScope();
            
          }
          TNode tmp44_AST = null;
          tmp44_AST = (TNode)astFactory.create(LT(1));
          match(RPAREN);
          break;
        }
        case LBRACKET:
        {
          TNode tmp45_AST = null;
          tmp45_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp45_AST);
          match(LBRACKET);
          {
          switch ( LA(1)) {
          case ID:
          case STAR:
          case LPAREN:
          case BAND:
          case PLUS:
          case MINUS:
          case INC:
          case DEC:
          case LITERAL_sizeof:
          case BNOT:
          case LNOT:
          case CharLiteral:
          case StringLiteral:
          case IntOctalConst:
          case LongOctalConst:
          case UnsignedOctalConst:
          case IntIntConst:
          case LongIntConst:
          case UnsignedIntConst:
          case IntHexConst:
          case LongHexConst:
          case UnsignedHexConst:
          case FloatDoubleConst:
          case DoubleDoubleConst:
          case LongDoubleConst:
          {
            constExpr();
            astFactory.addASTChild(currentAST, returnAST);
            break;
          }
          case RBRACKET:
          {
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          TNode tmp46_AST = null;
          tmp46_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp46_AST);
          match(RBRACKET);
          break;
        }
        default:
        {
          break _loop82;
        }
        }
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        declarator_AST = (TNode)currentAST.root;
        declarator_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NDeclarator)).add(declarator_AST));
        currentAST.root = declarator_AST;
        currentAST.child = declarator_AST!=null &&declarator_AST.getFirstChild()!=null ?
          declarator_AST.getFirstChild() : declarator_AST;
        currentAST.advanceChildToEnd();
      }
      declarator_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_29);
      } else {
        throw ex;
      }
    }
    returnAST = declarator_AST;
    return declName;
  }
  
  public final void enumList(
    String enumName
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode enumList_AST = null;
    
    try {      // for error handling
      enumerator(enumName);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop51:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          enumerator(enumName);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop51;
        }
        
      } while (true);
      }
      enumList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = enumList_AST;
  }
  
  public final void enumerator(
    String enumName
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode enumerator_AST = null;
    Token  i = null;
    TNode i_AST = null;
    
    try {      // for error handling
      i = LT(1);
      i_AST = (TNode)astFactory.create(i);
      astFactory.addASTChild(currentAST, i_AST);
      match(ID);
      if ( inputState.guessing==0 ) {
        symbolTable.add(  i.getText(),
        (TNode)astFactory.make( (new ASTArray(3)).add(null).add((TNode)astFactory.create(LITERAL_enum,"enum")).add((TNode)astFactory.create(ID,enumName)))
        );
        
      }
      {
      switch ( LA(1)) {
      case ASSIGN:
      {
        TNode tmp48_AST = null;
        tmp48_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp48_AST);
        match(ASSIGN);
        constExpr();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RCURLY:
      case COMMA:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      enumerator_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_30);
      } else {
        throw ex;
      }
    }
    returnAST = enumerator_AST;
  }
  
  public final void initDecl(
    AST declarationSpecifiers
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode initDecl_AST = null;
    TNode d_AST = null;
    String declName = "";
    
    try {      // for error handling
      declName=declarator(false);
      d_AST = (TNode)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        AST ds1, d1;
        ds1 = astFactory.dupList(declarationSpecifiers);
        d1 = astFactory.dupList(d_AST);
        symbolTable.add(declName, (TNode)astFactory.make( (new ASTArray(3)).add(null).add(ds1).add(d1)) );
        
      }
      {
      switch ( LA(1)) {
      case ASSIGN:
      {
        TNode tmp49_AST = null;
        tmp49_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp49_AST);
        match(ASSIGN);
        initializer();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case COLON:
      {
        TNode tmp50_AST = null;
        tmp50_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp50_AST);
        match(COLON);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case SEMI:
      case COMMA:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        initDecl_AST = (TNode)currentAST.root;
        initDecl_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NInitDecl)).add(initDecl_AST));
        currentAST.root = initDecl_AST;
        currentAST.child = initDecl_AST!=null &&initDecl_AST.getFirstChild()!=null ?
          initDecl_AST.getFirstChild() : initDecl_AST;
        currentAST.advanceChildToEnd();
      }
      initDecl_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_25);
      } else {
        throw ex;
      }
    }
    returnAST = initDecl_AST;
  }
  
  public final void initializer() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode initializer_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case ID:
      case STAR:
      case LPAREN:
      case BAND:
      case PLUS:
      case MINUS:
      case INC:
      case DEC:
      case LITERAL_sizeof:
      case BNOT:
      case LNOT:
      case CharLiteral:
      case StringLiteral:
      case IntOctalConst:
      case LongOctalConst:
      case UnsignedOctalConst:
      case IntIntConst:
      case LongIntConst:
      case UnsignedIntConst:
      case IntHexConst:
      case LongHexConst:
      case UnsignedHexConst:
      case FloatDoubleConst:
      case DoubleDoubleConst:
      case LongDoubleConst:
      {
        assignExpr();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case LCURLY:
      {
        TNode tmp51_AST = null;
        tmp51_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp51_AST);
        match(LCURLY);
        initializerList();
        astFactory.addASTChild(currentAST, returnAST);
        {
        switch ( LA(1)) {
        case COMMA:
        {
          match(COMMA);
          break;
        }
        case RCURLY:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        match(RCURLY);
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        initializer_AST = (TNode)currentAST.root;
        initializer_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NInitializer)).add(initializer_AST));
        currentAST.root = initializer_AST;
        currentAST.child = initializer_AST!=null &&initializer_AST.getFirstChild()!=null ?
          initializer_AST.getFirstChild() : initializer_AST;
        currentAST.advanceChildToEnd();
      }
      initializer_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_31);
      } else {
        throw ex;
      }
    }
    returnAST = initializer_AST;
  }
  
  public final void pointerGroup() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode pointerGroup_AST = null;
    
    try {      // for error handling
      {
      int _cnt63=0;
      _loop63:
      do {
        if ((LA(1)==STAR)) {
          TNode tmp54_AST = null;
          tmp54_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp54_AST);
          match(STAR);
          {
          _loop62:
          do {
            if ((LA(1)==LITERAL_volatile||LA(1)==LITERAL_const)) {
              typeQualifier();
              astFactory.addASTChild(currentAST, returnAST);
            }
            else {
              break _loop62;
            }
            
          } while (true);
          }
        }
        else {
          if ( _cnt63>=1 ) { break _loop63; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt63++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        pointerGroup_AST = (TNode)currentAST.root;
        pointerGroup_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NPointerGroup)).add(pointerGroup_AST));
        currentAST.root = pointerGroup_AST;
        currentAST.child = pointerGroup_AST!=null &&pointerGroup_AST.getFirstChild()!=null ?
          pointerGroup_AST.getFirstChild() : pointerGroup_AST;
        currentAST.advanceChildToEnd();
      }
      pointerGroup_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_32);
      } else {
        throw ex;
      }
    }
    returnAST = pointerGroup_AST;
  }
  
  public final void idList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode idList_AST = null;
    
    try {      // for error handling
      TNode tmp55_AST = null;
      tmp55_AST = (TNode)astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp55_AST);
      match(ID);
      {
      _loop66:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          TNode tmp57_AST = null;
          tmp57_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp57_AST);
          match(ID);
        }
        else {
          break _loop66;
        }
        
      } while (true);
      }
      idList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_33);
      } else {
        throw ex;
      }
    }
    returnAST = idList_AST;
  }
  
  public final void assignExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode assignExpr_AST = null;
    TNode a_AST = null;
    
    try {      // for error handling
      conditionalExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case ASSIGN:
      case DIV_ASSIGN:
      case PLUS_ASSIGN:
      case MINUS_ASSIGN:
      case STAR_ASSIGN:
      case MOD_ASSIGN:
      case RSHIFT_ASSIGN:
      case LSHIFT_ASSIGN:
      case BAND_ASSIGN:
      case BOR_ASSIGN:
      case BXOR_ASSIGN:
      {
        assignOperator();
        a_AST = (TNode)returnAST;
        assignExpr();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          assignExpr_AST = (TNode)currentAST.root;
          assignExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add(a_AST).add(assignExpr_AST));
          currentAST.root = assignExpr_AST;
          currentAST.child = assignExpr_AST!=null &&assignExpr_AST.getFirstChild()!=null ?
            assignExpr_AST.getFirstChild() : assignExpr_AST;
          currentAST.advanceChildToEnd();
        }
        break;
      }
      case RCURLY:
      case SEMI:
      case COMMA:
      case COLON:
      case RPAREN:
      case RBRACKET:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      assignExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_12);
      } else {
        throw ex;
      }
    }
    returnAST = assignExpr_AST;
  }
  
  public final void initializerList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode initializerList_AST = null;
    
    try {      // for error handling
      initializer();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop72:
      do {
        if ((LA(1)==COMMA) && (_tokenSet_34.member(LA(2)))) {
          match(COMMA);
          initializer();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop72;
        }
        
      } while (true);
      }
      initializerList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_30);
      } else {
        throw ex;
      }
    }
    returnAST = initializerList_AST;
  }
  
  public final void parameterTypeList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode parameterTypeList_AST = null;
    
    try {      // for error handling
      parameterDeclaration();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop85:
      do {
        if ((LA(1)==COMMA) && (_tokenSet_2.member(LA(2)))) {
          match(COMMA);
          parameterDeclaration();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop85;
        }
        
      } while (true);
      }
      {
      switch ( LA(1)) {
      case COMMA:
      {
        match(COMMA);
        TNode tmp61_AST = null;
        tmp61_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp61_AST);
        match(VARARGS);
        break;
      }
      case RPAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      parameterTypeList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_33);
      } else {
        throw ex;
      }
    }
    returnAST = parameterTypeList_AST;
  }
  
  public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode parameterDeclaration_AST = null;
    TNode ds_AST = null;
    TNode d_AST = null;
    String declName;
    
    try {      // for error handling
      declSpecifiers();
      ds_AST = (TNode)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      {
      boolean synPredMatched90 = false;
      if (((_tokenSet_10.member(LA(1))) && (_tokenSet_35.member(LA(2))))) {
        int _m90 = mark();
        synPredMatched90 = true;
        inputState.guessing++;
        try {
          {
          declarator(false);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched90 = false;
        }
        rewind(_m90);
        inputState.guessing--;
      }
      if ( synPredMatched90 ) {
        declName=declarator(false);
        d_AST = (TNode)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          
          AST d2, ds2;
          d2 = astFactory.dupList(d_AST);
          ds2 = astFactory.dupList(ds_AST);
          symbolTable.add(declName, (TNode)astFactory.make( (new ASTArray(3)).add(null).add(ds2).add(d2)));
          
        }
      }
      else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_37.member(LA(2)))) {
        nonemptyAbstractDeclarator();
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==COMMA||LA(1)==RPAREN)) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      if ( inputState.guessing==0 ) {
        parameterDeclaration_AST = (TNode)currentAST.root;
        
        parameterDeclaration_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NParameterDeclaration)).add(parameterDeclaration_AST));
        
        currentAST.root = parameterDeclaration_AST;
        currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
          parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
        currentAST.advanceChildToEnd();
      }
      parameterDeclaration_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = parameterDeclaration_AST;
  }
  
  public final void nonemptyAbstractDeclarator() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode nonemptyAbstractDeclarator_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case STAR:
      {
        pointerGroup();
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop184:
        do {
          switch ( LA(1)) {
          case LPAREN:
          {
            {
            TNode tmp62_AST = null;
            tmp62_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp62_AST);
            match(LPAREN);
            {
            switch ( LA(1)) {
            case STAR:
            case LPAREN:
            case LBRACKET:
            {
              nonemptyAbstractDeclarator();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case LITERAL_typedef:
            case LITERAL_volatile:
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_enum:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_extern:
            case LITERAL_static:
            case LITERAL_const:
            case LITERAL_void:
            case LITERAL_char:
            case LITERAL_short:
            case LITERAL_int:
            case LITERAL_long:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case ID:
            {
              parameterTypeList();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case RPAREN:
            {
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            TNode tmp63_AST = null;
            tmp63_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp63_AST);
            match(RPAREN);
            }
            break;
          }
          case LBRACKET:
          {
            {
            TNode tmp64_AST = null;
            tmp64_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp64_AST);
            match(LBRACKET);
            {
            switch ( LA(1)) {
            case ID:
            case STAR:
            case LPAREN:
            case BAND:
            case PLUS:
            case MINUS:
            case INC:
            case DEC:
            case LITERAL_sizeof:
            case BNOT:
            case LNOT:
            case CharLiteral:
            case StringLiteral:
            case IntOctalConst:
            case LongOctalConst:
            case UnsignedOctalConst:
            case IntIntConst:
            case LongIntConst:
            case UnsignedIntConst:
            case IntHexConst:
            case LongHexConst:
            case UnsignedHexConst:
            case FloatDoubleConst:
            case DoubleDoubleConst:
            case LongDoubleConst:
            {
              expr();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case RBRACKET:
            {
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            TNode tmp65_AST = null;
            tmp65_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp65_AST);
            match(RBRACKET);
            }
            break;
          }
          default:
          {
            break _loop184;
          }
          }
        } while (true);
        }
        break;
      }
      case LPAREN:
      case LBRACKET:
      {
        {
        int _cnt190=0;
        _loop190:
        do {
          switch ( LA(1)) {
          case LPAREN:
          {
            {
            TNode tmp66_AST = null;
            tmp66_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp66_AST);
            match(LPAREN);
            {
            switch ( LA(1)) {
            case STAR:
            case LPAREN:
            case LBRACKET:
            {
              nonemptyAbstractDeclarator();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case LITERAL_typedef:
            case LITERAL_volatile:
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_enum:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_extern:
            case LITERAL_static:
            case LITERAL_const:
            case LITERAL_void:
            case LITERAL_char:
            case LITERAL_short:
            case LITERAL_int:
            case LITERAL_long:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case ID:
            {
              parameterTypeList();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case RPAREN:
            {
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            TNode tmp67_AST = null;
            tmp67_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp67_AST);
            match(RPAREN);
            }
            break;
          }
          case LBRACKET:
          {
            {
            TNode tmp68_AST = null;
            tmp68_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp68_AST);
            match(LBRACKET);
            {
            switch ( LA(1)) {
            case ID:
            case STAR:
            case LPAREN:
            case BAND:
            case PLUS:
            case MINUS:
            case INC:
            case DEC:
            case LITERAL_sizeof:
            case BNOT:
            case LNOT:
            case CharLiteral:
            case StringLiteral:
            case IntOctalConst:
            case LongOctalConst:
            case UnsignedOctalConst:
            case IntIntConst:
            case LongIntConst:
            case UnsignedIntConst:
            case IntHexConst:
            case LongHexConst:
            case UnsignedHexConst:
            case FloatDoubleConst:
            case DoubleDoubleConst:
            case LongDoubleConst:
            {
              expr();
              astFactory.addASTChild(currentAST, returnAST);
              break;
            }
            case RBRACKET:
            {
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            TNode tmp69_AST = null;
            tmp69_AST = (TNode)astFactory.create(LT(1));
            astFactory.addASTChild(currentAST, tmp69_AST);
            match(RBRACKET);
            }
            break;
          }
          default:
          {
            if ( _cnt190>=1 ) { break _loop190; } else {throw new NoViableAltException(LT(1), getFilename());}
          }
          }
          _cnt190++;
        } while (true);
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        nonemptyAbstractDeclarator_AST = (TNode)currentAST.root;
        nonemptyAbstractDeclarator_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NNonemptyAbstractDeclarator)).add(nonemptyAbstractDeclarator_AST));
        currentAST.root = nonemptyAbstractDeclarator_AST;
        currentAST.child = nonemptyAbstractDeclarator_AST!=null &&nonemptyAbstractDeclarator_AST.getFirstChild()!=null ?
          nonemptyAbstractDeclarator_AST.getFirstChild() : nonemptyAbstractDeclarator_AST;
        currentAST.advanceChildToEnd();
      }
      nonemptyAbstractDeclarator_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = nonemptyAbstractDeclarator_AST;
  }
  
  public final void functionDeclSpecifiers() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode functionDeclSpecifiers_AST = null;
    int specCount = 0;
    
    try {      // for error handling
      {
      int _cnt104=0;
      _loop104:
      do {
        switch ( LA(1)) {
        case LITERAL_extern:
        case LITERAL_static:
        {
          functionStorageClassSpecifier();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case LITERAL_volatile:
        case LITERAL_const:
        {
          typeQualifier();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        default:
          boolean synPredMatched103 = false;
          if (((_tokenSet_13.member(LA(1))) && (_tokenSet_9.member(LA(2))))) {
            int _m103 = mark();
            synPredMatched103 = true;
            inputState.guessing++;
            try {
              {
              if ((LA(1)==LITERAL_struct) && (true)) {
                match(LITERAL_struct);
              }
              else if ((LA(1)==LITERAL_union) && (true)) {
                match(LITERAL_union);
              }
              else if ((LA(1)==LITERAL_enum) && (true)) {
                match(LITERAL_enum);
              }
              else if ((_tokenSet_13.member(LA(1))) && (true)) {
                typeSpecifier(specCount);
              }
              else {
                throw new NoViableAltException(LT(1), getFilename());
              }
              
              }
            }
            catch (RecognitionException pe) {
              synPredMatched103 = false;
            }
            rewind(_m103);
            inputState.guessing--;
          }
          if ( synPredMatched103 ) {
            specCount=typeSpecifier(specCount);
            astFactory.addASTChild(currentAST, returnAST);
          }
        else {
          if ( _cnt104>=1 ) { break _loop104; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        }
        _cnt104++;
      } while (true);
      }
      functionDeclSpecifiers_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_10);
      } else {
        throw ex;
      }
    }
    returnAST = functionDeclSpecifiers_AST;
  }
  
  public final void compoundStatement(
    String scopeName
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode compoundStatement_AST = null;
    
    try {      // for error handling
      match(LCURLY);
      if ( inputState.guessing==0 ) {
        
        pushScope(scopeName);
        
      }
      {
      boolean synPredMatched115 = false;
      if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
        int _m115 = mark();
        synPredMatched115 = true;
        inputState.guessing++;
        try {
          {
          declarationPredictor();
          }
        }
        catch (RecognitionException pe) {
          synPredMatched115 = false;
        }
        rewind(_m115);
        inputState.guessing--;
      }
      if ( synPredMatched115 ) {
        declarationList();
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      {
      switch ( LA(1)) {
      case LCURLY:
      case SEMI:
      case ID:
      case STAR:
      case LPAREN:
      case LITERAL_while:
      case LITERAL_do:
      case LITERAL_for:
      case LITERAL_goto:
      case LITERAL_continue:
      case LITERAL_break:
      case LITERAL_return:
      case LITERAL_case:
      case LITERAL_default:
      case LITERAL_if:
      case LITERAL_switch:
      case BAND:
      case PLUS:
      case MINUS:
      case INC:
      case DEC:
      case LITERAL_sizeof:
      case BNOT:
      case LNOT:
      case CharLiteral:
      case StringLiteral:
      case IntOctalConst:
      case LongOctalConst:
      case UnsignedOctalConst:
      case IntIntConst:
      case LongIntConst:
      case UnsignedIntConst:
      case IntHexConst:
      case LongHexConst:
      case UnsignedHexConst:
      case FloatDoubleConst:
      case DoubleDoubleConst:
      case LongDoubleConst:
      {
        statementList();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RCURLY:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        popScope();
      }
      match(RCURLY);
      if ( inputState.guessing==0 ) {
        compoundStatement_AST = (TNode)currentAST.root;
        compoundStatement_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NCompoundStatement,scopeName)).add(compoundStatement_AST));
        currentAST.root = compoundStatement_AST;
        currentAST.child = compoundStatement_AST!=null &&compoundStatement_AST.getFirstChild()!=null ?
          compoundStatement_AST.getFirstChild() : compoundStatement_AST;
        currentAST.advanceChildToEnd();
      }
      compoundStatement_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_41);
      } else {
        throw ex;
      }
    }
    returnAST = compoundStatement_AST;
  }
  
  public final void declarationList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode declarationList_AST = null;
    
    try {      // for error handling
      {
      int _cnt109=0;
      _loop109:
      do {
        boolean synPredMatched108 = false;
        if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
          int _m108 = mark();
          synPredMatched108 = true;
          inputState.guessing++;
          try {
            {
            declarationPredictor();
            }
          }
          catch (RecognitionException pe) {
            synPredMatched108 = false;
          }
          rewind(_m108);
          inputState.guessing--;
        }
        if ( synPredMatched108 ) {
          declaration();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt109>=1 ) { break _loop109; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt109++;
      } while (true);
      }
      declarationList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_39);
      } else {
        throw ex;
      }
    }
    returnAST = declarationList_AST;
  }
  
  public final void declarationPredictor() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode declarationPredictor_AST = null;
    
    try {      // for error handling
      {
      if ((LA(1)==LITERAL_typedef) && (LA(2)==EOF)) {
        TNode tmp72_AST = null;
        tmp72_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp72_AST);
        match(LITERAL_typedef);
      }
      else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
        declaration();
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      declarationPredictor_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = declarationPredictor_AST;
  }
  
  public final void statementList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode statementList_AST = null;
    
    try {      // for error handling
      {
      int _cnt119=0;
      _loop119:
      do {
        if ((_tokenSet_42.member(LA(1)))) {
          statement();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt119>=1 ) { break _loop119; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt119++;
      } while (true);
      }
      statementList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = statementList_AST;
  }
  
  public final void statement() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode statement_AST = null;
    TNode e1_AST = null;
    TNode e2_AST = null;
    TNode e3_AST = null;
    TNode s_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case SEMI:
      {
        TNode tmp73_AST = null;
        tmp73_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp73_AST);
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LCURLY:
      {
        compoundStatement(getAScopeName());
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_while:
      {
        TNode tmp74_AST = null;
        tmp74_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp74_AST);
        match(LITERAL_while);
        match(LPAREN);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_do:
      {
        TNode tmp77_AST = null;
        tmp77_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp77_AST);
        match(LITERAL_do);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        match(LITERAL_while);
        match(LPAREN);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_for:
      {
        match(LITERAL_for);
        TNode tmp83_AST = null;
        tmp83_AST = (TNode)astFactory.create(LT(1));
        match(LPAREN);
        {
        switch ( LA(1)) {
        case ID:
        case STAR:
        case LPAREN:
        case BAND:
        case PLUS:
        case MINUS:
        case INC:
        case DEC:
        case LITERAL_sizeof:
        case BNOT:
        case LNOT:
        case CharLiteral:
        case StringLiteral:
        case IntOctalConst:
        case LongOctalConst:
        case UnsignedOctalConst:
        case IntIntConst:
        case LongIntConst:
        case UnsignedIntConst:
        case IntHexConst:
        case LongHexConst:
        case UnsignedHexConst:
        case FloatDoubleConst:
        case DoubleDoubleConst:
        case LongDoubleConst:
        {
          expr();
          e1_AST = (TNode)returnAST;
          break;
        }
        case SEMI:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        TNode tmp84_AST = null;
        tmp84_AST = (TNode)astFactory.create(LT(1));
        match(SEMI);
        {
        switch ( LA(1)) {
        case ID:
        case STAR:
        case LPAREN:
        case BAND:
        case PLUS:
        case MINUS:
        case INC:
        case DEC:
        case LITERAL_sizeof:
        case BNOT:
        case LNOT:
        case CharLiteral:
        case StringLiteral:
        case IntOctalConst:
        case LongOctalConst:
        case UnsignedOctalConst:
        case IntIntConst:
        case LongIntConst:
        case UnsignedIntConst:
        case IntHexConst:
        case LongHexConst:
        case UnsignedHexConst:
        case FloatDoubleConst:
        case DoubleDoubleConst:
        case LongDoubleConst:
        {
          expr();
          e2_AST = (TNode)returnAST;
          break;
        }
        case SEMI:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        TNode tmp85_AST = null;
        tmp85_AST = (TNode)astFactory.create(LT(1));
        match(SEMI);
        {
        switch ( LA(1)) {
        case ID:
        case STAR:
        case LPAREN:
        case BAND:
        case PLUS:
        case MINUS:
        case INC:
        case DEC:
        case LITERAL_sizeof:
        case BNOT:
        case LNOT:
        case CharLiteral:
        case StringLiteral:
        case IntOctalConst:
        case LongOctalConst:
        case UnsignedOctalConst:
        case IntIntConst:
        case LongIntConst:
        case UnsignedIntConst:
        case IntHexConst:
        case LongHexConst:
        case UnsignedHexConst:
        case FloatDoubleConst:
        case DoubleDoubleConst:
        case LongDoubleConst:
        {
          expr();
          e3_AST = (TNode)returnAST;
          break;
        }
        case RPAREN:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        TNode tmp86_AST = null;
        tmp86_AST = (TNode)astFactory.create(LT(1));
        match(RPAREN);
        statement();
        s_AST = (TNode)returnAST;
        if ( inputState.guessing==0 ) {
          statement_AST = (TNode)currentAST.root;
          
          if ( e1_AST == null) { e1_AST = (TNode)astFactory.create(NEmptyExpression); }
          if ( e2_AST == null) { e2_AST = (TNode)astFactory.create(NEmptyExpression); }
          if ( e3_AST == null) { e3_AST = (TNode)astFactory.create(NEmptyExpression); }
          statement_AST = (TNode)astFactory.make( (new ASTArray(5)).add((TNode)astFactory.create(LITERAL_for,"for")).add(e1_AST).add(e2_AST).add(e3_AST).add(s_AST));
          
          currentAST.root = statement_AST;
          currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
            statement_AST.getFirstChild() : statement_AST;
          currentAST.advanceChildToEnd();
        }
        break;
      }
      case LITERAL_goto:
      {
        TNode tmp87_AST = null;
        tmp87_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp87_AST);
        match(LITERAL_goto);
        TNode tmp88_AST = null;
        tmp88_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp88_AST);
        match(ID);
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_continue:
      {
        TNode tmp90_AST = null;
        tmp90_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp90_AST);
        match(LITERAL_continue);
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_break:
      {
        TNode tmp92_AST = null;
        tmp92_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp92_AST);
        match(LITERAL_break);
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_return:
      {
        TNode tmp94_AST = null;
        tmp94_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp94_AST);
        match(LITERAL_return);
        {
        switch ( LA(1)) {
        case ID:
        case STAR:
        case LPAREN:
        case BAND:
        case PLUS:
        case MINUS:
        case INC:
        case DEC:
        case LITERAL_sizeof:
        case BNOT:
        case LNOT:
        case CharLiteral:
        case StringLiteral:
        case IntOctalConst:
        case LongOctalConst:
        case UnsignedOctalConst:
        case IntIntConst:
        case LongIntConst:
        case UnsignedIntConst:
        case IntHexConst:
        case LongHexConst:
        case UnsignedHexConst:
        case FloatDoubleConst:
        case DoubleDoubleConst:
        case LongDoubleConst:
        {
          expr();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case SEMI:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        match(SEMI);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_case:
      {
        TNode tmp96_AST = null;
        tmp96_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp96_AST);
        match(LITERAL_case);
        constExpr();
        astFactory.addASTChild(currentAST, returnAST);
        match(COLON);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_default:
      {
        TNode tmp98_AST = null;
        tmp98_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp98_AST);
        match(LITERAL_default);
        match(COLON);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_if:
      {
        TNode tmp100_AST = null;
        tmp100_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp100_AST);
        match(LITERAL_if);
        match(LPAREN);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        {
        if ((LA(1)==LITERAL_else) && (_tokenSet_42.member(LA(2)))) {
          TNode tmp103_AST = null;
          tmp103_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp103_AST);
          match(LITERAL_else);
          statement();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
        }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        
        }
        statement_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_switch:
      {
        TNode tmp104_AST = null;
        tmp104_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp104_AST);
        match(LITERAL_switch);
        match(LPAREN);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        statement();
        astFactory.addASTChild(currentAST, returnAST);
        statement_AST = (TNode)currentAST.root;
        break;
      }
      default:
        if ((_tokenSet_11.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
          expr();
          astFactory.addASTChild(currentAST, returnAST);
          match(SEMI);
          if ( inputState.guessing==0 ) {
            statement_AST = (TNode)currentAST.root;
            statement_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NStatementExpr)).add(statement_AST));
            currentAST.root = statement_AST;
            currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
              statement_AST.getFirstChild() : statement_AST;
            currentAST.advanceChildToEnd();
          }
          statement_AST = (TNode)currentAST.root;
        }
        else if ((LA(1)==ID) && (LA(2)==COLON)) {
          TNode tmp108_AST = null;
          tmp108_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp108_AST);
          match(ID);
          match(COLON);
          {
          if ((_tokenSet_42.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
            statement();
            astFactory.addASTChild(currentAST, returnAST);
          }
          else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
          }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
          
          }
          if ( inputState.guessing==0 ) {
            statement_AST = (TNode)currentAST.root;
            statement_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NLabel)).add(statement_AST));
            currentAST.root = statement_AST;
            currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
              statement_AST.getFirstChild() : statement_AST;
            currentAST.advanceChildToEnd();
          }
          statement_AST = (TNode)currentAST.root;
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_43);
      } else {
        throw ex;
      }
    }
    returnAST = statement_AST;
  }
  
  public final void conditionalExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode conditionalExpr_AST = null;
    
    try {      // for error handling
      logicalOrExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case QUESTION:
      {
        TNode tmp110_AST = null;
        tmp110_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp110_AST);
        match(QUESTION);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(COLON);
        conditionalExpr();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RCURLY:
      case SEMI:
      case COMMA:
      case COLON:
      case ASSIGN:
      case RPAREN:
      case RBRACKET:
      case DIV_ASSIGN:
      case PLUS_ASSIGN:
      case MINUS_ASSIGN:
      case STAR_ASSIGN:
      case MOD_ASSIGN:
      case RSHIFT_ASSIGN:
      case LSHIFT_ASSIGN:
      case BAND_ASSIGN:
      case BOR_ASSIGN:
      case BXOR_ASSIGN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      conditionalExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_46);
      } else {
        throw ex;
      }
    }
    returnAST = conditionalExpr_AST;
  }
  
  public final void assignOperator() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode assignOperator_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case ASSIGN:
      {
        TNode tmp112_AST = null;
        tmp112_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp112_AST);
        match(ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case DIV_ASSIGN:
      {
        TNode tmp113_AST = null;
        tmp113_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp113_AST);
        match(DIV_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case PLUS_ASSIGN:
      {
        TNode tmp114_AST = null;
        tmp114_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp114_AST);
        match(PLUS_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case MINUS_ASSIGN:
      {
        TNode tmp115_AST = null;
        tmp115_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp115_AST);
        match(MINUS_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case STAR_ASSIGN:
      {
        TNode tmp116_AST = null;
        tmp116_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp116_AST);
        match(STAR_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case MOD_ASSIGN:
      {
        TNode tmp117_AST = null;
        tmp117_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp117_AST);
        match(MOD_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case RSHIFT_ASSIGN:
      {
        TNode tmp118_AST = null;
        tmp118_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp118_AST);
        match(RSHIFT_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case LSHIFT_ASSIGN:
      {
        TNode tmp119_AST = null;
        tmp119_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp119_AST);
        match(LSHIFT_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case BAND_ASSIGN:
      {
        TNode tmp120_AST = null;
        tmp120_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp120_AST);
        match(BAND_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case BOR_ASSIGN:
      {
        TNode tmp121_AST = null;
        tmp121_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp121_AST);
        match(BOR_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      case BXOR_ASSIGN:
      {
        TNode tmp122_AST = null;
        tmp122_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp122_AST);
        match(BXOR_ASSIGN);
        assignOperator_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_11);
      } else {
        throw ex;
      }
    }
    returnAST = assignOperator_AST;
  }
  
  public final void logicalOrExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode logicalOrExpr_AST = null;
    
    try {      // for error handling
      logicalAndExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop138:
      do {
        if ((LA(1)==LOR)) {
          TNode tmp123_AST = null;
          tmp123_AST = (TNode)astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp123_AST);
          match(LOR);
          logicalAndExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop138;
        }
        
      } while (true);
      }
      logicalOrExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_47);
      } else {
        throw ex;
      }
    }
    returnAST = logicalOrExpr_AST;
  }
  
  public final void logicalAndExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode logicalAndExpr_AST = null;
    
    try {      // for error handling
      inclusiveOrExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop141:
      do {
        if ((LA(1)==LAND)) {
          TNode tmp124_AST = null;
          tmp124_AST = (TNode)astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp124_AST);
          match(LAND);
          inclusiveOrExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop141;
        }
        
      } while (true);
      }
      logicalAndExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_48);
      } else {
        throw ex;
      }
    }
    returnAST = logicalAndExpr_AST;
  }
  
  public final void inclusiveOrExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode inclusiveOrExpr_AST = null;
    
    try {      // for error handling
      exclusiveOrExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop144:
      do {
        if ((LA(1)==BOR)) {
          TNode tmp125_AST = null;
          tmp125_AST = (TNode)astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp125_AST);
          match(BOR);
          exclusiveOrExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop144;
        }
        
      } while (true);
      }
      inclusiveOrExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_49);
      } else {
        throw ex;
      }
    }
    returnAST = inclusiveOrExpr_AST;
  }
  
  public final void exclusiveOrExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode exclusiveOrExpr_AST = null;
    
    try {      // for error handling
      bitAndExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop147:
      do {
        if ((LA(1)==BXOR)) {
          TNode tmp126_AST = null;
          tmp126_AST = (TNode)astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp126_AST);
          match(BXOR);
          bitAndExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop147;
        }
        
      } while (true);
      }
      exclusiveOrExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_50);
      } else {
        throw ex;
      }
    }
    returnAST = exclusiveOrExpr_AST;
  }
  
  public final void bitAndExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode bitAndExpr_AST = null;
    
    try {      // for error handling
      equalityExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop150:
      do {
        if ((LA(1)==BAND)) {
          TNode tmp127_AST = null;
          tmp127_AST = (TNode)astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp127_AST);
          match(BAND);
          equalityExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop150;
        }
        
      } while (true);
      }
      bitAndExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_51);
      } else {
        throw ex;
      }
    }
    returnAST = bitAndExpr_AST;
  }
  
  public final void equalityExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode equalityExpr_AST = null;
    
    try {      // for error handling
      relationalExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop154:
      do {
        if ((LA(1)==EQUAL||LA(1)==NOT_EQUAL)) {
          {
          switch ( LA(1)) {
          case EQUAL:
          {
            TNode tmp128_AST = null;
            tmp128_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp128_AST);
            match(EQUAL);
            break;
          }
          case NOT_EQUAL:
          {
            TNode tmp129_AST = null;
            tmp129_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp129_AST);
            match(NOT_EQUAL);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          relationalExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop154;
        }
        
      } while (true);
      }
      equalityExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_52);
      } else {
        throw ex;
      }
    }
    returnAST = equalityExpr_AST;
  }
  
  public final void relationalExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode relationalExpr_AST = null;
    
    try {      // for error handling
      shiftExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop158:
      do {
        if (((LA(1) >= LT && LA(1) <= GTE))) {
          {
          switch ( LA(1)) {
          case LT:
          {
            TNode tmp130_AST = null;
            tmp130_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp130_AST);
            match(LT);
            break;
          }
          case LTE:
          {
            TNode tmp131_AST = null;
            tmp131_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp131_AST);
            match(LTE);
            break;
          }
          case GT:
          {
            TNode tmp132_AST = null;
            tmp132_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp132_AST);
            match(GT);
            break;
          }
          case GTE:
          {
            TNode tmp133_AST = null;
            tmp133_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp133_AST);
            match(GTE);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          shiftExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop158;
        }
        
      } while (true);
      }
      relationalExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_53);
      } else {
        throw ex;
      }
    }
    returnAST = relationalExpr_AST;
  }
  
  public final void shiftExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode shiftExpr_AST = null;
    
    try {      // for error handling
      additiveExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop162:
      do {
        if ((LA(1)==LSHIFT||LA(1)==RSHIFT)) {
          {
          switch ( LA(1)) {
          case LSHIFT:
          {
            TNode tmp134_AST = null;
            tmp134_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp134_AST);
            match(LSHIFT);
            break;
          }
          case RSHIFT:
          {
            TNode tmp135_AST = null;
            tmp135_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp135_AST);
            match(RSHIFT);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          additiveExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop162;
        }
        
      } while (true);
      }
      shiftExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_54);
      } else {
        throw ex;
      }
    }
    returnAST = shiftExpr_AST;
  }
  
  public final void additiveExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode additiveExpr_AST = null;
    
    try {      // for error handling
      multExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop166:
      do {
        if ((LA(1)==PLUS||LA(1)==MINUS)) {
          {
          switch ( LA(1)) {
          case PLUS:
          {
            TNode tmp136_AST = null;
            tmp136_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp136_AST);
            match(PLUS);
            break;
          }
          case MINUS:
          {
            TNode tmp137_AST = null;
            tmp137_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp137_AST);
            match(MINUS);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          multExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop166;
        }
        
      } while (true);
      }
      additiveExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_55);
      } else {
        throw ex;
      }
    }
    returnAST = additiveExpr_AST;
  }
  
  public final void multExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode multExpr_AST = null;
    
    try {      // for error handling
      castExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop170:
      do {
        if ((_tokenSet_56.member(LA(1)))) {
          {
          switch ( LA(1)) {
          case STAR:
          {
            TNode tmp138_AST = null;
            tmp138_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp138_AST);
            match(STAR);
            break;
          }
          case DIV:
          {
            TNode tmp139_AST = null;
            tmp139_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp139_AST);
            match(DIV);
            break;
          }
          case MOD:
          {
            TNode tmp140_AST = null;
            tmp140_AST = (TNode)astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp140_AST);
            match(MOD);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          castExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop170;
        }
        
      } while (true);
      }
      multExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_57);
      } else {
        throw ex;
      }
    }
    returnAST = multExpr_AST;
  }
  
  public final void castExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode castExpr_AST = null;
    
    try {      // for error handling
      boolean synPredMatched173 = false;
      if (((LA(1)==LPAREN) && (_tokenSet_20.member(LA(2))))) {
        int _m173 = mark();
        synPredMatched173 = true;
        inputState.guessing++;
        try {
          {
          match(LPAREN);
          typeName();
          match(RPAREN);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched173 = false;
        }
        rewind(_m173);
        inputState.guessing--;
      }
      if ( synPredMatched173 ) {
        match(LPAREN);
        typeName();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        {
        castExpr();
        astFactory.addASTChild(currentAST, returnAST);
        }
        if ( inputState.guessing==0 ) {
          castExpr_AST = (TNode)currentAST.root;
          castExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NCast,"(")).add(castExpr_AST));
          currentAST.root = castExpr_AST;
          currentAST.child = castExpr_AST!=null &&castExpr_AST.getFirstChild()!=null ?
            castExpr_AST.getFirstChild() : castExpr_AST;
          currentAST.advanceChildToEnd();
        }
        castExpr_AST = (TNode)currentAST.root;
      }
      else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
        unaryExpr();
        astFactory.addASTChild(currentAST, returnAST);
        castExpr_AST = (TNode)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_59);
      } else {
        throw ex;
      }
    }
    returnAST = castExpr_AST;
  }
  
  public final void typeName() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode typeName_AST = null;
    
    try {      // for error handling
      specifierQualifierList();
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case STAR:
      case LPAREN:
      case LBRACKET:
      {
        nonemptyAbstractDeclarator();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RPAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      typeName_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_33);
      } else {
        throw ex;
      }
    }
    returnAST = typeName_AST;
  }
  
  public final void unaryExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode unaryExpr_AST = null;
    TNode u_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case ID:
      case LPAREN:
      case CharLiteral:
      case StringLiteral:
      case IntOctalConst:
      case LongOctalConst:
      case UnsignedOctalConst:
      case IntIntConst:
      case LongIntConst:
      case UnsignedIntConst:
      case IntHexConst:
      case LongHexConst:
      case UnsignedHexConst:
      case FloatDoubleConst:
      case DoubleDoubleConst:
      case LongDoubleConst:
      {
        postfixExpr();
        astFactory.addASTChild(currentAST, returnAST);
        unaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case INC:
      {
        TNode tmp143_AST = null;
        tmp143_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp143_AST);
        match(INC);
        unaryExpr();
        astFactory.addASTChild(currentAST, returnAST);
        unaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case DEC:
      {
        TNode tmp144_AST = null;
        tmp144_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp144_AST);
        match(DEC);
        unaryExpr();
        astFactory.addASTChild(currentAST, returnAST);
        unaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case STAR:
      case BAND:
      case PLUS:
      case MINUS:
      case BNOT:
      case LNOT:
      {
        unaryOperator();
        u_AST = (TNode)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
        castExpr();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          unaryExpr_AST = (TNode)currentAST.root;
          unaryExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NUnaryExpr)).add(unaryExpr_AST));
          currentAST.root = unaryExpr_AST;
          currentAST.child = unaryExpr_AST!=null &&unaryExpr_AST.getFirstChild()!=null ?
            unaryExpr_AST.getFirstChild() : unaryExpr_AST;
          currentAST.advanceChildToEnd();
        }
        unaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case LITERAL_sizeof:
      {
        TNode tmp145_AST = null;
        tmp145_AST = (TNode)astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp145_AST);
        match(LITERAL_sizeof);
        {
        boolean synPredMatched194 = false;
        if (((LA(1)==LPAREN) && (_tokenSet_20.member(LA(2))))) {
          int _m194 = mark();
          synPredMatched194 = true;
          inputState.guessing++;
          try {
            {
            match(LPAREN);
            typeName();
            }
          }
          catch (RecognitionException pe) {
            synPredMatched194 = false;
          }
          rewind(_m194);
          inputState.guessing--;
        }
        if ( synPredMatched194 ) {
          TNode tmp146_AST = null;
          tmp146_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp146_AST);
          match(LPAREN);
          typeName();
          astFactory.addASTChild(currentAST, returnAST);
          TNode tmp147_AST = null;
          tmp147_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp147_AST);
          match(RPAREN);
        }
        else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
          unaryExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        
        }
        unaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_59);
      } else {
        throw ex;
      }
    }
    returnAST = unaryExpr_AST;
  }
  
  public final void postfixExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode postfixExpr_AST = null;
    
    try {      // for error handling
      primaryExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case LPAREN:
      case LBRACKET:
      case INC:
      case DEC:
      case PTR:
      case DOT:
      {
        postfixSuffix();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          postfixExpr_AST = (TNode)currentAST.root;
          postfixExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NPostfixExpr)).add(postfixExpr_AST));
          currentAST.root = postfixExpr_AST;
          currentAST.child = postfixExpr_AST!=null &&postfixExpr_AST.getFirstChild()!=null ?
            postfixExpr_AST.getFirstChild() : postfixExpr_AST;
          currentAST.advanceChildToEnd();
        }
        break;
      }
      case RCURLY:
      case SEMI:
      case COMMA:
      case COLON:
      case ASSIGN:
      case STAR:
      case RPAREN:
      case RBRACKET:
      case DIV_ASSIGN:
      case PLUS_ASSIGN:
      case MINUS_ASSIGN:
      case STAR_ASSIGN:
      case MOD_ASSIGN:
      case RSHIFT_ASSIGN:
      case LSHIFT_ASSIGN:
      case BAND_ASSIGN:
      case BOR_ASSIGN:
      case BXOR_ASSIGN:
      case QUESTION:
      case LOR:
      case LAND:
      case BOR:
      case BXOR:
      case BAND:
      case EQUAL:
      case NOT_EQUAL:
      case LT:
      case LTE:
      case GT:
      case GTE:
      case LSHIFT:
      case RSHIFT:
      case PLUS:
      case MINUS:
      case DIV:
      case MOD:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      postfixExpr_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_59);
      } else {
        throw ex;
      }
    }
    returnAST = postfixExpr_AST;
  }
  
  public final void unaryOperator() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode unaryOperator_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case BAND:
      {
        TNode tmp148_AST = null;
        tmp148_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp148_AST);
        match(BAND);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      case STAR:
      {
        TNode tmp149_AST = null;
        tmp149_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp149_AST);
        match(STAR);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      case PLUS:
      {
        TNode tmp150_AST = null;
        tmp150_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp150_AST);
        match(PLUS);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      case MINUS:
      {
        TNode tmp151_AST = null;
        tmp151_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp151_AST);
        match(MINUS);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      case BNOT:
      {
        TNode tmp152_AST = null;
        tmp152_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp152_AST);
        match(BNOT);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      case LNOT:
      {
        TNode tmp153_AST = null;
        tmp153_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp153_AST);
        match(LNOT);
        unaryOperator_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_11);
      } else {
        throw ex;
      }
    }
    returnAST = unaryOperator_AST;
  }
  
  public final void primaryExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode primaryExpr_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case ID:
      {
        TNode tmp154_AST = null;
        tmp154_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp154_AST);
        match(ID);
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case CharLiteral:
      {
        charConst();
        astFactory.addASTChild(currentAST, returnAST);
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case IntOctalConst:
      case LongOctalConst:
      case UnsignedOctalConst:
      case IntIntConst:
      case LongIntConst:
      case UnsignedIntConst:
      case IntHexConst:
      case LongHexConst:
      case UnsignedHexConst:
      {
        intConst();
        astFactory.addASTChild(currentAST, returnAST);
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case FloatDoubleConst:
      case DoubleDoubleConst:
      case LongDoubleConst:
      {
        floatConst();
        astFactory.addASTChild(currentAST, returnAST);
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case StringLiteral:
      {
        stringConst();
        astFactory.addASTChild(currentAST, returnAST);
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      case LPAREN:
      {
        match(LPAREN);
        expr();
        astFactory.addASTChild(currentAST, returnAST);
        match(RPAREN);
        if ( inputState.guessing==0 ) {
          primaryExpr_AST = (TNode)currentAST.root;
          primaryExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NExpressionGroup,"(")).add(primaryExpr_AST));
          currentAST.root = primaryExpr_AST;
          currentAST.child = primaryExpr_AST!=null &&primaryExpr_AST.getFirstChild()!=null ?
            primaryExpr_AST.getFirstChild() : primaryExpr_AST;
          currentAST.advanceChildToEnd();
        }
        primaryExpr_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = primaryExpr_AST;
  }
  
  public final void postfixSuffix() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode postfixSuffix_AST = null;
    
    try {      // for error handling
      {
      int _cnt200=0;
      _loop200:
      do {
        switch ( LA(1)) {
        case PTR:
        {
          TNode tmp157_AST = null;
          tmp157_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp157_AST);
          match(PTR);
          TNode tmp158_AST = null;
          tmp158_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp158_AST);
          match(ID);
          break;
        }
        case DOT:
        {
          TNode tmp159_AST = null;
          tmp159_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp159_AST);
          match(DOT);
          TNode tmp160_AST = null;
          tmp160_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp160_AST);
          match(ID);
          break;
        }
        case LPAREN:
        {
          functionCall();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case LBRACKET:
        {
          TNode tmp161_AST = null;
          tmp161_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp161_AST);
          match(LBRACKET);
          expr();
          astFactory.addASTChild(currentAST, returnAST);
          TNode tmp162_AST = null;
          tmp162_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp162_AST);
          match(RBRACKET);
          break;
        }
        case INC:
        {
          TNode tmp163_AST = null;
          tmp163_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp163_AST);
          match(INC);
          break;
        }
        case DEC:
        {
          TNode tmp164_AST = null;
          tmp164_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp164_AST);
          match(DEC);
          break;
        }
        default:
        {
          if ( _cnt200>=1 ) { break _loop200; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        }
        _cnt200++;
      } while (true);
      }
      postfixSuffix_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_59);
      } else {
        throw ex;
      }
    }
    returnAST = postfixSuffix_AST;
  }
  
  public final void functionCall() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode functionCall_AST = null;
    TNode a_AST = null;
    
    try {      // for error handling
      TNode tmp165_AST = null;
      tmp165_AST = (TNode)astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp165_AST);
      match(LPAREN);
      {
      switch ( LA(1)) {
      case ID:
      case STAR:
      case LPAREN:
      case BAND:
      case PLUS:
      case MINUS:
      case INC:
      case DEC:
      case LITERAL_sizeof:
      case BNOT:
      case LNOT:
      case CharLiteral:
      case StringLiteral:
      case IntOctalConst:
      case LongOctalConst:
      case UnsignedOctalConst:
      case IntIntConst:
      case LongIntConst:
      case UnsignedIntConst:
      case IntHexConst:
      case LongHexConst:
      case UnsignedHexConst:
      case FloatDoubleConst:
      case DoubleDoubleConst:
      case LongDoubleConst:
      {
        argExprList();
        a_AST = (TNode)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RPAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      TNode tmp166_AST = null;
      tmp166_AST = (TNode)astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp166_AST);
      match(RPAREN);
      if ( inputState.guessing==0 ) {
        functionCall_AST = (TNode)currentAST.root;
        
        functionCall_AST.setType( NFunctionCallArgs );
        
      }
      functionCall_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = functionCall_AST;
  }
  
  public final void argExprList() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode argExprList_AST = null;
    
    try {      // for error handling
      assignExpr();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop206:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          assignExpr();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop206;
        }
        
      } while (true);
      }
      argExprList_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_33);
      } else {
        throw ex;
      }
    }
    returnAST = argExprList_AST;
  }
  
  protected final void charConst() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode charConst_AST = null;
    
    try {      // for error handling
      TNode tmp168_AST = null;
      tmp168_AST = (TNode)astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp168_AST);
      match(CharLiteral);
      charConst_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = charConst_AST;
  }
  
  protected final void intConst() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode intConst_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case IntOctalConst:
      {
        TNode tmp169_AST = null;
        tmp169_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp169_AST);
        match(IntOctalConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case LongOctalConst:
      {
        TNode tmp170_AST = null;
        tmp170_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp170_AST);
        match(LongOctalConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case UnsignedOctalConst:
      {
        TNode tmp171_AST = null;
        tmp171_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp171_AST);
        match(UnsignedOctalConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case IntIntConst:
      {
        TNode tmp172_AST = null;
        tmp172_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp172_AST);
        match(IntIntConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case LongIntConst:
      {
        TNode tmp173_AST = null;
        tmp173_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp173_AST);
        match(LongIntConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case UnsignedIntConst:
      {
        TNode tmp174_AST = null;
        tmp174_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp174_AST);
        match(UnsignedIntConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case IntHexConst:
      {
        TNode tmp175_AST = null;
        tmp175_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp175_AST);
        match(IntHexConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case LongHexConst:
      {
        TNode tmp176_AST = null;
        tmp176_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp176_AST);
        match(LongHexConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      case UnsignedHexConst:
      {
        TNode tmp177_AST = null;
        tmp177_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp177_AST);
        match(UnsignedHexConst);
        intConst_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = intConst_AST;
  }
  
  protected final void floatConst() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode floatConst_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case FloatDoubleConst:
      {
        TNode tmp178_AST = null;
        tmp178_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp178_AST);
        match(FloatDoubleConst);
        floatConst_AST = (TNode)currentAST.root;
        break;
      }
      case DoubleDoubleConst:
      {
        TNode tmp179_AST = null;
        tmp179_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp179_AST);
        match(DoubleDoubleConst);
        floatConst_AST = (TNode)currentAST.root;
        break;
      }
      case LongDoubleConst:
      {
        TNode tmp180_AST = null;
        tmp180_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp180_AST);
        match(LongDoubleConst);
        floatConst_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = floatConst_AST;
  }
  
  protected final void stringConst() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode stringConst_AST = null;
    
    try {      // for error handling
      {
      int _cnt210=0;
      _loop210:
      do {
        if ((LA(1)==StringLiteral)) {
          TNode tmp181_AST = null;
          tmp181_AST = (TNode)astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp181_AST);
          match(StringLiteral);
        }
        else {
          if ( _cnt210>=1 ) { break _loop210; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt210++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        stringConst_AST = (TNode)currentAST.root;
        stringConst_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NStringSeq)).add(stringConst_AST));
        currentAST.root = stringConst_AST;
        currentAST.child = stringConst_AST!=null &&stringConst_AST.getFirstChild()!=null ?
          stringConst_AST.getFirstChild() : stringConst_AST;
        currentAST.advanceChildToEnd();
      }
      stringConst_AST = (TNode)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = stringConst_AST;
  }
  
  public final void dummy() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    TNode dummy_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case NTypedefName:
      {
        TNode tmp182_AST = null;
        tmp182_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp182_AST);
        match(NTypedefName);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NInitDecl:
      {
        TNode tmp183_AST = null;
        tmp183_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp183_AST);
        match(NInitDecl);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NDeclarator:
      {
        TNode tmp184_AST = null;
        tmp184_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp184_AST);
        match(NDeclarator);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NStructDeclarator:
      {
        TNode tmp185_AST = null;
        tmp185_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp185_AST);
        match(NStructDeclarator);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NDeclaration:
      {
        TNode tmp186_AST = null;
        tmp186_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp186_AST);
        match(NDeclaration);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NCast:
      {
        TNode tmp187_AST = null;
        tmp187_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp187_AST);
        match(NCast);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NPointerGroup:
      {
        TNode tmp188_AST = null;
        tmp188_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp188_AST);
        match(NPointerGroup);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NExpressionGroup:
      {
        TNode tmp189_AST = null;
        tmp189_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp189_AST);
        match(NExpressionGroup);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NFunctionCallArgs:
      {
        TNode tmp190_AST = null;
        tmp190_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp190_AST);
        match(NFunctionCallArgs);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NNonemptyAbstractDeclarator:
      {
        TNode tmp191_AST = null;
        tmp191_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp191_AST);
        match(NNonemptyAbstractDeclarator);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NInitializer:
      {
        TNode tmp192_AST = null;
        tmp192_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp192_AST);
        match(NInitializer);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NStatementExpr:
      {
        TNode tmp193_AST = null;
        tmp193_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp193_AST);
        match(NStatementExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NEmptyExpression:
      {
        TNode tmp194_AST = null;
        tmp194_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp194_AST);
        match(NEmptyExpression);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NParameterTypeList:
      {
        TNode tmp195_AST = null;
        tmp195_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp195_AST);
        match(NParameterTypeList);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NFunctionDef:
      {
        TNode tmp196_AST = null;
        tmp196_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp196_AST);
        match(NFunctionDef);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NCompoundStatement:
      {
        TNode tmp197_AST = null;
        tmp197_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp197_AST);
        match(NCompoundStatement);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NParameterDeclaration:
      {
        TNode tmp198_AST = null;
        tmp198_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp198_AST);
        match(NParameterDeclaration);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NCommaExpr:
      {
        TNode tmp199_AST = null;
        tmp199_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp199_AST);
        match(NCommaExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NUnaryExpr:
      {
        TNode tmp200_AST = null;
        tmp200_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp200_AST);
        match(NUnaryExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NLabel:
      {
        TNode tmp201_AST = null;
        tmp201_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp201_AST);
        match(NLabel);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NPostfixExpr:
      {
        TNode tmp202_AST = null;
        tmp202_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp202_AST);
        match(NPostfixExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NRangeExpr:
      {
        TNode tmp203_AST = null;
        tmp203_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp203_AST);
        match(NRangeExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NStringSeq:
      {
        TNode tmp204_AST = null;
        tmp204_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp204_AST);
        match(NStringSeq);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NInitializerElementLabel:
      {
        TNode tmp205_AST = null;
        tmp205_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp205_AST);
        match(NInitializerElementLabel);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NLcurlyInitializer:
      {
        TNode tmp206_AST = null;
        tmp206_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp206_AST);
        match(NLcurlyInitializer);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NAsmAttribute:
      {
        TNode tmp207_AST = null;
        tmp207_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp207_AST);
        match(NAsmAttribute);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NGnuAsmExpr:
      {
        TNode tmp208_AST = null;
        tmp208_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp208_AST);
        match(NGnuAsmExpr);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      case NTypeMissing:
      {
        TNode tmp209_AST = null;
        tmp209_AST = (TNode)astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp209_AST);
        match(NTypeMissing);
        dummy_AST = (TNode)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = dummy_AST;
  }
  
  
  public static final String[] _tokenNames = {
    "<0>",
    "EOF",
    "<2>",
    "NULL_TREE_LOOKAHEAD",
    "\"typedef\"",
    "\"asm\"",
    "\"volatile\"",
    "LCURLY",
    "RCURLY",
    "SEMI",
    "\"struct\"",
    "\"union\"",
    "\"enum\"",
    "\"auto\"",
    "\"register\"",
    "\"extern\"",
    "\"static\"",
    "\"const\"",
    "\"void\"",
    "\"char\"",
    "\"short\"",
    "\"int\"",
    "\"long\"",
    "\"float\"",
    "\"double\"",
    "\"signed\"",
    "\"unsigned\"",
    "ID",
    "COMMA",
    "COLON",
    "ASSIGN",
    "STAR",
    "LPAREN",
    "RPAREN",
    "LBRACKET",
    "RBRACKET",
    "VARARGS",
    "\"while\"",
    "\"do\"",
    "\"for\"",
    "\"goto\"",
    "\"continue\"",
    "\"break\"",
    "\"return\"",
    "\"case\"",
    "\"default\"",
    "\"if\"",
    "\"else\"",
    "\"switch\"",
    "DIV_ASSIGN",
    "PLUS_ASSIGN",
    "MINUS_ASSIGN",
    "STAR_ASSIGN",
    "MOD_ASSIGN",
    "RSHIFT_ASSIGN",
    "LSHIFT_ASSIGN",
    "BAND_ASSIGN",
    "BOR_ASSIGN",
    "BXOR_ASSIGN",
    "QUESTION",
    "LOR",
    "LAND",
    "BOR",
    "BXOR",
    "BAND",
    "EQUAL",
    "NOT_EQUAL",
    "LT",
    "LTE",
    "GT",
    "GTE",
    "LSHIFT",
    "RSHIFT",
    "PLUS",
    "MINUS",
    "DIV",
    "MOD",
    "INC",
    "DEC",
    "\"sizeof\"",
    "BNOT",
    "LNOT",
    "PTR",
    "DOT",
    "CharLiteral",
    "StringLiteral",
    "IntOctalConst",
    "LongOctalConst",
    "UnsignedOctalConst",
    "IntIntConst",
    "LongIntConst",
    "UnsignedIntConst",
    "IntHexConst",
    "LongHexConst",
    "UnsignedHexConst",
    "FloatDoubleConst",
    "DoubleDoubleConst",
    "LongDoubleConst",
    "NTypedefName",
    "NInitDecl",
    "NDeclarator",
    "NStructDeclarator",
    "NDeclaration",
    "NCast",
    "NPointerGroup",
    "NExpressionGroup",
    "NFunctionCallArgs",
    "NNonemptyAbstractDeclarator",
    "NInitializer",
    "NStatementExpr",
    "NEmptyExpression",
    "NParameterTypeList",
    "NFunctionDef",
    "NCompoundStatement",
    "NParameterDeclaration",
    "NCommaExpr",
    "NUnaryExpr",
    "NLabel",
    "NPostfixExpr",
    "NRangeExpr",
    "NStringSeq",
    "NInitializerElementLabel",
    "NLcurlyInitializer",
    "NAsmAttribute",
    "NGnuAsmExpr",
    "NTypeMissing",
    "Vocabulary",
    "Whitespace",
    "Comment",
    "CPPComment",
    "a line directive",
    "Space",
    "LineDirective",
    "BadStringLiteral",
    "Escape",
    "Digit",
    "LongSuffix",
    "UnsignedSuffix",
    "FloatSuffix",
    "Exponent",
    "Number"
  };
  
  protected void buildTokenTypeASTClassMap() {
    tokenTypeToASTClassMap=null;
  };
  
  private static final long[] mk_tokenSet_0() {
    long[] data = { 2L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
  private static final long[] mk_tokenSet_1() {
    long[] data = { 6710885488L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
  private static final long[] mk_tokenSet_2() {
    long[] data = { 268434512L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
  private static final long[] mk_tokenSet_3() {
    long[] data = { 6710886096L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
  private static final long[] mk_tokenSet_4() {
    long[] data = { 6710860864L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
  private static final long[] mk_tokenSet_5() {
    long[] data = { 92610232016L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
  private static final long[] mk_tokenSet_6() {
    long[] data = { 6710885490L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
  private static final long[] mk_tokenSet_7() {
    long[] data = { 422150456475634L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
  private static final long[] mk_tokenSet_8() {
    long[] data = { 268409920L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
  private static final long[] mk_tokenSet_9() {
    long[] data = { 6710860992L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
  private static final long[] mk_tokenSet_10() {
    long[] data = { 6576668672L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
  private static final long[] mk_tokenSet_11() {
    long[] data = { 6576668672L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
  private static final long[] mk_tokenSet_12() {
    long[] data = { 43754980096L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
  private static final long[] mk_tokenSet_13() {
    long[] data = { 268180480L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
  private static final long[] mk_tokenSet_14() {
    long[] data = { 32749125328L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
  private static final long[] mk_tokenSet_15() {
    long[] data = { 32614908416L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
  private static final long[] mk_tokenSet_16() {
    long[] data = { 512L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
  private static final long[] mk_tokenSet_17() {
    long[] data = { 32749125200L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
  private static final long[] mk_tokenSet_18() {
    long[] data = { 33285996112L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
  private static final long[] mk_tokenSet_19() {
    long[] data = { 134217856L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
  private static final long[] mk_tokenSet_20() {
    long[] data = { 268311616L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
  private static final long[] mk_tokenSet_21() {
    long[] data = { 256L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
  private static final long[] mk_tokenSet_22() {
    long[] data = { 268311872L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
  private static final long[] mk_tokenSet_23() {
    long[] data = { 33017437376L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
  private static final long[] mk_tokenSet_24() {
    long[] data = { 32883343360L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
  private static final long[] mk_tokenSet_25() {
    long[] data = { 268435968L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
  private static final long[] mk_tokenSet_26() {
    long[] data = { 35165045504L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
  private static final long[] mk_tokenSet_27() {
    long[] data = { 32749124816L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
  private static final long[] mk_tokenSet_28() {
    long[] data = { 100931731152L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
  private static final long[] mk_tokenSet_29() {
    long[] data = { 79456894672L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
  private static final long[] mk_tokenSet_30() {
    long[] data = { 268435712L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
  private static final long[] mk_tokenSet_31() {
    long[] data = { 268436224L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
  private static final long[] mk_tokenSet_32() {
    long[] data = { 30467424256L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
  private static final long[] mk_tokenSet_33() {
    long[] data = { 8589934592L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
  private static final long[] mk_tokenSet_34() {
    long[] data = { 6576668800L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
  private static final long[] mk_tokenSet_35() {
    long[] data = { 32615039040L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
  private static final long[] mk_tokenSet_36() {
    long[] data = { 23622320128L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
  private static final long[] mk_tokenSet_37() {
    long[] data = { 67108863056L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
  private static final long[] mk_tokenSet_38() {
    long[] data = { 8858370048L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
  private static final long[] mk_tokenSet_39() {
    long[] data = { 422081602782080L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
  private static final long[] mk_tokenSet_40() {
    long[] data = { -111669149710L, 17179869183L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
  private static final long[] mk_tokenSet_41() {
    long[] data = { 562819225354226L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
  private static final long[] mk_tokenSet_42() {
    long[] data = { 422081602781824L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
  private static final long[] mk_tokenSet_43() {
    long[] data = { 562819091137408L, 17179076097L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
  private static final long[] mk_tokenSet_44() {
    long[] data = { -562924720611776L, 17179869183L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
  private static final long[] mk_tokenSet_45() {
    long[] data = { -111669149744L, 17179869183L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
  private static final long[] mk_tokenSet_46() {
    long[] data = { 575897847178724096L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
  private static final long[] mk_tokenSet_47() {
    long[] data = { 1152358599482147584L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
  private static final long[] mk_tokenSet_48() {
    long[] data = { 2305280104088994560L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
  private static final long[] mk_tokenSet_49() {
    long[] data = { 4611123113302688512L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
  private static final long[] mk_tokenSet_50() {
    long[] data = { 9222809131730076416L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
  private static final long[] mk_tokenSet_51() {
    long[] data = { -562905124699392L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
  private static final long[] mk_tokenSet_52() {
    long[] data = { -562905124699392L, 1L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
  private static final long[] mk_tokenSet_53() {
    long[] data = { -562905124699392L, 7L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
  private static final long[] mk_tokenSet_54() {
    long[] data = { -562905124699392L, 127L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
  private static final long[] mk_tokenSet_55() {
    long[] data = { -562905124699392L, 511L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
  private static final long[] mk_tokenSet_56() {
    long[] data = { 2147483648L, 6144L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
  private static final long[] mk_tokenSet_57() {
    long[] data = { -562905124699392L, 2047L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
  private static final long[] mk_tokenSet_58() {
    long[] data = { -562881368161536L, 17179869183L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
  private static final long[] mk_tokenSet_59() {
    long[] data = { -562902977215744L, 8191L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
  private static final long[] mk_tokenSet_60() {
    long[] data = { -562881502379264L, 819199L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
  
  }
Source Code of processing.app.preproc.StdCParser

Related Classes of processing.app.preproc.StdCParser
