source: translator/ResolvExpr/AdjustExprType.cc @ a0d9f94

/*
 * This file is part of the Cforall project
 *
 * $Id: AdjustExprType.cc,v 1.3 2005/08/29 20:14:15 rcbilson Exp $
 *
 */

#include "typeops.h"
#include "SynTree/Type.h"
#include "TypeEnvironment.h"
#include "SymTab/Indexer.h"

namespace ResolvExpr {

class AdjustExprType : public Mutator
{
  typedef Mutator Parent;

public:
  AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );

private:
  virtual Type* mutate(VoidType *voidType);
  virtual Type* mutate(BasicType *basicType);
  virtual Type* mutate(PointerType *pointerType);
  virtual Type* mutate(ArrayType *arrayType);
  virtual Type* mutate(FunctionType *functionType);
  virtual Type* mutate(StructInstType *aggregateUseType);
  virtual Type* mutate(UnionInstType *aggregateUseType);
  virtual Type* mutate(EnumInstType *aggregateUseType);
  virtual Type* mutate(ContextInstType *aggregateUseType);
  virtual Type* mutate(TypeInstType *aggregateUseType);
  virtual Type* mutate(TupleType *tupleType);
  
  const TypeEnvironment &env;
  const SymTab::Indexer &indexer;
};

void
adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer )
{
  AdjustExprType adjuster( env, indexer );
  Type *newType = type->acceptMutator( adjuster );
  type = newType;
}

AdjustExprType::AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer )
  : env( env ), indexer( indexer )
{
}

Type* 
AdjustExprType::mutate(VoidType *voidType)
{
  return voidType;
}

Type* 
AdjustExprType::mutate(BasicType *basicType)
{
  return basicType;
}

Type* 
AdjustExprType::mutate(PointerType *pointerType)
{
  return pointerType;
}

Type* 
AdjustExprType::mutate(ArrayType *arrayType)
{
  PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone() );
  delete arrayType;
  return pointerType;
}

Type* 
AdjustExprType::mutate(FunctionType *functionType)
{
  PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
  return pointerType;
}

Type* 
AdjustExprType::mutate(StructInstType *aggregateUseType)
{
  return aggregateUseType;
}

Type* 
AdjustExprType::mutate(UnionInstType *aggregateUseType)
{
  return aggregateUseType;
}

Type* 
AdjustExprType::mutate(EnumInstType *aggregateUseType)
{
  return aggregateUseType;
}

Type* 
AdjustExprType::mutate(ContextInstType *aggregateUseType)
{
  return aggregateUseType;
}

Type* 
AdjustExprType::mutate(TypeInstType *typeInst)
{
  EqvClass eqvClass;
  if( env.lookup( typeInst->get_name(), eqvClass ) ) {
    if( eqvClass.kind == TypeDecl::Ftype ) {
      PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
      return pointerType;
    }
  } else if( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    if( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
      if( tyDecl->get_kind() == TypeDecl::Ftype ) {
        PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
        return pointerType;
      }
    }
  }
  return typeInst;
}

Type* 
AdjustExprType::mutate(TupleType *tupleType)
{
  return tupleType;
}


} // namespace ResolvExpr