Changeset 2362


Ignore:
Timestamp:
Sep 11, 2012, 6:46:04 PM (6 years ago)
Author:
ksherdy
Message:

Updated grammar to support index operation. Postpone typedefs.

File:
1 edited

Legend:

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

    r2361 r2362  
    22// Ken Herdy
    33// Sept. 8 2012
    4 //
    5 // (1) typedefs not supported.
    6 // (2) Local type declarations supported.
    74//
    85context main {
     
    2320  tokens {
    2421 
    25         // TYPEDEF,
     22//      TYPEDEF,
    2623        FUNCTION,       
    2724        STREAM,
    2825        STRUCT,
    2926        TUPLE,
    30         VOID,   
    31 
     27        VOID,
     28       
    3229        IF,
    3330        ELSE,
     
    6360
    6461nodes {
    65   binaryOperator {} [expression, expression1, expression3],
    66   unaryOperator {} [expression2],
    67   assignment {} [assignmentStatementTail],
     62  binaryOperator {} [expression, expression1],
     63  unaryOperator {} [expression2,expression3],
     64  postfixOperator {} [expression4],
     65//  compoundVariable {} [compoundVariableTail],
     66//  assignment {} [assignmentExprTail],
    6867//  ifStatement {} [ifStatementBulk],
    69   functionCall {} [functionCallTail],
    70   tupleIdentifier {} [tupleTail],
    71   variableDefinition {} [variableDefinitionTail], // variable definitions
     68  functionCall {} [functionCallRest],
     69//  tupleIndex {} [tupleIndexTail],
     70//  tupleIdentifier {} [tupleTail],
     71//  localDeclaration {} [localDeclarationTail], // variable definitions
    7272//  ASTNode [variableFunctionCall], //[assignmentOrFunctionInvocation, variableOrFunctionInvocation],
    7373}
    7474
    7575grammar {
    76         program         -> (typeDecl)* (functionDef)* ; // (typeDef)*
    77        
    78         // t y p e   d e f i n i t i o n s                     
    79         //
    80         // typeDef              ->  TYPEDEF (typeSpecifier | typeDecl) typeDefName TERMINATOR ? ;
    81     // typeDefName      #->  identifier ;
    82    
     76        program         -> (typeDecl | functionDef)*;
     77
    8378    //
    8479        // t y p e   d e c l a r a t i o n s             
    8580        //
    86         typeDecl        ->  (structTypeDecl | tupleTypeDecl) TERMINATOR ? ;
    87        
     81        typeDecl                                ->  type directDeclaratorList? TERMINATOR ? ;
     82    directDeclaratorList        #-> identifier (COMMA identifier)* ;
     83       
     84        //
     85        // t y p e   d e f i n i t i o n s                     
     86        //
     87        // typeDef                      ->  TYPEDEF type directDeclaratorList TERMINATOR ? ;
     88   
    8889    //
    8990        // f u n c t i o n   d e f i n i t i o n s                                                             
    9091        //
    91         functionDef             -> FUNCTION functionReturnType functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR ?;                         
     92        functionDef             -> FUNCTION type functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR ?;                               
    9293                                                                               
    93         functionReturnType      -> typeSpecifier | VOID ;
     94        returnType              #-> type;
    9495                                                                                                               
    9596        functionName    #-> identifier ;
    9697                                                                                                                       
    97         parameter               -> typeSpecifier parameterName ;
     98        parameter               -> type parameterName ;
    9899                                       
    99100        parameterName   #-> identifier ;
     
    104105        // s t a t e m e n t s
    105106        //
    106         statement                               #-> (variableDefinition | assignmentStatementOrFunctionCall | ifStatement | whileStatement | returnStatement) (TERMINATOR)?     ;
    107                        
    108         // variable definitions
    109         variableDefinition              ->  typeSpecifier variableDefinitionTail;
    110                        
    111         variableDefinitionTail  ->      variableName (assignmentOperator expression)? _promote_ ;
     107        statement                                                       #-> (localDecl | functionCallOrAssignmentStatement | ifStatement | whileStatement | returnStatement) (TERMINATOR)?      ;
    112108       
    113         variableName                    #-> identifier ;
    114                                
    115         assignmentStatementOrFunctionCall -> compoundVariable (assignmentStatementTail _promote_ | functionCallTail _promote_) ;
     109        localDecl                                                       -> typeDecl ( assignmentStatement)? ;
    116110       
    117         assignmentStatementTail -> assignmentOperator^! expression ;
     111        functionCallOrAssignmentStatement       ->  expression3 (assignmentStatement _promote_ )?;
     112               
     113        assignmentStatement                                     -> assignmentOperator expression ;
    118114       
    119         functionCallTail        -> LROUND (argumentList)? RROUND ;
     115        functionCall                                            -> functionCallRest ;
    120116       
    121         argumentList            -> expression (COMMA expression)* ;
    122 
    123         compoundVariable        -> identifierOrTuple (DOT identifierOrTuple)*   ; 
    124         // compoundVariable -> identifier (LSQUARE index RSQUARE)? (DOT identifier (LSQUARE index RSQUARE)?)* ; // TODO - mixed identifier / tuple list ?
     117        assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;                         
     118                                       
     119        ifStatement                                                     -> IF LROUND expression RROUND blockStatement (ELSE blockStatement)? ;
     120                                                       
     121        whileStatement                                          -> WHILE LROUND expression RROUND blockStatement ;
    125122       
    126         identifierOrTuple       #-> identifier (tupleTail _promote_)?;
    127        
    128         tupleTail                       -> LSQUARE index RSQUARE ;
    129                                        
    130         index                           -> INTEGER_CONST ;     
    131        
    132         assignmentOperator      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;
    133                                        
    134         ifStatement             -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
    135        
    136         ifCondition             -> expression ;
    137        
    138         ifBlock                 -> blockStatement ;
    139        
    140         elseBlock               -> blockStatement ; // TODO - dangling else problems?
    141                                                
    142         whileStatement  -> WHILE LROUND whileCondition RROUND blockStatement ;
    143        
    144         whileCondition  -> expression ;
    145        
    146         returnStatement -> RETURN (identifier)? ; // TODO - return an expression
     123        returnStatement                                         -> RETURN (expression)? ;
    147124       
    148125        //
     
    154131                                       
    155132        expression2             #-> NOT^^? expression3 _leftAssoc_ ;
    156                                        
    157         expression3             #-> LROUND expression RROUND
    158                                         | variableFunctionCall
    159                                         | constant ;
    160                                        
    161         variableFunctionCall    #-> compoundVariable (functionCallTail _promote_)? ;
     133                                                                                       
     134        expression3             #-> expression5 (expression4)?
     135                                        ;
     136       
     137        expression4             #-> (DOT^^ identifier expression4?)?
     138                                        | (LSQUARE INTEGER_CONST^^ RSQUARE expression4?)?
     139                                        | (functionCallRest)?
     140                                        ;
     141                                               
     142        expression5             #-> identifier
     143                                        | constant
     144                                        | LROUND expression RROUND
     145                                        ;                                                                       
     146       
     147        functionCallRest                -> LROUND^^ (argumentExpressionList)? RROUND;
     148       
     149        argumentExpressionList  -> expression (COMMA expression)* ;                                                     
    162150                                                       
    163151        constant                                -> STRING | SQ_STRING | INTEGER_CONST ; // '-1' | '0'
     
    169157        //
    170158
    171         // s t r e a m
     159        // p r i m i t i v e
     160        //
     161        // s t r e a m
    172162
    173         typeSpecifier                   ->  streamTypeSpecifier | structTypeSpecifier | tupleTypeSpecifier; // | identifier ; // no typedefs
     163        type                    ->  streamType | structType | tupleType | VOID ; // | identifier;
    174164       
    175         streamTypeSpecifier             ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     165        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
    176166                                       
    177         fieldWidth                              ->  INTEGER_CONST ;     
     167        fieldWidth              ->  INTEGER_CONST ;     
    178168       
    179         streamTypeName                  #->     identifier ;                           
     169        streamTypeName  #->     identifier ;                           
    180170               
    181171        // s t r u c t 
    182172               
    183         structTypeDecl                  ->      structTypeSpecifier LCURLY structTypeBody RCURLY ;
    184        
    185         structTypeSpecifier             ->      STRUCT structName ;
     173        structType                              ->      structTypeSpecifier (LCURLY structTypeBody RCURLY)? ;           
     174                                       
     175        structTypeSpecifier             -> STRUCT structName ;                         
    186176                                       
    187177        structName                              #->  identifier ;                               
     
    189179        structTypeBody                  ->      structMember TERMINATOR (structMember TERMINATOR)* ;
    190180                                       
    191         structMember                    ->      (typeSpecifier | typeDecl) structMemberName ;
     181        structMember                    ->      type structMemberName ;
    192182       
    193183        structMemberName                #-> identifier ;
     
    195185        // t u p l e
    196186       
    197         tupleTypeDecl                   ->      tupleTypeSpecifier tupleTypeBody ;
     187        tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
    198188       
    199189        tupleTypeSpecifier              ->      TUPLE tupleName ;       
    200190               
    201         tupleTypeBody                   ->  (LROUND (typeSpecifier | typeDecl) (COMMA  (typeSpecifier | typeDecl))* RROUND) ;                           
     191        tupleTypeBody                   ->  type (COMMA type)* ;                                 
    202192
    203193        tupleName                               #->  identifier ;
Note: See TracChangeset for help on using the changeset viewer.