Changeset b067d9b for src/ResolvExpr/FindOpenVars.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/FindOpenVars.cc (modified) (7 diffs)

src/ResolvExpr/FindOpenVars.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:42:48 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 09:45:25 2015
-// Update Count     : 3
+// Last Modified By : Andrew
+// Last Modified On : Fri Jul 12 14:18:00 2019
+// Update Count     : 4
 //
 
@@ -19 +19 @@
 #include <map>                    // for map<>::mapped_type
 
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
@@ -24 +26 @@
 
 namespace ResolvExpr {
-        struct FindOpenVars : public WithGuards {
-                FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
+        struct FindOpenVars_old : public WithGuards {
+                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
 
-                void previsit( PointerType * pointerType );
-                void previsit( ArrayType * arrayType );
-                void previsit( FunctionType * functionType );
-                void previsit( TupleType * tupleType );
+                void previsit( const PointerType * pointerType );
+                void previsit( const ArrayType * arrayType );
+                void previsit( const FunctionType * functionType );
+                void previsit( const TupleType * tupleType );
 
-                void common_action( Type *type );
+                void common_action( const Type *type );
 
                 OpenVarSet &openVars, &closedVars;
@@ -39 +41 @@
         };
 
-        void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
+        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
+                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
                 type->accept( finder );
         }
 
-        FindOpenVars::FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
+        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
                 : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
         }
 
-        void FindOpenVars::common_action( Type *type ) {
+        void FindOpenVars_old::common_action( const Type * type ) {
                 if ( nextIsOpen ) {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
@@ -59 +61 @@
                         }
                 } else {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
@@ -76 +78 @@
         }
 
-        void FindOpenVars::previsit(PointerType *pointerType) {
+        void FindOpenVars_old::previsit(const PointerType * pointerType) {
                 common_action( pointerType );
         }
 
-        void FindOpenVars::previsit(ArrayType *arrayType) {
+        void FindOpenVars_old::previsit(const ArrayType * arrayType) {
                 common_action( arrayType );
         }
 
-        void FindOpenVars::previsit(FunctionType *functionType) {
+        void FindOpenVars_old::previsit(const FunctionType * functionType) {
                 common_action( functionType );
                 nextIsOpen = ! nextIsOpen;
@@ -90 +92 @@
         }
 
-        void FindOpenVars::previsit(TupleType *tupleType) {
+        void FindOpenVars_old::previsit(const TupleType * tupleType) {
                 common_action( tupleType );
+        }
+
+        namespace {
+                struct FindOpenVars_new final : public ast::WithGuards {
+                        ast::OpenVarSet & open;
+                        ast::OpenVarSet & closed;
+                        ast::AssertionSet & need;
+                        ast::AssertionSet & have;
+                        bool nextIsOpen;
+
+                        FindOpenVars_new(
+                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
+                                ast::AssertionSet & h, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
+
+                        void previsit( const ast::FunctionType * type ) {
+                                // mark open/closed variables
+                                if ( nextIsOpen ) {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                open[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        need[ assert ].isUsed = false;
+                                                }
+                                        }
+                                } else {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                closed[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        have[ assert ].isUsed = false;
+                                                }
+                                        }
+                                }
+
+                                // flip open variables for contained function types
+                                nextIsOpen = ! nextIsOpen;
+                                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
+                        }
+
+                };
+        }
+
+        void findOpenVars(
+                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
+                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                type->accept( finder );
         }
 } // namespace ResolvExpr