source: proto/s2k/trunk/framework/input/grammar/scatter/b2k.scatter @ 4116

Last change on this file since 4116 was 4116, checked in by ksherdy, 5 years ago

Grammar clean-up. Removed unused types. Restricted var decl to primitive or aggregate types (stream/BitBlock).

File size: 9.3 KB
Line 
1//
2// b2k - A very high-level IR for the expression of block-by-block parallel bit stream processing.
3//
4// 02-12-2012      Original definition.
5// 29-03-2013      Added IDISA function call.
6// 06-04-2013      Updated to Scatter with types.
7//
8//
9//
10// Tom Shermer <shermer at sfu dot ca>
11// Ken Herdy <ksherdy at sfu dot ca>
12//
13
14
15types {
16//    toolchain.s2k.lang.type.Type,
17//    toolchain.s2k.lang.type.PrimitiveType,
18//    toolchain.s2k.lang.type.StreamType,
19}
20
21context main {
22    recognizers {
23        Whitespace [IGNORE],
24        Integer [INTEGER_CONST],
25        Identifier [IDENTIFIER],        // Java identifiers. Produces Lextant Tokens for keywords.
26        Comment [IGNORE] "#" "\n",      // parabix2_pablo debugging only.
27        Comment [IGNORE] "//" "\n",
28        Comment [SQ_STRING] "'" "'",
29        Comment [IGNORE] "/*" "*/",     // Comment. Comment [STRING] "/*" "*/",
30        String [STRING],
31        Punctuator,
32        EndOfInput,
33    }
34
35    // t o k e n s
36    tokens {
37        GRAPH,
38        INIT,
39        KERNEL,
40        IN,
41        OUT,
42        INOUT,
43        FUNCTION,   
44        STRUCT,
45        INT,
46        //BOOL,
47        //BITFIELD         "BitField",
48        BITBLOCK         "BitBlock",
49        //CODEBLOCK,
50        IF,
51        ELSE,
52        FOR,
53        BY,
54        WHILE,
55        RETURN,
56        AND             "&",
57        OR              "|",
58        NOT             "~",
59        XOR             "^",
60        MULTIPLY        "*",
61        DIVIDE          "/",
62        PLUS            "+",
63        MINUS           "-",
64        ASSIGN          "=",
65        LANGLE          "<",
66        RANGLE          ">",
67        LCURLY          "{",
68        RCURLY          "}",
69        LROUND          "(",
70        RROUND          ")",
71        LSQUARE         "[",
72        RSQUARE         "]",
73        COMMA           ",",
74        TERMINATOR      ";",
75        DOT             ".",
76        DDOT           "..",
77        COLON           ":",
78    }
79}
80
81interfaces {
82    intValued {int value = 0;},
83    hasFieldWidth   {int fieldWidth = 1;},
84}
85
86nodes {
87    unaryOperator           {}                     [expr2],
88    binaryOperator          {}                     [expr expr1 expr3 expr4],
89    assign                  {}                     [assignRest],
90    funcCall                {}                     [funcCallRest],
91    idisaFuncCall           {}                     [idisaFuncCallRest],
92    bitBlockType            {hasFieldWidth;}  [],
93    integerConstant         {intValued;}           [fieldWidthSpecifier],  // codeBlockWidthSpecifier ],
94    // primitiveType        {}                     [intType], // KH: update S2B
95    fieldWidthType          {int fieldWidth = 1;}  [],
96    // codeBlockWidth{int codeBlockWidth = 128;}   [],
97}
98
99grammar {
100   
101    program     -> (structDef | kernelDef) * graphDef ?;
102   
103    //
104    // s t r u c t   d e f i n i t i o n 
105    //
106    structDef           ->  STRUCT identifier structDefBody TERMINATOR? ;
107    structDefBody       ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
108    structMember        ->  structMemberType identifier ;
109    structMemberType    #-> bitBlockType ;
110
111    //
112    // k e r n e l   d e f i n i t i o n
113    //
114    kernelDef           ->  KERNEL identifier LCURLY kernelInitDef kernelFuncDefs carryDeclare TERMINATOR RCURLY TERMINATOR? ; 
115    kernelFuncDefs      ->  kernelFuncDef * ;
116
117    //
118    // k e r n e l   p r o p e r t i e s 
119    //
120    kernelInitDef       #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
121    kernelProperty      ->  identifier ASSIGN propertyValue TERMINATOR ;
122    propertyValue       ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
123
124    //
125    // k e r n e l   f u n c t i o n   d e f i n i t i o n
126    //
127    kernelFuncDef       ->  FUNCTION identifier LROUND kernelParameterList RROUND kernelFuncBody TERMINATOR? ;
128    kernelParameterList ->  (kernelParameter (COMMA kernelParameter)* )?;
129    kernelParameter     ->  (kernelParameterMode COLON)? type identifier ;
130    kernelParameterMode ->  (IN | OUT | INOUT) ;
131    kernelFuncBody      #-> blockStmt ;
132    carryDeclare                #-> expr; // KH: temp hack to append the CarryDeclare() macro
133
134    //
135    // s t r e a m   g r a p h  ( p i p e l i n e )  d e f i n i t i o n
136    //   
137    graphDef                    ->  GRAPH identifier LROUND graphParameterList RROUND graphBody TERMINATOR ? ;
138   
139    graphParameterList          ->  ( graphParameter (COMMA graphParameter)* ) ? ; // KH: implement as a 'modal' parameter
140    graphParameter              ->  graphParameterMode? type identifier ;
141    graphParameterMode          ->  (IN | OUT | INOUT) ;
142   
143    graphBody                   ->  LCURLY graphVarDecls addKernelStmts RCURLY ;
144   
145    graphVarDecls               ->  ( structDecl | kernelDecl ) * ;
146    structDecl                  ->  structType identifier TERMINATOR ;
147    kernelDecl                  ->  kernelType identifier TERMINATOR ;
148    // graphDecl                ->  GRAPH identifier TERMINATOR ;
149       
150    addKernelStmts              ->  addKernelStmt * ;   
151    addKernelStmt               ->  identifier addKernelArgList ;
152    addKernelArgList            ->  (identifier (COMMA identifier) *) ? ;
153
154    //
155    // c o d e   b l o c k     // (32,64,128,256,...)
156    //
157    // codeBlock        ->  CODEBLOCK codeBlockWidthSpecifier! 
158    //                      { @codeBlockWidth = @:value; }
159    //                      blockStmt (TERMINATOR)? ;
160    //               
161    // codeBlockWidthSpecifier  #-> (LANGLE fieldWidthSpecifier RANGLE ) | (epsilon {@value = 128;}) ;
162
163    //
164    // s t a t e m e n t s
165    //
166    stmt                    #-> varDecl | funcCallOrAssignStmt | returnStmt | ifStmt | whileStmt | forStmt ;
167    blockStmt               ->  LCURLY stmt* RCURLY ;
168    varDecl                 ->  (primitiveType | bitBlockType) identifier TERMINATOR ;
169    funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: Add SA pass to validate expr is a function call type   
170    assignOperator          ->  ASSIGN ;                 
171    assignRest              ->  assignOperator^! expr ;               
172    returnStmt              ->  RETURN (expr) ? TERMINATOR ;
173    ifStmt                  ->  IF expr blockStmt (ELSE blockStmt)? ;             
174    whileStmt               ->  WHILE expr blockStmt ;
175   
176    // KH: add forStmt SA, lowerBound <= upperBound, stride != 0
177        // KH: count controlled for loop to support reductions         
178        forStmt                     ->      FOR identifier IN stridedRange blockStmt ;
179        //indexTypeDecl             ->      indexType identifier ; // ?
180    stridedRange                ->      range step ;
181    range                       ->      integerConstant DDOT integerConstant ;
182    step                        #->     (BY integerConstant) | epsilon {@value = 1;} ;
183
184    //
185    // e x p r e s s i o n s
186    //   
187//    expr        #-> expr1 ((BY^) expr1)?                  _leftAssoc_ ;   
188//    expr1       #-> expr2 ((RANGE^) expr2)?               _leftAssoc_ ;
189    expr        #-> expr1 ((OR^) expr)?                   _leftAssoc_ ;
190    expr1       #-> expr2 ((XOR^) expr1)?                 _leftAssoc_ ;
191    expr2       #-> expr3 ((AND^) expr2)?                 _leftAssoc_ ;
192    expr3       #-> expr4 ((PLUS^ | MINUS^) expr3)?       _leftAssoc_ ;
193    expr4       #-> expr5 ((MULTIPLY^ | DIVIDE^) expr4)?  _leftAssoc_ ;
194    expr5       #-> ((PLUS^^ | MINUS^^)? expr6) | ((NOT^^)* expr6)                          ;
195    expr6       #-> compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? 
196                |   LROUND expr RROUND
197                |   constant ;
198
199    constant            #->     stringConstant | integerConstant ;
200    integerConstant     ->      INTEGER_CONST {@value = @@value;} ;
201    stringConstant      ->      STRING | SQ_STRING ;
202    compoundIdentifier  #->     identifier (DOT^ identifier)* ;
203    identifier          ->      IDENTIFIER ;
204    funcCallRest        ->      LROUND^ funcCallArgList RROUND ;
205    funcCallArgList     ->      (expr (COMMA expr)*) ? ;
206    idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND; // KH: parameterized function call ?
207    fieldWidth          ->      integerConstant ;                                             // KH: fieldWidthSpecifier / expr ?
208    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
209
210    //
211    // t y p e s
212    //
213    type                #-> primitiveType   |
214                            bitBlockType    |
215                            // bitFieldType |
216                            structType      |
217                            kernelType      ;
218
219    primitiveType       #->  ( intType ) ;
220
221    intType             ->  INT ;       // { @type = {{PrimitiveType.INTEGER}}; } ;
222    bitBlockType        ->  BITBLOCK fieldWidthSpecifier! {   @fieldWidth = @:value;
223                                                                    //@fieldWidth ; // KH ?
224                                                                } ;
225
226    // bitFieldType        ->  BITFIELD  fieldWidthSpecifier!
227    //                                        {   @fieldWidth = @:value;
228    //                                        // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
229    //                                        } ;
230
231    fieldWidthSpecifier    #-> (LANGLE integerConstant RANGLE )
232                            | (epsilon {@value = 1;}) ;
233
234    structType             ->  STRUCT identifier ;
235    kernelType             -> KERNEL identifier ;
236   
237}
Note: See TracBrowser for help on using the repository browser.