source: src/ResolvExpr/FindOpenVars.cc

Last change on this file was 3e5dd913, checked in by Fangren Yu <f37yu@…>, 12 months ago

reimplement function type and eliminate deep copy

  • Property mode set to 100644
File size: 5.4 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// FindOpenVars.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 09:42:48 2015
11// Last Modified By : Andrew
12// Last Modified On : Fri Jul 12 14:18:00 2019
13// Update Count     : 4
14//
15
16#include "FindOpenVars.h"
17
18#include <list>                   // for _List_const_iterator, list<>::const...
19#include <map>                    // for map<>::mapped_type
20
21#include "AST/Pass.hpp"
22#include "AST/Type.hpp"
23#include "Common/PassVisitor.h"
24#include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
25#include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
26
27namespace ResolvExpr {
28        struct FindOpenVars_old : public WithGuards {
29                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
30
31                void previsit( const PointerType * pointerType );
32                void previsit( const ArrayType * arrayType );
33                void previsit( const FunctionType * functionType );
34                void previsit( const TupleType * tupleType );
35
36                void common_action( const Type *type );
37
38                OpenVarSet &openVars, &closedVars;
39                AssertionSet &needAssertions, &haveAssertions;
40                bool nextIsOpen;
41        };
42
43        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
44                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
45                type->accept( finder );
46        }
47
48        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
49                : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
50        }
51
52        void FindOpenVars_old::common_action( const Type * type ) {
53                if ( nextIsOpen ) {
54                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
55                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
56                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
57                                        needAssertions[ *assert ].isUsed = false;
58                                }
59///       cloneAll( (*i)->get_assertions(), needAssertions );
60///       needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
61                        }
62                } else {
63                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
64                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
65                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
66                                        haveAssertions[ *assert ].isUsed = false;
67                                }
68///       cloneAll( (*i)->get_assertions(), haveAssertions );
69///       haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
70                        } // for
71                } // if
72///   std::cerr << "type is ";
73///   type->print( std::cerr );
74///   std::cerr << std::endl << "need is" << std::endl;
75///   printAssertionSet( needAssertions, std::cerr );
76///   std::cerr << std::endl << "have is" << std::endl;
77///   printAssertionSet( haveAssertions, std::cerr );
78        }
79
80        void FindOpenVars_old::previsit(const PointerType * pointerType) {
81                common_action( pointerType );
82        }
83
84        void FindOpenVars_old::previsit(const ArrayType * arrayType) {
85                common_action( arrayType );
86        }
87
88        void FindOpenVars_old::previsit(const FunctionType * functionType) {
89                common_action( functionType );
90                nextIsOpen = ! nextIsOpen;
91                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
92        }
93
94        void FindOpenVars_old::previsit(const TupleType * tupleType) {
95                common_action( tupleType );
96        }
97
98        namespace {
99                struct FindOpenVars_new final : public ast::WithGuards {
100                        ast::OpenVarSet & open;
101                        ast::OpenVarSet & closed;
102                        ast::AssertionSet & need;
103                        ast::AssertionSet & have;
104                        bool nextIsOpen;
105
106                        FindOpenVars_new(
107                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
108                                ast::AssertionSet & h, FirstMode firstIsOpen )
109                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
110
111                        void previsit( const ast::FunctionType * type ) {
112                                // mark open/closed variables
113                                if ( nextIsOpen ) {
114                                        for ( auto & decl : type->forall ) {
115                                                open[ *decl ] = ast::TypeDecl::Data{ decl->base };
116                                        }
117                                        for ( auto & assert : type->assertions ) {
118                                                need[ assert ].isUsed = false;
119                                        }
120                                } else {
121                                        for ( auto & decl : type->forall ) {
122                                                closed[ *decl ] = ast::TypeDecl::Data{ decl->base };   
123                                        }
124                                        for ( auto & assert : type->assertions ) {
125                                                have[ assert ].isUsed = false;
126                                        }
127                                }
128
129                                // flip open variables for contained function types
130                                nextIsOpen = ! nextIsOpen;
131                                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
132                        }
133
134                };
135        }
136
137        void findOpenVars(
138                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
139                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
140                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
141                type->accept( finder );
142        }
143} // namespace ResolvExpr
144
145// Local Variables: //
146// tab-width: 4 //
147// mode: c++ //
148// compile-command: "make install" //
149// End: //
Note: See TracBrowser for help on using the repository browser.