source: src/Tuples/TupleAssignment.h@ 057b34f

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// TupleAssignment.h -- 
//
// 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
//

#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 // _TUPLE_ASSIGNMENT_H_

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //