source: src/Tuples/AssignExpand.cc @ 08a40fd

//
// 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           : Rodolfo G. Esteves
// Created On       : Mon May 18 07:44:20 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Sat Jun 13 08:16:39 2015
// Update Count     : 4
//

#include <ctime>
#include <cstdlib>

#include <list>
#include <cassert>
#include <algorithm>

#include "AssignExpand.h"

#include "Parser/ParseNode.h"

#include "SynTree/Type.h"
#include "SynTree/Declaration.h"
#include "SynTree/Expression.h"
#include "SynTree/Statement.h"

namespace Tuples {
        AssignExpander::AssignExpander() : temporaryNamer("__tpl") {}

        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>());

                        newSt->get_kids().splice(newSt->get_kids().end(), extra);
                } // if

                if ( ! extra2.empty() ) {
                        if ( ! newSt )
                                newSt= new CompoundStmt(std::list<Label>());

                        newSt->get_kids().splice(newSt->get_kids().end(), extra2);
                }

                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 ));
                }

                if ( newSt ) return newSt; else return exprStmt;
        }

        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 ) ));

                   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 ||
                   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 );

                                        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_"), DeclarationNode::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_"), DeclarationNode::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 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");
          
                                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: //