00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "ast.h"
00021
#include <qstringlist.h>
00022
#include <kdebug.h>
00023
00024 QString nodeTypeToString(
int type )
00025 {
00026
switch( type )
00027 {
00028
case NodeType_Generic:
00029
return "Generic";
00030
case NodeType_TemplateArgumentList:
00031
return "TemplateArgumentList";
00032
case NodeType_ClassOrNamespaceName:
00033
return "ClassOrNamespaceName";
00034
case NodeType_Name:
00035
return "Name";
00036
case NodeType_Declaration:
00037
return "Declaration";
00038
case NodeType_TypeSpecifier:
00039
return "TypeSpecifier";
00040
case NodeType_BaseSpecifier:
00041
return "BaseSpecifier";
00042
case NodeType_BaseClause:
00043
return "BaseClause";
00044
case NodeType_ClassSpecifier:
00045
return "ClassSpecifier";
00046
case NodeType_Enumerator:
00047
return "Enumerator";
00048
case NodeType_EnumSpecifier:
00049
return "EnumSpecifier";
00050
case NodeType_ElaboratedTypeSpecifier:
00051
return "ElaboratedTypeSpecifier";
00052
case NodeType_LinkageBody:
00053
return "LinkageBody";
00054
case NodeType_LinkageSpecification:
00055
return "LinkageSpecification";
00056
case NodeType_Namespace:
00057
return "Namespace";
00058
case NodeType_NamespaceAlias:
00059
return "NamespaceAlias";
00060
case NodeType_Using:
00061
return "Using";
00062
case NodeType_UsingDirective:
00063
return "UsingDirective";
00064
case NodeType_InitDeclaratorList:
00065
return "InitDeclaratorList";
00066
case NodeType_Typedef:
00067
return "Typedef";
00068
case NodeType_Declarator:
00069
return "Declarator";
00070
case NodeType_InitDeclarator:
00071
return "InitDeclarator";
00072
case NodeType_TemplateDeclaration:
00073
return "TemplateDeclaration";
00074
case NodeType_SimpleDeclaration:
00075
return "SimpleDeclaration";
00076
case NodeType_Statement:
00077
return "Statement";
00078
case NodeType_IfStatement:
00079
return "IfStatement";
00080
case NodeType_WhileStatement:
00081
return "WhileStatement";
00082
case NodeType_DoStatement:
00083
return "DoStatement";
00084
case NodeType_ForStatement:
00085
return "ForStatement";
00086
case NodeType_SwitchStatement:
00087
return "SwitchStatement";
00088
case NodeType_DeclarationStatement:
00089
return "DeclarationStatement";
00090
case NodeType_StatementList:
00091
return "StatementList";
00092
case NodeType_TranslationUnit:
00093
return "TranslationUnit";
00094
case NodeType_FunctionDefinition:
00095
return "FunctionDefinition";
00096
case NodeType_ExpressionStatement:
00097
return "ExpressionStatement";
00098
case NodeType_ParameterDeclaration:
00099
return "ParameterDeclaration";
00100
case NodeType_ParameterDeclarationList:
00101
return "ParameterDeclarationList";
00102
case NodeType_ParameterDeclarationClause:
00103
return "ParameterDeclarationClause";
00104
case NodeType_Group:
00105
return "Group";
00106
case NodeType_AccessDeclaration:
00107
return "AccessDeclaration";
00108
case NodeType_TypeParameter:
00109
return "TypeParameter";
00110
case NodeType_TemplateParameter:
00111
return "TemplateParameter";
00112
case NodeType_TemplateParameterList:
00113
return "TemplateParameterList";
00114
case NodeType_Condition:
00115
return "Condition";
00116
case NodeType_Custom:
00117
return "Custom";
00118 }
00119
00120
return QString::null;
00121 }
00122
00123
00124
00125
AST::AST()
00126 : m_nodeType(
NodeType_Generic ), m_parent( 0 ),
00127 m_startLine( 0 ), m_startColumn( 0 ),
00128 m_endLine( 0 ), m_endColumn( 0 )
00129 {
00130
#ifndef CPPPARSER_NO_CHILDREN
00131
m_children.setAutoDelete(
false );
00132
#endif
00133
}
00134
00135
AST::~AST()
00136 {
00137
#ifndef CPPPARSER_NO_CHILDREN
00138
if(
m_parent )
00139
m_parent->
removeChild(
this );
00140
#endif
00141
}
00142
00143 void AST::setStartPosition(
int line,
int col )
00144 {
00145
m_startLine = line;
00146
m_startColumn = col;
00147 }
00148
00149 void AST::getStartPosition(
int* line,
int* col )
const
00150
{
00151
if( line )
00152 *line =
m_startLine;
00153
00154
if( col )
00155 * col =
m_startColumn;
00156 }
00157
00158 void AST::setEndPosition(
int line,
int col )
00159 {
00160
m_endLine = line;
00161
m_endColumn = col;
00162 }
00163
00164 void AST::getEndPosition(
int* line,
int* col )
const
00165
{
00166
if( line )
00167 *line =
m_endLine;
00168
00169
if( col )
00170 * col =
m_endColumn;
00171 }
00172
00173 void AST::setParent(
AST* parent )
00174 {
00175
#ifndef CPPPARSER_NO_CHILDREN
00176
if(
m_parent )
00177
m_parent->
removeChild(
this );
00178
#endif
00179
00180
m_parent = parent;
00181
00182
#ifndef CPPPARSER_NO_CHILDREN
00183
if(
m_parent )
00184
m_parent->
appendChild(
this );
00185
#endif
00186
}
00187
00188
#ifndef CPPPARSER_NO_CHILDREN
00189 void AST::appendChild(
AST* child )
00190 {
00191
m_children.append( child );
00192 }
00193
00194 void AST::removeChild(
AST* child )
00195 {
00196
m_children.remove( child );
00197 }
00198
#endif
00199
00200
00201 NameAST::NameAST()
00202 : m_global( false )
00203 {
00204
m_classOrNamespaceNameList.setAutoDelete(
true );
00205 }
00206
00207 void NameAST::setGlobal(
bool b )
00208 {
00209
m_global = b;
00210 }
00211
00212 void NameAST::setUnqualifiedName(
ClassOrNamespaceNameAST::Node& unqualifiedName )
00213 {
00214
m_unqualifiedName = unqualifiedName;
00215
if(
m_unqualifiedName.get() )
m_unqualifiedName->setParent(
this );
00216 }
00217
00218 void NameAST::addClassOrNamespaceName( ClassOrNamespaceNameAST::Node& classOrNamespaceName )
00219 {
00220
if( !classOrNamespaceName.get() )
00221
return;
00222
00223 classOrNamespaceName->setParent(
this );
00224
m_classOrNamespaceNameList.append( classOrNamespaceName.release() );
00225 }
00226
00227 QString NameAST::text()
const
00228
{
00229
if( !
m_unqualifiedName.get() )
00230
return QString::null;
00231
00232
QString str;
00233
00234
if(
m_global )
00235 str +=
"::";
00236
00237
QStringList l;
00238
QPtrListIterator<ClassOrNamespaceNameAST> it(
m_classOrNamespaceNameList );
00239
while( it.current() ){
00240 str += it.current()->text() +
"::";
00241 ++it;
00242 }
00243
00244
if(
m_unqualifiedName.get() )
00245 str +=
m_unqualifiedName->text();
00246
00247
return str;
00248 }
00249
00250
00251 DeclarationAST::DeclarationAST()
00252 {
00253 }
00254
00255
00256 LinkageBodyAST::LinkageBodyAST()
00257 {
00258
m_declarationList.setAutoDelete(
true );
00259 }
00260
00261 void LinkageBodyAST::addDeclaration(
DeclarationAST::Node& ast )
00262 {
00263
if( !ast.get() )
00264
return;
00265
00266 ast->setParent(
this );
00267
m_declarationList.append( ast.release() );
00268 }
00269
00270
00271 LinkageSpecificationAST::LinkageSpecificationAST()
00272 {
00273 }
00274
00275 void LinkageSpecificationAST::setExternType(
AST::Node& externType )
00276 {
00277
m_externType = externType;
00278
if(
m_externType.get() )
m_externType->setParent(
this );
00279 }
00280
00281 void LinkageSpecificationAST::setLinkageBody(
LinkageBodyAST::Node& linkageBody )
00282 {
00283
m_linkageBody = linkageBody;
00284
if(
m_linkageBody.get() )
m_linkageBody->setParent(
this );
00285 }
00286
00287 void LinkageSpecificationAST::setDeclaration(
DeclarationAST::Node& decl )
00288 {
00289
m_declaration = decl;
00290
if(
m_declaration.get() )
m_declaration->setParent(
this );
00291 }
00292
00293
00294 TranslationUnitAST::TranslationUnitAST()
00295 {
00296
00297
m_declarationList.setAutoDelete(
true );
00298 }
00299
00300 void TranslationUnitAST::addDeclaration(
DeclarationAST::Node& ast )
00301 {
00302
if( !ast.get() )
00303
return;
00304
00305 ast->setParent(
this );
00306
m_declarationList.append( ast.release() );
00307 }
00308
00309
00310 NamespaceAST::NamespaceAST()
00311 {
00312 }
00313
00314 void NamespaceAST::setNamespaceName(
AST::Node& namespaceName )
00315 {
00316
m_namespaceName = namespaceName;
00317
if(
m_namespaceName.get() )
m_namespaceName->setParent(
this );
00318 }
00319
00320 void NamespaceAST::setLinkageBody(
LinkageBodyAST::Node& linkageBody )
00321 {
00322
m_linkageBody = linkageBody;
00323
if(
m_linkageBody.get() )
m_linkageBody->setParent(
this );
00324 }
00325
00326
00327
00328 NamespaceAliasAST::NamespaceAliasAST()
00329 {
00330 }
00331
00332 void NamespaceAliasAST::setNamespaceName(
AST::Node& namespaceName )
00333 {
00334
m_namespaceName = namespaceName;
00335
if(
m_namespaceName.get() )
m_namespaceName->setParent(
this );
00336 }
00337
00338 void NamespaceAliasAST::setAliasName(
NameAST::Node& name )
00339 {
00340
m_aliasName = name;
00341
if(
m_aliasName.get() )
m_aliasName->setParent(
this );
00342 }
00343
00344
00345 UsingAST::UsingAST()
00346 {
00347 }
00348
00349 void UsingAST::setTypeName(
AST::Node& typeName )
00350 {
00351
m_typeName = typeName;
00352
if(
m_typeName.get() )
m_typeName->setParent(
this );
00353 }
00354
00355 void UsingAST::setName(
NameAST::Node& name )
00356 {
00357
m_name = name;
00358
if(
m_name.get() )
m_name->setParent(
this );
00359 }
00360
00361
00362 UsingDirectiveAST::UsingDirectiveAST()
00363 {
00364 }
00365
00366 void UsingDirectiveAST::setName(
NameAST::Node& name )
00367 {
00368
m_name = name;
00369
if(
m_name.get() )
m_name->setParent(
this );
00370 }
00371
00372 TypedefAST::TypedefAST()
00373 {
00374 }
00375
00376 void TypeSpecifierAST::setName(
NameAST::Node& name )
00377 {
00378
m_name = name;
00379
if(
m_name.get() )
m_name->setParent(
this );
00380 }
00381
00382 void TypedefAST::setTypeSpec(
TypeSpecifierAST::Node& typeSpec )
00383 {
00384
m_typeSpec = typeSpec;
00385
if(
m_typeSpec.get() )
m_typeSpec->setParent(
this );
00386 }
00387
00388 void TypedefAST::setInitDeclaratorList(
InitDeclaratorListAST::Node& initDeclaratorList )
00389 {
00390
m_initDeclaratorList = initDeclaratorList;
00391
if(
m_initDeclaratorList.get() )
m_initDeclaratorList->setParent(
this );
00392 }
00393
00394
00395 TemplateArgumentListAST::TemplateArgumentListAST()
00396 {
00397
m_argumentList.setAutoDelete(
true );
00398 }
00399
00400 void TemplateArgumentListAST::addArgument(
AST::Node& arg )
00401 {
00402
if( !arg.get() )
00403
return;
00404
00405 arg->setParent(
this );
00406
m_argumentList.append( arg.release() );
00407 }
00408
00409 QString TemplateArgumentListAST::text()
const
00410
{
00411
QStringList l;
00412
00413
QPtrListIterator<AST> it(
m_argumentList );
00414
while( it.current() ){
00415 l.append( it.current()->text() );
00416 ++it;
00417 }
00418
00419
return l.join(
", " );
00420 }
00421
00422
00423 TemplateDeclarationAST::TemplateDeclarationAST()
00424 {
00425 }
00426
00427 void TemplateDeclarationAST::setExported(
AST::Node& exported )
00428 {
00429
m_exported = exported;
00430
if(
m_exported.get() )
m_exported->setParent(
this );
00431 }
00432
00433 void TemplateDeclarationAST::setTemplateParameterList(
TemplateParameterListAST::Node& templateParameterList )
00434 {
00435
m_templateParameterList = templateParameterList;
00436
if(
m_templateParameterList.get() )
m_templateParameterList->setParent(
this );
00437 }
00438
00439 void TemplateDeclarationAST::setDeclaration(
DeclarationAST::Node& declaration )
00440 {
00441
m_declaration = declaration;
00442
if(
m_declaration.get() )
m_declaration->setParent(
this );
00443 }
00444
00445
00446 ClassOrNamespaceNameAST::ClassOrNamespaceNameAST()
00447 {
00448 }
00449
00450 void ClassOrNamespaceNameAST::setName(
AST::Node& name )
00451 {
00452
m_name = name;
00453
if(
m_name.get() )
m_name->setParent(
this );
00454 }
00455
00456 void ClassOrNamespaceNameAST::setTemplateArgumentList(
TemplateArgumentListAST::Node& templateArgumentList )
00457 {
00458
m_templateArgumentList = templateArgumentList;
00459
if(
m_templateArgumentList.get() )
m_templateArgumentList->setParent(
this );
00460 }
00461
00462 QString ClassOrNamespaceNameAST::text()
const
00463
{
00464
if( !
m_name.get() )
00465
return QString::null;
00466
00467
QString str =
m_name->text();
00468
if(
m_templateArgumentList.get() )
00469 str += QString::fromLatin1(
"< ") +
m_templateArgumentList->text() + QString::fromLatin1(
" >");
00470
00471
return str;
00472 }
00473
00474
00475 TypeSpecifierAST::TypeSpecifierAST()
00476 {
00477 }
00478
00479 void TypeSpecifierAST::setCvQualify(
GroupAST::Node& cvQualify )
00480 {
00481
m_cvQualify = cvQualify;
00482
if(
m_cvQualify.get() )
m_cvQualify->setParent(
this );
00483 }
00484
00485 void TypeSpecifierAST::setCv2Qualify( GroupAST::Node& cv2Qualify )
00486 {
00487
m_cv2Qualify = cv2Qualify;
00488
if(
m_cv2Qualify.get() )
m_cv2Qualify->setParent(
this );
00489 }
00490
00491 QString TypeSpecifierAST::text()
const
00492
{
00493
QString str;
00494
00495
if(
m_cvQualify.get() )
00496 str +=
m_cvQualify->text() +
" ";
00497
00498
if(
m_name.get() )
00499 str +=
m_name->text();
00500
00501
if(
m_cv2Qualify.get() )
00502 str +=
QString(
" ") +
m_cv2Qualify->text();
00503
00504
return str;
00505 }
00506
00507
00508 ClassSpecifierAST::ClassSpecifierAST()
00509 {
00510
m_declarationList.setAutoDelete(
true );
00511 }
00512
00513 void ClassSpecifierAST::setClassKey(
AST::Node& classKey )
00514 {
00515
m_classKey = classKey;
00516
if(
m_classKey.get() )
m_classKey->setParent(
this );
00517 }
00518
00519 void ClassSpecifierAST::addDeclaration(
DeclarationAST::Node& declaration )
00520 {
00521
if( !declaration.get() )
00522
return;
00523
00524 declaration->setParent(
this );
00525
m_declarationList.append( declaration.release() );
00526 }
00527
00528 void ClassSpecifierAST::setBaseClause(
BaseClauseAST::Node& baseClause )
00529 {
00530
m_baseClause = baseClause;
00531
if(
m_baseClause.get() )
m_baseClause->setParent(
this );
00532 }
00533
00534
00535 EnumSpecifierAST::EnumSpecifierAST()
00536 {
00537
m_enumeratorList.setAutoDelete(
true );
00538 }
00539
00540 void EnumSpecifierAST::addEnumerator(
EnumeratorAST::Node& enumerator )
00541 {
00542
if( !enumerator.get() )
00543
return;
00544
00545 enumerator->setParent(
this );
00546
m_enumeratorList.append( enumerator.release() );
00547 }
00548
00549
00550
00551 ElaboratedTypeSpecifierAST::ElaboratedTypeSpecifierAST()
00552 {
00553 }
00554
00555 void ElaboratedTypeSpecifierAST::setKind(
AST::Node& kind )
00556 {
00557
m_kind = kind;
00558
if(
m_kind.get() )
m_kind->setParent(
this );
00559 }
00560
00561 QString ElaboratedTypeSpecifierAST::text()
const
00562
{
00563
if(
m_kind.get() )
00564
return m_kind->text() +
" " +
TypeSpecifierAST::text();
00565
00566
return TypeSpecifierAST::text();
00567 }
00568
00569
00570 StatementAST::StatementAST()
00571 {
00572 }
00573
00574
00575 EnumeratorAST::EnumeratorAST()
00576 {
00577 }
00578
00579 void EnumeratorAST::setId(
AST::Node&
id )
00580 {
00581
m_id =
id;
00582
if(
m_id.get() )
m_id->setParent(
this );
00583 }
00584
00585 void EnumeratorAST::setExpr( AST::Node& expr )
00586 {
00587
m_expr = expr;
00588
if(
m_expr.get() )
m_expr->setParent(
this );
00589 }
00590
00591
00592 BaseClauseAST::BaseClauseAST()
00593 {
00594
m_baseSpecifierList.setAutoDelete(
true );
00595 }
00596
00597 void BaseClauseAST::addBaseSpecifier(
BaseSpecifierAST::Node& baseSpecifier )
00598 {
00599
if( !baseSpecifier.get() )
00600
return;
00601
00602 baseSpecifier->setParent(
this );
00603
m_baseSpecifierList.append( baseSpecifier.release() );
00604 }
00605
00606
00607 BaseSpecifierAST::BaseSpecifierAST()
00608 {
00609 }
00610
00611 void BaseSpecifierAST::setIsVirtual(
AST::Node& isVirtual )
00612 {
00613
m_isVirtual = isVirtual;
00614
if(
m_isVirtual.get() )
m_isVirtual->setParent(
this );
00615 }
00616
00617 void BaseSpecifierAST::setAccess( AST::Node& access )
00618 {
00619
m_access = access;
00620
if(
m_access.get() )
m_access->setParent(
this );
00621 }
00622
00623 void BaseSpecifierAST::setName(
NameAST::Node& name )
00624 {
00625
m_name = name;
00626
if(
m_name.get() )
m_name->setParent(
this );
00627 }
00628
00629
00630 SimpleDeclarationAST::SimpleDeclarationAST()
00631 {
00632 }
00633
00634 void SimpleDeclarationAST::setFunctionSpecifier(
GroupAST::Node& functionSpecifier )
00635 {
00636
m_functionSpecifier = functionSpecifier;
00637
if(
m_functionSpecifier.get() )
m_functionSpecifier->setParent(
this );
00638 }
00639
00640 void SimpleDeclarationAST::setStorageSpecifier( GroupAST::Node& storageSpecifier )
00641 {
00642
m_storageSpecifier = storageSpecifier;
00643
if(
m_storageSpecifier.get() )
m_storageSpecifier->setParent(
this );
00644 }
00645
00646 void SimpleDeclarationAST::setTypeSpec(
TypeSpecifierAST::Node& typeSpec )
00647 {
00648
m_typeSpec = typeSpec;
00649
if(
m_typeSpec.get() )
m_typeSpec->setParent(
this );
00650 }
00651
00652 void SimpleDeclarationAST::setInitDeclaratorList(
InitDeclaratorListAST::Node& initDeclaratorList )
00653 {
00654
m_initDeclaratorList = initDeclaratorList;
00655
if(
m_initDeclaratorList.get() )
m_initDeclaratorList->setParent(
this );
00656 }
00657
00658 void SimpleDeclarationAST::setWinDeclSpec( GroupAST::Node& winDeclSpec )
00659 {
00660
m_winDeclSpec = winDeclSpec;
00661
if(
m_winDeclSpec.get() )
m_winDeclSpec->setParent(
this );
00662 }
00663
00664
00665
00666 InitDeclaratorListAST::InitDeclaratorListAST()
00667 {
00668
m_initDeclaratorList.setAutoDelete(
true );
00669 }
00670
00671 void InitDeclaratorListAST::addInitDeclarator(
InitDeclaratorAST::Node& decl )
00672 {
00673
if( !decl.get() )
00674
return;
00675
00676 decl->setParent(
this );
00677
m_initDeclaratorList.append( decl.release() );
00678 }
00679
00680
00681 DeclaratorAST::DeclaratorAST()
00682 {
00683
m_ptrOpList.setAutoDelete(
true );
00684
m_arrayDimensionList.setAutoDelete(
true );
00685 }
00686
00687
void DeclaratorAST::setSubDeclarator(
DeclaratorAST::Node& subDeclarator )
00688 {
00689 m_subDeclarator = subDeclarator;
00690
if( m_subDeclarator.get() ) m_subDeclarator->setParent(
this );
00691 }
00692
00693 void DeclaratorAST::setDeclaratorId(
NameAST::Node& declaratorId )
00694 {
00695
m_declaratorId = declaratorId;
00696
if(
m_declaratorId.get() )
m_declaratorId->setParent(
this );
00697 }
00698
00699 void DeclaratorAST::setBitfieldInitialization(
AST::Node& bitfieldInitialization )
00700 {
00701
m_bitfieldInitialization = bitfieldInitialization;
00702
if(
m_bitfieldInitialization.get() )
m_bitfieldInitialization->setParent(
this );
00703 }
00704
00705 void DeclaratorAST::addArrayDimension( AST::Node& arrayDimension )
00706 {
00707
if( !arrayDimension.get() )
00708
return;
00709
00710 arrayDimension->setParent(
this );
00711
m_arrayDimensionList.append( arrayDimension.release() );
00712 }
00713
00714
void DeclaratorAST::setParameterDeclarationClause(
ParameterDeclarationClauseAST::Node& parameterDeclarationClause )
00715 {
00716 m_parameterDeclarationClause = parameterDeclarationClause;
00717
if( m_parameterDeclarationClause.get() ) m_parameterDeclarationClause->setParent(
this );
00718 }
00719
00720 void DeclaratorAST::setConstant( AST::Node& constant )
00721 {
00722
m_constant = constant;
00723
if(
m_constant.get() )
m_constant->setParent(
this );
00724 }
00725
00726 void DeclaratorAST::setExceptionSpecification(
GroupAST::Node& exceptionSpecification )
00727 {
00728
m_exceptionSpecification = exceptionSpecification;
00729
if(
m_exceptionSpecification.get() )
m_exceptionSpecification->setParent(
this );
00730 }
00731
00732 void DeclaratorAST::addPtrOp( AST::Node& ptrOp )
00733 {
00734
if( !ptrOp.get() )
00735
return;
00736
00737 ptrOp->setParent(
this );
00738
m_ptrOpList.append( ptrOp.release() );
00739 }
00740
00741
00742 InitDeclaratorAST::InitDeclaratorAST()
00743 {
00744 }
00745
00746 void InitDeclaratorAST::setDeclarator(
DeclaratorAST::Node& declarator )
00747 {
00748
m_declarator = declarator;
00749
if(
m_declarator.get() )
m_declarator->setParent(
this );
00750 }
00751
00752 void InitDeclaratorAST::setInitializer(
AST::Node& initializer )
00753 {
00754
m_initializer = initializer;
00755
if(
m_initializer.get() )
m_initializer->setParent(
this );
00756 }
00757
00758
00759 FunctionDefinitionAST::FunctionDefinitionAST()
00760 {
00761 }
00762
00763 void FunctionDefinitionAST::setFunctionSpecifier(
GroupAST::Node& functionSpecifier )
00764 {
00765
m_functionSpecifier = functionSpecifier;
00766
if(
m_functionSpecifier.get() )
m_functionSpecifier->setParent(
this );
00767 }
00768
00769 void FunctionDefinitionAST::setStorageSpecifier( GroupAST::Node& storageSpecifier )
00770 {
00771
m_storageSpecifier = storageSpecifier;
00772
if(
m_storageSpecifier.get() )
m_storageSpecifier->setParent(
this );
00773 }
00774
00775 void FunctionDefinitionAST::setTypeSpec(
TypeSpecifierAST::Node& typeSpec )
00776 {
00777
m_typeSpec = typeSpec;
00778
if(
m_typeSpec.get() )
m_typeSpec->setParent(
this );
00779 }
00780
00781 void FunctionDefinitionAST::setInitDeclarator(
InitDeclaratorAST::Node& initDeclarator )
00782 {
00783
m_initDeclarator = initDeclarator;
00784
if(
m_initDeclarator.get() )
m_initDeclarator->setParent(
this );
00785 }
00786
00787 void FunctionDefinitionAST::setFunctionBody(
StatementListAST::Node& functionBody )
00788 {
00789
m_functionBody = functionBody;
00790
if(
m_functionBody.get() )
m_functionBody->setParent(
this );
00791 }
00792
00793 void FunctionDefinitionAST::setWinDeclSpec( GroupAST::Node& winDeclSpec )
00794 {
00795
m_winDeclSpec = winDeclSpec;
00796
if(
m_winDeclSpec.get() )
m_winDeclSpec->setParent(
this );
00797 }
00798
00799
00800 StatementListAST::StatementListAST()
00801 {
00802
m_statementList.setAutoDelete(
true );
00803 }
00804
00805 void StatementListAST::addStatement(
StatementAST::Node& statement )
00806 {
00807
if( !statement.get() )
00808
return;
00809
00810 statement->setParent(
this );
00811
m_statementList.append( statement.release() );
00812 }
00813
00814
00815 IfStatementAST::IfStatementAST()
00816 {
00817 }
00818
00819 void IfStatementAST::setCondition(
ConditionAST::Node& condition )
00820 {
00821
m_condition = condition;
00822
if(
m_condition.get() )
m_condition->setParent(
this );
00823 }
00824
00825 void IfStatementAST::setStatement(
StatementAST::Node& statement )
00826 {
00827
m_statement = statement;
00828
if(
m_statement.get() )
m_statement->setParent(
this );
00829 }
00830
00831 void IfStatementAST::setElseStatement( StatementAST::Node& elseStatement )
00832 {
00833
m_elseStatement = elseStatement;
00834
if(
m_elseStatement.get() )
m_elseStatement->setParent(
this );
00835 }
00836
00837
00838 WhileStatementAST::WhileStatementAST()
00839 {
00840 }
00841
00842 void WhileStatementAST::setCondition(
ConditionAST::Node& condition )
00843 {
00844
m_condition = condition;
00845
if(
m_condition.get() )
m_condition->setParent(
this );
00846 }
00847
00848 void WhileStatementAST::setStatement(
StatementAST::Node& statement )
00849 {
00850
m_statement = statement;
00851
if(
m_statement.get() )
m_statement->setParent(
this );
00852 }
00853
00854
00855 DoStatementAST::DoStatementAST()
00856 {
00857 }
00858
00859 void DoStatementAST::setCondition(
ConditionAST::Node& condition )
00860 {
00861
m_condition = condition;
00862
if(
m_condition.get() )
m_condition->setParent(
this );
00863 }
00864
00865 void DoStatementAST::setStatement(
StatementAST::Node& statement )
00866 {
00867
m_statement = statement;
00868
if(
m_statement.get() )
m_statement->setParent(
this );
00869 }
00870
00871
00872 ForStatementAST::ForStatementAST()
00873 {
00874 }
00875
00876 void ForStatementAST::setCondition(
ConditionAST::Node& condition )
00877 {
00878
m_condition = condition;
00879
if(
m_condition.get() )
m_condition->setParent(
this );
00880 }
00881
00882 void ForStatementAST::setExpression(
AST::Node& expression )
00883 {
00884
m_expression = expression;
00885
if(
m_expression.get() )
m_expression->setParent(
this );
00886 }
00887
00888 void ForStatementAST::setStatement(
StatementAST::Node& statement )
00889 {
00890
m_statement = statement;
00891
if(
m_statement.get() )
m_statement->setParent(
this );
00892 }
00893
00894 void ForStatementAST::setInitStatement( StatementAST::Node& initStatement )
00895 {
00896
m_initStatement = initStatement;
00897
if(
m_initStatement.get() )
m_initStatement->setParent(
this );
00898 }
00899
00900
00901 SwitchStatementAST::SwitchStatementAST()
00902 {
00903 }
00904
00905 void SwitchStatementAST::setCondition(
ConditionAST::Node& condition )
00906 {
00907
m_condition = condition;
00908
if(
m_condition.get() )
m_condition->setParent(
this );
00909 }
00910
00911 void SwitchStatementAST::setStatement(
StatementAST::Node& statement )
00912 {
00913
m_statement = statement;
00914
if(
m_statement.get() )
m_statement->setParent(
this );
00915 }
00916
00917
00918 DeclarationStatementAST::DeclarationStatementAST()
00919 {
00920 }
00921
00922 void DeclarationStatementAST::setDeclaration(
DeclarationAST::Node& declaration )
00923 {
00924
m_declaration = declaration;
00925
if(
m_declaration.get() )
m_declaration->setParent(
this );
00926 }
00927
00928
00929 ExpressionStatementAST::ExpressionStatementAST()
00930 {
00931 }
00932
00933 void ExpressionStatementAST::setExpression(
AST::Node& expression )
00934 {
00935
m_expression = expression;
00936
if(
m_expression.get() )
m_expression->setParent(
this );
00937 }
00938
00939
00940
00941 ParameterDeclarationAST::ParameterDeclarationAST()
00942 {
00943 }
00944
00945 void ParameterDeclarationAST::setTypeSpec(
TypeSpecifierAST::Node& typeSpec )
00946 {
00947
m_typeSpec = typeSpec;
00948
if(
m_typeSpec.get() )
m_typeSpec->setParent(
this );
00949 }
00950
00951 void ParameterDeclarationAST::setDeclarator(
DeclaratorAST::Node& declarator )
00952 {
00953
m_declarator = declarator;
00954
if(
m_declarator.get() )
m_declarator->setParent(
this );
00955 }
00956
00957 void ParameterDeclarationAST::setExpression(
AST::Node& expression )
00958 {
00959
m_expression = expression;
00960
if(
m_expression.get() )
m_expression->setParent(
this );
00961 }
00962
00963 QString ParameterDeclarationAST::text()
const
00964
{
00965
QString str;
00966
if(
m_typeSpec.get() )
00967 str +=
m_typeSpec->text() +
" ";
00968
00969
if(
m_declarator.get() )
00970 str +=
m_declarator->text();
00971
00972
if(
m_expression.get() )
00973 str +=
QString(
" = " ) +
m_expression->text();
00974
00975
return str;
00976 }
00977
00978
00979 ParameterDeclarationListAST::ParameterDeclarationListAST()
00980 {
00981
m_parameterList.setAutoDelete(
true );
00982 }
00983
00984 void ParameterDeclarationListAST::addParameter(
ParameterDeclarationAST::Node& parameter )
00985 {
00986
if( !parameter.get() )
00987
return;
00988
00989 parameter->setParent(
this );
00990
m_parameterList.append( parameter.release() );
00991 }
00992
00993 QString ParameterDeclarationListAST::text()
const
00994
{
00995
QStringList l;
00996
00997
QPtrListIterator<ParameterDeclarationAST> it(
m_parameterList );
00998
while( it.current() ){
00999 l.append( it.current()->text() );
01000 ++it;
01001 }
01002
01003
return l.join(
", " );
01004 }
01005
01006
01007
01008 ParameterDeclarationClauseAST::ParameterDeclarationClauseAST()
01009 {
01010 }
01011
01012 void ParameterDeclarationClauseAST::setParameterDeclarationList(
ParameterDeclarationListAST::Node& parameterDeclarationList )
01013 {
01014
m_parameterDeclarationList = parameterDeclarationList;
01015
if(
m_parameterDeclarationList.get() )
m_parameterDeclarationList->setParent(
this );
01016 }
01017
01018 void ParameterDeclarationClauseAST::setEllipsis(
AST::Node& ellipsis )
01019 {
01020
m_ellipsis = ellipsis;
01021
if(
m_ellipsis.get() )
m_ellipsis->setParent(
this );
01022 }
01023
01024 QString ParameterDeclarationClauseAST::text()
const
01025
{
01026
QString str;
01027
01028
if(
m_parameterDeclarationList.get() )
01029 str +=
m_parameterDeclarationList->text();
01030
01031
if(
m_ellipsis.get() )
01032 str +=
" ...";
01033
01034
return str;
01035 }
01036
01037
01038
01039 GroupAST::GroupAST()
01040 {
01041
m_nodeList.setAutoDelete(
true );
01042 }
01043
01044 void GroupAST::addNode(
AST::Node& node )
01045 {
01046
if( !node.get() )
01047
return;
01048
01049 node->setParent(
this );
01050
m_nodeList.append( node.release() );
01051 }
01052
01053 QString GroupAST::text()
const
01054
{
01055
QStringList l;
01056
01057
QPtrListIterator<AST> it(
m_nodeList );
01058
while( it.current() ){
01059 l.append( it.current()->text() );
01060 ++it;
01061 }
01062
01063
return l.join(
" " );
01064 }
01065
01066
01067 AccessDeclarationAST::AccessDeclarationAST()
01068 {
01069
m_accessList.setAutoDelete(
true );
01070 }
01071
01072 void AccessDeclarationAST::addAccess(
AST::Node& access )
01073 {
01074
if( !access.get() )
01075
return;
01076
01077 access->setParent(
this );
01078
m_accessList.append( access.release() );
01079 }
01080
01081 QString AccessDeclarationAST::text()
const
01082
{
01083
QStringList l;
01084
01085
QPtrListIterator<AST> it(
m_accessList );
01086
while( it.current() ){
01087 l.append( it.current()->text() );
01088 ++it;
01089 }
01090
01091
return l.join(
" " );
01092 }
01093
01094
01095 TypeParameterAST::TypeParameterAST()
01096 {
01097 }
01098
01099 void TypeParameterAST::setKind(
AST::Node& kind )
01100 {
01101
m_kind = kind;
01102
if(
m_kind.get() )
m_kind->setParent(
this );
01103 }
01104
01105
void TypeParameterAST::setTemplateParameterList(
TemplateParameterListAST::Node& templateParameterList )
01106 {
01107 m_templateParameterList = templateParameterList;
01108
if( m_templateParameterList.get() ) m_templateParameterList->setParent(
this );
01109 }
01110
01111 void TypeParameterAST::setName(
NameAST::Node& name )
01112 {
01113
m_name = name;
01114
if(
m_name.get() )
m_name->setParent(
this );
01115 }
01116
01117 void TypeParameterAST::setTypeId( AST::Node& typeId )
01118 {
01119
m_typeId = typeId;
01120
if(
m_typeId.get() )
m_typeId->setParent(
this );
01121 }
01122
01123
01124 TemplateParameterAST::TemplateParameterAST()
01125 {
01126 }
01127
01128 void TemplateParameterAST::setTypeParameter(
TypeParameterAST::Node& typeParameter )
01129 {
01130
m_typeParameter = typeParameter;
01131
if(
m_typeParameter.get() )
m_typeParameter->setParent(
this );
01132 }
01133
01134 void TemplateParameterAST::setTypeValueParameter(
ParameterDeclarationAST::Node& typeValueParameter )
01135 {
01136
m_typeValueParameter = typeValueParameter;
01137
if(
m_typeValueParameter.get() )
m_typeValueParameter->setParent(
this );
01138 }
01139
01140
01141 TemplateParameterListAST::TemplateParameterListAST()
01142 {
01143
m_templateParameterList.setAutoDelete(
true );
01144 }
01145
01146 void TemplateParameterListAST::addTemplateParameter(
TemplateParameterAST::Node& templateParameter )
01147 {
01148
if( !templateParameter.get() )
01149
return;
01150
01151 templateParameter->setParent(
this );
01152
m_templateParameterList.append( templateParameter.release() );
01153 }
01154
01155
01156 ConditionAST::ConditionAST()
01157 {
01158 }
01159
01160 void ConditionAST::setTypeSpec(
TypeSpecifierAST::Node& typeSpec )
01161 {
01162
m_typeSpec = typeSpec;
01163
if(
m_typeSpec.get() )
m_typeSpec->setParent(
this );
01164 }
01165
01166 void ConditionAST::setDeclarator(
DeclaratorAST::Node& declarator )
01167 {
01168
m_declarator = declarator;
01169
if(
m_declarator.get() )
m_declarator->setParent(
this );
01170 }
01171
01172 void ConditionAST::setExpression(
AST::Node& expression )
01173 {
01174
m_expression = expression;
01175
if(
m_expression.get() )
m_expression->setParent(
this );
01176 }
01177
01178 void ClassSpecifierAST::setWinDeclSpec(
GroupAST::Node & winDeclSpec )
01179 {
01180
m_winDeclSpec = winDeclSpec;
01181
if(
m_winDeclSpec.get() )
m_winDeclSpec->setParent(
this );
01182 }
01183