source: proto/pablo/input/grammar/scatter/pablo.typedef.localDecls.scatter @ 2368

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

Updated Pablo test cases.

File size: 5.3 KB
Line 
1//
2// Ken Herdy
3// Sept. 8 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        FUNCTION,       
24        STREAM,
25        STRUCT,
26        TUPLE,
27        VOID,   
28
29        IF,
30        ELSE,
31        WHILE,
32        RETURN,
33
34        AND   "&",
35        OR    "|",
36        NOT   "~",
37        XOR   "^",
38        ASSIGN      "=",
39        AND_ASSIGN  "&=",
40        OR_ASSIGN   "|=",
41        NOT_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  }
55}
56
57interfaces {
58//       escapable {boolean escaped = false;},
59}
60
61nodes {
62  binaryOperator {} [expression, expression1, expression3],
63  unaryOperator {} [expression2],
64  assignment {} [assignmentStatementTail],
65//  ifStatement {} [ifStatementBulk],
66  functionCall {} [functionCallTail],
67  tupleIdentifier {} [tupleTail],
68  localDeclaration {} [localDeclarationTail], // variable definitions
69//  ASTNode [variableFunctionCall], //[assignmentOrFunctionInvocation, variableOrFunctionInvocation],
70  compoundVariable {} [compoundVariableTail],
71}
72
73grammar {
74        program         -> (typeDecl)* (typeDef)* (functionDef)*;
75
76    //
77        // t y p e   d e c l a r a t i o n s             
78        //
79        typeDecl        ->  (structTypeDecl | tupleTypeDecl) TERMINATOR ? ;
80       
81        //
82        // t y p e   d e f i n i t i o n s                     
83        //
84        typeDef         ->  TYPEDEF (typeSpecifier) typeDefName TERMINATOR ? ;
85    typeDefName #->  identifier ;
86   
87    //
88        // f u n c t i o n   d e f i n i t i o n s                                                             
89        //
90        functionDef             -> FUNCTION functionReturnType functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR ?;                         
91                                                                               
92        functionReturnType      -> typeSpecifier | VOID ;
93                                                                                                               
94        functionName    #-> identifier ;
95                                                                                                                       
96        parameter               -> typeSpecifier parameterName ;
97                                       
98        parameterName   #-> identifier ;
99       
100        blockStatement  -> LCURLY statement* RCURLY ;
101               
102        //
103        // s t a t e m e n t s
104        //
105        statement                               #-> (localDeclarationOrassignmentStatementOrFunctionCall | localDeclaration | ifStatement | whileStatement | returnStatement) (TERMINATOR)?     ;
106                       
107        localDeclarationOrassignmentStatementOrFunctionCall ->  identifier (localDeclarationTail _promote_ | assignmentStatementOrFunctionCallTail _promote_ );
108                       
109        // variable definitions
110        localDeclaration                ->      (streamTypeSpecifier | structTypeSpecifier | tupleTypeSpecifier | identifier) localDeclarationTail ;
111       
112        localDeclarationTail    ->      variableName (assignmentOperator expression)? ;
113       
114        variableName                    #-> identifier ;
115                               
116        assignmentStatementOrFunctionCallTail -> (compoundVariableTail)? (assignmentStatementTail _promote_ | functionCallTail _promote_) ;
117       
118        compoundVariableTail    -> (DOT identifier)* _promote_ ;
119       
120        assignmentStatementTail -> assignmentOperator^! expression ;
121       
122        functionCallTail        -> LROUND (argumentList)? RROUND ;
123       
124        argumentList            -> expression (COMMA expression)* ;
125
126        compoundVariable        -> identifierOrTuple (DOT identifierOrTuple)*   ; 
127        // compoundVariable -> identifier (LSQUARE index RSQUARE)? (DOT identifier (LSQUARE index RSQUARE)?)* ; // TODO - mixed identifier / tuple list ?
128       
129        identifierOrTuple       #-> identifier (tupleTail _promote_)?;
130       
131        tupleTail                       -> LSQUARE index RSQUARE ;
132                                       
133        index                           -> INTEGER_CONST ;     
134       
135        assignmentOperator      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;
136                                       
137        ifStatement             -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
138       
139        ifCondition             -> expression ;
140       
141        ifBlock                 -> blockStatement ;
142       
143        elseBlock               -> blockStatement ;
144                                               
145        whileStatement  -> WHILE LROUND whileCondition RROUND blockStatement ;
146       
147        whileCondition  -> expression ;
148       
149        returnStatement -> RETURN (identifier)? ; // TODO - Return an expression?
150       
151        //
152        // e x p r e s s i o n s
153        //
154        expression              #->     expression1 ((OR^|XOR^) expression)? ;
155                                       
156        expression1             #-> expression2 ((AND^) expression1)?   ;
157                                       
158        expression2             #-> NOT^^? expression3 _leftAssoc_ ;
159                                       
160        expression3             #-> LROUND expression RROUND
161                                        | variableFunctionCall
162                                        | constant ;
163                                       
164        variableFunctionCall    #-> compoundVariable (functionCallTail _promote_)? ;
165                                                       
166        constant                                -> STRING | SQ_STRING | INTEGER_CONST ; // '-1' | '0'
167                                                       
168        identifier                              -> IDENTIFIER ;
169       
170    //   
171        // t y p e s
172        //
173
174        // s t r e a m
175
176        typeSpecifier                   ->  streamTypeSpecifier | structTypeSpecifier | tupleTypeSpecifier | identifier ;
177       
178        streamTypeSpecifier             ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
179                                       
180        fieldWidth                              ->  INTEGER_CONST ;     
181       
182        streamTypeName                  #->     identifier ;                           
183               
184        // s t r u c t 
185               
186        structTypeDecl                  ->      structTypeSpecifier LCURLY structTypeBody RCURLY ;
187       
188        structTypeSpecifier             ->      STRUCT structName ;
189                                       
190        structName                              #->  identifier ;                               
191                                       
192        structTypeBody                  ->      structMember TERMINATOR (structMember TERMINATOR)* ;
193                                       
194        structMember                    ->      (typeSpecifier | typeDecl) structMemberName ;
195       
196        structMemberName                #-> identifier ;
197       
198        // t u p l e
199       
200        tupleTypeDecl                   ->      tupleTypeSpecifier tupleTypeBody ;
201       
202        tupleTypeSpecifier              ->      TUPLE tupleName ;       
203               
204        tupleTypeBody                   ->  (LROUND (typeSpecifier | typeDecl) (COMMA  (typeSpecifier | typeDecl))* RROUND) ;                           
205
206        tupleName                               #->  identifier ;
207
208}
Note: See TracBrowser for help on using the repository browser.