Changeset 2373


Ignore:
Timestamp:
Sep 17, 2012, 5:57:00 PM (6 years ago)
Author:
ksherdy
Message:

Simplified grammar with the removal of an explicit tuple type for multiple return values. Inspired by IBM SPL language.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2372 r2373  
    2121 
    2222        TYPEDEF,
     23//      CALL,
    2324        VAR,
    2425        FUNCTION,       
    2526        STREAM,
    2627        STRUCT,
    27         TUPLE,
     28//      TUPLE,
    2829        VOID,
    2930       
     
    4647        LCURLY          "{",
    4748        RCURLY          "}",
    48         LSQUARE         "[",
    49         RSQUARE         "]",
     49//      LSQUARE         "[",
     50//      RSQUARE         "]",
    5051        LROUND          "(",
    5152        RROUND          ")",
     
    6162
    6263nodes {
    63   binaryOperator {} [expression, expression1, expression4],
    64   unaryOperator {} [expression2, expression5],
    65   postfixOperator {} [expression5Rest],
     64  binaryOperator {} [expression, expression1],//, expression4],
     65  unaryOperator {} [expression2,],// expression5],
     66//  postfixOperator {} [expression5Rest],
    6667  functionCall {} [functionCallRest],
    67   //assignmentStatement {} [functionCallOrAssignmentStatement],
     68//  functionCallStatement {} [functionCallOrAssignmentStatement],
    6869}
    6970
     
    9091        // f u n c t i o n   d e f i n i t i o n s                                                             
    9192        //
    92         functionDef             -> FUNCTION type functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR?;                         
     93        functionDef             -> FUNCTION typeList functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR?;                           
    9394                                                                               
    94         returnType              #-> type ;
     95        returnType              #-> typeList ;
     96       
     97        typeList                -> type (COMMA type)*;
    9598                                                                                                               
    9699        functionName    #-> identifier ;
     
    109112        // s t a t e m e n t s
    110113        //
    111         statement                                                       -> (functionCallOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
     114        statement                                                       #-> ( functionCallOrAssignmentStatement | assignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
    112115                       
    113         functionCallOrAssignmentStatement       #-> expression3 (assignmentStatement _promote_ )? TERMINATOR;
    114                        
    115         assignmentStatement                                     -> assignmentOperator expression ;
     116        functionCallOrAssignmentStatement       -> compoundIdentifier ((functionCall _promote_) | (assignmentStatement _promote_)) TERMINATOR ;
     117               
     118        functionCall                                            #-> functionCallRest;
     119       
     120        assignmentStatement                                     -> assignmentOperator expression ;     
    116121               
    117122        assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;                         
    118123                                       
     124        assignmentStatementRest                         -> assignmentOperator expression ;                             
     125                                       
    119126        ifStatement                                                     -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
    120127                                                       
     
    137144        localVarDeclList                                        -> localVarDecl (COMMA localVarDecl)* ;
    138145               
    139         localVarDecl                                            -> identifier (assignmentStatement _promote_) ? ;
    140        
     146        localVarDecl                                            -> identifier (assignmentOperator expression) ? ;
     147               
    141148       
    142149        //
     
    151158        expression3             #-> LROUND expression RROUND
    152159                                        | constant
    153                                         | identifier (
    154                                                 (functionCallRest _promote_)?
    155                                                 | (expression4 _promote_)?
    156                                                 | (expression5 _promote_)?
    157                                         )?
     160                                        | compoundIdentifier (functionCallRest _promote_)?
    158161                                        ;
    159162
    160         expression4             -> DOT expression3 ;
    161                                                
    162         expression5     -> (LSQUARE INTEGER_CONST^^ RSQUARE) (expression5Rest)?   ;     
    163                
    164         expression5Rest -> DOT expression ;                                                                                             
     163                                                //(
     164                                                //(functionCallRest _promote_)?
     165                                                //| (expression4 _promote_)?
     166                                                //| (expression5 _promote_)?
     167                                                //)?
     168                                                // ;
     169                                       
     170                                                //expression4            -> DOT expression3 ;
     171                                                //expression5    -> (LSQUARE INTEGER_CONST^^ RSQUARE) (expression5Rest)?   ;   
     172                                                //expression5Rest        -> DOT expression3 ;                                                                                           
    165173                                                                                                                                                                               
    166         functionCallRest                -> LROUND^^ (argumentExpressionList)? RROUND;
     174        functionCallRest -> LROUND^^ (argumentExpressionList)? RROUND ; //(expression5Rest)?;
    167175       
    168176        argumentExpressionList  -> expression (COMMA expression)* ;                                                     
    169177                                                       
    170178        constant                                -> STRING | SQ_STRING | INTEGER_CONST ; // '-1' | '0'
     179       
     180        compoundIdentifier              -> identifier (DOT identifier)*;
    171181                                                       
    172182        identifier                              -> IDENTIFIER ;
     
    180190        // s t r e a m
    181191
    182         type                    ->  streamType | structType | tupleType | VOID | identifier;
     192        type                    ->  streamType | structType | VOID | identifier ; // | tupleType;
    183193       
    184194        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     
    204214        // t u p l e
    205215       
    206         tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
    207        
    208         tupleTypeSpecifier              ->      TUPLE tupleName ;       
    209                
    210         tupleTypeBody                   ->  type (COMMA type)* ;                                 
    211 
    212         tupleName                               #->  identifier ;
    213 
    214 }
     216//      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
     217       
     218//      tupleTypeSpecifier              ->      TUPLE tupleName ;       
     219               
     220//      tupleTypeBody                   ->  type (COMMA type)* ;                                 
     221
     222//      tupleName                               #->  identifier ;
     223
     224}
Note: See TracChangeset for help on using the changeset viewer.