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

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

Continued updates PabloS, PabloB grammars. Attempts to get it right.

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