Index: translator/Tuples/TupleAssignment.h
===================================================================
--- translator/Tuples/TupleAssignment.h	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/TupleAssignment.h	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
@@ -0,0 +1,127 @@
+#ifndef _TUPLE_ASSIGNMENT_H_
+#define _TUPLE_ASSIGNMENT_H_
+
+#include <string>
+#include <vector>
+#include "ResolvExpr/AlternativeFinder.h"
+
+#include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
+
+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 );
+  }
+
+} // namespace Tuples
+
+
+#endif // #ifndef _TUPLE_ASSIGNMENT_H_
+
+/*
+  Local Variables:
+  mode: c++
+  End:
+*/
