source: trunk/tools/porting/src/treewalker.cpp@ 497

Last change on this file since 497 was 2, checked in by Dmitry A. Kuminov, 16 years ago

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