← Back to branch summary

~ubuntu-branches/debian/sid/kdevelop/sid

« back to all changes in this revision

Viewing changes to languages/java/java.store.g

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Lainé
  • Date: 2006-05-23 18:39:42 UTC
  • Revision ID: james.westby@ubuntu.com-20060523183942-hucifbvh68k2bwz7
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
languages/java/java.store.g
 
1
// KDevelop support by Roberto Raggi (roberto@kdevelop.org)
 
2
 
 
3
header "pre_include_hpp" {
 
4
        #include <codemodel.h>
 
5
        #include "JavaAST.hpp"
 
6
 
 
7
        #include <qstring.h>
 
8
        #include <qstringlist.h>
 
9
        #include <qvaluestack.h>
 
10
        #include <qfileinfo.h>
 
11
}
 
12
 
 
13
header "post_include_hpp" {
 
14
        #include <codemodel.h>
 
15
 
 
16
        #include <kdebug.h>
 
17
}
 
18
 
 
19
options {
 
20
        language="Cpp";
 
21
}
 
22
 
 
23
/** Java 1.2 AST Recognizer Grammar
 
24
 *
 
25
 * Author:
 
26
 *      Terence Parr    parrt@magelang.com
 
27
 *
 
28
 * Version tracking now done with following ID:
 
29
 *
 
30
 * $Id: java.store.g 255951 2003-10-03 17:00:32Z aclu $
 
31
 *
 
32
 * This grammar is in the PUBLIC DOMAIN
 
33
 *
 
34
 * BUGS
 
35
 */
 
36
class JavaStoreWalker extends TreeParser;
 
37
 
 
38
options {
 
39
        importVocab=Java;
 
40
        defaultErrorHandler = true;
 
41
        ASTLabelType = "RefJavaAST";
 
42
}
 
43
{
 
44
private:
 
45
        QStringList m_currentScope;
 
46
        CodeModel* m_model;
 
47
        FileDom m_file;
 
48
        QValueStack<ClassDom> m_currentClass;
 
49
        int m_currentAccess;
 
50
        int m_anon;
 
51
        ANTLR_USE_NAMESPACE(antlr)JavaASTFactory ast_factory;
 
52
 
 
53
public:
 
54
        void setCodeModel( CodeModel* model )
 
55
        {
 
56
                m_model = model;
 
57
        }
 
58
 
 
59
        void setFile( FileDom file )
 
60
        {
 
61
                m_file = file;
 
62
        }
 
63
 
 
64
        void init()
 
65
        {
 
66
                m_currentScope.clear();
 
67
                m_currentAccess = CodeModelItem::Public;
 
68
                m_anon = 0;
 
69
 
 
70
                initializeASTFactory (ast_factory);
 
71
                setASTFactory (&ast_factory);
 
72
        }
 
73
}
 
74
 
 
75
compilationUnit { QString package; QString imp; QStringList imports; }
 
76
        : { init(); }
 
77
                (package=packageDefinition)?
 
78
                (imp=importDefinition { imports << imp; } )*
 
79
                (typeDefinition)*
 
80
        ;
 
81
 
 
82
packageDefinition returns [ QString id ]
 
83
        :       #( PACKAGE_DEF id=identifier )
 
84
        ;
 
85
 
 
86
importDefinition returns [ QString id ]
 
87
        :       #( IMPORT id=identifierStar )
 
88
        ;
 
89
 
 
90
typeDefinition { QStringList bases; QString className; ClassDom klass; QStringList m;}
 
91
        :       #(CLASS_DEF m=modifiers IDENT
 
92
                                                {
 
93
                                                klass = m_model->create<ClassModel>();
 
94
                                                QString name = QString::fromUtf8( #IDENT->getText().c_str(), #IDENT->getText().length() );
 
95
                                                QStringList path = QStringList::split( ".", name );
 
96
                                                className = path.back();
 
97
 
 
98
                                                klass->setName( path.back() );
 
99
                                                klass->setScope( m_currentScope );
 
100
                                                klass->setStartPosition( #IDENT->getLine(), #IDENT->getColumn() );
 
101
                                                /// @todo klass->setEndPositon()
 
102
 
 
103
                                                klass->setFileName( m_file->name() );
 
104
                                                if( m_currentClass.top() )
 
105
                                                    m_currentClass.top()->addClass( klass );
 
106
                                                else
 
107
                                                    m_file->addClass( klass );
 
108
                                                }
 
109
                bases=extendsClause
 
110
                                                {
 
111
                                                for( QStringList::Iterator it = bases.begin(); it != bases.end(); ++it )
 
112
                                                        klass->addBaseClass( *it );
 
113
                                                }
 
114
                implementsClause
 
115
                                                {
 
116
                                                m_currentClass.push( klass );
 
117
                                                m_currentScope.push_back( className );
 
118
                                                }
 
119
                objBlock[klass]
 
120
                                                {
 
121
                                                m_currentClass.pop();
 
122
                                                m_currentScope.pop_back();
 
123
                                                }
 
124
                )
 
125
        |       #(INTERFACE_DEF m=modifiers IDENT
 
126
                                                {
 
127
                                                klass = m_model->create<ClassModel>();
 
128
                                                QString name = QString::fromUtf8( #IDENT->getText().c_str(), #IDENT->getText().length() );
 
129
                                                QStringList path = QStringList::split( ".", name );
 
130
                                                className = path.back();
 
131
 
 
132
                                                klass->setName( path.back() );
 
133
                                                klass->setScope( m_currentScope );
 
134
                                                klass->setStartPosition( #IDENT->getLine(), #IDENT->getColumn() );
 
135
                                                /// @todo klass->setEndPositon()
 
136
 
 
137
                                                klass->setFileName( m_file->name() );
 
138
 
 
139
                                                if( m_currentClass.top() )
 
140
                                                    m_currentClass.top()->addClass( klass );
 
141
                                                else
 
142
                                                    m_file->addClass( klass );
 
143
                                                }
 
144
                bases=extendsClause
 
145
                                                {
 
146
                                                m_currentClass.push( klass );
 
147
                                                m_currentScope.push_back( className );
 
148
                                                }
 
149
                interfaceBlock[klass]
 
150
                                                {
 
151
                                                m_currentClass.pop();
 
152
                                                m_currentScope.pop_back();
 
153
                                                }
 
154
                )
 
155
        ;
 
156
 
 
157
typeSpec returns [ QString tp ]
 
158
        :       #(TYPE tp=typeSpecArray)
 
159
        ;
 
160
 
 
161
typeSpecArray returns [ QString tp ]
 
162
        :       #( ARRAY_DECLARATOR tp=typeSpecArray ) { tp += "[]"; }
 
163
        |       tp=type
 
164
        ;
 
165
 
 
166
type returns [ QString tp ]
 
167
        :       tp=identifier
 
168
        |       b:builtInType                   { tp = #b->getText().c_str(); }
 
169
        ;
 
170
 
 
171
builtInType
 
172
    :   "void"
 
173
    |   "boolean"
 
174
    |   "byte"
 
175
    |   "char"
 
176
    |   "short"
 
177
    |   "int"
 
178
    |   "float"
 
179
    |   "long"
 
180
    |   "double"
 
181
    ;
 
182
 
 
183
modifiers returns [ QStringList l ]
 
184
        :       #( MODIFIERS (m:modifier { l << #m->getText().c_str(); } )* )
 
185
        ;
 
186
 
 
187
modifier
 
188
    :   "private"
 
189
    |   "public"
 
190
    |   "protected"
 
191
    |   "static"
 
192
    |   "transient"
 
193
    |   "final"
 
194
    |   "abstract"
 
195
    |   "native"
 
196
    |   "threadsafe"
 
197
    |   "synchronized"
 
198
    |   "const"
 
199
    |   "volatile"
 
200
    ;
 
201
 
 
202
extendsClause returns [ QStringList l ] { QString id; }
 
203
        :       #(EXTENDS_CLAUSE (id=identifier { l << id; } )* )
 
204
        ;
 
205
 
 
206
implementsClause returns [ QStringList l ] { QString id; }
 
207
        :       #(IMPLEMENTS_CLAUSE (id=identifier { l << id; } )* )
 
208
        ;
 
209
 
 
210
interfaceBlock [ ClassDom klass ] { FunctionDom meth; VariableDom attr; }
 
211
        :       #(      OBJBLOCK
 
212
                        (       meth=methodDecl                 {
 
213
                                                                }
 
214
 
 
215
                        |       attr=variableDef                {
 
216
                                                                }
 
217
                        )*
 
218
                )
 
219
        ;
 
220
 
 
221
objBlock [ ClassDom klass ] { FunctionDom meth; VariableDom attr; }
 
222
        :       #(      OBJBLOCK
 
223
                        (       meth=ctorDef                    {
 
224
                                                                klass->addFunction( meth );
 
225
                                                                }
 
226
                        |       meth=methodDef                  {
 
227
                                                                klass->addFunction( meth );
 
228
                                                                }
 
229
                        |       attr=variableDef                {
 
230
                                                                klass->addVariable( attr );
 
231
                                                                }
 
232
                        |       typeDefinition
 
233
                        |       #(STATIC_INIT slist)
 
234
                        |       #(INSTANCE_INIT slist)
 
235
                        )*
 
236
                )
 
237
        ;
 
238
 
 
239
ctorDef returns [ FunctionDom meth ]                            {
 
240
                                                                QStringList m;
 
241
                                                                meth = m_model->create<FunctionModel>();
 
242
                                                                meth->setFileName( m_file->name() );
 
243
                                                                }
 
244
        :       #(CTOR_DEF
 
245
                m=modifiers methodHead[meth] slist
 
246
                )
 
247
                                                                {
 
248
                                                                if( m.contains("public") )
 
249
                                                                    meth->setAccess( CodeModelItem::Public );
 
250
                                                                else if( m.contains("protected") )
 
251
                                                                    meth->setAccess( CodeModelItem::Protected );
 
252
                                                                else
 
253
                                                                    meth->setAccess( CodeModelItem::Private );
 
254
                                                                }
 
255
        ;
 
256
 
 
257
methodDecl returns [ FunctionDom meth ]                         {
 
258
                                                                QStringList m;
 
259
                                                                QString tp;
 
260
                                                                meth = m_model->create<FunctionModel>();
 
261
                                                                meth->setFileName( m_file->name() );
 
262
                                                                }
 
263
        :       #(METHOD_DEF m=modifiers tp=typeSpec methodHead[meth])
 
264
                                                                {
 
265
                                                                meth->setResultType( tp );
 
266
                                                                if( m.contains("public") )
 
267
                                                                    meth->setAccess( CodeModelItem::Public );
 
268
                                                                else if( m.contains("protected") )
 
269
                                                                    meth->setAccess( CodeModelItem::Protected );
 
270
                                                                else
 
271
                                                                    meth->setAccess( CodeModelItem::Private );
 
272
                                                                }
 
273
        ;
 
274
 
 
275
methodDef returns [ FunctionDom meth ]                          {
 
276
                                                                QStringList m;
 
277
                                                                QString tp;
 
278
                                                                meth = m_model->create<FunctionModel>();
 
279
                                                                meth->setFileName( m_file->name() );
 
280
                                                                }
 
281
        :       #(METHOD_DEF m=modifiers tp=typeSpec methodHead[meth] (slist)?)
 
282
                                                                {
 
283
                                                                meth->setResultType( tp );
 
284
                                                                if( m.contains("public") )
 
285
                                                                    meth->setAccess( CodeModelItem::Public );
 
286
                                                                else if( m.contains("protected") )
 
287
                                                                    meth->setAccess( CodeModelItem::Protected );
 
288
                                                                else
 
289
                                                                    meth->setAccess( CodeModelItem::Private );
 
290
                                                                }
 
291
        ;
 
292
 
 
293
variableDef returns [ VariableDom attr ]                        {
 
294
                                                                QStringList m;
 
295
                                                                QString tp;
 
296
                                                                attr = m_model->create<VariableModel>();
 
297
                                                                attr->setFileName( m_file->name() );
 
298
                                                                }
 
299
        :       #(VARIABLE_DEF m=modifiers tp=typeSpec variableDeclarator[attr] varInitializer)
 
300
                                                                {
 
301
                                                                attr->setType( tp );
 
302
                                                                if( m.contains("public") )
 
303
                                                                    attr->setAccess( CodeModelItem::Public );
 
304
                                                                else if( m.contains("protected") )
 
305
                                                                    attr->setAccess( CodeModelItem::Protected );
 
306
                                                                else
 
307
                                                                    attr->setAccess( CodeModelItem::Private );
 
308
 
 
309
                                                                attr->setStatic( m.contains("static") );
 
310
                                                                }
 
311
        ;
 
312
 
 
313
parameterDef returns [ ArgumentDom arg ]                        {
 
314
                                                                QString tp;
 
315
                                                                arg = m_model->create<ArgumentModel>();
 
316
                                                                }
 
317
        :       #(PARAMETER_DEF modifiers tp=typeSpec IDENT )
 
318
                                                                {
 
319
                                                                arg->setType( tp );
 
320
                                                                arg->setName( #IDENT->getText().c_str() );
 
321
                                                                }
 
322
        ;
 
323
 
 
324
objectinitializer
 
325
        :       #(INSTANCE_INIT slist)
 
326
        ;
 
327
 
 
328
variableDeclarator [ VariableDom attr ]
 
329
        :       IDENT                                           {
 
330
                                                                attr->setName( #IDENT->getText().c_str() );
 
331
                                                                attr->setStartPosition( #IDENT->getLine(), #IDENT->getColumn() );
 
332
                                                                }
 
333
        |       LBRACK variableDeclarator[attr]
 
334
        ;
 
335
 
 
336
varInitializer
 
337
        :       #(ASSIGN initializer)
 
338
        |
 
339
        ;
 
340
 
 
341
initializer
 
342
        :       expression
 
343
        |       arrayInitializer
 
344
        ;
 
345
 
 
346
arrayInitializer
 
347
        :       #(ARRAY_INIT (initializer)*)
 
348
        ;
 
349
 
 
350
methodHead [ FunctionDom meth ] { ArgumentDom arg; }
 
351
        :       IDENT #( PARAMETERS (arg=parameterDef { meth->addArgument(arg); } )* ) (throwsClause)?
 
352
        {
 
353
        meth->setName( #IDENT->getText().c_str() );
 
354
        meth->setScope( m_currentScope );
 
355
        meth->setStartPosition( #IDENT->getLine(), #IDENT->getColumn() );
 
356
        }
 
357
        ;
 
358
 
 
359
throwsClause
 
360
        :       #( "throws" (identifier)* )
 
361
        ;
 
362
 
 
363
identifier returns [ QString id ]
 
364
        :       IDENT                                           {
 
365
                                                                id = #IDENT->getText().c_str();
 
366
                                                                }
 
367
        |       #( DOT id=identifier IDENT )                    {
 
368
                                                                id += QString(".") + #IDENT->getText().c_str();
 
369
                                                                }
 
370
        ;
 
371
 
 
372
identifierStar returns [ QString id ]
 
373
        :       IDENT                                           {
 
374
                                                                id = #IDENT->getText().c_str();
 
375
                                                                }
 
376
        |       #( DOT id=identifier (STAR  { id += QString(".") + #STAR->getText().c_str(); } |
 
377
                                      IDENT { id += QString(".") + #IDENT->getText().c_str(); }) )
 
378
        ;
 
379
 
 
380
slist
 
381
        :       #( SLIST (stat)* )
 
382
        ;
 
383
 
 
384
stat:   typeDefinition
 
385
        |       variableDef
 
386
        |       expression
 
387
        |       #(LABELED_STAT IDENT stat)
 
388
        |       #("if" expression stat (stat)? )
 
389
        |       #(      "for"
 
390
                        #(FOR_INIT (variableDef | elist)?)
 
391
                        #(FOR_CONDITION (expression)?)
 
392
                        #(FOR_ITERATOR (elist)?)
 
393
                        stat
 
394
                )
 
395
        |       #("while" expression stat)
 
396
        |       #("do" stat expression)
 
397
        |       #("break" (IDENT)? )
 
398
        |       #("continue" (IDENT)? )
 
399
        |       #("return" (expression)? )
 
400
        |       #("switch" expression (caseGroup)*)
 
401
        |       #("throw" expression)
 
402
        |       #("synchronized" expression stat)
 
403
        |       tryBlock
 
404
        |       slist // nested SLIST
 
405
        |       EMPTY_STAT
 
406
        ;
 
407
 
 
408
caseGroup
 
409
        :       #(CASE_GROUP (#("case" expression) | "default")+ slist)
 
410
        ;
 
411
 
 
412
tryBlock
 
413
        :       #( "try" slist (handler)* (#("finally" slist))? )
 
414
        ;
 
415
 
 
416
handler
 
417
        :       #( "catch" parameterDef slist )
 
418
        ;
 
419
 
 
420
elist
 
421
        :       #( ELIST (expression)* )
 
422
        ;
 
423
 
 
424
expression
 
425
        :       #(EXPR expr)
 
426
        ;
 
427
 
 
428
expr:   #(QUESTION expr expr expr)      // trinary operator
 
429
        |       #(ASSIGN expr expr)                     // binary operators...
 
430
        |       #(PLUS_ASSIGN expr expr)
 
431
        |       #(MINUS_ASSIGN expr expr)
 
432
        |       #(STAR_ASSIGN expr expr)
 
433
        |       #(DIV_ASSIGN expr expr)
 
434
        |       #(MOD_ASSIGN expr expr)
 
435
        |       #(SR_ASSIGN expr expr)
 
436
        |       #(BSR_ASSIGN expr expr)
 
437
        |       #(SL_ASSIGN expr expr)
 
438
        |       #(BAND_ASSIGN expr expr)
 
439
        |       #(BXOR_ASSIGN expr expr)
 
440
        |       #(BOR_ASSIGN expr expr)
 
441
        |       #(LOR expr expr)
 
442
        |       #(LAND expr expr)
 
443
        |       #(BOR expr expr)
 
444
        |       #(BXOR expr expr)
 
445
        |       #(BAND expr expr)
 
446
        |       #(NOT_EQUAL expr expr)
 
447
        |       #(EQUAL expr expr)
 
448
        |       #(LT_ expr expr)
 
449
        |       #(GT expr expr)
 
450
        |       #(LE expr expr)
 
451
        |       #(GE expr expr)
 
452
        |       #(SL expr expr)
 
453
        |       #(SR expr expr)
 
454
        |       #(BSR expr expr)
 
455
        |       #(PLUS expr expr)
 
456
        |       #(MINUS expr expr)
 
457
        |       #(DIV expr expr)
 
458
        |       #(MOD expr expr)
 
459
        |       #(STAR expr expr)
 
460
        |       #(INC expr)
 
461
        |       #(DEC expr)
 
462
        |       #(POST_INC expr)
 
463
        |       #(POST_DEC expr)
 
464
        |       #(BNOT expr)
 
465
        |       #(LNOT expr)
 
466
        |       #("instanceof" expr expr)
 
467
        |       #(UNARY_MINUS expr)
 
468
        |       #(UNARY_PLUS expr)
 
469
        |       primaryExpression
 
470
        ;
 
471
 
 
472
primaryExpression
 
473
    :   IDENT
 
474
    |   #(      DOT
 
475
                        (       expr
 
476
                                (       IDENT
 
477
                                |       arrayIndex
 
478
                                |       "this"
 
479
                                |       "class"
 
480
                                |       #( "new" IDENT elist )
 
481
                                )
 
482
                        |       #(ARRAY_DECLARATOR type)
 
483
                        |       builtInType ("class")?
 
484
                        )
 
485
                )
 
486
        |       arrayIndex
 
487
        |       #(METHOD_CALL primaryExpression elist)
 
488
        |       #(TYPECAST typeSpec expr)
 
489
        |   newExpression
 
490
        |   constant
 
491
    |   "super"
 
492
    |   "true"
 
493
    |   "false"
 
494
    |   "this"
 
495
    |   "null"
 
496
        |       typeSpec // type name used with instanceof
 
497
        ;
 
498
 
 
499
arrayIndex
 
500
        :       #(INDEX_OP primaryExpression expression)
 
501
        ;
 
502
 
 
503
constant
 
504
    :   NUM_INT
 
505
    |   CHAR_LITERAL
 
506
    |   STRING_LITERAL
 
507
    |   NUM_FLOAT
 
508
    ;
 
509
 
 
510
newExpression
 
511
        :       #(      "new" type
 
512
                        (       newArrayDeclarator (arrayInitializer)?
 
513
                        |       elist
 
514
                        )
 
515
                )
 
516
 
 
517
        ;
 
518
 
 
519
newArrayDeclarator
 
520
        :       #( ARRAY_DECLARATOR (newArrayDeclarator)? (expression)? )
 
521
        ;