Index: translator/CodeGen/GenType.cc
===================================================================
--- translator/CodeGen/GenType.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/CodeGen/GenType.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
@@ -0,0 +1,273 @@
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: GenType.cc,v 1.6 2005/08/29 20:14:12 rcbilson Exp $
+ *
+ */
+
+#include <strstream>
+#include <cassert>
+
+#include "GenType.h"
+#include "CodeGenerator2.h"
+#include "SynTree/Visitor.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+
+namespace CodeGen {
+
+class GenType : public Visitor
+{
+public:
+  GenType( const std::string &typeString );
+  std::string get_typeString() const { return typeString; }
+  void set_typeString( const std::string &newValue ) { typeString = newValue; }
+  
+  virtual void visit( FunctionType *funcType );
+  virtual void visit( VoidType *voidType );
+  virtual void visit( BasicType *basicType );
+  virtual void visit( PointerType *pointerType );
+  virtual void visit( ArrayType *arrayType );
+  virtual void visit( StructInstType *structInst );
+  virtual void visit( UnionInstType *unionInst );
+  virtual void visit( EnumInstType *enumInst );
+  virtual void visit( TypeInstType *typeInst );
+  
+private:
+  void handleQualifiers( Type *type );
+  void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+  
+  std::string typeString;
+};
+
+std::string
+genType( Type *type, const std::string &baseString )
+{
+  GenType gt( baseString );
+  type->accept( gt );
+  return gt.get_typeString();
+}
+
+GenType::GenType( const std::string &typeString )
+  : typeString( typeString )
+{
+}
+
+void GenType::visit(VoidType *voidType){
+  typeString = "void " + typeString;
+  handleQualifiers( voidType );
+}
+
+void GenType::visit(BasicType *basicType)
+{
+  std::string typeWords;
+  switch(basicType->get_kind()){
+  case BasicType::Bool:
+    typeWords = "bool";
+    break;
+  case BasicType::Char:
+  case BasicType::SignedChar:
+    typeWords = "char";
+    break;
+  case BasicType::UnsignedChar:
+    typeWords = "unsigned char";
+    break;
+  case BasicType::ShortSignedInt:
+    typeWords = "short";
+    break;
+  case BasicType::ShortUnsignedInt:
+    typeWords = "short unsigned";
+    break;
+  case BasicType::SignedInt:
+    typeWords = "int";
+    break;
+  case BasicType::UnsignedInt:
+    typeWords = "unsigned int";
+    break;
+  case BasicType::LongSignedInt:
+    typeWords = "long int";
+    break;
+  case BasicType::LongUnsignedInt:
+    typeWords = "long unsigned int";
+    break;
+  case BasicType::LongLongSignedInt:
+    typeWords = "long long int";
+    break;
+  case BasicType::LongLongUnsignedInt:
+    typeWords = "long long unsigned int";
+    break;
+  case BasicType::Float:
+    typeWords = "float";
+    break;
+  case BasicType::Double:
+    typeWords = "double";
+    break;
+  case BasicType::LongDouble:
+    typeWords = "long double";
+    break;
+  case BasicType::FloatComplex:
+    typeWords = "float _Complex";
+    break;
+  case BasicType::DoubleComplex:
+    typeWords = "double _Complex";
+    break;
+  case BasicType::LongDoubleComplex:
+    typeWords = "long double _Complex";
+    break;
+  case BasicType::FloatImaginary:
+    typeWords = "float _Imaginary";
+    break;
+  case BasicType::DoubleImaginary:
+    typeWords = "double _Imaginary";
+    break;
+  case BasicType::LongDoubleImaginary:
+    typeWords = "long double _Imaginary";
+    break;
+  default:
+    assert( false );
+  }
+  typeString = typeWords + " " + typeString;
+  handleQualifiers( basicType );
+}
+
+void
+GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic )
+{
+  std::ostrstream os;
+  if( typeString != "" ) {
+    if( typeString[ 0 ] == '*' ) {
+      os << "(" << typeString << ")";
+    } else {
+      os << typeString;
+    }
+  }
+  os << "[";
+  if( isStatic ) {
+    os << "static ";
+  }
+  if( qualifiers.isConst ) {
+    os << "const ";
+  }
+  if( qualifiers.isVolatile ) {
+    os << "volatile ";
+  }
+  if( isVarLen ) {
+    os << "*";
+  }
+  if( dimension != 0 ) {
+    CodeGenerator2 cg( os );
+    dimension->accept( cg );
+  }
+  os << "]";
+  
+  typeString = std::string( os.str(), os.pcount() );
+  
+  base->accept ( *this );
+}
+
+void GenType::visit(PointerType *pointerType) {
+  assert(pointerType->get_base() != 0);
+  if( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) {
+    genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() );
+  } else {
+    handleQualifiers( pointerType );
+    if( typeString[ 0 ] == '?' ) {
+      typeString = "* " + typeString;
+    } else {
+      typeString = "*" + typeString;
+    }
+    pointerType->get_base()->accept ( *this );
+  }
+}
+
+void GenType::visit(ArrayType *arrayType){
+  genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+}
+
+void GenType::visit(FunctionType *funcType) {
+  std::ostrstream os;
+
+  if( typeString != "" ) {
+    if( typeString[ 0 ] == '*' ) {
+      os << "(" << typeString << ")";
+    } else {
+      os << typeString;
+    }
+  }
+  
+  /************* parameters ***************/
+
+  const std::list<DeclarationWithType*> &pars = funcType->get_parameters();
+
+  if( pars.empty() ) {
+    if( funcType->get_isVarArgs() ) {
+      os << "()";
+    } else {
+      os << "(void)";
+    }
+  } else {
+    CodeGenerator2 cg( os );
+    os << "(" ;
+
+    cg.genCommaList( pars.begin(), pars.end() );
+    
+    if( funcType->get_isVarArgs() ){
+      os << ", ...";
+    }
+    os << ")";
+  }
+  
+  typeString = std::string( os.str(), os.pcount() );
+
+  if( funcType->get_returnVals().size() == 0 ) {
+    typeString = "void " + typeString;
+  } else {
+
+    funcType->get_returnVals().front()->get_type()->accept( *this );
+
+  }
+  
+}
+
+void GenType::visit( StructInstType *structInst ) 
+{
+  typeString = "struct " + structInst->get_name() + " " + typeString;
+  handleQualifiers( structInst );
+}
+
+void 
+GenType::visit( UnionInstType *unionInst )
+{
+  typeString = "union " + unionInst->get_name() + " " + typeString;
+  handleQualifiers( unionInst );
+}
+
+void 
+GenType::visit( EnumInstType *enumInst )
+{
+  typeString = "enum " + enumInst->get_name() + " " + typeString;
+  handleQualifiers( enumInst );
+}
+
+void 
+GenType::visit( TypeInstType *typeInst )
+{
+  typeString = typeInst->get_name() + " " + typeString;
+  handleQualifiers( typeInst );
+}
+
+void 
+GenType::handleQualifiers( Type *type )
+{
+  if( type->get_isConst() ) {
+    typeString = "const " + typeString;
+  }
+  if( type->get_isVolatile() ) {
+    typeString = "volatile " + typeString;
+  }
+  if( type->get_isRestrict() ) {
+    typeString = "__restrict " + typeString;
+  }
+}
+
+} // namespace CodeGen
