Index: translator/Tuples/AssignExpand.cc
===================================================================
--- translator/Tuples/AssignExpand.cc	(revision a32b204359041ff1f6ef505a929495bcfe7a54f3)
+++ translator/Tuples/AssignExpand.cc	(revision 01aeadef077c992eb10d8adaf24ed68ff9c4b7ca)
@@ -1,2 +1,17 @@
+//
+// 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.
+//
+// AssignExpand.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:24:47 2015
+// Update Count     : 2
+//
+
 #include <ctime>
 #include <cstdlib>
@@ -14,118 +29,118 @@
 
 namespace Tuples {
-  AssignExpander::AssignExpander() : temporaryNamer("__tpl") {}
+	AssignExpander::AssignExpander() : temporaryNamer("__tpl") {}
 
-  Statement *AssignExpander::mutate( ExprStmt *exprStmt ) {
-    replace.clear();
-    extra.clear();
-    extra2.clear();
-    exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
+	Statement *AssignExpander::mutate( ExprStmt *exprStmt ) {
+		replace.clear();
+		extra.clear();
+		extra2.clear();
+		exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
 
-    CompoundStmt *newSt = 0;
-    if (! extra.empty() ) {
-      if ( ! newSt )
-	newSt= new CompoundStmt(std::list<Label>());
+		CompoundStmt *newSt = 0;
+		if (! extra.empty() ) {
+			if ( ! newSt )
+				newSt= new CompoundStmt(std::list<Label>());
 
-      newSt->get_kids().splice(newSt->get_kids().end(), extra);
-    }
+			newSt->get_kids().splice(newSt->get_kids().end(), extra);
+		} // if
 
-    if (! extra2.empty() ) {
-      if ( ! newSt )
-	newSt= new CompoundStmt(std::list<Label>());
+		if ( ! extra2.empty() ) {
+			if ( ! newSt )
+				newSt= new CompoundStmt(std::list<Label>());
 
-      newSt->get_kids().splice(newSt->get_kids().end(), extra2);
-    }
+			newSt->get_kids().splice(newSt->get_kids().end(), extra2);
+		}
 
-    if (! replace.empty() ) {
-      if ( ! newSt )
-	newSt= new CompoundStmt(std::list<Label>());
+		if ( ! replace.empty() ) {
+			if ( ! newSt )
+				newSt= new CompoundStmt(std::list<Label>());
 
-      for ( std::list<Expression *>::iterator r = replace.begin(); r != replace.end(); r++ )
-	newSt->get_kids().push_back( new ExprStmt( std::list<Label>(), *r ));
-    }
+			for ( std::list<Expression *>::iterator r = replace.begin(); r != replace.end(); r++ )
+				newSt->get_kids().push_back( new ExprStmt( std::list<Label>(), *r ));
+		}
 
-    if ( newSt ) return newSt; else return exprStmt;
-  }
+		if ( newSt ) return newSt; else return exprStmt;
+	}
 
-  Expression *AssignExpander::mutate( SolvedTupleExpr *tupleExpr ) {
-    /* 
-    std::list<Expression *> &exprs = tupleExpr->get_exprs();
+	Expression *AssignExpander::mutate( SolvedTupleExpr *tupleExpr ) {
+		/* 
+		   std::list<Expression *> &exprs = tupleExpr->get_exprs();
 
-    if ( tupleExpr->get_type() == SolvedTupleExpr::MASS ) {
-      // extract lhs of assignments, assert that rhs is the same, create temporaries
-      assert (! exprs.empty());
-      ApplicationExpr *ap1 = dynamic_cast< ApplicationExpr * >( exprs.front() );
-      std::list<Expression *> &args = ap1->get_args();
-      assert(args.size() == 2);
-      std::list<Type *> &temp_types = args.back()->get_results();
-      assert(temp_types.size() == 1);
-      extra.push_back(new DeclStmt( std::list<Label>(), new ObjectDecl(temporaryNamer.newName(), Declaration::Auto, LinkageSpec::C, 0, temp_types.front(), 0 ) ));
+		   if ( tupleExpr->get_type() == SolvedTupleExpr::MASS ) {
+		   // extract lhs of assignments, assert that rhs is the same, create temporaries
+		   assert (! exprs.empty());
+		   ApplicationExpr *ap1 = dynamic_cast< ApplicationExpr * >( exprs.front() );
+		   std::list<Expression *> &args = ap1->get_args();
+		   assert(args.size() == 2);
+		   std::list<Type *> &temp_types = args.back()->get_results();
+		   assert(temp_types.size() == 1);
+		   extra.push_back(new DeclStmt( std::list<Label>(), new ObjectDecl(temporaryNamer.newName(), Declaration::Auto, LinkageSpec::C, 0, temp_types.front(), 0 ) ));
 
-      for ( std::list<Expression *>::iterator e = exprs.begin(); e != exprs.end(); e++ ) {
-	ApplicationExpr *ap = dynamic_cast< ApplicationExpr * >( *e );
-	assert( ap != 0 );
-	replace.push_back(ap);
-      }
+		   for ( std::list<Expression *>::iterator e = exprs.begin(); e != exprs.end(); e++ ) {
+		   ApplicationExpr *ap = dynamic_cast< ApplicationExpr * >( *e );
+		   assert( ap != 0 );
+		   replace.push_back(ap);
+		   }
 
-      return tupleExpr;
-    } else if ( tupleExpr->get_type() == SolvedTupleExpr::MULTIPLE ||
+		   return tupleExpr;
+		   } else if ( tupleExpr->get_type() == SolvedTupleExpr::MULTIPLE ||
 		   tupleExpr->get_type() == SolvedTupleExpr::MASS ) */ {
-      std::list<Expression *> &comps = tupleExpr->get_exprs();
-      for ( std::list<Expression *>::iterator i = comps.begin(); i != comps.end(); ++i ) {
-	std::list<Statement *> decls;
-	std::list<Statement *> temps;
-	std::list<Statement *> assigns;
-	if ( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >(*i) ) {
-	  assert( app->get_args().size() == 2 );
+			std::list<Expression *> &comps = tupleExpr->get_exprs();
+			for ( std::list<Expression *>::iterator i = comps.begin(); i != comps.end(); ++i ) {
+				std::list<Statement *> decls;
+				std::list<Statement *> temps;
+				std::list<Statement *> assigns;
+				if ( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >(*i) ) {
+					assert( app->get_args().size() == 2 );
 
-	  Expression *lhsT = app->get_args().front();
-	  Expression *rhsT = app->get_args().back();
-	  // after the round of type analysis this should be true
-	  assert( lhsT->get_results().size() == 1 );
-	  assert( rhsT->get_results().size() == 1 );
-	  // declare temporaries
-	  ObjectDecl *lhs = new ObjectDecl( temporaryNamer.newName("_lhs_"), Declaration::NoStorageClass, LinkageSpec::Intrinsic, 0,
-					    lhsT->get_results().front(), 0 );
-	  decls.push_back( new DeclStmt( std::list< Label >(), lhs ) );
-	  ObjectDecl *rhs = new ObjectDecl( temporaryNamer.newName("_rhs_"), Declaration::NoStorageClass, LinkageSpec::Intrinsic, 0,
-					    rhsT->get_results().front(), 0);
-	  decls.push_back( new DeclStmt( std::list< Label >(), rhs ));
+					Expression *lhsT = app->get_args().front();
+					Expression *rhsT = app->get_args().back();
+					// after the round of type analysis this should be true
+					assert( lhsT->get_results().size() == 1 );
+					assert( rhsT->get_results().size() == 1 );
+					// declare temporaries
+					ObjectDecl *lhs = new ObjectDecl( temporaryNamer.newName("_lhs_"), Declaration::NoStorageClass, LinkageSpec::Intrinsic, 0,
+													  lhsT->get_results().front(), 0 );
+					decls.push_back( new DeclStmt( std::list< Label >(), lhs ) );
+					ObjectDecl *rhs = new ObjectDecl( temporaryNamer.newName("_rhs_"), Declaration::NoStorageClass, LinkageSpec::Intrinsic, 0,
+													  rhsT->get_results().front(), 0);
+					decls.push_back( new DeclStmt( std::list< Label >(), rhs ));
 
 
-	  // create temporary for lhs, assign address
-	  UntypedExpr *assgnL = new UntypedExpr( new NameExpr( "?=?" ) );
-	  assgnL->get_args().push_back( new VariableExpr( lhs ) );
-	  assgnL->get_args().push_back( lhsT );
-	  temps.push_back( new ExprStmt(std::list<Label>(), assgnL) );
+					// create temporary for lhs, assign address
+					UntypedExpr *assgnL = new UntypedExpr( new NameExpr( "?=?" ) );
+					assgnL->get_args().push_back( new VariableExpr( lhs ) );
+					assgnL->get_args().push_back( lhsT );
+					temps.push_back( new ExprStmt(std::list<Label>(), assgnL) );
 
-	  // create temporary for rhs, assign value
-	  UntypedExpr *assgnR = new UntypedExpr( new NameExpr( "?=?" ) );
-	  assgnR->get_args().push_back( new VariableExpr( rhs ) );
-	  assgnR->get_args().push_back( rhsT );
-	  temps.push_back( new ExprStmt(std::list<Label>(), assgnR) );
+					// create temporary for rhs, assign value
+					UntypedExpr *assgnR = new UntypedExpr( new NameExpr( "?=?" ) );
+					assgnR->get_args().push_back( new VariableExpr( rhs ) );
+					assgnR->get_args().push_back( rhsT );
+					temps.push_back( new ExprStmt(std::list<Label>(), assgnR) );
 
-	  // assign rhs to lhs
-	  UntypedExpr *assgn = new UntypedExpr( new NameExpr( "?=?" ) );
-	  UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-	  deref->get_args().push_back( new VariableExpr( lhs ) );
-	  assgn->get_args().push_back( deref );
-	  assgn->get_args().push_back( new VariableExpr( rhs ) );
-	  assigns.push_back( new ExprStmt(std::list<Label>(), assgn) );
-
-	} else
-	  throw CompilerError("Solved Tuple should contain only assignment statements");
+					// assign rhs to lhs
+					UntypedExpr *assgn = new UntypedExpr( new NameExpr( "?=?" ) );
+					UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+					deref->get_args().push_back( new VariableExpr( lhs ) );
+					assgn->get_args().push_back( deref );
+					assgn->get_args().push_back( new VariableExpr( rhs ) );
+					assigns.push_back( new ExprStmt(std::list<Label>(), assgn) );
+				} else
+					throw CompilerError("Solved Tuple should contain only assignment statements");
 	  
-	extra.splice( extra.begin(), decls );
-	extra.splice( extra.end(), temps );
-	extra2.splice( extra2.end(), assigns );
-      }
-
-      return tupleExpr;
-    }
-
-    throw 0; // shouldn't be here
-  }
-
-
+				extra.splice( extra.begin(), decls );
+				extra.splice( extra.end(), temps );
+				extra2.splice( extra2.end(), assigns );
+			} // for
+			return tupleExpr;
+		}
+		throw 0; // shouldn't be here
+	}
 } // namespace Tuples
 
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
