source: proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloB.scatter @ 3192

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

Sweeping changes to sync branch with trunk.

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