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

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

Migrated pablo to pabloj/trunk.

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        //stateInitList         ->      streamType (COMMA streamType)* ;
151       
152        // k e r n e l   f u n c t i o n s
153        //
154        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
155       
156        returnType                      #-> type ;      // Note: Strictly not required.
157       
158        parameterList           ->      parameter (COMMA parameter)* ;
159                                                                                                               
160        funcName                        #-> identifier ;
161                                                                                                                       
162        parameter                       ->      type parameterName ;
163                                       
164        parameterName           #-> identifier ;
165       
166        basicBlockStmt          #-> blockStmt ;
167       
168        optFuncDef                      #-> funcDef ;
169 
170               
171        //
172        // s t a t e m e n t s
173        //
174        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
175                       
176        funcCallOrAssignStmt    -> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
177       
178        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
179
180        funcCallArgList                 -> (expr (COMMA expr)*)? ;     
181               
182        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
183                                       
184        assignRest                              -> assignOperator^! expr ;                             
185                                       
186        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
187                                                       
188        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
189                       
190        returnStmt                              -> RETURN (expr)? TERMINATOR ;
191                       
192        localVarDecl                    -> VAR type VarName (assignOperator^! expr) ? ;
193               
194        VarName                                 #-> identifier ;
195
196        blockStmt                               -> LCURLY stmt* RCURLY ;
197       
198        //
199        // e x p r e s s i o n s
200        //     
201        expr            #->     expr1 ((OR^|XOR^) expr)? ;
202                                       
203        expr1           #-> expr2 ((AND^) expr1)? ;
204                                       
205        expr2           #-> NOT^^? expr3  _leftAssoc_;
206       
207        expr3           #-> LROUND expr RROUND
208                                        | streamConstant
209                                        | stringConstant
210                                        | compoundIdentifier (funcCallRest _promote_)?
211                                        ;
212                                                                                                                                                                                       
213        constant                                #->  stringConstant | signedIntegerConstant ; 
214               
215        streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
216       
217        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
218                                            | integerConstant ;
219                                           
220        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
221       
222        stringConstant                  -> STRING | SQ_STRING ;
223       
224        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
225                                                       
226        identifier                              -> IDENTIFIER ;
227       
228    //   
229        // t y p e s
230        //
231
232        //
233        // p r i m i t i v e s
234        //
235
236        type                    #->  streamType | structType | void | identifier ; // | tupleType;
237       
238        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
239                                       
240        fieldWidth              ->  integerConstant ;   
241       
242        streamTypeName  #->     identifier ;                           
243               
244        //     
245        // c o m p o s i t e s
246        //     
247        // s t r u c t 
248               
249        structType                              ->      STRUCT structName (structTypeBody)? ;           
250                                       
251        structName                              #->  identifier ;                               
252                                       
253        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
254                                       
255        structMember                    ->      type structMemberName ;
256       
257        structMemberName                #-> identifier ;
258       
259        void                                    -> VOID ;
260       
261}
Note: See TracBrowser for help on using the repository browser.