| /**************************************************************************** |
| ** |
| ** Copyright (C) 2001-2004 Roberto Raggi |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the qt3to4 porting application of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "ast.h" |
| #include <QStringList> |
| #include <stdio.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| int AST::N = 0; |
| |
| // ------------------------------------------------------------------------ |
| AST::AST(int startToken, int count) |
| : m_scope(0), |
| m_startToken(startToken), |
| m_endToken(startToken + count), |
| m_parent(0), |
| m_children(0) |
| { |
| ++N; |
| } |
| |
| void AST::setParent(AST *parent) |
| { |
| if (m_parent) |
| m_parent->removeChild(this); |
| |
| m_parent = parent; |
| |
| if (m_parent) |
| m_parent->appendChild(this); |
| } |
| |
| void AST::appendChild(AST *child) |
| { |
| m_children = snoc(m_children, child, _pool); |
| } |
| |
| void AST::removeChild(AST *child) |
| { |
| fprintf(stderr, "AST::removeChild child: %p not implemented yet\n", child); |
| } |
| |
| // ------------------------------------------------------------------------ |
| NameAST::NameAST() |
| : m_global(false), m_unqualifiedName(0), m_classOrNamespaceNameList(0) |
| { |
| } |
| |
| void NameAST::setGlobal(bool b) |
| { |
| m_global = b; |
| } |
| |
| void NameAST::setUnqualifiedName(ClassOrNamespaceNameAST *unqualifiedName) |
| { |
| m_unqualifiedName = unqualifiedName; |
| if (m_unqualifiedName) m_unqualifiedName->setParent(this); |
| } |
| |
| void NameAST::addClassOrNamespaceName(ClassOrNamespaceNameAST *classOrNamespaceName) |
| { |
| if(!classOrNamespaceName) |
| return; |
| |
| classOrNamespaceName->setParent(this); |
| m_classOrNamespaceNameList = snoc(m_classOrNamespaceNameList, classOrNamespaceName, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| DeclarationAST::DeclarationAST() |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| LinkageBodyAST::LinkageBodyAST() |
| : m_declarationList(0) |
| { |
| } |
| |
| void LinkageBodyAST::addDeclaration(DeclarationAST *ast) |
| { |
| if(!ast) |
| return; |
| |
| ast->setParent(this); |
| m_declarationList = snoc(m_declarationList, ast, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| LinkageSpecificationAST::LinkageSpecificationAST() |
| : m_externType(0), |
| m_linkageBody(0), |
| m_declaration(0) |
| { |
| } |
| |
| void LinkageSpecificationAST::setExternType(AST *externType) |
| { |
| m_externType = externType; |
| if (m_externType) m_externType->setParent(this); |
| } |
| |
| void LinkageSpecificationAST::setLinkageBody(LinkageBodyAST *linkageBody) |
| { |
| m_linkageBody = linkageBody; |
| if (m_linkageBody) m_linkageBody->setParent(this); |
| } |
| |
| void LinkageSpecificationAST::setDeclaration(DeclarationAST *decl) |
| { |
| m_declaration = decl; |
| if (m_declaration) m_declaration->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| TranslationUnitAST::TranslationUnitAST() |
| : m_declarationList(0) |
| { |
| //kdDebug(9007) << "++ TranslationUnitAST::TranslationUnitAST()" << endl; |
| } |
| |
| void TranslationUnitAST::addDeclaration(DeclarationAST *ast) |
| { |
| if(!ast) |
| return; |
| |
| ast->setParent(this); |
| m_declarationList = snoc(m_declarationList, ast, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| NamespaceAST::NamespaceAST() |
| : m_namespaceName(0), |
| m_linkageBody(0) |
| { |
| } |
| |
| void NamespaceAST::setNamespaceName(AST *namespaceName) |
| { |
| m_namespaceName = namespaceName; |
| if (m_namespaceName) m_namespaceName->setParent(this); |
| } |
| |
| void NamespaceAST::setLinkageBody(LinkageBodyAST *linkageBody) |
| { |
| m_linkageBody = linkageBody; |
| if (m_linkageBody) m_linkageBody->setParent(this); |
| } |
| |
| |
| // ------------------------------------------------------------------------ |
| NamespaceAliasAST::NamespaceAliasAST() |
| : m_namespaceName(0), |
| m_aliasName(0) |
| { |
| } |
| |
| void NamespaceAliasAST::setNamespaceName(AST *namespaceName) |
| { |
| m_namespaceName = namespaceName; |
| if (m_namespaceName) m_namespaceName->setParent(this); |
| } |
| |
| void NamespaceAliasAST::setAliasName(NameAST *name) |
| { |
| m_aliasName = name; |
| if (m_aliasName) m_aliasName->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| UsingAST::UsingAST() |
| : m_typeName(0), |
| m_name(0) |
| { |
| } |
| |
| void UsingAST::setTypeName(AST *typeName) |
| { |
| m_typeName = typeName; |
| if (m_typeName) m_typeName->setParent(this); |
| } |
| |
| void UsingAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| UsingDirectiveAST::UsingDirectiveAST() |
| : m_name(0) |
| { |
| } |
| |
| void UsingDirectiveAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| TypedefAST::TypedefAST() |
| : m_typeSpec(0), |
| m_initDeclaratorList(0) |
| { |
| } |
| |
| void TypeSpecifierAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| void TypedefAST::setTypeSpec(TypeSpecifierAST *typeSpec) |
| { |
| m_typeSpec = typeSpec; |
| if (m_typeSpec) m_typeSpec->setParent(this); |
| } |
| |
| void TypedefAST::setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList) |
| { |
| m_initDeclaratorList = initDeclaratorList; |
| if (m_initDeclaratorList) m_initDeclaratorList->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| TemplateArgumentListAST::TemplateArgumentListAST() |
| : m_argumentList(0) |
| { |
| } |
| |
| void TemplateArgumentListAST::addArgument(AST *arg) |
| { |
| if(!arg) |
| return; |
| |
| arg->setParent(this); |
| m_argumentList = snoc(m_argumentList, arg, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| TemplateDeclarationAST::TemplateDeclarationAST() |
| : m_exported(0), |
| m_templateParameterList(0), |
| m_declaration(0) |
| { |
| } |
| |
| void TemplateDeclarationAST::setExported(AST *exported) |
| { |
| m_exported = exported; |
| if (m_exported) m_exported->setParent(this); |
| } |
| |
| void TemplateDeclarationAST::setTemplateParameterList(TemplateParameterListAST *templateParameterList) |
| { |
| m_templateParameterList = templateParameterList; |
| if (m_templateParameterList) m_templateParameterList->setParent(this); |
| } |
| |
| void TemplateDeclarationAST::setDeclaration(DeclarationAST *declaration) |
| { |
| m_declaration = declaration; |
| if (m_declaration) m_declaration->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| ClassOrNamespaceNameAST::ClassOrNamespaceNameAST() |
| : m_name(0), m_templateArgumentList(0) |
| { |
| } |
| |
| void ClassOrNamespaceNameAST::setName(AST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| void ClassOrNamespaceNameAST::setTemplateArgumentList(TemplateArgumentListAST *templateArgumentList) |
| { |
| m_templateArgumentList = templateArgumentList; |
| if (m_templateArgumentList) m_templateArgumentList->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| TypeSpecifierAST::TypeSpecifierAST() |
| : m_name(0), m_cvQualify(0), m_cv2Qualify(0) |
| |
| { |
| } |
| |
| void TypeSpecifierAST::setCvQualify(AST *cvQualify) |
| { |
| m_cvQualify = cvQualify; |
| if (m_cvQualify) m_cvQualify->setParent(this); |
| } |
| |
| void TypeSpecifierAST::setCv2Qualify(AST *cv2Qualify) |
| { |
| m_cv2Qualify = cv2Qualify; |
| if (m_cv2Qualify) m_cv2Qualify->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| ClassSpecifierAST::ClassSpecifierAST() |
| : m_winDeclSpec(0), |
| m_classKey(0), |
| m_baseClause(0), |
| m_declarationList(0) |
| { |
| } |
| |
| void ClassSpecifierAST::setClassKey(AST *classKey) |
| { |
| m_classKey = classKey; |
| if (m_classKey) m_classKey->setParent(this); |
| } |
| |
| void ClassSpecifierAST::addDeclaration(DeclarationAST *declaration) |
| { |
| if(!declaration) |
| return; |
| |
| declaration->setParent(this); |
| m_declarationList = snoc(m_declarationList, declaration, _pool); |
| } |
| |
| void ClassSpecifierAST::setBaseClause(BaseClauseAST *baseClause) |
| { |
| m_baseClause = baseClause; |
| if (m_baseClause) m_baseClause->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| EnumSpecifierAST::EnumSpecifierAST() |
| : m_enumeratorList(0) |
| { |
| } |
| |
| void EnumSpecifierAST::addEnumerator(EnumeratorAST *enumerator) |
| { |
| if(!enumerator) |
| return; |
| |
| enumerator->setParent(this); |
| m_enumeratorList = snoc(m_enumeratorList, enumerator, _pool); |
| } |
| |
| |
| // ------------------------------------------------------------------------ |
| ElaboratedTypeSpecifierAST::ElaboratedTypeSpecifierAST() |
| : m_kind(0) |
| { |
| } |
| |
| void ElaboratedTypeSpecifierAST::setKind(AST *kind) |
| { |
| m_kind = kind; |
| if (m_kind) m_kind->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| EnumeratorAST::EnumeratorAST() |
| : m_id(0), |
| m_expression(0) |
| { |
| } |
| |
| void EnumeratorAST::setId(AST *id) |
| { |
| m_id = id; |
| if (m_id) m_id->setParent(this); |
| } |
| |
| void EnumeratorAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| BaseClauseAST::BaseClauseAST() |
| : m_baseSpecifierList(0) |
| { |
| } |
| |
| void BaseClauseAST::addBaseSpecifier(BaseSpecifierAST *baseSpecifier) |
| { |
| if(!baseSpecifier) |
| return; |
| |
| baseSpecifier->setParent(this); |
| m_baseSpecifierList = snoc(m_baseSpecifierList, baseSpecifier, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| BaseSpecifierAST::BaseSpecifierAST() |
| : m_isVirtual(0), m_access(0), m_name(0) |
| |
| { |
| } |
| |
| void BaseSpecifierAST::setIsVirtual(AST *isVirtual) |
| { |
| m_isVirtual = isVirtual; |
| if (m_isVirtual) m_isVirtual->setParent(this); |
| } |
| |
| void BaseSpecifierAST::setAccess(AST *access) |
| { |
| m_access = access; |
| if (m_access) m_access->setParent(this); |
| } |
| |
| void BaseSpecifierAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| SimpleDeclarationAST::SimpleDeclarationAST() |
| : m_functionSpecifier(0), |
| m_storageSpecifier(0), |
| m_typeSpec(0), |
| m_initDeclaratorList(0), |
| m_winDeclSpec(0) |
| { |
| } |
| |
| void SimpleDeclarationAST::setFunctionSpecifier(AST *functionSpecifier) |
| { |
| m_functionSpecifier = functionSpecifier; |
| if (m_functionSpecifier) m_functionSpecifier->setParent(this); |
| } |
| |
| void SimpleDeclarationAST::setStorageSpecifier(AST *storageSpecifier) |
| { |
| m_storageSpecifier = storageSpecifier; |
| if (m_storageSpecifier) m_storageSpecifier->setParent(this); |
| } |
| |
| void SimpleDeclarationAST::setTypeSpec(TypeSpecifierAST *typeSpec) |
| { |
| m_typeSpec = typeSpec; |
| if (m_typeSpec) m_typeSpec->setParent(this); |
| } |
| |
| void SimpleDeclarationAST::setInitDeclaratorList(InitDeclaratorListAST *initDeclaratorList) |
| { |
| m_initDeclaratorList = initDeclaratorList; |
| if (m_initDeclaratorList) m_initDeclaratorList->setParent(this); |
| } |
| |
| void SimpleDeclarationAST::setWinDeclSpec(AST *winDeclSpec) |
| { |
| m_winDeclSpec = winDeclSpec; |
| if (m_winDeclSpec) m_winDeclSpec->setParent(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| InitDeclaratorListAST::InitDeclaratorListAST() |
| : m_initDeclaratorList(0) |
| { |
| } |
| |
| void InitDeclaratorListAST::addInitDeclarator(InitDeclaratorAST *decl) |
| { |
| if(!decl) |
| return; |
| |
| decl->setParent(this); |
| m_initDeclaratorList = snoc(m_initDeclaratorList, decl, _pool); |
| } |
| |
| // ------------------------------------------------------------------------ |
| DeclaratorAST::DeclaratorAST() |
| : m_ptrOpList(0), |
| m_subDeclarator(0), |
| m_declaratorId(0), |
| m_bitfieldInitialization(0), |
| m_arrayDimensionList(0), |
| m_parameterDeclarationClause(0), |
| m_constant(0), |
| m_exceptionSpecification(0) |
| { |
| } |
| |
| void DeclaratorAST::setSubDeclarator(DeclaratorAST *subDeclarator) |
| { |
| m_subDeclarator = subDeclarator; |
| if (m_subDeclarator) m_subDeclarator->setParent(this); |
| } |
| |
| void DeclaratorAST::setDeclaratorId(NameAST *declaratorId) |
| { |
| m_declaratorId = declaratorId; |
| if (m_declaratorId) m_declaratorId->setParent(this); |
| } |
| |
| void DeclaratorAST::setBitfieldInitialization(AST *bitfieldInitialization) |
| { |
| m_bitfieldInitialization = bitfieldInitialization; |
| if (m_bitfieldInitialization) m_bitfieldInitialization->setParent(this); |
| } |
| |
| void DeclaratorAST::addArrayDimension(AST *arrayDimension) |
| { |
| if(!arrayDimension) |
| return; |
| |
| arrayDimension->setParent(this); |
| m_arrayDimensionList = snoc(m_arrayDimensionList, arrayDimension, _pool); |
| } |
| |
| void DeclaratorAST::setParameterDeclarationClause(ParameterDeclarationClauseAST *parameterDeclarationClause) |
| { |
| m_parameterDeclarationClause = parameterDeclarationClause; |
| if (m_parameterDeclarationClause) m_parameterDeclarationClause->setParent(this); |
| } |
| |
| void DeclaratorAST::setConstant(AST *constant) |
| { |
| m_constant = constant; |
| if (m_constant) m_constant->setParent(this); |
| } |
| |
| void DeclaratorAST::setExceptionSpecification(AST *exceptionSpecification) |
| { |
| m_exceptionSpecification = exceptionSpecification; |
| if (m_exceptionSpecification) m_exceptionSpecification->setParent(this); |
| } |
| |
| void DeclaratorAST::addPtrOp(AST *ptrOp) |
| { |
| if(!ptrOp) |
| return; |
| |
| ptrOp->setParent(this); |
| m_ptrOpList = snoc(m_ptrOpList, ptrOp, _pool); |
| } |
| |
| // -------------------------------------------------------------------------- |
| InitDeclaratorAST::InitDeclaratorAST() |
| : m_declarator(0), |
| m_initializer(0) |
| { |
| } |
| |
| void InitDeclaratorAST::setDeclarator(DeclaratorAST *declarator) |
| { |
| m_declarator = declarator; |
| if (m_declarator) m_declarator->setParent(this); |
| } |
| |
| void InitDeclaratorAST::setInitializer(AST *initializer) |
| { |
| m_initializer = initializer; |
| if (m_initializer) m_initializer->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| FunctionDefinitionAST::FunctionDefinitionAST() |
| : m_functionSpecifier(0), |
| m_storageSpecifier(0), |
| m_typeSpec(0), |
| m_initDeclarator(0), |
| m_functionBody(0), |
| m_winDeclSpec(0) |
| { |
| } |
| |
| void FunctionDefinitionAST::setFunctionSpecifier(AST *functionSpecifier) |
| { |
| m_functionSpecifier = functionSpecifier; |
| if (m_functionSpecifier) m_functionSpecifier->setParent(this); |
| } |
| |
| void FunctionDefinitionAST::setStorageSpecifier(AST *storageSpecifier) |
| { |
| m_storageSpecifier = storageSpecifier; |
| if (m_storageSpecifier) m_storageSpecifier->setParent(this); |
| } |
| |
| void FunctionDefinitionAST::setTypeSpec(TypeSpecifierAST *typeSpec) |
| { |
| m_typeSpec = typeSpec; |
| if (m_typeSpec) m_typeSpec->setParent(this); |
| } |
| |
| void FunctionDefinitionAST::setInitDeclarator(InitDeclaratorAST *initDeclarator) |
| { |
| m_initDeclarator = initDeclarator; |
| if (m_initDeclarator) m_initDeclarator->setParent(this); |
| } |
| |
| void FunctionDefinitionAST::setFunctionBody(StatementListAST *functionBody) |
| { |
| m_functionBody = functionBody; |
| if (m_functionBody) m_functionBody->setParent(this); |
| } |
| |
| void FunctionDefinitionAST::setWinDeclSpec(AST *winDeclSpec) |
| { |
| m_winDeclSpec = winDeclSpec; |
| if (m_winDeclSpec) m_winDeclSpec->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| StatementListAST::StatementListAST() |
| : m_statementList(0) |
| { |
| } |
| |
| void StatementListAST::addStatement(StatementAST *statement) |
| { |
| if(!statement) |
| return; |
| |
| statement->setParent(this); |
| m_statementList = snoc(m_statementList, statement, _pool); |
| } |
| |
| // -------------------------------------------------------------------------- |
| IfStatementAST::IfStatementAST() |
| : m_condition(0), |
| m_statement(0), |
| m_elseStatement(0) |
| { |
| } |
| |
| void IfStatementAST::setCondition(ConditionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) m_condition->setParent(this); |
| } |
| |
| void IfStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| void IfStatementAST::setElseStatement(StatementAST *elseStatement) |
| { |
| m_elseStatement = elseStatement; |
| if (m_elseStatement) m_elseStatement->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| WhileStatementAST::WhileStatementAST() |
| : m_condition(0), |
| m_statement(0) |
| { |
| } |
| |
| void WhileStatementAST::setCondition(ConditionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) m_condition->setParent(this); |
| } |
| |
| void WhileStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| DoStatementAST::DoStatementAST() |
| : m_condition(0), |
| m_statement(0) |
| { |
| } |
| |
| void DoStatementAST::setCondition(ConditionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) m_condition->setParent(this); |
| } |
| |
| void DoStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ForStatementAST::ForStatementAST() |
| : m_condition(0), |
| m_initStatement(0), |
| m_statement(0), |
| m_expression(0) |
| { |
| } |
| |
| void ForStatementAST::setCondition(ConditionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) m_condition->setParent(this); |
| } |
| |
| void ForStatementAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| void ForStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| void ForStatementAST::setInitStatement(StatementAST *initStatement) |
| { |
| m_initStatement = initStatement; |
| if (m_initStatement) m_initStatement->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| SwitchStatementAST::SwitchStatementAST() |
| : m_condition(0), |
| m_statement(0) |
| { |
| } |
| |
| void SwitchStatementAST::setCondition(ConditionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) m_condition->setParent(this); |
| } |
| |
| void SwitchStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| DeclarationStatementAST::DeclarationStatementAST() |
| : m_declaration(0) |
| { |
| } |
| |
| void DeclarationStatementAST::setDeclaration(DeclarationAST *declaration) |
| { |
| m_declaration = declaration; |
| if (m_declaration) m_declaration->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| LabeledStatementAST::LabeledStatementAST() |
| : m_statement(0), m_expression(0) |
| { |
| } |
| |
| void LabeledStatementAST::setStatement(StatementAST *statement) |
| { |
| m_statement = statement; |
| if (m_statement) m_statement->setParent(this); |
| } |
| |
| void LabeledStatementAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ExpressionStatementAST::ExpressionStatementAST() |
| : m_expression(0) |
| { |
| } |
| |
| void ExpressionStatementAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| |
| // -------------------------------------------------------------------------- |
| ParameterDeclarationAST::ParameterDeclarationAST() |
| : m_typeSpec(0), |
| m_declarator(0), |
| m_expression(0) |
| { |
| } |
| |
| void ParameterDeclarationAST::setTypeSpec(TypeSpecifierAST *typeSpec) |
| { |
| m_typeSpec = typeSpec; |
| if (m_typeSpec) m_typeSpec->setParent(this); |
| } |
| |
| void ParameterDeclarationAST::setDeclarator(DeclaratorAST *declarator) |
| { |
| m_declarator = declarator; |
| if (m_declarator) m_declarator->setParent(this); |
| } |
| |
| void ParameterDeclarationAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ParameterDeclarationListAST::ParameterDeclarationListAST() |
| : m_parameterList(0) |
| { |
| } |
| |
| void ParameterDeclarationListAST::addParameter(ParameterDeclarationAST *parameter) |
| { |
| if(!parameter) |
| return; |
| |
| parameter->setParent(this); |
| m_parameterList = snoc(m_parameterList, parameter, _pool); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ParameterDeclarationClauseAST::ParameterDeclarationClauseAST() |
| : m_parameterDeclarationList(0), |
| m_ellipsis(0) |
| { |
| } |
| |
| void ParameterDeclarationClauseAST::setParameterDeclarationList(ParameterDeclarationListAST *parameterDeclarationList) |
| { |
| m_parameterDeclarationList = parameterDeclarationList; |
| if (m_parameterDeclarationList) m_parameterDeclarationList->setParent(this); |
| } |
| |
| void ParameterDeclarationClauseAST::setEllipsis(AST *ellipsis) |
| { |
| m_ellipsis = ellipsis; |
| if (m_ellipsis) m_ellipsis->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| AccessDeclarationAST::AccessDeclarationAST() |
| : m_accessList(0) |
| { |
| } |
| |
| void AccessDeclarationAST::addAccess(AST *access) |
| { |
| if(!access) |
| return; |
| |
| access->setParent(this); |
| m_accessList = snoc(m_accessList, access, _pool); |
| } |
| |
| // -------------------------------------------------------------------------- |
| TypeParameterAST::TypeParameterAST() |
| : m_kind(0), m_templateParameterList(0), |
| m_name(0), m_typeId(0) |
| |
| { |
| } |
| |
| void TypeParameterAST::setKind(AST *kind) |
| { |
| m_kind = kind; |
| } |
| |
| void TypeParameterAST::setTemplateParameterList(TemplateParameterListAST *templateParameterList) |
| { |
| m_templateParameterList = templateParameterList; |
| if (m_templateParameterList) m_templateParameterList->setParent(this); |
| } |
| |
| void TypeParameterAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) m_name->setParent(this); |
| } |
| |
| void TypeParameterAST::setTypeId(AST *typeId) |
| { |
| m_typeId = typeId; |
| if (m_typeId) m_typeId->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| TemplateParameterAST::TemplateParameterAST() |
| : m_typeParameter(0), |
| m_typeValueParameter(0) |
| { |
| } |
| |
| void TemplateParameterAST::setTypeParameter(TypeParameterAST *typeParameter) |
| { |
| m_typeParameter = typeParameter; |
| if (m_typeParameter) m_typeParameter->setParent(this); |
| } |
| |
| void TemplateParameterAST::setTypeValueParameter(ParameterDeclarationAST *typeValueParameter) |
| { |
| m_typeValueParameter = typeValueParameter; |
| if (m_typeValueParameter) m_typeValueParameter->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| TemplateParameterListAST::TemplateParameterListAST() |
| : m_templateParameterList(0) |
| { |
| } |
| |
| void TemplateParameterListAST::addTemplateParameter(TemplateParameterAST *templateParameter) |
| { |
| if(!templateParameter) |
| return; |
| |
| templateParameter->setParent(this); |
| m_templateParameterList = snoc(m_templateParameterList, templateParameter, _pool); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ConditionAST::ConditionAST() |
| : m_typeSpec(0), |
| m_declarator(0), |
| m_expression(0) |
| { |
| } |
| |
| void ConditionAST::setTypeSpec(TypeSpecifierAST *typeSpec) |
| { |
| m_typeSpec = typeSpec; |
| if (m_typeSpec) m_typeSpec->setParent(this); |
| } |
| |
| void ConditionAST::setDeclarator(DeclaratorAST *declarator) |
| { |
| m_declarator = declarator; |
| if (m_declarator) m_declarator->setParent(this); |
| } |
| |
| void ConditionAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| void ClassSpecifierAST::setWinDeclSpec(AST *winDeclSpec) |
| { |
| m_winDeclSpec = winDeclSpec; |
| if (m_winDeclSpec) m_winDeclSpec->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ReturnStatementAST::ReturnStatementAST() |
| : m_expression(0) |
| { |
| } |
| |
| void ReturnStatementAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| BinaryExpressionAST::BinaryExpressionAST() |
| : m_op(0), m_left(0), m_right(0) |
| { |
| } |
| |
| void BinaryExpressionAST::setOp(AST *op) |
| { |
| m_op = op; |
| if (m_op) |
| m_op->setParent(this); |
| } |
| |
| void BinaryExpressionAST::setLeftExpression(AbstractExpressionAST *left) |
| { |
| m_left = left; |
| if (m_left) |
| m_left->setParent(this); |
| } |
| |
| void BinaryExpressionAST::setRightExpression(AbstractExpressionAST *right) |
| { |
| m_right = right; |
| if (m_right) |
| m_right->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ConditionalExpressionAST::ConditionalExpressionAST() |
| : m_condition(0), m_left(0), m_right(0) |
| { |
| } |
| |
| void ConditionalExpressionAST::setCondition(AbstractExpressionAST *condition) |
| { |
| m_condition = condition; |
| if (m_condition) |
| m_condition->setParent(this); |
| } |
| |
| void ConditionalExpressionAST::setLeftExpression(AbstractExpressionAST *left) |
| { |
| m_left = left; |
| if (m_left) |
| m_left->setParent(this); |
| } |
| |
| void ConditionalExpressionAST::setRightExpression(AbstractExpressionAST *right) |
| { |
| m_right = right; |
| if (m_right) |
| m_right->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| CppCastExpressionAST::CppCastExpressionAST() |
| : m_castOp(0), m_typeId(0), m_expression(0) |
| { |
| } |
| |
| void CppCastExpressionAST::setCastOp(AST *castOp) |
| { |
| m_castOp = castOp; |
| if (m_castOp) |
| m_castOp->setParent(this); |
| } |
| |
| void CppCastExpressionAST::setTypeId(AST *typeId) |
| { |
| m_typeId = typeId; |
| if (m_typeId) |
| m_typeId->setParent(this); |
| } |
| |
| void CppCastExpressionAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) |
| m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| SubscriptingAST::SubscriptingAST() |
| : m_expression(0), m_subscript(0) |
| { |
| } |
| |
| void SubscriptingAST::setSubscript(AbstractExpressionAST *subscript) |
| { |
| m_subscript = subscript; |
| if (m_subscript) |
| m_subscript->setParent(this); |
| } |
| |
| void SubscriptingAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) |
| m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| FunctionCallAST::FunctionCallAST() |
| : m_expression(0), m_arguments(0) |
| { |
| } |
| |
| void FunctionCallAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) |
| m_expression->setParent(this); |
| } |
| |
| void FunctionCallAST::setArguments(AbstractExpressionAST *arguments) |
| { |
| m_arguments = arguments; |
| if (m_arguments) |
| m_arguments->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| ExplicitTypeConversionAST::ExplicitTypeConversionAST() |
| { |
| } |
| |
| // -------------------------------------------------------------------------- |
| PseudoDestructorCallAST::PseudoDestructorCallAST() |
| { |
| } |
| |
| // -------------------------------------------------------------------------- |
| ClassMemberAccessAST::ClassMemberAccessAST() |
| : m_op(0), m_expression(0), m_templ(0), m_name(0) |
| { |
| } |
| |
| void ClassMemberAccessAST::setOp(AST *op) |
| { |
| m_op = op; |
| if (m_op) |
| m_op->setParent(this); |
| } |
| |
| void ClassMemberAccessAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) |
| m_expression->setParent(this); |
| } |
| |
| void ClassMemberAccessAST::setName(NameAST *name) |
| { |
| m_name = name; |
| if (m_name) |
| m_name->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| IncrDecrAST::IncrDecrAST() |
| : m_op(0), m_expression(0) |
| { |
| } |
| |
| void IncrDecrAST::setOp(AST *op) |
| { |
| m_op = op; |
| if (m_op) |
| m_op->setParent(this); |
| } |
| |
| void IncrDecrAST::setExpression(AbstractExpressionAST *expression) |
| { |
| m_expression = expression; |
| if (m_expression) |
| m_expression->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| TypeIdentificationAST::TypeIdentificationAST() |
| { |
| } |
| |
| // -------------------------------------------------------------------------- |
| TypeIdAST::TypeIdAST() |
| : m_typeSpecifier(0), m_declarator(0) |
| { |
| } |
| |
| void TypeIdAST::setTypeSpecifier(TypeSpecifierAST *typeSpecifier) |
| { |
| m_typeSpecifier = typeSpecifier; |
| if (m_typeSpecifier) |
| m_typeSpecifier->setParent(this); |
| } |
| |
| void TypeIdAST::setDeclarator(DeclaratorAST *declarator) |
| { |
| m_declarator = declarator; |
| if (m_declarator) |
| m_declarator->setParent(this); |
| } |
| |
| // -------------------------------------------------------------------------- |
| AbstractExpressionAST::AbstractExpressionAST() |
| { |
| m_symbol = 0; |
| } |
| |
| QT_END_NAMESPACE |