source: proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloB.scatter @ 3161

Last change on this file since 3161 was 3161, checked in by ksherdy, 6 years ago

Minor modification to expressions. Formatting.

File size: 4.9 KB
Line 
1//
2// Ken Herdy
3//
4// PabloB - Block-at-a-time language
5//
6// Modified:    02-12-2012      Original definition.
7//                      29-03-2013      Added IDISA function call.
8//                              06-04-2013      Updated to Scatter with types.
9//
10// TODO:                Add BlockMode blocks to specify SIMD field width.
11//                              Add compile time integer expressions evaluation '+','-','*','/'.
12//                              Add Code Block.
13
14types {}
15
16context main {
17  recognizers {
18         Whitespace [IGNORE],
19         Integer [INTEGER_CONST],
20         Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant Tokens for keywords.
21         Comment [IGNORE] "#" "\n",                     // parabix2_pablo debugging only.
22         Comment [IGNORE] "//" "\n",     
23         Comment [SQ_STRING] "'" "'",
24         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
25         String [STRING],
26         Punctuator,
27         EndOfInput,
28  }
29
30  // t o k e n s
31  tokens {
32        INIT,
33        VAR,
34        KERNEL,
35        FUNCTION,       
36        STREAM, // TODO - remove
37        STRUCT,
38        VOID,
39        BITFIELD        "BitField",     
40        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
41        //BLOCKMODE,
42        IF,
43        ELSE,
44        WHILE,
45        RETURN,
46        ASSIGN      "=",
47        LANGLE          "<",
48        RANGLE          ">",
49        LCURLY          "{",
50        RCURLY          "}",
51        LROUND          "(",
52        RROUND          ")",
53        LSQUARE         "[",
54        RSQUARE         "]",
55        COMMA           ",",
56        TERMINATOR  ";",
57        DOT                     ".",
58  }
59}
60
61interfaces {
62//       escapable {boolean escaped = false;},
63         intValued {int value = 0;},
64         
65}
66
67nodes {
68        assign {} [assignRest],
69        funcCall {} [funcCallRest],
70        idisaFuncCall {} [idisaFuncCallRest],
71        integerConstant{intValued;} [],
72        streamConstant{intValued;} [],
73}
74
75grammar {
76        program         -> (typeDecl | kernelDef) * ;
77       
78        //
79        // d e c l a r a t i o n s
80        //
81        // Decls                -> typeDecl TERMINATOR ;
82        typeDecl                ->  type TERMINATOR ;           
83   
84    //
85        // k e r n e l   d e c l a r a t i o n s                                                       
86        //
87        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)* expr TERMINATOR? RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
88        kernelName                      #-> identifier ;
89       
90        //
91        // k e r n e l   s t a t e   i n i t
92        //
93        initDef                         ->  INIT initBlock TERMINATOR? ;
94        initBlock                       #-> LCURLY (stateInitStmt)* RCURLY;
95        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
96        stateIdentifier         ->  IDENTIFIER ;
97        stateSize                       ->  integerConstant ;
98        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
99        stateValue                      ->  integerConstant ;
100
101        //     
102        // k e r n e l   f u n c t i o n s
103        //
104        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
105        returnType                      #-> type ;      // Note: Strictly not required.
106        parameterList           ->      parameter (COMMA parameter)* ;
107        funcName                        #-> identifier ;
108        parameter                       ->      type parameterName ;
109        parameterName           #-> identifier ;
110        basicBlockStmt          #-> blockStmt ;
111        optFuncDef                      #-> funcDef ;
112
113        //
114        // c o d e   b l o c k // (32,64,128,256,...)
115        //
116        // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
117               
118        //
119        // s t a t e m e n t s
120        //
121        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
122        funcCallOrAssignStmt    #-> expr ( (idisaFuncCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
123        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
124        funcCallArgList                 -> (expr (COMMA expr)*)? ;
125        idisaFuncCallRest               -> LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
126        idisaFuncCallArgList    ->  (expr (COMMA expr)*)? ;
127        assignOperator                  -> ASSIGN;                             
128        assignRest                              -> assignOperator^! expr ;                             
129        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
130        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
131        returnStmt                              -> RETURN (expr)? TERMINATOR ;
132        localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
133        varName                                 #-> identifier ;
134        blockStmt                               -> LCURLY stmt* RCURLY ;
135       
136        //
137        // e x p r e s s i o n s
138        //     
139        expr            #-> LROUND expr RROUND
140                                        |integerConstant
141                                        | stringConstant
142                                        | compoundIdentifier (funcCallRest _promote_ | idisaFuncCallRest _promote_)?
143                                        ;
144
145        constant                                #->  stringConstant | integerConstant ; 
146        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
147        stringConstant                  -> STRING | SQ_STRING ;
148        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
149        identifier                              -> IDENTIFIER ;   
150       
151    //   
152        // t y p e s
153        //
154        type                    #->     identifier      |
155                                                        voidType        |
156                                                        streamType      | // TODO - update in PabloS2PabloB
157                                                        structType      |
158                                                        bitFieldType|
159                                                        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
166       
167        structType                              ->      STRUCT structName (structTypeBody)? ;           
168        structName                              #->  identifier ;                               
169        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
170        structMember                    ->      type structMemberName ;
171        structMemberName                #-> identifier ;
172        voidType                                -> VOID ;
173       
174}
Note: See TracBrowser for help on using the repository browser.