Changeset 141b786 for src/Tuples/Tuples.h

Timestamp:

Nov 9, 2016, 2:21:05 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:

b726084

Parents:

23bb1b9

Message:

rework UniqueExpr?, handle UniqueExpr? in FixInit?, fix translation for UniqueExprs?, refactor explode functions and fix AddressExpr? distribution over exploded tuple exprs

File:

• src/Tuples/Tuples.h (modified) (3 diffs)

src/Tuples/Tuples.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 15:04:02 2015
-// Update Count     : 2
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:17:58 2016
+// Update Count     : 15
 //
 
@@ -18 +18 @@
 
 #include <string>
-#include <vector>
-#include "ResolvExpr/AlternativeFinder.h"
-#include "ResolvExpr/Resolver.h"
 
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
+
+#include "ResolvExpr/AlternativeFinder.h"
 
 namespace Tuples {
@@ -45 +44 @@
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );
-
-
-        /// helper function used by explode
-        template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out ) {
-                Type * res = expr->get_result();
-                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                        ResolvExpr::AltList alts;
-                        explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ) );
-                        for ( ResolvExpr::Alternative & alt : alts ) {
-                                // distribute '&' over all components
-                                alt.expr = new AddressExpr( alt.expr );
-                                *out++ = alt;
-                        }
-                } else if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
-                        if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
-                                // can open tuple expr and dump its exploded components
-                                for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, out );
-                                }
-                        } else {
-                                // tuple type, but not tuple expr - recursively index into its components
-                                Expression * arg = expr->clone();
-                                if ( Tuples::maybeImpure( arg ) ) {
-                                        // expressions which may contain side effects require a single unique instance of the expression.
-                                        // resolve the UniqueExpr (which should be relatively cheap, since the argument is already resolved)
-                                        // so that its accompanying object is properly constructed and destructed.
-                                        arg = new UniqueExpr( arg );
-                                        arg = ResolvExpr::resolveInVoidContext( arg, indexer );
-                                }
-                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
-                                        TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, out );
-                                        delete idx;
-                                }
-                                delete arg;
-                        }
-                } else {
-                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        *out++ = ResolvExpr::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( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explodeUnique( alt.expr, alt, indexer, out );
-        }
-
-        // explode list of alternatives
-        template< typename AltIterator, typename OutputIterator >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out ) {
-                for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out );
-                }
-        }
-
-        template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explode( alts.begin(), alts.end(), indexer, out );
-        }
 } // namespace Tuples