← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to tools/porting/src/treewalker.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/porting/src/treewalker.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
 
4
** Copyright (C) 2001-2004 Roberto Raggi
 
5
**
 
6
** This file is part of the porting application of the Qt Toolkit.
 
7
**
 
8
** This file may be distributed under the terms of the Q Public License
 
9
** as defined by Trolltech AS of Norway and appearing in the file
 
10
** LICENSE.QPL included in the packaging of this file.
 
11
**
 
12
** This file may be distributed and/or modified under the terms of the
 
13
** GNU General Public License version 2 as published by the Free Software
 
14
** Foundation and appearing in the file LICENSE.GPL included in the
 
15
** packaging of this file.
 
16
**
 
17
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
18
**   information about Qt Commercial License Agreements.
 
19
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
20
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
21
**
 
22
** Contact info@trolltech.com if any conditions of this licensing are
 
23
** not clear to you.
 
24
**
 
25
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
26
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
27
**
 
28
****************************************************************************/
 
29
 
 
30
#include "treewalker.h"
 
31
 
 
32
/*
 
33
template <class T>
 
34
inline void parseAll(TreeWalker *w, const List<T *> *l)
 
35
{
 
36
    if (!l)
 
37
        return;
 
38
 
 
39
    foreach(T *e, *l)
 
40
        w->parseNode(e);
 
41
}
 
42
*/
 
43
 
 
44
//Workaround for ICE on MSVC, use macro instead of template.
 
45
#define PARSE_ALL(ListType, ListValueType) \
 
46
inline void parseAll(TreeWalker *w, const ListType *l) \
 
47
{ \
 
48
    if (!l) \
 
49
        return; \
 
50
    foreach(ListValueType *e, *l) \
 
51
        w->parseNode(e); \
 
52
} \
 
53
 
 
54
PARSE_ALL(List<AST *>, AST)
 
55
PARSE_ALL(List<ClassOrNamespaceNameAST *>, ClassOrNamespaceNameAST)
 
56
PARSE_ALL(List<BaseSpecifierAST *>, BaseSpecifierAST)
 
57
PARSE_ALL(List<DeclarationAST *>, DeclarationAST)
 
58
PARSE_ALL(List<EnumeratorAST *>, EnumeratorAST)
 
59
PARSE_ALL(List<ParameterDeclarationAST *>, ParameterDeclarationAST)
 
60
PARSE_ALL(List<InitDeclaratorAST *>, InitDeclaratorAST)
 
61
PARSE_ALL(List<TemplateParameterAST *>, TemplateParameterAST)
 
62
PARSE_ALL(List<StatementAST *>, StatementAST)
 
63
 
 
64
 
 
65
void TreeWalker::parseTemplateArgumentList(TemplateArgumentListAST *node)
 
66
{
 
67
    List<AST *> *arglist = node->argumentList();
 
68
        parseAll(this, arglist);
 
69
}
 
70
 
 
71
void TreeWalker::parseClassOrNamespaceName(ClassOrNamespaceNameAST *node)
 
72
{
 
73
    parseNode(node->name());
 
74
    parseNode(node->templateArgumentList());
 
75
}
 
76
 
 
77
void TreeWalker::parseName(NameAST *node)
 
78
{
 
79
    parseAll(this, node->classOrNamespaceNameList());
 
80
    parseNode(node->unqualifiedName());
 
81
}
 
82
 
 
83
void TreeWalker::parseTypeParameter(TypeParameterAST *node)
 
84
{
 
85
    parseNode(node->templateParameterList());
 
86
    parseNode(node->name());
 
87
    parseNode(node->typeId());
 
88
}
 
89
 
 
90
void TreeWalker::parseDeclaration(DeclarationAST *node)
 
91
{
 
92
    switch (node->nodeType()) {
 
93
    case NodeType_AccessDeclaration:
 
94
        parseAccessDeclaration(static_cast<AccessDeclarationAST*>(node));
 
95
        break;
 
96
    case NodeType_LinkageSpecification:
 
97
        parseLinkageSpecification(static_cast<LinkageSpecificationAST*>(node));
 
98
        break;
 
99
    case NodeType_Namespace:
 
100
        parseNamespace(static_cast<NamespaceAST*>(node));
 
101
        break;
 
102
    case NodeType_NamespaceAlias:
 
103
        parseNamespaceAlias(static_cast<NamespaceAliasAST*>(node));
 
104
        break;
 
105
    case NodeType_Using:
 
106
        parseUsing(static_cast<UsingAST*>(node));
 
107
        break;
 
108
    case NodeType_UsingDirective:
 
109
        parseUsingDirective(static_cast<UsingDirectiveAST*>(node));
 
110
        break;
 
111
    case NodeType_Typedef:
 
112
        parseTypedef(static_cast<TypedefAST*>(node));
 
113
        break;
 
114
    case NodeType_TemplateDeclaration:
 
115
        parseTemplateDeclaration(static_cast<TemplateDeclarationAST*>(node));
 
116
        break;
 
117
    case NodeType_SimpleDeclaration:
 
118
        parseSimpleDeclaration(static_cast<SimpleDeclarationAST*>(node));
 
119
        break;
 
120
    case NodeType_FunctionDefinition:
 
121
        parseFunctionDefinition(static_cast<FunctionDefinitionAST*>(node));
 
122
        break;
 
123
    default:
 
124
        break;
 
125
    }
 
126
}
 
127
 
 
128
void TreeWalker::parseAccessDeclaration(AccessDeclarationAST *node)
 
129
{
 
130
    parseAll(this, node->accessList());
 
131
}
 
132
 
 
133
void TreeWalker::parseTypeSpecifier(TypeSpecifierAST *node)
 
134
{
 
135
    parseNode(node->name());
 
136
    parseNode(node->cvQualify());
 
137
    parseNode(node->cv2Qualify());
 
138
 
 
139
    switch (node->nodeType()) {
 
140
    case NodeType_ClassSpecifier:
 
141
        parseClassSpecifier(static_cast<ClassSpecifierAST*>(node));
 
142
        break;
 
143
    case NodeType_EnumSpecifier:
 
144
        parseEnumSpecifier(static_cast<EnumSpecifierAST*>(node));
 
145
        break;
 
146
    case NodeType_ElaboratedTypeSpecifier:
 
147
        parseElaboratedTypeSpecifier(static_cast<ElaboratedTypeSpecifierAST*>(node));
 
148
        break;
 
149
    default:
 
150
        break;
 
151
    }
 
152
}
 
153
 
 
154
void TreeWalker::parseBaseSpecifier(BaseSpecifierAST *node)
 
155
{
 
156
    parseNode(node->isVirtual());
 
157
    parseNode(node->access());
 
158
    parseNode(node->name());
 
159
}
 
160
 
 
161
void TreeWalker::parseBaseClause(BaseClauseAST *node)
 
162
{
 
163
    parseAll(this, node->baseSpecifierList());
 
164
}
 
165
 
 
166
void TreeWalker::parseClassSpecifier(ClassSpecifierAST *node)
 
167
{
 
168
    parseNode(node->winDeclSpec());
 
169
    parseNode(node->classKey());
 
170
    parseNode(node->baseClause());
 
171
    parseAll(this, node->declarationList());
 
172
}
 
173
 
 
174
void TreeWalker::parseEnumerator(EnumeratorAST *node)
 
175
{
 
176
    parseNode(node->id());
 
177
    parseNode(node->expression());
 
178
}
 
179
 
 
180
void TreeWalker::parseEnumSpecifier(EnumSpecifierAST *node)
 
181
{
 
182
    parseAll(this, node->enumeratorList());
 
183
}
 
184
 
 
185
void TreeWalker::parseElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
 
186
{
 
187
    parseNode(node->kind());
 
188
}
 
189
 
 
190
void TreeWalker::parseLinkageBody(LinkageBodyAST *node)
 
191
{
 
192
    parseAll(this, node->declarationList());
 
193
}
 
194
 
 
195
void TreeWalker::parseLinkageSpecification(LinkageSpecificationAST *node)
 
196
{
 
197
    parseNode(node->externType());
 
198
    parseNode(node->linkageBody());
 
199
    parseNode(node->declaration());
 
200
}
 
201
 
 
202
void TreeWalker::parseNamespace(NamespaceAST *node)
 
203
{
 
204
    parseNode(node->namespaceName());
 
205
    parseNode(node->linkageBody());
 
206
}
 
207
 
 
208
void TreeWalker::parseNamespaceAlias(NamespaceAliasAST *node)
 
209
{
 
210
    parseNode(node->namespaceName());
 
211
    parseNode(node->aliasName());
 
212
}
 
213
 
 
214
void TreeWalker::parseUsing(UsingAST *node)
 
215
{
 
216
    parseNode(node->typeName());
 
217
    parseNode(node->name());
 
218
}
 
219
 
 
220
void TreeWalker::parseUsingDirective(UsingDirectiveAST *node)
 
221
{
 
222
    parseNode(node->name());
 
223
}
 
224
 
 
225
void TreeWalker::parseDeclarator(DeclaratorAST *node)
 
226
{
 
227
    parseAll(this, node->ptrOpList());
 
228
    parseNode(node->subDeclarator());
 
229
    parseNode(node->declaratorId());
 
230
    parseNode(node->bitfieldInitialization());
 
231
    parseAll(this, node->arrayDimensionList());
 
232
    parseNode(node->parameterDeclarationClause());
 
233
    parseNode(node->constant());
 
234
    parseNode(node->exceptionSpecification());
 
235
}
 
236
 
 
237
void TreeWalker::parseParameterDeclaration(ParameterDeclarationAST *node)
 
238
{
 
239
    parseNode(node->typeSpec());
 
240
    parseNode(node->declarator());
 
241
    parseNode(node->expression());
 
242
}
 
243
 
 
244
void TreeWalker::parseParameterDeclarationList(ParameterDeclarationListAST *node)
 
245
{
 
246
    parseAll(this, node->parameterList());
 
247
}
 
248
 
 
249
void TreeWalker::parseParameterDeclarationClause(ParameterDeclarationClauseAST *node)
 
250
{
 
251
    parseNode(node->parameterDeclarationList());
 
252
    parseNode(node->ellipsis());
 
253
}
 
254
 
 
255
void TreeWalker::parseInitDeclarator(InitDeclaratorAST *node)
 
256
{
 
257
    parseNode(node->declarator());
 
258
    parseNode(node->initializer());
 
259
}
 
260
 
 
261
void TreeWalker::parseInitDeclaratorList(InitDeclaratorListAST *node)
 
262
{
 
263
    parseAll(this, node->initDeclaratorList());
 
264
}
 
265
 
 
266
void TreeWalker::parseTypedef(TypedefAST *node)
 
267
{
 
268
    parseNode(node->typeSpec());
 
269
    parseNode(node->initDeclaratorList());
 
270
}
 
271
 
 
272
void TreeWalker::parseTemplateParameter(TemplateParameterAST *node)
 
273
{
 
274
    parseNode(node->typeParameter());
 
275
    parseNode(node->typeValueParameter());
 
276
}
 
277
 
 
278
void TreeWalker::parseTemplateParameterList(TemplateParameterListAST *node)
 
279
{
 
280
    parseAll(this, node->templateParameterList());
 
281
}
 
282
 
 
283
void TreeWalker::parseTemplateDeclaration(TemplateDeclarationAST *node)
 
284
{
 
285
    parseNode(node->exported());
 
286
    parseNode(node->templateParameterList());
 
287
    parseNode(node->declaration());
 
288
}
 
289
 
 
290
void TreeWalker::parseSimpleDeclaration(SimpleDeclarationAST *node)
 
291
{
 
292
    parseNode(node->functionSpecifier());
 
293
    parseNode(node->storageSpecifier());
 
294
    parseNode(node->typeSpec());
 
295
    parseNode(node->initDeclaratorList());
 
296
    parseNode(node->winDeclSpec());
 
297
}
 
298
 
 
299
void TreeWalker::parseStatement(StatementAST *node)
 
300
{
 
301
    switch (node->nodeType()) {
 
302
    case NodeType_ExpressionStatement:
 
303
        parseExpressionStatement(static_cast<ExpressionStatementAST*>(node));
 
304
        break;
 
305
 
 
306
    case NodeType_IfStatement:
 
307
        parseIfStatement(static_cast<IfStatementAST*>(node));
 
308
        break;
 
309
 
 
310
    case NodeType_WhileStatement:
 
311
        parseWhileStatement(static_cast<WhileStatementAST*>(node));
 
312
        return;
 
313
 
 
314
    case NodeType_DoStatement:
 
315
        parseDoStatement(static_cast<DoStatementAST*>(node));
 
316
        break;
 
317
 
 
318
    case NodeType_ForStatement:
 
319
        parseForStatement(static_cast<ForStatementAST*>(node));
 
320
        break;
 
321
 
 
322
    case NodeType_SwitchStatement:
 
323
        parseSwitchStatement(static_cast<SwitchStatementAST*>(node));
 
324
        break;
 
325
 
 
326
    case NodeType_StatementList:
 
327
        parseStatementList(static_cast<StatementListAST*>(node));
 
328
        break;
 
329
 
 
330
    case NodeType_DeclarationStatement:
 
331
        parseDeclarationStatement(static_cast<DeclarationStatementAST*>(node));
 
332
        break;
 
333
 
 
334
    case NodeType_ReturnStatement:
 
335
        parseReturnStatement(static_cast<ReturnStatementAST*>(node));
 
336
        break;
 
337
 
 
338
    default:
 
339
        break;
 
340
    }
 
341
}
 
342
 
 
343
void TreeWalker::parseExpressionStatement(ExpressionStatementAST *node)
 
344
{
 
345
    parseNode(node->expression());
 
346
}
 
347
 
 
348
void TreeWalker::parseCondition(ConditionAST *node)
 
349
{
 
350
    parseNode(node->typeSpec());
 
351
    parseNode(node->declarator());
 
352
    parseNode(node->expression());
 
353
}
 
354
 
 
355
void TreeWalker::parseIfStatement(IfStatementAST *node)
 
356
{
 
357
    parseNode(node->condition());
 
358
    parseNode(node->statement());
 
359
    parseNode(node->elseStatement());
 
360
}
 
361
 
 
362
void TreeWalker::parseWhileStatement(WhileStatementAST *node)
 
363
{
 
364
    parseNode(node->condition());
 
365
    parseNode(node->statement());
 
366
}
 
367
 
 
368
void TreeWalker::parseDoStatement(DoStatementAST *node)
 
369
{
 
370
    parseNode(node->condition());
 
371
    parseNode(node->statement());
 
372
}
 
373
 
 
374
void TreeWalker::parseForStatement(ForStatementAST *node)
 
375
{
 
376
    parseNode(node->initStatement());
 
377
    parseNode(node->condition());
 
378
    parseNode(node->expression());
 
379
    parseNode(node->statement());
 
380
}
 
381
 
 
382
void TreeWalker::parseSwitchStatement(SwitchStatementAST *node)
 
383
{
 
384
    parseNode(node->condition());
 
385
    parseNode(node->statement());
 
386
}
 
387
 
 
388
void TreeWalker::parseStatementList(StatementListAST *node)
 
389
{
 
390
    parseAll(this, node->statementList());
 
391
}
 
392
 
 
393
void TreeWalker::parseDeclarationStatement(DeclarationStatementAST *node)
 
394
{
 
395
    parseNode(node->declaration());
 
396
}
 
397
 
 
398
void TreeWalker::parseFunctionDefinition(FunctionDefinitionAST *node)
 
399
{
 
400
    parseNode(node->functionSpecifier());
 
401
    parseNode(node->storageSpecifier());
 
402
    parseNode(node->typeSpec());
 
403
    parseNode(node->initDeclarator());
 
404
    parseNode(node->functionBody());
 
405
    parseNode(node->winDeclSpec());
 
406
}
 
407
 
 
408
void TreeWalker::parseTranslationUnit(TranslationUnitAST *node)
 
409
{
 
410
    parseAll(this, node->declarationList());
 
411
}
 
412
 
 
413
 
 
414
void TreeWalker::parseExpression(AbstractExpressionAST *node)
 
415
{
 
416
    parseAll(this, node->children());
 
417
}
 
418
 
 
419
 
 
420
void TreeWalker::parseBinaryExpression(BinaryExpressionAST *node)
 
421
{
 
422
    parseNode(node->op());
 
423
    parseNode(node->leftExpression());
 
424
    parseNode(node->rightExpression());
 
425
}
 
426
 
 
427
void TreeWalker::parseReturnStatement(ReturnStatementAST *node)
 
428
{
 
429
    parseNode(node->expression());
 
430
}