Changes in src/GenPoly/FindFunction.cc [c6b4432:c97b448]

File:

• src/GenPoly/FindFunction.cc (modified) (4 diffs)

src/GenPoly/FindFunction.cc

@@ -20 +20 @@
 #include "AST/Pass.hpp"                 // for Pass
 #include "AST/Type.hpp"
+#include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 #include "GenPoly/GenPoly.h"            // for TyVarMap
 #include "ScrubTyVars.h"                // for ScrubTyVars
+#include "SynTree/Declaration.h"        // for DeclarationWithType, TypeDecl
+#include "SynTree/Mutator.h"            // for Mutator, mutateAll
+#include "SynTree/Type.h"               // for FunctionType, Type, Type::For...
 
 namespace GenPoly {
+        class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
+          public:
+                FindFunction( std::list< FunctionType const* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
+
+                void premutate( FunctionType * functionType );
+                Type * postmutate( FunctionType * functionType );
+                void premutate( PointerType * pointerType );
+          private:
+                void handleForall( const Type::ForallList &forall );
+
+                std::list< FunctionType const * > & functions;
+                TyVarMap tyVars;
+                bool replaceMode;
+                FindFunctionPredicate predicate;
+        };
+
+        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
+                PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
+                type->acceptMutator( finder );
+        }
+
+        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
+                PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
+                type = type->acceptMutator( finder );
+        }
+
+        FindFunction::FindFunction( std::list< FunctionType const * > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate )
+                : functions( functions ), tyVars( tyVars ), replaceMode( replaceMode ), predicate( predicate ) {
+        }
+
+        void FindFunction::handleForall( const Type::ForallList &forall ) {
+                for ( const Declaration * td : forall ) {
+                        TyVarMap::iterator var = tyVars.find( td->name );
+                        if ( var != tyVars.end() ) {
+                                tyVars.erase( var->first );
+                        } // if
+                } // for
+        }
+
+        void FindFunction::premutate( FunctionType * functionType ) {
+                visit_children = false;
+                GuardScope( tyVars );
+                handleForall( functionType->get_forall() );
+                mutateAll( functionType->get_returnVals(), *visitor );
+        }
+
+        Type * FindFunction::postmutate( FunctionType * functionType ) {
+                Type *ret = functionType;
+                if ( predicate( functionType, tyVars ) ) {
+                        functions.push_back( functionType );
+                        if ( replaceMode ) {
+                                // replace type parameters in function type with void*
+                                ret = ScrubTyVars::scrub( functionType->clone(), tyVars );
+                        } // if
+                } // if
+                return ret;
+        }
+
+        void FindFunction::premutate( PointerType * pointerType ) {
+                GuardScope( tyVars );
+                handleForall( pointerType->get_forall() );
+        }
 
 namespace {
@@ -88 +154 @@
 void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
         GuardScope( typeVars );
+        //handleForall( type->forall );
 }
 
@@ -97 +164 @@
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
         type->accept( pass );
+        //(void)type;
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
 }
 
@@ -104 +175 @@
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
         return type->accept( pass );
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+        //return type;
 }