expandednesctreeparser.g

plugin for eclipse

initializerList :( initializer )*
        ;

declarator :#( NDeclarator
               ( pointerGroup )?               
               ( 
                 ( id:ID                         
                
                   ( DOT id2:ID )?                   
                 )
                 | lp:LPAREN declarator rp:RPAREN
               )

			   ( #( ip:NInterfaceParameterList					
					( parameterTypeList
					| idList 
					)
					rbr:RBRACKET		
				  )
				)?

                ( #( n:NParameterTypeList     
                    ( parameterTypeList
                    | (idList)?
                    )
                    r:RPAREN                    
                    )
                  | lb:LBRACKET ( expr )? rb:RBRACKET
                )*
             )
        ;

parameterTypeList :( parameterDeclaration ( COMMA | SEMI )? )+ ( VARARGS )?
        ;

parameterDeclaration :#( NParameterDeclaration
                declSpecifiers
                (declarator | nonemptyAbstractDeclarator)?
                )
        ;

functionDef :#( NFunctionDef
                ( functionDeclSpecifiers)? 
                declarator
                (declaration | VARARGS)*
                ( attributeDecl )*                            
                compoundStatement
            )
        ;

functionDeclSpecifiers :( functionStorageClassSpecifier
                | typeQualifier
                | typeSpecifier
                )+
        ;

declarationList :(   //ANTLR doesn't know that declarationList properly eats all the declarations
                    //so it warns about the ambiguity
                    options {
                        warnWhenFollowAmbig = false;
                    } :
                localLabelDecl
                | declaration
                )+
        ;

localLabelDecl :#("__label__" (ID)+ )
        ;

compoundStatement :#( NCompoundStatement
                ( declarationList
                | functionDef
                )*
                ( statementList )?
                RCURLY
                )
        ;

statementList :( statement )+
        ;

statement :("atomic")? statementBody
        ;

statementBody :SEMI                    // Empty statements

        |       compoundStatement       // Group of statements

        |       #(NStatementExpr expr)                    // Expressions

// Iteration statements:

        |       #( "while" expr statement )
        |       #( "do" statement expr )
        |       #( "for"
                expr expr expr
                statement
                )


// Jump statements:

        |       #( "goto" expr )
        |       "continue" 
        |       "break"
        |       #( "return" ( expr )? )


// Labeled statements:
        |       #( NLabel ID (statement)? )
        |       #( "case" expr (statement)? )
        |       #( "default" (statement)? )



// Selection statements:

        |       #( "if"
                    expr statement  
                    ( "else" statement )?
                 )
        |       #( "switch" expr statement )



        ;

expr :assignExpr
        |       conditionalExpr
        |       logicalOrExpr
        |       logicalAndExpr
        |       inclusiveOrExpr
        |       exclusiveOrExpr
        |       bitAndExpr
        |       equalityExpr
        |       relationalExpr
        |       shiftExpr
        |       additiveExpr
        |       multExpr
        |       castExpr
        |       unaryExpr
        |       postfixExpr
        |       primaryExpr
        |       commaExpr
        |       emptyExpr
        |       compoundStatementExpr
        |       initializer
        |       rangeExpr
        |       gnuAsmExpr
        ;

commaExpr :#(NCommaExpr expr expr)
        ;

emptyExpr :NEmptyExpression
        ;

compoundStatementExpr :#(LPAREN compoundStatement 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 :#( NNonemptyAbstractDeclarator
            (   pointerGroup
                (   (LPAREN  
                    (   nonemptyAbstractDeclarator
                        | parameterTypeList
                    )?
                    RPAREN)
                | (LBRACKET (expr)? RBRACKET)
                )*

            |  (   (LPAREN  
                    (   nonemptyAbstractDeclarator
                        | parameterTypeList
                    )?
                    RPAREN)
                | (LBRACKET (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"  )
                  primaryExpr
                  d2:DOT 
                  primaryExpr
                  (interfaceParamArgs)?                    
                  #( n2:NFunctionCallArgs                    
                     (argExprList)?
                     rp2:RPAREN                              
                   )
       
                | 
                  p3:"post"
                  primaryExpr
                  #( n3:NFunctionCallArgs                    
                     (argExprList)?
                     rp3:RPAREN                              
                   )
                )
               )            
       ;

interfaceParamArgs :#(lb:NInterfaceParamArgs               
              argExprList
              rb:RBRACKET                          
             )
        ;

primaryExpr :ID
        |       Number
        |       charConst
        |       stringConst

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

        |       #( NExpressionGroup expr )
        ;

argExprList :( expr )+
        ;

protected charConst :CharLiteral
        ;

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

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

protected floatConst :FloatDoubleConst
        |       DoubleDoubleConst
        |       LongDoubleConst
        ;