Changeset b3d70eba for src/CodeGen/GenType.cc

Timestamp:

Apr 19, 2017, 10:31:57 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

12d3187, 4e9151f, 6a8ac0b

Parents:

5c3632f (diff), e3987770 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

File:

• src/CodeGen/GenType.cc (modified) (8 diffs)

src/CodeGen/GenType.cc

@@ -28 +28 @@
         class GenType : public Visitor {
           public:
-                GenType( const std::string &typeString, bool pretty = false );
+                GenType( const std::string &typeString, bool pretty = false, bool genC = false );
                 std::string get_typeString() const { return typeString; }
                 void set_typeString( const std::string &newValue ) { typeString = newValue; }
@@ -48 +48 @@
           private:
                 void handleQualifiers( Type *type );
+                std::string handleGeneric( ReferenceToType * refType );
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
 
                 std::string typeString;
                 bool pretty = false; // pretty print
+                bool genC = false;   // generating C code?
         };
 
-        std::string genType( Type *type, const std::string &baseString, bool pretty ) {
-                GenType gt( baseString, pretty );
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC ) {
+                GenType gt( baseString, pretty, genC );
                 std::ostringstream os;
 
                 if ( ! type->get_attributes().empty() ) {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         cg.genAttributes( type->get_attributes() );
                 } // if
@@ -68 +70 @@
 
   std::string genPrettyType( Type * type, const std::string & baseString ) {
-        return genType( type, baseString, true );
+        return genType( type, baseString, true, false );
   }
 
-        GenType::GenType( const std::string &typeString, bool pretty ) : typeString( typeString ), pretty( pretty ) {}
+        GenType::GenType( const std::string &typeString, bool pretty, bool genC ) : typeString( typeString ), pretty( pretty ), genC( genC ) {}
 
         void GenType::visit( VoidType *voidType ) {
@@ -112 +114 @@
                 } // if
                 if ( dimension != 0 ) {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -166 +168 @@
                         } // if
                 } else {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         os << "(" ;
 
@@ -184 +186 @@
                         funcType->get_returnVals().front()->get_type()->accept( *this );
                 } // if
+
+                // add forall
+                if( ! funcType->get_forall().empty() && ! genC ) {
+                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
+                        std::ostringstream os;
+                        CodeGenerator cg( os, pretty, genC );
+                        os << "forall(";
+                        cg.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
+                        os << ")" << std::endl;
+                        typeString = os.str() + typeString;
+                }
+        }
+
+        std::string GenType::handleGeneric( ReferenceToType * refType ) {
+                if ( ! refType->get_parameters().empty() ) {
+                        std::ostringstream os;
+                        CodeGenerator cg( os, pretty, genC );
+                        os << "(";
+                        cg.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
+                        os << ") ";
+                        return os.str();
+                }
+                return "";
         }
 
         void GenType::visit( StructInstType *structInst )  {
-                typeString = "struct " + structInst->get_name() + " " + typeString;
+                typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString;
+                if ( genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
         }
 
         void GenType::visit( UnionInstType *unionInst ) {
-                typeString = "union " + unionInst->get_name() + " " + typeString;
+                typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString;
+                if ( genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
         }
 
         void GenType::visit( EnumInstType *enumInst ) {
-                typeString = "enum " + enumInst->get_name() + " " + typeString;
+                typeString = enumInst->get_name() + " " + typeString;
+                if ( genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
         }
@@ -207 +235 @@
 
         void GenType::visit( TupleType * tupleType ) {
-                assertf( pretty, "Tuple types should not make it to Code Gen." );
+                assertf( ! genC, "Tuple types should not reach code generation." );
                 Visitor::visit( tupleType );
                 unsigned int i = 0;
@@ -214 +242 @@
                 for ( Type * t : *tupleType ) {
                         i++;
-                        os << genType( t, "", pretty ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", pretty, genC ) << (i == tupleType->size() ? "" : ", ");
                 }
                 os << "]";