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

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

Shortened variable names for sanity.

File size: 4.8 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 {} [expression, expression1],//, expression4],
65  unaryOperator {} [expression2],// expression5],
66  assignment {} [assignmentRest],
67  FuncCall {} [FuncCallRest],
68  integerConstant{intValued;} [],
69}
70
71grammar {
72        program         -> (declarations | 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        declarations                    -> (typeDecl | typeDef) TERMINATOR ;
82
83        typeDecl                                ->  type declaratorList?;
84               
85        typeDef                                 ->  TYPEDEF type identifier ;
86       
87        declaratorList                  ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' Func definitions
88       
89   
90    //
91        // f u n c t i o n   d e f i n i t i o n s                                                             
92        //
93        FuncDef         -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
94                                                                               
95        returnType              #-> type ;      // Note: Strictly not required.
96       
97        parameterList   -> parameter (COMMA parameter)*;
98                                                                                                               
99        FuncName        #-> identifier ;
100                                                                                                                       
101        parameter               -> type parameterName ;
102                                       
103        parameterName   #-> identifier ;
104       
105        //
106        // f u n c t i o n - l e v e l 
107        //
108       
109        //
110        // s t a t e m e n t s
111        //
112        Stmt                                                    #-> (FuncCallOrAssignmentStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
113                       
114        FuncCallOrAssignmentStmt        -> compoundVariable ((FuncCallRest _promote_) | (assignmentRest _promote_)) TERMINATOR ;
115       
116        FuncCallRest                            -> LROUND^ FuncCallArgList RROUND ;
117
118        FuncCallArgList                         -> (expression (COMMA expression)*)? ; 
119               
120        assignmentOperator                              -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
121                                       
122        assignmentRest                                  -> assignmentOperator^! expression ;                           
123                                       
124        ifStmt                                                  -> IF LROUND expression RROUND blockStmt (ELSE blockStmt)? ;                   
125                                                       
126        whileStmt                                               -> WHILE LROUND expression RROUND blockStmt ;
127                       
128        returnStmt                                              -> RETURN (expression)? TERMINATOR;
129                       
130        localVarDecl                                    -> VAR type variableName (assignmentOperator^! expression) ?;
131               
132        variableName                                    #-> identifier;
133
134        blockStmt                                               -> LCURLY Stmt* RCURLY ;
135       
136        //
137        // e x p r e s s i o n s
138        //     
139        expression              #->     expression1 ((OR^|XOR^) expression)? ;
140                                       
141        expression1             #-> expression2 ((AND^) expression1)? ;
142                                       
143        expression2             #-> NOT^^? expression3  _leftAssoc_;
144       
145        expression3             #-> LROUND expression RROUND
146                                        | constant
147                                        | compoundVariable (FuncCallRest _promote_)?
148                                        ;
149
150                                        //(
151                                        //(FuncCallRest _promote_)?
152                                        //| (expression4 _promote_)?
153                                        //| (expression5 _promote_)?
154                                        //)?
155                                        // ;
156                                        //expression4            -> DOT expression3 ;
157                                        //expression5    -> (LSQUARE INTEGER_CONST^ RSQUARE) (expression5Rest)?   ;     
158                                        //expression5Rest        -> DOT expression3 ;                                                                                           
159                                                                                                                                                                                                                                                                       
160        constant                                #-> stringConstant | signedIntegerConstant ;
161       
162        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
163                                            | integerConstant ;
164                                           
165        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
166       
167        stringConstant                  -> STRING | SQ_STRING ;
168       
169        compoundVariable                #-> identifier (DOT^ identifier)*;
170                                                       
171        identifier                              -> IDENTIFIER ;
172       
173    //   
174        // t y p e s
175        //
176
177        // p r i m i t i v e s
178        //
179        // s t r e a m
180
181        type                    #->  streamType | structType | void | identifier ; // | tupleType;
182       
183        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
184                                       
185        fieldWidth              ->  INTEGER_CONST ;     
186       
187        streamTypeName  #->     identifier ;                           
188               
189        // s t r u c t 
190               
191        structType                              ->      STRUCT structName (structTypeBody)? ;           
192                                       
193        structName                              #->  identifier ;                               
194                                       
195        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
196                                       
197        structMember                    ->      type structMemberName ;
198       
199        structMemberName                #-> identifier ;
200       
201        void                                    -> VOID ;
202       
203        // t u p l e
204       
205//      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
206       
207//      tupleTypeSpecifier              ->      TUPLE tupleName ;       
208               
209//      tupleTypeBody                   ->  type (COMMA type)* ;                                 
210
211//      tupleName                               #->  identifier ;
212
213}
Note: See TracBrowser for help on using the repository browser.