Changeset 51587aa for translator/Tuples/FunctionChecker.cc

Timestamp:

May 18, 2015, 11:45:33 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

01aeade

Parents:

0dd3a2f

Message:

licencing: fourth groups of files

File:

• translator/Tuples/FunctionChecker.cc (modified) (2 diffs)

translator/Tuples/FunctionChecker.cc

@@ +1 @@
+//
+// 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           : 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:59:55 2015
+// Update Count     : 3
+//
+
 #include "FunctionChecker.h"
 #include "FunctionFixer.h"
@@ -8 +23 @@
 
 namespace Tuples {
-  using namespace std;
+        using namespace std;
 
-  void checkFunctions( std::list< Declaration * > translationUnit )
-  {
-    FunctionChecker fchk(true);
-    TupleDistrib td;
-    FunctionFixer ff;
+        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(),Declaration::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 ) );
+                mutateAll( translationUnit , fchk );
+                mutateAll( translationUnit , ff );
+                mutateAll( translationUnit , td );
+                return;
         }
 
-        // 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 ) );
+        FunctionChecker::FunctionChecker( bool _topLevel, UniqueName *_nameGen ) : topLevel( _topLevel ), nameGen( _nameGen ) {
+                if ( topLevel ) {
+                        assert( ! nameGen );
+                        nameGen = new UniqueName("_MVR_");
+                } else
+                        assert( nameGen );
+        }
 
-        temporaries.splice( temporaries.end(), rec.temporaries );
-      } else
-        newArgs.push_back( *e );
-      // percolate to recursive calls
-    }
+        FunctionChecker::~FunctionChecker() {
+                if ( topLevel ) {
+                        delete nameGen;
+                        nameGen = 0;
+                }
+        }
 
-    applicationExpr->get_args().clear();
-    std::copy( newArgs.begin(), newArgs.end(), back_inserter(applicationExpr->get_args()) );
+        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 ) );
 
-    return applicationExpr;
-  }
+                        newBlock->get_kids().push_back( exprStmt );
+                        return newBlock;
+                } else
+                        return exprStmt;
+        }
 
-  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
-            }
-      } else
-        assert(false); // It's not an assignment, shouldn't be here
-    }
-    return expr;
-  }
+        Expression* FunctionChecker::mutate( ApplicationExpr *applicationExpr ) {
+                if ( topLevel )
+                        ; // In top level of Functionchecker
 
-} // namespace Tuples
+                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(),Declaration::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: //