← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/ant/jaunty-proposed

« back to all changes in this revision

Viewing changes to src/etc/testcases/taskdefs/optional/antlr/java.tree.g

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Gybas
  • Date: 2002-02-14 14:28:48 UTC
  • Revision ID: james.westby@ubuntu.com-20020214142848-2ww7ynmqkj31vlmn
Tags: upstream-1.4.1
Import upstream version 1.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/etc/testcases/taskdefs/optional/antlr/java.tree.g
 
1
/** Java 1.2 AST Recognizer Grammar
 
2
 *
 
3
 * Author:
 
4
 *      Terence Parr    parrt@jguru.com
 
5
 *
 
6
 * Version tracking now done with following ID:
 
7
 *
 
8
 * $Id: java.tree.g,v 1.1 2000/11/06 12:35:13 bodewig Exp $
 
9
 *
 
10
 * This grammar is in the PUBLIC DOMAIN
 
11
 *
 
12
 * BUGS
 
13
 */
 
14
class JavaTreeParser extends TreeParser;
 
15
 
 
16
options {
 
17
        importVocab = Java;
 
18
}
 
19
 
 
20
compilationUnit
 
21
        :       (packageDefinition)?
 
22
                (importDefinition)*
 
23
                (typeDefinition)*
 
24
        ;
 
25
 
 
26
packageDefinition
 
27
        :       #( PACKAGE_DEF identifier )
 
28
        ;
 
29
 
 
30
importDefinition
 
31
        :       #( IMPORT identifierStar )
 
32
        ;
 
33
 
 
34
typeDefinition
 
35
        :       #(CLASS_DEF modifiers IDENT extendsClause implementsClause objBlock )
 
36
        |       #(INTERFACE_DEF modifiers IDENT extendsClause interfaceBlock )
 
37
        ;
 
38
 
 
39
typeSpec
 
40
        :       #(TYPE typeSpecArray)
 
41
        ;
 
42
 
 
43
typeSpecArray
 
44
        :       #( ARRAY_DECLARATOR typeSpecArray )
 
45
        |       type
 
46
        ;
 
47
 
 
48
type:   identifier
 
49
        |       builtInType
 
50
        ;
 
51
 
 
52
builtInType
 
53
    :   "void"
 
54
    |   "boolean"
 
55
    |   "byte"
 
56
    |   "char"
 
57
    |   "short"
 
58
    |   "int"
 
59
    |   "float"
 
60
    |   "long"
 
61
    |   "double"
 
62
    ;
 
63
 
 
64
modifiers
 
65
        :       #( MODIFIERS (modifier)* )
 
66
        ;
 
67
 
 
68
modifier
 
69
    :   "private"
 
70
    |   "public"
 
71
    |   "protected"
 
72
    |   "static"
 
73
    |   "transient"
 
74
    |   "final"
 
75
    |   "abstract"
 
76
    |   "native"
 
77
    |   "threadsafe"
 
78
    |   "synchronized"
 
79
    |   "const"
 
80
    |   "volatile"
 
81
    ;
 
82
 
 
83
extendsClause
 
84
        :       #(EXTENDS_CLAUSE (identifier)* )
 
85
        ;
 
86
 
 
87
implementsClause
 
88
        :       #(IMPLEMENTS_CLAUSE (identifier)* )
 
89
        ;
 
90
 
 
91
 
 
92
interfaceBlock
 
93
        :       #(      OBJBLOCK
 
94
                        (       methodDecl
 
95
                        |       variableDef
 
96
                        )*
 
97
                )
 
98
        ;
 
99
        
 
100
objBlock
 
101
        :       #(      OBJBLOCK
 
102
                        (       ctorDef
 
103
                        |       methodDef
 
104
                        |       variableDef
 
105
                        |       typeDefinition
 
106
                        |       #(STATIC_INIT slist)
 
107
                        |       #(INSTANCE_INIT slist)
 
108
                        )*
 
109
                )
 
110
        ;
 
111
 
 
112
ctorDef
 
113
        :       #(CTOR_DEF modifiers methodHead slist)
 
114
        ;
 
115
 
 
116
methodDecl
 
117
        :       #(METHOD_DEF modifiers typeSpec methodHead)
 
118
        ;
 
119
 
 
120
methodDef
 
121
        :       #(METHOD_DEF modifiers typeSpec methodHead (slist)?)
 
122
        ;
 
123
 
 
124
variableDef
 
125
        :       #(VARIABLE_DEF modifiers typeSpec variableDeclarator varInitializer)
 
126
        ;
 
127
 
 
128
parameterDef
 
129
        :       #(PARAMETER_DEF modifiers typeSpec IDENT )
 
130
        ;
 
131
 
 
132
objectinitializer
 
133
        :       #(INSTANCE_INIT slist)
 
134
        ;
 
135
 
 
136
variableDeclarator
 
137
        :       IDENT
 
138
        |       LBRACK variableDeclarator
 
139
        ;
 
140
 
 
141
varInitializer
 
142
        :       #(ASSIGN initializer)
 
143
        |
 
144
        ;
 
145
 
 
146
initializer
 
147
        :       expression
 
148
        |       arrayInitializer
 
149
        ;
 
150
 
 
151
arrayInitializer
 
152
        :       #(ARRAY_INIT (initializer)*)
 
153
        ;
 
154
 
 
155
methodHead
 
156
        :       IDENT #( PARAMETERS (parameterDef)* ) (throwsClause)?
 
157
        ;
 
158
 
 
159
throwsClause
 
160
        :       #( "throws" (identifier)* )
 
161
        ;
 
162
 
 
163
identifier
 
164
        :       IDENT
 
165
        |       #( DOT identifier IDENT )
 
166
        ;
 
167
 
 
168
identifierStar
 
169
        :       IDENT
 
170
        |       #( DOT identifier (STAR|IDENT) )
 
171
        ;
 
172
 
 
173
slist
 
174
        :       #( SLIST (stat)* )
 
175
        ;
 
176
 
 
177
stat:   typeDefinition
 
178
        |       variableDef
 
179
        |       expression
 
180
        |       #(LABELED_STAT IDENT stat)
 
181
        |       #("if" expression stat (stat)? )
 
182
        |       #(      "for"
 
183
                        #(FOR_INIT (variableDef | elist)?)
 
184
                        #(FOR_CONDITION (expression)?)
 
185
                        #(FOR_ITERATOR (elist)?)
 
186
                        stat
 
187
                )
 
188
        |       #("while" expression stat)
 
189
        |       #("do" stat expression)
 
190
        |       #("break" (IDENT)? )
 
191
        |       #("continue" (IDENT)? )
 
192
        |       #("return" (expression)? )
 
193
        |       #("switch" expression (caseGroup)*)
 
194
        |       #("throw" expression)
 
195
        |       #("synchronized" expression stat)
 
196
        |       tryBlock
 
197
        |       slist // nested SLIST
 
198
        |       EMPTY_STAT
 
199
        ;
 
200
 
 
201
caseGroup
 
202
        :       #(CASE_GROUP (#("case" expression) | "default")+ slist)
 
203
        ;
 
204
 
 
205
tryBlock
 
206
        :       #( "try" slist (handler)* (#("finally" slist))? )
 
207
        ;
 
208
 
 
209
handler
 
210
        :       #( "catch" parameterDef slist )
 
211
        ;
 
212
 
 
213
elist
 
214
        :       #( ELIST (expression)* )
 
215
        ;
 
216
 
 
217
expression
 
218
        :       #(EXPR expr)
 
219
        ;
 
220
 
 
221
expr:   #(QUESTION expr expr expr)      // trinary operator
 
222
        |       #(ASSIGN expr expr)                     // binary operators...
 
223
        |       #(PLUS_ASSIGN expr expr)
 
224
        |       #(MINUS_ASSIGN expr expr)
 
225
        |       #(STAR_ASSIGN expr expr)
 
226
        |       #(DIV_ASSIGN expr expr)
 
227
        |       #(MOD_ASSIGN expr expr)
 
228
        |       #(SR_ASSIGN expr expr)
 
229
        |       #(BSR_ASSIGN expr expr)
 
230
        |       #(SL_ASSIGN expr expr)
 
231
        |       #(BAND_ASSIGN expr expr)
 
232
        |       #(BXOR_ASSIGN expr expr)
 
233
        |       #(BOR_ASSIGN expr expr)
 
234
        |       #(LOR expr expr)
 
235
        |       #(LAND expr expr)
 
236
        |       #(BOR expr expr)
 
237
        |       #(BXOR expr expr)
 
238
        |       #(BAND expr expr)
 
239
        |       #(NOT_EQUAL expr expr)
 
240
        |       #(EQUAL expr expr)
 
241
        |       #(LT expr expr)
 
242
        |       #(GT expr expr)
 
243
        |       #(LE expr expr)
 
244
        |       #(GE expr expr)
 
245
        |       #(SL expr expr)
 
246
        |       #(SR expr expr)
 
247
        |       #(BSR expr expr)
 
248
        |       #(PLUS expr expr)
 
249
        |       #(MINUS expr expr)
 
250
        |       #(DIV expr expr)
 
251
        |       #(MOD expr expr)
 
252
        |       #(STAR expr expr)
 
253
        |       #(INC expr)
 
254
        |       #(DEC expr)
 
255
        |       #(POST_INC expr)
 
256
        |       #(POST_DEC expr)
 
257
        |       #(BNOT expr)
 
258
        |       #(LNOT expr)
 
259
        |       #("instanceof" expr expr)
 
260
        |       #(UNARY_MINUS expr)
 
261
        |       #(UNARY_PLUS expr)
 
262
        |       primaryExpression
 
263
        ;
 
264
 
 
265
primaryExpression
 
266
    :   IDENT
 
267
    |   #(      DOT
 
268
                        (       expr
 
269
                                (       IDENT
 
270
                                |       arrayIndex
 
271
                                |       "this"
 
272
                                |       "class"
 
273
                                |       #( "new" IDENT elist )
 
274
                                )
 
275
                        |       #(ARRAY_DECLARATOR type)
 
276
                        |       builtInType ("class")?
 
277
                        )
 
278
                )
 
279
        |       arrayIndex
 
280
        |       #(METHOD_CALL primaryExpression elist)
 
281
        |       #(TYPECAST typeSpec expr)
 
282
        |   newExpression
 
283
        |   constant
 
284
    |   "super"
 
285
    |   "true"
 
286
    |   "false"
 
287
    |   "this"
 
288
    |   "null"
 
289
        |       typeSpec // type name used with instanceof
 
290
        ;
 
291
 
 
292
arrayIndex
 
293
        :       #(INDEX_OP primaryExpression expression)
 
294
        ;
 
295
 
 
296
constant
 
297
    :   NUM_INT
 
298
    |   CHAR_LITERAL
 
299
    |   STRING_LITERAL
 
300
    |   NUM_FLOAT
 
301
    ;
 
302
 
 
303
newExpression
 
304
        :       #(      "new" type
 
305
                        (       newArrayDeclarator (arrayInitializer)?
 
306
                        |       elist
 
307
                        )
 
308
                )
 
309
                        
 
310
        ;
 
311
 
 
312
newArrayDeclarator
 
313
        :       #( ARRAY_DECLARATOR (newArrayDeclarator)? (expression)? )
 
314
        ;