source: translator/Parser/TypeData.cc @ 134b86a

#include <cassert>
#include <algorithm>
#include <iterator>
#include "utility.h"
#include "TypeData.h"
#include "SynTree/Type.h"
#include "SynTree/Declaration.h"
#include "SynTree/Expression.h"
#include "SynTree/Statement.h"


TypeData::TypeData( Kind k )
  : kind( k ), base( 0 ), forall( 0 )
{
  switch( kind ) {
  case Unknown:
  case Pointer:
  case EnumConstant:
    // nothing else to initialize
    break;

  case Basic:
    basic = new Basic_t;
    break;

  case Array:
    array = new Array_t;
    array->dimension = 0;
    array->isVarLen = false;
    array->isStatic = false;
    break;

  case Function:
    function = new Function_t;
    function->params = 0;
    function->idList = 0;
    function->oldDeclList = 0;
    function->body = 0;
    function->hasBody = false;
    break;

  case Aggregate:
    aggregate = new Aggregate_t;
    aggregate->params = 0;
    aggregate->actuals = 0;
    aggregate->members = 0;
    break;

  case AggregateInst:
    aggInst = new AggInst_t;
    aggInst->aggregate = 0;
    aggInst->params = 0;
    break;

  case Enum:
    enumeration = new Enumeration_t;
    enumeration->constants = 0;
    break;

  case Symbolic:
  case SymbolicInst:
    symbolic = new Symbolic_t;
    symbolic->params = 0;
    symbolic->actuals = 0;
    symbolic->assertions = 0;
    break;

  case Variable:
    variable = new Variable_t;
    variable->tyClass = DeclarationNode::Type;
    variable->assertions = 0;
    break;

  case Tuple:
    tuple = new Tuple_t;
    tuple->members = 0;
    break;
  
  case Typeof:
    typeexpr = new Typeof_t;
    typeexpr->expr = 0;
    break;
  
  case Attr:
    attr = new Attr_t;
    attr->expr = 0;
    attr->type = 0;
    break;
  }
}

TypeData::~TypeData()
{
  delete base;
  delete forall;

  switch( kind ) {
  case Unknown:
  case Pointer:
  case EnumConstant:
    // nothing to destroy
    break;

  case Basic:
    delete basic;
    break;

  case Array:
    delete array->dimension;
    delete array;
    break;

  case Function:
    delete function->params;
    delete function->idList;
    delete function->oldDeclList;
    delete function->body;
    delete function;
    break;

  case Aggregate:
    delete aggregate->params;
    delete aggregate->actuals;
    delete aggregate->members;
    delete aggregate;
    break;

  case AggregateInst:
    delete aggInst->aggregate;
    delete aggInst->params;
    delete aggInst;
    break;

  case Enum:
    delete enumeration->constants;
    delete enumeration;
    break;

  case Symbolic:
  case SymbolicInst:
    delete symbolic->params;
    delete symbolic->actuals;
    delete symbolic->assertions;
    delete symbolic;
    break;

  case Variable:
    delete variable->assertions;
    delete variable;
    break;

  case Tuple:
    delete tuple->members;
    delete tuple;
    break;
  
  case Typeof:
    delete typeexpr->expr;
    delete typeexpr;
    break;
  
  case Attr:
    delete attr->expr;
    delete attr->type;
    delete attr;
    break;
  }
}

TypeData *
TypeData::clone() const
{
  TypeData *newtype = new TypeData( kind );
  newtype->qualifiers = qualifiers;
  newtype->base = maybeClone( base );
  newtype->forall = maybeClone( forall );

  switch( kind ) {
  case Unknown:
  case EnumConstant:
  case Pointer:
    // nothing else to copy
    break;

  case Basic:
    newtype->basic->typeSpec = basic->typeSpec;
    newtype->basic->modifiers = basic->modifiers;
    break;

  case Array:
    newtype->array->dimension = maybeClone( array->dimension );
    newtype->array->isVarLen = array->isVarLen;
    newtype->array->isStatic = array->isStatic;
    break;

  case Function:
    newtype->function->params = maybeClone( function->params );
    newtype->function->idList = maybeClone( function->idList );
    newtype->function->oldDeclList = maybeClone( function->oldDeclList );
    newtype->function->body = maybeClone( function->body );
    newtype->function->hasBody = function->hasBody;
    newtype->function->newStyle = function->newStyle;
    break;

  case Aggregate:
    newtype->aggregate->params = maybeClone( aggregate->params );
    newtype->aggregate->actuals = maybeClone( aggregate->actuals );
    newtype->aggregate->members = maybeClone( aggregate->members );
    newtype->aggregate->name = aggregate->name;
    newtype->aggregate->kind = aggregate->kind;
    break;

  case AggregateInst:
    newtype->aggInst->aggregate = maybeClone( aggInst->aggregate );
    newtype->aggInst->params = maybeClone( aggInst->params );
    break;

  case Enum:
    newtype->enumeration->name = enumeration->name;
    newtype->enumeration->constants = maybeClone( enumeration->constants );
    break;

  case Symbolic:
  case SymbolicInst:
    newtype->symbolic->params = maybeClone( symbolic->params );
    newtype->symbolic->actuals = maybeClone( symbolic->actuals );
    newtype->symbolic->assertions = maybeClone( symbolic->assertions );
    newtype->symbolic->isTypedef = symbolic->isTypedef;
    newtype->symbolic->name = symbolic->name;
    break;

  case Variable:
    newtype->variable->assertions = maybeClone( variable->assertions );
    newtype->variable->name = variable->name;
    newtype->variable->tyClass = variable->tyClass;
    break;

  case Tuple:
    newtype->tuple->members = maybeClone( tuple->members );
    break;
    
  case Typeof:
    newtype->typeexpr->expr = maybeClone( typeexpr->expr );
    break;
  
  case Attr:
    newtype->attr->expr = maybeClone( attr->expr );
    newtype->attr->type = maybeClone( attr->type );
    break;
  }
  return newtype;
}

void 
TypeData::print( std::ostream &os, int indent ) const
{
  using std::endl;
  using std::string;

  printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os );

  if( forall ) {
    os << "forall " << endl;
    forall->printList( os, indent+4 );
  }

  switch( kind ) {
  case Unknown:
    os << "entity of unknown type ";
    break;

  case Pointer:
    os << "pointer ";
    if( base ) {
      os << "to ";
      base->print( os, indent );
    }
    break;

  case EnumConstant:
    os << "enumeration constant ";
    break;

  case Basic:
    printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os );
    printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os );
    break;

  case Array:
    if( array->isStatic ) {
      os << "static ";
    }
    if( array->dimension ) {
      os << "array of ";
      array->dimension->printOneLine( os, indent );
    } else if ( array->isVarLen ) {
      os << "variable-length array of ";
    } else {
      os << "open array of ";
    }
    if( base ) {
      base->print( os, indent );
    }
    break;

  case Function:
    os << "function" << endl;
    if ( function->params ) {
      os << string( indent+2, ' ' ) << "with parameters " << endl;
      function->params->printList( os, indent+4 );
    } else {
      os << string( indent+2, ' ' ) << "with no parameters " << endl;
    }
    if ( function->idList ) {
      os << string( indent+2, ' ' ) << "with old-style identifier list " << endl;
      function->idList->printList( os, indent+4 );
    }
    if ( function->oldDeclList ) {
      os << string( indent+2, ' ' ) << "with old-style declaration list " << endl;
      function->oldDeclList->printList( os, indent+4 );
    }
    os << string( indent+2, ' ' ) << "returning ";
    if ( base ) {
      base->print( os, indent+4 );
    } else {
      os << "nothing ";
    }
    os << endl;
    if ( function->hasBody ) {
      os << string( indent+2, ' ' ) << "with body " << endl;
    }
    if ( function->body ) {
      function->body->printList( os, indent+2 );
    }
    break;

  case Aggregate:
    os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl;
    if( aggregate->params ) {
      os << string( indent+2, ' ' ) << "with type parameters " << endl;
      aggregate->params->printList( os, indent+4 );
    }
    if( aggregate->actuals ) {
      os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl;
      aggregate->actuals->printList( os, indent+4 );
    }
    if( aggregate->members ) {
      os << string( indent+2, ' ' ) << "with members " << endl;
      aggregate->members->printList( os, indent+4 );
///     } else {
///       os << string( indent+2, ' ' ) << "with no members " << endl;
    }
    break;

  case AggregateInst:
    if( aggInst->aggregate ) {
      os << "instance of " ;
      aggInst->aggregate->print( os, indent );
    } else {
      os << "instance of an unspecified aggregate ";
    }
    if( aggInst->params ) {
      os << string( indent+2, ' ' ) << "with parameters " << endl;
      aggInst->params->printList( os, indent+2 );
    }
    break;

  case Enum:
    os << "enumeration ";
    if( enumeration->constants ) {
      os << "with constants" << endl;
      enumeration->constants->printList( os, indent+2 );
    }
    break;

  case SymbolicInst:
    os << "instance of type " << symbolic->name;
    if( symbolic->actuals ) {
      os << " with parameters" << endl;
      symbolic->actuals->printList( os, indent + 2 );
    }
    break;

  case Symbolic:
    if( symbolic->isTypedef ) {
      os << "typedef definition ";
    } else {
      os << "type definition ";
    }
    if( symbolic->params ) {
      os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
      symbolic->params->printList( os, indent + 2 );
    }
    if( symbolic->assertions ) {
      os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
      symbolic->assertions->printList( os, indent + 4 );
      os << string( indent+2, ' ' );
    }
    if( base ) {
      os << "for ";
      base->print( os, indent + 2 );
    }
    break;

  case Variable:
    os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable ";
    if( variable->assertions ) {
      os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
      variable->assertions->printList( os, indent + 4 );
      os << string( indent+2, ' ' );
    }
    break;

  case Tuple:
    os << "tuple ";
    if( tuple->members ) {
      os << "with members " << endl;
      tuple->members->printList( os, indent + 2 );
    }
    break;
    
  case Typeof:
    os << "type-of expression ";
    if( typeexpr->expr ) {
      typeexpr->expr->print( os, indent + 2 );
    }
    break;
    
  case Attr:
    os << "attribute type decl " << attr->name << " applied to ";
    if( attr->expr ) {
      attr->expr->print( os, indent + 2 );
    }
    if( attr->type ) {
      attr->type->print( os, indent + 2 );
    }
    break;
  }
}

TypeData *
TypeData::extractAggregate( bool toplevel ) const
{
  TypeData *ret = 0;

  switch( kind ) {
  case Aggregate:
    if( !toplevel && aggregate->members ) {
      ret = clone();
      ret->qualifiers.clear();
    }
    break;

  case Enum:
    if( !toplevel && enumeration->constants ) {
      ret = clone();
      ret->qualifiers.clear();
    }
    break;

  case AggregateInst:
    if( aggInst->aggregate ) {
      ret = aggInst->aggregate->extractAggregate( false );
    }
    break;

  default:
    if( base ) {
      ret = base->extractAggregate( false );
    }
  }
  return ret;
}

void
buildForall( const DeclarationNode *firstNode, std::list< TypeDecl* > &outputList )
{
  
  buildList( firstNode, outputList );
  for( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
    if( (*i)->get_kind() == TypeDecl::Any ) {
      FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
      assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
      assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
      assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
      (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall,  assignType, 0, false ) );
    }
  }
}

Declaration *
TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const
{

  if ( kind == TypeData::Function ) {
    FunctionDecl *decl;
    if( function->hasBody ) {
      if( function->body ) {
        Statement *stmt = function->body->build();
        CompoundStmt *body = dynamic_cast< CompoundStmt* >( stmt );
        assert( body );
        decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline );
      } else {
        // std::list<Label> ls;
        decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline );
      }
    } else {
      decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline );
    }
    for( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
      if( cur->get_name() != "" ) {
        decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
      }
    }
    buildList( function->oldDeclList, decl->get_oldDecls() );
    return decl;
  } else if ( kind == TypeData::Aggregate ) {
    return buildAggregate();
  } else if ( kind == TypeData::Enum ) {
    return buildEnum();
  } else if ( kind == TypeData::Symbolic ) {
    return buildSymbolic( name, sc );
  } else if ( kind == TypeData::Variable ) {
    return buildVariable();
  } else {
    if( isInline ) {
      throw SemanticError( "invalid inline specification in declaration of ", this );
    } else {
      return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
    }
  }
  return 0;
}

Type *
TypeData::build() const
{

  switch( kind ) {
  case Unknown:
    // fill in implicit int
    return new BasicType( buildQualifiers(), BasicType::SignedInt );

  case Basic:
    return buildBasicType();

  case Pointer:
    return buildPointer();

  case Array:
    return buildArray();

  case Function:
    return buildFunction();

  case AggregateInst:
    return buildAggInst();

  case EnumConstant:
    // the name gets filled in later -- by SymTab::Validate
    return new EnumInstType( buildQualifiers(), "" );

  case SymbolicInst:
    return buildSymbolicInst();;

  case Tuple:
    return buildTuple();
  
  case Typeof:
    return buildTypeof();

  case Attr:
    return buildAttr();

  case Symbolic:
  case Enum:
  case Aggregate:
  case Variable:
    assert( false );
  }

  return 0;
}

Type::Qualifiers
TypeData::buildQualifiers() const
{
  Type::Qualifiers q;
  for( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) {
    switch( *i ) {
    case DeclarationNode::Const:
      q.isConst = true;
      break;

    case DeclarationNode::Volatile:
      q.isVolatile = true;
      break;

    case DeclarationNode::Restrict:
      q.isRestrict = true;
      break;

    case DeclarationNode::Lvalue:
      q.isLvalue = true;
      break;
    }
  }
  return q;
}

Type*
TypeData::buildBasicType() const
{

  static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double,
                                             BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex,
                                             BasicType::DoubleImaginary };

  bool init = false;
  bool sawDouble = false;
  bool sawSigned = false;
  BasicType::Kind ret;

  for( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) {
    if( !init ) {
      init = true;
      if( *i == DeclarationNode::Void ) {
        if( basic->typeSpec.size() != 1 || !basic->modifiers.empty() ) {
          throw SemanticError( "invalid type specifier \"void\" in type ", this );
        } else {
          return new VoidType( buildQualifiers() );
        }
      } else {
        ret = kindMap[ *i ];
      }
    } else {
      switch( *i ) {
      case DeclarationNode::Float:
        if( sawDouble ) {
          throw SemanticError( "invalid type specifier \"float\" in type ", this );
        } else {
          switch( ret ) {
          case BasicType::DoubleComplex:
            ret = BasicType::FloatComplex;
            break;

          case BasicType::DoubleImaginary:
            ret = BasicType::FloatImaginary;
            break;

          default:
            throw SemanticError( "invalid type specifier \"float\" in type ", this );
          }
        }
        break;

      case DeclarationNode::Double:
        if( sawDouble ) {
          throw SemanticError( "duplicate type specifier \"double\" in type ", this );
        } else {
          switch( ret ) {
          case BasicType::DoubleComplex:
          case BasicType::DoubleImaginary:
            break;

          default:
            throw SemanticError( "invalid type specifier \"double\" in type ", this );
          }
        }
        break;
        
      case DeclarationNode::Complex:
        switch( ret ) {
        case BasicType::Float:
          ret = BasicType::FloatComplex;
          break;
          
        case BasicType::Double:
          ret = BasicType::DoubleComplex;
          break;

        default:
          throw SemanticError( "invalid type specifier \"complex\" in type ", this );
        }
        break;
        
      case DeclarationNode::Imaginary:
        switch( ret ) {
        case BasicType::Float:
          ret = BasicType::FloatImaginary;
          break;
          
        case BasicType::Double:
          ret = BasicType::DoubleImaginary;
          break;

        default:
          throw SemanticError( "invalid type specifier \"imaginary\" in type ", this );
        }
        break;
        
      default:
        throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type ", this );
      }
    }
    if( *i == DeclarationNode::Double ) {
      sawDouble = true;
    }
  }

  for( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) {
    switch( *i ) {
    case DeclarationNode::Long:
      if( !init ) {
        init = true;
        ret = BasicType::LongSignedInt;
      } else {
        switch( ret ) {
        case BasicType::SignedInt:
          ret = BasicType::LongSignedInt;
          break;

        case BasicType::UnsignedInt:
          ret = BasicType::LongUnsignedInt;
          break;

        case BasicType::LongSignedInt:
          ret = BasicType::LongLongSignedInt;
          break;

        case BasicType::LongUnsignedInt:
          ret = BasicType::LongLongUnsignedInt;
          break;

        case BasicType::Double:
          ret = BasicType::LongDouble;
          break;

        case BasicType::DoubleComplex:
          ret = BasicType::LongDoubleComplex;
          break;

        case BasicType::DoubleImaginary:
          ret = BasicType::LongDoubleImaginary;
          break;

        default:
          throw SemanticError( "invalid type modifier \"long\" in type ", this );
        }
      }
      break;

    case DeclarationNode::Short:
      if( !init ) {
        init = true;
        ret = BasicType::ShortSignedInt;
      } else {
        switch( ret ) {
        case BasicType::SignedInt:
          ret = BasicType::ShortSignedInt;
          break;

        case BasicType::UnsignedInt:
          ret = BasicType::ShortUnsignedInt;
          break;

        default:
          throw SemanticError( "invalid type modifier \"short\" in type ", this );
        }
      }
      break;

    case DeclarationNode::Signed:
      if( !init ) {
        init = true;
        ret = BasicType::SignedInt;
      } else if( sawSigned ) {
        throw SemanticError( "duplicate type modifer \"signed\" in type ", this );
      } else {
        switch( ret ) {
        case BasicType::SignedInt:
        case BasicType::ShortSignedInt:
          break;

        case BasicType::Char:
          ret = BasicType::SignedChar;
          break;

        default:
          throw SemanticError( "invalid type modifer \"signed\" in type ", this );
        }
      }
      break;

    case DeclarationNode::Unsigned:
      if( !init ) {
        init = true;
        ret = BasicType::UnsignedInt;
      } else if( sawSigned ) {
        throw SemanticError( "invalid type modifer \"unsigned\" in type ", this );
      } else {
        switch( ret ) {
        case BasicType::LongSignedInt:
          ret = BasicType::LongUnsignedInt;
          break;

        case BasicType::SignedInt:
          ret = BasicType::UnsignedInt;
          break;

        case BasicType::ShortSignedInt:
          ret = BasicType::ShortUnsignedInt;
          break;

        case BasicType::Char:
          ret = BasicType::UnsignedChar;
          break;

        default:
          throw SemanticError( "invalid type modifer \"unsigned\" in type ", this );
        }
      }
      break;
    }

    if( *i == DeclarationNode::Signed ) {
      sawSigned = true;
    }
  }

  BasicType *bt;
  if( !init ) {
    bt = new BasicType( buildQualifiers(), BasicType::SignedInt );
  } else {
    bt = new BasicType( buildQualifiers(), ret );
  }
  buildForall( forall, bt->get_forall() );
  return bt;
}


PointerType * 
TypeData::buildPointer() const
{
  
  PointerType *pt;
  if( base ) {
    pt = new PointerType( buildQualifiers(), base->build() );
  } else {
    pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
  }
  buildForall( forall, pt->get_forall() );
  return pt;
}

ArrayType * 
TypeData::buildArray() const
{
  
  ArrayType *at;
  if( base ) {
    at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ),
                          array->isVarLen, array->isStatic );
  } else {
    at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
                          maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
  }
  buildForall( forall, at->get_forall() );
  return at;
}

FunctionType *
TypeData::buildFunction() const
{
  assert( kind == Function );


  bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true;
  if( !function->params ) hasEllipsis = !function->newStyle;
  FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis );
  buildList( function->params, ft->get_parameters() );
  buildForall( forall, ft->get_forall() );
  if( base ) {
    switch( base->kind ) {
    case Tuple:
      buildList( base->tuple->members, ft->get_returnVals() );
      break;

    default:
      ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
    }
  } else {
    ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
  }
  return ft;
}

AggregateDecl *
TypeData::buildAggregate() const
{
  assert( kind == Aggregate );


  AggregateDecl *at;
  switch( aggregate->kind ) {
  case DeclarationNode::Struct:
    at = new StructDecl( aggregate->name );
    break;
    
  case DeclarationNode::Union:
    at = new UnionDecl( aggregate->name );
    break;
    
  case DeclarationNode::Context:
    at = new ContextDecl( aggregate->name );
    break;
    
  default:
    assert( false );
  }
  
  buildList( aggregate->params, at->get_parameters() );
  buildList( aggregate->members, at->get_members() );

  return at;
}

/// namespace {
/// Type*
/// makeType( Declaration* decl )
/// {
///   if( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
///     return dwt->get_type()->clone();
///   } else {
///     return 0;
///   }
/// }
/// }

ReferenceToType *
TypeData::buildAggInst() const
{
  assert( kind == AggregateInst );


  std::string name;

  ReferenceToType *ret;
  if( aggInst->aggregate->kind == Enum ) {
    ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name );
  } else {
    assert( aggInst->aggregate->kind == Aggregate );
    switch( aggInst->aggregate->aggregate->kind ) {
    case DeclarationNode::Struct:
      ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
      break;

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

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

    default:
      assert( false );
    }
  }
  buildList( aggInst->params, ret->get_parameters() );
  buildForall( forall, ret->get_forall() );
  return ret;
}

NamedTypeDecl*
TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const
{
  assert( kind == Symbolic );


  NamedTypeDecl *ret;
  if( symbolic->isTypedef ) {
    ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) );
  } else {
    ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
  }
  buildList( symbolic->params, ret->get_parameters() );
  buildList( symbolic->assertions, ret->get_assertions() );
  return ret;
}

TypeDecl*
TypeData::buildVariable() const
{
  assert( kind == Variable );


  static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };

  TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] );
  buildList( variable->assertions, ret->get_assertions() );
    
  return ret;
}

EnumDecl* 
TypeData::buildEnum() const
{
  assert( kind == Enum );


  EnumDecl *ret = new EnumDecl( enumeration->name );
  buildList( enumeration->constants, ret->get_members() );

  return ret;
}

TypeInstType * 
TypeData::buildSymbolicInst() const
{
  assert( kind == SymbolicInst );


  TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false );
  buildList( symbolic->actuals, ret->get_parameters() );
  buildForall( forall, ret->get_forall() );

  return ret;
}

TupleType * 
TypeData::buildTuple() const
{
  assert( kind == Tuple );


  TupleType *ret = new TupleType( buildQualifiers() );
  buildTypeList( tuple->members, ret->get_types() );
  buildForall( forall, ret->get_forall() );

  return ret;
}

TypeofType * 
TypeData::buildTypeof() const
{
  assert( kind == Typeof );


  assert( typeexpr );
  assert( typeexpr->expr );
  TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() );

  return ret;
}

AttrType * 
TypeData::buildAttr() const
{
  assert( kind == Attr );


  assert( attr );
  AttrType *ret;
  if( attr->expr ) {
    ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() );
  } else {
    assert( attr->type );
    ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
  }

  return ret;
}