src/default_visitor.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
   4 **
   5 ** This file is part of Qt Jambi.
   6 **
   7 ** ** This file may be used under the terms of the GNU General Public
   8 ** License version 2.0 as published by the Free Software Foundation
   9 ** and appearing in the file LICENSE.GPL included in the packaging of
  10 ** this file.  Please review the following information to ensure GNU
  11 ** General Public Licensing requirements will be met:
  12 ** http://www.trolltech.com/products/qt/opensource.html
  13 **
  14 ** If you are unsure which license is appropriate for your use, please
  15 ** review the following information:
  16 ** http://www.trolltech.com/products/qt/licensing.html or contact the
  17 ** sales department at sales@trolltech.com.
  18
  19 **
  20 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  21 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22 **
  23 ****************************************************************************/
  24
  25 /* This file is part of KDevelop
  26     Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
  27
  28    This library is free software; you can redistribute it and/or
  29    modify it under the terms of the GNU Library General Public
  30    License version 2 as published by the Free Software Foundation.
  31
  32    This library is distributed in the hope that it will be useful,
  33    but WITHOUT ANY WARRANTY; without even the implied warranty of
  34    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  35    Library General Public License for more details.
  36
  37    You should have received a copy of the GNU Library General Public License
  38    along with this library; see the file COPYING.LIB.  If not, write to
  39    the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  40    Boston, MA 02110-1301, USA.
  41 */
  42
  43 #include "default_visitor.h"
  44
  45 void DefaultVisitor::visitAccessSpecifier(AccessSpecifierAST *)
  46 {
  47   // nothing to do
  48 }
  49
  50 void DefaultVisitor::visitAsmDefinition(AsmDefinitionAST *)
  51 {
  52   // nothing to do
  53 }
  54
  55 void DefaultVisitor::visitBaseClause(BaseClauseAST *node)
  56 {
  57   visitNodes(this, node->base_specifiers);
  58 }
  59
  60 void DefaultVisitor::visitBaseSpecifier(BaseSpecifierAST *node)
  61 {
  62   visit(node->name);
  63 }
  64
  65 void DefaultVisitor::visitBinaryExpression(BinaryExpressionAST *node)
  66 {
  67   visit(node->left_expression);
  68   visit(node->right_expression);
  69 }
  70
  71 void DefaultVisitor::visitCastExpression(CastExpressionAST *node)
  72 {
  73   visit(node->type_id);
  74   visit(node->expression);
  75 }
  76
  77 void DefaultVisitor::visitClassMemberAccess(ClassMemberAccessAST *node)
  78 {
  79   visit(node->name);
  80 }
  81
  82 void DefaultVisitor::visitClassSpecifier(ClassSpecifierAST *node)
  83 {
  84   visit(node->win_decl_specifiers);
  85   visit(node->name);
  86   visit(node->base_clause);
  87   visitNodes(this, node->member_specs);
  88 }
  89
  90 void DefaultVisitor::visitCompoundStatement(CompoundStatementAST *node)
  91 {
  92   visitNodes(this, node->statements);
  93 }
  94
  95 void DefaultVisitor::visitCondition(ConditionAST *node)
  96 {
  97   visit(node->type_specifier);
  98   visit(node->declarator);
  99   visit(node->expression);
 100 }
 101
 102 void DefaultVisitor::visitConditionalExpression(ConditionalExpressionAST *node)
 103 {
 104   visit(node->condition);
 105   visit(node->left_expression);
 106   visit(node->right_expression);
 107 }
 108
 109 void DefaultVisitor::visitCppCastExpression(CppCastExpressionAST *node)
 110 {
 111   visit(node->type_id);
 112   visit(node->expression);
 113   visitNodes(this, node->sub_expressions);
 114 }
 115
 116 void DefaultVisitor::visitCtorInitializer(CtorInitializerAST *node)
 117 {
 118   visitNodes(this, node->member_initializers);
 119 }
 120
 121 void DefaultVisitor::visitDeclarationStatement(DeclarationStatementAST *node)
 122 {
 123   visit(node->declaration);
 124 }
 125
 126 void DefaultVisitor::visitDeclarator(DeclaratorAST *node)
 127 {
 128   visit(node->sub_declarator);
 129   visitNodes(this, node->ptr_ops);
 130   visit(node->id);
 131   visit(node->bit_expression);
 132   visitNodes(this, node->array_dimensions);
 133   visit(node->parameter_declaration_clause);
 134   visit(node->exception_spec);
 135 }
 136
 137 void DefaultVisitor::visitDeleteExpression(DeleteExpressionAST *node)
 138 {
 139   visit(node->expression);
 140 }
 141
 142 void DefaultVisitor::visitDoStatement(DoStatementAST *node)
 143 {
 144   visit(node->statement);
 145   visit(node->expression);
 146 }
 147
 148 void DefaultVisitor::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
 149 {
 150   visit(node->name);
 151 }
 152
 153 void DefaultVisitor::visitEnumSpecifier(EnumSpecifierAST *node)
 154 {
 155   visit(node->name);
 156   visitNodes(this, node->enumerators);
 157 }
 158
 159 void DefaultVisitor::visitEnumerator(EnumeratorAST *node)
 160 {
 161   visit(node->expression);
 162 }
 163
 164 void DefaultVisitor::visitExceptionSpecification(ExceptionSpecificationAST *node)
 165 {
 166   visitNodes(this, node->type_ids);
 167 }
 168
 169 void DefaultVisitor::visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST *node)
 170 {
 171   visit(node->expression);
 172   visit(node->declaration);
 173 }
 174
 175 void DefaultVisitor::visitExpressionStatement(ExpressionStatementAST *node)
 176 {
 177   visit(node->expression);
 178 }
 179
 180 void DefaultVisitor::visitForStatement(ForStatementAST *node)
 181 {
 182   visit(node->init_statement);
 183   visit(node->condition);
 184   visit(node->expression);
 185   visit(node->statement);
 186 }
 187
 188 void DefaultVisitor::visitFunctionCall(FunctionCallAST *node)
 189 {
 190   visit(node->arguments);
 191 }
 192
 193 void DefaultVisitor::visitFunctionDefinition(FunctionDefinitionAST *node)
 194 {
 195   visit(node->type_specifier);
 196   visit(node->init_declarator);
 197   visit(node->function_body);
 198   visit(node->win_decl_specifiers);
 199 }
 200
 201 void DefaultVisitor::visitIfStatement(IfStatementAST *node)
 202 {
 203   visit(node->condition);
 204   visit(node->statement);
 205   visit(node->else_statement);
 206 }
 207
 208 void DefaultVisitor::visitIncrDecrExpression(IncrDecrExpressionAST *)
 209 {
 210   // nothing to do
 211 }
 212
 213 void DefaultVisitor::visitInitDeclarator(InitDeclaratorAST *node)
 214 {
 215   visit(node->declarator);
 216   visit(node->initializer);
 217 }
 218
 219 void DefaultVisitor::visitInitializer(InitializerAST *node)
 220 {
 221   visit(node->initializer_clause);
 222   visit(node->expression);
 223 }
 224
 225 void DefaultVisitor::visitInitializerClause(InitializerClauseAST *node)
 226 {
 227   visit(node->expression);
 228 }
 229
 230 void DefaultVisitor::visitLabeledStatement(LabeledStatementAST *)
 231 {
 232   // nothing to do
 233 }
 234
 235 void DefaultVisitor::visitLinkageBody(LinkageBodyAST *node)
 236 {
 237   visitNodes(this, node->declarations);
 238 }
 239
 240 void DefaultVisitor::visitLinkageSpecification(LinkageSpecificationAST *node)
 241 {
 242   visit(node->linkage_body);
 243   visit(node->declaration);
 244 }
 245
 246 void DefaultVisitor::visitMemInitializer(MemInitializerAST *node)
 247 {
 248   visit(node->initializer_id);
 249   visit(node->expression);
 250 }
 251
 252 void DefaultVisitor::visitName(NameAST *node)
 253 {
 254   visitNodes(this, node->qualified_names);
 255   visit(node->unqualified_name);
 256 }
 257
 258 void DefaultVisitor::visitNamespace(NamespaceAST *node)
 259 {
 260   visit(node->linkage_body);
 261 }
 262
 263 void DefaultVisitor::visitNamespaceAliasDefinition(NamespaceAliasDefinitionAST *node)
 264 {
 265   visit(node->alias_name);
 266 }
 267
 268 void DefaultVisitor::visitNewDeclarator(NewDeclaratorAST *node)
 269 {
 270   visit(node->ptr_op);
 271   visit(node->sub_declarator);
 272   visitNodes(this, node->expressions);
 273 }
 274
 275 void DefaultVisitor::visitNewExpression(NewExpressionAST *node)
 276 {
 277   visit(node->expression);
 278   visit(node->type_id);
 279   visit(node->new_type_id);
 280   visit(node->new_initializer);
 281 }
 282
 283 void DefaultVisitor::visitNewInitializer(NewInitializerAST *node)
 284 {
 285   visit(node->expression);
 286 }
 287
 288 void DefaultVisitor::visitNewTypeId(NewTypeIdAST *node)
 289 {
 290   visit(node->type_specifier);
 291   visit(node->new_initializer);
 292   visit(node->new_declarator);
 293 }
 294
 295 void DefaultVisitor::visitOperator(OperatorAST *)
 296 {
 297   // nothing to do
 298 }
 299
 300 void DefaultVisitor::visitOperatorFunctionId(OperatorFunctionIdAST *node)
 301 {
 302   visit(node->op);
 303   visit(node->type_specifier);
 304   visitNodes(this, node->ptr_ops);
 305 }
 306
 307 void DefaultVisitor::visitParameterDeclaration(ParameterDeclarationAST *node)
 308 {
 309   visit(node->type_specifier);
 310   visit(node->declarator);
 311   visit(node->expression);
 312 }
 313
 314 void DefaultVisitor::visitParameterDeclarationClause(ParameterDeclarationClauseAST *node)
 315 {
 316   visitNodes(this, node->parameter_declarations);
 317 }
 318
 319 void DefaultVisitor::visitPostfixExpression(PostfixExpressionAST *node)
 320 {
 321   visit(node->type_specifier);
 322   visit(node->expression);
 323   visitNodes(this, node->sub_expressions);
 324 }
 325
 326 void DefaultVisitor::visitPrimaryExpression(PrimaryExpressionAST *node)
 327 {
 328   visit(node->literal);
 329   visit(node->expression_statement);
 330   visit(node->sub_expression);
 331   visit(node->name);
 332 }
 333
 334 void DefaultVisitor::visitPtrOperator(PtrOperatorAST *node)
 335 {
 336   visit(node->mem_ptr);
 337 }
 338
 339 void DefaultVisitor::visitPtrToMember(PtrToMemberAST *)
 340 {
 341   // nothing to do
 342 }
 343
 344 void DefaultVisitor::visitReturnStatement(ReturnStatementAST *node)
 345 {
 346   visit(node->expression);
 347 }
 348
 349 void DefaultVisitor::visitSimpleDeclaration(SimpleDeclarationAST *node)
 350 {
 351   visit(node->type_specifier);
 352   visitNodes(this, node->init_declarators);
 353   visit(node->win_decl_specifiers);
 354 }
 355
 356 void DefaultVisitor::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
 357 {
 358   visit(node->name);
 359   visit(node->type_id);
 360   visit(node->expression);
 361 }
 362
 363 void DefaultVisitor::visitSizeofExpression(SizeofExpressionAST *node)
 364 {
 365   visit(node->type_id);
 366   visit(node->expression);
 367 }
 368
 369 void DefaultVisitor::visitStringLiteral(StringLiteralAST *)
 370 {
 371   // nothing to do
 372 }
 373
 374 void DefaultVisitor::visitSubscriptExpression(SubscriptExpressionAST *node)
 375 {
 376   visit(node->subscript);
 377 }
 378
 379 void DefaultVisitor::visitSwitchStatement(SwitchStatementAST *node)
 380 {
 381   visit(node->condition);
 382   visit(node->statement);
 383 }
 384
 385 void DefaultVisitor::visitTemplateArgument(TemplateArgumentAST *node)
 386 {
 387   visit(node->type_id);
 388   visit(node->expression);
 389 }
 390
 391 void DefaultVisitor::visitTemplateDeclaration(TemplateDeclarationAST *node)
 392 {
 393   visitNodes(this, node->template_parameters);
 394   visit(node->declaration);
 395 }
 396
 397 void DefaultVisitor::visitTemplateParameter(TemplateParameterAST *node)
 398 {
 399   visit(node->type_parameter);
 400   visit(node->parameter_declaration);
 401 }
 402
 403 void DefaultVisitor::visitThrowExpression(ThrowExpressionAST *node)
 404 {
 405   visit(node->expression);
 406 }
 407
 408 void DefaultVisitor::visitTranslationUnit(TranslationUnitAST *node)
 409 {
 410   visitNodes(this, node->declarations);
 411 }
 412
 413 void DefaultVisitor::visitTryBlockStatement(TryBlockStatementAST *)
 414 {
 415   // nothing to do
 416 }
 417
 418 void DefaultVisitor::visitTypeId(TypeIdAST *node)
 419 {
 420   visit(node->type_specifier);
 421   visit(node->declarator);
 422 }
 423
 424 void DefaultVisitor::visitTypeIdentification(TypeIdentificationAST *node)
 425 {
 426   visit(node->name);
 427   visit(node->expression);
 428 }
 429
 430 void DefaultVisitor::visitTypeParameter(TypeParameterAST *node)
 431 {
 432   visit(node->name);
 433   visit(node->type_id);
 434   visitNodes(this, node->template_parameters);
 435   visit(node->template_name);
 436 }
 437
 438 void DefaultVisitor::visitTypedef(TypedefAST *node)
 439 {
 440   visit(node->type_specifier);
 441   visitNodes(this, node->init_declarators);
 442 }
 443
 444 void DefaultVisitor::visitUnaryExpression(UnaryExpressionAST *node)
 445 {
 446   visit(node->expression);
 447 }
 448
 449 void DefaultVisitor::visitUnqualifiedName(UnqualifiedNameAST *node)
 450 {
 451   visit(node->operator_id);
 452   visitNodes(this, node->template_arguments);
 453 }
 454
 455 void DefaultVisitor::visitUsing(UsingAST *node)
 456 {
 457   visit(node->name);
 458 }
 459
 460 void DefaultVisitor::visitUsingDirective(UsingDirectiveAST *node)
 461 {
 462   visit(node->name);
 463 }
 464
 465 void DefaultVisitor::visitWhileStatement(WhileStatementAST *node)
 466 {
 467   visit(node->condition);
 468   visit(node->statement);
 469 }
 470
 471 void DefaultVisitor::visitWinDeclSpec(WinDeclSpecAST *)
 472 {
 473   // nothing to do
 474 }
 475
 476 // kate: space-indent on; indent-width 2; replace-tabs on;