source: src/ResolvExpr/TypeMap.h@ 79308c8e

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 79308c8e was 62e5546, checked in by Thierry Delisle <tdelisle@…>, 9 years ago

Removed warnings when compiling with clang
  • Property mode set to 100644
File size: 7.0 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// ScopedMap.h --
8//
9// Author : Aaron B. Moss
10// Created On : Fri Feb 19 13:55:00 2016
11// Last Modified By : Aaron B. Moss
12// Last Modified On : Fri Feb 19 13:55:00 2016
13// Update Count : 1
14//
15
16#ifndef _TYPEMAP_H
17#define _TYPEMAP_H
18
19#include <map>
20#include <string>
21#include <utility>
22#include <vector>
23
24#include "SynTree/Type.h"
25#include "SynTree/Visitor.h"
26
27namespace ResolvExpr {
28
29 /// A map from types to some value; lookup is done by structural decomposition on types.
30 /// The TypeMap stores its values by reference, so stored objects should be kept alive by the caller.
31 /// The scoping mechanism essentially by keeping a list of changes to roll back, then rolling them back
32 /// WARNING: This map is only incompletely and approximately consistent with the resolution rules in Unify.cc;
33 /// it has potential, if extended, to form the basis of a resolver that is more performant than the current
34 /// linear-search-by-unification approach, but is only currently used for finding assignment operators in GenPoly::box.
35 template< typename Value >
36 class TypeMap {
37 /// Map of names to types
38 typedef typename std::map< std::string, Value* > ValueMap;
39 typedef typename ValueMap::iterator ValueMapIterator;
40
41 Value *voidValue; ///< Value for void type
42 Value *basicValue[BasicType::NUMBER_OF_BASIC_TYPES]; ///< Values for basic types
43 Value *pointerValue; ///< Value for all pointer types
44 Value *voidPointerValue; ///< Value for void* types
45 Value *functionPointerValue; ///< Value for all function pointer types
46 ValueMap structValue; ///< Values for struct types, indexed by name
47 ValueMap unionValue; ///< Values for struct types, indexed by name
48 ValueMap enumValue; ///< Values for struct types, indexed by name
49
50 /// Information needed to roll back one scope change
51 struct Rollback {
52 /// One scope of pointer rollbacks
53 typedef std::vector< std::pair< Value **, Value* > > PointerScope;
54 /// One scope of map rollbacks
55 typedef std::vector< std::pair< ValueMapIterator, Value* > > MapScope;
56
57 PointerScope pointers; ///< Value pointers to roll back to their previous state
58 MapScope mapNodes; ///< Value map iterators to roll back to their previous state
59
60 void addRollback( Value **loc, Value *old ) {
61 pointers.push_back( std::make_pair( loc, old ) );
62 }
63
64 void addRollback( ValueMapIterator loc, Value *old ) {
65 mapNodes.push_back( std::make_pair( loc, old ) );
66 }
67 };
68
69 std::vector< Rollback > scopes; ///< Scope rollback information
70
71 struct Lookup : public Visitor {
72 Lookup( TypeMap<Value> &typeMap ) : typeMap( typeMap ), found( 0 ), toInsert( 0 ) {}
73
74 /// Inserts a new value into the map; returns the old value (if set, NULL otherwise).
75 /// key must be non-null.
76 Value *insert( Type *key, Value *val ) {
77 toInsert = val;
78 key->accept( *this );
79 return found;
80 }
81
82 /// Looks up a value in the map.
83 /// key must be non-null.
84 Value *find( Type *key ) {
85 //toInsert = 0;
86 key->accept( *this );
87 return found;
88 }
89
90 void findAndReplace( Value *&loc ) {
91 found = loc;
92 if ( toInsert ) {
93 typeMap.scopes.back().addRollback( &loc, found );
94 loc = toInsert;
95 }
96 }
97
98 void findAndReplace( ValueMap &map, const std::string &name ) {
99 ValueMapIterator loc = map.find( name );
100 if ( loc != map.end() ) {
101 found = loc->second;
102 if ( toInsert ) {
103 typeMap.scopes.back().addRollback( loc, found );
104 loc->second = toInsert;
105 }
106 } else if ( toInsert ) {
107 loc = map.insert( loc, std::make_pair( name, toInsert ) );
108 typeMap.scopes.back().addRollback( loc, found );
109 }
110 }
111
112 virtual void visit( VoidType *voidType ) {
113 findAndReplace( typeMap.voidValue );
114 }
115
116 virtual void visit( BasicType *basicType ) {
117 findAndReplace( typeMap.basicValue[basicType->get_kind()] );
118 }
119
120 virtual void visit( PointerType *pointerType ) {
121 // NOTE This is one of the places where the apporoximation of the resolver is (deliberately) poor;
122 // A better version would likely not equate all pointer types to a match.
123 if ( dynamic_cast< FunctionType* >( pointerType->get_base() ) ) {
124 findAndReplace( typeMap.functionPointerValue );
125 } else if ( dynamic_cast< VoidType* >( pointerType->get_base() ) ) {
126 findAndReplace( typeMap.voidPointerValue );
127 } else {
128 findAndReplace( typeMap.pointerValue );
129 }
130 }
131
132 virtual void visit( ArrayType *arrayType ) {
133 if ( dynamic_cast< FunctionType* >( arrayType->get_base() ) ) {
134 findAndReplace( typeMap.functionPointerValue );
135 } else {
136 findAndReplace( typeMap.pointerValue );
137 }
138 }
139
140 virtual void visit( FunctionType *functionType ) {
141 findAndReplace( typeMap.functionPointerValue );
142 }
143
144 virtual void visit( StructInstType *structType ) {
145 findAndReplace( typeMap.structValue, structType->get_name() );
146 }
147
148 virtual void visit( UnionInstType *unionType ) {
149 findAndReplace( typeMap.unionValue, unionType->get_name() );
150 }
151
152 virtual void visit( EnumInstType *enumType ) {
153 findAndReplace( typeMap.enumValue, enumType->get_name() );
154 }
155
156 TypeMap<Value> &typeMap; ///< map storage
157 Value *found; ///< Value found (NULL if none yet)
158 Value *toInsert; ///< Value to insert (NULL if a lookup)
159 }; // struct Lookup
160 friend struct Lookup;
161
162 public:
163 /// Starts a new scope
164 void beginScope() {
165 Rollback scope;
166 scopes.push_back(scope);
167 }
168
169 /// Ends a scope; rolls back any changes made during that scope
170 void endScope() {
171 Rollback &scope = scopes.back();
172 /// Roll back pointer changes
173 for (unsigned i = 0; i < scope.pointers.size(); ++i) {
174 *scope.pointers[i].first = scope.pointers[i].second;
175 }
176 /// Roll back map changes
177 for (unsigned i = 0; i < scope.mapNodes.size(); ++i) {
178 scope.mapNodes[i].first->second = scope.mapNodes[i].second;
179 }
180 scopes.pop_back();
181 }
182
183 TypeMap() : voidValue( 0 ), pointerValue( 0 ), voidPointerValue( 0 ), functionPointerValue( 0 ), structValue(), unionValue(), enumValue(), scopes() {
184 beginScope();
185 for (int i = 0; i < BasicType::NUMBER_OF_BASIC_TYPES; ++i) { basicValue[i] = 0; }
186 }
187
188 /// Inserts a new value into the map; returns the old value (if set, NULL otherwise).
189 /// key, val must be non-null.
190 Value *insert( Type *key, Value *val ) {
191 Lookup searcher( *this );
192 return searcher.insert( key, val );
193 }
194
195 /// Looks up a value in the map.
196 /// key must be non-null
197 Value *find( Type *key ) {
198 Lookup searcher( *this );
199 return searcher.find( key );
200 }
201
202 }; // class TypeMap
203
204} // namespace ResolvExpr
205
206#endif // _TYPEMAP_H
207
208// Local Variables: //
209// tab-width: 4 //
210// mode: c++ //
211// compile-command: "make install" //
212// End: //
Note: See TracBrowser for help on using the repository browser.