1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    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 ** 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 additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "AST.h"

    43 #include "ASTVisitor.h"

    44 

    45 using namespace CPlusPlus;

    46 

    47 void SimpleSpecifierAST::accept0(ASTVisitor *visitor)

    48 {

    49     if (visitor->visit(this)) {

    50     }

    51     visitor->endVisit(this);

    52 }

    53 

    54 void AttributeSpecifierAST::accept0(ASTVisitor *visitor)

    55 {

    56     if (visitor->visit(this)) {

    57         accept(attribute_list, visitor);

    58     }

    59     visitor->endVisit(this);

    60 }

    61 

    62 void AttributeAST::accept0(ASTVisitor *visitor)

    63 {

    64     if (visitor->visit(this)) {

    65         accept(expression_list, visitor);

    66     }

    67     visitor->endVisit(this);

    68 }

    69 

    70 void TypeofSpecifierAST::accept0(ASTVisitor *visitor)

    71 {

    72     if (visitor->visit(this)) {

    73         accept(expression, visitor);

    74     }

    75     visitor->endVisit(this);

    76 }

    77 

    78 void DeclaratorAST::accept0(ASTVisitor *visitor)

    79 {

    80     if (visitor->visit(this)) {

    81         accept(attribute_list, visitor);

    82         accept(ptr_operator_list, visitor);

    83         accept(core_declarator, visitor);

    84         accept(postfix_declarator_list, visitor);

    85         accept(post_attribute_list, visitor);

    86         accept(initializer, visitor);

    87     }

    88     visitor->endVisit(this);

    89 }

    90 

    91 void SimpleDeclarationAST::accept0(ASTVisitor *visitor)

    92 {

    93     if (visitor->visit(this)) {

    94         accept(decl_specifier_list, visitor);

    95         accept(declarator_list, visitor);

    96     }

    97     visitor->endVisit(this);

    98 }

    99 

   100 void EmptyDeclarationAST::accept0(ASTVisitor *visitor)

   101 {

   102     if (visitor->visit(this)) {

   103     }

   104     visitor->endVisit(this);

   105 }

   106 

   107 void AccessDeclarationAST::accept0(ASTVisitor *visitor)

   108 {

   109     if (visitor->visit(this)) {

   110     }

   111     visitor->endVisit(this);

   112 }

   113 

   114 #ifdef ICHECK_BUILD

   115 void QPropertyDeclarationAST::accept0(ASTVisitor *visitor)

   116 {

   117     if (visitor->visit(this)) {

   118     }

   119     visitor->endVisit(this);

   120 }

   121 

   122 void QEnumDeclarationAST::accept0(ASTVisitor *visitor)

   123 {

   124     if (visitor->visit(this)) {

   125     }

   126     visitor->endVisit(this);

   127 }

   128 

   129 void QFlagsDeclarationAST::accept0(ASTVisitor *visitor)

   130 {

   131     if (visitor->visit(this)) {

   132     }

   133     visitor->endVisit(this);

   134 }

   135 

   136 void QDeclareFlagsDeclarationAST::accept0(ASTVisitor *visitor)

   137 {

   138     if (visitor->visit(this)) {

   139     }

   140     visitor->endVisit(this);

   141 }

   142 #endif

   143 

   144 void AsmDefinitionAST::accept0(ASTVisitor *visitor)

   145 {

   146     if (visitor->visit(this)) {

   147     }

   148     visitor->endVisit(this);

   149 }

   150 

   151 void BaseSpecifierAST::accept0(ASTVisitor *visitor)

   152 {

   153     if (visitor->visit(this)) {

   154         accept(name, visitor);

   155     }

   156     visitor->endVisit(this);

   157 }

   158 

   159 void CompoundLiteralAST::accept0(ASTVisitor *visitor)

   160 {

   161     if (visitor->visit(this)) {

   162         accept(type_id, visitor);

   163         accept(initializer, visitor);

   164     }

   165     visitor->endVisit(this);

   166 }

   167 

   168 void QtMethodAST::accept0(ASTVisitor *visitor)

   169 {

   170     if (visitor->visit(this)) {

   171         accept(declarator, visitor);

   172     }

   173     visitor->endVisit(this);

   174 }

   175 

   176 void QtMemberDeclarationAST::accept0(ASTVisitor *visitor)

   177 {

   178     if (visitor->visit(this)) {

   179         accept(type_id, visitor);

   180     }

   181     visitor->endVisit(this);

   182 }

   183 

   184 void BinaryExpressionAST::accept0(ASTVisitor *visitor)

   185 {

   186     if (visitor->visit(this)) {

   187         accept(left_expression, visitor);

   188         accept(right_expression, visitor);

   189     }

   190     visitor->endVisit(this);

   191 }

   192 

   193 void CastExpressionAST::accept0(ASTVisitor *visitor)

   194 {

   195     if (visitor->visit(this)) {

   196         accept(type_id, visitor);

   197         accept(expression, visitor);

   198     }

   199     visitor->endVisit(this);

   200 }

   201 

   202 void ClassSpecifierAST::accept0(ASTVisitor *visitor)

   203 {

   204     if (visitor->visit(this)) {

   205         accept(attribute_list, visitor);

   206         accept(name, visitor);

   207         accept(base_clause_list, visitor);

   208         accept(member_specifier_list, visitor);

   209     }

   210     visitor->endVisit(this);

   211 }

   212 

   213 void CaseStatementAST::accept0(ASTVisitor *visitor)

   214 {

   215     if (visitor->visit(this)) {

   216         accept(expression, visitor);

   217         accept(statement, visitor);

   218     }

   219     visitor->endVisit(this);

   220 }

   221 

   222 void CompoundStatementAST::accept0(ASTVisitor *visitor)

   223 {

   224     if (visitor->visit(this)) {

   225         accept(statement_list, visitor);

   226     }

   227     visitor->endVisit(this);

   228 }

   229 

   230 void ConditionAST::accept0(ASTVisitor *visitor)

   231 {

   232     if (visitor->visit(this)) {

   233         accept(type_specifier_list, visitor);

   234         accept(declarator, visitor);

   235     }

   236     visitor->endVisit(this);

   237 }

   238 

   239 void ConditionalExpressionAST::accept0(ASTVisitor *visitor)

   240 {

   241     if (visitor->visit(this)) {

   242         accept(condition, visitor);

   243         accept(left_expression, visitor);

   244         accept(right_expression, visitor);

   245     }

   246     visitor->endVisit(this);

   247 }

   248 

   249 void CppCastExpressionAST::accept0(ASTVisitor *visitor)

   250 {

   251     if (visitor->visit(this)) {

   252         accept(type_id, visitor);

   253         accept(expression, visitor);

   254     }

   255     visitor->endVisit(this);

   256 }

   257 

   258 void CtorInitializerAST::accept0(ASTVisitor *visitor)

   259 {

   260     if (visitor->visit(this)) {

   261         accept(member_initializer_list, visitor);

   262     }

   263     visitor->endVisit(this);

   264 }

   265 

   266 void DeclarationStatementAST::accept0(ASTVisitor *visitor)

   267 {

   268     if (visitor->visit(this)) {

   269         accept(declaration, visitor);

   270     }

   271     visitor->endVisit(this);

   272 }

   273 

   274 void DeclaratorIdAST::accept0(ASTVisitor *visitor)

   275 {

   276     if (visitor->visit(this)) {

   277         accept(name, visitor);

   278     }

   279     visitor->endVisit(this);

   280 }

   281 

   282 void NestedDeclaratorAST::accept0(ASTVisitor *visitor)

   283 {

   284     if (visitor->visit(this)) {

   285         accept(declarator, visitor);

   286     }

   287     visitor->endVisit(this);

   288 }

   289 

   290 void FunctionDeclaratorAST::accept0(ASTVisitor *visitor)

   291 {

   292     if (visitor->visit(this)) {

   293         accept(parameters, visitor);

   294         accept(cv_qualifier_list, visitor);

   295         accept(exception_specification, visitor);

   296         accept(as_cpp_initializer, visitor);

   297     }

   298     visitor->endVisit(this);

   299 }

   300 

   301 void ArrayDeclaratorAST::accept0(ASTVisitor *visitor)

   302 {

   303     if (visitor->visit(this)) {

   304         accept(expression, visitor);

   305     }

   306     visitor->endVisit(this);

   307 }

   308 

   309 void DeleteExpressionAST::accept0(ASTVisitor *visitor)

   310 {

   311     if (visitor->visit(this)) {

   312         accept(expression, visitor);

   313     }

   314     visitor->endVisit(this);

   315 }

   316 

   317 void DoStatementAST::accept0(ASTVisitor *visitor)

   318 {

   319     if (visitor->visit(this)) {

   320         accept(statement, visitor);

   321         accept(expression, visitor);

   322     }

   323     visitor->endVisit(this);

   324 }

   325 

   326 void NamedTypeSpecifierAST::accept0(ASTVisitor *visitor)

   327 {

   328     if (visitor->visit(this)) {

   329         accept(name, visitor);

   330     }

   331     visitor->endVisit(this);

   332 }

   333 

   334 void ElaboratedTypeSpecifierAST::accept0(ASTVisitor *visitor)

   335 {

   336     if (visitor->visit(this)) {

   337         accept(name, visitor);

   338     }

   339     visitor->endVisit(this);

   340 }

   341 

   342 void EnumSpecifierAST::accept0(ASTVisitor *visitor)

   343 {

   344     if (visitor->visit(this)) {

   345         accept(name, visitor);

   346         accept(enumerator_list, visitor);

   347     }

   348     visitor->endVisit(this);

   349 }

   350 

   351 void EnumeratorAST::accept0(ASTVisitor *visitor)

   352 {

   353     if (visitor->visit(this)) {

   354         accept(expression, visitor);

   355     }

   356     visitor->endVisit(this);

   357 }

   358 

   359 void ExceptionDeclarationAST::accept0(ASTVisitor *visitor)

   360 {

   361     if (visitor->visit(this)) {

   362         accept(type_specifier_list, visitor);

   363         accept(declarator, visitor);

   364     }

   365     visitor->endVisit(this);

   366 }

   367 

   368 void ExceptionSpecificationAST::accept0(ASTVisitor *visitor)

   369 {

   370     if (visitor->visit(this)) {

   371         accept(type_id_list, visitor);

   372     }

   373     visitor->endVisit(this);

   374 }

   375 

   376 void ExpressionOrDeclarationStatementAST::accept0(ASTVisitor *visitor)

   377 {

   378     if (visitor->visit(this)) {

   379         accept(expression, visitor);

   380         accept(declaration, visitor);

   381     }

   382     visitor->endVisit(this);

   383 }

   384 

   385 void ExpressionStatementAST::accept0(ASTVisitor *visitor)

   386 {

   387     if (visitor->visit(this)) {

   388         accept(expression, visitor);

   389     }

   390     visitor->endVisit(this);

   391 }

   392 

   393 void FunctionDefinitionAST::accept0(ASTVisitor *visitor)

   394 {

   395     if (visitor->visit(this)) {

   396         accept(decl_specifier_list, visitor);

   397         accept(declarator, visitor);

   398         accept(ctor_initializer, visitor);

   399         accept(function_body, visitor);

   400     }

   401     visitor->endVisit(this);

   402 }

   403 

   404 void ForeachStatementAST::accept0(ASTVisitor *visitor)

   405 {

   406     if (visitor->visit(this)) {

   407         accept(type_specifier_list, visitor);

   408         accept(declarator, visitor);

   409         accept(initializer, visitor);

   410         accept(expression, visitor);

   411         accept(statement, visitor);

   412     }

   413     visitor->endVisit(this);

   414 }

   415 

   416 void ForStatementAST::accept0(ASTVisitor *visitor)

   417 {

   418     if (visitor->visit(this)) {

   419         accept(initializer, visitor);

   420         accept(condition, visitor);

   421         accept(expression, visitor);

   422         accept(statement, visitor);

   423     }

   424     visitor->endVisit(this);

   425 }

   426 

   427 void IfStatementAST::accept0(ASTVisitor *visitor)

   428 {

   429     if (visitor->visit(this)) {

   430         accept(condition, visitor);

   431         accept(statement, visitor);

   432         accept(else_statement, visitor);

   433     }

   434     visitor->endVisit(this);

   435 }

   436 

   437 void ArrayInitializerAST::accept0(ASTVisitor *visitor)

   438 {

   439     if (visitor->visit(this)) {

   440         accept(expression_list, visitor);

   441     }

   442     visitor->endVisit(this);

   443 }

   444 

   445 void LabeledStatementAST::accept0(ASTVisitor *visitor)

   446 {

   447     if (visitor->visit(this)) {

   448         accept(statement, visitor);

   449     }

   450     visitor->endVisit(this);

   451 }

   452 

   453 void LinkageBodyAST::accept0(ASTVisitor *visitor)

   454 {

   455     if (visitor->visit(this)) {

   456         accept(declaration_list, visitor);

   457     }

   458     visitor->endVisit(this);

   459 }

   460 

   461 void LinkageSpecificationAST::accept0(ASTVisitor *visitor)

   462 {

   463     if (visitor->visit(this)) {

   464         accept(declaration, visitor);

   465     }

   466     visitor->endVisit(this);

   467 }

   468 

   469 void MemInitializerAST::accept0(ASTVisitor *visitor)

   470 {

   471     if (visitor->visit(this)) {

   472         accept(name, visitor);

   473         accept(expression_list, visitor);

   474     }

   475     visitor->endVisit(this);

   476 }

   477 

   478 void NestedNameSpecifierAST::accept0(ASTVisitor *visitor)

   479 {

   480     if (visitor->visit(this)) {

   481         accept(class_or_namespace_name, visitor);

   482     }

   483     visitor->endVisit(this);

   484 }

   485 

   486 void QualifiedNameAST::accept0(ASTVisitor *visitor)

   487 {

   488     if (visitor->visit(this)) {

   489         accept(nested_name_specifier_list, visitor);

   490         accept(unqualified_name, visitor);

   491     }

   492     visitor->endVisit(this);

   493 }

   494 

   495 void OperatorFunctionIdAST::accept0(ASTVisitor *visitor)

   496 {

   497     if (visitor->visit(this)) {

   498         accept(op, visitor);

   499     }

   500     visitor->endVisit(this);

   501 }

   502 

   503 void ConversionFunctionIdAST::accept0(ASTVisitor *visitor)

   504 {

   505     if (visitor->visit(this)) {

   506         accept(type_specifier_list, visitor);

   507         accept(ptr_operator_list, visitor);

   508     }

   509     visitor->endVisit(this);

   510 }

   511 

   512 void SimpleNameAST::accept0(ASTVisitor *visitor)

   513 {

   514     if (visitor->visit(this)) {

   515     }

   516     visitor->endVisit(this);

   517 }

   518 

   519 void DestructorNameAST::accept0(ASTVisitor *visitor)

   520 {

   521     if (visitor->visit(this)) {

   522     }

   523     visitor->endVisit(this);

   524 }

   525 

   526 void TemplateIdAST::accept0(ASTVisitor *visitor)

   527 {

   528     if (visitor->visit(this)) {

   529         accept(template_argument_list, visitor);

   530     }

   531     visitor->endVisit(this);

   532 }

   533 

   534 void NamespaceAST::accept0(ASTVisitor *visitor)

   535 {

   536     if (visitor->visit(this)) {

   537         accept(attribute_list, visitor);

   538         accept(linkage_body, visitor);

   539     }

   540     visitor->endVisit(this);

   541 }

   542 

   543 void NamespaceAliasDefinitionAST::accept0(ASTVisitor *visitor)

   544 {

   545     if (visitor->visit(this)) {

   546         accept(name, visitor);

   547     }

   548     visitor->endVisit(this);

   549 }

   550 

   551 void NewPlacementAST::accept0(ASTVisitor *visitor)

   552 {

   553     if (visitor->visit(this)) {

   554         accept(expression_list, visitor);

   555     }

   556     visitor->endVisit(this);

   557 }

   558 

   559 void NewArrayDeclaratorAST::accept0(ASTVisitor *visitor)

   560 {

   561     if (visitor->visit(this)) {

   562         accept(expression, visitor);

   563     }

   564     visitor->endVisit(this);

   565 }

   566 

   567 void NewExpressionAST::accept0(ASTVisitor *visitor)

   568 {

   569     if (visitor->visit(this)) {

   570         accept(new_placement, visitor);

   571         accept(type_id, visitor);

   572         accept(new_type_id, visitor);

   573         accept(new_initializer, visitor);

   574     }

   575     visitor->endVisit(this);

   576 }

   577 

   578 void NewInitializerAST::accept0(ASTVisitor *visitor)

   579 {

   580     if (visitor->visit(this)) {

   581         accept(expression, visitor);

   582     }

   583     visitor->endVisit(this);

   584 }

   585 

   586 void NewTypeIdAST::accept0(ASTVisitor *visitor)

   587 {

   588     if (visitor->visit(this)) {

   589         accept(type_specifier_list, visitor);

   590         accept(ptr_operator_list, visitor);

   591         accept(new_array_declarator_list, visitor);

   592     }

   593     visitor->endVisit(this);

   594 }

   595 

   596 void OperatorAST::accept0(ASTVisitor *visitor)

   597 {

   598     if (visitor->visit(this)) {

   599     }

   600     visitor->endVisit(this);

   601 }

   602 

   603 void ParameterDeclarationAST::accept0(ASTVisitor *visitor)

   604 {

   605     if (visitor->visit(this)) {

   606         accept(type_specifier_list, visitor);

   607         accept(declarator, visitor);

   608         accept(expression, visitor);

   609     }

   610     visitor->endVisit(this);

   611 }

   612 

   613 void ParameterDeclarationClauseAST::accept0(ASTVisitor *visitor)

   614 {

   615     if (visitor->visit(this)) {

   616         accept(parameter_declaration_list, visitor);

   617     }

   618     visitor->endVisit(this);

   619 }

   620 

   621 void CallAST::accept0(ASTVisitor *visitor)

   622 {

   623     if (visitor->visit(this)) {

   624         accept(expression_list, visitor);

   625     }

   626     visitor->endVisit(this);

   627 }

   628 

   629 void ArrayAccessAST::accept0(ASTVisitor *visitor)

   630 {

   631     if (visitor->visit(this)) {

   632         accept(expression, visitor);

   633     }

   634     visitor->endVisit(this);

   635 }

   636 

   637 void PostIncrDecrAST::accept0(ASTVisitor *visitor)

   638 {

   639     if (visitor->visit(this)) {

   640     }

   641     visitor->endVisit(this);

   642 }

   643 

   644 void MemberAccessAST::accept0(ASTVisitor *visitor)

   645 {

   646     if (visitor->visit(this)) {

   647         accept(member_name, visitor);

   648     }

   649     visitor->endVisit(this);

   650 }

   651 

   652 void TypeidExpressionAST::accept0(ASTVisitor *visitor)

   653 {

   654     if (visitor->visit(this)) {

   655         accept(expression, visitor);

   656     }

   657     visitor->endVisit(this);

   658 }

   659 

   660 void TypenameCallExpressionAST::accept0(ASTVisitor *visitor)

   661 {

   662     if (visitor->visit(this)) {

   663         accept(name, visitor);

   664         accept(expression_list, visitor);

   665     }

   666     visitor->endVisit(this);

   667 }

   668 

   669 void TypeConstructorCallAST::accept0(ASTVisitor *visitor)

   670 {

   671     if (visitor->visit(this)) {

   672         accept(type_specifier_list, visitor);

   673         accept(expression_list, visitor);

   674     }

   675     visitor->endVisit(this);

   676 }

   677 

   678 void PostfixExpressionAST::accept0(ASTVisitor *visitor)

   679 {

   680     if (visitor->visit(this)) {

   681         accept(base_expression, visitor);

   682         accept(postfix_expression_list, visitor);

   683     }

   684     visitor->endVisit(this);

   685 }

   686 

   687 void PointerToMemberAST::accept0(ASTVisitor *visitor)

   688 {

   689     if (visitor->visit(this)) {

   690         accept(nested_name_specifier_list, visitor);

   691         accept(cv_qualifier_list, visitor);

   692     }

   693     visitor->endVisit(this);

   694 }

   695 

   696 void PointerAST::accept0(ASTVisitor *visitor)

   697 {

   698     if (visitor->visit(this)) {

   699         accept(cv_qualifier_list, visitor);

   700     }

   701     visitor->endVisit(this);

   702 }

   703 

   704 void ReferenceAST::accept0(ASTVisitor *visitor)

   705 {

   706     if (visitor->visit(this)) {

   707     }

   708     visitor->endVisit(this);

   709 }

   710 

   711 void BreakStatementAST::accept0(ASTVisitor *visitor)

   712 {

   713     if (visitor->visit(this)) {

   714     }

   715     visitor->endVisit(this);

   716 }

   717 

   718 void ContinueStatementAST::accept0(ASTVisitor *visitor)

   719 {

   720     if (visitor->visit(this)) {

   721     }

   722     visitor->endVisit(this);

   723 }

   724 

   725 void GotoStatementAST::accept0(ASTVisitor *visitor)

   726 {

   727     if (visitor->visit(this)) {

   728     }

   729     visitor->endVisit(this);

   730 }

   731 

   732 void ReturnStatementAST::accept0(ASTVisitor *visitor)

   733 {

   734     if (visitor->visit(this)) {

   735         accept(expression, visitor);

   736     }

   737     visitor->endVisit(this);

   738 }

   739 

   740 void SizeofExpressionAST::accept0(ASTVisitor *visitor)

   741 {

   742     if (visitor->visit(this)) {

   743         accept(expression, visitor);

   744     }

   745     visitor->endVisit(this);

   746 }

   747 

   748 void NumericLiteralAST::accept0(ASTVisitor *visitor)

   749 {

   750     if (visitor->visit(this)) {

   751     }

   752     visitor->endVisit(this);

   753 }

   754 

   755 void BoolLiteralAST::accept0(ASTVisitor *visitor)

   756 {

   757     if (visitor->visit(this)) {

   758     }

   759     visitor->endVisit(this);

   760 }

   761 

   762 void ThisExpressionAST::accept0(ASTVisitor *visitor)

   763 {

   764     if (visitor->visit(this)) {

   765     }

   766     visitor->endVisit(this);

   767 }

   768 

   769 void NestedExpressionAST::accept0(ASTVisitor *visitor)

   770 {

   771     if (visitor->visit(this)) {

   772         accept(expression, visitor);

   773     }

   774     visitor->endVisit(this);

   775 }

   776 

   777 void StringLiteralAST::accept0(ASTVisitor *visitor)

   778 {

   779     if (visitor->visit(this)) {

   780     }

   781     visitor->endVisit(this);

   782 }

   783 

   784 void SwitchStatementAST::accept0(ASTVisitor *visitor)

   785 {

   786     if (visitor->visit(this)) {

   787         accept(condition, visitor);

   788         accept(statement, visitor);

   789     }

   790     visitor->endVisit(this);

   791 }

   792 

   793 void TemplateDeclarationAST::accept0(ASTVisitor *visitor)

   794 {

   795     if (visitor->visit(this)) {

   796         accept(template_parameter_list, visitor);

   797         accept(declaration, visitor);

   798     }

   799     visitor->endVisit(this);

   800 }

   801 

   802 void ThrowExpressionAST::accept0(ASTVisitor *visitor)

   803 {

   804     if (visitor->visit(this)) {

   805         accept(expression, visitor);

   806     }

   807     visitor->endVisit(this);

   808 }

   809 

   810 void TranslationUnitAST::accept0(ASTVisitor *visitor)

   811 {

   812     if (visitor->visit(this)) {

   813         accept(declaration_list, visitor);

   814     }

   815     visitor->endVisit(this);

   816 }

   817 

   818 void TryBlockStatementAST::accept0(ASTVisitor *visitor)

   819 {

   820     if (visitor->visit(this)) {

   821         accept(statement, visitor);

   822         accept(catch_clause_list, visitor);

   823     }

   824     visitor->endVisit(this);

   825 }

   826 

   827 void CatchClauseAST::accept0(ASTVisitor *visitor)

   828 {

   829     if (visitor->visit(this)) {

   830         accept(exception_declaration, visitor);

   831         accept(statement, visitor);

   832     }

   833     visitor->endVisit(this);

   834 }

   835 

   836 void TypeIdAST::accept0(ASTVisitor *visitor)

   837 {

   838     if (visitor->visit(this)) {

   839         accept(type_specifier_list, visitor);

   840         accept(declarator, visitor);

   841     }

   842     visitor->endVisit(this);

   843 }

   844 

   845 void TypenameTypeParameterAST::accept0(ASTVisitor *visitor)

   846 {

   847     if (visitor->visit(this)) {

   848         accept(name, visitor);

   849         accept(type_id, visitor);

   850     }

   851     visitor->endVisit(this);

   852 }

   853 

   854 void TemplateTypeParameterAST::accept0(ASTVisitor *visitor)

   855 {

   856     if (visitor->visit(this)) {

   857         accept(template_parameter_list, visitor);

   858         accept(name, visitor);

   859         accept(type_id, visitor);

   860     }

   861     visitor->endVisit(this);

   862 }

   863 

   864 void UnaryExpressionAST::accept0(ASTVisitor *visitor)

   865 {

   866     if (visitor->visit(this)) {

   867         accept(expression, visitor);

   868     }

   869     visitor->endVisit(this);

   870 }

   871 

   872 void UsingAST::accept0(ASTVisitor *visitor)

   873 {

   874     if (visitor->visit(this)) {

   875         accept(name, visitor);

   876     }

   877     visitor->endVisit(this);

   878 }

   879 

   880 void UsingDirectiveAST::accept0(ASTVisitor *visitor)

   881 {

   882     if (visitor->visit(this)) {

   883         accept(name, visitor);

   884     }

   885     visitor->endVisit(this);

   886 }

   887 

   888 void WhileStatementAST::accept0(ASTVisitor *visitor)

   889 {

   890     if (visitor->visit(this)) {

   891         accept(condition, visitor);

   892         accept(statement, visitor);

   893     }

   894     visitor->endVisit(this);

   895 }

   896 

   897 void ObjCClassForwardDeclarationAST::accept0(ASTVisitor *visitor)

   898 {

   899     if (visitor->visit(this)) {

   900         accept(attribute_list, visitor);

   901         accept(identifier_list, visitor);

   902     }

   903     visitor->endVisit(this);

   904 }

   905 

   906 void ObjCClassDeclarationAST::accept0(ASTVisitor *visitor)

   907 {

   908     if (visitor->visit(this)) {

   909         accept(attribute_list, visitor);

   910         accept(class_name, visitor);

   911         accept(category_name, visitor);

   912         accept(superclass, visitor);

   913         accept(protocol_refs, visitor);

   914         accept(inst_vars_decl, visitor);

   915         accept(member_declaration_list, visitor);

   916     }

   917     visitor->endVisit(this);

   918 }

   919 

   920 void ObjCProtocolForwardDeclarationAST::accept0(ASTVisitor *visitor)

   921 {

   922     if (visitor->visit(this)) {

   923         accept(attribute_list, visitor);

   924         accept(identifier_list, visitor);

   925     }

   926     visitor->endVisit(this);

   927 }

   928 

   929 void ObjCProtocolDeclarationAST::accept0(ASTVisitor *visitor)

   930 {

   931     if (visitor->visit(this)) {

   932         accept(attribute_list, visitor);

   933         accept(name, visitor);

   934         accept(protocol_refs, visitor);

   935         accept(member_declaration_list, visitor);

   936     }

   937     visitor->endVisit(this);

   938 }

   939 

   940 void ObjCProtocolRefsAST::accept0(ASTVisitor *visitor)

   941 {

   942     if (visitor->visit(this)) {

   943         accept(identifier_list, visitor);

   944     }

   945     visitor->endVisit(this);

   946 }

   947 

   948 void ObjCMessageArgumentAST::accept0(ASTVisitor *visitor)

   949 {

   950     if (visitor->visit(this)) {

   951         accept(parameter_value_expression, visitor);

   952     }

   953     visitor->endVisit(this);

   954 }

   955 

   956 void ObjCMessageExpressionAST::accept0(ASTVisitor *visitor)

   957 {

   958     if (visitor->visit(this)) {

   959         accept(receiver_expression, visitor);

   960         accept(selector, visitor);

   961         accept(argument_list, visitor);

   962     }

   963     visitor->endVisit(this);

   964 }

   965 

   966 void ObjCProtocolExpressionAST::accept0(ASTVisitor *visitor)

   967 {

   968     if (visitor->visit(this)) {

   969     }

   970     visitor->endVisit(this);

   971 }

   972 

   973 void ObjCTypeNameAST::accept0(ASTVisitor *visitor)

   974 {

   975     if (visitor->visit(this)) {

   976         accept(type_id, visitor);

   977     }

   978     visitor->endVisit(this);

   979 }

   980 

   981 void ObjCEncodeExpressionAST::accept0(ASTVisitor *visitor)

   982 {

   983     if (visitor->visit(this)) {

   984         accept(type_name, visitor);

   985     }

   986     visitor->endVisit(this);

   987 }

   988 

   989 void ObjCSelectorWithoutArgumentsAST::accept0(ASTVisitor *visitor)

   990 {

   991     if (visitor->visit(this)) {

   992     }

   993     visitor->endVisit(this);

   994 }

   995 

   996 void ObjCSelectorArgumentAST::accept0(ASTVisitor *visitor)

   997 {

   998     if (visitor->visit(this)) {

   999     }

  1000     visitor->endVisit(this);

  1001 }

  1002 

  1003 void ObjCSelectorWithArgumentsAST::accept0(ASTVisitor *visitor)

  1004 {

  1005     if (visitor->visit(this)) {

  1006         accept(selector_argument_list, visitor);

  1007     }

  1008     visitor->endVisit(this);

  1009 }

  1010 

  1011 void ObjCSelectorExpressionAST::accept0(ASTVisitor *visitor)

  1012 {

  1013     if (visitor->visit(this)) {

  1014         accept(selector, visitor);

  1015     }

  1016     visitor->endVisit(this);

  1017 }

  1018 

  1019 void ObjCInstanceVariablesDeclarationAST::accept0(ASTVisitor *visitor)

  1020 {

  1021     if (visitor->visit(this)) {

  1022         accept(instance_variable_list, visitor);

  1023     }

  1024     visitor->endVisit(this);

  1025 }

  1026 

  1027 void ObjCVisibilityDeclarationAST::accept0(ASTVisitor *visitor)

  1028 {

  1029     if (visitor->visit(this)) {

  1030     }

  1031     visitor->endVisit(this);

  1032 }

  1033 

  1034 void ObjCPropertyAttributeAST::accept0(ASTVisitor *visitor)

  1035 {

  1036     if (visitor->visit(this)) {

  1037         accept(method_selector, visitor);

  1038     }

  1039     visitor->endVisit(this);

  1040 }

  1041 

  1042 void ObjCPropertyDeclarationAST::accept0(ASTVisitor *visitor)

  1043 {

  1044     if (visitor->visit(this)) {

  1045         accept(attribute_list, visitor);

  1046         accept(property_attribute_list, visitor);

  1047         accept(simple_declaration, visitor);

  1048     }

  1049     visitor->endVisit(this);

  1050 }

  1051 

  1052 void ObjCMessageArgumentDeclarationAST::accept0(ASTVisitor *visitor)

  1053 {

  1054     if (visitor->visit(this)) {

  1055         accept(type_name, visitor);

  1056         accept(attribute_list, visitor);

  1057     }

  1058     visitor->endVisit(this);

  1059 }

  1060 

  1061 void ObjCMethodPrototypeAST::accept0(ASTVisitor *visitor)

  1062 {

  1063     if (visitor->visit(this)) {

  1064         accept(type_name, visitor);

  1065         accept(selector, visitor);

  1066         accept(argument_list, visitor);

  1067         accept(attribute_list, visitor);

  1068     }

  1069     visitor->endVisit(this);

  1070 }

  1071 

  1072 void ObjCMethodDeclarationAST::accept0(ASTVisitor *visitor)

  1073 {

  1074     if (visitor->visit(this)) {

  1075         accept(method_prototype, visitor);

  1076         accept(function_body, visitor);

  1077     }

  1078     visitor->endVisit(this);

  1079 }

  1080 

  1081 void ObjCSynthesizedPropertyAST::accept0(ASTVisitor *visitor)

  1082 {

  1083     if (visitor->visit(this)) {

  1084     }

  1085     visitor->endVisit(this);

  1086 }

  1087 

  1088 void ObjCSynthesizedPropertiesDeclarationAST::accept0(ASTVisitor *visitor)

  1089 {

  1090     if (visitor->visit(this)) {

  1091         accept(property_identifier_list, visitor);

  1092     }

  1093     visitor->endVisit(this);

  1094 }

  1095 

  1096 void ObjCDynamicPropertiesDeclarationAST::accept0(ASTVisitor *visitor)

  1097 {

  1098     if (visitor->visit(this)) {

  1099         accept(property_identifier_list, visitor);

  1100     }

  1101     visitor->endVisit(this);

  1102 }

  1103 

  1104 void ObjCFastEnumerationAST::accept0(ASTVisitor *visitor)

  1105 {

  1106     if (visitor->visit(this)) {

  1107         accept(type_specifier_list, visitor);

  1108         accept(declarator, visitor);

  1109         accept(initializer, visitor);

  1110         accept(fast_enumeratable_expression, visitor);

  1111         accept(statement, visitor);

  1112     }

  1113     visitor->endVisit(this);

  1114 }

  1115 

  1116 void ObjCSynchronizedStatementAST::accept0(ASTVisitor *visitor)

  1117 {

  1118     if (visitor->visit(this)) {

  1119         accept(synchronized_object, visitor);

  1120         accept(statement, visitor);

  1121     }

  1122     visitor->endVisit(this);

  1123 }

  1124