source: proto/pablo/input/grammar/scatter/pablo.scatter @ 2368

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

Updated Pablo test cases.

File size: 4.7 KB
Line 
1//
2// Ken Herdy
3// Sept. 8 2012
4//
5context main {
6  recognizers {
7         Whitespace [IGNORE],
8         Integer [INTEGER_CONST],
9         Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant Tokens for keywords.
10         Comment [IGNORE] "#" "\n",                     // parabix2_pablo debugging only.
11         Comment [IGNORE] "//" "\n",     
12         Comment [SQ_STRING] "'" "'",
13         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
14         String [STRING],
15         Punctuator,
16         EndOfInput,
17  }
18
19  // t o k e n s
20  tokens {
21 
22        TYPEDEF,
23        VAR,
24        FUNCTION,       
25        STREAM,
26        STRUCT,
27        TUPLE,
28        VOID,
29       
30        IF,
31        ELSE,
32        WHILE,
33        RETURN,
34
35        AND   "&",
36        OR    "|",
37        NOT   "~",
38        XOR   "^",
39        ASSIGN      "=",
40        AND_ASSIGN  "&=",
41        OR_ASSIGN   "|=",
42        NOT_ASSIGN  "~=",
43        XOR_ASSIGN  "^=",
44        LANGLE          "<",
45        RANGLE          ">",
46        LCURLY          "{",
47        RCURLY          "}",
48        LSQUARE         "[",
49        RSQUARE         "]",
50        LROUND          "(",
51        RROUND          ")",
52        COMMA           ",",
53        TERMINATOR  ";",
54        DOT                     ".",
55  }
56}
57
58interfaces {
59//       escapable {boolean escaped = false;},
60}
61
62nodes {
63  binaryOperator {} [expression, expression1, expression4],
64  unaryOperator {} [expression2, expression5],
65  postfixOperator {} [expression5Rest],
66  functionCall {} [functionCallRest],
67  //assignmentStatement {} [functionCallOrAssignmentStatement],
68}
69
70grammar {
71        program         -> (declarations | functionDef ) *;
72
73        //
74        // t o p - l e v e l 
75        //
76       
77        //
78        // d e c l a r a t i o n s
79        //
80        declarations                    #-> (typeDecl | typeDef) TERMINATOR ;
81
82        typeDecl                                ->  type ;
83               
84        typeDef                                 ->  TYPEDEF type declaratorList ? ;
85       
86        declaratorList                  ->  identifier (COMMA identifier)? ;
87       
88   
89    //
90        // f u n c t i o n   d e f i n i t i o n s                                                             
91        //
92        functionDef             -> FUNCTION type functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR?;                         
93                                                                               
94        returnType              #-> type ;
95                                                                                                               
96        functionName    #-> identifier ;
97                                                                                                                       
98        parameter               -> type parameterName ;
99                                       
100        parameterName   #-> identifier ;
101       
102        blockStatement  -> LCURLY statement* RCURLY ;
103               
104        //
105        // f u n c t i o n - l e v e l 
106        //
107       
108        //
109        // s t a t e m e n t s
110        //
111        statement                                                       -> (functionCallOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) TERMINATOR ? ;
112                       
113        functionCallOrAssignmentStatement       #-> expression3 (assignmentStatement _promote_ )? ;
114                       
115        assignmentStatement                                     -> assignmentOperator expression ;
116               
117        assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;                         
118                                       
119        ifStatement                                                     -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
120                                                       
121        ifCondition                                                     -> expression ;                                         
122                                                       
123        ifBlock                                                         -> blockStatement ;
124       
125        elseBlock                                                       -> blockStatement ;                                             
126                                                       
127        whileStatement                                          -> WHILE LROUND whileCondition RROUND whileBlock ;
128       
129        whileCondition                                          -> expression ;
130       
131        whileBlock                                                      -> blockStatement ;
132       
133        returnStatement                                         -> RETURN (expression)? ;
134       
135        localVarDecl                                            -> VAR type localVarDeclList ;
136       
137        localVarDeclList                                        -> localVarDecl (COMMA localVarDecl)* ;
138               
139        localVarDecl                                            -> identifier (assignmentStatement _promote_) ? ;
140       
141       
142        //
143        // e x p r e s s i o n s
144        //
145        expression              #->     expression1 ((OR^|XOR^) expression)? ;
146                                       
147        expression1             #-> expression2 ((AND^) expression1)?   ;
148                                       
149        expression2             #-> NOT^^? expression3 _leftAssoc_ ;
150       
151        expression3             #-> LROUND expression RROUND
152                                        | constant
153                                        | identifier (
154                                                (functionCallRest _promote_)?
155                                                | (expression4 _promote_)?
156                                                | (expression5 _promote_)?
157                                        )?
158                                        ;
159
160        expression4             -> DOT expression3 ;
161                                               
162        expression5     -> (LSQUARE INTEGER_CONST^^ RSQUARE) (expression5Rest)?   ;     
163               
164        expression5Rest -> DOT expression ;                                                                                             
165                                                                                                                                                                               
166        functionCallRest                -> LROUND^^ (argumentExpressionList)? RROUND;
167       
168        argumentExpressionList  -> expression (COMMA expression)* ;                                                     
169                                                       
170        constant                                -> STRING | SQ_STRING | INTEGER_CONST ; // '-1' | '0'
171                                                       
172        identifier                              -> IDENTIFIER ;
173       
174    //   
175        // t y p e s
176        //
177
178        // p r i m i t i v e
179        //
180        // s t r e a m
181
182        type                    ->  streamType | structType | tupleType | VOID | identifier;
183       
184        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
185                                       
186        fieldWidth              ->  INTEGER_CONST ;     
187       
188        streamTypeName  #->     identifier ;                           
189               
190        // s t r u c t 
191               
192        structType                              ->      structTypeSpecifier (LCURLY structTypeBody RCURLY)? ;           
193                                       
194        structTypeSpecifier             -> STRUCT structName ;                         
195                                       
196        structName                              #->  identifier ;                               
197                                       
198        structTypeBody                  ->      structMember TERMINATOR (structMember TERMINATOR)* ;
199                                       
200        structMember                    ->      type structMemberName ;
201       
202        structMemberName                #-> identifier ;
203       
204        // t u p l e
205       
206        tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
207       
208        tupleTypeSpecifier              ->      TUPLE tupleName ;       
209               
210        tupleTypeBody                   ->  type (COMMA type)* ;                                 
211
212        tupleName                               #->  identifier ;
213
214}
Note: See TracBrowser for help on using the repository browser.