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

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

Updated Pablo grammar and example program fragments.

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