source: translator/Parser/InitializerNode.cc @ 3848e0e

#include "ParseNode.h"
#include "SynTree/Expression.h"
#include "SynTree/Initializer.h"
#include "utility.h"
#include "SemanticError.h"
// #include <cstdlib> // for strtol
#include <cassert>


InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
        : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ) {
    if ( aggrp )
        kids = dynamic_cast< InitializerNode *>( get_link() );

    if ( kids != 0 )
        set_link( 0 );
}

InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
        : aggregate( aggrp ), designator( des ), kids( 0 ) {
    if ( init != 0 )
        set_link(init);

    if ( aggrp )
        kids = dynamic_cast< InitializerNode *>( get_link() );

    if ( kids != 0 )
        set_next( 0 );
}

InitializerNode::~InitializerNode() {
    delete expr;
}

void InitializerNode::print( std::ostream &os, int indent ) const {
    os << std::string(indent, ' ') << "Initializer expression" << std::endl;
}

void InitializerNode::printOneLine( std::ostream &os ) const {
    if ( ! aggregate ) {
        if ( designator != 0 ) {
            os << "designated by: (";
            ExpressionNode  *curdes = designator;
            while( curdes != 0) {
                curdes->printOneLine(os);
                curdes = (ExpressionNode *)(curdes->get_link());
                if ( curdes ) os << ", ";
            }
            os << ")";
        }
        if ( expr ) expr->printOneLine(os);
    } else {  // It's an aggregate
        os << "[--";
        if ( next_init() != 0 )
            next_init()->printOneLine(os);
        if (aggregate) os << "--]";
    }

    InitializerNode *moreInit;
    if  ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) )
        moreInit->printOneLine( os );
}

Initializer *InitializerNode::build() const {
    // if ( get_expression() == 0 ) return 0;  // XXX (?)

    if ( aggregate ) {
        assert( next_init() != 0 );

        std::list< Initializer *> initlist;
        buildList<Initializer, InitializerNode>( next_init(), initlist );

        std::list< Expression *> designlist;
        if ( designator != 0 )
            buildList<Expression, ExpressionNode>( designator, designlist );

        return new ListInit( initlist, designlist );
    } else {
        std::list< Expression *> designators;

        if ( designator != 0 )
            buildList<Expression, ExpressionNode>( designator, designators );

        if ( get_expression() != 0)
            return new SingleInit( get_expression()->build(), designators );
    }

    return 0;
}