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

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

Shortened variable names for sanity.

File size: 4.9 KB
Line 
1// Meta Symbols
2//
3// #                    - Compress node.
4// _promote_    - Promote children to parent node.
5// ^                    - Up.
6// !                    - Omit node.
7//
8
9context main {
10  recognizers {
11         Whitespace [IGNORE],
12         Integer [INTEGER_CONST],
13         Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant Tokens for keywords.
14         Comment [IGNORE] "#" "\n",                     // parabix2_pablo debugging only.
15         Comment [IGNORE] "//" "\n",     
16         Comment [SQ_STRING] "'" "'",
17         Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
18         String [STRING],
19         Punctuator,
20         EndOfInput,
21  }
22
23  // t o k e n s
24  tokens {
25 
26        TYPEDEF,
27        FUNCTION,       
28        STREAM,
29        STRUCT,
30        TUPLE,
31        VOID,   
32
33        IF,
34        ELSE,
35        WHILE,
36        RETURN,
37
38        AND   "&",
39        OR    "|",
40        NOT   "~",
41        XOR   "^",
42        ASSIGN      "=",
43        AND_ASSIGN  "&=",
44        OR_ASSIGN   "|=",
45        NOT_ASSIGN  "~=",
46        XOR_ASSIGN  "^=",
47        LANGLE          "<",
48        RANGLE          ">",
49        LCURLY          "{",
50        RCURLY          "}",
51        LSQUARE         "[",
52        RSQUARE         "]",
53        LROUND          "(",
54        RROUND          ")",
55        COMMA           ",",
56        TERMINATOR  ";",
57        DOT                     ".",
58  }
59}
60
61interfaces {
62//       escapable {boolean escaped = false;},
63}
64
65nodes {
66  binaryOperator {} [expression, expression1, expression3],
67  unaryOperator {} [expression2],
68  assignment {} [assignmentStmtTail],
69//  ifStmt {} [ifStmtBulk],
70  functionCall {} [functionCallTail],
71  tupleIdentifier {} [tupleTail],
72//  ASTNode [variableFunctionCall], //[assignmentOrFunctionCall, variableOrFunctionCall],
73}
74
75grammar {
76        program         -> (typeDef)* (typeDecl)* (functionDef)* ;
77       
78        //             
79        // t y p e   d e f i n i t i o n s                     
80        //
81        typeDef         ->  TYPEDEF (typeSpecifier | typeDecl) typeDefName TERMINATOR ? ;
82    typeDefName #->  identifier ;
83   
84    //
85        // t y p e   d e c l a r a t i o n s             
86        //
87        // typeDecl     ->  (structTypeDecl | tupleTypeDecl ) TERMINATOR ? ;
88        typeDecl        ->  (structTypeDecl) TERMINATOR ? ;
89       
90    //
91        // f u n c t i o n   d e f i n i t i o n s                                                             
92        //
93        functionDef             -> FUNCTION functionReturnType functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStmt TERMINATOR ?;                               
94                                                                               
95        functionReturnType      -> typeSpecifier | VOID ;
96                                                                                                               
97        functionName    #-> identifier ;
98                                                                                                                       
99        parameter               -> typeSpecifier parameterName ;
100                                       
101        parameterName   #-> identifier ;
102       
103        blockStmt       -> LCURLY Stmt* RCURLY ;
104               
105        //
106        // s t a t e m e n t s
107        //
108        Stmt                    #-> (assignmentStmtOrFunctionCall | ifStmt | whileStmt | returnStmt) (TERMINATOR)?      ;
109                       
110        //variableDefinition           
111        //variableDefinition    -> typeSpecifier variableName (assignmentOperator expression)? ;                                       
112        //variableName          #-> identifier ;
113       
114        assignmentStmtOrFunctionCall -> compoundVariable (assignmentStmtTail _promote_ | functionCallTail _promote_) ;
115       
116        assignmentStmtTail      -> assignmentOperator^! expression ;
117       
118        functionCallTail        -> LROUND (argumentList)? RROUND ;
119       
120        argumentList            -> expression (COMMA expression)* ;
121
122        compoundVariable        -> identifierOrTuple (DOT identifierOrTuple)*   ; 
123        // compoundVariable -> identifier (LSQUARE index RSQUARE)? (DOT identifier (LSQUARE index RSQUARE)?)* ; // TODO - mixed identifier / tuple list ?
124       
125        identifierOrTuple       #-> identifier (tupleTail _promote_)?;
126       
127        tupleTail                       -> LSQUARE index RSQUARE ;
128                                       
129        index                           -> INTEGER_CONST ;     
130       
131        assignmentOperator      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;
132                                       
133        ifStmt          -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
134       
135        ifCondition             -> expression ;
136       
137        ifBlock                 -> blockStmt ;
138       
139        elseBlock               -> blockStmt ; // TODO - dangling else problems?
140                                               
141        whileStmt       -> WHILE LROUND whileCondition RROUND blockStmt ;
142       
143        whileCondition  -> expression ;
144       
145        returnStmt      -> RETURN (identifier)? ; // TODO - return an expression
146       
147        //
148        // e x p r e s s i o n s
149        //
150        expression              #->     expression1 ((OR^|XOR^) expression)? ;
151                                       
152        expression1             #-> expression2 ((AND^) expression1)?   ;
153                                       
154        expression2             #-> NOT^^? expression3 _leftAssoc_ ;
155                                       
156        expression3             #-> LROUND expression RROUND
157                                        | variableFunctionCall
158                                        | constant ;
159                                       
160        variableFunctionCall    #-> compoundVariable (functionCallTail _promote_)? ;
161                                                       
162        constant                                -> STRING | SQ_STRING | INTEGER_CONST ; // '-1' | '0'
163                                                       
164        identifier                              -> IDENTIFIER ;
165       
166    //   
167        // t y p e s
168        //
169
170        // s t r e a m
171
172        typeSpecifier                   ->  streamTypeSpecifier | structTypeSpecifier | tupleTypeSpecifier | identifier ;
173       
174        streamTypeSpecifier             ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
175                                       
176        fieldWidth                              ->  INTEGER_CONST ;     
177       
178        streamTypeName                  #->     identifier ;                           
179               
180        // s t r u c t 
181               
182        structTypeDecl                  ->      structTypeSpecifier LCURLY structTypeBody RCURLY ;
183       
184        structTypeSpecifier             ->      STRUCT structName ;
185                                       
186        structName                              #->  identifier ;                               
187                                       
188        structTypeBody                  ->      structMember TERMINATOR (structMember TERMINATOR)* ;
189                                       
190        structMember                    ->      (typeSpecifier | typeDecl) structMemberName ;
191       
192        structMemberName                #-> identifier ;
193       
194        // t u p l e
195       
196        tupleTypeDecl                   ->      tupleTypeSpecifier tupleTypeBody ;
197       
198        tupleTypeSpecifier              ->      TUPLE tupleName ;       
199               
200        tupleTypeBody                   ->  (LROUND (typeSpecifier | typeDecl) (COMMA  (typeSpecifier | typeDecl))* RROUND) ;                           
201
202        tupleName                               #->  identifier ;
203
204
205}
Note: See TracBrowser for help on using the repository browser.