PreprocessorExpressionParser.java

// $ANTLR 3.5.2 PreprocessorExpressionParser.g 2023-02-11 20:42:06

package edu.udel.cis.vsl.abc.front.c.preproc;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.tree.*;


@SuppressWarnings("all")
public class PreprocessorExpressionParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "AMPERSAND", "AND", "ANNOTATION_END", 
		"ANNOTATION_START", "ARROW", "ASSIGN", "AT", "BITANDEQ", "BITOR", "BITOREQ", 
		"BITXOR", "BITXOREQ", "BLOCK_COMMENT", "BinaryExponentPart", "CChar", 
		"CHARACTER_CONSTANT", "COLON", "COMMA", "COMMENT", "DEFINE", "DEFINED", 
		"DIV", "DIVEQ", "DOT", "DOTDOT", "DecimalConstant", "DecimalFloatingConstant", 
		"Digit", "ELIF", "ELLIPSIS", "ELSE", "ENDIF", "EQUALS", "EQUIV_ACSL", 
		"ERROR", "EXTENDED_IDENTIFIER", "EscapeSequence", "ExponentPart", "FLOATING_CONSTANT", 
		"FloatingSuffix", "FractionalConstant", "GT", "GTE", "HASH", "HASHHASH", 
		"HexEscape", "HexFractionalConstant", "HexPrefix", "HexQuad", "HexadecimalConstant", 
		"HexadecimalDigit", "HexadecimalFloatingConstant", "IDENTIFIER", "IF", 
		"IFDEF", "IFNDEF", "IMPLIES", "IMPLIES_ACSL", "INCLUDE", "INLINE_ANNOTATION_START", 
		"INLINE_COMMENT", "INTEGER_CONSTANT", "IdentifierNonDigit", "IntegerSuffix", 
		"LCURLY", "LEXCON", "LINE", "LPAREN", "LSLIST", "LSQUARE", "LT", "LTE", 
		"LongLongSuffix", "LongSuffix", "MINUSMINUS", "MOD", "MODEQ", "NEQ", "NEWLINE", 
		"NOT", "NonDigit", "NonZeroDigit", "OR", "OTHER", "OctalConstant", "OctalDigit", 
		"OctalEscape", "PLUS", "PLUSEQ", "PLUSPLUS", "PP_NUMBER", "PRAGMA", "QMARK", 
		"RCURLY", "REXCON", "RPAREN", "RSLIST", "RSQUARE", "SChar", "SEMI", "SHIFTLEFT", 
		"SHIFTLEFTEQ", "SHIFTRIGHT", "SHIFTRIGHTEQ", "STAR", "STAREQ", "STRING_LITERAL", 
		"SUB", "SUBEQ", "TILDE", "UNDEF", "UniversalCharacterName", "UnsignedSuffix", 
		"WS", "XOR_ACSL", "Zero", "EXPR"
	};
	public static final int EOF=-1;
	public static final int AMPERSAND=4;
	public static final int AND=5;
	public static final int ANNOTATION_END=6;
	public static final int ANNOTATION_START=7;
	public static final int ARROW=8;
	public static final int ASSIGN=9;
	public static final int AT=10;
	public static final int BITANDEQ=11;
	public static final int BITOR=12;
	public static final int BITOREQ=13;
	public static final int BITXOR=14;
	public static final int BITXOREQ=15;
	public static final int BLOCK_COMMENT=16;
	public static final int BinaryExponentPart=17;
	public static final int CChar=18;
	public static final int CHARACTER_CONSTANT=19;
	public static final int COLON=20;
	public static final int COMMA=21;
	public static final int COMMENT=22;
	public static final int DEFINE=23;
	public static final int DEFINED=24;
	public static final int DIV=25;
	public static final int DIVEQ=26;
	public static final int DOT=27;
	public static final int DOTDOT=28;
	public static final int DecimalConstant=29;
	public static final int DecimalFloatingConstant=30;
	public static final int Digit=31;
	public static final int ELIF=32;
	public static final int ELLIPSIS=33;
	public static final int ELSE=34;
	public static final int ENDIF=35;
	public static final int EQUALS=36;
	public static final int EQUIV_ACSL=37;
	public static final int ERROR=38;
	public static final int EXTENDED_IDENTIFIER=39;
	public static final int EscapeSequence=40;
	public static final int ExponentPart=41;
	public static final int FLOATING_CONSTANT=42;
	public static final int FloatingSuffix=43;
	public static final int FractionalConstant=44;
	public static final int GT=45;
	public static final int GTE=46;
	public static final int HASH=47;
	public static final int HASHHASH=48;
	public static final int HexEscape=49;
	public static final int HexFractionalConstant=50;
	public static final int HexPrefix=51;
	public static final int HexQuad=52;
	public static final int HexadecimalConstant=53;
	public static final int HexadecimalDigit=54;
	public static final int HexadecimalFloatingConstant=55;
	public static final int IDENTIFIER=56;
	public static final int IF=57;
	public static final int IFDEF=58;
	public static final int IFNDEF=59;
	public static final int IMPLIES=60;
	public static final int IMPLIES_ACSL=61;
	public static final int INCLUDE=62;
	public static final int INLINE_ANNOTATION_START=63;
	public static final int INLINE_COMMENT=64;
	public static final int INTEGER_CONSTANT=65;
	public static final int IdentifierNonDigit=66;
	public static final int IntegerSuffix=67;
	public static final int LCURLY=68;
	public static final int LEXCON=69;
	public static final int LINE=70;
	public static final int LPAREN=71;
	public static final int LSLIST=72;
	public static final int LSQUARE=73;
	public static final int LT=74;
	public static final int LTE=75;
	public static final int LongLongSuffix=76;
	public static final int LongSuffix=77;
	public static final int MINUSMINUS=78;
	public static final int MOD=79;
	public static final int MODEQ=80;
	public static final int NEQ=81;
	public static final int NEWLINE=82;
	public static final int NOT=83;
	public static final int NonDigit=84;
	public static final int NonZeroDigit=85;
	public static final int OR=86;
	public static final int OTHER=87;
	public static final int OctalConstant=88;
	public static final int OctalDigit=89;
	public static final int OctalEscape=90;
	public static final int PLUS=91;
	public static final int PLUSEQ=92;
	public static final int PLUSPLUS=93;
	public static final int PP_NUMBER=94;
	public static final int PRAGMA=95;
	public static final int QMARK=96;
	public static final int RCURLY=97;
	public static final int REXCON=98;
	public static final int RPAREN=99;
	public static final int RSLIST=100;
	public static final int RSQUARE=101;
	public static final int SChar=102;
	public static final int SEMI=103;
	public static final int SHIFTLEFT=104;
	public static final int SHIFTLEFTEQ=105;
	public static final int SHIFTRIGHT=106;
	public static final int SHIFTRIGHTEQ=107;
	public static final int STAR=108;
	public static final int STAREQ=109;
	public static final int STRING_LITERAL=110;
	public static final int SUB=111;
	public static final int SUBEQ=112;
	public static final int TILDE=113;
	public static final int UNDEF=114;
	public static final int UniversalCharacterName=115;
	public static final int UnsignedSuffix=116;
	public static final int WS=117;
	public static final int XOR_ACSL=118;
	public static final int Zero=119;
	public static final int EXPR=120;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// delegators


	public PreprocessorExpressionParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public PreprocessorExpressionParser(TokenStream input, RecognizerSharedState state) {
		super(input, state);
	}

	protected TreeAdaptor adaptor = new CommonTreeAdaptor();

	public void setTreeAdaptor(TreeAdaptor adaptor) {
		this.adaptor = adaptor;
	}
	public TreeAdaptor getTreeAdaptor() {
		return adaptor;
	}
	@Override public String[] getTokenNames() { return PreprocessorExpressionParser.tokenNames; }
	@Override public String getGrammarFileName() { return "PreprocessorExpressionParser.g"; }


	public static class start_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "start"
	// PreprocessorExpressionParser.g:24:1: start : expr EOF -> expr ;
	public final PreprocessorExpressionParser.start_return start() throws RecognitionException {
		PreprocessorExpressionParser.start_return retval = new PreprocessorExpressionParser.start_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token EOF2=null;
		ParserRuleReturnScope expr1 =null;

		Object EOF2_tree=null;
		RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// PreprocessorExpressionParser.g:24:8: ( expr EOF -> expr )
			// PreprocessorExpressionParser.g:24:10: expr EOF
			{
			pushFollow(FOLLOW_expr_in_start56);
			expr1=expr();
			state._fsp--;

			stream_expr.add(expr1.getTree());
			EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_start58);  
			stream_EOF.add(EOF2);

			// AST REWRITE
			// elements: expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 24:19: -> expr
			{
				adaptor.addChild(root_0, stream_expr.nextTree());
			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "start"


	public static class expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "expr"
	// PreprocessorExpressionParser.g:27:1: expr : logical_or_expr ;
	public final PreprocessorExpressionParser.expr_return expr() throws RecognitionException {
		PreprocessorExpressionParser.expr_return retval = new PreprocessorExpressionParser.expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope logical_or_expr3 =null;


		try {
			// PreprocessorExpressionParser.g:27:8: ( logical_or_expr )
			// PreprocessorExpressionParser.g:27:10: logical_or_expr
			{
			root_0 = (Object)adaptor.nil();


			pushFollow(FOLLOW_logical_or_expr_in_expr75);
			logical_or_expr3=logical_or_expr();
			state._fsp--;

			adaptor.addChild(root_0, logical_or_expr3.getTree());

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "expr"


	public static class logical_or_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "logical_or_expr"
	// PreprocessorExpressionParser.g:36:1: logical_or_expr : ( logical_and_expr -> logical_and_expr ) ( OR arg= logical_and_expr -> ^( OR $logical_or_expr $arg) )* ;
	public final PreprocessorExpressionParser.logical_or_expr_return logical_or_expr() throws RecognitionException {
		PreprocessorExpressionParser.logical_or_expr_return retval = new PreprocessorExpressionParser.logical_or_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token OR5=null;
		ParserRuleReturnScope arg =null;
		ParserRuleReturnScope logical_and_expr4 =null;

		Object OR5_tree=null;
		RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
		RewriteRuleSubtreeStream stream_logical_and_expr=new RewriteRuleSubtreeStream(adaptor,"rule logical_and_expr");

		try {
			// PreprocessorExpressionParser.g:36:17: ( ( logical_and_expr -> logical_and_expr ) ( OR arg= logical_and_expr -> ^( OR $logical_or_expr $arg) )* )
			// PreprocessorExpressionParser.g:36:19: ( logical_and_expr -> logical_and_expr ) ( OR arg= logical_and_expr -> ^( OR $logical_or_expr $arg) )*
			{
			// PreprocessorExpressionParser.g:36:19: ( logical_and_expr -> logical_and_expr )
			// PreprocessorExpressionParser.g:36:20: logical_and_expr
			{
			pushFollow(FOLLOW_logical_and_expr_in_logical_or_expr89);
			logical_and_expr4=logical_and_expr();
			state._fsp--;

			stream_logical_and_expr.add(logical_and_expr4.getTree());
			// AST REWRITE
			// elements: logical_and_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 36:37: -> logical_and_expr
			{
				adaptor.addChild(root_0, stream_logical_and_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:37:4: ( OR arg= logical_and_expr -> ^( OR $logical_or_expr $arg) )*
			loop1:
			while (true) {
				int alt1=2;
				int LA1_0 = input.LA(1);
				if ( (LA1_0==OR) ) {
					alt1=1;
				}

				switch (alt1) {
				case 1 :
					// PreprocessorExpressionParser.g:37:5: OR arg= logical_and_expr
					{
					OR5=(Token)match(input,OR,FOLLOW_OR_in_logical_or_expr100);  
					stream_OR.add(OR5);

					pushFollow(FOLLOW_logical_and_expr_in_logical_or_expr104);
					arg=logical_and_expr();
					state._fsp--;

					stream_logical_and_expr.add(arg.getTree());
					// AST REWRITE
					// elements: arg, OR, logical_or_expr
					// token labels: 
					// rule labels: arg, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg",arg!=null?arg.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 37:29: -> ^( OR $logical_or_expr $arg)
					{
						// PreprocessorExpressionParser.g:37:32: ^( OR $logical_or_expr $arg)
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_OR.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_arg.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop1;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "logical_or_expr"


	public static class logical_and_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "logical_and_expr"
	// PreprocessorExpressionParser.g:46:1: logical_and_expr : ( equality_expr -> equality_expr ) ( AND arg= equality_expr -> ^( AND $logical_and_expr $arg) )* ;
	public final PreprocessorExpressionParser.logical_and_expr_return logical_and_expr() throws RecognitionException {
		PreprocessorExpressionParser.logical_and_expr_return retval = new PreprocessorExpressionParser.logical_and_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token AND7=null;
		ParserRuleReturnScope arg =null;
		ParserRuleReturnScope equality_expr6 =null;

		Object AND7_tree=null;
		RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
		RewriteRuleSubtreeStream stream_equality_expr=new RewriteRuleSubtreeStream(adaptor,"rule equality_expr");

		try {
			// PreprocessorExpressionParser.g:46:17: ( ( equality_expr -> equality_expr ) ( AND arg= equality_expr -> ^( AND $logical_and_expr $arg) )* )
			// PreprocessorExpressionParser.g:46:19: ( equality_expr -> equality_expr ) ( AND arg= equality_expr -> ^( AND $logical_and_expr $arg) )*
			{
			// PreprocessorExpressionParser.g:46:19: ( equality_expr -> equality_expr )
			// PreprocessorExpressionParser.g:46:20: equality_expr
			{
			pushFollow(FOLLOW_equality_expr_in_logical_and_expr131);
			equality_expr6=equality_expr();
			state._fsp--;

			stream_equality_expr.add(equality_expr6.getTree());
			// AST REWRITE
			// elements: equality_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 46:34: -> equality_expr
			{
				adaptor.addChild(root_0, stream_equality_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:47:4: ( AND arg= equality_expr -> ^( AND $logical_and_expr $arg) )*
			loop2:
			while (true) {
				int alt2=2;
				int LA2_0 = input.LA(1);
				if ( (LA2_0==AND) ) {
					alt2=1;
				}

				switch (alt2) {
				case 1 :
					// PreprocessorExpressionParser.g:47:5: AND arg= equality_expr
					{
					AND7=(Token)match(input,AND,FOLLOW_AND_in_logical_and_expr142);  
					stream_AND.add(AND7);

					pushFollow(FOLLOW_equality_expr_in_logical_and_expr146);
					arg=equality_expr();
					state._fsp--;

					stream_equality_expr.add(arg.getTree());
					// AST REWRITE
					// elements: AND, logical_and_expr, arg
					// token labels: 
					// rule labels: arg, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg",arg!=null?arg.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 47:27: -> ^( AND $logical_and_expr $arg)
					{
						// PreprocessorExpressionParser.g:47:30: ^( AND $logical_and_expr $arg)
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_AND.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_arg.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop2;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "logical_and_expr"


	public static class equality_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "equality_expr"
	// PreprocessorExpressionParser.g:56:1: equality_expr : ( relational_expr -> relational_expr ) (op= equality_operator arg= relational_expr -> ^( $op $equality_expr $arg) )* ;
	public final PreprocessorExpressionParser.equality_expr_return equality_expr() throws RecognitionException {
		PreprocessorExpressionParser.equality_expr_return retval = new PreprocessorExpressionParser.equality_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope op =null;
		ParserRuleReturnScope arg =null;
		ParserRuleReturnScope relational_expr8 =null;

		RewriteRuleSubtreeStream stream_relational_expr=new RewriteRuleSubtreeStream(adaptor,"rule relational_expr");
		RewriteRuleSubtreeStream stream_equality_operator=new RewriteRuleSubtreeStream(adaptor,"rule equality_operator");

		try {
			// PreprocessorExpressionParser.g:56:15: ( ( relational_expr -> relational_expr ) (op= equality_operator arg= relational_expr -> ^( $op $equality_expr $arg) )* )
			// PreprocessorExpressionParser.g:56:17: ( relational_expr -> relational_expr ) (op= equality_operator arg= relational_expr -> ^( $op $equality_expr $arg) )*
			{
			// PreprocessorExpressionParser.g:56:17: ( relational_expr -> relational_expr )
			// PreprocessorExpressionParser.g:56:18: relational_expr
			{
			pushFollow(FOLLOW_relational_expr_in_equality_expr174);
			relational_expr8=relational_expr();
			state._fsp--;

			stream_relational_expr.add(relational_expr8.getTree());
			// AST REWRITE
			// elements: relational_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 56:34: -> relational_expr
			{
				adaptor.addChild(root_0, stream_relational_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:57:4: (op= equality_operator arg= relational_expr -> ^( $op $equality_expr $arg) )*
			loop3:
			while (true) {
				int alt3=2;
				int LA3_0 = input.LA(1);
				if ( (LA3_0==EQUALS||LA3_0==NEQ) ) {
					alt3=1;
				}

				switch (alt3) {
				case 1 :
					// PreprocessorExpressionParser.g:57:5: op= equality_operator arg= relational_expr
					{
					pushFollow(FOLLOW_equality_operator_in_equality_expr187);
					op=equality_operator();
					state._fsp--;

					stream_equality_operator.add(op.getTree());
					pushFollow(FOLLOW_relational_expr_in_equality_expr191);
					arg=relational_expr();
					state._fsp--;

					stream_relational_expr.add(arg.getTree());
					// AST REWRITE
					// elements: arg, equality_expr, op
					// token labels: 
					// rule labels: op, arg, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.getTree():null);
					RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg",arg!=null?arg.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 58:7: -> ^( $op $equality_expr $arg)
					{
						// PreprocessorExpressionParser.g:58:10: ^( $op $equality_expr $arg)
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_op.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_arg.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop3;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "equality_expr"


	public static class equality_operator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "equality_operator"
	// PreprocessorExpressionParser.g:61:1: equality_operator : ( EQUALS | NEQ );
	public final PreprocessorExpressionParser.equality_operator_return equality_operator() throws RecognitionException {
		PreprocessorExpressionParser.equality_operator_return retval = new PreprocessorExpressionParser.equality_operator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set9=null;

		Object set9_tree=null;

		try {
			// PreprocessorExpressionParser.g:62:3: ( EQUALS | NEQ )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set9=input.LT(1);
			if ( input.LA(1)==EQUALS||input.LA(1)==NEQ ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set9));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "equality_operator"


	public static class relational_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "relational_expr"
	// PreprocessorExpressionParser.g:72:1: relational_expr : ( additive_expr -> additive_expr ) (op= relational_operator arg= additive_expr -> ^( $op $relational_expr $arg) )* ;
	public final PreprocessorExpressionParser.relational_expr_return relational_expr() throws RecognitionException {
		PreprocessorExpressionParser.relational_expr_return retval = new PreprocessorExpressionParser.relational_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope op =null;
		ParserRuleReturnScope arg =null;
		ParserRuleReturnScope additive_expr10 =null;

		RewriteRuleSubtreeStream stream_additive_expr=new RewriteRuleSubtreeStream(adaptor,"rule additive_expr");
		RewriteRuleSubtreeStream stream_relational_operator=new RewriteRuleSubtreeStream(adaptor,"rule relational_operator");

		try {
			// PreprocessorExpressionParser.g:72:17: ( ( additive_expr -> additive_expr ) (op= relational_operator arg= additive_expr -> ^( $op $relational_expr $arg) )* )
			// PreprocessorExpressionParser.g:72:19: ( additive_expr -> additive_expr ) (op= relational_operator arg= additive_expr -> ^( $op $relational_expr $arg) )*
			{
			// PreprocessorExpressionParser.g:72:19: ( additive_expr -> additive_expr )
			// PreprocessorExpressionParser.g:72:20: additive_expr
			{
			pushFollow(FOLLOW_additive_expr_in_relational_expr245);
			additive_expr10=additive_expr();
			state._fsp--;

			stream_additive_expr.add(additive_expr10.getTree());
			// AST REWRITE
			// elements: additive_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 72:34: -> additive_expr
			{
				adaptor.addChild(root_0, stream_additive_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:73:4: (op= relational_operator arg= additive_expr -> ^( $op $relational_expr $arg) )*
			loop4:
			while (true) {
				int alt4=2;
				int LA4_0 = input.LA(1);
				if ( ((LA4_0 >= GT && LA4_0 <= GTE)||(LA4_0 >= LT && LA4_0 <= LTE)) ) {
					alt4=1;
				}

				switch (alt4) {
				case 1 :
					// PreprocessorExpressionParser.g:73:5: op= relational_operator arg= additive_expr
					{
					pushFollow(FOLLOW_relational_operator_in_relational_expr258);
					op=relational_operator();
					state._fsp--;

					stream_relational_operator.add(op.getTree());
					pushFollow(FOLLOW_additive_expr_in_relational_expr262);
					arg=additive_expr();
					state._fsp--;

					stream_additive_expr.add(arg.getTree());
					// AST REWRITE
					// elements: op, relational_expr, arg
					// token labels: 
					// rule labels: op, arg, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.getTree():null);
					RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg",arg!=null?arg.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 74:7: -> ^( $op $relational_expr $arg)
					{
						// PreprocessorExpressionParser.g:74:10: ^( $op $relational_expr $arg)
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_op.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_arg.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop4;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "relational_expr"


	public static class relational_operator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "relational_operator"
	// PreprocessorExpressionParser.g:77:1: relational_operator : ( LT | GT | LTE | GTE );
	public final PreprocessorExpressionParser.relational_operator_return relational_operator() throws RecognitionException {
		PreprocessorExpressionParser.relational_operator_return retval = new PreprocessorExpressionParser.relational_operator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set11=null;

		Object set11_tree=null;

		try {
			// PreprocessorExpressionParser.g:78:3: ( LT | GT | LTE | GTE )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set11=input.LT(1);
			if ( (input.LA(1) >= GT && input.LA(1) <= GTE)||(input.LA(1) >= LT && input.LA(1) <= LTE) ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set11));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "relational_operator"


	public static class additive_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "additive_expr"
	// PreprocessorExpressionParser.g:89:1: additive_expr : ( multi_expr -> multi_expr ) ( additive_operator arg= multi_expr -> ^( additive_operator $additive_expr $arg) )* ;
	public final PreprocessorExpressionParser.additive_expr_return additive_expr() throws RecognitionException {
		PreprocessorExpressionParser.additive_expr_return retval = new PreprocessorExpressionParser.additive_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope arg =null;
		ParserRuleReturnScope multi_expr12 =null;
		ParserRuleReturnScope additive_operator13 =null;

		RewriteRuleSubtreeStream stream_additive_operator=new RewriteRuleSubtreeStream(adaptor,"rule additive_operator");
		RewriteRuleSubtreeStream stream_multi_expr=new RewriteRuleSubtreeStream(adaptor,"rule multi_expr");

		try {
			// PreprocessorExpressionParser.g:89:15: ( ( multi_expr -> multi_expr ) ( additive_operator arg= multi_expr -> ^( additive_operator $additive_expr $arg) )* )
			// PreprocessorExpressionParser.g:89:17: ( multi_expr -> multi_expr ) ( additive_operator arg= multi_expr -> ^( additive_operator $additive_expr $arg) )*
			{
			// PreprocessorExpressionParser.g:89:17: ( multi_expr -> multi_expr )
			// PreprocessorExpressionParser.g:89:18: multi_expr
			{
			pushFollow(FOLLOW_multi_expr_in_additive_expr328);
			multi_expr12=multi_expr();
			state._fsp--;

			stream_multi_expr.add(multi_expr12.getTree());
			// AST REWRITE
			// elements: multi_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 89:29: -> multi_expr
			{
				adaptor.addChild(root_0, stream_multi_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:90:4: ( additive_operator arg= multi_expr -> ^( additive_operator $additive_expr $arg) )*
			loop5:
			while (true) {
				int alt5=2;
				int LA5_0 = input.LA(1);
				if ( (LA5_0==PLUS||LA5_0==SUB) ) {
					alt5=1;
				}

				switch (alt5) {
				case 1 :
					// PreprocessorExpressionParser.g:90:5: additive_operator arg= multi_expr
					{
					pushFollow(FOLLOW_additive_operator_in_additive_expr339);
					additive_operator13=additive_operator();
					state._fsp--;

					stream_additive_operator.add(additive_operator13.getTree());
					pushFollow(FOLLOW_multi_expr_in_additive_expr343);
					arg=multi_expr();
					state._fsp--;

					stream_multi_expr.add(arg.getTree());
					// AST REWRITE
					// elements: arg, additive_operator, additive_expr
					// token labels: 
					// rule labels: arg, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_arg=new RewriteRuleSubtreeStream(adaptor,"rule arg",arg!=null?arg.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 91:7: -> ^( additive_operator $additive_expr $arg)
					{
						// PreprocessorExpressionParser.g:91:10: ^( additive_operator $additive_expr $arg)
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_additive_operator.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_arg.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop5;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "additive_expr"


	public static class additive_operator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "additive_operator"
	// PreprocessorExpressionParser.g:93:1: additive_operator : ( PLUS | SUB );
	public final PreprocessorExpressionParser.additive_operator_return additive_operator() throws RecognitionException {
		PreprocessorExpressionParser.additive_operator_return retval = new PreprocessorExpressionParser.additive_operator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set14=null;

		Object set14_tree=null;

		try {
			// PreprocessorExpressionParser.g:94:3: ( PLUS | SUB )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set14=input.LT(1);
			if ( input.LA(1)==PLUS||input.LA(1)==SUB ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set14));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "additive_operator"


	public static class multi_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "multi_expr"
	// PreprocessorExpressionParser.g:103:1: multi_expr : ( unary_expr -> unary_expr ) ( multi_operator unary_expr -> ^( multi_operator $multi_expr unary_expr ) )* ;
	public final PreprocessorExpressionParser.multi_expr_return multi_expr() throws RecognitionException {
		PreprocessorExpressionParser.multi_expr_return retval = new PreprocessorExpressionParser.multi_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope unary_expr15 =null;
		ParserRuleReturnScope multi_operator16 =null;
		ParserRuleReturnScope unary_expr17 =null;

		RewriteRuleSubtreeStream stream_unary_expr=new RewriteRuleSubtreeStream(adaptor,"rule unary_expr");
		RewriteRuleSubtreeStream stream_multi_operator=new RewriteRuleSubtreeStream(adaptor,"rule multi_operator");

		try {
			// PreprocessorExpressionParser.g:103:12: ( ( unary_expr -> unary_expr ) ( multi_operator unary_expr -> ^( multi_operator $multi_expr unary_expr ) )* )
			// PreprocessorExpressionParser.g:103:14: ( unary_expr -> unary_expr ) ( multi_operator unary_expr -> ^( multi_operator $multi_expr unary_expr ) )*
			{
			// PreprocessorExpressionParser.g:103:14: ( unary_expr -> unary_expr )
			// PreprocessorExpressionParser.g:103:15: unary_expr
			{
			pushFollow(FOLLOW_unary_expr_in_multi_expr396);
			unary_expr15=unary_expr();
			state._fsp--;

			stream_unary_expr.add(unary_expr15.getTree());
			// AST REWRITE
			// elements: unary_expr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 103:26: -> unary_expr
			{
				adaptor.addChild(root_0, stream_unary_expr.nextTree());
			}


			retval.tree = root_0;

			}

			// PreprocessorExpressionParser.g:104:4: ( multi_operator unary_expr -> ^( multi_operator $multi_expr unary_expr ) )*
			loop6:
			while (true) {
				int alt6=2;
				int LA6_0 = input.LA(1);
				if ( (LA6_0==DIV||LA6_0==MOD||LA6_0==STAR) ) {
					alt6=1;
				}

				switch (alt6) {
				case 1 :
					// PreprocessorExpressionParser.g:104:5: multi_operator unary_expr
					{
					pushFollow(FOLLOW_multi_operator_in_multi_expr407);
					multi_operator16=multi_operator();
					state._fsp--;

					stream_multi_operator.add(multi_operator16.getTree());
					pushFollow(FOLLOW_unary_expr_in_multi_expr409);
					unary_expr17=unary_expr();
					state._fsp--;

					stream_unary_expr.add(unary_expr17.getTree());
					// AST REWRITE
					// elements: unary_expr, multi_operator, multi_expr
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 105:7: -> ^( multi_operator $multi_expr unary_expr )
					{
						// PreprocessorExpressionParser.g:105:10: ^( multi_operator $multi_expr unary_expr )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_multi_operator.nextNode(), root_1);
						adaptor.addChild(root_1, stream_retval.nextTree());
						adaptor.addChild(root_1, stream_unary_expr.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

				default :
					break loop6;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "multi_expr"


	public static class multi_operator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "multi_operator"
	// PreprocessorExpressionParser.g:108:1: multi_operator : ( STAR | DIV | MOD );
	public final PreprocessorExpressionParser.multi_operator_return multi_operator() throws RecognitionException {
		PreprocessorExpressionParser.multi_operator_return retval = new PreprocessorExpressionParser.multi_operator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set18=null;

		Object set18_tree=null;

		try {
			// PreprocessorExpressionParser.g:108:16: ( STAR | DIV | MOD )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set18=input.LT(1);
			if ( input.LA(1)==DIV||input.LA(1)==MOD||input.LA(1)==STAR ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set18));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "multi_operator"


	public static class unary_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "unary_expr"
	// PreprocessorExpressionParser.g:117:1: unary_expr : ( primary_expr | unary_operator unary_expr -> ^( unary_operator unary_expr ) );
	public final PreprocessorExpressionParser.unary_expr_return unary_expr() throws RecognitionException {
		PreprocessorExpressionParser.unary_expr_return retval = new PreprocessorExpressionParser.unary_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope primary_expr19 =null;
		ParserRuleReturnScope unary_operator20 =null;
		ParserRuleReturnScope unary_expr21 =null;

		RewriteRuleSubtreeStream stream_unary_expr=new RewriteRuleSubtreeStream(adaptor,"rule unary_expr");
		RewriteRuleSubtreeStream stream_unary_operator=new RewriteRuleSubtreeStream(adaptor,"rule unary_operator");

		try {
			// PreprocessorExpressionParser.g:117:12: ( primary_expr | unary_operator unary_expr -> ^( unary_operator unary_expr ) )
			int alt7=2;
			int LA7_0 = input.LA(1);
			if ( (LA7_0==DEFINED||LA7_0==FLOATING_CONSTANT||LA7_0==IDENTIFIER||LA7_0==INTEGER_CONSTANT||LA7_0==LPAREN||LA7_0==PP_NUMBER) ) {
				alt7=1;
			}
			else if ( (LA7_0==NOT||LA7_0==PLUS||LA7_0==STAR||LA7_0==SUB) ) {
				alt7=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 7, 0, input);
				throw nvae;
			}

			switch (alt7) {
				case 1 :
					// PreprocessorExpressionParser.g:117:14: primary_expr
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_primary_expr_in_unary_expr464);
					primary_expr19=primary_expr();
					state._fsp--;

					adaptor.addChild(root_0, primary_expr19.getTree());

					}
					break;
				case 2 :
					// PreprocessorExpressionParser.g:118:5: unary_operator unary_expr
					{
					pushFollow(FOLLOW_unary_operator_in_unary_expr470);
					unary_operator20=unary_operator();
					state._fsp--;

					stream_unary_operator.add(unary_operator20.getTree());
					pushFollow(FOLLOW_unary_expr_in_unary_expr472);
					unary_expr21=unary_expr();
					state._fsp--;

					stream_unary_expr.add(unary_expr21.getTree());
					// AST REWRITE
					// elements: unary_expr, unary_operator
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 118:31: -> ^( unary_operator unary_expr )
					{
						// PreprocessorExpressionParser.g:118:34: ^( unary_operator unary_expr )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_unary_operator.nextNode(), root_1);
						adaptor.addChild(root_1, stream_unary_expr.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

			}
			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "unary_expr"


	public static class unary_operator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "unary_operator"
	// PreprocessorExpressionParser.g:121:1: unary_operator : ( PLUS | SUB | NOT | STAR );
	public final PreprocessorExpressionParser.unary_operator_return unary_operator() throws RecognitionException {
		PreprocessorExpressionParser.unary_operator_return retval = new PreprocessorExpressionParser.unary_operator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set22=null;

		Object set22_tree=null;

		try {
			// PreprocessorExpressionParser.g:121:16: ( PLUS | SUB | NOT | STAR )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set22=input.LT(1);
			if ( input.LA(1)==NOT||input.LA(1)==PLUS||input.LA(1)==STAR||input.LA(1)==SUB ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set22));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "unary_operator"


	public static class primary_expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "primary_expr"
	// PreprocessorExpressionParser.g:127:1: primary_expr : ( pp_number | LPAREN expr RPAREN -> expr | DEFINED ( identifier | LPAREN identifier RPAREN ) -> ^( DEFINED identifier ) | identifier );
	public final PreprocessorExpressionParser.primary_expr_return primary_expr() throws RecognitionException {
		PreprocessorExpressionParser.primary_expr_return retval = new PreprocessorExpressionParser.primary_expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token LPAREN24=null;
		Token RPAREN26=null;
		Token DEFINED27=null;
		Token LPAREN29=null;
		Token RPAREN31=null;
		ParserRuleReturnScope pp_number23 =null;
		ParserRuleReturnScope expr25 =null;
		ParserRuleReturnScope identifier28 =null;
		ParserRuleReturnScope identifier30 =null;
		ParserRuleReturnScope identifier32 =null;

		Object LPAREN24_tree=null;
		Object RPAREN26_tree=null;
		Object DEFINED27_tree=null;
		Object LPAREN29_tree=null;
		Object RPAREN31_tree=null;
		RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
		RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
		RewriteRuleTokenStream stream_DEFINED=new RewriteRuleTokenStream(adaptor,"token DEFINED");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// PreprocessorExpressionParser.g:127:14: ( pp_number | LPAREN expr RPAREN -> expr | DEFINED ( identifier | LPAREN identifier RPAREN ) -> ^( DEFINED identifier ) | identifier )
			int alt9=4;
			switch ( input.LA(1) ) {
			case FLOATING_CONSTANT:
			case INTEGER_CONSTANT:
			case PP_NUMBER:
				{
				alt9=1;
				}
				break;
			case LPAREN:
				{
				alt9=2;
				}
				break;
			case DEFINED:
				{
				alt9=3;
				}
				break;
			case IDENTIFIER:
				{
				alt9=4;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 9, 0, input);
				throw nvae;
			}
			switch (alt9) {
				case 1 :
					// PreprocessorExpressionParser.g:127:16: pp_number
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pp_number_in_primary_expr523);
					pp_number23=pp_number();
					state._fsp--;

					adaptor.addChild(root_0, pp_number23.getTree());

					}
					break;
				case 2 :
					// PreprocessorExpressionParser.g:128:5: LPAREN expr RPAREN
					{
					LPAREN24=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_primary_expr529);  
					stream_LPAREN.add(LPAREN24);

					pushFollow(FOLLOW_expr_in_primary_expr531);
					expr25=expr();
					state._fsp--;

					stream_expr.add(expr25.getTree());
					RPAREN26=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_primary_expr533);  
					stream_RPAREN.add(RPAREN26);

					// AST REWRITE
					// elements: expr
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 128:24: -> expr
					{
						adaptor.addChild(root_0, stream_expr.nextTree());
					}


					retval.tree = root_0;

					}
					break;
				case 3 :
					// PreprocessorExpressionParser.g:129:5: DEFINED ( identifier | LPAREN identifier RPAREN )
					{
					DEFINED27=(Token)match(input,DEFINED,FOLLOW_DEFINED_in_primary_expr543);  
					stream_DEFINED.add(DEFINED27);

					// PreprocessorExpressionParser.g:129:13: ( identifier | LPAREN identifier RPAREN )
					int alt8=2;
					int LA8_0 = input.LA(1);
					if ( (LA8_0==IDENTIFIER) ) {
						alt8=1;
					}
					else if ( (LA8_0==LPAREN) ) {
						alt8=2;
					}

					else {
						NoViableAltException nvae =
							new NoViableAltException("", 8, 0, input);
						throw nvae;
					}

					switch (alt8) {
						case 1 :
							// PreprocessorExpressionParser.g:129:15: identifier
							{
							pushFollow(FOLLOW_identifier_in_primary_expr547);
							identifier28=identifier();
							state._fsp--;

							stream_identifier.add(identifier28.getTree());
							}
							break;
						case 2 :
							// PreprocessorExpressionParser.g:129:28: LPAREN identifier RPAREN
							{
							LPAREN29=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_primary_expr551);  
							stream_LPAREN.add(LPAREN29);

							pushFollow(FOLLOW_identifier_in_primary_expr553);
							identifier30=identifier();
							state._fsp--;

							stream_identifier.add(identifier30.getTree());
							RPAREN31=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_primary_expr555);  
							stream_RPAREN.add(RPAREN31);

							}
							break;

					}

					// AST REWRITE
					// elements: identifier, DEFINED
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 130:4: -> ^( DEFINED identifier )
					{
						// PreprocessorExpressionParser.g:130:7: ^( DEFINED identifier )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_DEFINED.nextNode(), root_1);
						adaptor.addChild(root_1, stream_identifier.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;
				case 4 :
					// PreprocessorExpressionParser.g:131:5: identifier
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_identifier_in_primary_expr574);
					identifier32=identifier();
					state._fsp--;

					adaptor.addChild(root_0, identifier32.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "primary_expr"


	public static class white_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "white"
	// PreprocessorExpressionParser.g:135:1: white : ( WS | NEWLINE );
	public final PreprocessorExpressionParser.white_return white() throws RecognitionException {
		PreprocessorExpressionParser.white_return retval = new PreprocessorExpressionParser.white_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set33=null;

		Object set33_tree=null;

		try {
			// PreprocessorExpressionParser.g:135:8: ( WS | NEWLINE )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set33=input.LT(1);
			if ( input.LA(1)==NEWLINE||input.LA(1)==WS ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set33));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "white"


	public static class identifier_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "identifier"
	// PreprocessorExpressionParser.g:140:1: identifier : IDENTIFIER ;
	public final PreprocessorExpressionParser.identifier_return identifier() throws RecognitionException {
		PreprocessorExpressionParser.identifier_return retval = new PreprocessorExpressionParser.identifier_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token IDENTIFIER34=null;

		Object IDENTIFIER34_tree=null;

		try {
			// PreprocessorExpressionParser.g:140:12: ( IDENTIFIER )
			// PreprocessorExpressionParser.g:140:14: IDENTIFIER
			{
			root_0 = (Object)adaptor.nil();


			IDENTIFIER34=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier605); 
			IDENTIFIER34_tree = (Object)adaptor.create(IDENTIFIER34);
			adaptor.addChild(root_0, IDENTIFIER34_tree);

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "identifier"


	public static class pp_number_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pp_number"
	// PreprocessorExpressionParser.g:143:1: pp_number : ( INTEGER_CONSTANT | FLOATING_CONSTANT | PP_NUMBER );
	public final PreprocessorExpressionParser.pp_number_return pp_number() throws RecognitionException {
		PreprocessorExpressionParser.pp_number_return retval = new PreprocessorExpressionParser.pp_number_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set35=null;

		Object set35_tree=null;

		try {
			// PreprocessorExpressionParser.g:143:11: ( INTEGER_CONSTANT | FLOATING_CONSTANT | PP_NUMBER )
			// PreprocessorExpressionParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set35=input.LT(1);
			if ( input.LA(1)==FLOATING_CONSTANT||input.LA(1)==INTEGER_CONSTANT||input.LA(1)==PP_NUMBER ) {
				input.consume();
				adaptor.addChild(root_0, (Object)adaptor.create(set35));
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pp_number"

	// Delegated rules



	public static final BitSet FOLLOW_expr_in_start56 = new BitSet(new long[]{0x0000000000000000L});
	public static final BitSet FOLLOW_EOF_in_start58 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_logical_or_expr_in_expr75 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_logical_and_expr_in_logical_or_expr89 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
	public static final BitSet FOLLOW_OR_in_logical_or_expr100 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_logical_and_expr_in_logical_or_expr104 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
	public static final BitSet FOLLOW_equality_expr_in_logical_and_expr131 = new BitSet(new long[]{0x0000000000000022L});
	public static final BitSet FOLLOW_AND_in_logical_and_expr142 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_equality_expr_in_logical_and_expr146 = new BitSet(new long[]{0x0000000000000022L});
	public static final BitSet FOLLOW_relational_expr_in_equality_expr174 = new BitSet(new long[]{0x0000001000000002L,0x0000000000020000L});
	public static final BitSet FOLLOW_equality_operator_in_equality_expr187 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_relational_expr_in_equality_expr191 = new BitSet(new long[]{0x0000001000000002L,0x0000000000020000L});
	public static final BitSet FOLLOW_additive_expr_in_relational_expr245 = new BitSet(new long[]{0x0000600000000002L,0x0000000000000C00L});
	public static final BitSet FOLLOW_relational_operator_in_relational_expr258 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_additive_expr_in_relational_expr262 = new BitSet(new long[]{0x0000600000000002L,0x0000000000000C00L});
	public static final BitSet FOLLOW_multi_expr_in_additive_expr328 = new BitSet(new long[]{0x0000000000000002L,0x0000800008000000L});
	public static final BitSet FOLLOW_additive_operator_in_additive_expr339 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_multi_expr_in_additive_expr343 = new BitSet(new long[]{0x0000000000000002L,0x0000800008000000L});
	public static final BitSet FOLLOW_unary_expr_in_multi_expr396 = new BitSet(new long[]{0x0000000002000002L,0x0000100000008000L});
	public static final BitSet FOLLOW_multi_operator_in_multi_expr407 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_unary_expr_in_multi_expr409 = new BitSet(new long[]{0x0000000002000002L,0x0000100000008000L});
	public static final BitSet FOLLOW_primary_expr_in_unary_expr464 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_unary_operator_in_unary_expr470 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_unary_expr_in_unary_expr472 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pp_number_in_primary_expr523 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LPAREN_in_primary_expr529 = new BitSet(new long[]{0x0100040001000000L,0x0000900048080082L});
	public static final BitSet FOLLOW_expr_in_primary_expr531 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_primary_expr533 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_DEFINED_in_primary_expr543 = new BitSet(new long[]{0x0100000000000000L,0x0000000000000080L});
	public static final BitSet FOLLOW_identifier_in_primary_expr547 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LPAREN_in_primary_expr551 = new BitSet(new long[]{0x0100000000000000L});
	public static final BitSet FOLLOW_identifier_in_primary_expr553 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_primary_expr555 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_identifier_in_primary_expr574 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IDENTIFIER_in_identifier605 = new BitSet(new long[]{0x0000000000000002L});
}