source: translator/Parser/DeclarationNode.cc @ d9a0e76

#include <string>
#include <list>
#include <iterator>
#include <algorithm>
#include <cassert>

#include "ParseNode.h"
#include "TypeData.h"
#include "utility.h"
#include "SynTree/Declaration.h"
#include "SynTree/Expression.h"
#include "SynTree/Initializer.h"
#include "SemanticError.h"
#include "UniqueName.h"
#include "LinkageSpec.h"

using namespace std;

/* these must remain in the same order as the corresponding DeclarationNode enumerations */
const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue" };
const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "bool", "complex", "imaginary" };
const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
const char *DeclarationNode::tyConName[] = { "struct", "union", "context" };
const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };

UniqueName DeclarationNode::anonymous( "__anonymous" );

extern LinkageSpec::Type linkage;               /* defined in cfa.y */

DeclarationNode *DeclarationNode::clone() const {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = maybeClone( type );
    newnode->name = name;
    newnode->storageClasses = storageClasses;
    newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    newnode->hasEllipsis = hasEllipsis;
    newnode->initializer = initializer;
    newnode->next = maybeClone( next );
    newnode->linkage = linkage;
    return newnode;
}

DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
}

DeclarationNode::~DeclarationNode() {
    delete type;
    delete bitfieldWidth;
    delete initializer;
}

bool DeclarationNode::get_hasEllipsis() const {
    return hasEllipsis;
}

const char *storageClassName[] = {
    // order must correspond with DeclarationNode::StorageClass
    "static",
    "auto",
    "extern",
    "register",
    "inline",
    "fortran",
};

void DeclarationNode::print( std::ostream &os, int indent ) const {
    os << string(indent, ' ' );
    if ( name == "" ) {
///     os << "An unnamed ";
    } else {
        os << name << ": a ";
    }

    if ( linkage != LinkageSpec::Cforall ) {
        os << LinkageSpec::toString( linkage ) << " ";
    }

    printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
    if ( type ) {
        type->print( os, indent );
    } else {
        os << "untyped entity ";
    }

    if ( bitfieldWidth ) {
        os << endl << string(indent+2,  ' ') << "with bitfield width ";
        bitfieldWidth->printOneLine( os );
    }

    if ( initializer != 0 ) {
        os << endl << string(indent+2,  ' ') << "with initializer ";
        initializer->printOneLine( os );
    }

    os << endl;
}

void DeclarationNode::printList( std::ostream &os, int indent ) const {
    ParseNode::printList( os, indent );
    if ( hasEllipsis ) {
        os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
    }
}

DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );

    newnode->type = new TypeData( TypeData::Function );
    newnode->type->function->params = param;
    newnode->type->function->newStyle = newStyle;
    newnode->type->function->body = body;

    if ( body ) {
        newnode->type->function->hasBody = true;
    }

    if ( ret ) {
        newnode->type->base = ret->type;
        ret->type = 0;
        delete ret;
    }

    return newnode;
}

DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData();
    newnode->type->qualifiers.push_back( q );
    return newnode;
}

DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->storageClasses.push_back( sc );
    return newnode;
}

DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Basic );
    newnode->type->basic->typeSpec.push_back( bt );
    return newnode;
}

DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Basic );
    newnode->type->basic->modifiers.push_back( mod );
    return newnode;
}

DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Unknown );
    newnode->type->forall = forall;
    return newnode;
}

DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::SymbolicInst );
    newnode->type->symbolic->name = assign_strptr( name );
    newnode->type->symbolic->isTypedef = true;
    newnode->type->symbolic->params = 0;
    return newnode;
}

DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Aggregate );
    newnode->type->aggregate->kind = kind;
    newnode->type->aggregate->name = assign_strptr( name );
    if ( newnode->type->aggregate->name == "" ) {
        newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
    }
    newnode->type->aggregate->params = formals;
    newnode->type->aggregate->actuals = actuals;
    newnode->type->aggregate->members = fields;
    return newnode;
}

DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );
    newnode->type = new TypeData( TypeData::Enum );
    newnode->type->enumeration->name = newnode->name;
    if ( newnode->type->enumeration->name == "" ) {
        newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
    }
    newnode->type->enumeration->constants = constants;
    return newnode;
}

DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );
    // do something with the constant
    return newnode;
}

DeclarationNode *DeclarationNode::newName( std::string* name ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );
    return newnode;
}

DeclarationNode *DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::SymbolicInst );
    newnode->type->symbolic->name = assign_strptr( name );
    newnode->type->symbolic->isTypedef = false;
    newnode->type->symbolic->actuals = params;
    return newnode;
}

DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );
    newnode->type = new TypeData( TypeData::Variable );
    newnode->type->variable->tyClass = tc;
    newnode->type->variable->name = newnode->name;
    return newnode;
}

DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Aggregate );
    newnode->type->aggregate->kind = Context;
    newnode->type->aggregate->params = params;
    newnode->type->aggregate->members = asserts;
    newnode->type->aggregate->name = assign_strptr( name );
    return newnode;
}

DeclarationNode *DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::AggregateInst );
    newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
    newnode->type->aggInst->aggregate->aggregate->kind = Context;
    newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
    newnode->type->aggInst->params = params;
    return newnode;
}

DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->name = assign_strptr( name );
    newnode->type = new TypeData( TypeData::Symbolic );
    newnode->type->symbolic->isTypedef = false;
    newnode->type->symbolic->params = typeParams;
    newnode->type->symbolic->name = newnode->name;
    return newnode;
}

DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Pointer );
    return newnode->addQualifiers( qualifiers );
}

DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Array );
    newnode->type->array->dimension = size;
    newnode->type->array->isStatic = isStatic;
    newnode->type->array->isVarLen = false;
    return newnode->addQualifiers( qualifiers );
}

DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Array );
    newnode->type->array->dimension = 0;
    newnode->type->array->isStatic = false;
    newnode->type->array->isVarLen = true;
    return newnode->addQualifiers( qualifiers );
}

DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->bitfieldWidth = size;
    return newnode;
}

DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Tuple );
    newnode->type->tuple->members = members;
    return newnode;
}

DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Typeof );
    newnode->type->typeexpr->expr = expr;
    return newnode;
}

DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Attr );
    newnode->type->attr->name = assign_strptr( name );
    newnode->type->attr->expr = expr;
    return newnode;
}

DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = new TypeData( TypeData::Attr );
    newnode->type->attr->name = assign_strptr( name );
    newnode->type->attr->type = type;
    return newnode;
}

static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
    if ( src && dst ) {
        if ( src->forall && dst->kind == TypeData::Function ) {
            if ( dst->forall ) {
                dst->forall->appendList( src->forall );
            } else {
                dst->forall = src->forall;
            }
            src->forall = 0;
        }
        if ( dst->base ) {
            addQualifiersToType( src, dst->base );
        } else if ( dst->kind == TypeData::Function ) {
            dst->base = src;
            src = 0;
        } else {
            dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
        }
    }
}
      
DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
    if ( q ) {
        storageClasses.splice( storageClasses.end(), q->storageClasses );
        if ( q->type ) {
            if ( ! type ) {
                type = new TypeData;
            }
            addQualifiersToType( q->type, type );
            if ( q->type && q->type->forall ) {
                if ( type->forall ) {
                    type->forall->appendList( q->type->forall );
                } else {
                    type->forall = q->type->forall;
                }
                q->type->forall = 0;
            }
        }
    }
    delete q;
    return this;
}

DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
    storageClasses = q->storageClasses;
    return this;
}

static void addTypeToType( TypeData *&src, TypeData *&dst ) {
    if ( src && dst ) {
        if ( src->forall && dst->kind == TypeData::Function ) {
            if ( dst->forall ) {
                dst->forall->appendList( src->forall );
            } else {
                dst->forall = src->forall;
            }
            src->forall = 0;
        }
        if ( dst->base ) {
            addTypeToType( src, dst->base );
        } else {
            switch ( dst->kind ) {
              case TypeData::Unknown:
                src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
                dst = src;
                src = 0;
                break;

              case TypeData::Basic:
                dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
                if ( src->kind != TypeData::Unknown ) {
                    assert( src->kind == TypeData::Basic );
                    dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
                    dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
                }
                break;

              default:
                switch ( src->kind ) {
                  case TypeData::Aggregate:
                  case TypeData::Enum:
                    dst->base = new TypeData( TypeData::AggregateInst );
                    dst->base->aggInst->aggregate = src;
                    if ( src->kind == TypeData::Aggregate ) {
                        dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
                    }
                    dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
                    src = 0;
                    break;
          
                  default:
                    if ( dst->forall ) {
                        dst->forall->appendList( src->forall );
                    } else {
                        dst->forall = src->forall;
                    }
                    src->forall = 0;
                    dst->base = src;
                    src = 0;
                }
            }
        }
    }
}

DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
    if ( o ) {
        storageClasses.splice( storageClasses.end(), o->storageClasses );
        if ( o->type ) {
            if ( ! type ) {
                if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
                    type = new TypeData( TypeData::AggregateInst );
                    type->aggInst->aggregate = o->type;
                    if ( o->type->kind == TypeData::Aggregate ) {
                        type->aggInst->params = maybeClone( o->type->aggregate->actuals );
                    }
                    type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
                } else {
                    type = o->type;
                }
                o->type = 0;
            } else {
                addTypeToType( o->type, type );
            }
        }
        if ( o->bitfieldWidth ) {
            bitfieldWidth = o->bitfieldWidth;
        }
    }
    delete o;
    return this;
}

DeclarationNode *DeclarationNode::addTypedef() {
    TypeData *newtype = new TypeData( TypeData::Symbolic );
    newtype->symbolic->params = 0;
    newtype->symbolic->isTypedef = true;
    newtype->symbolic->name = name;
    newtype->base = type;
    type = newtype;
    return this;
}

DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
    assert( type );
    switch ( type->kind ) {
      case TypeData::Symbolic:
        if ( type->symbolic->assertions ) {
            type->symbolic->assertions->appendList( assertions );
        } else {
            type->symbolic->assertions = assertions;
        }
        break;
    
      case TypeData::Variable:
        if ( type->variable->assertions ) {
            type->variable->assertions->appendList( assertions );
        } else {
            type->variable->assertions = assertions;
        }
        break;
    
      default:
        assert( false );
    }
    
    return this;
}

DeclarationNode *DeclarationNode::addName( std::string* newname ) {
    name = assign_strptr( newname );
    return this;
}

DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
    bitfieldWidth = size;
    return this;
}

DeclarationNode *DeclarationNode::addVarArgs() {
    assert( type );
    hasEllipsis = true;
    return this;
}

DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
    assert( type );
    assert( type->kind == TypeData::Function );
    assert( type->function->body == 0 );
    type->function->body = body;
    type->function->hasBody = true;
    return this;
}

DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
    assert( type );
    assert( type->kind == TypeData::Function );
    assert( type->function->oldDeclList == 0 );
    type->function->oldDeclList = list;
    return this;
}

static void
setBase( TypeData *&type, TypeData *newType ) {
    if ( type ) {
        TypeData *prevBase = type;
        TypeData *curBase = type->base;
        while( curBase != 0 ) {
            prevBase = curBase;
            curBase = curBase->base;
        }
        prevBase->base = newType;
    } else {
        type = newType;
    }
}

DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
    if ( p ) {
        assert( p->type->kind == TypeData::Pointer );
        setBase( type, p->type );
        p->type = 0;
        delete p;
    }
    return this;
}

DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
    if ( a ) {
        assert( a->type->kind == TypeData::Array );
        setBase( type, a->type );
        a->type = 0;
        delete a;
    }
    return this;
}

DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
    if ( p ) {
        assert( p->type->kind == TypeData::Pointer );
        if ( type ) {
            switch ( type->kind ) {
              case TypeData::Aggregate:
              case TypeData::Enum:
                p->type->base = new TypeData( TypeData::AggregateInst );
                p->type->base->aggInst->aggregate = type;
                if ( type->kind == TypeData::Aggregate ) {
                    p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
                }
                p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
                break;
        
              default:
                p->type->base = type;
            }
            type = 0;
        }
        delete this;
        return p;
    } else {
        return this;
    }
}

static TypeData *findLast( TypeData *a ) {
    assert( a );
    TypeData *cur = a;
    while( cur->base ) {
        cur = cur->base;
    }
    return cur;
}

DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
    if ( a ) {
        assert( a->type->kind == TypeData::Array );
        TypeData *lastArray = findLast( a->type );
        if ( type ) {  
            switch ( type->kind ) {
              case TypeData::Aggregate:
              case TypeData::Enum:
                lastArray->base = new TypeData( TypeData::AggregateInst );
                lastArray->base->aggInst->aggregate = type;
                if ( type->kind == TypeData::Aggregate ) {
                    lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
                }
                lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
                break;
        
              default:
                lastArray->base = type;
            }
            type = 0;
        }
        delete this;
        return a;
    } else {
        return this;
    }
}

DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
    TypeData *ftype = new TypeData( TypeData::Function );
    ftype->function->params = params;
    setBase( type, ftype );
    return this;
}

static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
    if ( type ) {
        if ( type->kind != TypeData::Function ) {
            type->base = addIdListToType( type->base, ids );
        } else {
            type->function->idList = ids;
        }
        return type;
    } else {
        TypeData *newtype = new TypeData( TypeData::Function );
        newtype->function->idList = ids;
        return newtype;
    }
}
    
DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
    type = addIdListToType( type, ids );
    return this;
}

DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
    //assert
    initializer = init;
    return this;
}

DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
    DeclarationNode *newnode = new DeclarationNode;
    TypeData *srcType = type;
    while( srcType->base ) {
        srcType = srcType->base;
    }
    newnode->type = maybeClone( srcType );
    if ( newnode->type->kind == TypeData::AggregateInst ) {
        // don't duplicate members
        if ( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
            delete newnode->type->aggInst->aggregate->enumeration->constants;
            newnode->type->aggInst->aggregate->enumeration->constants = 0;
        } else {
            assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
            delete newnode->type->aggInst->aggregate->aggregate->members;
            newnode->type->aggInst->aggregate->aggregate->members = 0;
        }
    }
    newnode->type->forall = maybeClone( type->forall );
    newnode->storageClasses = storageClasses;
    newnode->name = assign_strptr( newName );
    return newnode;
}

DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
    if ( o ) {
        o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
        if ( type ) {
            TypeData *srcType = type;
            while( srcType->base ) {
                srcType = srcType->base;
            }
            TypeData *newType = srcType->clone();
            if ( newType->kind == TypeData::AggregateInst ) {
                // don't duplicate members
                if ( newType->aggInst->aggregate->kind == TypeData::Enum ) {
                    delete newType->aggInst->aggregate->enumeration->constants;
                    newType->aggInst->aggregate->enumeration->constants = 0;
                } else {
                    assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
                    delete newType->aggInst->aggregate->aggregate->members;
                    newType->aggInst->aggregate->aggregate->members = 0;
                }
            }
            newType->forall = maybeClone( type->forall );
            if ( ! o->type ) {
                o->type = newType;
            } else {
                addTypeToType( newType, o->type );
                delete newType;
            }
        }
    }
    return o;
}

DeclarationNode *DeclarationNode::cloneType( string *newName ) {
    DeclarationNode *newnode = new DeclarationNode;
    newnode->type = maybeClone( type );
    newnode->storageClasses = storageClasses;
    newnode->name = assign_strptr( newName );
    return newnode;
}

DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
    if ( o ) {
        o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
        if ( type ) {
            TypeData *newType = type->clone();
            if ( ! o->type ) {
                o->type = newType;
            } else {
                addTypeToType( newType, o->type );
                delete newType;
            }
        }
    }
    return o;
}

DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
    if ( node != 0 ) {
        set_link( node );
    }
    return this;
}

DeclarationNode *DeclarationNode::extractAggregate() const {
    if ( type ) {
        TypeData *ret = type->extractAggregate();
        if ( ret ) {
            DeclarationNode *newnode = new DeclarationNode;
            newnode->type = ret;
            return newnode;
        } else {
            return 0;
        }
    } else {
        return 0;
    }
}

void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) {
    SemanticError errors;
    std::back_insert_iterator< std::list< Declaration* > > out( outputList );
    const DeclarationNode *cur = firstNode;
    while( cur ) {
        try {
            if ( DeclarationNode *extr = cur->extractAggregate() ) {
                // handle the case where a structure declaration is contained within an object or type
                // declaration
                Declaration *decl = extr->build();
                if ( decl ) {
                   *out++ = decl;
                }
            }
            Declaration *decl = cur->build();
            if ( decl ) {
                *out++ = decl;
            }
        } catch( SemanticError &e ) {
            errors.append( e );
        }
        cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    }
    if ( ! errors.isEmpty() ) {
        throw errors;
    }
}

void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) {
    SemanticError errors;
    std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
    const DeclarationNode *cur = firstNode;
    while( cur ) {
        try {
///       if ( DeclarationNode *extr = cur->extractAggregate() ) {
///     // handle the case where a structure declaration is contained within an object or type
///     // declaration
///     Declaration *decl = extr->build();
///     if ( decl ) {
///          *out++ = decl;
///     }
///       }
            Declaration *decl = cur->build();
            if ( decl ) {
                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
                   *out++ = dwt;
                } else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
                    StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
                   *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
                    delete agg;
                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
                    UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
                   *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
                }
            }
        } catch( SemanticError &e ) {
            errors.append( e );
        }
        cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    }
    if ( ! errors.isEmpty() ) {
        throw errors;
    }
}

void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) {
    SemanticError errors;
    std::back_insert_iterator< std::list< Type* > > out( outputList );
    const DeclarationNode *cur = firstNode;
    while( cur ) {
        try {
           *out++ = cur->buildType();
        } catch( SemanticError &e ) {
            errors.append( e );
        }
        cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    }
    if ( ! errors.isEmpty() ) {
        throw errors;
    }
}

Declaration *DeclarationNode::build() const {

    if ( ! type ) {
        if ( buildInline() ) {
            throw SemanticError( "invalid inline specification in declaration of ", this );
        } else {
            return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
        }
    } else {
        Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
        return newDecl;
    }
    // we should never get here
    assert( false );
    return 0;
}

Type *DeclarationNode::buildType() const {
    assert( type );
  
    switch ( type->kind ) {
      case TypeData::Enum:
        return new EnumInstType( type->buildQualifiers(), type->enumeration->name );
      case TypeData::Aggregate: {
          ReferenceToType *ret;
          switch ( type->aggregate->kind ) {
            case DeclarationNode::Struct:
              ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
              break;

            case DeclarationNode::Union:
              ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
              break;

            case DeclarationNode::Context:
              ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
              break;

            default:
              assert( false );
          }
          buildList( type->aggregate->actuals, ret->get_parameters() );
          return ret;
      }
      case TypeData::Symbolic: {
          TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false );
          buildList( type->symbolic->actuals, ret->get_parameters() );
          return ret;
      }
      default:
        return type->build();
    }
}

Declaration::StorageClass DeclarationNode::buildStorageClass() const {
    static const Declaration::StorageClass scMap[] = {  
        Declaration::Static,
        Declaration::Auto,
        Declaration::Extern,
        Declaration::Register,
        Declaration::NoStorageClass, // inline
        Declaration::Fortran
    };  
  
    Declaration::StorageClass ret = Declaration::NoStorageClass;
    for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
        assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
        if ( *i == Inline ) continue;
        if ( ret == Declaration::NoStorageClass ) {
            ret = scMap[ *i ];
        } else {
            throw SemanticError( "invalid combination of storage classes in declaration of ", this );
        }
    }
    return ret;
}

bool DeclarationNode::buildInline() const {
    std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
    if ( first == storageClasses.end() ) {
        return false;
    } else {
        std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
        if ( next == storageClasses.end() ) {
            return true;
        } else {
            throw SemanticError( "duplicate inline specification in declaration of ", this );
        }
    }
    // we should never get here
    return false;
}