ast.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

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;
}