Index: src/Designators/Processor.cc
===================================================================
--- src/Designators/Processor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/Designators/Processor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,168 @@
+//
+// 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.
+//
+// Processor.cc -- 
+//
+// Author           : Rodolfo G. Esteves
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 16:23:10 2015
+// Update Count     : 2
+//
+
+#include <vector>
+#include <algorithm>
+
+#include "Processor.h"
+#include "SynTree/Declaration.h"
+
+namespace Designators {
+	Matcher::Matcher( const std::list< DeclarationWithType * > &decls ) {
+		int cnt = 0;
+		for ( std::list< DeclarationWithType * >::const_iterator i = decls.begin();
+			  i != decls.end(); i++, cnt++ ) {
+			std::string newName = (*i)->get_name();
+			if ( table.find( newName ) == table.end() ) {
+				table.insert( std::pair<std::string, int>(newName, cnt) );
+				order.push_back( newName );
+				declarations.push_back( *i );
+				alternatives.push_back( 0 );
+			} // if
+		} // for
+	}
+
+	template< class InputIterator >
+	bool Matcher::add(InputIterator begin, InputIterator end, ResolvExpr::Alternative &alt ) {
+		while ( begin != end ) {
+			if ( table.find( *begin ) != table.end() )
+				alternatives[ table[ *begin ] ] = new ResolvExpr::Alternative(alt);
+			else
+				return false;
+			begin++;
+		} // while
+		return true;
+	}
+
+	template< class InputIterator, class OutputIterator >
+	bool Matcher::slice(InputIterator begin, InputIterator end, OutputIterator out ) {
+		while ( begin != end )
+			if ( table.find( *begin ) != table.end() )
+				*out++ = declarations [ table[ *begin++ ] ];
+			else
+				return false; // throw 0;
+		return true;
+	}
+
+	template< class OutputIterator >
+	bool Matcher::get_reorderedCall( OutputIterator out ) {
+		// fill call with defaults, if need be
+		for (Matcher::iterator o = begin(); o != end(); o++ )
+			if ( alternatives[ table[ *o ] ] == 0 )
+				return false;
+			else
+				out++ = *alternatives[table[ *o ]];
+		return true;
+	}
+
+	bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation ) {
+		// Distribute `designation' over alternatives contained in `finder'
+		if ( ! designation) return false;
+		else
+			for ( ResolvExpr::AlternativeFinder::iterator alt = finder.begin(); alt != finder.end(); alt++ )
+				alt->expr->set_argName( designation );
+		return true;
+	}
+
+	template < class OutputIterator >
+	bool extractNames( Expression *expr, OutputIterator out, Matcher matcher ) {
+		Expression *designator = expr->get_argName();
+		if ( designator == 0 ) return false;
+
+		if ( NameExpr *ndes = dynamic_cast<NameExpr *>(designator) )
+			out++ = ndes->get_name();
+		else if ( TupleExpr *tdes = dynamic_cast<TupleExpr *>(designator) ) {
+			std::cerr << "Tuple designation" << std::endl;
+//      ObjectDecl *decl = extractTupleV(matcher, tdes); // xxx
+			// transform?
+			for ( std::list< Expression * >::iterator n = tdes->get_exprs().begin();
+				  n != tdes->get_exprs().end(); n++ ) {
+
+				if ( NameExpr *name = dynamic_cast<NameExpr *>(*n) )
+					out++ = name->get_name();
+				else
+					// flatten nested Tuples
+					throw SemanticError( "Invalid tuple designation." );
+			} // for
+		} // if
+		return true;
+	}
+
+	std::string extractName( Expression *expr ) /* throw NoNameExtraction */ {
+		if ( NameExpr *name = dynamic_cast< NameExpr *>(expr) )
+			return name->get_name();
+		else /* if () */
+			throw 0;
+	}
+
+	DeclarationWithType *gensym( DeclarationWithType *, std::string prefix ) {
+		return 0;
+	}
+
+	ObjectDecl *extractTupleV( Matcher matcher, TupleExpr *nmTuple ) {
+		// extract a subtuple of the function `fun' argument list, corresponding to the tuple of names requested by
+		// `nmTuple'.
+		std::list< Expression * > &exprs = nmTuple->get_exprs();
+		std::cerr << "In extractTupleV, the tuple has " << exprs.size() << " components." << std::endl;
+		std::list< std::string > names;
+		std::transform( exprs.begin(), exprs.end(), back_inserter(names), extractName );
+		std::list< DeclarationWithType * > decls;
+		matcher.slice( names.begin(), names.end(), back_inserter(decls) );
+		//std::for_each( decls.begin(), decls.end(), gensym );
+		std::cerr << "Returning declaration with " << decls.size() << " components." << std::endl;
+
+		return 0;//new ObjectDecl()
+	}
+
+	void check_alternative( FunctionType *fun, ResolvExpr::AltList &args ) {
+		using namespace ResolvExpr;
+
+		Matcher matcher( fun->get_parameters() );
+		for ( AltList::iterator a = args.begin(); a != args.end(); a++ ) {
+			std::list< std::string > actNames;
+			if ( ! extractNames( a->expr, back_inserter(actNames), matcher ) ) {
+				return; // not a designated call, leave alternative alone
+			} else {
+				// see if there's a match
+				matcher.add( actNames.begin(), actNames.end(), *a );
+			} // if
+		} // for
+		//AltList newArgs;
+		args.clear();
+		matcher.get_reorderedCall( back_inserter(args) );
+
+		return;
+	}
+#if 0
+	void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder &finder ) {
+		if ( expr->get_argName() != 0 ) {
+			// Looking at designated expression
+			using namespace ResolvExpr;
+			AltList &alternatives = finder.get_alternatives();
+			std::cerr << "Now printing alternatives: " << std::endl;
+			for ( AltList::iterator a = alternatives.begin(); a != alternatives.end(); a++ )
+				a->expr->print( std::cerr );
+			//std::cerr << "Looking for constructions of length no more than: " << tdes->get_exprs().size() << "." << std::endl;
+		}
+		return;
+	}
+#endif // 0
+} // namespaces Designators
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Designators/Processor.h
===================================================================
--- src/Designators/Processor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/Designators/Processor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,78 @@
+//
+// 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.
+//
+// Processor.h -- 
+//
+// Author           : Rodolfo G. Esteves
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 16:24:34 2015
+// Update Count     : 3
+//
+
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Type.h"
+#include "ResolvExpr/AlternativeFinder.h"
+
+#include <vector>
+#include <string>
+#include <list>
+#include <map>
+
+namespace Designators {
+	class Matcher;
+	class GenSym;
+
+	template < class OutputIterator >  bool extractNames( std::list< DeclarationWithType * > &, OutputIterator );
+	template < class OutputIterator >  bool extractNames( Expression *, OutputIterator, Matcher );
+	void check_alternative( FunctionType *, ResolvExpr::AltList & );
+	ObjectDecl *extractTupleV( Matcher, TupleExpr *names );
+	bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation );
+	DeclarationWithType *gensym( GenSym &, DeclarationWithType * );
+
+	class GenSym {
+	  public:
+		GenSym( std::string prefix = "" ) : gensym_count(0) {}
+		GenSym( GenSym &other ) { gensym_count = other.gensym_count; }
+
+//    std::string get_symbol() { }
+	  private:
+		std::string prefix;
+		int gensym_count;
+	};
+
+	// template< typename Key >
+	class Matcher {
+	  public:
+		typedef std::vector< std::string >::iterator iterator;
+
+		Matcher( const std::list< DeclarationWithType * > & );
+		~Matcher() {}
+
+		template< class OutputIterator > bool get_reorderedCall( OutputIterator );
+		template< class InputIterator >  bool add(InputIterator, InputIterator, ResolvExpr::Alternative &);
+		template< class InputIterator, class OutputIterator >  bool slice(InputIterator begin, InputIterator end, OutputIterator );
+		//std::vector<std::string> &get_order() const { return order; }
+
+		iterator begin() { return order.begin(); }
+		iterator end() { return order.end(); }
+
+		//Expression *operator[]( int idx ) { return table( order[ idx ] ); }
+	  private:
+		std::map< std::string, int > table;
+		std::vector<std::string> order;
+		std::vector<DeclarationWithType *> declarations;
+		std::vector<ResolvExpr::Alternative *> alternatives;
+	};
+	//  void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder & );
+} // namespace Designators
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Designators/module.mk
===================================================================
--- src/Designators/module.mk	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/Designators/module.mk	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,2 @@
+SRC +=  Designators/Processor.cc \
+	$(NULL)