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

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

Migrated to latest pabloS Scatter grammar. Passes all tests.

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