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

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

Moved lang.carrySet to PabloS package. Added CarryFlip?() and CarryDeclare?() calls to PabloS to PabloB translation.

File size: 5.5 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
11types {
12//      toolchain.pabloS.lang.type.Type,
13//      toolchain.pabloS.lang.type.PrimitiveType,
14//      toolchain.pabloS.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        FUNCTION,       
36        STRUCT,
37        INT,
38        VOID,
39        BOOL,
40        BITFIELD        "BitField",     
41        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD type
42        //CODEBLOCK,
43        IF,
44        ELSE,
45        WHILE,
46        RETURN,
47        ASSIGN      "=",
48        LANGLE          "<",
49        RANGLE          ">",
50        LCURLY          "{",
51        RCURLY          "}",
52        LROUND          "(",
53        RROUND          ")",
54        LSQUARE         "[",
55        RSQUARE         "]",
56        COMMA           ",",
57        TERMINATOR  ";",
58        DOT                     ".",
59  }
60}
61
62interfaces {
63         intValued {int value = 0;},     
64}
65
66nodes {
67        assign {} [assignRest],
68        funcCall {} [funcCallRest],
69        idisaFuncCall {} [idisaFuncCallRest],
70        integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
71        // primitiveType{} [intType voidType boolType bitBlockType],  // TODO - update S2B to handle this
72        fieldWidthType{int fieldWidth = 1;} [],
73        // codeBlockWidth{int codeBlockWidth = 128;} [],
74}
75
76grammar {
77       
78        program         -> (structDecl | kernelDef) * ;
79           
80        //
81        // s t r u c t   d e c l a r a t i o n s 
82        //
83        structDecl                      ->  STRUCT structName structDeclBody TERMINATOR? ;
84        structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
85        structMember            ->      structMemberType structMemberName ;
86        structMemberType        #-> structType | bitBlockType ;
87        structMemberName        #-> identifier ;
88   
89    //
90        // k e r n e l   d e c l a r a t i o n s                                                       
91        //
92        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
93        kernelName                      #-> identifier ;
94       
95        //
96        // k e r n e l   p r o p e r t i e s 
97        //
98        initDef                         #->  INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
99        kernelProperty          ->  propertyName ASSIGN propertyValue TERMINATOR ;
100        propertyName            #-> identifier ;
101        propertyValue           ->      LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
102
103        //     
104        // k e r n e l   f u n c t i o n s
105        //
106        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
107        returnType                      #-> type ;      // KH: TODO - Not required. Planned move to in/out parameters.
108        parameterList           ->      parameter (COMMA parameter)* ;
109        funcName                        #-> identifier ;
110        parameter                       ->      type parameterName ;
111        parameterName           #-> identifier ;
112        basicBlockStmt          #-> blockStmt ;
113        optFuncDef                      #-> funcDef ;
114
115        //
116        // c o d e   b l o c k  // (32,64,128,256,...)
117        //
118        // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:value; }
119        //                                                                                                                                      blockStmt (TERMINATOR)? ;
120        //                             
121        // codeBlockWidthSpecifier      #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 128;}) ;
122               
123        //
124        // s t a t e m e n t s
125        //
126        stmt                                    #->     localVarDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
127        funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: TODO Add Semantic Analysis pass to validate expr non-terminal is of function call node type       
128        idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
129        assignOperator                  ->      ASSIGN ;                               
130        assignRest                              ->      assignOperator^! expr ;                         
131        ifStmt                                  ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                     
132        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
133        returnStmt                              ->      RETURN (expr) ? TERMINATOR ;
134        localVarDecl                    ->      type varName (assignOperator^! expr) ? TERMINATOR ;
135        varName                                 #-> compoundIdentifier ;
136        blockStmt                               ->      LCURLY stmt* RCURLY ;
137       
138        //
139        // e x p r e s s i o n s
140        //     
141        expr            #-> LROUND expr RROUND
142                                        | constant
143                                        | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
144
145        constant                                #->     stringConstant | integerConstant ; 
146        integerConstant                 ->              INTEGER_CONST {@value = @@value;} ;
147        stringConstant                  ->              STRING | SQ_STRING ;   
148        compoundIdentifier              #->     identifier (DOT^ identifier)* ;
149        identifier                              ->              IDENTIFIER ;   
150        funcCallRest                    ->              LROUND^ funcCallArgList RROUND ;
151        funcCallArgList                 ->              (expr (COMMA expr)*) ? ;       
152        idisaFuncCallRest               ->              LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
153        fieldWidth                              ->              integerConstant ; // TODO - update using PabloS style
154
155    //   
156        // t y p e s
157        //
158        type                            #-> primitiveType      |
159                                bitFieldType       |
160                                                        structType             
161                                                        ; 
162       
163        primitiveType           #->  ( intType | voidType | boolType | bitBlockType ) ;
164
165        intType                         ->      INT ;           // { @type = {{PrimitiveType.INTEGER}}; } ;
166        voidType                        ->  VOID ;              // { @type = {{PrimitiveType.VOID}}; } ;
167        boolType                        ->  BOOL ;              // { @type = {{PrimitiveType.BOOL}}; } ;
168        bitBlockType            ->      BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
169       
170        bitFieldType            ->      BITFIELD  fieldWidthSpecifier! {        @fieldWidth = @:value;
171                                                                                                                                // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
172                                                                                                                } ;
173                                                                                                                       
174        fieldWidthSpecifier     #-> (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;       
175       
176        structType                      ->      STRUCT structName ;             
177        structName                      #-> identifier ;                               
178       
179}
Note: See TracBrowser for help on using the repository browser.