source: proto/pablo/input/grammar/scatter/pabloS.scatter @ 2749

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

Initial check in to support both PabloS (stream language syntax) and PabloB (block language syntax).

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