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 "ASTMatcher.h"

    44 #include "TranslationUnit.h"

    45 

    46 using namespace CPlusPlus;

    47 

    48 ASTMatcher::ASTMatcher()

    49 { }

    50 

    51 ASTMatcher::~ASTMatcher()

    52 { }

    53 

    54 bool ASTMatcher::match(SimpleSpecifierAST *node, SimpleSpecifierAST *pattern)

    55 {

    56     (void) node;

    57     (void) pattern;

    58 

    59     pattern->specifier_token = node->specifier_token;

    60 

    61     return true;

    62 }

    63 

    64 bool ASTMatcher::match(AttributeSpecifierAST *node, AttributeSpecifierAST *pattern)

    65 {

    66     (void) node;

    67     (void) pattern;

    68 

    69     pattern->attribute_token = node->attribute_token;

    70 

    71     pattern->first_lparen_token = node->first_lparen_token;

    72 

    73     pattern->second_lparen_token = node->second_lparen_token;

    74 

    75     if (! pattern->attribute_list)

    76         pattern->attribute_list = node->attribute_list;

    77     else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

    78         return false;

    79 

    80     pattern->first_rparen_token = node->first_rparen_token;

    81 

    82     pattern->second_rparen_token = node->second_rparen_token;

    83 

    84     return true;

    85 }

    86 

    87 bool ASTMatcher::match(AttributeAST *node, AttributeAST *pattern)

    88 {

    89     (void) node;

    90     (void) pattern;

    91 

    92     pattern->identifier_token = node->identifier_token;

    93 

    94     pattern->lparen_token = node->lparen_token;

    95 

    96     pattern->tag_token = node->tag_token;

    97 

    98     if (! pattern->expression_list)

    99         pattern->expression_list = node->expression_list;

   100     else if (! AST::match(node->expression_list, pattern->expression_list, this))

   101         return false;

   102 

   103     pattern->rparen_token = node->rparen_token;

   104 

   105     return true;

   106 }

   107 

   108 bool ASTMatcher::match(TypeofSpecifierAST *node, TypeofSpecifierAST *pattern)

   109 {

   110     (void) node;

   111     (void) pattern;

   112 

   113     pattern->typeof_token = node->typeof_token;

   114 

   115     pattern->lparen_token = node->lparen_token;

   116 

   117     if (! pattern->expression)

   118         pattern->expression = node->expression;

   119     else if (! AST::match(node->expression, pattern->expression, this))

   120         return false;

   121 

   122     pattern->rparen_token = node->rparen_token;

   123 

   124     return true;

   125 }

   126 

   127 bool ASTMatcher::match(DeclaratorAST *node, DeclaratorAST *pattern)

   128 {

   129     (void) node;

   130     (void) pattern;

   131 

   132     if (! pattern->attribute_list)

   133         pattern->attribute_list = node->attribute_list;

   134     else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

   135         return false;

   136 

   137     if (! pattern->ptr_operator_list)

   138         pattern->ptr_operator_list = node->ptr_operator_list;

   139     else if (! AST::match(node->ptr_operator_list, pattern->ptr_operator_list, this))

   140         return false;

   141 

   142     if (! pattern->core_declarator)

   143         pattern->core_declarator = node->core_declarator;

   144     else if (! AST::match(node->core_declarator, pattern->core_declarator, this))

   145         return false;

   146 

   147     if (! pattern->postfix_declarator_list)

   148         pattern->postfix_declarator_list = node->postfix_declarator_list;

   149     else if (! AST::match(node->postfix_declarator_list, pattern->postfix_declarator_list, this))

   150         return false;

   151 

   152     if (! pattern->post_attribute_list)

   153         pattern->post_attribute_list = node->post_attribute_list;

   154     else if (! AST::match(node->post_attribute_list, pattern->post_attribute_list, this))

   155         return false;

   156 

   157     pattern->equals_token = node->equals_token;

   158 

   159     if (! pattern->initializer)

   160         pattern->initializer = node->initializer;

   161     else if (! AST::match(node->initializer, pattern->initializer, this))

   162         return false;

   163 

   164     return true;

   165 }

   166 

   167 bool ASTMatcher::match(SimpleDeclarationAST *node, SimpleDeclarationAST *pattern)

   168 {

   169     (void) node;

   170     (void) pattern;

   171 

   172     pattern->qt_invokable_token = node->qt_invokable_token;

   173 

   174     if (! pattern->decl_specifier_list)

   175         pattern->decl_specifier_list = node->decl_specifier_list;

   176     else if (! AST::match(node->decl_specifier_list, pattern->decl_specifier_list, this))

   177         return false;

   178 

   179     if (! pattern->declarator_list)

   180         pattern->declarator_list = node->declarator_list;

   181     else if (! AST::match(node->declarator_list, pattern->declarator_list, this))

   182         return false;

   183 

   184     pattern->semicolon_token = node->semicolon_token;

   185 

   186     return true;

   187 }

   188 

   189 bool ASTMatcher::match(EmptyDeclarationAST *node, EmptyDeclarationAST *pattern)

   190 {

   191     (void) node;

   192     (void) pattern;

   193 

   194     pattern->semicolon_token = node->semicolon_token;

   195 

   196     return true;

   197 }

   198 

   199 bool ASTMatcher::match(AccessDeclarationAST *node, AccessDeclarationAST *pattern)

   200 {

   201     (void) node;

   202     (void) pattern;

   203 

   204     pattern->access_specifier_token = node->access_specifier_token;

   205 

   206     pattern->slots_token = node->slots_token;

   207 

   208     pattern->colon_token = node->colon_token;

   209 

   210 #ifdef ICHECK_BUILD

   211     pattern->invoke_token = node->invoke_token;

   212 #endif

   213 

   214     return true;

   215 }

   216 

   217 #ifdef ICHECK_BUILD

   218 bool ASTMatcher::match(QPropertyDeclarationAST *node, QPropertyDeclarationAST *pattern)

   219 {

   220     (void) node;

   221     (void) pattern;

   222 

   223     pattern->property_specifier_token = node->property_specifier_token;

   224 

   225     pattern->type_name_token = node->type_name_token;

   226 

   227     pattern->read_function_token = node->read_function_token;

   228 

   229     pattern->write_function_token = node->write_function_token;

   230 

   231     pattern->notify_function_token = node->notify_function_token;

   232 

   233     return true;

   234 }

   235 

   236 bool ASTMatcher::match(QEnumDeclarationAST *node, QEnumDeclarationAST *pattern)

   237 {

   238     (void) node;

   239     (void) pattern;

   240 

   241     pattern->enum_specifier_token = node->enum_specifier_token;

   242 

   243     if (! pattern->enumerator_list)

   244         pattern->enumerator_list = node->enumerator_list;

   245     else if (! AST::match(node->enumerator_list, pattern->enumerator_list, this))

   246         return false;

   247 

   248     return true;

   249 }

   250 

   251 bool ASTMatcher::match(QFlagsDeclarationAST *node, QFlagsDeclarationAST *pattern)

   252 {

   253     (void) node;

   254     (void) pattern;

   255 

   256     pattern->flags_specifier_token = node->flags_specifier_token;

   257 

   258     if (! pattern->enumerator_list)

   259         pattern->enumerator_list = node->enumerator_list;

   260     else if (! AST::match(node->enumerator_list, pattern->enumerator_list, this))

   261         return false;

   262 

   263     return true;

   264 }

   265 

   266 bool ASTMatcher::match(QDeclareFlagsDeclarationAST *node, QDeclareFlagsDeclarationAST *pattern)

   267 {

   268     (void) node;

   269     (void) pattern;

   270 

   271     pattern->declareflags_specifier_token = node->declareflags_specifier_token;

   272     pattern->flag_token = node->flag_token;

   273     pattern->enum_token = node->enum_token;

   274 

   275     return true;

   276 }

   277 #endif

   278 

   279 bool ASTMatcher::match(AsmDefinitionAST *node, AsmDefinitionAST *pattern)

   280 {

   281     (void) node;

   282     (void) pattern;

   283 

   284     pattern->asm_token = node->asm_token;

   285 

   286     pattern->volatile_token = node->volatile_token;

   287 

   288     pattern->lparen_token = node->lparen_token;

   289 

   290     pattern->rparen_token = node->rparen_token;

   291 

   292     pattern->semicolon_token = node->semicolon_token;

   293 

   294     return true;

   295 }

   296 

   297 bool ASTMatcher::match(BaseSpecifierAST *node, BaseSpecifierAST *pattern)

   298 {

   299     (void) node;

   300     (void) pattern;

   301 

   302     pattern->virtual_token = node->virtual_token;

   303 

   304     pattern->access_specifier_token = node->access_specifier_token;

   305 

   306     if (! pattern->name)

   307         pattern->name = node->name;

   308     else if (! AST::match(node->name, pattern->name, this))

   309         return false;

   310 

   311     return true;

   312 }

   313 

   314 bool ASTMatcher::match(CompoundLiteralAST *node, CompoundLiteralAST *pattern)

   315 {

   316     (void) node;

   317     (void) pattern;

   318 

   319     pattern->lparen_token = node->lparen_token;

   320 

   321     if (! pattern->type_id)

   322         pattern->type_id = node->type_id;

   323     else if (! AST::match(node->type_id, pattern->type_id, this))

   324         return false;

   325 

   326     pattern->rparen_token = node->rparen_token;

   327 

   328     if (! pattern->initializer)

   329         pattern->initializer = node->initializer;

   330     else if (! AST::match(node->initializer, pattern->initializer, this))

   331         return false;

   332 

   333     return true;

   334 }

   335 

   336 bool ASTMatcher::match(QtMethodAST *node, QtMethodAST *pattern)

   337 {

   338     (void) node;

   339     (void) pattern;

   340 

   341     pattern->method_token = node->method_token;

   342 

   343     pattern->lparen_token = node->lparen_token;

   344 

   345     if (! pattern->declarator)

   346         pattern->declarator = node->declarator;

   347     else if (! AST::match(node->declarator, pattern->declarator, this))

   348         return false;

   349 

   350     pattern->rparen_token = node->rparen_token;

   351 

   352     return true;

   353 }

   354 

   355 bool ASTMatcher::match(QtMemberDeclarationAST *node, QtMemberDeclarationAST *pattern)

   356 {

   357     (void) node;

   358     (void) pattern;

   359 

   360     pattern->q_token = node->q_token;

   361 

   362     pattern->lparen_token = node->lparen_token;

   363 

   364     if (! pattern->type_id)

   365         pattern->type_id = node->type_id;

   366     else if (! AST::match(node->type_id, pattern->type_id, this))

   367         return false;

   368 

   369     pattern->rparen_token = node->rparen_token;

   370 

   371     return true;

   372 }

   373 

   374 bool ASTMatcher::match(BinaryExpressionAST *node, BinaryExpressionAST *pattern)

   375 {

   376     (void) node;

   377     (void) pattern;

   378 

   379     if (! pattern->left_expression)

   380         pattern->left_expression = node->left_expression;

   381     else if (! AST::match(node->left_expression, pattern->left_expression, this))

   382         return false;

   383 

   384     pattern->binary_op_token = node->binary_op_token;

   385 

   386     if (! pattern->right_expression)

   387         pattern->right_expression = node->right_expression;

   388     else if (! AST::match(node->right_expression, pattern->right_expression, this))

   389         return false;

   390 

   391     return true;

   392 }

   393 

   394 bool ASTMatcher::match(CastExpressionAST *node, CastExpressionAST *pattern)

   395 {

   396     (void) node;

   397     (void) pattern;

   398 

   399     pattern->lparen_token = node->lparen_token;

   400 

   401     if (! pattern->type_id)

   402         pattern->type_id = node->type_id;

   403     else if (! AST::match(node->type_id, pattern->type_id, this))

   404         return false;

   405 

   406     pattern->rparen_token = node->rparen_token;

   407 

   408     if (! pattern->expression)

   409         pattern->expression = node->expression;

   410     else if (! AST::match(node->expression, pattern->expression, this))

   411         return false;

   412 

   413     return true;

   414 }

   415 

   416 bool ASTMatcher::match(ClassSpecifierAST *node, ClassSpecifierAST *pattern)

   417 {

   418     (void) node;

   419     (void) pattern;

   420 

   421     pattern->classkey_token = node->classkey_token;

   422 

   423     if (! pattern->attribute_list)

   424         pattern->attribute_list = node->attribute_list;

   425     else if (! AST::match(node->attribute_list, pattern->attribute_list, this))

   426         return false;

   427 

   428     if (! pattern->name)

   429         pattern->name = node->name;

   430     else if (! AST::match(node->name, pattern->name, this))

   431         return false;

   432 

   433     pattern->colon_token = node->colon_token;

   434 

   435     if (! pattern->base_clause_list)

   436         pattern->base_clause_list = node->base_clause_list;

   437     else if (! AST::match(node->base_clause_list, pattern->base_clause_list, this))

   438         return false;

   439 

   440     pattern->lbrace_token = node->lbrace_token;

   441 

   442     if (! pattern->member_specifier_list)

   443         pattern->member_specifier_list = node->member_specifier_list;

   444     else if (! AST::match(node->member_specifier_list, pattern->member_specifier_list, this))

   445         return false;

   446 

   447     pattern->rbrace_token = node->rbrace_token;

   448 

   449     return true;

   450 }

   451 

   452 bool ASTMatcher::match(CaseStatementAST *node, CaseStatementAST *pattern)

   453 {

   454     (void) node;

   455     (void) pattern;

   456 

   457     pattern->case_token = node->case_token;

   458 

   459     if (! pattern->expression)

   460         pattern->expression = node->expression;

   461     else if (! AST::match(node->expression, pattern->expression, this))

   462         return false;

   463 

   464     pattern->colon_token = node->colon_token;

   465 

   466     if (! pattern->statement)

   467         pattern->statement = node->statement;

   468     else if (! AST::match(node->statement, pattern->statement, this))

   469         return false;

   470 

   471     return true;

   472 }

   473 

   474 bool ASTMatcher::match(CompoundStatementAST *node, CompoundStatementAST *pattern)

   475 {

   476     (void) node;

   477     (void) pattern;

   478 

   479     pattern->lbrace_token = node->lbrace_token;

   480 

   481     if (! pattern->statement_list)

   482         pattern->statement_list = node->statement_list;

   483     else if (! AST::match(node->statement_list, pattern->statement_list, this))

   484         return false;

   485 

   486     pattern->rbrace_token = node->rbrace_token;

   487 

   488     return true;

   489 }

   490 

   491 bool ASTMatcher::match(ConditionAST *node, ConditionAST *pattern)

   492 {

   493     (void) node;

   494     (void) pattern;

   495 

   496     if (! pattern->type_specifier_list)

   497         pattern->type_specifier_list = node->type_specifier_list;

   498     else if (! AST::match(node->type_specifier_list, pattern->type_specifier_list, this))

   499         return false;

   500 

   501     if (! pattern->declarator)

   502         pattern->declarator = node->declarator;

   503     else if (! AST::match(node->declarator, pattern->declarator, this))

   504         return false;

   505 

   506     return true;

   507 }

   508 

   509 bool ASTMatcher::match(ConditionalExpressionAST *node, ConditionalExpressionAST *pattern)

   510 {

   511     (void) node;

   512     (void) pattern;

   513 

   514     if (! pattern->condition)

   515         pattern->condition = node->condition;

   516     else if (! AST::match(node->condition, pattern->condition, this))

   517         return false;

   518 

   519     pattern->question_token = node->question_token;

   520 

   521     if (! pattern->left_expression)

   522         pattern->left_expression = node->left_expression;

   523     else if (! AST::match(node->left_expression, pattern->left_expression, this))

   524         return false;

   525 

   526     pattern->colon_token = node->colon_token;

   527 

   528     if (! pattern->right_expression)

   529         pattern->right_expression = node->right_expression;

   530     else if (! AST::match(node->right_expression, pattern->right_expression, this))

   531         return false;

   532 

   533     return true;

   534 }

   535 

   536 bool ASTMatcher::match(CppCastExpressionAST *node, CppCastExpressionAST *pattern)

   537 {

   538     (void) node;

   539     (void) pattern;

   540 

   541     pattern->cast_token = node->cast_token;

   542 

   543     pattern->less_token = node->less_token;

   544 

   545     if (! pattern->type_id)

   546         pattern->type_id = node->type_id;

   547     else if (! AST::match(node->type_id, pattern->type_id, this))

   548         return false;

   549 

   550     pattern->greater_token = node->greater_token;

   551 

   552     pattern->lparen_token = node->lparen_token;

   553 

   554     if (! pattern->expression)

   555         pattern->expression = node->expression;

   556     else if (! AST::match(node->expression, pattern->expression, this))

   557         return false;

   558 

   559     pattern->rparen_token = node->rparen_token;

   560 

   561     return true;

   562 }

   563 

   564 bool ASTMatcher::match(CtorInitializerAST *node, CtorInitializerAST *pattern)

   565 {

   566     (void) node;

   567     (void) pattern;

   568 

   569     pattern->colon_token = node->colon_token;

   570 

   571     if (! pattern->member_initializer_list)

   572         pattern->member_initializer_list = node->member_initializer_list;

   573     else if (! AST::match(node->member_initializer_list, pattern->member_initializer_list, this))

   574         return false;

   575 

   576     return true;

   577 }

   578 

   579 bool ASTMatcher::match(DeclarationStatementAST *node, DeclarationStatementAST *pattern)

   580 {

   581     (void) node;

   582     (void) pattern;

   583 

   584     if (! pattern->declaration)

   585         pattern->declaration = node->declaration;

   586     else if (! AST::match(node->declaration, pattern->declaration, this))

   587         return false;

   588 

   589     return true;

   590 }

   591 

   592 bool ASTMatcher::match(DeclaratorIdAST *node, DeclaratorIdAST *pattern)

   593 {

   594     (void) node;

   595     (void) pattern;

   596 

   597     if (! pattern->name)

   598         pattern->name = node->name;

   599     else if (! AST::match(node->name, pattern->name, this))

   600         return false;

   601 

   602     return true;

   603 }

   604 

   605 bool ASTMatcher::match(NestedDeclaratorAST *node, NestedDeclaratorAST *pattern)

   606 {

   607     (void) node;

   608     (void) pattern;

   609 

   610     pattern->lparen_token = node->lparen_token;

   611 

   612     if (! pattern->declarator)

   613         pattern->declarator = node->declarator;

   614     else if (! AST::match(node->declarator, pattern->declarator, this))

   615         return false;

   616 

   617     pattern->rparen_token = node->rparen_token;

   618 

   619     return true;

   620 }

   621 

   622 bool ASTMatcher::match(FunctionDeclaratorAST *node, FunctionDeclaratorAST *pattern)

   623 {

   624     (void) node;

   625     (void) pattern;

   626 

   627     pattern->lparen_token = node->lparen_token;

   628 

   629     if (! pattern->parameters)

   630         pattern->parameters = node->parameters;

   631     else if (! AST::match(node->parameters, pattern->parameters, this))

   632         return false;

   633 

   634     pattern->rparen_token = node->rparen_token;

   635 

   636     if (! pattern->cv_qualifier_list)

   637         pattern->cv_qualifier_list = node->cv_qualifier_list;

   638     else if (! AST::match(node->cv_qualifier_list, pattern->cv_qualifier_list, this))

   639         return false;

   640 

   641     if (! pattern->exception_specification)

   642         pattern->exception_specification = node->exception_specification;

   643     else if (! AST::match(node->exception_specification, pattern->exception_specification, this))

   644         return false;

   645 

   646     if (! pattern->as_cpp_initializer)

   647         pattern->as_cpp_initializer = node->as_cpp_initializer;

   648     else if (! AST::match(node->as_cpp_initializer, pattern->as_cpp_initializer, this))

   649         return false;

   650 

   651     return true;

   652 }

   653 

   654 bool ASTMatcher::match(ArrayDeclaratorAST *node, ArrayDeclaratorAST *pattern)

   655 {

   656     (void) node;

   657     (void) pattern;

   658 

   659     pattern->lbracket_token = node->lbracket_token;

   660 

   661     if (! pattern->expression)

   662         pattern->expression = node->expression;

   663     else if (! AST::match(node->expression, pattern->expression, this))

   664         return false;

   665 

   666     pattern->rbracket_token = node->rbracket_token;

   667 

   668     return true;

   669 }

   670 

   671 bool ASTMatcher::match(DeleteExpressionAST *node, DeleteExpressionAST *pattern)

   672 {

   673     (void) node;

   674     (void) pattern;

   675 

   676     pattern->scope_token = node->scope_token;

   677 

   678     pattern->delete_token = node->delete_token;

   679 

   680     pattern->lbracket_token = node->lbracket_token;

   681 

   682     pattern->rbracket_token = node->rbracket_token;

   683 

   684     if (! pattern->expression)

   685         pattern->expression = node->expression;

   686     else if (! AST::match(node->expression, pattern->expression, this))

   687         return false;

   688 

   689     return true;

   690 }

   691 

   692 bool ASTMatcher::match(DoStatementAST *node, DoStatementAST *pattern)

   693 {

   694     (void) node;

   695     (void) pattern;

   696 

   697     pattern->do_token = node->do_token;

   698 

   699     if (! pattern->statement)

   700         pattern->statement = node->statement;

   701     else if (! AST::match(node->statement, pattern->statement, this))

   702         return false;

   703 

   704     pattern->while_token = node->while_token;

   705 

   706     pattern->lparen_token = node->lparen_token;

   707 

   708     if (! pattern->expression)

   709         pattern->expression = node->expression;

   710     else if (! AST::match(node->expression, pattern->expression, this))

   711         return false;

   712 

   713     pattern->rparen_token = node->rparen_token;

   714 

   715     pattern->semicolon_token = node->semicolon_token;

   716 

   717     return true;

   718 }

   719 

   720 bool ASTMatcher::match(NamedTypeSpecifierAST *node, NamedTypeSpecifierAST *pattern)

   721 {

   722     (void) node;

   723     (void) pattern;

   724 

   725     if (! pattern->name)

   726         pattern->name = node->name;

   727     else if (! AST::match(node->name, pattern->name, this))

   728         return false;

   729 

   730     return true;

   731 }

   732 

   733 bool ASTMatcher::match(ElaboratedTypeSpecifierAST *node, ElaboratedTypeSpecifierAST *pattern)

   734 {

   735     (void) node;

   736     (void) pattern;

   737 

   738     pattern->classkey_token = node->classkey_token;

   739 

   740     if (! pattern->name)

   741         pattern->name = node->name;

   742     else if (! AST::match(node->name, pattern->name, this))

   743         return false;

   744 

   745     return true;

   746 }

   747 

   748 bool ASTMatcher::match(EnumSpecifierAST *node, EnumSpecifierAST *pattern)

   749 {

   750     (void) node;

   751     (void) pattern;

   752 

   753     pattern->enum_token = node->enum_token;

   754 

   755     if (! pattern->name)

   756         pattern->name = node->name;

   757     else if (! AST::match(node->name, pattern->name, this))

   758         return false;

   759 

   760     pattern->lbrace_token = node->lbrace_token;

   761 

   762     if (! pattern->enumerator_list)

   763         pattern->enumerator_list = node->enumerator_list;

   764     else if (! AST::match(node->enumerator_list, pattern->enumerator_list, this))

   765         return false;

   766 

   767     pattern->rbrace_token = node->rbrace_token;

   768 

   769     return true;

   770 }

   771 

   772 bool ASTMatcher::match(EnumeratorAST *node, EnumeratorAST *pattern)

   773 {

   774     (void) node;

   775     (void) pattern;

   776 

   777     pattern->identifier_token = node->identifier_token;

   778 

   779     pattern->equal_token = node->equal_token;

   780 

   781     if (! pattern->expression)

   782         pattern->expression = node->expression;

   783     else if (! AST::match(node->expression, pattern->expression, this))

   784         return false;

   785 

   786     return true;

   787 }

   788 

   789 bool ASTMatcher::match(ExceptionDeclarationAST *node, ExceptionDeclarationAST *pattern)

   790 {

   791     (void) node;

   792     (void) pattern;

   793 

   794     if (! pattern->type_specifier_list)

   795         pattern->type_specifier_list = node->type_specifier_list;

   796     else if (! AST::match(node->type_specifier_list, pattern->type_specifier_list, this))

   797         return false;

   798 

   799     if (! pattern->declarator)

   800         pattern->declarator = node->declarator;

   801     else if (! AST::match(node->declarator, pattern->declarator, this))

   802         return false;

   803 

   804     pattern->dot_dot_dot_token = node->dot_dot_dot_token;

   805 

   806     return true;

   807 }

   808 

   809 bool ASTMatcher::match(ExceptionSpecificationAST *node, ExceptionSpecificationAST *pattern)

   810 {

   811     (void) node;

   812     (void) pattern;

   813 

   814     pattern->throw_token = node->throw_token;

   815 

   816     pattern->lparen_token = node->lparen_token;

   817 

   818     pattern->dot_dot_dot_token = node->dot_dot_dot_token;

   819 

   820     if (! pattern->type_id_list)

   821         pattern->type_id_list = node->type_id_list;

   822     else if (! AST::match(node->type_id_list, pattern->type_id_list, this))

   823         return false;

   824 

   825     pattern->rparen_token = node->rparen_token;

   826 

   827     return true;

   828 }

   829 

   830 bool ASTMatcher::match(ExpressionOrDeclarationStatementAST *node, ExpressionOrDeclarationStatementAST *pattern)

   831 {

   832     (void) node;

   833     (void) pattern;

   834 

   835     if (! pattern->expression)

   836         pattern->expression = node->expression;

   837     else if (! AST::match(node->expression, pattern->expression, this))

   838         return false;

   839 

   840     if (! pattern->declaration)

   841         pattern->declaration = node->declaration;

   842     else if (! AST::match(node->declaration, pattern->declaration, this))

   843         return false;

   844 

   845     return true;

   846 }

   847 

   848 bool ASTMatcher::match(ExpressionStatementAST *node, ExpressionStatementAST *pattern)

   849 {

   850     (void) node;

   851     (void) pattern;

   852 

   853     if (! pattern->expression)

   854         pattern->expression = node->expression;

   855     else if (! AST::match(node->expression, pattern->expression, this))

   856         return false;

   857 

   858     pattern->semicolon_token = node->semicolon_token;

   859 

   860     return true;

   861 }

   862 

   863 bool ASTMatcher::match(FunctionDefinitionAST *node, FunctionDefinitionAST *pattern)

   864 {

   865     (void) node;

   866     (void) pattern;

   867 

   868     pattern->qt_invokable_token = node->qt_invokable_token;

   869 

   870     if (! pattern->decl_specifier_list)

   871         pattern->decl_specifier_list = node->decl_specifier_list;

   872     else if (! AST::match(node->decl_specifier_list, pattern->decl_specifier_list, this))

   873         return false;

   874 

   875     if (! pattern->declarator)

   876         pattern->declarator = node->declarator;

   877     else if (! AST::match(node->declarator, pattern->declarator, this))

   878         return false;

   879 

   880     if (! pattern->ctor_initializer)

   881         pattern->ctor_initializer = node->ctor_initializer;

   882     else if (! AST::match(node->ctor_initializer, pattern->ctor_initializer, this))

   883         return false;

   884 

   885     if (! pattern->function_body)

   886         pattern->function_body = node->function_body;

   887     else if (! AST::match(node->function_body, pattern->function_body, this))

   888         return false;

   889 

   890     return true;

   891 }

   892 

   893 bool ASTMatcher::match(ForeachStatementAST *node, ForeachStatementAST *pattern)

   894 {

   895     (void) node;

   896     (void) pattern;

   897 

   898     pattern->foreach_token = node->foreach_token;

   899 

   900     pattern->lparen_token = node->lparen_token;

   901 

   902     if (! pattern->type_specifier_list)

   903         pattern->type_specifier_list = node->type_specifier_list;

   904     else if (! AST::match(node->type_specifier_list, pattern->type_specifier_list, this))

   905         return false;

   906 

   907     if (! pattern->declarator)

   908         pattern->declarator = node->declarator;

   909     else if (! AST::match(node->declarator, pattern->declarator, this))

   910         return false;

   911 

   912     if (! pattern->initializer)

   913         pattern->initializer = node->initializer;

   914     else if (! AST::match(node->initializer, pattern->initializer, this))

   915         return false;

   916 

   917     pattern->comma_token = node->comma_token;

   918 

   919     if (! pattern->expression)

   920         pattern->expression = node->expression;

   921     else if (! AST::match(node->expression, pattern->expression, this))

   922         return false;

   923 

   924     pattern->rparen_token = node->rparen_token;

   925 

   926     if (! pattern->statement)

   927         pattern->statement = node->statement;

   928     else if (! AST::match(node->statement, pattern->statement, this))

   929         return false;

   930 

   931     return true;

   932 }

   933 

   934 bool ASTMatcher::match(ForStatementAST *node, ForStatementAST *pattern)

   935 {

   936     (void) node;

   937     (void) pattern;

   938 

   939     pattern->for_token = node->for_token;

   940 

   941     pattern->lparen_token = node->lparen_token;

   942 

   943     if (! pattern->initializer)

   944         pattern->initializer = node->initializer;

   945     else if (! AST::match(node->initializer, pattern->initializer, this))

   946         return false;

   947 

   948     if (! pattern->condition)

   949         pattern->condition = node->condition;

   950     else if (! AST::match(node->condition, pattern->condition, this))

   951         return false;

   952 

   953     pattern->semicolon_token = node->semicolon_token;

   954 

   955     if (! pattern->expression)

   956         pattern->expression = node->expression;

   957     else if (! AST::match(node->expression, pattern->expression, this))

   958         return false;

   959 

   960     pattern->rparen_token = node->rparen_token;

   961 

   962     if (! pattern->statement)

   963         pattern->statement = node->statement;

   964     else if (! AST::match(node->statement, pattern->statement, this))

   965         return false;

   966 

   967     return true;

   968 }

   969 

   970 bool ASTMatcher::match(IfStatementAST *node, IfStatementAST *pattern)

   971 {

   972     (void) node;

   973     (void) pattern;

   974 

   975     pattern->if_token = node->if_token;

   976 

   977     pattern->lparen_token = node->lparen_token;

   978 

   979     if (! pattern->condition)

   980         pattern->condition = node->condition;

   981     else if (! AST::match(node->condition, pattern->condition, this))

   982         return false;

   983 

   984     pattern->rparen_token = node->rparen_token;

   985 

   986     if (! pattern->statement)

   987         pattern->statement = node->statement;

   988     else if (! AST::match(node->statement, pattern->statement, this))

   989         return false;

   990 

   991     pattern->else_token = node->else_token;

   992 

   993     if (! pattern->else_statement)

   994         pattern->else_statement = node->else_statement;

   995     else if (! AST::match(node->else_statement, pattern->else_statement, this))

   996         return false;

   997 

   998     return true;

   999 }

  1000 

  1001 bool ASTMatcher::match(ArrayInitializerAST *node, ArrayInitializerAST *pattern)

  1002 {

  1003     (void) node;

  1004     (void) pattern;

  1005 

  1006     pattern->lbrace_token = node->lbrace_token;

  1007 

  1008     if (! pattern->expression_list)

  1009         pattern->expression_list = node->expression_list;

  1010     else if (! AST::match(node->expression_list, pattern->expression_list, this))

  1011         return false;

  1012 

  1013     pattern->rbrace_token = node->rbrace_token;

  1014 

  1015     return true;

  1016 }

  1017 

  1018 bool ASTMatcher::match(LabeledStatementAST *node, LabeledStatementAST *pattern)

  1019 {

  1020     (void) node;

  1021     (void) pattern;

  1022 

  1023     pattern->label_token = node->label_token;

  1024 

  1025     pattern->colon_token = node->colon_token;

  1026 

  1027     if (! pattern->statement)

  1028         pattern->statement = node->statement;

  1029     else if (! AST::match(node->statement, pattern->statement, this))

  1030         return false;

  1031 

  1032     return true;

  1033 }

  1034 

  1035 bool ASTMatcher::match(LinkageBodyAST *node, LinkageBodyAST *pattern)

  1036 {

  1037     (void) node;

  1038     (void) pattern;

  1039 

  1040     pattern->lbrace_token = node->lbrace_token;

  1041 

  1042     if (! pattern->declaration_list)

  1043         pattern->declaration_list = node->declaration_list;

  1044     else if (! AST::match(node->declaration_list, pattern->declaration_list, this))

  1045         return false;

  1046 

  1047     pattern->rbrace_token = node->rbrace_token;

  1048 

  1049     return true;

  1050 }

  1051 

  1052 bool ASTMatcher::match(LinkageSpecificationAST *node, LinkageSpecificationAST *pattern)

  1053 {

  1054     (void) node;

  1055     (void) pattern;

  1056 

  1057     pattern->extern_token = node->extern_token;

  1058 

  1059     pattern->extern_type_token = node->extern_type_token;

  1060 

  1061     if (! pattern->declaration)

  1062         pattern->declaration = node->declaration;

  1063     else if (! AST::match(node->declaration, pattern->declaration, this))

  1064         return false;

  1065 

  1066     return true;

  1067 }

  1068 

  1069 bool ASTMatcher::match(MemInitializerAST *node, MemInitializerAST *pattern)

  1070 {

  1071     (void) node;

  1072     (void) pattern;

  1073 

  1074     if (! pattern->name)

  1075         pattern->name = node->name;

  1076     else if (! AST::match(node->name, pattern->name, this))

  1077         return false;

  1078 

  1079     pattern->lparen_token = node->lparen_token;

  1080 

  1081     if (! pattern->expression_list)

  1082         pattern->expression_list = node->expression_list;

  1083     else if (! AST::match(node->expression_list, pattern->expression_list, this))

  1084         return false;

  1085 

  1086     pattern->rparen_token = node->rparen_token;

  1087 

  1088     return true;

  1089 }

  1090 

  1091 bool ASTMatcher::match(NestedNameSpecifierAST *node, NestedNameSpecifierAST *pattern)

  1092 {

  1093     (void) node;

  1094     (void) pattern;

  1095 

  1096     if (! pattern->class_or_namespace_name)

  1097         pattern->class_or_namespace_name = node->class_or_namespace_name;

  1098     else if (! AST::match(node->class_or_namespace_name, pattern->class_or_namespace_name, this))

  1099         return false;

  1100 

  1101     pattern->scope_token = node->scope_token;

  1102 

  1103     return true;

  1104 }

  1105 

  1106 bool ASTMatcher::match(QualifiedNameAST *node, QualifiedNameAST *pattern)

  1107 {

  1108     (void) node;

  1109     (void) pattern;

  1110 

  1111     pattern->global_scope_token = node->global_scope_token;

  1112 

  1113     if (! pattern->nested_name_specifier_list)

  1114         pattern->nested_name_specifier_list = node->nested_name_specifier_list;

  1115     else if (! AST::match(node->nested_name_specifier_list, pattern->nested_name_specifier_list, this))

  1116         return false;

  1117 

  1118     if (! pattern->unqualified_name)

  1119         pattern->unqualified_name = node->unqualified_name;

  1120     else if (! AST::match(node->unqualified_name, pattern->unqualified_name, this))

  1121         return false;

  1122 

  1123     return true;

  1124 }

  1125 

  1126 bool ASTMatcher::match(OperatorFunctionIdAST *node, OperatorFunctionIdAST *pattern)

  1127 {

  1128     (void) node;

  1129     (void) pattern;

  1130 

  1131     pattern->operator_token = node->operator_token;

  1132 

  1133     if (! pattern->op)

  1134         pattern->op = node->op;

  1135     else if (! AST::match(node->op, pattern->op, this))