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

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

Added comments to grammar.

File size: 5.6 KB
Line 
1//
2// Ken Herdy
3//
4// PabloB (block-at-a-time language)
5//
6// Modified: 2-December-2012    - Original definition.
7// Modified: 29-March-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        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? (compoundIdentifier (funcCallRest _promote_))? RCURLY TERMINATOR? ; // TODO eliminate carry.Declare ?
108       
109        kernelName                      #-> identifier ;
110       
111        // s t a t e   i n i t
112        //
113        initDef                         ->  INIT initBlock TERMINATOR? ;
114       
115        initBlock                       #-> LCURLY stateInitStmt* RCURLY;
116       
117        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
118       
119        stateIdentifier         ->  IDENTIFIER ;
120               
121        stateSize                       ->  integerConstant ;
122       
123        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
124       
125        stateValue                      ->  integerConstant ;
126       
127        //stateInitList         ->      streamType (COMMA streamType)* ;
128       
129        // k e r n e l   f u n c t i o n s
130        //
131        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
132       
133        returnType                      #-> type ;      // Note: Strictly not required.
134       
135        parameterList           ->      parameter (COMMA parameter)* ;
136                                                                                                               
137        funcName                        #-> identifier ;
138                                                                                                                       
139        parameter                       ->      type parameterName ;
140                                       
141        parameterName           #-> identifier ;
142       
143        basicBlockStmt          #-> blockStmt ;
144       
145        optFuncDef                      #-> funcDef ;
146 
147        // c o d e   b l o c k
148        //
149        // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
150 
151               
152        //
153        // s t a t e m e n t s
154        //
155        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
156                       
157        funcCallOrAssignStmt    -> compoundIdentifier ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
158       
159        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
160       
161        funcCallArgList                 -> (expr (COMMA expr)*)? ;
162       
163        idisaCallRest                   -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
164
165        idisaCallArgList                -> (expr (COMMA expr)*)? ;     
166               
167        assignOperator                  -> ASSIGN;                             
168                                       
169        assignRest                              -> assignOperator^! expr ;                             
170                                       
171        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
172                                                       
173        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
174                       
175        returnStmt                              -> RETURN (expr)? TERMINATOR ;
176                       
177        localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
178               
179        varName                                 #-> identifier ;
180
181        blockStmt                               -> LCURLY stmt* RCURLY ;
182       
183        //
184        // e x p r e s s i o n s
185        //     
186        expr            #-> LROUND expr RROUND
187                                        |integerConstant
188                                        | stringConstant
189                                        | compoundIdentifier (funcCallRest _promote_ | idisaCallRest _promote_)?
190                                        ;
191                                                                                                                                                                                       
192        constant                                #->  stringConstant | integerConstant ; 
193                                                                   
194        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
195       
196        stringConstant                  -> STRING | SQ_STRING ;
197       
198        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
199                                                       
200        identifier                              -> IDENTIFIER ;   
201       
202    //   
203        // t y p e s
204        //
205
206        //
207        // p r i m i t i v e s
208        //
209
210        type                    #->     identifier      |
211                                                        voidType        |
212                                                        streamType      |
213                                                        structType      |
214                                                        uint8Type       |
215                                                        uint16Type      |
216                                                        uint32Type      |
217                                                        uint64Type      |
218                                                        uint128Type |
219                                                        uint256Type |
220                                                        bitBlockType; // | tupleType;
221       
222        streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
223                                       
224        fieldWidth              ->  integerConstant ;   
225       
226        streamTypeName  #->     identifier ;                           
227               
228        uint8Type               -> UINT8 ;
229        uint16Type              -> UINT16 ;
230        uint32Type              -> UINT32 ;
231        uint64Type              -> UINT64 ;
232        uint128Type             -> UINT128 ;
233        uint256Type             -> UINT256 ;
234       
235        bitBlockType    -> BITBLOCK;
236               
237        //     
238        // c o m p o s i t e s
239        //     
240        // s t r u c t 
241               
242        structType                              ->      STRUCT structName (structTypeBody)? ;           
243                                       
244        structName                              #->  identifier ;                               
245                                       
246        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
247                                       
248        structMember                    ->      type structMemberName ;
249       
250        structMemberName                #-> identifier ;
251       
252        voidType                                -> VOID ;
253       
254}
Note: See TracBrowser for help on using the repository browser.