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

Last change on this file since 3769 was 3769, checked in by ksherdy, 4 years ago

Added filter to s2k. Minor changes to s2k and b2k grammar.

File size: 6.6 KB
Line 
1//
2// Tom Shermer, Ken Herdy
3//
4// b2k - Very high-level IR for the expression of block-by-block parallel bit stream processing.
5//
6// Modified:    02-12-2012      Original definition.
7//              29-03-2013      Added IDISA function call.
8//              06-04-2013      Updated to Scatter with types.
9//
10
11types {
12//    toolchain.s2k.lang.type.Type,
13//    toolchain.s2k.lang.type.PrimitiveType,
14//    toolchain.s2k.lang.type.StreamType,
15}
16
17context main {
18    recognizers {
19        Whitespace [IGNORE],
20        Integer [INTEGER_CONST],
21        Identifier [IDENTIFIER],        // Java identifiers. Produces Lextant Tokens for keywords.
22        Comment [IGNORE] "#" "\n",      // parabix2_pablo debugging only.
23        Comment [IGNORE] "//" "\n",
24        Comment [SQ_STRING] "'" "'",
25        Comment [IGNORE] "/*" "*/",     // Comment. Comment [STRING] "/*" "*/",
26        String [STRING],
27        Punctuator,
28        EndOfInput,
29    }
30
31    // t o k e n s
32    tokens {
33        INIT,
34        KERNEL,
35        IN,
36        OUT,
37        INOUT,
38        FUNCTION,   
39        STRUCT,
40        INT,
41        VOID,
42        BOOL,
43        BITFIELD    "BitField",
44        BITBLOCK    "BitBlock", // alias for architecture dependent SIMD type
45        //CODEBLOCK,
46        IF,
47        ELSE,
48        WHILE,
49        RETURN,
50        ASSIGN      "=",
51        LANGLE      "<",
52        RANGLE      ">",
53        LCURLY      "{",
54        RCURLY      "}",
55        LROUND      "(",
56        RROUND      ")",
57        LSQUARE     "[",
58        RSQUARE     "]",
59        COMMA       ",",
60        TERMINATOR  ";",
61        DOT         ".",
62    }
63}
64
65interfaces {
66    intValued {int value = 0;},
67}
68
69nodes {
70    assign {} [assignRest],
71    funcCall {} [funcCallRest],
72    idisaFuncCall {} [idisaFuncCallRest],
73    integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
74    // primitiveType{} [intType voidType boolType bitBlockType], // TODO - update S2B to handle this
75    fieldWidthType{int fieldWidth = 1;} [],
76    // codeBlockWidth{int codeBlockWidth = 128;} [],
77}
78
79grammar {
80   
81    program     -> (structDecl | kernelDef) * ;
82   
83    //
84    // s t r u c t   d e c l a r a t i o n s 
85    //
86    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
87    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
88    structMember        ->  structMemberType structMemberName ;
89    structMemberType    #-> structType | bitBlockType ;
90    structMemberName    #-> identifier ;
91
92    //
93    // k e r n e l   d e c l a r a t i o n s
94    //
95    kernelDef           ->  KERNEL kernelName LCURLY initDef funcDef (funcDef)* carryDeclare TERMINATOR RCURLY TERMINATOR? ; 
96    kernelName          #-> identifier ;
97
98    //
99    // k e r n e l   p r o p e r t i e s 
100    //
101    initDef             #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
102    kernelProperty      ->  propertyName ASSIGN propertyValue TERMINATOR ;
103    propertyName        #-> identifier ;
104    propertyValue       ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
105
106    //
107    // k e r n e l   f u n c t i o n s
108    //
109    funcDef             ->  FUNCTION funcName LROUND parameterList RROUND basicBlockStmt TERMINATOR? ;
110    parameterList       ->  (parameter (COMMA parameter)* )?;
111    funcName            #-> identifier ;
112    parameter           ->  (parameterMode)? type parameterName ;
113    parameterMode               ->  (IN | OUT | INOUT) ;
114    parameterName       #-> identifier ;
115    basicBlockStmt      #-> blockStmt ;
116    carryDeclare                #-> expr; // KH: temp hack to append the CarryDeclare() macro
117
118    //
119    // c o d e   b l o c k     // (32,64,128,256,...)
120    //
121    // codeBlock        ->  CODEBLOCK codeBlockWidthSpecifier! 
122    //                      { @codeBlockWidth = @:value; }
123    //                      blockStmt (TERMINATOR)? ;
124    //               
125    // codeBlockWidthSpecifier  #-> (LANGLE integerConstant RANGLE ) | (epsilon {@value = 128;}) ;
126
127    //
128    // s t a t e m e n t s
129    //
130    stmt                    #-> varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
131    funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: TODO Add Semantic Analysis pass to validate expr non-terminal is of function call node type   
132    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
133    assignOperator          ->  ASSIGN ;                 
134    assignRest              ->  assignOperator^! expr ;               
135    ifStmt                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;             
136    whileStmt               ->  WHILE LROUND expr RROUND blockStmt ;
137    returnStmt              ->  RETURN (expr) ? TERMINATOR ;
138    varDecl                 ->  type varName TERMINATOR ;
139    varName                 #-> identifier ;
140    blockStmt               ->  LCURLY stmt* RCURLY ;
141
142    //
143    // e x p r e s s i o n s
144    //   
145    expr            #-> LROUND expr RROUND
146                    | constant
147                    | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
148
149    constant            #->     stringConstant | integerConstant ;
150    integerConstant     ->      INTEGER_CONST {@value = @@value;} ;
151    stringConstant      ->      STRING | SQ_STRING ;
152    compoundIdentifier  #->     identifier (DOT^ identifier)* ;
153    identifier          ->      IDENTIFIER ;
154    funcCallRest        ->      LROUND^ funcCallArgList RROUND ;
155    funcCallArgList     ->      (expr (COMMA expr)*) ? ;
156    idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
157    fieldWidth          ->      integerConstant ; // fieldWidthSpecifier
158
159    //
160    // t y p e s
161    //
162    type                #-> primitiveType   |
163                            bitFieldType    |
164                            structType ;
165
166    primitiveType       #->  ( intType | voidType | boolType | bitBlockType ) ;
167
168    intType             ->  INT ;       // { @type = {{PrimitiveType.INTEGER}}; } ;
169    voidType            ->  VOID ;      // { @type = {{PrimitiveType.VOID}}; } ;
170    boolType            ->  BOOL ;      // { @type = {{PrimitiveType.BOOL}}; } ;
171    bitBlockType        ->  BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
172   
173    bitFieldType        ->  BITFIELD  fieldWidthSpecifier!
174                                            {   @fieldWidth = @:value;
175                                            // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
176                                            } ;
177
178    fieldWidthSpecifier    #-> (LANGLE integerConstant RANGLE )
179                            | (epsilon {@value = 1;}) ;
180   
181    structType              ->  STRUCT structName ;
182    structName              #-> identifier ;
183   
184}
Note: See TracBrowser for help on using the repository browser.