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

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

Added methods to generate @global label.

File size: 4.6 KB
Line 
1//
2// Ken Herdy
3// 8-September-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        XOR_ASSIGN  "^=",
43        LANGLE          "<",
44        RANGLE          ">",
45        LCURLY          "{",
46        RCURLY          "}",
47//      LSQUARE         "[",
48//      RSQUARE         "]",
49        LROUND          "(",
50        RROUND          ")",
51        COMMA           ",",
52        TERMINATOR  ";",
53        DOT                     ".",
54        MINUS           "-",
55  }
56}
57
58interfaces {
59//       escapable {boolean escaped = false;},
60         intValued {int value = 0;},
61}
62
63nodes {
64  binaryOperator {} [expr, expr1],//, expr4],
65  unaryOperator {} [expr2],// expr5],
66  Assign {} [AssignRest],
67  FuncCall {} [FuncCallRest],
68  integerConstant{intValued;} [],
69}
70
71grammar {
72        program         -> (typeDecl | typeDef | FuncDef) *;
73
74        //
75        // t o p - l e v e l 
76        //
77       
78        //
79        // d e c l a r a t i o n s
80        //
81        // Decls                        -> (typeDecl | typeDef) TERMINATOR ;
82       
83        // typeDecl             
84
85        typeDecl                ->  type TERMINATOR ; // DeclList?; // Disallow top-level instance decls
86               
87        typeDef                 ->  TYPEDEF type identifier TERMINATOR ;
88       
89        // DeclList             ->  identifier (COMMA identifier)* ; 
90       
91   
92    //
93        // f u n c t i o n   d e f i n i t i o n s      // d e c l a r a t i o n s ?                                                   
94        //
95        FuncDef                 -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
96                                                                               
97        returnType              #-> type ;      // Note: Strictly not required.
98       
99        parameterList   -> parameter (COMMA parameter)*;
100                                                                                                               
101        FuncName                #-> identifier ;
102                                                                                                                       
103        parameter               -> type parameterName ;
104                                       
105        parameterName   #-> identifier ;
106       
107        //
108        // f u n c t i o n - l e v e l 
109        //
110       
111        //
112        // s t a t e m e n t s
113        //
114        Stmt                                    #-> (FuncCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
115                       
116        FuncCallOrAssignStmt    -> compoundIdentifier ((FuncCallRest _promote_) | (AssignRest _promote_)) TERMINATOR ;
117       
118        FuncCallRest                    -> LROUND^ FuncCallArgList RROUND ;
119
120        FuncCallArgList                 -> (expr (COMMA expr)*)? ;     
121               
122        AssignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
123                                       
124        AssignRest                              -> AssignOperator^! expr ;                             
125                                       
126        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
127                                                       
128        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
129                       
130        returnStmt                              -> RETURN (expr)? TERMINATOR;
131                       
132        localVarDecl                    -> VAR type VarName (AssignOperator^! expr) ?;
133               
134        VarName                                 #-> identifier;
135
136        blockStmt                               -> LCURLY Stmt* RCURLY ;
137       
138        //
139        // e x p r e s s i o n s
140        //     
141        expr            #->     expr1 ((OR^|XOR^) expr)? ;
142                                       
143        expr1           #-> expr2 ((AND^) expr1)? ;
144                                       
145        expr2           #-> NOT^^? expr3  _leftAssoc_;
146       
147        expr3           #-> LROUND expr RROUND
148                                        | constant
149                                        | compoundIdentifier (FuncCallRest _promote_)?
150                                        ;
151
152                                        //(
153                                        //(FuncCallRest _promote_)?
154                                        //| (expr4 _promote_)?
155                                        //| (expr5 _promote_)?
156                                        //)?
157                                        // ;
158                                        //expr4          -> DOT expr3 ;
159                                        //expr5          -> (LSQUARE INTEGER_CONST^ RSQUARE) (expr5Rest)?   ;   
160                                        //expr5Rest      -> DOT expr3 ;                                                                                         
161                                                                                                                                                                                                                                                                       
162        constant                                #-> stringConstant | signedIntegerConstant ;
163       
164        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
165                                            | integerConstant ;
166                                           
167        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
168       
169        stringConstant                  -> STRING | SQ_STRING ;
170       
171        compoundIdentifier              #-> identifier (DOT^ identifier)*;
172                                                       
173        identifier                              -> IDENTIFIER ;
174       
175    //   
176        // t y p e s
177        //
178
179        // p r i m i t i v e s
180        //
181        // s t r e a m
182
183        type                    #->  streamType | structType | void | identifier ; // | tupleType;
184       
185        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
186                                       
187        fieldWidth              ->  INTEGER_CONST ;     
188       
189        streamTypeName  #->     identifier ;                           
190               
191        // s t r u c t 
192               
193        structType                              ->      STRUCT structName (structTypeBody)? ;           
194                                       
195        structName                              #->  identifier ;                               
196                                       
197        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
198                                       
199        structMember                    ->      type structMemberName ;
200       
201        structMemberName                #-> identifier ;
202       
203        void                                    -> VOID ;
204       
205        // t u p l e
206       
207//      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
208       
209//      tupleTypeSpecifier              ->      TUPLE tupleName ;       
210               
211//      tupleTypeBody                   ->  type (COMMA type)* ;                                 
212
213//      tupleName                               #->  identifier ;
214
215}
Note: See TracBrowser for help on using the repository browser.