source: src/Tuples/FunctionChecker.cc@ 0caaa6a

//
// 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.
//
// FunctionChecker.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:17:19 2015
// Update Count     : 4
//

#include "FunctionChecker.h"
#include "FunctionFixer.h"
#include "Common/SemanticError.h"

#include <algorithm>
#include <iostream>
#include <cassert>

namespace Tuples {
        using namespace std;

        void checkFunctions( std::list< Declaration * > translationUnit ) {
                FunctionChecker fchk( true );
                TupleDistrib td;
                FunctionFixer ff;

                mutateAll( translationUnit , fchk );
                mutateAll( translationUnit , ff );
                mutateAll( translationUnit , td );
                return;
        }

        FunctionChecker::FunctionChecker( bool _topLevel, UniqueName *_nameGen ) : topLevel( _topLevel ), nameGen( _nameGen ) {
                if ( topLevel ) {
                        assert( ! nameGen );
                        nameGen = new UniqueName("_MVR_");
                } else
                        assert( nameGen );
        }

        FunctionChecker::~FunctionChecker() {
                if ( topLevel ) {
                        delete nameGen;
                        nameGen = 0;
                }
        }

        Statement* FunctionChecker::mutate( ExprStmt *exprStmt ) {
                exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
                if ( ! tempExpr.empty() ) {
                        assert ( ! temporaries.empty() );
                        CompoundStmt *newBlock = new CompoundStmt( std::list< Label >() );
                        // declarations
                        for ( std::list< ObjectDecl *>::iterator d = temporaries.begin(); d != temporaries.end(); ++d )
                                newBlock->get_kids().push_back( new DeclStmt( std::list<Label>(), *d ) );
                        // new expression statements
                        for ( std::list< Expression *>::iterator e = tempExpr.begin(); e != tempExpr.end(); ++e )
                                newBlock->get_kids().push_back( new ExprStmt( std::list<Label>(), *e ) );

                        newBlock->get_kids().push_back( exprStmt );
                        return newBlock;
                } else
                        return exprStmt;
        }

        Expression* FunctionChecker::mutate( ApplicationExpr *applicationExpr ) {
                if ( topLevel )
                        ; // In top level of Functionchecker

                if ( applicationExpr->get_results().size() > 1 ) {
                        for ( std::list< Type *>::iterator res = applicationExpr->get_results().begin(); res != applicationExpr->get_results().end(); res++ )
                                temporaries.push_back( new ObjectDecl( nameGen->newName(), DeclarationNode::Auto, LinkageSpec::AutoGen, 0, (*res )->clone(), 0 ) );

                        assert( ! temporaries.empty() );
                }

                applicationExpr->set_function(  maybeMutate( applicationExpr->get_function(), *this ) );

                std::list< Expression * > newArgs;
                for ( std::list< Expression *>::iterator e = applicationExpr->get_args().begin(); e != applicationExpr->get_args().end(); ++e ) {
                        FunctionChecker rec( false, nameGen );
                        (*e )->acceptMutator( rec );

                        if ( ! rec.temporaries.empty() ) {
                                TupleExpr *lhs = new TupleExpr;
                                std::list< Expression * > &tmem = lhs->get_exprs();
                                for ( std::list<ObjectDecl *>::iterator d = rec.temporaries.begin();  d != rec.temporaries.end(); ++d ) {
                                        tmem.push_back( new VariableExpr( *d ) );
                                        newArgs.push_back( new VariableExpr( *d ) );
                                }

                                // construct tuple assignment
                                std::list<Expression *> args;
                                args.push_back( new AddressExpr( lhs ) );
                                args.push_back( *e );
                                tempExpr.push_back( new UntypedExpr( new NameExpr("?=?"), args ) );

                                temporaries.splice( temporaries.end(), rec.temporaries );
                        } else
                                newArgs.push_back( *e );
                        // percolate to recursive calls
                }

                applicationExpr->get_args().clear();
                std::copy( newArgs.begin(), newArgs.end(), back_inserter( applicationExpr->get_args()) );

                return applicationExpr;
        }

        Expression* TupleDistrib::mutate( UntypedExpr *expr ) {
                if (  NameExpr *assgnop = dynamic_cast< NameExpr * >( expr->get_function()) ) {
                        if ( assgnop->get_name() == std::string("?=?") ) {
                                std::list<Expression *> &args = expr->get_args();
                                assert( args.size() == 2 );
                                //if args.front() points to a tuple and if args.back() is already resolved
                                if ( AddressExpr *addr = dynamic_cast<AddressExpr *>( args.front()) )
                                        if ( TupleExpr *lhs = dynamic_cast<TupleExpr *>( addr->get_arg()) )
                                                if ( ApplicationExpr *rhs = dynamic_cast<ApplicationExpr *>( args.back() ) ) {
                                                        for ( std::list<Expression *>::iterator tc = lhs->get_exprs().begin(); tc != lhs->get_exprs().end(); ++tc )
                                                                rhs->get_args().push_back( new AddressExpr( *tc ) );
                                                        return rhs; // XXX
                                                } // if
                        } else
                                assert( false ); // It's not an assignment, shouldn't be here
                } // if
                return expr;
        }

}

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