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

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

Added carry getter/setter for implementation consistency.

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