Changeset 3c13c03 for src/ResolvExpr

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?

Location:

src/ResolvExpr

Files:

• Alternative.cc (modified) (1 diff)
• Alternative.h (modified) (4 diffs)
• AlternativeFinder.cc (modified) (2 diffs)

src/ResolvExpr/Alternative.cc

@@ -20 +20 @@
 
 namespace ResolvExpr {
-        Alternative::Alternative() : expr( 0 ) {}
+        Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( 0 ) {}
 
         Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )

src/ResolvExpr/Alternative.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Alternative.h -- 
+// Alternative.h --
 //
 // Author           : Richard C. Bilson
@@ -12 +12 @@
 // Last Modified On : Sat May 16 23:54:39 2015
 // Update Count     : 2
-// 
+//
 
 #ifndef ALTERNATIVE_H
@@ -33 +33 @@
                 Alternative &operator=( const Alternative &other );
                 ~Alternative();
-  
+
                 void initialize( const Alternative &src, Alternative &dest );
-  
+
                 void print( std::ostream &os, int indent = 0 ) const;
-  
+
                 Cost cost;
                 Cost cvtCost;
@@ -43 +43 @@
                 TypeEnvironment env;
         };
+
+        /// helper function used by explode
+        template< typename OutputIterator >
+        void explodeUnique( Expression * expr, const Alternative & alt, OutputIterator out ) {
+                Type * res = expr->get_result();
+                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
+                        if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( alt.expr ) ) {
+                                for ( Expression * expr : tupleExpr->get_exprs() ) {
+                                        explodeUnique( expr, alt, out );
+                                }
+                        } else {
+                                UniqueExpr * unq = new UniqueExpr( expr->clone() );
+                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
+                                        TupleIndexExpr * idx = new TupleIndexExpr( unq->clone(), i );
+                                        explodeUnique( idx, alt, out );
+                                        delete idx;
+                                }
+                                delete unq;
+                        }
+                } else {
+                        *out++ = Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
+                }
+        }
+
+        /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
+        template< typename OutputIterator >
+        void explode( Alternative &alt, OutputIterator out ) {
+                explodeUnique( alt.expr, alt, out );
+        }
+
+        // explode list of alternatives
+        template< typename OutputIterator >
+        void explode( AltList & alts, OutputIterator out ) {
+                for ( Alternative & alt : alts ) {
+                        explode( alt, out );
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc

@@ -380 +380 @@
 
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
+
+                AltList newActuals;
+                explode( actuals, back_inserter( newActuals ) );
 
                 std::list< Type * > formalTypes;
@@ -994 +997 @@
                         TupleExpr *newExpr = new TupleExpr;
                         makeExprList( *i, newExpr->get_exprs() );
-                        TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, true) );
-                        Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
-                        for ( Expression * resultExpr : newExpr->get_exprs() ) {
-                                Type * type = resultExpr->get_result()->clone();
-                                tupleType->get_types().push_back( type );
-                                qualifiers &= type->get_qualifiers();
-                        } // for
-                        newExpr->set_result( tupleType );
+                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
 
                         TypeEnvironment compositeEnv;