Changeset bf32bb8 for src/Tuples/TupleExpansion.cc

Timestamp:

Oct 18, 2016, 4:23:04 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:

f0121d7

Parents:

848ce71

Message:

implement transformation for MemberTupleExprs?

File:

• src/Tuples/TupleExpansion.cc (modified) (4 diffs)

src/Tuples/TupleExpansion.cc

@@ -31 +31 @@
 namespace Tuples {
         namespace {
+                class MemberTupleExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( UntypedMemberExpr * memberExpr );
+                };
+
                 class UniqueExprExpander : public GenPoly::DeclMutator {
                 public:
                         typedef GenPoly::DeclMutator Parent;
                         virtual Expression * mutate( UniqueExpr * unqExpr );
-                        std::map< Expression *, ObjectDecl * > decls;
+                        std::map< int, ObjectDecl * > decls; // not vector, because order added may not be increasing order
                 };
 
@@ -73 +79 @@
         }
 
+        void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
+                MemberTupleExpander expander;
+                mutateAll( translationUnit, expander );
+        }
+
         void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
                 UniqueExprExpander unqExpander;
@@ -92 +103 @@
         }
 
+        namespace {
+                /// given a expression representing the member and an expression representing the aggregate,
+                /// reconstructs a flattened UntypedMemberExpr with the right precedence
+                Expression * reconstructMemberExpr( Expression * member, UniqueExpr * aggr ) {
+                        if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( member ) ) {
+                                // construct a new UntypedMemberExpr with the correct structure , and recursively
+                                // expand that member expression.
+                                MemberTupleExpander expander;
+                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() ) );
+
+                                memberExpr->set_member(nullptr);
+                                memberExpr->set_aggregate(nullptr);
+                                delete memberExpr;
+                                return newMemberExpr->acceptMutator( expander );
+                        } else {
+                                // not a member expression, so there is nothing to do but attach and return
+                                return new UntypedMemberExpr( member, aggr->clone() );
+                        }
+                }
+        }
+
+        Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
+                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( memberExpr->get_member() ) ) {
+                        UniqueExpr * unqExpr = new UniqueExpr( memberExpr->get_aggregate()->clone() );
+                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
+                                expr = reconstructMemberExpr( expr, unqExpr );
+                        }
+                        delete unqExpr;
+                        return tupleExpr;
+                } else {
+                        return memberExpr;
+                }
+        }
+
         Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
                 static UniqueName tempNamer( "_unq_expr_" );
                 unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
-                if ( ! decls.count( unqExpr->get_expr() ) ) {
+                if ( ! decls.count( unqExpr->get_id() ) ) {
                         // xxx - it's possible (likely?) that expressions can appear in the wrong order because of this. Need to ensure they're placed in the correct location.
+                        // xxx - is it possible to make the decl's type const?
                         ObjectDecl * decl = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, unqExpr->get_result()->clone(), new SingleInit( unqExpr->get_expr()->clone() ) );
-                        decls[unqExpr->get_expr()] = decl;
+                        decls[unqExpr->get_id()] = decl;
                         addDeclaration( decl );
                 }
-                return new VariableExpr( decls[unqExpr->get_expr()] );
+                return new VariableExpr( decls[unqExpr->get_id()] );
         }
 
@@ -176 +222 @@
 
         Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
+                // recursively expand sub-tuple-expressions
+                tupleExpr = safe_dynamic_cast<TupleExpr *>(Parent::mutate(tupleExpr));
                 Type * result = tupleExpr->get_result();
                 std::list< Expression * > exprs = tupleExpr->get_exprs();
                 assert( result );
 
+                // remove data from shell and delete it
                 tupleExpr->set_result( nullptr );
                 tupleExpr->get_exprs().clear();