source: proto/pablo/input/grammar/scatter/pabloB.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.2 KB
Line 
1//
2// Ken Herdy
3// 2-December-2012
4//
5// PabloBlock (block-at-a-time 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        VAR,
25        KERNEL,
26        FUNCTION,       
27        STREAM,
28        STRUCT,
29        VOID,
30       
31        IF,
32        ELSE,
33        WHILE,
34        RETURN,
35
36        AND   "&",
37        OR    "|",
38        NOT   "~",
39        XOR   "^",
40        ASSIGN      "=",
41        AND_ASSIGN  "&=",
42        OR_ASSIGN   "|=",
43        XOR_ASSIGN  "^=",       
44        LANGLE          "<",
45        RANGLE          ">",
46        LCURLY          "{",
47        RCURLY          "}",
48        LROUND          "(",
49        RROUND          ")",
50        COMMA           ",",
51        TERMINATOR  ";",
52        DOT                     ".",
53        MINUS           "-",
54  }
55}
56
57interfaces {
58//       escapable {boolean escaped = false;},
59         intValued {int value = 0;},
60}
61
62nodes {
63  binaryOperator {} [expr, expr1],//, expr4],
64  unaryOperator {} [expr2],// expr5],
65  assign {} [assignRest],
66  funcCall {} [funcCallRest],
67  integerConstant{intValued;} [],
68}
69
70grammar {
71        program         -> (typeDecl | kernelDef) *;
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        // Decls                -> typeDecl TERMINATOR ;
81               
82        typeDecl                ->  type TERMINATOR ;           
83               
84        // typeDef              ->  TYPEDEF type identifier TERMINATOR ;
85       
86        // DeclList             ->  identifier (COMMA identifier)* ; 
87       
88   
89    //
90        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
91        //
92        kernelDef                       ->      KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
93       
94        kernelName                      #-> identifier ;
95       
96        funcDef                         ->      FUNCTION type funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR?;
97       
98        returnType                      #-> type ;      // Note: Strictly not required.
99       
100        parameterList           ->      parameter (COMMA parameter)*;
101                                                                                                               
102        funcName                        #-> identifier ;
103                                                                                                                       
104        parameter                       ->      type parameterName ;
105                                       
106        parameterName           #-> identifier ;
107       
108        basicBlockStmt          #-> blockStmt ;
109       
110        optFuncDef                      #-> funcDef ;
111       
112        //
113        // f u n c t i o n - l e v e l 
114        //
115       
116        //
117        // s t a t e m e n t s
118        //
119        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
120                       
121        funcCallOrAssignStmt    -> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
122       
123        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
124
125        funcCallArgList                 -> (expr (COMMA expr)*)? ;     
126               
127        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
128                                       
129        assignRest                              -> assignOperator^! expr ;                             
130                                       
131        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
132                                                       
133        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
134                       
135        returnStmt                              -> RETURN (expr)? TERMINATOR;
136                       
137        localVarDecl                    -> VAR type VarName (assignOperator^! expr) ?;
138               
139        VarName                                 #-> identifier;
140
141        blockStmt                               -> LCURLY stmt* RCURLY ;
142       
143        //
144        // e x p r e s s i o n s
145        //     
146        expr            #->     expr1 ((OR^|XOR^) expr)? ;
147                                       
148        expr1           #-> expr2 ((AND^) expr1)? ;
149                                       
150        expr2           #-> NOT^^? expr3  _leftAssoc_;
151       
152        expr3           #-> LROUND expr RROUND
153                                        | constant
154                                        | compoundIdentifier (funcCallRest _promote_)?
155                                        ;
156                                                                                                                                                                                       
157        constant                                #-> stringConstant | signedIntegerConstant ;
158       
159        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
160                                            | integerConstant ;
161                                           
162        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
163       
164        stringConstant                  -> STRING | SQ_STRING ;
165       
166        compoundIdentifier              #-> identifier (DOT^ identifier)*;
167                                                       
168        identifier                              -> IDENTIFIER ;
169       
170    //   
171        // t y p e s
172        //
173
174        // p r i m i t i v e s
175        //
176        // s t r e a m
177
178        type                    #->  streamType | structType | void | identifier ; // | tupleType;
179       
180        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
181                                       
182        fieldWidth              ->  INTEGER_CONST ;     
183       
184        streamTypeName  #->     identifier ;                           
185               
186        // s t r u c t 
187               
188        structType                              ->      STRUCT structName (structTypeBody)? ;           
189                                       
190        structName                              #->  identifier ;                               
191                                       
192        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
193                                       
194        structMember                    ->      type structMemberName ;
195       
196        structMemberName                #-> identifier ;
197       
198        void                                    -> VOID ;
199       
200}
Note: See TracBrowser for help on using the repository browser.