Changeset 3161


Ignore:
Timestamp:
May 21, 2013, 3:15:39 PM (5 years ago)
Author:
ksherdy
Message:

Minor modification to expressions. Formatting.

Location:
proto/pabloj/branches/refactor-experimental/input/grammar/scatter
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloB.scatter

    r3011 r3161  
    22// Ken Herdy
    33//
    4 // PabloB (block-at-a-time language)
     4// PabloB - Block-at-a-time language
    55//
    66// Modified:    02-12-2012      Original definition.
     
    3030  // t o k e n s
    3131  tokens {
    32  
    3332        INIT,
    3433        VAR,
     
    3837        STRUCT,
    3938        VOID,
    40        
    4139        BITFIELD        "BitField",     
    4240        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
    43        
    4441        //BLOCKMODE,
    45        
    4642        IF,
    4743        ELSE,
    4844        WHILE,
    4945        RETURN,
    50 
    5146        ASSIGN      "=",
    5247        LANGLE          "<",
     
    5651        LROUND          "(",
    5752        RROUND          ")",
    58        
    5953        LSQUARE         "[",
    6054        RSQUARE         "]",
    61        
    6255        COMMA           ",",
    6356        TERMINATOR  ";",
    6457        DOT                     ".",
    65        
    6658  }
    6759}
     
    8375grammar {
    8476        program         -> (typeDecl | kernelDef) * ;
    85 
    86         //
    87         // t o p - l e v e l 
    88         //
    8977       
    9078        //
     
    9280        //
    9381        // Decls                -> typeDecl TERMINATOR ;
    94                
    9582        typeDecl                ->  type TERMINATOR ;           
    96                
    97         // typeDef              ->  TYPEDEF type identifier TERMINATOR ;
    98        
    99         // DeclList             ->  identifier (COMMA identifier)* ; 
    100        
    10183   
    10284    //
    103         // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
     85        // k e r n e l   d e c l a r a t i o n s                                                       
    10486        //
    105                
    10687        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)* expr TERMINATOR? RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
    107        
    10888        kernelName                      #-> identifier ;
    10989       
    110         // s t a t e   i n i t
    11190        //
    112        
     91        // k e r n e l   s t a t e   i n i t
     92        //
    11393        initDef                         ->  INIT initBlock TERMINATOR? ;
    114        
    11594        initBlock                       #-> LCURLY (stateInitStmt)* RCURLY;
    116                
    11795        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
    118        
    11996        stateIdentifier         ->  IDENTIFIER ;
    120                
    12197        stateSize                       ->  integerConstant ;
    122        
    12398        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
    124        
    12599        stateValue                      ->  integerConstant ;
    126        
    127        
    128        
     100
     101        //     
    129102        // k e r n e l   f u n c t i o n s
    130103        //
    131104        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
    132        
    133105        returnType                      #-> type ;      // Note: Strictly not required.
    134        
    135106        parameterList           ->      parameter (COMMA parameter)* ;
    136                                                                                                                
    137107        funcName                        #-> identifier ;
    138                                                                                                                        
    139108        parameter                       ->      type parameterName ;
    140                                        
    141109        parameterName           #-> identifier ;
    142        
    143110        basicBlockStmt          #-> blockStmt ;
    144        
    145111        optFuncDef                      #-> funcDef ;
    146  
    147         // c o d e   b l o c k
     112
     113        //
     114        // c o d e   b l o c k // (32,64,128,256,...)
    148115        //
    149116        // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
    150  
    151                
     117               
    152118        //
    153119        // s t a t e m e n t s
    154120        //
    155121        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    156        
    157122        funcCallOrAssignStmt    #-> expr ( (idisaFuncCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
    158        
    159123        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    160        
    161124        funcCallArgList                 -> (expr (COMMA expr)*)? ;
    162        
    163125        idisaFuncCallRest               -> LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
    164 
    165126        idisaFuncCallArgList    ->  (expr (COMMA expr)*)? ;
    166                
    167127        assignOperator                  -> ASSIGN;                             
    168                                        
    169128        assignRest                              -> assignOperator^! expr ;                             
    170                                        
    171129        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
    172                                                        
    173130        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
    174                        
    175131        returnStmt                              -> RETURN (expr)? TERMINATOR ;
    176                        
    177132        localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
    178                
    179133        varName                                 #-> identifier ;
    180 
    181134        blockStmt                               -> LCURLY stmt* RCURLY ;
    182135       
     
    189142                                        | compoundIdentifier (funcCallRest _promote_ | idisaFuncCallRest _promote_)?
    190143                                        ;
    191                                                                                                                                                                                        
     144
    192145        constant                                #->  stringConstant | integerConstant ; 
    193                                                                    
    194146        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    195        
    196147        stringConstant                  -> STRING | SQ_STRING ;
    197        
    198148        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
    199                                                        
    200149        identifier                              -> IDENTIFIER ;   
    201150       
     
    203152        // t y p e s
    204153        //
    205 
    206         //
    207         // p r i m i t i v e s
    208         //
    209 
    210154        type                    #->     identifier      |
    211155                                                        voidType        |
     
    214158                                                        bitFieldType|
    215159                                                        bitBlockType; // | tupleType;
     160
     161        streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
     162        fieldWidth              ->  integerConstant ;   
     163        streamTypeName  #->     identifier ;                           
     164        bitFieldType    -> BITFIELD ; // Power-of-2 bit field
     165        bitBlockType    -> BITBLOCK ; // SIMD vector
    216166       
    217         streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
    218                                        
    219         fieldWidth              ->  integerConstant ;   
    220        
    221         streamTypeName  #->     identifier ;                           
    222                
    223         bitFieldType    -> BITFIELD ; // Power-of-2 bit field
    224        
    225         bitBlockType    -> BITBLOCK; // SIMD vector
    226                
    227         //     
    228         // c o m p o s i t e s
    229         //     
    230         // s t r u c t 
    231                
    232167        structType                              ->      STRUCT structName (structTypeBody)? ;           
    233                                        
    234168        structName                              #->  identifier ;                               
    235                                        
    236169        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
    237                                        
    238170        structMember                    ->      type structMemberName ;
    239        
    240171        structMemberName                #-> identifier ;
    241        
    242172        voidType                                -> VOID ;
    243173       
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3147 r3161  
    11//
    2 // PabloS - Parallel Stream Language - A tiny language for the definition of stream functions and stream types.
     2// PabloS - Parallel Stream Language  
    33//
    4 // Author:              Ken Herdy <ksherdy at sfu dot ca>
     4// A tiny language for the definition of stream structures, functions, and types.
     5//
     6// Author:                      Ken Herdy <ksherdy at sfu dot ca>
    57// Created:             2012/09/08
    68// Last Changed:        2013/02/01
    79//
    8 // History:
    9 //                              Initial definition, 2012/09/08
    10 //
    11 //
     10// History:                     2012/09/08 Initial definition.
     11//                                             
    1212
    1313types {
     
    1717}
    1818
    19 
    2019context main {
    2120
     
    2423         Integer [INTEGER_CONST],
    2524         Identifier [IDENTIFIER],                       // Java identifiers, except $ character. Produces Lextant tokens for keywords.
    26          Comment [IGNORE] "#" "\n",                     // Added to support parabix2_pablo debugging.
     25         Comment [IGNORE] "#" "\n",                     // Support parabix2_pablo debugging.
    2726         Comment [IGNORE] "//" "\n",     
    2827         Comment [SQ_STRING] "'" "'",
     
    4948        RETURN,
    5049
    51         AND   "&",
    52         OR    "|",
    53         NOT   "~",
    54         XOR   "^",
     50        AND             "&",
     51        OR              "|",
     52        NOT             "~",
     53        XOR             "^",
    5554        MULTIPLY        "*",
    5655        DIVIDE          "/",
     
    8685nodes {
    8786  ASTNode {Type type = null;} [assignOperator],
    88   binaryOperator {} [expr expr1],       //, expr4],
    89   unaryOperator {} [expr2],                     // expr5],
     87  binaryOperator {} [expr expr1 expr3 expr4],
     88  unaryOperator {} [expr2],     
    9089  assign {} [assignRest],
    9190  funcCall {} [funcCallRest],
     
    10099
    101100        //
    102         // t o p - l e v e l   d e c l a r a t i o n s 
     101        // s t r e a m   s t r u c t   d e c l a r a t i o n s 
    103102        //
    104        
    105         // structDecl           
    106 
    107103        structDecl                      ->  STRUCT structName structTypeBody ;
    108                                                
    109104        structTypeBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
    110                                        
    111105        structMember            ->      structMemberType structMemberName ;
    112        
    113106        structMemberType        #-> structType | streamType ;
    114        
    115107        structMemberName        #-> identifier ;
    116108   
    117109    //
    118         // f u n c t i o n   d e c l a r a t i o n s                                                   
     110        // s t r e a m   f u n c t i o n   d e c l a r a t i o n s                                                     
    119111        //
    120112        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                             
    121                                                                                
    122113        returnType              #-> type ;     
    123        
    124114        parameterList   -> parameter (COMMA parameter)*;
    125                                                                                                                
    126115        funcName                #-> identifier ;
    127                                                                                                                        
    128116        parameter               -> type parameterName ;
    129                                        
    130117        parameterName   #-> identifier ;
    131        
    132         //
    133         // f u n c t i o n - l e v e l 
    134         //
    135        
     118               
    136119        //
    137120        // s t a t e m e n t s
    138121        //
    139122        stmt                                    #->     funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl ;
    140                
     123
    141124        funcCallOrAssignStmt    #-> expr (assignRest _promote_)? TERMINATOR ;
    142        
    143         assignRest                              -> assignOperator^! expr ;
    144         assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
    145                                                            MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;             
    146                                        
    147         ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                         
    148         whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
    149         returnStmt                              -> RETURN (expr)? TERMINATOR;
    150         blockStmt                               -> LCURLY stmt* RCURLY ;
    151                        
    152         localVarDecl                    -> type varName (ASSIGN^ expr) ?;
    153                
    154         varName                                 #-> identifier;                         // compoundIdentifier ?
     125        assignRest                              ->      assignOperator^! expr ;
     126        assignOperator                  ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
     127                                                                MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;               
     128        ifStmt                                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                                 
     129        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
     130        returnStmt                              ->      RETURN (expr)? TERMINATOR;
     131        blockStmt                               ->      LCURLY stmt* RCURLY ;
     132        localVarDecl                    ->      type varName (ASSIGN^ expr) ? ;
     133        varName                                 #-> compoundIdentifier ;
    155134
    156        
    157135        //
    158136        // e x p r e s s i o n s
    159137        //     
    160138        expr    #->     expr1 ((OR^|XOR^) expr)?  _leftAssoc_ ;
    161                                        
    162139        expr1   #-> expr2 ((AND^) expr1)?  _leftAssoc_ ;
    163                                        
    164140        expr2   #-> NOT^^? expr3;
    165        
    166141        expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
    167         expr4   #-> expr4 ((ADD^ | SUBTRACT^) expr3)? _leftAssoc_ ;
    168        
    169         expr3   #-> LROUND expr RROUND
     142        expr4   #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
     143        expr5   #-> LROUND expr RROUND
    170144                                        | stringConstant
    171145                                        | integerConstant
    172146                                        | compoundIdentifier (funcCallRest _promote_)?
    173147                                        ;
     148                                                                                                                                                                                                                                                                       
     149        constant                                #-> stringConstant | integerConstant ;
     150        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
     151        stringConstant                  -> STRING | SQ_STRING ;
     152        compoundIdentifier              #-> identifier (DOT^ identifier)*;
     153        identifier                              -> IDENTIFIER ;
    174154
    175                                         //(
    176                                         //(funcCallRest _promote_)?
    177                                         //| (expr4 _promote_)?
    178                                         //| (expr5 _promote_)?
    179                                         //)?
    180                                         // ;
    181                                         //expr4          -> DOT expr3 ;
    182                                         //expr5          -> (LSQUARE INTEGER_CONST^ RSQUARE) (expr5Rest)?   ;   
    183                                         //expr5Rest      -> DOT expr3 ;                                                                                         
    184                                                                                                                                                                                                                                                                        
    185         constant                #-> stringConstant | integerConstant ;
    186                                                            
    187         integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    188        
    189         stringConstant                  -> STRING | SQ_STRING ;
    190        
    191         compoundIdentifier              #-> identifier (DOT^ identifier)*;
    192                                                        
    193         identifier                              -> IDENTIFIER ;
    194    
    195155    funcCallRest                        -> LROUND^ funcCallArgList RROUND ;
    196 
    197156        funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
    198157               
    199158        // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
    200 
    201159        // streamCallArgList            -> (expr (COMMA expr)*)? ;             
    202160     
     
    205163        // t y p e s
    206164        //
    207 
    208165        type                    #->     primitiveType   |
    209166                                                        streamType              |
    210                                                         structType              ;                       // | tupleType;
    211        
    212        
    213         // p r i m i t i v e   t y p e s
    214        
     167                                                        structType              ;
     168
    215169        primitiveType   #-> ( intType | voidType ) ;
    216        
    217         intType                  -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
    218         voidType                 -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
    219        
    220        
    221         // s t r e a m
    222        
    223         streamType              ->      STREAM fieldWidthSpec!  {       @fieldWidth = @:value;
     170        intType                 -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
     171        voidType                -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
     172
     173        streamType              ->      STREAM fieldWidthSpec! {        @fieldWidth = @:value;
    224174                                                                                                        @type = {{ new StreamType(%?) }} , @fieldWidth ;
    225175                                                                                       } ;
     
    227177        fieldWidthSpec  #->  (LANGLE integerConstant RANGLE ) |
    228178                                                 (epsilon {@value = 1;}) ;     
    229                                        
    230179       
    231         // c o m p o u n d   t y p e s
    232                
    233         // s t r u c t 
    234                
    235         structType                              ->      STRUCT structName ;             
    236                                        
    237         structName                              #->  identifier ;                               
    238 
     180        structType              ->      STRUCT structName ;             
     181        structName              #->  identifier ;                               
    239182       
    240        
    241         // t u p l e
    242183        //      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
    243184        //      tupleTypeSpecifier              ->      TUPLE tupleName ;       
Note: See TracChangeset for help on using the changeset viewer.