Changeset 5af62f1 for src/Tuples/TupleAssignment.h

Timestamp:

Sep 10, 2016, 12:53:36 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

aaron-thesis, arm-eh, 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:

908cc83

Parents:

add7117

Message:

major refactoring of Rodolfo's tuple assignment code

File:

• src/Tuples/TupleAssignment.h (modified) (2 diffs)

src/Tuples/TupleAssignment.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleAssignment.h -- 
+// TupleAssignment.h --
 //
 // Author           : Rodolfo G. Esteves
@@ -26 +26 @@
 
 namespace Tuples {
-        class TupleAssignSpotter {
-          public:
-                // dispatcher for Tuple (multiple and mass) assignment operations
-                TupleAssignSpotter( ResolvExpr::AlternativeFinder * );
-                ~TupleAssignSpotter() { delete matcher; matcher = 0; }
-
-                bool pointsToTuple( Expression * );
-                static bool isTupleVar( DeclarationWithType * );
-                bool isTuple( Expression *, bool isRight = false );
-                bool isMVR( Expression * );
-                bool isTupleAssignment( UntypedExpr *, std::list<ResolvExpr::AltList> & );
-                bool match();
-          private:
-                // records for assignment generation
-                class Options {
-                  public:
-                        void add_option( ResolvExpr::AltList &opt );
-                        std::list< ResolvExpr::AltList > get_best();
-                        void print( std::ostream & );
-                        int size() const { return options.size(); }
-                        ResolvExpr::AltList get_option( std::list< ResolvExpr::AltList >::size_type index );
-
-                        // should really use the one in ResolvExpr/AlternativeFinder, but it's too coupled with the object
-                        template< typename InputIterator, typename OutputIterator >
-                        void findMinCost( InputIterator begin, InputIterator end, OutputIterator out );
-
-                        template< typename InputIterator, typename OutputIterator >
-                        void lift_intersection( InputIterator begin, InputIterator end, OutputIterator out );
-                  private:
-                        std::list< ResolvExpr::AltList > options;
-                        std::vector< std::vector< ResolvExpr::Cost > > costMatrix;
-                };
-
-                class Matcher {
-                  public:
-                        Matcher( /*TupleAssignSpotter &spot, */Expression *_lhs, Expression *_rhs );
-                        virtual ~Matcher() {}
-                        virtual bool match( std::list< Expression * > &out ) = 0;
-                        virtual bool solve( std::list< Expression * > &assigns ) = 0;
-                        static UntypedExpr *createAssgn( Expression *left, Expression *right );
-                  protected:
-                        Matcher() /*: own_spotter( TupleAssignSpotter(0) ) */{}
-                        void init(/* TupleAssignSpotter &, */Expression *_lhs, Expression *_rhs );
-                        std::list< Expression * > lhs, rhs;
-                        //TupleAssignSpotter &own_spotter;
-                };
-
-                class MassAssignMatcher : public Matcher {
-                  public:
-                        MassAssignMatcher( Expression *_lhs, Expression *_rhs ) : Matcher( _lhs, _rhs ) {
-                                rhs.push_back( _rhs );
-                        }
-                        virtual bool match( std::list< Expression * > &out );
-                        virtual bool solve( std::list< Expression * > &assigns );
-                  private:
-                        //std::vector< ResolvExpr::AltList > optMass;
-                };
-
-                class MultipleAssignMatcher : public Matcher {
-                  public:
-                        MultipleAssignMatcher( Expression *_lhs, Expression *_rhs );
-                        virtual bool match( std::list< Expression * > &out );
-                        virtual bool solve( std::list< Expression * > &assigns );
-                  private:
-                        //Options options;
-                };
-
-                friend class Matcher;
-
-                ResolvExpr::AlternativeFinder *currentFinder;
-                //std::list<Expression *> rhs, lhs;
-                Expression *rhs, *lhs;
-                Matcher *matcher;
-                bool hasMatched;
-                Options options;
-                std::vector< ResolvExpr::AltList > optMass;
-        };
-
-        ResolvExpr::Cost extract_cost( ResolvExpr::Alternative & );
-
-        template< typename InputIterator, typename OutputIterator >
-        void findMinCostAlt( InputIterator begin, InputIterator end, OutputIterator out ) {
-                using namespace ResolvExpr;
-                AltList alternatives;
-
-                // select the alternatives that have the minimum parameter cost
-                Cost minCost = Cost::infinity;
-                for ( AltList::iterator i = begin; i != end; ++i ) {
-                        if ( i->cost < minCost ) {
-                                minCost = i->cost;
-                                i->cost = i->cvtCost;
-                                alternatives.clear();
-                                alternatives.push_back( *i );
-                        } else if ( i->cost == minCost ) {
-                                i->cost = i->cvtCost;
-                                alternatives.push_back( *i );
-                        }
-                }
-                std::copy( alternatives.begin(), alternatives.end(), out );
-        }
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, std::list<ResolvExpr::AltList> & possibilities );
 } // namespace Tuples