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

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

Continued updates PabloS, PabloB grammars. Attempts to get it right.

File size: 5.8 KB
Line 
1//
2// Ken Herdy
3// 2-December-2012
4//
5// PabloBlock (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// Boolean
20// String Constant
21//
22// Compound Types
23//
24// ...
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        VAR,
59        KERNEL,
60        FUNCTION,       
61        STREAM,
62        STRUCT,
63        VOID,
64        INIT,
65               
66        IF,
67        ELSE,
68        WHILE,
69        RETURN,
70
71        AND   "&",
72        OR    "|",
73        NOT   "~",
74        XOR   "^",
75        ASSIGN      "=",
76        AND_ASSIGN  "&=",
77        OR_ASSIGN   "|=",
78        XOR_ASSIGN  "^=",       
79        LANGLE          "<",
80        RANGLE          ">",
81        LCURLY          "{",
82        RCURLY          "}",
83        LROUND          "(",
84        RROUND          ")",
85       
86        LSQUARE         "[",
87        RSQUARE         "]",
88       
89        COMMA           ",",
90        TERMINATOR  ";",
91        DOT                     ".",
92        MINUS           "-",
93  }
94}
95
96interfaces {
97//       escapable {boolean escaped = false;},
98         intValued {int value = 0;},
99}
100
101nodes {
102  binaryOperator {} [expr, expr1],//, expr4],
103  unaryOperator {} [expr2],// expr5],
104  assign {} [assignRest],
105  funcCall {} [funcCallRest],
106  integerConstant{intValued;} [],
107  streamConstant{intValued;} [],
108}
109
110grammar {
111        program         -> (typeDecl | kernelDef) * ;
112
113        //
114        // t o p - l e v e l 
115        //
116       
117        //
118        // d e c l a r a t i o n s
119        //
120        // Decls                -> typeDecl TERMINATOR ;
121               
122        typeDecl                ->  type TERMINATOR ;           
123               
124        // typeDef              ->  TYPEDEF type identifier TERMINATOR ;
125       
126        // DeclList             ->  identifier (COMMA identifier)* ; 
127       
128   
129    //
130        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
131        //
132        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? RCURLY TERMINATOR? ;
133       
134        kernelName                      #-> identifier ;
135       
136        // s t a t e   i n i t
137        //
138        initDef                         ->  INIT initBlock TERMINATOR? ;
139       
140        initBlock                       #-> LCURLY stateInitStmt* RCURLY;
141       
142        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
143       
144        stateIdentifier         ->  IDENTIFIER ;
145               
146        stateSize                       ->  integerConstant ;
147       
148        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of intX type
149       
150        stateValue                      ->  integerConstant ;
151       
152        //stateInitList         ->      streamType (COMMA streamType)* ;
153       
154        // k e r n e l   f u n c t i o n s
155        //
156        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
157       
158        returnType                      #-> type ;      // Note: Strictly not required.
159       
160        parameterList           ->      parameter (COMMA parameter)* ;
161                                                                                                               
162        funcName                        #-> identifier ;
163                                                                                                                       
164        parameter                       ->      type parameterName ;
165                                       
166        parameterName           #-> identifier ;
167       
168        basicBlockStmt          #-> blockStmt ;
169       
170        optFuncDef                      #-> funcDef ;
171 
172               
173        //
174        // s t a t e m e n t s
175        //
176        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
177                       
178        funcCallOrAssignStmt    -> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
179       
180        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
181
182        funcCallArgList                 -> (expr (COMMA expr)*)? ;     
183               
184        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
185                                       
186        assignRest                              -> assignOperator^! expr ;                             
187                                       
188        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
189                                                       
190        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
191                       
192        returnStmt                              -> RETURN (expr)? TERMINATOR ;
193                       
194        localVarDecl                    -> VAR type VarName (assignOperator^! expr) ? ;
195               
196        VarName                                 #-> identifier ;
197
198        blockStmt                               -> LCURLY stmt* RCURLY ;
199       
200        //
201        // e x p r e s s i o n s
202        //     
203        expr            #->     expr1 ((OR^|XOR^) expr)? ;
204                                       
205        expr1           #-> expr2 ((AND^) expr1)? ;
206                                       
207        expr2           #-> NOT^^? expr3  _leftAssoc_;
208       
209        expr3           #-> LROUND expr RROUND
210                                        | streamConstant
211                                        | stringConstant
212                                        | compoundIdentifier (funcCallRest _promote_)?
213                                        ;
214                                                                                                                                                                                       
215        constant                                #->  stringConstant | signedIntegerConstant ; 
216               
217        streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
218       
219        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
220                                            | integerConstant ;
221                                           
222        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
223       
224        stringConstant                  -> STRING | SQ_STRING ;
225       
226        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
227                                                       
228        identifier                              -> IDENTIFIER ;
229       
230    //   
231        // t y p e s
232        //
233
234        //
235        // p r i m i t i v e s
236        //
237
238        type                    #->  streamType | structType | void | identifier ; // | tupleType;
239       
240        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
241                                       
242        fieldWidth              ->  integerConstant ;   
243       
244        streamTypeName  #->     identifier ;                           
245               
246        //     
247        // c o m p o s i t e s
248        //     
249        // s t r u c t 
250               
251        structType                              ->      STRUCT structName (structTypeBody)? ;           
252                                       
253        structName                              #->  identifier ;                               
254                                       
255        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
256                                       
257        structMember                    ->      type structMemberName ;
258       
259        structMemberName                #-> identifier ;
260       
261        void                                    -> VOID ;
262       
263}
Note: See TracBrowser for help on using the repository browser.