source: translator/Tuples/AssignExpand.cc @ ad8e062

#include <ctime>
#include <cstdlib>

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

#include "AssignExpand.h"

#include "SynTree/Type.h"
#include "SynTree/Statement.h"
#include "SynTree/Expression.h"
#include "SynTree/Declaration.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 (! 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_"), 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 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 );
      }

      return tupleExpr;
    }

    throw 0; // shouldn't be here
  }


} // namespace Tuples