src/shared/cplusplus/ASTVisit.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (qt-info@nokia.com)
   8 **
   9 ** No Commercial Usage
  10 **
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 **
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Nokia gives you certain additional
  26 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** If you have questions regarding the use of this file, please contact
  30 ** Nokia at qt-info@nokia.com.
  31 **
  32 **************************************************************************/
  33
  34 //
  35 //  W A R N I N G
  36 //  -------------
  37 //
  38 // This file is automatically generated.
  39 // Changes will be lost.
  40 //
  41
  42
  43 #include "AST.h"
  44 #include "ASTVisitor.h"
  45
  46 using namespace CPlusPlus;
  47
  48 void ObjCSelectorArgumentAST::accept0(ASTVisitor *visitor)
  49 {
  50     if (visitor->visit(this)) {
  51     }
  52     visitor->endVisit(this);
  53 }
  54
  55 void ObjCSelectorAST::accept0(ASTVisitor *visitor)
  56 {
  57     if (visitor->visit(this)) {
  58         accept(selector_argument_list, visitor);
  59     }
  60     visitor->endVisit(this);
  61 }
  62
  63 void SimpleSpecifierAST::accept0(ASTVisitor *visitor)
  64 {
  65     if (visitor->visit(this)) {
  66     }
  67     visitor->endVisit(this);
  68 }
  69
  70 void AttributeSpecifierAST::accept0(ASTVisitor *visitor)
  71 {
  72     if (visitor->visit(this)) {
  73         accept(attribute_list, visitor);
  74     }
  75     visitor->endVisit(this);
  76 }
  77
  78 void AttributeAST::accept0(ASTVisitor *visitor)
  79 {
  80     if (visitor->visit(this)) {
  81         accept(expression_list, visitor);
  82     }
  83     visitor->endVisit(this);
  84 }
  85
  86 void TypeofSpecifierAST::accept0(ASTVisitor *visitor)
  87 {
  88     if (visitor->visit(this)) {
  89         accept(expression, visitor);
  90     }
  91     visitor->endVisit(this);
  92 }
  93
  94 void DeclaratorAST::accept0(ASTVisitor *visitor)
  95 {
  96     if (visitor->visit(this)) {
  97         accept(attribute_list, visitor);
  98         accept(ptr_operator_list, visitor);
  99         accept(core_declarator, visitor);
 100         accept(postfix_declarator_list, visitor);
 101         accept(post_attribute_list, visitor);
 102         accept(initializer, visitor);
 103     }
 104     visitor->endVisit(this);
 105 }
 106
 107 void SimpleDeclarationAST::accept0(ASTVisitor *visitor)
 108 {
 109     if (visitor->visit(this)) {
 110         accept(decl_specifier_list, visitor);
 111         accept(declarator_list, visitor);
 112     }
 113     visitor->endVisit(this);
 114 }
 115
 116 void EmptyDeclarationAST::accept0(ASTVisitor *visitor)
 117 {
 118     if (visitor->visit(this)) {
 119     }
 120     visitor->endVisit(this);
 121 }
 122
 123 void AccessDeclarationAST::accept0(ASTVisitor *visitor)
 124 {
 125     if (visitor->visit(this)) {
 126     }
 127     visitor->endVisit(this);
 128 }
 129
 130 void QtObjectTagAST::accept0(ASTVisitor *visitor)
 131 {
 132     if (visitor->visit(this)) {
 133     }
 134     visitor->endVisit(this);
 135 }
 136
 137 void QtPrivateSlotAST::accept0(ASTVisitor *visitor)
 138 {
 139     if (visitor->visit(this)) {
 140         accept(type_specifier_list, visitor);
 141         accept(declarator, visitor);
 142     }
 143     visitor->endVisit(this);
 144 }
 145
 146 void QtPropertyDeclarationItemAST::accept0(ASTVisitor *visitor)
 147 {
 148     if (visitor->visit(this)) {
 149         accept(expression, visitor);
 150     }
 151     visitor->endVisit(this);
 152 }
 153
 154 void QtPropertyDeclarationAST::accept0(ASTVisitor *visitor)
 155 {
 156     if (visitor->visit(this)) {
 157         accept(expression, visitor);
 158         accept(type_id, visitor);
 159         accept(property_name, visitor);
 160         accept(property_declaration_item_list, visitor);
 161     }
 162     visitor->endVisit(this);
 163 }
 164
 165 void QtEnumDeclarationAST::accept0(ASTVisitor *visitor)
 166 {
 167     if (visitor->visit(this)) {
 168         accept(enumerator_list, visitor);
 169     }
 170     visitor->endVisit(this);
 171 }
 172
 173 void QtFlagsDeclarationAST::accept0(ASTVisitor *visitor)
 174 {
 175     if (visitor->visit(this)) {
 176         accept(flag_enums_list, visitor);
 177     }
 178     visitor->endVisit(this);
 179 }
 180
 181 void QtInterfaceNameAST::accept0(ASTVisitor *visitor)
 182 {
 183     if (visitor->visit(this)) {
 184         accept(interface_name, visitor);
 185         accept(constraint_list, visitor);
 186     }
 187     visitor->endVisit(this);
 188 }
 189
 190 void QtInterfacesDeclarationAST::accept0(ASTVisitor *visitor)
 191 {
 192     if (visitor->visit(this)) {
 193         accept(interface_name_list, visitor);
 194     }
 195     visitor->endVisit(this);
 196 }
 197
 198 void AsmDefinitionAST::accept0(ASTVisitor *visitor)
 199 {
 200     if (visitor->visit(this)) {
 201     }
 202     visitor->endVisit(this);
 203 }
 204
 205 void BaseSpecifierAST::accept0(ASTVisitor *visitor)
 206 {
 207     if (visitor->visit(this)) {
 208         accept(name, visitor);
 209     }
 210     visitor->endVisit(this);
 211 }
 212
 213 void IdExpressionAST::accept0(ASTVisitor *visitor)
 214 {
 215     if (visitor->visit(this)) {
 216         accept(name, visitor);
 217     }
 218     visitor->endVisit(this);
 219 }
 220
 221 void CompoundExpressionAST::accept0(ASTVisitor *visitor)
 222 {
 223     if (visitor->visit(this)) {
 224         accept(statement, visitor);
 225     }
 226     visitor->endVisit(this);
 227 }
 228
 229 void CompoundLiteralAST::accept0(ASTVisitor *visitor)
 230 {
 231     if (visitor->visit(this)) {
 232         accept(type_id, visitor);
 233         accept(initializer, visitor);
 234     }
 235     visitor->endVisit(this);
 236 }
 237
 238 void QtMethodAST::accept0(ASTVisitor *visitor)
 239 {
 240     if (visitor->visit(this)) {
 241         accept(declarator, visitor);
 242     }
 243     visitor->endVisit(this);
 244 }
 245
 246 void QtMemberDeclarationAST::accept0(ASTVisitor *visitor)
 247 {
 248     if (visitor->visit(this)) {
 249         accept(type_id, visitor);
 250     }
 251     visitor->endVisit(this);
 252 }
 253
 254 void BinaryExpressionAST::accept0(ASTVisitor *visitor)
 255 {
 256     if (visitor->visit(this)) {
 257         accept(left_expression, visitor);
 258         accept(right_expression, visitor);
 259     }
 260     visitor->endVisit(this);
 261 }
 262
 263 void CastExpressionAST::accept0(ASTVisitor *visitor)
 264 {
 265     if (visitor->visit(this)) {
 266         accept(type_id, visitor);
 267         accept(expression, visitor);
 268     }
 269     visitor->endVisit(this);
 270 }
 271
 272 void ClassSpecifierAST::accept0(ASTVisitor *visitor)
 273 {
 274     if (visitor->visit(this)) {
 275         accept(attribute_list, visitor);
 276         accept(name, visitor);
 277         accept(base_clause_list, visitor);
 278         accept(member_specifier_list, visitor);
 279     }
 280     visitor->endVisit(this);
 281 }
 282
 283 void CaseStatementAST::accept0(ASTVisitor *visitor)
 284 {
 285     if (visitor->visit(this)) {
 286         accept(expression, visitor);
 287         accept(statement, visitor);
 288     }
 289     visitor->endVisit(this);
 290 }
 291
 292 void CompoundStatementAST::accept0(ASTVisitor *visitor)
 293 {
 294     if (visitor->visit(this)) {
 295         accept(statement_list, visitor);
 296     }
 297     visitor->endVisit(this);
 298 }
 299
 300 void ConditionAST::accept0(ASTVisitor *visitor)
 301 {
 302     if (visitor->visit(this)) {
 303         accept(type_specifier_list, visitor);
 304         accept(declarator, visitor);
 305     }
 306     visitor->endVisit(this);
 307 }
 308
 309 void ConditionalExpressionAST::accept0(ASTVisitor *visitor)
 310 {
 311     if (visitor->visit(this)) {
 312         accept(condition, visitor);
 313         accept(left_expression, visitor);
 314         accept(right_expression, visitor);
 315     }
 316     visitor->endVisit(this);
 317 }
 318
 319 void CppCastExpressionAST::accept0(ASTVisitor *visitor)
 320 {
 321     if (visitor->visit(this)) {
 322         accept(type_id, visitor);
 323         accept(expression, visitor);
 324     }
 325     visitor->endVisit(this);
 326 }
 327
 328 void CtorInitializerAST::accept0(ASTVisitor *visitor)
 329 {
 330     if (visitor->visit(this)) {
 331         accept(member_initializer_list, visitor);
 332     }
 333     visitor->endVisit(this);
 334 }
 335
 336 void DeclarationStatementAST::accept0(ASTVisitor *visitor)
 337 {
 338     if (visitor->visit(this)) {
 339         accept(declaration, visitor);
 340     }
 341     visitor->endVisit(this);
 342 }
 343
 344 void DeclaratorIdAST::accept0(ASTVisitor *visitor)
 345 {
 346     if (visitor->visit(this)) {
 347         accept(name, visitor);
 348     }
 349     visitor->endVisit(this);
 350 }
 351
 352 void NestedDeclaratorAST::accept0(ASTVisitor *visitor)
 353 {
 354     if (visitor->visit(this)) {
 355         accept(declarator, visitor);
 356     }
 357     visitor->endVisit(this);
 358 }
 359
 360 void FunctionDeclaratorAST::accept0(ASTVisitor *visitor)
 361 {
 362     if (visitor->visit(this)) {
 363         accept(parameter_declaration_clause, visitor);
 364         accept(cv_qualifier_list, visitor);
 365         accept(exception_specification, visitor);
 366         accept(trailing_return_type, visitor);
 367         accept(as_cpp_initializer, visitor);
 368     }
 369     visitor->endVisit(this);
 370 }
 371
 372 void ArrayDeclaratorAST::accept0(ASTVisitor *visitor)
 373 {
 374     if (visitor->visit(this)) {
 375         accept(expression, visitor);
 376     }
 377     visitor->endVisit(this);
 378 }
 379
 380 void DeleteExpressionAST::accept0(ASTVisitor *visitor)
 381 {
 382     if (visitor->visit(this)) {
 383         accept(expression, visitor);
 384     }
 385     visitor->endVisit(this);
 386 }
 387
 388 void DoStatementAST::accept0(ASTVisitor *visitor)
 389 {
 390     if (visitor->visit(this)) {
 391         accept(statement, visitor);
 392         accept(expression, visitor);
 393     }
 394     visitor->endVisit(this);
 395 }
 396
 397 void NamedTypeSpecifierAST::accept0(ASTVisitor *visitor)
 398 {
 399     if (visitor->visit(this)) {
 400         accept(name, visitor);
 401     }
 402     visitor->endVisit(this);
 403 }
 404
 405 void ElaboratedTypeSpecifierAST::accept0(ASTVisitor *visitor)
 406 {
 407     if (visitor->visit(this)) {
 408         accept(attribute_list, visitor);
 409         accept(name, visitor);
 410     }
 411     visitor->endVisit(this);
 412 }
 413
 414 void EnumSpecifierAST::accept0(ASTVisitor *visitor)
 415 {
 416     if (visitor->visit(this)) {
 417         accept(name, visitor);
 418         accept(enumerator_list, visitor);
 419     }
 420     visitor->endVisit(this);
 421 }
 422
 423 void EnumeratorAST::accept0(ASTVisitor *visitor)
 424 {
 425     if (visitor->visit(this)) {
 426         accept(expression, visitor);
 427     }
 428     visitor->endVisit(this);
 429 }
 430
 431 void ExceptionDeclarationAST::accept0(ASTVisitor *visitor)
 432 {
 433     if (visitor->visit(this)) {
 434         accept(type_specifier_list, visitor);
 435         accept(declarator, visitor);
 436     }
 437     visitor->endVisit(this);
 438 }
 439
 440 void ExceptionSpecificationAST::accept0(ASTVisitor *visitor)
 441 {
 442     if (visitor->visit(this)) {
 443         accept(type_id_list, visitor);
 444     }
 445     visitor->endVisit(this);
 446 }
 447
 448 void ExpressionOrDeclarationStatementAST::accept0(ASTVisitor *visitor)
 449 {
 450     if (visitor->visit(this)) {
 451         accept(expression, visitor);
 452         accept(declaration, visitor);
 453     }
 454     visitor->endVisit(this);
 455 }
 456
 457 void ExpressionStatementAST::accept0(ASTVisitor *visitor)
 458 {
 459     if (visitor->visit(this)) {
 460         accept(expression, visitor);
 461     }
 462     visitor->endVisit(this);
 463 }
 464
 465 void FunctionDefinitionAST::accept0(ASTVisitor *visitor)
 466 {
 467     if (visitor->visit(this)) {
 468         accept(decl_specifier_list, visitor);
 469         accept(declarator, visitor);
 470         accept(ctor_initializer, visitor);
 471         accept(function_body, visitor);
 472     }
 473     visitor->endVisit(this);
 474 }
 475
 476 void ForeachStatementAST::accept0(ASTVisitor *visitor)
 477 {
 478     if (visitor->visit(this)) {
 479         accept(type_specifier_list, visitor);
 480         accept(declarator, visitor);
 481         accept(initializer, visitor);
 482         accept(expression, visitor);
 483         accept(statement, visitor);
 484     }
 485     visitor->endVisit(this);
 486 }
 487
 488 void ForStatementAST::accept0(ASTVisitor *visitor)
 489 {
 490     if (visitor->visit(this)) {
 491         accept(initializer, visitor);
 492         accept(condition, visitor);
 493         accept(expression, visitor);
 494         accept(statement, visitor);
 495     }
 496     visitor->endVisit(this);
 497 }
 498
 499 void IfStatementAST::accept0(ASTVisitor *visitor)
 500 {
 501     if (visitor->visit(this)) {
 502         accept(condition, visitor);
 503         accept(statement, visitor);
 504         accept(else_statement, visitor);
 505     }
 506     visitor->endVisit(this);
 507 }
 508
 509 void ArrayInitializerAST::accept0(ASTVisitor *visitor)
 510 {
 511     if (visitor->visit(this)) {
 512         accept(expression_list, visitor);
 513     }
 514     visitor->endVisit(this);
 515 }
 516
 517 void LabeledStatementAST::accept0(ASTVisitor *visitor)
 518 {
 519     if (visitor->visit(this)) {
 520         accept(statement, visitor);
 521     }
 522     visitor->endVisit(this);
 523 }
 524
 525 void LinkageBodyAST::accept0(ASTVisitor *visitor)
 526 {
 527     if (visitor->visit(this)) {
 528         accept(declaration_list, visitor);
 529     }
 530     visitor->endVisit(this);
 531 }
 532
 533 void LinkageSpecificationAST::accept0(ASTVisitor *visitor)
 534 {
 535     if (visitor->visit(this)) {
 536         accept(declaration, visitor);
 537     }
 538     visitor->endVisit(this);
 539 }
 540
 541 void MemInitializerAST::accept0(ASTVisitor *visitor)
 542 {
 543     if (visitor->visit(this)) {
 544         accept(name, visitor);
 545         accept(expression_list, visitor);
 546     }
 547     visitor->endVisit(this);
 548 }
 549
 550 void NestedNameSpecifierAST::accept0(ASTVisitor *visitor)
 551 {
 552     if (visitor->visit(this)) {
 553         accept(class_or_namespace_name, visitor);
 554     }
 555     visitor->endVisit(this);
 556 }
 557
 558 void QualifiedNameAST::accept0(ASTVisitor *visitor)
 559 {
 560     if (visitor->visit(this)) {
 561         accept(nested_name_specifier_list, visitor);
 562         accept(unqualified_name, visitor);
 563     }
 564     visitor->endVisit(this);
 565 }
 566
 567 void OperatorFunctionIdAST::accept0(ASTVisitor *visitor)
 568 {
 569     if (visitor->visit(this)) {
 570         accept(op, visitor);
 571     }
 572     visitor->endVisit(this);
 573 }
 574
 575 void ConversionFunctionIdAST::accept0(ASTVisitor *visitor)
 576 {
 577     if (visitor->visit(this)) {
 578         accept(type_specifier_list, visitor);
 579         accept(ptr_operator_list, visitor);
 580     }
 581     visitor->endVisit(this);
 582 }
 583
 584 void SimpleNameAST::accept0(ASTVisitor *visitor)
 585 {
 586     if (visitor->visit(this)) {
 587     }
 588     visitor->endVisit(this);
 589 }
 590
 591 void DestructorNameAST::accept0(ASTVisitor *visitor)
 592 {
 593     if (visitor->visit(this)) {
 594     }
 595     visitor->endVisit(this);
 596 }
 597
 598 void TemplateIdAST::accept0(ASTVisitor *visitor)
 599 {
 600     if (visitor->visit(this)) {
 601         accept(template_argument_list, visitor);
 602     }
 603     visitor->endVisit(this);
 604 }
 605
 606 void NamespaceAST::accept0(ASTVisitor *visitor)
 607 {
 608     if (visitor->visit(this)) {
 609         accept(attribute_list, visitor);
 610         accept(linkage_body, visitor);
 611     }
 612     visitor->endVisit(this);
 613 }
 614
 615 void NamespaceAliasDefinitionAST::accept0(ASTVisitor *visitor)
 616 {
 617     if (visitor->visit(this)) {
 618         accept(name, visitor);
 619     }
 620     visitor->endVisit(this);
 621 }
 622
 623 void NewPlacementAST::accept0(ASTVisitor *visitor)
 624 {
 625     if (visitor->visit(this)) {
 626         accept(expression_list, visitor);
 627     }
 628     visitor->endVisit(this);
 629 }
 630
 631 void NewArrayDeclaratorAST::accept0(ASTVisitor *visitor)
 632 {
 633     if (visitor->visit(this)) {
 634         accept(expression, visitor);
 635     }
 636     visitor->endVisit(this);
 637 }
 638
 639 void NewExpressionAST::accept0(ASTVisitor *visitor)
 640 {
 641     if (visitor->visit(this)) {
 642         accept(new_placement, visitor);
 643         accept(type_id, visitor);
 644         accept(new_type_id, visitor);
 645         accept(new_initializer, visitor);
 646     }
 647     visitor->endVisit(this);
 648 }
 649
 650 void NewInitializerAST::accept0(ASTVisitor *visitor)
 651 {
 652     if (visitor->visit(this)) {
 653         accept(expression, visitor);
 654     }
 655     visitor->endVisit(this);
 656 }
 657
 658 void NewTypeIdAST::accept0(ASTVisitor *visitor)
 659 {
 660     if (visitor->visit(this)) {
 661         accept(type_specifier_list, visitor);
 662         accept(ptr_operator_list, visitor);
 663         accept(new_array_declarator_list, visitor);
 664     }
 665     visitor->endVisit(this);
 666 }
 667
 668 void OperatorAST::accept0(ASTVisitor *visitor)
 669 {
 670     if (visitor->visit(this)) {
 671     }
 672     visitor->endVisit(this);
 673 }
 674
 675 void ParameterDeclarationAST::accept0(ASTVisitor *visitor)
 676 {
 677     if (visitor->visit(this)) {
 678         accept(type_specifier_list, visitor);
 679         accept(declarator, visitor);
 680         accept(expression, visitor);
 681     }
 682     visitor->endVisit(this);
 683 }
 684
 685 void ParameterDeclarationClauseAST::accept0(ASTVisitor *visitor)
 686 {
 687     if (visitor->visit(this)) {
 688         accept(parameter_declaration_list, visitor);
 689     }
 690     visitor->endVisit(this);
 691 }
 692
 693 void CallAST::accept0(ASTVisitor *visitor)
 694 {
 695     if (visitor->visit(this)) {
 696         accept(base_expression, visitor);
 697         accept(expression_list, visitor);
 698     }
 699     visitor->endVisit(this);
 700 }
 701
 702 void ArrayAccessAST::accept0(ASTVisitor *visitor)
 703 {
 704     if (visitor->visit(this)) {
 705         accept(base_expression, visitor);
 706         accept(expression, visitor);
 707     }
 708     visitor->endVisit(this);
 709 }
 710
 711 void PostIncrDecrAST::accept0(ASTVisitor *visitor)
 712 {
 713     if (visitor->visit(this)) {
 714         accept(base_expression, visitor);
 715     }
 716     visitor->endVisit(this);
 717 }
 718
 719 void MemberAccessAST::accept0(ASTVisitor *visitor)
 720 {
 721     if (visitor->visit(this)) {
 722         accept(base_expression, visitor);
 723         accept(member_name, visitor);
 724     }
 725     visitor->endVisit(this);
 726 }
 727
 728 void TypeidExpressionAST::accept0(ASTVisitor *visitor)
 729 {
 730     if (visitor->visit(this)) {
 731         accept(expression, visitor);
 732     }
 733     visitor->endVisit(this);
 734 }
 735
 736 void TypenameCallExpressionAST::accept0(ASTVisitor *visitor)
 737 {
 738     if (visitor->visit(this)) {
 739         accept(name, visitor);
 740         accept(expression_list, visitor);
 741     }
 742     visitor->endVisit(this);
 743 }
 744
 745 void TypeConstructorCallAST::accept0(ASTVisitor *visitor)
 746 {
 747     if (visitor->visit(this)) {
 748         accept(type_specifier_list, visitor);
 749         accept(expression_list, visitor);
 750     }
 751     visitor->endVisit(this);
 752 }
 753
 754 void PointerToMemberAST::accept0(ASTVisitor *visitor)
 755 {
 756     if (visitor->visit(this)) {
 757         accept(nested_name_specifier_list, visitor);
 758         accept(cv_qualifier_list, visitor);
 759     }
 760     visitor->endVisit(this);
 761 }
 762
 763 void PointerAST::accept0(ASTVisitor *visitor)
 764 {
 765     if (visitor->visit(this)) {
 766         accept(cv_qualifier_list, visitor);
 767     }
 768     visitor->endVisit(this);
 769 }
 770
 771 void ReferenceAST::accept0(ASTVisitor *visitor)
 772 {
 773     if (visitor->visit(this)) {
 774     }
 775     visitor->endVisit(this);
 776 }
 777
 778 void BreakStatementAST::accept0(ASTVisitor *visitor)
 779 {
 780     if (visitor->visit(this)) {
 781     }
 782     visitor->endVisit(this);
 783 }
 784
 785 void ContinueStatementAST::accept0(ASTVisitor *visitor)
 786 {
 787     if (visitor->visit(this)) {
 788     }
 789     visitor->endVisit(this);
 790 }
 791
 792 void GotoStatementAST::accept0(ASTVisitor *visitor)
 793 {
 794     if (visitor->visit(this)) {
 795     }
 796     visitor->endVisit(this);
 797 }
 798
 799 void ReturnStatementAST::accept0(ASTVisitor *visitor)
 800 {
 801     if (visitor->visit(this)) {
 802         accept(expression, visitor);
 803     }
 804     visitor->endVisit(this);
 805 }
 806
 807 void SizeofExpressionAST::accept0(ASTVisitor *visitor)
 808 {
 809     if (visitor->visit(this)) {
 810         accept(expression, visitor);
 811     }
 812     visitor->endVisit(this);
 813 }
 814
 815 void NumericLiteralAST::accept0(ASTVisitor *visitor)
 816 {
 817     if (visitor->visit(this)) {
 818     }
 819     visitor->endVisit(this);
 820 }
 821
 822 void BoolLiteralAST::accept0(ASTVisitor *visitor)
 823 {
 824     if (visitor->visit(this)) {
 825     }
 826     visitor->endVisit(this);
 827 }
 828
 829 void ThisExpressionAST::accept0(ASTVisitor *visitor)
 830 {
 831     if (visitor->visit(this)) {
 832     }
 833     visitor->endVisit(this);
 834 }
 835
 836 void NestedExpressionAST::accept0(ASTVisitor *visitor)
 837 {
 838     if (visitor->visit(this)) {
 839         accept(expression, visitor);
 840     }
 841     visitor->endVisit(this);
 842 }
 843
 844 void StringLiteralAST::accept0(ASTVisitor *visitor)
 845 {
 846     if (visitor->visit(this)) {
 847     }
 848     visitor->endVisit(this);
 849 }
 850
 851 void SwitchStatementAST::accept0(ASTVisitor *visitor)
 852 {
 853     if (visitor->visit(this)) {
 854         accept(condition, visitor);
 855         accept(statement, visitor);
 856     }
 857     visitor->endVisit(this);
 858 }
 859
 860 void TemplateDeclarationAST::accept0(ASTVisitor *visitor)
 861 {
 862     if (visitor->visit(this)) {
 863         accept(template_parameter_list, visitor);
 864         accept(declaration, visitor);
 865     }
 866     visitor->endVisit(this);
 867 }
 868
 869 void ThrowExpressionAST::accept0(ASTVisitor *visitor)
 870 {
 871     if (visitor->visit(this)) {
 872         accept(expression, visitor);
 873     }
 874     visitor->endVisit(this);
 875 }
 876
 877 void TranslationUnitAST::accept0(ASTVisitor *visitor)
 878 {
 879     if (visitor->visit(this)) {
 880         accept(declaration_list, visitor);
 881     }
 882     visitor->endVisit(this);
 883 }
 884
 885 void TryBlockStatementAST::accept0(ASTVisitor *visitor)
 886 {
 887     if (visitor->visit(this)) {
 888         accept(statement, visitor);
 889         accept(catch_clause_list, visitor);
 890     }
 891     visitor->endVisit(this);
 892 }
 893
 894 void CatchClauseAST::accept0(ASTVisitor *visitor)
 895 {
 896     if (visitor->visit(this)) {
 897         accept(exception_declaration, visitor);
 898         accept(statement, visitor);
 899     }
 900     visitor->endVisit(this);
 901 }
 902
 903 void TypeIdAST::accept0(ASTVisitor *visitor)
 904 {
 905     if (visitor->visit(this)) {
 906         accept(type_specifier_list, visitor);
 907         accept(declarator, visitor);
 908     }
 909     visitor->endVisit(this);
 910 }
 911
 912 void TypenameTypeParameterAST::accept0(ASTVisitor *visitor)
 913 {
 914     if (visitor->visit(this)) {
 915         accept(name, visitor);
 916         accept(type_id, visitor);
 917     }
 918     visitor->endVisit(this);
 919 }
 920
 921 void TemplateTypeParameterAST::accept0(ASTVisitor *visitor)
 922 {
 923     if (visitor->visit(this)) {
 924         accept(template_parameter_list, visitor);
 925         accept(name, visitor);
 926         accept(type_id, visitor);
 927     }
 928     visitor->endVisit(this);
 929 }
 930
 931 void UnaryExpressionAST::accept0(ASTVisitor *visitor)
 932 {
 933     if (visitor->visit(this)) {
 934         accept(expression, visitor);
 935     }
 936     visitor->endVisit(this);
 937 }
 938
 939 void UsingAST::accept0(ASTVisitor *visitor)
 940 {
 941     if (visitor->visit(this)) {
 942         accept(name, visitor);
 943     }
 944     visitor->endVisit(this);
 945 }
 946
 947 void UsingDirectiveAST::accept0(ASTVisitor *visitor)
 948 {
 949     if (visitor->visit(this)) {
 950         accept(name, visitor);
 951     }
 952     visitor->endVisit(this);
 953 }
 954
 955 void WhileStatementAST::accept0(ASTVisitor *visitor)
 956 {
 957     if (visitor->visit(this)) {
 958         accept(condition, visitor);
 959         accept(statement, visitor);
 960     }
 961     visitor->endVisit(this);
 962 }
 963
 964 void ObjCClassForwardDeclarationAST::accept0(ASTVisitor *visitor)
 965 {
 966     if (visitor->visit(this)) {
 967         accept(attribute_list, visitor);
 968         accept(identifier_list, visitor);
 969     }
 970     visitor->endVisit(this);
 971 }
 972
 973 void ObjCClassDeclarationAST::accept0(ASTVisitor *visitor)
 974 {
 975     if (visitor->visit(this)) {
 976         accept(attribute_list, visitor);
 977         accept(class_name, visitor);
 978         accept(category_name, visitor);
 979         accept(superclass, visitor);
 980         accept(protocol_refs, visitor);
 981         accept(inst_vars_decl, visitor);
 982         accept(member_declaration_list, visitor);
 983     }
 984     visitor->endVisit(this);
 985 }
 986
 987 void ObjCProtocolForwardDeclarationAST::accept0(ASTVisitor *visitor)
 988 {
 989     if (visitor->visit(this)) {
 990         accept(attribute_list, visitor);
 991         accept(identifier_list, visitor);
 992     }
 993     visitor->endVisit(this);
 994 }
 995
 996 void ObjCProtocolDeclarationAST::accept0(ASTVisitor *visitor)
 997 {
 998     if (visitor->visit(this)) {
 999         accept(attribute_list, visitor);
1000         accept(name, visitor);
1001         accept(protocol_refs, visitor);
1002         accept(member_declaration_list, visitor);
1003     }
1004     visitor->endVisit(this);
1005 }
1006
1007 void ObjCProtocolRefsAST::accept0(ASTVisitor *visitor)
1008 {
1009     if (visitor->visit(this)) {
1010         accept(identifier_list, visitor);
1011     }
1012     visitor->endVisit(this);
1013 }
1014
1015 void ObjCMessageArgumentAST::accept0(ASTVisitor *visitor)
1016 {
1017     if (visitor->visit(this)) {
1018         accept(parameter_value_expression, visitor);
1019     }
1020     visitor->endVisit(this);
1021 }
1022
1023 void ObjCMessageExpressionAST::accept0(ASTVisitor *visitor)
1024 {
1025     if (visitor->visit(this)) {
1026         accept(receiver_expression, visitor);
1027         accept(selector, visitor);
1028         accept(argument_list, visitor);
1029     }
1030     visitor->endVisit(this);
1031 }
1032
1033 void ObjCProtocolExpressionAST::accept0(ASTVisitor *visitor)
1034 {
1035     if (visitor->visit(this)) {
1036     }
1037     visitor->endVisit(this);
1038 }
1039
1040 void ObjCTypeNameAST::accept0(ASTVisitor *visitor)
1041 {
1042     if (visitor->visit(this)) {
1043         accept(type_id, visitor);
1044     }
1045     visitor->endVisit(this);
1046 }
1047
1048 void ObjCEncodeExpressionAST::accept0(ASTVisitor *visitor)
1049 {
1050     if (visitor->visit(this)) {
1051         accept(type_name, visitor);
1052     }
1053     visitor->endVisit(this);
1054 }
1055
1056 void ObjCSelectorExpressionAST::accept0(ASTVisitor *visitor)
1057 {
1058     if (visitor->visit(this)) {
1059         accept(selector, visitor);
1060     }
1061     visitor->endVisit(this);
1062 }
1063
1064 void ObjCInstanceVariablesDeclarationAST::accept0(ASTVisitor *visitor)
1065 {
1066     if (visitor->visit(this)) {
1067         accept(instance_variable_list, visitor);
1068     }
1069     visitor->endVisit(this);
1070 }
1071
1072 void ObjCVisibilityDeclarationAST::accept0(ASTVisitor *visitor)
1073 {
1074     if (visitor->visit(this)) {
1075     }
1076     visitor->endVisit(this);
1077 }
1078
1079 void ObjCPropertyAttributeAST::accept0(ASTVisitor *visitor)
1080 {
1081     if (visitor->visit(this)) {
1082         accept(method_selector, visitor);
1083     }
1084     visitor->endVisit(this);
1085 }
1086
1087 void ObjCPropertyDeclarationAST::accept0(ASTVisitor *visitor)
1088 {
1089     if (visitor->visit(this)) {
1090         accept(attribute_list, visitor);
1091         accept(property_attribute_list, visitor);
1092         accept(simple_declaration, visitor);
1093     }
1094     visitor->endVisit(this);
1095 }
1096
1097 void ObjCMessageArgumentDeclarationAST::accept0(ASTVisitor *visitor)
1098 {
1099     if (visitor->visit(this)) {
1100         accept(type_name, visitor);
1101         accept(attribute_list, visitor);
1102         accept(param_name, visitor);
1103     }
1104     visitor->endVisit(this);
1105 }
1106
1107 void ObjCMethodPrototypeAST::accept0(ASTVisitor *visitor)
1108 {
1109     if (visitor->visit(this)) {
1110         accept(type_name, visitor);
1111         accept(selector, visitor);
1112         accept(argument_list, visitor);
1113         accept(attribute_list, visitor);
1114     }
1115     visitor->endVisit(this);
1116 }
1117
1118 void ObjCMethodDeclarationAST::accept0(ASTVisitor *visitor)
1119 {
1120     if (visitor->visit(this)) {
1121         accept(method_prototype, visitor);
1122         accept(function_body, visitor);
1123     }
1124     visitor->endVisit(this);
1125 }
1126
1127 void ObjCSynthesizedPropertyAST::accept0(ASTVisitor *visitor)
1128 {
1129     if (visitor->visit(this)) {
1130     }
1131     visitor->endVisit(this);
1132 }
1133
1134 void ObjCSynthesizedPropertiesDeclarationAST::accept0(ASTVisitor *visitor)
1135 {
1136     if (visitor->visit(this)) {
1137         accept(property_identifier_list, visitor);
1138     }
1139     visitor->endVisit(this);
1140 }
1141
1142 void ObjCDynamicPropertiesDeclarationAST::accept0(ASTVisitor *visitor)
1143 {
1144     if (visitor->visit(this)) {
1145         accept(property_identifier_list, visitor);
1146     }
1147     visitor->endVisit(this);
1148 }
1149
1150 void ObjCFastEnumerationAST::accept0(ASTVisitor *visitor)
1151 {
1152     if (visitor->visit(this)) {
1153         accept(type_specifier_list, visitor);
1154         accept(declarator, visitor);
1155         accept(initializer, visitor);
1156         accept(fast_enumeratable_expression, visitor);
1157         accept(statement, visitor);
1158     }
1159     visitor->endVisit(this);
1160 }
1161
1162 void ObjCSynchronizedStatementAST::accept0(ASTVisitor *visitor)
1163 {
1164     if (visitor->visit(this)) {
1165         accept(synchronized_object, visitor);
1166         accept(statement, visitor);
1167     }
1168     visitor->endVisit(this);
1169 }
1170
1171 void LambdaExpressionAST::accept0(ASTVisitor *visitor)
1172 {
1173     if (visitor->visit(this)) {
1174         accept(lambda_introducer, visitor);
1175         accept(lambda_declarator, visitor);
1176         accept(statement, visitor);
1177     }
1178     visitor->endVisit(this);
1179 }
1180
1181 void LambdaIntroducerAST::accept0(ASTVisitor *visitor)
1182 {
1183     if (visitor->visit(this)) {
1184         accept(lambda_capture, visitor);
1185     }
1186     visitor->endVisit(this);
1187 }
1188
1189 void LambdaCaptureAST::accept0(ASTVisitor *visitor)
1190 {
1191     if (visitor->visit(this)) {
1192         accept(capture_list, visitor);
1193     }
1194     visitor->endVisit(this);
1195 }
1196
1197 void CaptureAST::accept0(ASTVisitor *visitor)
1198 {
1199     if (visitor->visit(this)) {
1200     }
1201     visitor->endVisit(this);
1202 }
1203
1204 void LambdaDeclaratorAST::accept0(ASTVisitor *visitor)
1205 {
1206     if (visitor->visit(this)) {
1207         accept(parameter_declaration_clause, visitor);
1208         accept(attributes, visitor);
1209         accept(exception_specification, visitor);
1210         accept(trailing_return_type, visitor);
1211     }
1212     visitor->endVisit(this);
1213 }
1214
1215 void TrailingReturnTypeAST::accept0(ASTVisitor *visitor)
1216 {
1217     if (visitor->visit(this)) {
1218         accept(attributes, visitor);
1219         accept(type_specifier_list, visitor);
1220         accept(declarator, visitor);
1221     }
1222     visitor->endVisit(this);
1223 }
1224
1225 void BracedInitializerAST::accept0(ASTVisitor *visitor)
1226 {
1227     if (visitor->visit(this)) {
1228         accept(expression_list, visitor);
1229     }
1230     visitor->endVisit(this);
1231 }
1232