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

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

Added sequential for support to grammar. Grammar cleanup.

File size: 8.9 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        VOID,
47        BOOL,
48        BITFIELD    "BitField",
49        BITBLOCK    "BitBlock",
50        //CODEBLOCK,
51        IF,
52        ELSE,
53        FOR,
54        BY,
55        WHILE,
56        RETURN,
57        AND             "&",
58        OR              "|",
59        NOT             "~",
60        XOR             "^",
61        MULTIPLY        "*",
62        DIVIDE          "/",
63        PLUS            "+",
64        MINUS           "-",
65        ASSIGN      "=",
66        LANGLE      "<",
67        RANGLE      ">",
68        LCURLY      "{",
69        RCURLY      "}",
70        LROUND      "(",
71        RROUND      ")",
72        LSQUARE     "[",
73        RSQUARE     "]",
74        COMMA       ",",
75        TERMINATOR  ";",
76        DOT         ".",
77        DDOT        "..",
78    }
79}
80
81interfaces {
82    intValued {int value = 0;},
83}
84
85nodes {
86    unaryOperator           {}                     [expr2],
87    binaryOperator          {}                     [expr expr1 expr3 expr4],
88    assign                  {}                     [assignRest],
89    funcCall                {}                     [funcCallRest],
90    idisaFuncCall           {}                     [idisaFuncCallRest],
91    integerConstant         {intValued;}           [fieldWidthSpecifier],  // codeBlockWidthSpecifier ],
92    // primitiveType        {}                     [intType voidType boolType bitBlockType], // KH: update S2B
93    fieldWidthType          {int fieldWidth = 1;}  [],
94    // codeBlockWidth{int codeBlockWidth = 128;}   [],
95}
96
97grammar {
98   
99    program     -> (structDef | kernelDef) * graphDef ?;
100   
101    //
102    // s t r u c t   d e f i n i t i o n 
103    //
104    structDef           ->  STRUCT identifier structDefBody TERMINATOR? ;
105    structDefBody       ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
106    structMember        ->  structMemberType identifier ;
107    structMemberType    #-> bitBlockType ;
108
109    //
110    // k e r n e l   d e f i n i t i o n
111    //
112    kernelDef           ->  KERNEL identifier LCURLY kernelInitDef kernelFuncDefs carryDeclare TERMINATOR RCURLY TERMINATOR? ; 
113    kernelFuncDefs      ->  kernelFuncDef * ;
114
115    //
116    // k e r n e l   p r o p e r t i e s 
117    //
118    kernelInitDef       #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
119    kernelProperty      ->  identifier ASSIGN propertyValue TERMINATOR ;
120    propertyValue       ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
121
122    //
123    // k e r n e l   f u n c t i o n   d e f i n i t i o n
124    //
125    kernelFuncDef       ->  FUNCTION identifier LROUND kernelParameterList RROUND kernelFuncBody TERMINATOR? ;
126    kernelParameterList ->  (kernelParameter (COMMA kernelParameter)* )?;
127    kernelParameter     ->  (kernelParameterMode)? type identifier ;
128    kernelParameterMode ->  (IN | OUT | INOUT) ;
129    kernelFuncBody      #-> blockStmt ;
130    carryDeclare                #-> expr; // KH: temp hack to append the CarryDeclare() macro
131
132    //
133    // 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
134    //   
135    graphDef                    ->  GRAPH identifier LROUND graphParameterList RROUND graphBody TERMINATOR ? ;
136   
137    graphParameterList          ->  ( graphParameter (COMMA graphParameter)* ) ? ; // KH: implement as a 'modal' parameter
138    graphParameter              ->  graphParameterMode? type identifier ;
139    graphParameterMode          ->  (IN | OUT | INOUT) ;
140   
141    graphBody                   ->  LCURLY graphVarDecls addKernelStmts RCURLY ;
142   
143    graphVarDecls               ->  ( structDecl | kernelDecl ) * ;
144    structDecl                  ->  structType identifier TERMINATOR ;
145    kernelDecl                  ->  kernelType identifier TERMINATOR ;
146    // graphDecl                ->  GRAPH identifier TERMINATOR ;
147       
148    addKernelStmts              ->  addKernelStmt * ;   
149    addKernelStmt               ->  identifier addKernelArgList ;
150    addKernelArgList            ->  (identifier (COMMA identifier) *) ? ;
151
152    //
153    // c o d e   b l o c k     // (32,64,128,256,...)
154    //
155    // codeBlock        ->  CODEBLOCK codeBlockWidthSpecifier! 
156    //                      { @codeBlockWidth = @:value; }
157    //                      blockStmt (TERMINATOR)? ;
158    //               
159    // codeBlockWidthSpecifier  #-> (LANGLE fieldWidthSpecifier RANGLE ) | (epsilon {@value = 128;}) ;
160
161    //
162    // s t a t e m e n t s
163    //
164    stmt                    #-> varDecl | funcCallOrAssignStmt | returnStmt | ifStmt | whileStmt  | forStmt ;
165    varDecl                 ->  type identifier TERMINATOR ;
166    funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: Add SA pass to validate expr is a function call type   
167    assignOperator          ->  ASSIGN ;                 
168    assignRest              ->  assignOperator^! expr ;               
169    returnStmt              ->  RETURN (expr) ? TERMINATOR ;
170    ifStmt                  ->  IF expr blockStmt (ELSE blockStmt)? ;             
171    whileStmt               ->  WHILE expr blockStmt ;
172   
173    // KH: add forStmt SA, lowerBound <= upperBound, stride != 0
174    forStmt                     ->      FOR identifier IN range stride blockStmt ;
175        // indexTypeDecl            ->      indexType identifier;
176        range                       ->      lowerBoundExpr DDOT upperBoundExpr ;
177        lowerBoundExpr              #->     expr ;
178        upperBoundExpr              #->     expr ;
179        stride                      ->      (BY integerConstant) | (epsilon {@value = 1;}) ;
180
181    blockStmt               ->  LCURLY stmt* RCURLY ;
182
183    //
184    // e x p r e s s i o n s
185    //   
186        expr                 #-> expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
187    expr1                #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
188    expr2                #-> NOT^^? expr3;                                         
189    expr3                #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
190    expr4                #-> expr5 ((PLUS^ | MINUS^) expr4)? _leftAssoc_ ;
191    expr5                #-> LROUND expr RROUND
192                         | constant
193                         | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
194
195    constant            #->     stringConstant | integerConstant ;
196    integerConstant     ->      INTEGER_CONST {@value = @@value;} ;
197    stringConstant      ->      STRING | SQ_STRING ;
198    compoundIdentifier  #->     identifier (DOT^ identifier)* ;
199    identifier          ->      IDENTIFIER ;
200    funcCallRest        ->      LROUND^ funcCallArgList RROUND ;
201    funcCallArgList     ->      (expr (COMMA expr)*) ? ;
202    idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND; // KH: parameterized function call ?
203    fieldWidth          ->      integerConstant ;                                             // KH: fieldWidthSpecifier / expr ?
204    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
205
206    //
207    // t y p e s
208    //
209    type                #-> primitiveType   |
210                            bitFieldType    |
211                            structType      |
212                            kernelType      ;
213
214    primitiveType       #->  ( intType | voidType | boolType | bitBlockType ) ;
215
216    intType             ->  INT ;       // { @type = {{PrimitiveType.INTEGER}}; } ;
217    voidType            ->  VOID ;      // { @type = {{PrimitiveType.VOID}}; } ; // KH: ?
218    boolType            ->  BOOL ;      // { @type = {{PrimitiveType.BOOL}}; } ;
219    bitBlockType        ->  BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
220   
221    bitFieldType        ->  BITFIELD  fieldWidthSpecifier!
222                                            {   @fieldWidth = @:value;
223                                            // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
224                                            } ;
225
226    fieldWidthSpecifier    #-> (LANGLE integerConstant RANGLE )
227                            | (epsilon {@value = 1;}) ;
228   
229    structType             ->  STRUCT identifier ;
230    kernelType             -> KERNEL identifier ;
231   
232}
Note: See TracBrowser for help on using the repository browser.