Changeset f006f01

Timestamp:

Sep 12, 2016, 7:08:41 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

fd782b2

Parents:

6eb8948

Message:

replace tuple types with an equivalent struct type

Location:

src

Files:

• SynTree/ReferenceToType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (3 diffs)

src/SynTree/ReferenceToType.cc

@@ -56 +56 @@
         }
 } // namespace
+
+StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct ) : Parent( tq, baseStruct->get_name() ), baseStruct( baseStruct ) {}
 
 std::string StructInstType::typeString() const { return "struct"; }

src/SynTree/Type.h

@@ -234 +234 @@
   public:
         StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct );
         StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 

src/Tuples/TupleExpansion.cc

@@ -18 +18 @@
 #include <cassert>
 #include "Tuples.h"
-#include "GenPoly/PolyMutator.h"
+#include "GenPoly/DeclMutator.h"
+#include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
+#include "SymTab/Mangler.h"
+#include "Common/ScopedMap.h"
 
 namespace Tuples {
-        class TupleAssignExpander : public GenPoly::PolyMutator {
+        class TupleAssignExpander : public Mutator {
         public:
                 virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+        };
+
+        class TupleTypeReplacer : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+
+                virtual Type * mutate( TupleType * tupleType );
+
+                virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
+                        typeMap.beginScope();
+                        stmt = Parent::mutate( stmt );
+                        typeMap.endScope();
+                        return stmt;
+                }
+          private:
+                ScopedMap< std::string, StructDecl * > typeMap;
         };
 
@@ -30 +51 @@
                 TupleAssignExpander expander;
                 mutateAll( translationUnit, expander );
+
+                TupleTypeReplacer replacer;
+                replacer.mutateDeclarationList( translationUnit );
         }
 
@@ -47 +71 @@
         }
 
+        Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
+                std::string mangleName = SymTab::Mangler::mangleType( tupleType );
+                TupleType * newType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
+                if ( ! typeMap.count( mangleName ) ) {
+                        // generate struct type to replace tuple type
+                        StructDecl * decl = new StructDecl( "_tuple_type_" + mangleName );
+                        decl->set_body( true );
+                        int cnt = 0;
+                        for ( Type * t : *newType ) {
+                                decl->get_members().push_back( new ObjectDecl( "field_"+std::to_string(++cnt), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
+                        }
+                        typeMap[mangleName] = decl;
+                        addDeclaration( decl );
+                }
+                delete newType;
+                return new StructInstType( newType->get_qualifiers(), typeMap[mangleName] );
+        }
+
 } // namespace Tuples