source: proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter @ 2981

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

Grammar updates. Eliminated optional fw on stream types. Removed typedef.

File size: 5.0 KB
Line 
1//
2// PabloS - Parallel Stream Language - A tiny language for the definition of stream functions and stream types.
3//
4// Author:              Ken Herdy <ksherdy at sfu dot ca>
5// Created:             2012/09/08
6// Last Changed:        2013/02/01
7//
8// History:
9//                              Initial definition, 2012/09/08
10//
11//
12context main {
13
14  recognizers {
15         Whitespace [IGNORE],
16         Integer [INTEGER_CONST],
17         Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant tokens for keywords.
18         Comment [IGNORE] "#" "\n",                     // Added to support parabix2_pablo debugging.
19         Comment [IGNORE] "//" "\n",     
20         Comment [SQ_STRING] "'" "'",
21         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
22         String [STRING],
23         Punctuator,
24         EndOfInput,
25  }
26
27  // t o k e n s
28  tokens {
29 
30//      TYPEDEF,
31        VAR,
32        FUNCTION,       
33        STREAM,
34        STRUCT,
35//      TUPLE,
36        VOID,
37       
38        IF,
39        ELSE,
40        WHILE,
41        RETURN,
42
43        AND   "&",
44        OR    "|",
45        NOT   "~",
46        XOR   "^",
47        ASSIGN      "=",
48        AND_ASSIGN  "&=",
49        OR_ASSIGN   "|=",
50        XOR_ASSIGN  "^=",
51        LANGLE          "<",
52        RANGLE          ">",
53        LCURLY          "{",
54        RCURLY          "}",
55//      LSQUARE         "[",
56//      RSQUARE         "]",
57        LROUND          "(",
58        RROUND          ")",
59        COMMA           ",",
60        TERMINATOR  ";",
61        DOT                     ".",
62//      MINUS           "-",
63  }
64}
65
66interfaces {
67//       escapable {boolean escaped = false;},
68         intValued {int value = 0;},
69}
70
71nodes {
72  binaryOperator {} [expr expr1],//, expr4],
73  unaryOperator {} [expr2],// expr5],
74  assign {} [assignRest],
75  funcCall {} [funcCallRest],
76  // streamCall {} [streamCallRest],
77  integerConstant{intValued;} [],
78}
79
80grammar {
81        program         -> (typeDecl | funcDef) *; // | typeDef // not implemented
82
83        //
84        // t o p - l e v e l   d e c l a r a t i o n s 
85        //
86       
87        // typeDecl             
88
89        typeDecl                ->  type TERMINATOR ;
90               
91        // typeDef                      ->  TYPEDEF type identifier TERMINATOR ; // not implemented
92       
93        // DeclList             ->  identifier (COMMA identifier)* ; 
94       
95   
96    //
97        // f u n c t i o n   d e c l a r a t i o n s                                                   
98        //
99        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                             
100                                                                               
101        returnType              #-> type ;     
102       
103        parameterList   -> parameter (COMMA parameter)*;
104                                                                                                               
105        funcName                #-> identifier ;
106                                                                                                                       
107        parameter               -> type parameterName ;
108                                       
109        parameterName   #-> identifier ;
110       
111        //
112        // f u n c t i o n - l e v e l 
113        //
114       
115        //
116        // s t a t e m e n t s
117        //
118        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
119                       
120        funcCallOrAssignStmt    #-> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
121       
122        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
123
124        funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
125               
126        // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
127
128        // streamCallArgList            -> (expr (COMMA expr)*)? ;             
129               
130        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
131                                       
132        assignRest                              -> assignOperator^! expr ;                             
133                                       
134        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
135                                                       
136        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
137                       
138        returnStmt                              -> RETURN (expr)? TERMINATOR;
139                       
140        localVarDecl                    -> VAR type varName (localVarAssignOperator^! expr) ?;
141       
142        localVarAssignOperator  -> ASSIGN ;
143               
144        varName                                 #-> identifier; // compoundIdentifier ?
145
146        blockStmt                               -> LCURLY stmt* RCURLY ;
147       
148        //
149        // e x p r e s s i o n s
150        //     
151        expr            #->     expr1 ((OR^|XOR^) expr)? ;
152                                       
153        expr1           #-> expr2 ((AND^) expr1)? ;
154                                       
155        expr2           #-> NOT^^? expr3  _leftAssoc_;
156       
157        expr3           #-> LROUND expr RROUND
158                                        | stringConstant
159                                        | integerConstant
160                                        | compoundIdentifier (funcCallRest _promote_)?
161                                        ;
162
163                                        //(
164                                        //(funcCallRest _promote_)?
165                                        //| (expr4 _promote_)?
166                                        //| (expr5 _promote_)?
167                                        //)?
168                                        // ;
169                                        //expr4          -> DOT expr3 ;
170                                        //expr5          -> (LSQUARE INTEGER_CONST^ RSQUARE) (expr5Rest)?   ;   
171                                        //expr5Rest      -> DOT expr3 ;                                                                                         
172                                                                                                                                                                                                                                                                       
173        constant                #-> stringConstant | integerConstant ;
174                                                           
175        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
176       
177        stringConstant                  -> STRING | SQ_STRING ;
178       
179        compoundIdentifier              #-> identifier (DOT^ identifier)*;
180                                                       
181        identifier                              -> IDENTIFIER ;
182       
183    //   
184        // t y p e s
185        //
186
187        // p r i m i t i v e s   t y p e s
188       
189        // s t r e a m
190
191        type                    #->  streamType | structType | void | identifier ; // | tupleType;
192       
193        streamType              ->      STREAM LANGLE fieldWidth RANGLE ;       
194                                       
195        fieldWidth              ->  integerConstant ;   
196                                       
197       
198        // c o m p o u n d   t y p e s
199               
200        // s t r u c t 
201               
202        structType                              ->      STRUCT structName (structTypeBody)? ;           
203                                       
204        structName                              #->  identifier ;                               
205                                       
206        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
207                                       
208        structMember                    ->      type structMemberName ; // (structMemberAssignOperator^! expr) ?; // TODO
209       
210        structMemberName                #-> identifier ;
211       
212        void                                    -> VOID ;
213       
214        // t u p l e
215        //      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
216        //      tupleTypeSpecifier              ->      TUPLE tupleName ;       
217        //      tupleTypeBody                   ->  type (COMMA type)* ;                                 
218        //      tupleName                               #->  identifier ;
219
220}
Note: See TracBrowser for help on using the repository browser.