nescobjecttreebuilder.g

plugin for eclipse

        												}
        |       #( rsn:"return" ( expr1Obj = expr )? 	{	ReturnStatement rstObj = new ReturnStatement();
        													rstObj.setDefNode(rsn);
        													rstObj.setReturnExpression(expr1Obj);
        													stObj = rstObj;
        												}
        		)


// Labeled statements:
        |       #( NLabel l:ID (st1Obj = statement)? 	{	LabeledStatement lstObj = new LabeledStatement();        	
        													lstObj.setLabelNode(l);
        													lstObj.setStatement(st1Obj);
        													stObj = lstObj;
        												}
        		)
        |       #( casn:"case" expr1Obj = expr
        			 (st1Obj = statement)?
        												{
        													CaseStatement castObj = new CaseStatement();
        													castObj.setDefNode(casn);
        													castObj.setCaseExpression(expr1Obj);
        													castObj.setStatement(st1Obj);
        													stObj = castObj;
        												}
        		)
        |       #( dcn:"default" (st1Obj = statement)? )
        												{	DefaultCaseStatement dcstObj = new DefaultCaseStatement();
        													dcstObj.setDefNode(dcn);
        													dcstObj.setStatement(st1Obj);
        													stObj = dcstObj;
        												}

// Selection statements:

        |       #( in:"if"
                    expr1Obj = expr
                    st1Obj = statement  
                    ( en:"else" 
                    st2Obj = statement )?
                    									{	IfStatement ifstObj = new IfStatement();
                    										ifstObj.setDefNode(in);
                    										ifstObj.setCondition(expr1Obj);
                    										ifstObj.setTrueBranchStatement(st1Obj);
                    										ifstObj.setElseNode(en);
                    										ifstObj.setFalseBranchStatement(st2Obj);
                    										stObj = ifstObj;
                    									}
                 )
        |       #( swn:"switch" expr1Obj = expr	
        			st1Obj = statement )				{	SwitchStatement swstObj = new SwitchStatement();
        													swstObj.setDefNode(swn);
        													swstObj.setSwitchExpression(expr1Obj);
        													swstObj.setStatement(st1Obj);
        													stObj = swstObj;
        												}
        ;

expr returns [Expression exprObj = new Expression()] :
		
				n1:assignExpr							{ exprObj.setDefNode(n1); }
        |       n2:conditionalExpr						{ exprObj.setDefNode(n2); }
        |       n3:logicalOrExpr						{ exprObj.setDefNode(n3); }
        |       n4:logicalAndExpr						{ exprObj.setDefNode(n4); }
        |       n5:inclusiveOrExpr						{ exprObj.setDefNode(n5); }
        |       n6:exclusiveOrExpr						{ exprObj.setDefNode(n6); }
        |       n7:bitAndExpr							{ exprObj.setDefNode(n7); }
        |       n8:equalityExpr							{ exprObj.setDefNode(n8); }
        |       n9:relationalExpr						{ exprObj.setDefNode(n9); }
        |       n10:shiftExpr							{ exprObj.setDefNode(n10); }
        |       n11:additiveExpr						{ exprObj.setDefNode(n11); }
        |       n12:multExpr							{ exprObj.setDefNode(n12); }
        |       n13:castExpr							{ exprObj.setDefNode(n13); }
        |       n14:unaryExpr							{ exprObj.setDefNode(n14); }
        |       n15:postfixExpr							{ exprObj.setDefNode(n15); }
        |       n16:primaryExpr							{ exprObj.setDefNode(n16); }
        |       n17:commaExpr							{ exprObj.setDefNode(n17); }
        |       n18:emptyExpr							{ exprObj.setDefNode(n18); }
        |       n19:compoundStatementExpr				{ exprObj.setDefNode(n19); }
        |       n20:initializer							{ exprObj.setDefNode(n20); }
        |       n21:rangeExpr							{ exprObj.setDefNode(n21); }
        |       n22:gnuAsmExpr							{ exprObj.setDefNode(n22); }
        ;

commaExpr :#(NCommaExpr expr expr)
        ;

emptyExpr :NEmptyExpression
        ;

compoundStatementExpr :#(LPAREN compoundStatement[null,null] RPAREN)
        ;

rangeExpr :#(NRangeExpr expr VARARGS expr)
        ;

gnuAsmExpr :#(NGnuAsmExpr
                ("volatile")? 
                LPAREN stringConst
                ( options { warnWhenFollowAmbig = false; }:
                  COLON (strOptExprPair ( COMMA strOptExprPair)* )?
                  ( options { warnWhenFollowAmbig = false; }:
                    COLON (strOptExprPair ( COMMA strOptExprPair)* )?
                  )?
                )?
                ( COLON stringConst ( COMMA stringConst)* )?
                RPAREN
            )
        ;

strOptExprPair :stringConst ( LPAREN expr RPAREN )?
        ;

assignExpr :#( ASSIGN expr expr)
        |       #( DIV_ASSIGN expr expr)
        |       #( PLUS_ASSIGN expr expr)
        |       #( MINUS_ASSIGN expr expr)
        |       #( STAR_ASSIGN expr expr)
        |       #( MOD_ASSIGN expr expr)
        |       #( RSHIFT_ASSIGN expr expr)
        |       #( LSHIFT_ASSIGN expr expr)
        |       #( BAND_ASSIGN expr expr)
        |       #( BOR_ASSIGN expr expr)
        |       #( BXOR_ASSIGN expr expr)
        ;

conditionalExpr :#( QUESTION expr (expr)? COLON expr )
        ;

logicalOrExpr :#( LOR expr expr) 
        ;

logicalAndExpr :#( LAND expr expr )
        ;

inclusiveOrExpr :#( BOR expr expr )
        ;

exclusiveOrExpr :#( BXOR expr expr )
        ;

bitAndExpr :#( BAND expr expr )
        ;

equalityExpr :#( EQUAL expr expr)
        |       #( NOT_EQUAL expr expr)
        ;

relationalExpr :#( LT expr expr)
        |       #( LTE expr expr)
        |       #( GT expr expr)
        |       #( GTE expr expr)
        ;

shiftExpr :#( LSHIFT expr expr)
                | #( RSHIFT expr expr)
        ;

additiveExpr :#( PLUS expr expr)
        |       #( MINUS expr expr)
        ;

multExpr :#( STAR expr expr)
        |       #( DIV expr expr)
        |       #( MOD expr expr)
        ;

castExpr :#( NCast typeName RPAREN expr)
        ;

typeName :specifierQualifierList (nonemptyAbstractDeclarator)?
        ;

nonemptyAbstractDeclarator returns [AbstractDeclarator adObj]
														{	adObj = null;
															PointerGroup pgObj = null; 
															AbstractDeclarator childAdObj = null;
															ParameterTypeList childPtlObj = null;
															ArrayConstructor acObj = null;
														}
		: 	#( ad:NNonemptyAbstractDeclarator			{	adObj = new AbstractDeclarator();
															adObj.setDefNode(ad);
														}
               ( pgObj = pointerGroup					{	adObj.setPointerGroup(pgObj); }
                (   (lp1:LPAREN							
                    (   childAdObj = nonemptyAbstractDeclarator
                    									{	adObj.addNestedDecl(childAdObj); }
                        | childPtlObj = parameterTypeList	
                        								{	adObj.addParameterTypeList(childPtlObj); }
                    )?
                    RPAREN)
                | ( lb1:LBRACKET 						{	acObj = new ArrayConstructor();
                											acObj.setDefNode(lb1);
                											adObj.addArrayConstructor(acObj);
                										}
                    (expr)?
                    RBRACKET)
                )*

            |  (   (lp2:LPAREN
                    (   childAdObj = nonemptyAbstractDeclarator
                    									{	adObj.addNestedDecl(childAdObj); }               
                        | childPtlObj = parameterTypeList
                        								{	adObj.addParameterTypeList(childPtlObj); }
                    )?
                    RPAREN)
                | ( lb2:LBRACKET 						{	acObj = new ArrayConstructor();
                											acObj.setDefNode(lb2);
                											adObj.addArrayConstructor(acObj);
                										}
                    (expr)?
                    RBRACKET)
                )+
            )
            )
        ;

unaryExpr :#( INC expr )
        |       #( DEC expr )
        |       #( NUnaryExpr unaryOperator expr)
        |       #( "sizeof"
                    ( ( LPAREN typeName )=> LPAREN typeName RPAREN
                    | expr
                    )
                )
        |       #( "__alignof"
                    ( ( LPAREN typeName )=> LPAREN typeName RPAREN
                    | expr
                    )
                )
        ;

unaryOperator :BAND
        |       STAR
        |       PLUS
        |       MINUS
        |       BNOT
        |       LNOT
        |       LAND
        |       "__real"
        |       "__imag"
        ;

postfixExpr :#( NPostfixExpr
                  (
                    (    
                        primaryExpr
                        ( a:PTR b:ID                                
                        | c:DOT d:ID                                
                        | #( n:NFunctionCallArgs                    
                            (argExprList)?
                            rp:RPAREN                               
                            )
                        | lb:LBRACKET                               
                            expr 
                            rb:RBRACKET                             
                        | f:INC                                     
                        | g:DEC                                     
                        )+
                     )

                | 
                  ( c2:"call" | s2:"signal"  )
                  ifid:ID                 
                  (d2:DOT 
                  fnid:ID)?
														                  
                  (interfaceParamArgs)?                    
                  #( n2:NFunctionCallArgs                    
                     (argExprList)?
                     rp2:RPAREN                              
                   )
       
                | 
                  p3:"post"
                  primaryExpr
                  #( n3:NFunctionCallArgs                    
                     (argExprList)?
                     rp3:RPAREN                              
                   )
                )
               )            
       ;

interfaceParamArgs returns [List exprListObj = null]
		 :#(lb:NInterfaceParamArgs               
              exprListObj = argExprList
              rb:RBRACKET                          
             )
        ;

primaryExpr :id:ID										
        |       Number
        |       charConst
        |       stringConst

// JTC:
// ID should catch the enumerator
// leaving it in gives ambiguous err
//      | enumerator

        |       #( NExpressionGroup expr )
        ;

argExprList returns [List listObj = new ArrayList()]
														{	Expression exprObj = null; }
		:
		( exprObj = expr								{	listObj.add(exprObj); }
		)+
        ;

protected charConst :CharLiteral
        ;

protected stringConst :#(NStringSeq (StringLiteral)+)
        ;

protected intConst :IntOctalConst
        |       LongOctalConst
        |       UnsignedOctalConst
        |       IntIntConst
        |       LongIntConst
        |       UnsignedIntConst
        |       IntHexConst
        |       LongHexConst
        |       UnsignedHexConst
        ;

protected floatConst :FloatDoubleConst
        |       DoubleDoubleConst
        |       LongDoubleConst
        ;