// $ANTLR 2.7.2: "expandedWParser.g" -> "WParser.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 WParser extends antlr.LLkParser implements WTokenTypes
{
// 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 WParser(TokenBuffer tokenBuf, int k) {
super(tokenBuf,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public WParser(TokenBuffer tokenBuf) {
this(tokenBuf,1);
}
protected WParser(TokenStream lexer, int k) {
super(lexer,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public WParser(TokenStream lexer) {
this(lexer,1);
}
public WParser(ParserSharedInputState state) {
super(state,1);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public final void translationUnit() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode translationUnit_AST = null;
{
switch ( LA(1)) {
case LITERAL_typedef:
case LITERAL_asm:
case LITERAL_volatile:
case SEMI:
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:
case LITERAL_inline:
case LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
externalList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case EOF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
translationUnit_AST = (TNode)currentAST.root;
returnAST = translationUnit_AST;
}
public final void externalList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode externalList_AST = null;
{
int _cnt211=0;
_loop211:
do {
if ((_tokenSet_0.member(LA(1)))) {
externalDef();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt211>=1 ) { break _loop211; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt211++;
} while (true);
}
externalList_AST = (TNode)currentAST.root;
returnAST = externalList_AST;
}
public final void asm_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode asm_expr_AST = null;
TNode tmp1_AST = null;
tmp1_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1_AST);
match(LITERAL_asm);
{
switch ( LA(1)) {
case LITERAL_volatile:
{
TNode tmp2_AST = null;
tmp2_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp2_AST);
match(LITERAL_volatile);
break;
}
case LCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp3_AST = null;
tmp3_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp3_AST);
match(LCURLY);
expr();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp4_AST = null;
tmp4_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp4_AST);
match(RCURLY);
{
int _cnt6=0;
_loop6:
do {
if ((LA(1)==SEMI)) {
TNode tmp5_AST = null;
tmp5_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp5_AST);
match(SEMI);
}
else {
if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt6++;
} while (true);
}
asm_expr_AST = (TNode)currentAST.root;
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;
assignExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop261:
do {
if ((LA(1)==COMMA)) {
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 _loop261;
}
} while (true);
}
expr_AST = (TNode)currentAST.root;
returnAST = expr_AST;
}
public final void idList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode idList_AST = null;
TNode tmp6_AST = null;
tmp6_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp6_AST);
match(ID);
{
_loop9:
do {
if ((LA(1)==COMMA)) {
TNode tmp7_AST = null;
tmp7_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp7_AST);
match(COMMA);
TNode tmp8_AST = null;
tmp8_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp8_AST);
match(ID);
}
else {
break _loop9;
}
} while (true);
}
idList_AST = (TNode)currentAST.root;
returnAST = idList_AST;
}
public final void externalDef() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode externalDef_AST = null;
switch ( LA(1)) {
case LITERAL_asm:
{
asm_expr();
astFactory.addASTChild(currentAST, returnAST);
externalDef_AST = (TNode)currentAST.root;
break;
}
case SEMI:
{
TNode tmp9_AST = null;
tmp9_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp9_AST);
match(SEMI);
externalDef_AST = (TNode)currentAST.root;
break;
}
default:
boolean synPredMatched12 = false;
if (((_tokenSet_1.member(LA(1))))) {
int _m12 = mark();
synPredMatched12 = true;
inputState.guessing++;
try {
{
if ((LA(1)==LITERAL_typedef)) {
match(LITERAL_typedef);
}
else if ((_tokenSet_1.member(LA(1)))) {
declaration();
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException pe) {
synPredMatched12 = false;
}
rewind(_m12);
inputState.guessing--;
}
if ( synPredMatched12 ) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
externalDef_AST = (TNode)currentAST.root;
}
else {
boolean synPredMatched14 = false;
if (((_tokenSet_2.member(LA(1))))) {
int _m14 = mark();
synPredMatched14 = true;
inputState.guessing++;
try {
{
functionPrefix();
}
}
catch (RecognitionException pe) {
synPredMatched14 = false;
}
rewind(_m14);
inputState.guessing--;
}
if ( synPredMatched14 ) {
functionDef();
astFactory.addASTChild(currentAST, returnAST);
externalDef_AST = (TNode)currentAST.root;
}
else if ((_tokenSet_3.member(LA(1)))) {
typelessDeclaration();
astFactory.addASTChild(currentAST, returnAST);
externalDef_AST = (TNode)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}}
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;
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());
}
}
}
{
int _cnt78=0;
_loop78:
do {
if ((LA(1)==SEMI)) {
TNode tmp10_AST = null;
tmp10_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp10_AST);
match(SEMI);
}
else {
if ( _cnt78>=1 ) { break _loop78; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt78++;
} while (true);
}
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;
returnAST = declaration_AST;
}
public final void functionPrefix() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode functionPrefix_AST = null;
TNode ds_AST = null;
TNode d_AST = null;
String declName;
{
boolean synPredMatched18 = false;
if (((_tokenSet_4.member(LA(1))))) {
int _m18 = mark();
synPredMatched18 = true;
inputState.guessing++;
try {
{
functionDeclSpecifiers();
}
}
catch (RecognitionException pe) {
synPredMatched18 = false;
}
rewind(_m18);
inputState.guessing--;
}
if ( synPredMatched18 ) {
functionDeclSpecifiers();
ds_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
declName=declarator(true);
d_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop20:
do {
if ((_tokenSet_1.member(LA(1)))) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop20;
}
} while (true);
}
{
switch ( LA(1)) {
case VARARGS:
{
TNode tmp11_AST = null;
tmp11_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp11_AST);
match(VARARGS);
break;
}
case LCURLY:
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop23:
do {
if ((LA(1)==SEMI)) {
TNode tmp12_AST = null;
tmp12_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp12_AST);
match(SEMI);
}
else {
break _loop23;
}
} while (true);
}
TNode tmp13_AST = null;
tmp13_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp13_AST);
match(LCURLY);
functionPrefix_AST = (TNode)currentAST.root;
returnAST = functionPrefix_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;
{
boolean synPredMatched243 = false;
if (((_tokenSet_4.member(LA(1))))) {
int _m243 = mark();
synPredMatched243 = true;
inputState.guessing++;
try {
{
functionDeclSpecifiers();
}
}
catch (RecognitionException pe) {
synPredMatched243 = false;
}
rewind(_m243);
inputState.guessing--;
}
if ( synPredMatched243 ) {
functionDeclSpecifiers();
ds_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1)))) {
}
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);
}
{
_loop245:
do {
if ((_tokenSet_1.member(LA(1)))) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop245;
}
} while (true);
}
{
switch ( LA(1)) {
case VARARGS:
{
TNode tmp14_AST = null;
tmp14_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp14_AST);
match(VARARGS);
break;
}
case LCURLY:
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop248:
do {
if ((LA(1)==SEMI)) {
match(SEMI);
}
else {
break _loop248;
}
} 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;
returnAST = functionDef_AST;
}
public final void typelessDeclaration() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode typelessDeclaration_AST = null;
AST typeMissing = (TNode)astFactory.create(NTypeMissing);
initDeclList(typeMissing);
astFactory.addASTChild(currentAST, returnAST);
TNode tmp16_AST = null;
tmp16_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp16_AST);
match(SEMI);
if ( inputState.guessing==0 ) {
typelessDeclaration_AST = (TNode)currentAST.root;
typelessDeclaration_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NTypeMissing)).add(typelessDeclaration_AST));
currentAST.root = typelessDeclaration_AST;
currentAST.child = typelessDeclaration_AST!=null &&typelessDeclaration_AST.getFirstChild()!=null ?
typelessDeclaration_AST.getFirstChild() : typelessDeclaration_AST;
currentAST.advanceChildToEnd();
}
typelessDeclaration_AST = (TNode)currentAST.root;
returnAST = typelessDeclaration_AST;
}
public final void functionDeclSpecifiers() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode functionDeclSpecifiers_AST = null;
int specCount = 0;
{
int _cnt253=0;
_loop253:
do {
switch ( LA(1)) {
case LITERAL_extern:
case LITERAL_static:
case LITERAL_inline:
{
functionStorageClassSpecifier();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_volatile:
case LITERAL_const:
{
typeQualifier();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
boolean synPredMatched252 = false;
if (((_tokenSet_5.member(LA(1))))) {
int _m252 = mark();
synPredMatched252 = true;
inputState.guessing++;
try {
{
if ((LA(1)==LITERAL_struct)) {
match(LITERAL_struct);
}
else if ((LA(1)==LITERAL_union)) {
match(LITERAL_union);
}
else if ((LA(1)==LITERAL_enum)) {
match(LITERAL_enum);
}
else if ((_tokenSet_5.member(LA(1)))) {
typeSpecifier(specCount);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException pe) {
synPredMatched252 = false;
}
rewind(_m252);
inputState.guessing--;
}
if ( synPredMatched252 ) {
specCount=typeSpecifier(specCount);
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt253>=1 ) { break _loop253; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt253++;
} while (true);
}
functionDeclSpecifiers_AST = (TNode)currentAST.root;
returnAST = functionDeclSpecifiers_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;
declName = "";
{
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 tmp17_AST = null;
tmp17_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp17_AST);
match(LPAREN);
declName=declarator(false);
astFactory.addASTChild(currentAST, returnAST);
TNode tmp18_AST = null;
tmp18_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp18_AST);
match(RPAREN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop50:
do {
switch ( LA(1)) {
case LPAREN:
{
declaratorParamaterList(isFunctionDefinition, declName);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LBRACKET:
{
TNode tmp19_AST = null;
tmp19_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp19_AST);
match(LBRACKET);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RBRACKET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp20_AST = null;
tmp20_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp20_AST);
match(RBRACKET);
break;
}
default:
{
break _loop50;
}
}
} 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;
returnAST = declarator_AST;
return declName;
}
public final void initDeclList(
AST declarationSpecifiers
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode initDeclList_AST = null;
initDecl(declarationSpecifiers);
astFactory.addASTChild(currentAST, returnAST);
{
_loop115:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
initDecl(declarationSpecifiers);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop115;
}
} while (true);
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
initDeclList_AST = (TNode)currentAST.root;
returnAST = initDeclList_AST;
}
public final void initializer() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode initializer_AST = null;
{
if ((_tokenSet_6.member(LA(1)))) {
{
{
boolean synPredMatched30 = false;
if (((_tokenSet_7.member(LA(1))))) {
int _m30 = mark();
synPredMatched30 = true;
inputState.guessing++;
try {
{
initializerElementLabel();
}
}
catch (RecognitionException pe) {
synPredMatched30 = false;
}
rewind(_m30);
inputState.guessing--;
}
if ( synPredMatched30 ) {
initializerElementLabel();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_8.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
assignExpr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LCURLY:
{
lcurlyInitializer();
astFactory.addASTChild(currentAST, returnAST);
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();
}
}
}
else if ((LA(1)==LCURLY)) {
lcurlyInitializer();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
initializer_AST = (TNode)currentAST.root;
returnAST = initializer_AST;
}
public final void initializerElementLabel() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode initializerElementLabel_AST = null;
{
switch ( LA(1)) {
case LBRACKET:
{
{
TNode tmp23_AST = null;
tmp23_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp23_AST);
match(LBRACKET);
{
boolean synPredMatched37 = false;
if (((_tokenSet_9.member(LA(1))))) {
int _m37 = mark();
synPredMatched37 = true;
inputState.guessing++;
try {
{
constExpr();
match(VARARGS);
}
}
catch (RecognitionException pe) {
synPredMatched37 = false;
}
rewind(_m37);
inputState.guessing--;
}
if ( synPredMatched37 ) {
rangeExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_9.member(LA(1)))) {
constExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
TNode tmp24_AST = null;
tmp24_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp24_AST);
match(RBRACKET);
{
switch ( LA(1)) {
case ASSIGN:
{
TNode tmp25_AST = null;
tmp25_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp25_AST);
match(ASSIGN);
break;
}
case LITERAL_asm:
case LCURLY:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
break;
}
case ID:
{
TNode tmp26_AST = null;
tmp26_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp26_AST);
match(ID);
TNode tmp27_AST = null;
tmp27_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp27_AST);
match(COLON);
break;
}
case DOT:
{
TNode tmp28_AST = null;
tmp28_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp28_AST);
match(DOT);
TNode tmp29_AST = null;
tmp29_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp29_AST);
match(ID);
TNode tmp30_AST = null;
tmp30_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp30_AST);
match(ASSIGN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
initializerElementLabel_AST = (TNode)currentAST.root;
initializerElementLabel_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NInitializerElementLabel)).add(initializerElementLabel_AST)) ;
currentAST.root = initializerElementLabel_AST;
currentAST.child = initializerElementLabel_AST!=null &&initializerElementLabel_AST.getFirstChild()!=null ?
initializerElementLabel_AST.getFirstChild() : initializerElementLabel_AST;
currentAST.advanceChildToEnd();
}
initializerElementLabel_AST = (TNode)currentAST.root;
returnAST = initializerElementLabel_AST;
}
public final void assignExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode assignExpr_AST = null;
TNode a_AST = null;
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;
returnAST = assignExpr_AST;
}
public final void lcurlyInitializer() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode lcurlyInitializer_AST = null;
TNode tmp31_AST = null;
tmp31_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp31_AST);
match(LCURLY);
{
switch ( LA(1)) {
case LITERAL_asm:
case LCURLY:
case ID:
case STAR:
case LPAREN:
case LBRACKET:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case DOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
initializerList();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp33_AST = null;
tmp33_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp33_AST);
match(RCURLY);
if ( inputState.guessing==0 ) {
lcurlyInitializer_AST = (TNode)currentAST.root;
lcurlyInitializer_AST.setType( NLcurlyInitializer );
}
lcurlyInitializer_AST = (TNode)currentAST.root;
returnAST = lcurlyInitializer_AST;
}
public final void constExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode constExpr_AST = null;
conditionalExpr();
astFactory.addASTChild(currentAST, returnAST);
constExpr_AST = (TNode)currentAST.root;
returnAST = constExpr_AST;
}
public final void rangeExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode rangeExpr_AST = null;
constExpr();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp34_AST = null;
tmp34_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp34_AST);
match(VARARGS);
constExpr();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
rangeExpr_AST = (TNode)currentAST.root;
rangeExpr_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NRangeExpr)).add(rangeExpr_AST));
currentAST.root = rangeExpr_AST;
currentAST.child = rangeExpr_AST!=null &&rangeExpr_AST.getFirstChild()!=null ?
rangeExpr_AST.getFirstChild() : rangeExpr_AST;
currentAST.advanceChildToEnd();
}
rangeExpr_AST = (TNode)currentAST.root;
returnAST = rangeExpr_AST;
}
public final void initializerList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode initializerList_AST = null;
initializer();
astFactory.addASTChild(currentAST, returnAST);
{
_loop44:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
initializer();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop44;
}
} while (true);
}
initializerList_AST = (TNode)currentAST.root;
returnAST = initializerList_AST;
}
public final void pointerGroup() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode pointerGroup_AST = null;
{
int _cnt235=0;
_loop235:
do {
if ((LA(1)==STAR)) {
TNode tmp36_AST = null;
tmp36_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp36_AST);
match(STAR);
{
_loop234:
do {
if ((LA(1)==LITERAL_volatile||LA(1)==LITERAL_const)) {
typeQualifier();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop234;
}
} while (true);
}
}
else {
if ( _cnt235>=1 ) { break _loop235; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt235++;
} 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;
returnAST = pointerGroup_AST;
}
public final void declaratorParamaterList(
boolean isFunctionDefinition, String declName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode declaratorParamaterList_AST = null;
TNode tmp37_AST = null;
tmp37_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp37_AST);
match(LPAREN);
if ( inputState.guessing==0 ) {
if (isFunctionDefinition) {
pushScope(declName);
}
else {
pushScope("!"+declName);
}
}
{
boolean synPredMatched54 = false;
if (((_tokenSet_1.member(LA(1))))) {
int _m54 = mark();
synPredMatched54 = true;
inputState.guessing++;
try {
{
declSpecifiers();
}
}
catch (RecognitionException pe) {
synPredMatched54 = false;
}
rewind(_m54);
inputState.guessing--;
}
if ( synPredMatched54 ) {
parameterTypeList();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_10.member(LA(1)))) {
{
switch ( LA(1)) {
case ID:
{
idList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COMMA:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if ( inputState.guessing==0 ) {
popScope();
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp39_AST = null;
tmp39_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp39_AST);
match(RPAREN);
if ( inputState.guessing==0 ) {
declaratorParamaterList_AST = (TNode)currentAST.root;
declaratorParamaterList_AST.setType(NParameterTypeList);
}
declaratorParamaterList_AST = (TNode)currentAST.root;
returnAST = declaratorParamaterList_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;
{
int _cnt216=0;
_loop216:
do {
switch ( LA(1)) {
case LITERAL_typedef:
case LITERAL_auto:
case LITERAL_register:
case LITERAL_extern:
case LITERAL_static:
case LITERAL_inline:
{
storageClassSpecifier();
s_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_volatile:
case LITERAL_const:
{
typeQualifier();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
boolean synPredMatched215 = false;
if (((_tokenSet_5.member(LA(1))))) {
int _m215 = mark();
synPredMatched215 = true;
inputState.guessing++;
try {
{
if ((LA(1)==LITERAL_struct)) {
match(LITERAL_struct);
}
else if ((LA(1)==LITERAL_union)) {
match(LITERAL_union);
}
else if ((LA(1)==LITERAL_enum)) {
match(LITERAL_enum);
}
else if ((_tokenSet_5.member(LA(1)))) {
typeSpecifier(specCount);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException pe) {
synPredMatched215 = false;
}
rewind(_m215);
inputState.guessing--;
}
if ( synPredMatched215 ) {
specCount=typeSpecifier(specCount);
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt216>=1 ) { break _loop216; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt216++;
} while (true);
}
declSpecifiers_AST = (TNode)currentAST.root;
returnAST = declSpecifiers_AST;
}
public final void parameterTypeList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode parameterTypeList_AST = null;
parameterDeclaration();
astFactory.addASTChild(currentAST, returnAST);
{
_loop60:
do {
if ((LA(1)==SEMI||LA(1)==COMMA)) {
{
switch ( LA(1)) {
case COMMA:
{
TNode tmp40_AST = null;
tmp40_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp40_AST);
match(COMMA);
break;
}
case SEMI:
{
TNode tmp41_AST = null;
tmp41_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp41_AST);
match(SEMI);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
parameterDeclaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop60;
}
} while (true);
}
{
if ((LA(1)==SEMI||LA(1)==COMMA)) {
{
switch ( LA(1)) {
case COMMA:
{
TNode tmp42_AST = null;
tmp42_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp42_AST);
match(COMMA);
break;
}
case SEMI:
{
TNode tmp43_AST = null;
tmp43_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp43_AST);
match(SEMI);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp44_AST = null;
tmp44_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp44_AST);
match(VARARGS);
}
else if ((LA(1)==COMMA||LA(1)==RPAREN)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
parameterTypeList_AST = (TNode)currentAST.root;
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;
declSpecifiers();
ds_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
boolean synPredMatched239 = false;
if (((_tokenSet_3.member(LA(1))))) {
int _m239 = mark();
synPredMatched239 = true;
inputState.guessing++;
try {
{
declarator(false);
}
}
catch (RecognitionException pe) {
synPredMatched239 = false;
}
rewind(_m239);
inputState.guessing--;
}
if ( synPredMatched239 ) {
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_11.member(LA(1)))) {
nonemptyAbstractDeclarator();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_12.member(LA(1)))) {
}
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 &¶meterDeclaration_AST.getFirstChild()!=null ?
parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
currentAST.advanceChildToEnd();
}
parameterDeclaration_AST = (TNode)currentAST.root;
returnAST = parameterDeclaration_AST;
}
public final void declarationList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode declarationList_AST = null;
{
int _cnt67=0;
_loop67:
do {
if ((LA(1)==LITERAL___label__)) {
localLabelDeclaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
boolean synPredMatched66 = false;
if (((_tokenSet_1.member(LA(1))))) {
int _m66 = mark();
synPredMatched66 = true;
inputState.guessing++;
try {
{
declarationPredictor();
}
}
catch (RecognitionException pe) {
synPredMatched66 = false;
}
rewind(_m66);
inputState.guessing--;
}
if ( synPredMatched66 ) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt67>=1 ) { break _loop67; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt67++;
} while (true);
}
declarationList_AST = (TNode)currentAST.root;
returnAST = declarationList_AST;
}
public final void localLabelDeclaration() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode localLabelDeclaration_AST = null;
{
TNode tmp45_AST = null;
tmp45_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp45_AST);
match(LITERAL___label__);
TNode tmp46_AST = null;
tmp46_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp46_AST);
match(ID);
{
_loop71:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
TNode tmp48_AST = null;
tmp48_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp48_AST);
match(ID);
}
else {
break _loop71;
}
} while (true);
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
int _cnt74=0;
_loop74:
do {
if ((LA(1)==SEMI)) {
match(SEMI);
}
else {
if ( _cnt74>=1 ) { break _loop74; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt74++;
} while (true);
}
}
localLabelDeclaration_AST = (TNode)currentAST.root;
returnAST = localLabelDeclaration_AST;
}
public final void declarationPredictor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode declarationPredictor_AST = null;
{
if ((LA(1)==LITERAL_typedef)) {
TNode tmp51_AST = null;
tmp51_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp51_AST);
match(LITERAL_typedef);
}
else if ((_tokenSet_1.member(LA(1)))) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
declarationPredictor_AST = (TNode)currentAST.root;
returnAST = declarationPredictor_AST;
}
public final void functionStorageClassSpecifier() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode functionStorageClassSpecifier_AST = null;
switch ( LA(1)) {
case LITERAL_extern:
{
TNode tmp52_AST = null;
tmp52_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp52_AST);
match(LITERAL_extern);
functionStorageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_static:
{
TNode tmp53_AST = null;
tmp53_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp53_AST);
match(LITERAL_static);
functionStorageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_inline:
{
TNode tmp54_AST = null;
tmp54_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp54_AST);
match(LITERAL_inline);
functionStorageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = functionStorageClassSpecifier_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;
{
switch ( LA(1)) {
case LITERAL_void:
{
TNode tmp55_AST = null;
tmp55_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp55_AST);
match(LITERAL_void);
break;
}
case LITERAL_char:
{
TNode tmp56_AST = null;
tmp56_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp56_AST);
match(LITERAL_char);
break;
}
case LITERAL_short:
{
TNode tmp57_AST = null;
tmp57_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp57_AST);
match(LITERAL_short);
break;
}
case LITERAL_int:
{
TNode tmp58_AST = null;
tmp58_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp58_AST);
match(LITERAL_int);
break;
}
case LITERAL_long:
{
TNode tmp59_AST = null;
tmp59_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp59_AST);
match(LITERAL_long);
break;
}
case LITERAL_float:
{
TNode tmp60_AST = null;
tmp60_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp60_AST);
match(LITERAL_float);
break;
}
case LITERAL_double:
{
TNode tmp61_AST = null;
tmp61_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp61_AST);
match(LITERAL_double);
break;
}
case LITERAL_signed:
{
TNode tmp62_AST = null;
tmp62_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp62_AST);
match(LITERAL_signed);
break;
}
case LITERAL_unsigned:
{
TNode tmp63_AST = null;
tmp63_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp63_AST);
match(LITERAL_unsigned);
break;
}
case LITERAL_byte:
{
TNode tmp64_AST = null;
tmp64_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp64_AST);
match(LITERAL_byte);
break;
}
case LITERAL_boolean:
{
TNode tmp65_AST = null;
tmp65_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp65_AST);
match(LITERAL_boolean);
break;
}
case LITERAL_struct:
case LITERAL_union:
{
structOrUnionSpecifier();
astFactory.addASTChild(currentAST, returnAST);
{
_loop83:
do {
if ((LA(1)==LITERAL_asm||LA(1)==LITERAL___attribute)) {
attributeDecl();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop83;
}
} while (true);
}
break;
}
case LITERAL_enum:
{
enumSpecifier();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_typeof:
{
TNode tmp66_AST = null;
tmp66_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp66_AST);
match(LITERAL_typeof);
TNode tmp67_AST = null;
tmp67_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp67_AST);
match(LPAREN);
{
boolean synPredMatched86 = false;
if (((_tokenSet_13.member(LA(1))))) {
int _m86 = mark();
synPredMatched86 = true;
inputState.guessing++;
try {
{
typeName();
}
}
catch (RecognitionException pe) {
synPredMatched86 = false;
}
rewind(_m86);
inputState.guessing--;
}
if ( synPredMatched86 ) {
typeName();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_9.member(LA(1)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
TNode tmp68_AST = null;
tmp68_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp68_AST);
match(RPAREN);
break;
}
case LITERAL___complex:
{
TNode tmp69_AST = null;
tmp69_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp69_AST);
match(LITERAL___complex);
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;
returnAST = typeSpecifier_AST;
return retSpecCount;
}
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;
structOrUnion();
sou_AST = (TNode)returnAST;
{
boolean synPredMatched90 = false;
if (((LA(1)==ID))) {
int _m90 = mark();
synPredMatched90 = true;
inputState.guessing++;
try {
{
match(ID);
match(LCURLY);
}
}
catch (RecognitionException pe) {
synPredMatched90 = false;
}
rewind(_m90);
inputState.guessing--;
}
if ( synPredMatched90 ) {
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);
}
{
switch ( LA(1)) {
case LITERAL_volatile:
case LITERAL_struct:
case LITERAL_union:
case LITERAL_enum:
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 LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
structDeclarationList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
popScope();
}
TNode tmp70_AST = null;
tmp70_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp70_AST);
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);
}
{
switch ( LA(1)) {
case LITERAL_volatile:
case LITERAL_struct:
case LITERAL_union:
case LITERAL_enum:
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 LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
structDeclarationList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
popScope();
}
TNode tmp71_AST = null;
tmp71_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp71_AST);
match(RCURLY);
}
else if ((LA(1)==ID)) {
TNode tmp72_AST = null;
tmp72_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp72_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;
returnAST = structOrUnionSpecifier_AST;
}
public final void attributeDecl() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode attributeDecl_AST = null;
switch ( LA(1)) {
case LITERAL___attribute:
{
TNode tmp73_AST = null;
tmp73_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp73_AST);
match(LITERAL___attribute);
TNode tmp74_AST = null;
tmp74_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp74_AST);
match(LPAREN);
TNode tmp75_AST = null;
tmp75_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp75_AST);
match(LPAREN);
attributeList();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp76_AST = null;
tmp76_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp76_AST);
match(RPAREN);
TNode tmp77_AST = null;
tmp77_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp77_AST);
match(RPAREN);
attributeDecl_AST = (TNode)currentAST.root;
break;
}
case LITERAL_asm:
{
TNode tmp78_AST = null;
tmp78_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp78_AST);
match(LITERAL_asm);
TNode tmp79_AST = null;
tmp79_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp79_AST);
match(LPAREN);
stringConst();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp80_AST = null;
tmp80_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp80_AST);
match(RPAREN);
if ( inputState.guessing==0 ) {
attributeDecl_AST = (TNode)currentAST.root;
attributeDecl_AST.setType( NAsmAttribute );
}
attributeDecl_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = attributeDecl_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;
TNode tmp81_AST = null;
tmp81_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp81_AST);
match(LITERAL_enum);
{
boolean synPredMatched108 = false;
if (((LA(1)==ID))) {
int _m108 = mark();
synPredMatched108 = true;
inputState.guessing++;
try {
{
match(ID);
match(LCURLY);
}
}
catch (RecognitionException pe) {
synPredMatched108 = false;
}
rewind(_m108);
inputState.guessing--;
}
if ( synPredMatched108 ) {
i = LT(1);
i_AST = (TNode)astFactory.create(i);
astFactory.addASTChild(currentAST, i_AST);
match(ID);
TNode tmp82_AST = null;
tmp82_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp82_AST);
match(LCURLY);
enumList(i.getText());
astFactory.addASTChild(currentAST, returnAST);
TNode tmp83_AST = null;
tmp83_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp83_AST);
match(RCURLY);
}
else if ((LA(1)==LCURLY)) {
TNode tmp84_AST = null;
tmp84_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp84_AST);
match(LCURLY);
enumList("anonymous");
astFactory.addASTChild(currentAST, returnAST);
TNode tmp85_AST = null;
tmp85_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp85_AST);
match(RCURLY);
}
else if ((LA(1)==ID)) {
TNode tmp86_AST = null;
tmp86_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp86_AST);
match(ID);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
enumSpecifier_AST = (TNode)currentAST.root;
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;
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;
returnAST = typedefName_AST;
}
public final void typeName() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode typeName_AST = null;
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;
returnAST = typeName_AST;
}
public final void structOrUnion() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode structOrUnion_AST = null;
switch ( LA(1)) {
case LITERAL_struct:
{
TNode tmp87_AST = null;
tmp87_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp87_AST);
match(LITERAL_struct);
structOrUnion_AST = (TNode)currentAST.root;
break;
}
case LITERAL_union:
{
TNode tmp88_AST = null;
tmp88_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp88_AST);
match(LITERAL_union);
structOrUnion_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = structOrUnion_AST;
}
public final void structDeclarationList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode structDeclarationList_AST = null;
{
int _cnt223=0;
_loop223:
do {
if ((_tokenSet_13.member(LA(1)))) {
structDeclaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt223>=1 ) { break _loop223; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt223++;
} while (true);
}
structDeclarationList_AST = (TNode)currentAST.root;
returnAST = structDeclarationList_AST;
}
public final void structDeclaration() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode structDeclaration_AST = null;
specifierQualifierList();
astFactory.addASTChild(currentAST, returnAST);
structDeclaratorList();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
int _cnt96=0;
_loop96:
do {
if ((LA(1)==SEMI)) {
match(SEMI);
}
else {
if ( _cnt96>=1 ) { break _loop96; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt96++;
} while (true);
}
structDeclaration_AST = (TNode)currentAST.root;
returnAST = structDeclaration_AST;
}
public final void specifierQualifierList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode specifierQualifierList_AST = null;
int specCount = 0;
{
int _cnt228=0;
_loop228:
do {
boolean synPredMatched227 = false;
if (((_tokenSet_5.member(LA(1))))) {
int _m227 = mark();
synPredMatched227 = true;
inputState.guessing++;
try {
{
if ((LA(1)==LITERAL_struct)) {
match(LITERAL_struct);
}
else if ((LA(1)==LITERAL_union)) {
match(LITERAL_union);
}
else if ((LA(1)==LITERAL_enum)) {
match(LITERAL_enum);
}
else if ((_tokenSet_5.member(LA(1)))) {
typeSpecifier(specCount);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException pe) {
synPredMatched227 = false;
}
rewind(_m227);
inputState.guessing--;
}
if ( synPredMatched227 ) {
specCount=typeSpecifier(specCount);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==LITERAL_volatile||LA(1)==LITERAL_const)) {
typeQualifier();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt228>=1 ) { break _loop228; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt228++;
} while (true);
}
specifierQualifierList_AST = (TNode)currentAST.root;
returnAST = specifierQualifierList_AST;
}
public final void structDeclaratorList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode structDeclaratorList_AST = null;
structDeclarator();
astFactory.addASTChild(currentAST, returnAST);
{
_loop99:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
structDeclarator();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop99;
}
} while (true);
}
structDeclaratorList_AST = (TNode)currentAST.root;
returnAST = structDeclaratorList_AST;
}
public final void structDeclarator() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode structDeclarator_AST = null;
{
switch ( LA(1)) {
case ID:
case STAR:
case LPAREN:
{
declarator(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_asm:
case SEMI:
case COMMA:
case COLON:
case LITERAL___attribute:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case COLON:
{
TNode tmp92_AST = null;
tmp92_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp92_AST);
match(COLON);
constExpr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_asm:
case SEMI:
case COMMA:
case LITERAL___attribute:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop104:
do {
if ((LA(1)==LITERAL_asm||LA(1)==LITERAL___attribute)) {
attributeDecl();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop104;
}
} while (true);
}
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;
returnAST = structDeclarator_AST;
}
public final void enumList(
String enumName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode enumList_AST = null;
enumerator(enumName);
astFactory.addASTChild(currentAST, returnAST);
{
_loop111:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
enumerator(enumName);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop111;
}
} while (true);
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
enumList_AST = (TNode)currentAST.root;
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;
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 tmp95_AST = null;
tmp95_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp95_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;
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 = "";
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)) );
}
{
_loop119:
do {
if ((LA(1)==LITERAL_asm||LA(1)==LITERAL___attribute)) {
attributeDecl();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop119;
}
} while (true);
}
{
switch ( LA(1)) {
case ASSIGN:
{
TNode tmp96_AST = null;
tmp96_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp96_AST);
match(ASSIGN);
initializer();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COLON:
{
TNode tmp97_AST = null;
tmp97_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp97_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;
returnAST = initDecl_AST;
}
public final void attributeList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode attributeList_AST = null;
attribute();
astFactory.addASTChild(currentAST, returnAST);
{
_loop124:
do {
if ((LA(1)==COMMA)) {
TNode tmp98_AST = null;
tmp98_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp98_AST);
match(COMMA);
attribute();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop124;
}
} while (true);
}
{
switch ( LA(1)) {
case COMMA:
{
TNode tmp99_AST = null;
tmp99_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp99_AST);
match(COMMA);
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
attributeList_AST = (TNode)currentAST.root;
returnAST = attributeList_AST;
}
protected final void stringConst() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode stringConst_AST = null;
{
int _cnt314=0;
_loop314:
do {
if ((LA(1)==StringLiteral)) {
TNode tmp100_AST = null;
tmp100_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp100_AST);
match(StringLiteral);
}
else {
if ( _cnt314>=1 ) { break _loop314; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt314++;
} 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;
returnAST = stringConst_AST;
}
public final void attribute() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode attribute_AST = null;
{
_loop129:
do {
if ((_tokenSet_14.member(LA(1)))) {
{
TNode tmp101_AST = null;
tmp101_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp101_AST);
match(_tokenSet_14);
}
}
else if ((LA(1)==LPAREN)) {
TNode tmp102_AST = null;
tmp102_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp102_AST);
match(LPAREN);
attributeList();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp103_AST = null;
tmp103_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp103_AST);
match(RPAREN);
}
else {
break _loop129;
}
} while (true);
}
attribute_AST = (TNode)currentAST.root;
returnAST = attribute_AST;
}
public final void compoundStatement(
String scopeName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode compoundStatement_AST = null;
TNode tmp104_AST = null;
tmp104_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp104_AST);
match(LCURLY);
if ( inputState.guessing==0 ) {
pushScope(scopeName);
}
{
_loop136:
do {
boolean synPredMatched133 = false;
if (((_tokenSet_15.member(LA(1))))) {
int _m133 = mark();
synPredMatched133 = true;
inputState.guessing++;
try {
{
if ((LA(1)==LITERAL_typedef)) {
match(LITERAL_typedef);
}
else if ((LA(1)==LITERAL___label__)) {
match(LITERAL___label__);
}
else if ((_tokenSet_1.member(LA(1)))) {
declaration();
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException pe) {
synPredMatched133 = false;
}
rewind(_m133);
inputState.guessing--;
}
if ( synPredMatched133 ) {
declarationList();
astFactory.addASTChild(currentAST, returnAST);
}
else {
boolean synPredMatched135 = false;
if (((_tokenSet_16.member(LA(1))))) {
int _m135 = mark();
synPredMatched135 = true;
inputState.guessing++;
try {
{
nestedFunctionDef();
}
}
catch (RecognitionException pe) {
synPredMatched135 = false;
}
rewind(_m135);
inputState.guessing--;
}
if ( synPredMatched135 ) {
nestedFunctionDef();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop136;
}
}
} while (true);
}
{
switch ( LA(1)) {
case LITERAL_asm:
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 LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
statementList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RCURLY:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
popScope();
}
TNode tmp105_AST = null;
tmp105_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp105_AST);
match(RCURLY);
if ( inputState.guessing==0 ) {
compoundStatement_AST = (TNode)currentAST.root;
compoundStatement_AST.setType( NCompoundStatement ); compoundStatement_AST.setAttribute( "scopeName", scopeName );
}
compoundStatement_AST = (TNode)currentAST.root;
returnAST = compoundStatement_AST;
}
public final void nestedFunctionDef() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode nestedFunctionDef_AST = null;
TNode ds_AST = null;
TNode d_AST = null;
String declName;
{
switch ( LA(1)) {
case LITERAL_auto:
{
TNode tmp106_AST = null;
tmp106_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp106_AST);
match(LITERAL_auto);
break;
}
case LITERAL_volatile:
case LITERAL_struct:
case LITERAL_union:
case LITERAL_enum:
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:
case LITERAL_inline:
case LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
boolean synPredMatched142 = false;
if (((_tokenSet_4.member(LA(1))))) {
int _m142 = mark();
synPredMatched142 = true;
inputState.guessing++;
try {
{
functionDeclSpecifiers();
}
}
catch (RecognitionException pe) {
synPredMatched142 = false;
}
rewind(_m142);
inputState.guessing--;
}
if ( synPredMatched142 ) {
functionDeclSpecifiers();
ds_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
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)));
pushScope(declName);
}
{
_loop144:
do {
if ((_tokenSet_1.member(LA(1)))) {
declaration();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop144;
}
} while (true);
}
if ( inputState.guessing==0 ) {
popScope();
}
compoundStatement(declName);
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
nestedFunctionDef_AST = (TNode)currentAST.root;
nestedFunctionDef_AST = (TNode)astFactory.make( (new ASTArray(2)).add((TNode)astFactory.create(NFunctionDef)).add(nestedFunctionDef_AST));
currentAST.root = nestedFunctionDef_AST;
currentAST.child = nestedFunctionDef_AST!=null &&nestedFunctionDef_AST.getFirstChild()!=null ?
nestedFunctionDef_AST.getFirstChild() : nestedFunctionDef_AST;
currentAST.advanceChildToEnd();
}
nestedFunctionDef_AST = (TNode)currentAST.root;
returnAST = nestedFunctionDef_AST;
}
public final void statementList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode statementList_AST = null;
{
int _cnt258=0;
_loop258:
do {
if ((_tokenSet_17.member(LA(1)))) {
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt258>=1 ) { break _loop258; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt258++;
} while (true);
}
statementList_AST = (TNode)currentAST.root;
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;
switch ( LA(1)) {
case SEMI:
{
TNode tmp107_AST = null;
tmp107_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp107_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 tmp108_AST = null;
tmp108_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp108_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 tmp111_AST = null;
tmp111_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp111_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 tmp117_AST = null;
tmp117_AST = (TNode)astFactory.create(LT(1));
match(LPAREN);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
e1_AST = (TNode)returnAST;
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp118_AST = null;
tmp118_AST = (TNode)astFactory.create(LT(1));
match(SEMI);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
e2_AST = (TNode)returnAST;
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp119_AST = null;
tmp119_AST = (TNode)astFactory.create(LT(1));
match(SEMI);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
e3_AST = (TNode)returnAST;
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp120_AST = null;
tmp120_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 tmp121_AST = null;
tmp121_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp121_AST);
match(LITERAL_goto);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(SEMI);
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_continue:
{
TNode tmp123_AST = null;
tmp123_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp123_AST);
match(LITERAL_continue);
match(SEMI);
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_break:
{
TNode tmp125_AST = null;
tmp125_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp125_AST);
match(LITERAL_break);
match(SEMI);
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_return:
{
TNode tmp127_AST = null;
tmp127_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp127_AST);
match(LITERAL_return);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
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 tmp129_AST = null;
tmp129_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp129_AST);
match(LITERAL_case);
{
boolean synPredMatched153 = false;
if (((_tokenSet_9.member(LA(1))))) {
int _m153 = mark();
synPredMatched153 = true;
inputState.guessing++;
try {
{
constExpr();
match(VARARGS);
}
}
catch (RecognitionException pe) {
synPredMatched153 = false;
}
rewind(_m153);
inputState.guessing--;
}
if ( synPredMatched153 ) {
rangeExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_9.member(LA(1)))) {
constExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
match(COLON);
{
if ((_tokenSet_17.member(LA(1)))) {
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_18.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_default:
{
TNode tmp131_AST = null;
tmp131_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp131_AST);
match(LITERAL_default);
match(COLON);
{
if ((_tokenSet_17.member(LA(1)))) {
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_18.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_if:
{
TNode tmp133_AST = null;
tmp133_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp133_AST);
match(LITERAL_if);
match(LPAREN);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
statement();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==LITERAL_else)) {
TNode tmp136_AST = null;
tmp136_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp136_AST);
match(LITERAL_else);
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_18.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
statement_AST = (TNode)currentAST.root;
break;
}
case LITERAL_switch:
{
TNode tmp137_AST = null;
tmp137_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp137_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_9.member(LA(1)))) {
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)) {
TNode tmp141_AST = null;
tmp141_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp141_AST);
match(ID);
match(COLON);
{
if ((_tokenSet_17.member(LA(1)))) {
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_18.member(LA(1)))) {
}
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());
}
}
returnAST = statement_AST;
}
public final void conditionalExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode conditionalExpr_AST = null;
logicalOrExpr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case QUESTION:
{
TNode tmp143_AST = null;
tmp143_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp143_AST);
match(QUESTION);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp144_AST = null;
tmp144_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp144_AST);
match(COLON);
conditionalExpr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LITERAL_asm:
case RCURLY:
case SEMI:
case COMMA:
case COLON:
case ASSIGN:
case RPAREN:
case RBRACKET:
case VARARGS:
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 LITERAL___attribute:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
conditionalExpr_AST = (TNode)currentAST.root;
returnAST = conditionalExpr_AST;
}
public final void logicalOrExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode logicalOrExpr_AST = null;
logicalAndExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop268:
do {
if ((LA(1)==LOR)) {
TNode tmp145_AST = null;
tmp145_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp145_AST);
match(LOR);
logicalAndExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop268;
}
} while (true);
}
logicalOrExpr_AST = (TNode)currentAST.root;
returnAST = logicalOrExpr_AST;
}
public final void castExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode castExpr_AST = null;
boolean synPredMatched163 = false;
if (((LA(1)==LPAREN))) {
int _m163 = mark();
synPredMatched163 = true;
inputState.guessing++;
try {
{
match(LPAREN);
typeName();
match(RPAREN);
}
}
catch (RecognitionException pe) {
synPredMatched163 = false;
}
rewind(_m163);
inputState.guessing--;
}
if ( synPredMatched163 ) {
TNode tmp146_AST = null;
tmp146_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(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);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
castExpr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LCURLY:
{
lcurlyInitializer();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
castExpr_AST = (TNode)currentAST.root;
castExpr_AST.setType(NCast);
}
castExpr_AST = (TNode)currentAST.root;
}
else if ((_tokenSet_9.member(LA(1)))) {
unaryExpr();
astFactory.addASTChild(currentAST, returnAST);
castExpr_AST = (TNode)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
returnAST = castExpr_AST;
}
public final void unaryExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode unaryExpr_AST = null;
TNode u_AST = null;
switch ( LA(1)) {
case ID:
case LPAREN:
case CharLiteral:
case StringLiteral:
case Number:
{
postfixExpr();
astFactory.addASTChild(currentAST, returnAST);
unaryExpr_AST = (TNode)currentAST.root;
break;
}
case INC:
{
TNode tmp148_AST = null;
tmp148_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp148_AST);
match(INC);
castExpr();
astFactory.addASTChild(currentAST, returnAST);
unaryExpr_AST = (TNode)currentAST.root;
break;
}
case DEC:
{
TNode tmp149_AST = null;
tmp149_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp149_AST);
match(DEC);
castExpr();
astFactory.addASTChild(currentAST, returnAST);
unaryExpr_AST = (TNode)currentAST.root;
break;
}
case STAR:
case LAND:
case BAND:
case PLUS:
case MINUS:
case BNOT:
case LNOT:
case LITERAL___real:
case LITERAL___imag:
{
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 tmp150_AST = null;
tmp150_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp150_AST);
match(LITERAL_sizeof);
{
boolean synPredMatched184 = false;
if (((LA(1)==LPAREN))) {
int _m184 = mark();
synPredMatched184 = true;
inputState.guessing++;
try {
{
match(LPAREN);
typeName();
}
}
catch (RecognitionException pe) {
synPredMatched184 = false;
}
rewind(_m184);
inputState.guessing--;
}
if ( synPredMatched184 ) {
TNode tmp151_AST = null;
tmp151_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp151_AST);
match(LPAREN);
typeName();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp152_AST = null;
tmp152_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp152_AST);
match(RPAREN);
}
else if ((_tokenSet_9.member(LA(1)))) {
unaryExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
unaryExpr_AST = (TNode)currentAST.root;
break;
}
case LITERAL___alignof:
{
TNode tmp153_AST = null;
tmp153_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp153_AST);
match(LITERAL___alignof);
{
boolean synPredMatched187 = false;
if (((LA(1)==LPAREN))) {
int _m187 = mark();
synPredMatched187 = true;
inputState.guessing++;
try {
{
match(LPAREN);
typeName();
}
}
catch (RecognitionException pe) {
synPredMatched187 = false;
}
rewind(_m187);
inputState.guessing--;
}
if ( synPredMatched187 ) {
TNode tmp154_AST = null;
tmp154_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp154_AST);
match(LPAREN);
typeName();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp155_AST = null;
tmp155_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp155_AST);
match(RPAREN);
}
else if ((_tokenSet_9.member(LA(1)))) {
unaryExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
unaryExpr_AST = (TNode)currentAST.root;
break;
}
case LITERAL_asm:
{
gnuAsmExpr();
astFactory.addASTChild(currentAST, returnAST);
unaryExpr_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = unaryExpr_AST;
}
public final void nonemptyAbstractDeclarator() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode nonemptyAbstractDeclarator_AST = null;
{
switch ( LA(1)) {
case STAR:
{
pointerGroup();
astFactory.addASTChild(currentAST, returnAST);
{
_loop173:
do {
switch ( LA(1)) {
case LPAREN:
{
{
TNode tmp156_AST = null;
tmp156_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp156_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:
case LITERAL_inline:
case LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
parameterTypeList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COMMA:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp158_AST = null;
tmp158_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp158_AST);
match(RPAREN);
}
break;
}
case LBRACKET:
{
{
TNode tmp159_AST = null;
tmp159_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp159_AST);
match(LBRACKET);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RBRACKET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp160_AST = null;
tmp160_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp160_AST);
match(RBRACKET);
}
break;
}
default:
{
break _loop173;
}
}
} while (true);
}
break;
}
case LPAREN:
case LBRACKET:
{
{
int _cnt180=0;
_loop180:
do {
switch ( LA(1)) {
case LPAREN:
{
{
TNode tmp161_AST = null;
tmp161_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp161_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:
case LITERAL_inline:
case LITERAL_byte:
case LITERAL_boolean:
case LITERAL_typeof:
case LITERAL___complex:
{
parameterTypeList();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COMMA:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case COMMA:
{
match(COMMA);
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp163_AST = null;
tmp163_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp163_AST);
match(RPAREN);
}
break;
}
case LBRACKET:
{
{
TNode tmp164_AST = null;
tmp164_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp164_AST);
match(LBRACKET);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RBRACKET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp165_AST = null;
tmp165_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp165_AST);
match(RBRACKET);
}
break;
}
default:
{
if ( _cnt180>=1 ) { break _loop180; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt180++;
} 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;
returnAST = nonemptyAbstractDeclarator_AST;
}
public final void postfixExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode postfixExpr_AST = null;
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 LITERAL_asm:
case RCURLY:
case SEMI:
case COMMA:
case COLON:
case ASSIGN:
case STAR:
case RPAREN:
case RBRACKET:
case VARARGS:
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:
case LITERAL___attribute:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
postfixExpr_AST = (TNode)currentAST.root;
returnAST = postfixExpr_AST;
}
public final void unaryOperator() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode unaryOperator_AST = null;
switch ( LA(1)) {
case BAND:
{
TNode tmp166_AST = null;
tmp166_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp166_AST);
match(BAND);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case STAR:
{
TNode tmp167_AST = null;
tmp167_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp167_AST);
match(STAR);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case PLUS:
{
TNode tmp168_AST = null;
tmp168_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp168_AST);
match(PLUS);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case MINUS:
{
TNode tmp169_AST = null;
tmp169_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp169_AST);
match(MINUS);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case BNOT:
{
TNode tmp170_AST = null;
tmp170_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp170_AST);
match(BNOT);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case LNOT:
{
TNode tmp171_AST = null;
tmp171_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp171_AST);
match(LNOT);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case LAND:
{
TNode tmp172_AST = null;
tmp172_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp172_AST);
match(LAND);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case LITERAL___real:
{
TNode tmp173_AST = null;
tmp173_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp173_AST);
match(LITERAL___real);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
case LITERAL___imag:
{
TNode tmp174_AST = null;
tmp174_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp174_AST);
match(LITERAL___imag);
unaryOperator_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = unaryOperator_AST;
}
public final void gnuAsmExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode gnuAsmExpr_AST = null;
TNode tmp175_AST = null;
tmp175_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp175_AST);
match(LITERAL_asm);
{
switch ( LA(1)) {
case LITERAL_volatile:
{
TNode tmp176_AST = null;
tmp176_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp176_AST);
match(LITERAL_volatile);
break;
}
case LPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp177_AST = null;
tmp177_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp177_AST);
match(LPAREN);
stringConst();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==COLON)) {
TNode tmp178_AST = null;
tmp178_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp178_AST);
match(COLON);
{
switch ( LA(1)) {
case StringLiteral:
{
strOptExprPair();
astFactory.addASTChild(currentAST, returnAST);
{
_loop194:
do {
if ((LA(1)==COMMA)) {
TNode tmp179_AST = null;
tmp179_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp179_AST);
match(COMMA);
strOptExprPair();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop194;
}
} while (true);
}
break;
}
case COLON:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==COLON)) {
TNode tmp180_AST = null;
tmp180_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp180_AST);
match(COLON);
{
switch ( LA(1)) {
case StringLiteral:
{
strOptExprPair();
astFactory.addASTChild(currentAST, returnAST);
{
_loop198:
do {
if ((LA(1)==COMMA)) {
TNode tmp181_AST = null;
tmp181_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp181_AST);
match(COMMA);
strOptExprPair();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop198;
}
} while (true);
}
break;
}
case COLON:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==COLON||LA(1)==RPAREN)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==COLON||LA(1)==RPAREN)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case COLON:
{
TNode tmp182_AST = null;
tmp182_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp182_AST);
match(COLON);
stringConst();
astFactory.addASTChild(currentAST, returnAST);
{
_loop201:
do {
if ((LA(1)==COMMA)) {
TNode tmp183_AST = null;
tmp183_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp183_AST);
match(COMMA);
stringConst();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop201;
}
} while (true);
}
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp184_AST = null;
tmp184_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp184_AST);
match(RPAREN);
if ( inputState.guessing==0 ) {
gnuAsmExpr_AST = (TNode)currentAST.root;
gnuAsmExpr_AST.setType(NGnuAsmExpr);
}
gnuAsmExpr_AST = (TNode)currentAST.root;
returnAST = gnuAsmExpr_AST;
}
public final void strOptExprPair() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode strOptExprPair_AST = null;
stringConst();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case LPAREN:
{
TNode tmp185_AST = null;
tmp185_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp185_AST);
match(LPAREN);
expr();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp186_AST = null;
tmp186_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp186_AST);
match(RPAREN);
break;
}
case COMMA:
case COLON:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
strOptExprPair_AST = (TNode)currentAST.root;
returnAST = strOptExprPair_AST;
}
public final void functionCall() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode functionCall_AST = null;
TNode a_AST = null;
TNode tmp187_AST = null;
tmp187_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp187_AST);
match(LPAREN);
{
switch ( LA(1)) {
case LITERAL_asm:
case ID:
case STAR:
case LPAREN:
case LAND:
case BAND:
case PLUS:
case MINUS:
case INC:
case DEC:
case LITERAL_sizeof:
case BNOT:
case LNOT:
case CharLiteral:
case StringLiteral:
case Number:
case LITERAL___alignof:
case LITERAL___real:
case LITERAL___imag:
{
argExprList();
a_AST = (TNode)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
TNode tmp188_AST = null;
tmp188_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp188_AST);
match(RPAREN);
if ( inputState.guessing==0 ) {
functionCall_AST = (TNode)currentAST.root;
functionCall_AST.setType( NFunctionCallArgs );
}
functionCall_AST = (TNode)currentAST.root;
returnAST = functionCall_AST;
}
public final void argExprList() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode argExprList_AST = null;
assignExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop310:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
assignExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop310;
}
} while (true);
}
argExprList_AST = (TNode)currentAST.root;
returnAST = argExprList_AST;
}
public final void primaryExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode primaryExpr_AST = null;
switch ( LA(1)) {
case ID:
{
TNode tmp190_AST = null;
tmp190_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp190_AST);
match(ID);
primaryExpr_AST = (TNode)currentAST.root;
break;
}
case Number:
{
TNode tmp191_AST = null;
tmp191_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp191_AST);
match(Number);
primaryExpr_AST = (TNode)currentAST.root;
break;
}
case CharLiteral:
{
charConst();
astFactory.addASTChild(currentAST, returnAST);
primaryExpr_AST = (TNode)currentAST.root;
break;
}
case StringLiteral:
{
stringConst();
astFactory.addASTChild(currentAST, returnAST);
primaryExpr_AST = (TNode)currentAST.root;
break;
}
default:
boolean synPredMatched208 = false;
if (((LA(1)==LPAREN))) {
int _m208 = mark();
synPredMatched208 = true;
inputState.guessing++;
try {
{
match(LPAREN);
match(LCURLY);
}
}
catch (RecognitionException pe) {
synPredMatched208 = false;
}
rewind(_m208);
inputState.guessing--;
}
if ( synPredMatched208 ) {
TNode tmp192_AST = null;
tmp192_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp192_AST);
match(LPAREN);
compoundStatement(getAScopeName());
astFactory.addASTChild(currentAST, returnAST);
TNode tmp193_AST = null;
tmp193_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp193_AST);
match(RPAREN);
primaryExpr_AST = (TNode)currentAST.root;
}
else if ((LA(1)==LPAREN)) {
TNode tmp194_AST = null;
tmp194_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp194_AST);
match(LPAREN);
expr();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp195_AST = null;
tmp195_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp195_AST);
match(RPAREN);
if ( inputState.guessing==0 ) {
primaryExpr_AST = (TNode)currentAST.root;
primaryExpr_AST.setType(NExpressionGroup);
}
primaryExpr_AST = (TNode)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = primaryExpr_AST;
}
protected final void charConst() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode charConst_AST = null;
TNode tmp196_AST = null;
tmp196_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp196_AST);
match(CharLiteral);
charConst_AST = (TNode)currentAST.root;
returnAST = charConst_AST;
}
public final void storageClassSpecifier() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode storageClassSpecifier_AST = null;
switch ( LA(1)) {
case LITERAL_auto:
{
TNode tmp197_AST = null;
tmp197_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp197_AST);
match(LITERAL_auto);
storageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_register:
{
TNode tmp198_AST = null;
tmp198_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp198_AST);
match(LITERAL_register);
storageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_typedef:
{
TNode tmp199_AST = null;
tmp199_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp199_AST);
match(LITERAL_typedef);
storageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_extern:
case LITERAL_static:
case LITERAL_inline:
{
functionStorageClassSpecifier();
astFactory.addASTChild(currentAST, returnAST);
storageClassSpecifier_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = storageClassSpecifier_AST;
}
public final void typeQualifier() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode typeQualifier_AST = null;
switch ( LA(1)) {
case LITERAL_const:
{
TNode tmp200_AST = null;
tmp200_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp200_AST);
match(LITERAL_const);
typeQualifier_AST = (TNode)currentAST.root;
break;
}
case LITERAL_volatile:
{
TNode tmp201_AST = null;
tmp201_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp201_AST);
match(LITERAL_volatile);
typeQualifier_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = typeQualifier_AST;
}
public final void assignOperator() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode assignOperator_AST = null;
switch ( LA(1)) {
case ASSIGN:
{
TNode tmp202_AST = null;
tmp202_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp202_AST);
match(ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case DIV_ASSIGN:
{
TNode tmp203_AST = null;
tmp203_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp203_AST);
match(DIV_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case PLUS_ASSIGN:
{
TNode tmp204_AST = null;
tmp204_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp204_AST);
match(PLUS_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case MINUS_ASSIGN:
{
TNode tmp205_AST = null;
tmp205_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp205_AST);
match(MINUS_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case STAR_ASSIGN:
{
TNode tmp206_AST = null;
tmp206_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp206_AST);
match(STAR_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case MOD_ASSIGN:
{
TNode tmp207_AST = null;
tmp207_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp207_AST);
match(MOD_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case RSHIFT_ASSIGN:
{
TNode tmp208_AST = null;
tmp208_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp208_AST);
match(RSHIFT_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case LSHIFT_ASSIGN:
{
TNode tmp209_AST = null;
tmp209_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp209_AST);
match(LSHIFT_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case BAND_ASSIGN:
{
TNode tmp210_AST = null;
tmp210_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp210_AST);
match(BAND_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case BOR_ASSIGN:
{
TNode tmp211_AST = null;
tmp211_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp211_AST);
match(BOR_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
case BXOR_ASSIGN:
{
TNode tmp212_AST = null;
tmp212_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp212_AST);
match(BXOR_ASSIGN);
assignOperator_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = assignOperator_AST;
}
public final void logicalAndExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode logicalAndExpr_AST = null;
inclusiveOrExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop271:
do {
if ((LA(1)==LAND)) {
TNode tmp213_AST = null;
tmp213_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp213_AST);
match(LAND);
inclusiveOrExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop271;
}
} while (true);
}
logicalAndExpr_AST = (TNode)currentAST.root;
returnAST = logicalAndExpr_AST;
}
public final void inclusiveOrExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode inclusiveOrExpr_AST = null;
exclusiveOrExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop274:
do {
if ((LA(1)==BOR)) {
TNode tmp214_AST = null;
tmp214_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp214_AST);
match(BOR);
exclusiveOrExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop274;
}
} while (true);
}
inclusiveOrExpr_AST = (TNode)currentAST.root;
returnAST = inclusiveOrExpr_AST;
}
public final void exclusiveOrExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode exclusiveOrExpr_AST = null;
bitAndExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop277:
do {
if ((LA(1)==BXOR)) {
TNode tmp215_AST = null;
tmp215_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp215_AST);
match(BXOR);
bitAndExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop277;
}
} while (true);
}
exclusiveOrExpr_AST = (TNode)currentAST.root;
returnAST = exclusiveOrExpr_AST;
}
public final void bitAndExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode bitAndExpr_AST = null;
equalityExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop280:
do {
if ((LA(1)==BAND)) {
TNode tmp216_AST = null;
tmp216_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp216_AST);
match(BAND);
equalityExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop280;
}
} while (true);
}
bitAndExpr_AST = (TNode)currentAST.root;
returnAST = bitAndExpr_AST;
}
public final void equalityExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode equalityExpr_AST = null;
relationalExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop284:
do {
if ((LA(1)==EQUAL||LA(1)==NOT_EQUAL)) {
{
switch ( LA(1)) {
case EQUAL:
{
TNode tmp217_AST = null;
tmp217_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp217_AST);
match(EQUAL);
break;
}
case NOT_EQUAL:
{
TNode tmp218_AST = null;
tmp218_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp218_AST);
match(NOT_EQUAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
relationalExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop284;
}
} while (true);
}
equalityExpr_AST = (TNode)currentAST.root;
returnAST = equalityExpr_AST;
}
public final void relationalExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode relationalExpr_AST = null;
shiftExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop288:
do {
if (((LA(1) >= LT && LA(1) <= GTE))) {
{
switch ( LA(1)) {
case LT:
{
TNode tmp219_AST = null;
tmp219_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp219_AST);
match(LT);
break;
}
case LTE:
{
TNode tmp220_AST = null;
tmp220_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp220_AST);
match(LTE);
break;
}
case GT:
{
TNode tmp221_AST = null;
tmp221_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp221_AST);
match(GT);
break;
}
case GTE:
{
TNode tmp222_AST = null;
tmp222_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp222_AST);
match(GTE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
shiftExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop288;
}
} while (true);
}
relationalExpr_AST = (TNode)currentAST.root;
returnAST = relationalExpr_AST;
}
public final void shiftExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode shiftExpr_AST = null;
additiveExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop292:
do {
if ((LA(1)==LSHIFT||LA(1)==RSHIFT)) {
{
switch ( LA(1)) {
case LSHIFT:
{
TNode tmp223_AST = null;
tmp223_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp223_AST);
match(LSHIFT);
break;
}
case RSHIFT:
{
TNode tmp224_AST = null;
tmp224_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp224_AST);
match(RSHIFT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
additiveExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop292;
}
} while (true);
}
shiftExpr_AST = (TNode)currentAST.root;
returnAST = shiftExpr_AST;
}
public final void additiveExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode additiveExpr_AST = null;
multExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop296:
do {
if ((LA(1)==PLUS||LA(1)==MINUS)) {
{
switch ( LA(1)) {
case PLUS:
{
TNode tmp225_AST = null;
tmp225_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp225_AST);
match(PLUS);
break;
}
case MINUS:
{
TNode tmp226_AST = null;
tmp226_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp226_AST);
match(MINUS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
multExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop296;
}
} while (true);
}
additiveExpr_AST = (TNode)currentAST.root;
returnAST = additiveExpr_AST;
}
public final void multExpr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode multExpr_AST = null;
castExpr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop300:
do {
if ((_tokenSet_19.member(LA(1)))) {
{
switch ( LA(1)) {
case STAR:
{
TNode tmp227_AST = null;
tmp227_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp227_AST);
match(STAR);
break;
}
case DIV:
{
TNode tmp228_AST = null;
tmp228_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp228_AST);
match(DIV);
break;
}
case MOD:
{
TNode tmp229_AST = null;
tmp229_AST = (TNode)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp229_AST);
match(MOD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
castExpr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop300;
}
} while (true);
}
multExpr_AST = (TNode)currentAST.root;
returnAST = multExpr_AST;
}
public final void postfixSuffix() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode postfixSuffix_AST = null;
{
int _cnt307=0;
_loop307:
do {
switch ( LA(1)) {
case PTR:
{
TNode tmp230_AST = null;
tmp230_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp230_AST);
match(PTR);
TNode tmp231_AST = null;
tmp231_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp231_AST);
match(ID);
break;
}
case DOT:
{
TNode tmp232_AST = null;
tmp232_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp232_AST);
match(DOT);
TNode tmp233_AST = null;
tmp233_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp233_AST);
match(ID);
break;
}
case LPAREN:
{
functionCall();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LBRACKET:
{
TNode tmp234_AST = null;
tmp234_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp234_AST);
match(LBRACKET);
expr();
astFactory.addASTChild(currentAST, returnAST);
TNode tmp235_AST = null;
tmp235_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp235_AST);
match(RBRACKET);
break;
}
case INC:
{
TNode tmp236_AST = null;
tmp236_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp236_AST);
match(INC);
break;
}
case DEC:
{
TNode tmp237_AST = null;
tmp237_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp237_AST);
match(DEC);
break;
}
default:
{
if ( _cnt307>=1 ) { break _loop307; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt307++;
} while (true);
}
postfixSuffix_AST = (TNode)currentAST.root;
returnAST = postfixSuffix_AST;
}
protected final void intConst() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode intConst_AST = null;
switch ( LA(1)) {
case IntOctalConst:
{
TNode tmp238_AST = null;
tmp238_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp238_AST);
match(IntOctalConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case LongOctalConst:
{
TNode tmp239_AST = null;
tmp239_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp239_AST);
match(LongOctalConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case UnsignedOctalConst:
{
TNode tmp240_AST = null;
tmp240_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp240_AST);
match(UnsignedOctalConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case IntIntConst:
{
TNode tmp241_AST = null;
tmp241_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp241_AST);
match(IntIntConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case LongIntConst:
{
TNode tmp242_AST = null;
tmp242_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp242_AST);
match(LongIntConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case UnsignedIntConst:
{
TNode tmp243_AST = null;
tmp243_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp243_AST);
match(UnsignedIntConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case IntHexConst:
{
TNode tmp244_AST = null;
tmp244_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp244_AST);
match(IntHexConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case LongHexConst:
{
TNode tmp245_AST = null;
tmp245_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp245_AST);
match(LongHexConst);
intConst_AST = (TNode)currentAST.root;
break;
}
case UnsignedHexConst:
{
TNode tmp246_AST = null;
tmp246_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp246_AST);
match(UnsignedHexConst);
intConst_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = intConst_AST;
}
protected final void floatConst() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode floatConst_AST = null;
switch ( LA(1)) {
case FloatDoubleConst:
{
TNode tmp247_AST = null;
tmp247_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp247_AST);
match(FloatDoubleConst);
floatConst_AST = (TNode)currentAST.root;
break;
}
case DoubleDoubleConst:
{
TNode tmp248_AST = null;
tmp248_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp248_AST);
match(DoubleDoubleConst);
floatConst_AST = (TNode)currentAST.root;
break;
}
case LongDoubleConst:
{
TNode tmp249_AST = null;
tmp249_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp249_AST);
match(LongDoubleConst);
floatConst_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = floatConst_AST;
}
public final void dummy() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
TNode dummy_AST = null;
switch ( LA(1)) {
case NTypedefName:
{
TNode tmp250_AST = null;
tmp250_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp250_AST);
match(NTypedefName);
dummy_AST = (TNode)currentAST.root;
break;
}
case NInitDecl:
{
TNode tmp251_AST = null;
tmp251_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp251_AST);
match(NInitDecl);
dummy_AST = (TNode)currentAST.root;
break;
}
case NDeclarator:
{
TNode tmp252_AST = null;
tmp252_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp252_AST);
match(NDeclarator);
dummy_AST = (TNode)currentAST.root;
break;
}
case NStructDeclarator:
{
TNode tmp253_AST = null;
tmp253_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp253_AST);
match(NStructDeclarator);
dummy_AST = (TNode)currentAST.root;
break;
}
case NDeclaration:
{
TNode tmp254_AST = null;
tmp254_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp254_AST);
match(NDeclaration);
dummy_AST = (TNode)currentAST.root;
break;
}
case NCast:
{
TNode tmp255_AST = null;
tmp255_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp255_AST);
match(NCast);
dummy_AST = (TNode)currentAST.root;
break;
}
case NPointerGroup:
{
TNode tmp256_AST = null;
tmp256_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp256_AST);
match(NPointerGroup);
dummy_AST = (TNode)currentAST.root;
break;
}
case NExpressionGroup:
{
TNode tmp257_AST = null;
tmp257_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp257_AST);
match(NExpressionGroup);
dummy_AST = (TNode)currentAST.root;
break;
}
case NFunctionCallArgs:
{
TNode tmp258_AST = null;
tmp258_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp258_AST);
match(NFunctionCallArgs);
dummy_AST = (TNode)currentAST.root;
break;
}
case NNonemptyAbstractDeclarator:
{
TNode tmp259_AST = null;
tmp259_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp259_AST);
match(NNonemptyAbstractDeclarator);
dummy_AST = (TNode)currentAST.root;
break;
}
case NInitializer:
{
TNode tmp260_AST = null;
tmp260_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp260_AST);
match(NInitializer);
dummy_AST = (TNode)currentAST.root;
break;
}
case NStatementExpr:
{
TNode tmp261_AST = null;
tmp261_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp261_AST);
match(NStatementExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NEmptyExpression:
{
TNode tmp262_AST = null;
tmp262_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp262_AST);
match(NEmptyExpression);
dummy_AST = (TNode)currentAST.root;
break;
}
case NParameterTypeList:
{
TNode tmp263_AST = null;
tmp263_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp263_AST);
match(NParameterTypeList);
dummy_AST = (TNode)currentAST.root;
break;
}
case NFunctionDef:
{
TNode tmp264_AST = null;
tmp264_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp264_AST);
match(NFunctionDef);
dummy_AST = (TNode)currentAST.root;
break;
}
case NCompoundStatement:
{
TNode tmp265_AST = null;
tmp265_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp265_AST);
match(NCompoundStatement);
dummy_AST = (TNode)currentAST.root;
break;
}
case NParameterDeclaration:
{
TNode tmp266_AST = null;
tmp266_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp266_AST);
match(NParameterDeclaration);
dummy_AST = (TNode)currentAST.root;
break;
}
case NCommaExpr:
{
TNode tmp267_AST = null;
tmp267_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp267_AST);
match(NCommaExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NUnaryExpr:
{
TNode tmp268_AST = null;
tmp268_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp268_AST);
match(NUnaryExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NLabel:
{
TNode tmp269_AST = null;
tmp269_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp269_AST);
match(NLabel);
dummy_AST = (TNode)currentAST.root;
break;
}
case NPostfixExpr:
{
TNode tmp270_AST = null;
tmp270_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp270_AST);
match(NPostfixExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NRangeExpr:
{
TNode tmp271_AST = null;
tmp271_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp271_AST);
match(NRangeExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NStringSeq:
{
TNode tmp272_AST = null;
tmp272_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp272_AST);
match(NStringSeq);
dummy_AST = (TNode)currentAST.root;
break;
}
case NInitializerElementLabel:
{
TNode tmp273_AST = null;
tmp273_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp273_AST);
match(NInitializerElementLabel);
dummy_AST = (TNode)currentAST.root;
break;
}
case NLcurlyInitializer:
{
TNode tmp274_AST = null;
tmp274_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp274_AST);
match(NLcurlyInitializer);
dummy_AST = (TNode)currentAST.root;
break;
}
case NAsmAttribute:
{
TNode tmp275_AST = null;
tmp275_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp275_AST);
match(NAsmAttribute);
dummy_AST = (TNode)currentAST.root;
break;
}
case NGnuAsmExpr:
{
TNode tmp276_AST = null;
tmp276_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp276_AST);
match(NGnuAsmExpr);
dummy_AST = (TNode)currentAST.root;
break;
}
case NTypeMissing:
{
TNode tmp277_AST = null;
tmp277_AST = (TNode)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp277_AST);
match(NTypeMissing);
dummy_AST = (TNode)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
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",
"\"__label__\"",
"\"inline\"",
"\"byte\"",
"\"boolean\"",
"\"typeof\"",
"\"__complex\"",
"\"__attribute\"",
"\"__alignof\"",
"\"__real\"",
"\"__imag\""
};
protected void buildTokenTypeASTClassMap() {
tokenTypeToASTClassMap=null;
};
private static final long[] mk_tokenSet_0() {
long[] data = { 6710886000L, 0L, 507904L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = { 268434512L, 0L, 507904L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
private static final long[] mk_tokenSet_2() {
long[] data = { 6710860864L, 0L, 507904L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
private static final long[] mk_tokenSet_3() {
long[] data = { 6576668672L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
private static final long[] mk_tokenSet_4() {
long[] data = { 268409920L, 0L, 507904L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
private static final long[] mk_tokenSet_5() {
long[] data = { 268180480L, 0L, 491520L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
private static final long[] mk_tokenSet_6() {
long[] data = { 2305843032970231968L, 3925505L, 7344128L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
private static final long[] mk_tokenSet_7() {
long[] data = { 17314086912L, 524288L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
private static final long[] mk_tokenSet_8() {
long[] data = { 2305843015790362784L, 3401217L, 7344128L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
private static final long[] mk_tokenSet_9() {
long[] data = { 2305843015790362656L, 3401217L, 7344128L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
private static final long[] mk_tokenSet_10() {
long[] data = { 8992587776L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
private static final long[] mk_tokenSet_11() {
long[] data = { 23622320128L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
private static final long[] mk_tokenSet_12() {
long[] data = { 8858370560L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
private static final long[] mk_tokenSet_13() {
long[] data = { 268311616L, 0L, 491520L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
private static final long[] mk_tokenSet_14() {
long[] data = { -13153337360L, -1L, 8388607L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
private static final long[] mk_tokenSet_15() {
long[] data = { 268434512L, 0L, 516096L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
private static final long[] mk_tokenSet_16() {
long[] data = { 6710869056L, 0L, 507904L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
private static final long[] mk_tokenSet_17() {
long[] data = { 2306265090816475808L, 3401217L, 7344128L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
private static final long[] mk_tokenSet_18() {
long[] data = { 2306405828304831392L, 3401217L, 7344128L, 0L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
private static final long[] mk_tokenSet_19() {
long[] data = { 2147483648L, 6144L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
}