source: src/ResolvExpr/AlternativeFinder.h @ e472d54

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since e472d54 was e472d54, checked in by Aaron Moss <a3moss@…>, 5 years ago

Remove broken polymorphic exponentiation from prelude

  • Property mode set to 100644
File size: 7.1 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// AlternativeFinder.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sat May 16 23:56:12 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Jul 26 11:24:00 2017
13// Update Count     : 4
14//
15
16#pragma once
17
18#include <algorithm>                     // for copy
19#include <list>                          // for list
20#include <string>                        // for string
21
22#include "Alternative.h"                 // for AltList, Alternative
23#include "ResolvExpr/Cost.h"             // for Cost, Cost::infinity
24#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
25#include "SynTree/Visitor.h"             // for Visitor
26#include "SynTree/SynTree.h"             // for Visitor Nodes
27
28namespace SymTab {
29class Indexer;
30}  // namespace SymTab
31
32namespace ResolvExpr {
33        class AlternativeFinder : public Visitor {
34          public:
35                AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
36
37                AlternativeFinder( const AlternativeFinder& o )
38                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env), 
39                          targetType(o.targetType) {}
40               
41                AlternativeFinder( AlternativeFinder&& o )
42                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env), 
43                          targetType(o.targetType) {}
44               
45                AlternativeFinder& operator= ( const AlternativeFinder& o ) {
46                        if (&o == this) return *this;
47                       
48                        // horrific nasty hack to rebind references...
49                        alternatives.~AltList();
50                        new(this) AlternativeFinder(o);
51                        return *this;
52                }
53
54                AlternativeFinder& operator= ( AlternativeFinder&& o ) {
55                        if (&o == this) return *this;
56                       
57                        // horrific nasty hack to rebind references...
58                        alternatives.~AltList();
59                        new(this) AlternativeFinder(std::move(o));
60                        return *this;
61                }
62
63                void find( Expression *expr, bool adjust = false, bool prune = true );
64                /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
65                void findWithAdjustment( Expression *expr, bool prune = true );
66                AltList &get_alternatives() { return alternatives; }
67
68                // make this look like an STL container so that we can apply generic algorithms
69                typedef Alternative value_type;
70                typedef AltList::iterator iterator;
71                typedef AltList::const_iterator const_iterator;
72                AltList::iterator begin() { return alternatives.begin(); }
73                AltList::iterator end() { return alternatives.end(); }
74                AltList::const_iterator begin() const { return alternatives.begin(); }
75                AltList::const_iterator end() const { return alternatives.end(); }
76
77                const SymTab::Indexer &get_indexer() const { return indexer; }
78                const TypeEnvironment &get_environ() const { return env; }
79          private:
80                virtual void visit( ApplicationExpr *applicationExpr );
81                virtual void visit( UntypedExpr *untypedExpr );
82                virtual void visit( AddressExpr *addressExpr );
83                virtual void visit( LabelAddressExpr *labelExpr );
84                virtual void visit( CastExpr *castExpr );
85                virtual void visit( VirtualCastExpr *castExpr );
86                virtual void visit( UntypedMemberExpr *memberExpr );
87                virtual void visit( MemberExpr *memberExpr );
88                virtual void visit( NameExpr *variableExpr );
89                virtual void visit( VariableExpr *variableExpr );
90                virtual void visit( ConstantExpr *constantExpr );
91                virtual void visit( SizeofExpr *sizeofExpr );
92                virtual void visit( AlignofExpr *alignofExpr );
93                virtual void visit( UntypedOffsetofExpr *offsetofExpr );
94                virtual void visit( OffsetofExpr *offsetofExpr );
95                virtual void visit( OffsetPackExpr *offsetPackExpr );
96                virtual void visit( AttrExpr *attrExpr );
97                virtual void visit( LogicalExpr *logicalExpr );
98                virtual void visit( ConditionalExpr *conditionalExpr );
99                virtual void visit( CommaExpr *commaExpr );
100                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
101                virtual void visit( ConstructorExpr * ctorExpr );
102                virtual void visit( RangeExpr * rangeExpr );
103                virtual void visit( UntypedTupleExpr *tupleExpr );
104                virtual void visit( TupleExpr *tupleExpr );
105                virtual void visit( TupleIndexExpr *tupleExpr );
106                virtual void visit( TupleAssignExpr *tupleExpr );
107                virtual void visit( UniqueExpr *unqExpr );
108                virtual void visit( StmtExpr *stmtExpr );
109                virtual void visit( UntypedInitExpr *initExpr );
110                /// Runs a new alternative finder on each element in [begin, end)
111                /// and writes each alternative finder to out.
112                template< typename InputIterator, typename OutputIterator >
113                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
114
115                /// Adds alternatives for anonymous members
116                void addAnonConversions( const Alternative & alt );
117                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
118                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
119                /// Adds alternatives for member expressions where the left side has tuple type
120                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
121                /// Adds alternatives for offsetof expressions, given the base type and name of the member
122                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
123                template<typename OutputIterator>
124                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const std::vector< AlternativeFinder >& args, OutputIterator out );
125                template< typename OutputIterator >
126                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
127                void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );
128
129                const SymTab::Indexer &indexer;
130                AltList alternatives;
131                const TypeEnvironment &env;
132                Type * targetType = nullptr;
133        }; // AlternativeFinder
134
135        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
136
137        template< typename InputIterator, typename OutputIterator >
138        void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
139                AltList alternatives;
140
141                // select the alternatives that have the minimum parameter cost
142                Cost minCost = Cost::infinity;
143                for ( InputIterator i = begin; i != end; ++i ) {
144                        if ( i->cost < minCost ) {
145                                minCost = i->cost;
146                                i->cost = i->cvtCost;
147                                alternatives.clear();
148                                alternatives.push_back( *i );
149                        } else if ( i->cost == minCost ) {
150                                i->cost = i->cvtCost;
151                                alternatives.push_back( *i );
152                        }
153                }
154                std::copy( alternatives.begin(), alternatives.end(), out );
155        }
156
157        Cost sumCost( const AltList &in );
158
159        template< typename InputIterator >
160        void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
161                while ( begin != end ) {
162                        result.simpleCombine( (*begin++).env );
163                }
164        }
165} // namespace ResolvExpr
166
167// Local Variables: //
168// tab-width: 4 //
169// mode: c++ //
170// compile-command: "make install" //
171// End: //
Note: See TracBrowser for help on using the repository browser.