Changeset 3c13c03 for src/Tuples/TupleExpansion.cc

Timestamp:

Sep 17, 2016, 8:27:51 AM (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:

8c49c0e

Parents:

12bc63a

Message:

expand TupleExpr? and TupleIndexExpr?, add UniqueExpr?

File:

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

src/Tuples/TupleExpansion.cc

@@ -23 +23 @@
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SymTab/Mangler.h"
 #include "Common/ScopedMap.h"
 
 namespace Tuples {
-        class TupleAssignExpander : public Mutator {
-        public:
-                virtual Expression * mutate( TupleAssignExpr * tupleExpr );
-        };
+        namespace {
+                class UniqueExprExpander : public GenPoly::DeclMutator {
+                public:
+                        typedef GenPoly::DeclMutator Parent;
+                        virtual Expression * mutate( UniqueExpr * unqExpr );
+                        std::map< Expression *, ObjectDecl * > decls;
+                };
 
-        class TupleTypeReplacer : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
+                class TupleAssignExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                };
 
-                virtual Type * mutate( TupleType * tupleType );
+                class TupleTypeReplacer : public GenPoly::DeclMutator {
+                  public:
+                        typedef GenPoly::DeclMutator Parent;
 
-                virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
-                        typeMap.beginScope();
-                        stmt = Parent::mutate( stmt );
-                        typeMap.endScope();
-                        return stmt;
-                }
-          private:
-                ScopedMap< std::string, StructDecl * > typeMap;
-        };
+                        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;
+                };
+
+                class TupleIndexExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleIndexExpr * tupleExpr );
+                };
+
+                class TupleExprExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleExpr * tupleExpr );
+                };
+        }
 
         void expandTuples( std::list< Declaration * > & translationUnit ) {
-                TupleAssignExpander expander;
-                mutateAll( translationUnit, expander );
+                UniqueExprExpander unqExpander;
+                unqExpander.mutateDeclarationList( translationUnit );
+
+                TupleAssignExpander assnExpander;
+                mutateAll( translationUnit, assnExpander );
 
                 TupleTypeReplacer replacer;
                 replacer.mutateDeclarationList( translationUnit );
+
+                TupleIndexExpander idxExpander;
+                mutateAll( translationUnit, idxExpander );
+
+                TupleExprExpander exprExpander;
+                mutateAll( translationUnit, exprExpander );
         }
 
-        Expression * TupleAssignExpander::mutate( TupleAssignExpr * tupleExpr ) {
+        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
+                static UniqueName tempNamer( "_unq_expr_" );
+                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+                if ( ! decls.count( unqExpr->get_expr() ) ) {
+                        // 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.
+                        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;
+                        addDeclaration( decl );
+                }
+                return new VariableExpr( decls[unqExpr->get_expr()] );
+        }
+
+        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
+                // xxx - Parent::mutate?
                 CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
                 std::list< Statement * > & stmts = compoundStmt->get_kids();
-                for ( ObjectDecl * obj : tupleExpr->get_tempDecls() ) {
+                for ( ObjectDecl * obj : assnExpr->get_tempDecls() ) {
                         stmts.push_back( new DeclStmt( noLabels, obj ) );
                 }
-                for ( Expression * assign : tupleExpr->get_assigns() ) {
-                        stmts.push_back( new ExprStmt( noLabels, assign ) );
-                }
-                tupleExpr->get_tempDecls().clear();
-                tupleExpr->get_assigns().clear();
-                delete tupleExpr;
+                TupleExpr * tupleExpr = new TupleExpr( assnExpr->get_assigns() );
+                assert( tupleExpr->get_result() );
+                stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+                assnExpr->get_tempDecls().clear();
+                assnExpr->get_assigns().clear();
+                delete assnExpr;
                 return new StmtExpr( compoundStmt );
         }
@@ -90 +136 @@
         }
 
+        Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) {
+                Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this );
+                assert( tuple );
+                tupleExpr->set_tuple( nullptr );
+                unsigned int idx = tupleExpr->get_index();
+                delete tupleExpr;
+
+                StructInstType * type = safe_dynamic_cast< StructInstType * >( tuple->get_result() );
+                StructDecl * structDecl = type->get_baseStruct();
+                assert( structDecl->get_members().size() > idx );
+                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
+                return new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
+        }
+
+        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
+                assert( tupleExpr->get_result() );
+                std::list< Initializer * > inits;
+                for ( Expression * expr : tupleExpr->get_exprs() ) {
+                        inits.push_back( new SingleInit( expr ) );
+                }
+                return new CompoundLiteralExpr( tupleExpr->get_result(), new ListInit( inits ) );
+        }
+
+        TupleType * makeTupleType( const std::list< Expression * > & exprs ) {
+                TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, false) );
+                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                for ( Expression * expr : exprs ) {
+                        assert( expr->get_result() );
+                        Type * type = expr->get_result()->clone();
+                        tupleType->get_types().push_back( type );
+                        qualifiers &= type->get_qualifiers();
+                } // for
+                return tupleType;
+        }
 } // namespace Tuples