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

Last change on this file since 2948 was 2948, checked in by ksherdy, 7 years ago

Removed compound assignment from variable declarations.

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//
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 // streamConstant{intValued;} [],
77  integerConstant{intValued;} [],
78}
79
80grammar {
81        program         -> (typeDecl | typeDef | funcDef) *;
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 ;
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 ;
121       
122        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
123
124        funcCallArgList                 -> ( expr (COMMA expr)* )? ;   
125               
126        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
127                                       
128        assignRest                              -> assignOperator^! expr ;                             
129                                       
130        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
131                                                       
132        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
133                       
134        returnStmt                              -> RETURN (expr)? TERMINATOR;
135                       
136        localVarDecl                    -> VAR type VarName (localVarAssignOperator^! expr) ?;
137       
138        localVarAssignOperator  -> ASSIGN ;
139               
140        VarName                                 #-> identifier;
141
142        blockStmt                               -> LCURLY stmt* RCURLY ;
143       
144        //
145        // e x p r e s s i o n s
146        //     
147        expr            #->     expr1 ((OR^|XOR^) expr)? ;
148                                       
149        expr1           #-> expr2 ((AND^) expr1)? ;
150                                       
151        expr2           #-> NOT^^? expr3  _leftAssoc_;
152       
153        expr3           #-> LROUND expr RROUND
154                                        | stringConstant
155                                        | integerConstant
156                                        | compoundIdentifier (funcCallRest _promote_)?
157                                        ;
158
159                                        //(
160                                        //(funcCallRest _promote_)?
161                                        //| (expr4 _promote_)?
162                                        //| (expr5 _promote_)?
163                                        //)?
164                                        // ;
165                                        //expr4          -> DOT expr3 ;
166                                        //expr5          -> (LSQUARE INTEGER_CONST^ RSQUARE) (expr5Rest)?   ;   
167                                        //expr5Rest      -> DOT expr3 ;                                                                                         
168                                                                                                                                                                                                                                                                       
169        constant                                #-> stringConstant | integerConstant ;
170       
171       
172        // signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
173        //                                  | integerConstant ;
174       
175        // streamConstant                       -> INTEGER_CONST {@value = @@value;} ;
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                    #->  streamType | structType | void | identifier ; // | tupleType;
194       
195        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
196                                       
197        fieldWidth              ->  integerConstant ;   
198       
199        streamTypeName  #->     identifier ;                           
200       
201        // c o m p o u n d   t y p e s
202               
203        // s t r u c t 
204               
205        structType                              ->      STRUCT structName (structTypeBody)? ;           
206                                       
207        structName                              #->  identifier ;                               
208                                       
209        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
210                                       
211        structMember                    ->      type structMemberName ;
212       
213        structMemberName                #-> identifier ;
214       
215        void                                    -> VOID ;
216       
217        // t u p l e
218//      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
219//      tupleTypeSpecifier              ->      TUPLE tupleName ;       
220//      tupleTypeBody                   ->  type (COMMA type)* ;                                 
221//      tupleName                               #->  identifier ;
222
223}
Note: See TracBrowser for help on using the repository browser.