source: proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter @ 2984

Last change on this file since 2984 was 2984, checked in by ksherdy, 7 years ago

Added parabix2_pablo.py as parabix2_pablo.pablob. Set idisa builtin syntax in PabloB grammar as library_name.operation_name<field_width>(arg_list), e.g. simd.and<1>(a,b), bitblock.any<1>(a) to maintain consistency with existing builtins syntax.

File size: 6.3 KB
Line 
1//
2// Ken Herdy
3// 2-December-2012
4//
5// PabloB (block-at-a-time language)
6//
7// Type System
8//
9// Primitive Types
10//
11// uint8
12// uint16
13// uint32
14// uint64
15// uint128
16// uint256
17// BitBlock - a special type that evaluates uint128 or uint256
18//            at compile time based on the target architecture
19//
20// String Constant
21//
22// Compound Types
23//
24// Stream Structure (record type)
25//
26// Comments
27//
28//                      PabloB expression evaluate to types ? -> Add type checking support.
29//                      Add support for a boolean type.
30//                      Add support for IDISA operations.
31//                      Add support for '+', '-'.
32//                      Extend integer type system to include int8, int16, int32, int64, int128, int256 types.
33//                      Stream constant type.
34//                      Map PabloS builtins to PabloB equivalents. Effectively expand PabloS macros to support an optimization pass the
35//                      Remove stream type from PabloB definition.
36//                      PabloS stream type maps to PabloB BitBlock type.
37//                      PabloS stream<2^k> operations map to IDISA supported Pablo operations.
38//                      PabloB intermediate language level.
39//             
40//
41context main {
42  recognizers {
43         Whitespace [IGNORE],
44         Integer [INTEGER_CONST],
45         Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant Tokens for keywords.
46         Comment [IGNORE] "#" "\n",                     // parabix2_pablo debugging only.
47         Comment [IGNORE] "//" "\n",     
48         Comment [SQ_STRING] "'" "'",
49         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
50         String [STRING],
51         Punctuator,
52         EndOfInput,
53  }
54
55  // t o k e n s
56  tokens {
57 
58        INIT,
59        VAR,
60        KERNEL,
61        FUNCTION,       
62        STREAM,
63        STRUCT,
64        VOID,
65       
66        UINT8           "uint8",
67        UINT16          "uint16",
68        UINT32          "uint32",
69        UINT64          "uint64",
70        UINT128         "uint128",
71        UINT256         "uint256",
72        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
73       
74        //BLOCKMODE,
75       
76        IF,
77        ELSE,
78        WHILE,
79        RETURN,
80
81        ASSIGN      "=",
82        LANGLE          "<",
83        RANGLE          ">",
84        LCURLY          "{",
85        RCURLY          "}",
86        LROUND          "(",
87        RROUND          ")",
88       
89        LSQUARE         "[",
90        RSQUARE         "]",
91       
92        COMMA           ",",
93        TERMINATOR  ";",
94        DOT                     ".",
95       
96  }
97}
98
99interfaces {
100//       escapable {boolean escaped = false;},
101         intValued {int value = 0;},
102}
103
104nodes {
105  assign {} [assignRest],
106  funcCall {} [funcCallRest],
107  idisaCall {} [idisaCallRest],
108  integerConstant{intValued;} [],
109  streamConstant{intValued;} [],
110}
111
112grammar {
113        program         -> (typeDecl | kernelDef) * ;
114
115        //
116        // t o p - l e v e l 
117        //
118       
119        //
120        // d e c l a r a t i o n s
121        //
122        // Decls                -> typeDecl TERMINATOR ;
123               
124        typeDecl                ->  type TERMINATOR ;           
125               
126        // typeDef              ->  TYPEDEF type identifier TERMINATOR ;
127       
128        // DeclList             ->  identifier (COMMA identifier)* ; 
129       
130   
131    //
132        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
133        //
134        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? (compoundIdentifier (funcCallRest _promote_))? RCURLY TERMINATOR? ; // TODO eliminate carry.Declare ?
135       
136        kernelName                      #-> identifier ;
137       
138        // s t a t e   i n i t
139        //
140        initDef                         ->  INIT initBlock TERMINATOR? ;
141       
142        initBlock                       #-> LCURLY stateInitStmt* RCURLY;
143       
144        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
145       
146        stateIdentifier         ->  IDENTIFIER ;
147               
148        stateSize                       ->  integerConstant ;
149       
150        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
151       
152        stateValue                      ->  integerConstant ;
153       
154        //stateInitList         ->      streamType (COMMA streamType)* ;
155       
156        // k e r n e l   f u n c t i o n s
157        //
158        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
159       
160        returnType                      #-> type ;      // Note: Strictly not required.
161       
162        parameterList           ->      parameter (COMMA parameter)* ;
163                                                                                                               
164        funcName                        #-> identifier ;
165                                                                                                                       
166        parameter                       ->      type parameterName ;
167                                       
168        parameterName           #-> identifier ;
169       
170        basicBlockStmt          #-> blockStmt ;
171       
172        optFuncDef                      #-> funcDef ;
173 
174        // c o d e   b l o c k
175        //
176        // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
177 
178               
179        //
180        // s t a t e m e n t s
181        //
182        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
183                       
184        funcCallOrAssignStmt    -> compoundIdentifier ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
185       
186        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
187       
188        funcCallArgList                 -> (expr (COMMA expr)*)? ;
189       
190        idisaCallRest                   -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
191
192        idisaCallArgList                -> (expr (COMMA expr)*)? ;     
193               
194        assignOperator                  -> ASSIGN;                             
195                                       
196        assignRest                              -> assignOperator^! expr ;                             
197                                       
198        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
199                                                       
200        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
201                       
202        returnStmt                              -> RETURN (expr)? TERMINATOR ;
203                       
204        localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
205               
206        varName                                 #-> identifier ;
207
208        blockStmt                               -> LCURLY stmt* RCURLY ;
209       
210        //
211        // e x p r e s s i o n s
212        //     
213        expr            #-> LROUND expr RROUND
214                                        |integerConstant
215                                        | stringConstant
216                                        | compoundIdentifier (funcCallRest _promote_ | idisaCallRest _promote_)?
217                                        ;
218                                                                                                                                                                                       
219        constant                                #->  stringConstant | integerConstant ; 
220                                                                   
221        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
222       
223        stringConstant                  -> STRING | SQ_STRING ;
224       
225        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
226                                                       
227        identifier                              -> IDENTIFIER ;   
228       
229    //   
230        // t y p e s
231        //
232
233        //
234        // p r i m i t i v e s
235        //
236
237        type                    #->     identifier      |
238                                                        voidType        |
239                                                        streamType      |
240                                                        structType      |
241                                                        uint8Type       |
242                                                        uint16Type      |
243                                                        uint32Type      |
244                                                        uint64Type      |
245                                                        uint128Type |
246                                                        uint256Type |
247                                                        bitBlockType; // | tupleType;
248       
249        streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
250                                       
251        fieldWidth              ->  integerConstant ;   
252       
253        streamTypeName  #->     identifier ;                           
254               
255        uint8Type               -> UINT8 ;
256        uint16Type              -> UINT16 ;
257        uint32Type              -> UINT32 ;
258        uint64Type              -> UINT64 ;
259        uint128Type             -> UINT128 ;
260        uint256Type             -> UINT256 ;
261       
262        bitBlockType    -> BITBLOCK;
263               
264        //     
265        // c o m p o s i t e s
266        //     
267        // s t r u c t 
268               
269        structType                              ->      STRUCT structName (structTypeBody)? ;           
270                                       
271        structName                              #->  identifier ;                               
272                                       
273        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
274                                       
275        structMember                    ->      type structMemberName ;
276       
277        structMemberName                #-> identifier ;
278       
279        voidType                                -> VOID ;
280       
281}
Note: See TracBrowser for help on using the repository browser.