source: src/SymTab/Indexer.cc@ 22bc276

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 22bc276 was 33a25f9, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

Remove visitor feature from Indexer
  • Property mode set to 100644
File size: 24.8 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// Indexer.cc --
8//
9// Author : Richard C. Bilson
10// Created On : Sun May 17 21:37:33 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Aug 17 16:08:40 2017
13// Update Count : 20
14//
15
16#include "Indexer.h"
17
18#include <cassert> // for assert, strict_dynamic_cast
19#include <iostream> // for operator<<, basic_ostream, ostream
20#include <string> // for string, operator<<, operator!=
21#include <unordered_map> // for operator!=, unordered_map<>::const...
22#include <unordered_set> // for unordered_set
23#include <utility> // for pair, make_pair, move
24
25#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
26#include "Common/SemanticError.h" // for SemanticError
27#include "Common/utility.h" // for cloneAll
28#include "InitTweak/InitTweak.h" // for isConstructor, isCopyFunction, isC...
29#include "Mangler.h" // for Mangler
30#include "Parser/LinkageSpec.h" // for isMangled, isOverridable, Spec
31#include "ResolvExpr/typeops.h" // for typesCompatible
32#include "SynTree/Constant.h" // for Constant
33#include "SynTree/Declaration.h" // for DeclarationWithType, FunctionDecl
34#include "SynTree/Expression.h" // for Expression, ImplicitCopyCtorExpr
35#include "SynTree/Initializer.h" // for Initializer
36#include "SynTree/Statement.h" // for CompoundStmt, Statement, ForStmt (...
37#include "SynTree/Type.h" // for Type, StructInstType, UnionInstType
38
39#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
40
41namespace SymTab {
42 struct NewScope {
43 NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
44 ~NewScope() { indexer.leaveScope(); }
45 SymTab::Indexer & indexer;
46 };
47
48 template< typename TreeType, typename VisitorType >
49 inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
50 visitor.enterScope();
51 maybeAccept( tree, visitor );
52 visitor.leaveScope();
53 }
54
55 typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
56 typedef std::unordered_map< std::string, MangleTable > IdTable;
57 typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
58 typedef std::unordered_map< std::string, StructDecl* > StructTable;
59 typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
60 typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
61 typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
62
63 void dump( const IdTable &table, std::ostream &os ) {
64 for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
65 for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
66 os << mangle->second << std::endl;
67 }
68 }
69 }
70
71 template< typename Decl >
72 void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
73 for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
74 os << it->second << std::endl;
75 } // for
76 }
77
78 struct Indexer::Impl {
79 Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
80 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
81 Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
82 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
83 unsigned long refCount; ///< Number of references to these tables
84 unsigned long scope; ///< Scope these tables are associated with
85 unsigned long size; ///< Number of elements stored in this table
86 const Indexer base; ///< Base indexer this extends
87
88 IdTable idTable; ///< Identifier namespace
89 TypeTable typeTable; ///< Type namespace
90 StructTable structTable; ///< Struct namespace
91 EnumTable enumTable; ///< Enum namespace
92 UnionTable unionTable; ///< Union namespace
93 TraitTable traitTable; ///< Trait namespace
94 };
95
96 Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
97 if ( ! toClone ) return 0;
98
99 // shorten the search chain by skipping empty links
100 Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
101 if ( ret ) { ++ret->refCount; }
102
103 return ret;
104 }
105
106 void Indexer::deleteRef( Indexer::Impl *toFree ) {
107 if ( ! toFree ) return;
108
109 if ( --toFree->refCount == 0 ) delete toFree;
110 }
111
112 void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
113 // only need to perform this step for constructors, destructors, and assignment functions
114 if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
115
116 // helpful data structure
117 struct ValueType {
118 struct DeclBall {
119 FunctionDecl * decl;
120 bool isUserDefinedFunc; // properties for this particular decl
121 bool isDefaultCtor;
122 bool isDtor;
123 bool isCopyFunc;
124 };
125 // properties for this type
126 bool existsUserDefinedFunc = false; // any user-defined function found
127 bool existsUserDefinedCtor = false; // any user-defined constructor found
128 bool existsUserDefinedDtor = false; // any user-defined destructor found
129 bool existsUserDefinedCopyFunc = false; // user-defined copy ctor found
130 bool existsUserDefinedDefaultCtor = false; // user-defined default ctor found
131 std::list< DeclBall > decls;
132
133 // another FunctionDecl for the current type was found - determine
134 // if it has special properties and update data structure accordingly
135 ValueType & operator+=( FunctionDecl * function ) {
136 bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
137 bool isDefaultCtor = InitTweak::isDefaultConstructor( function );
138 bool isDtor = InitTweak::isDestructor( function );
139 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
140 decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
141 existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
142 existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) );
143 existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor);
144 existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
145 existsUserDefinedDefaultCtor = existsUserDefinedDefaultCtor || (isUserDefinedFunc && isDefaultCtor);
146 return *this;
147 }
148 }; // ValueType
149
150 std::list< DeclarationWithType * > copy;
151 copy.splice( copy.end(), out );
152
153 // organize discovered declarations by type
154 std::unordered_map< std::string, ValueType > funcMap;
155 for ( DeclarationWithType * decl : copy ) {
156 if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
157 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
158 assert( ! params.empty() );
159 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
160 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
161 assert( base );
162 funcMap[ Mangler::mangle( base ) ] += function;
163 } else {
164 out.push_back( decl );
165 }
166 }
167
168 // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
169 // the set of ctor/dtor/assign that are seen by the requester. In particular, if the user defines
170 // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor
171 // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen.
172 // If the user defines any ctor then the generated default ctor should not be seen (intrinsic default
173 // ctor must be overridden exactly).
174 for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
175 ValueType & val = pair.second;
176 for ( ValueType::DeclBall ball : val.decls ) {
177 bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
178 bool isUserDefinedFunc = ball.isUserDefinedFunc;
179 bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
180 bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
181 bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
182 if ( noUserDefinedFunc || isUserDefinedFunc || isAcceptableDefaultCtor || isAcceptableCopyFunc || isAcceptableDtor ) {
183 // decl conforms to the rules described above, so it should be seen by the requester
184 out.push_back( ball.decl );
185 }
186 }
187 }
188 }
189
190 void Indexer::makeWritable() {
191 if ( ! tables ) {
192 // create indexer if not yet set
193 tables = new Indexer::Impl( scope );
194 } else if ( tables->refCount > 1 || tables->scope != scope ) {
195 // make this indexer the base of a fresh indexer at the current scope
196 tables = new Indexer::Impl( scope, std::move( *this ) );
197 }
198 }
199
200 Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
201
202 Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
203
204 Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
205 that.tables = 0;
206 }
207
208 Indexer::~Indexer() {
209 deleteRef( tables );
210 }
211
212 Indexer& Indexer::operator= ( const Indexer &that ) {
213 deleteRef( tables );
214
215 tables = newRef( that.tables );
216 scope = that.scope;
217 doDebug = that.doDebug;
218
219 return *this;
220 }
221
222 Indexer& Indexer::operator= ( Indexer &&that ) {
223 deleteRef( tables );
224
225 tables = that.tables;
226 scope = that.scope;
227 doDebug = that.doDebug;
228
229 that.tables = 0;
230
231 return *this;
232 }
233
234 void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
235 std::unordered_set< std::string > foundMangleNames;
236
237 Indexer::Impl *searchTables = tables;
238 while ( searchTables ) {
239
240 IdTable::const_iterator decls = searchTables->idTable.find( id );
241 if ( decls != searchTables->idTable.end() ) {
242 const MangleTable &mangleTable = decls->second;
243 for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
244 // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
245 if ( foundMangleNames.insert( decl->first ).second == false ) continue;
246
247 out.push_back( decl->second );
248 }
249 }
250
251 // get declarations from base indexers
252 searchTables = searchTables->base.tables;
253 }
254
255 // some special functions, e.g. constructors and destructors
256 // remove autogenerated functions when they are defined so that
257 // they can never be matched
258 removeSpecialOverrides( id, out );
259 }
260
261 NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
262 if ( ! tables ) return 0;
263
264 TypeTable::const_iterator ret = tables->typeTable.find( id );
265 return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
266 }
267
268 StructDecl *Indexer::lookupStruct( const std::string &id ) const {
269 if ( ! tables ) return 0;
270
271 StructTable::const_iterator ret = tables->structTable.find( id );
272 return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
273 }
274
275 EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
276 if ( ! tables ) return 0;
277
278 EnumTable::const_iterator ret = tables->enumTable.find( id );
279 return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
280 }
281
282 UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
283 if ( ! tables ) return 0;
284
285 UnionTable::const_iterator ret = tables->unionTable.find( id );
286 return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
287 }
288
289 TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
290 if ( ! tables ) return 0;
291
292 TraitTable::const_iterator ret = tables->traitTable.find( id );
293 return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
294 }
295
296 DeclarationWithType *Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
297 if ( ! tables ) return 0;
298 if ( tables->scope < scope ) return 0;
299
300 IdTable::const_iterator decls = tables->idTable.find( id );
301 if ( decls != tables->idTable.end() ) {
302 const MangleTable &mangleTable = decls->second;
303 MangleTable::const_iterator decl = mangleTable.find( mangleName );
304 if ( decl != mangleTable.end() ) return decl->second;
305 }
306
307 return tables->base.lookupIdAtScope( id, mangleName, scope );
308 }
309
310 bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
311 if ( ! tables ) return false;
312 if ( tables->scope < scope ) return false;
313
314 IdTable::const_iterator decls = tables->idTable.find( id );
315 if ( decls != tables->idTable.end() ) {
316 const MangleTable &mangleTable = decls->second;
317 for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
318 // check for C decls with the same name, skipping those with a compatible type (by mangleName)
319 if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true;
320 }
321 }
322
323 return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
324 }
325
326 bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
327 if ( ! tables ) return false;
328 if ( tables->scope < scope ) return false;
329
330 IdTable::const_iterator decls = tables->idTable.find( id );
331 if ( decls != tables->idTable.end() ) {
332 const MangleTable &mangleTable = decls->second;
333 for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
334 // check for C decls with the same name, skipping
335 // those with an incompatible type (by mangleName)
336 if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true;
337 }
338 }
339
340 return tables->base.hasCompatibleCDecl( id, mangleName, scope );
341 }
342
343 NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
344 if ( ! tables ) return 0;
345 if ( tables->scope < scope ) return 0;
346
347 TypeTable::const_iterator ret = tables->typeTable.find( id );
348 return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
349 }
350
351 StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
352 if ( ! tables ) return 0;
353 if ( tables->scope < scope ) return 0;
354
355 StructTable::const_iterator ret = tables->structTable.find( id );
356 return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
357 }
358
359 EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
360 if ( ! tables ) return 0;
361 if ( tables->scope < scope ) return 0;
362
363 EnumTable::const_iterator ret = tables->enumTable.find( id );
364 return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
365 }
366
367 UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
368 if ( ! tables ) return 0;
369 if ( tables->scope < scope ) return 0;
370
371 UnionTable::const_iterator ret = tables->unionTable.find( id );
372 return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
373 }
374
375 TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
376 if ( ! tables ) return 0;
377 if ( tables->scope < scope ) return 0;
378
379 TraitTable::const_iterator ret = tables->traitTable.find( id );
380 return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
381 }
382
383 bool addedIdConflicts( DeclarationWithType *existing, DeclarationWithType *added ) {
384 // if we're giving the same name mangling to things of different types then there is something wrong
385 assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing ) )
386 || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing ) ) );
387
388 if ( LinkageSpec::isOverridable( existing->get_linkage() ) ) {
389 // new definition shadows the autogenerated one, even at the same scope
390 return false;
391 } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
392 // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
393 // we should ignore outermost pointer qualifiers, except _Atomic?
394 FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( added );
395 FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( existing );
396 if ( newentry && oldentry ) {
397 if ( newentry->get_statements() && oldentry->get_statements() ) {
398 throw SemanticError( "duplicate function definition for ", added );
399 } // if
400 } else {
401 // two objects with the same mangled name defined in the same scope.
402 // both objects must be marked extern or both must be intrinsic for this to be okay
403 // xxx - perhaps it's actually if either is intrinsic then this is okay?
404 // might also need to be same storage class?
405 ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added );
406 ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
407 if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
408 throw SemanticError( "duplicate object definition for ", added );
409 } // if
410 } // if
411 } else {
412 throw SemanticError( "duplicate definition for ", added );
413 } // if
414
415 return true;
416 }
417
418 void Indexer::addId( DeclarationWithType *decl ) {
419 debugPrint( "Adding Id " << decl->name << std::endl );
420 makeWritable();
421
422 const std::string &name = decl->get_name();
423 std::string mangleName;
424 if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
425 // mangle the name without including the appropriate suffix, so overridable routines are placed into the
426 // same "bucket" as their user defined versions.
427 mangleName = Mangler::mangle( decl, false );
428 } else {
429 mangleName = Mangler::mangle( decl );
430 } // if
431
432 // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
433 if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) {
434 // NOTE this is broken in Richard's original code in such a way that it never triggers (it
435 // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
436 // have their name as their manglename, hence the error can never trigger).
437 // The code here is closer to correct, but name mangling would have to be completely
438 // isomorphic to C type-compatibility, which it may not be.
439 if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
440 throw SemanticError( "conflicting overload of C function ", decl );
441 }
442 } else {
443 // Check that a Cforall declaration doesn't overload any C declaration
444 if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
445 throw SemanticError( "Cforall declaration hides C function ", decl );
446 }
447 }
448
449 // Skip repeat declarations of the same identifier
450 DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
451 if ( existing && addedIdConflicts( existing, decl ) ) return;
452
453 // add to indexer
454 tables->idTable[ name ][ mangleName ] = decl;
455 ++tables->size;
456 }
457
458 bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
459 if ( existing->get_base() == 0 ) {
460 return false;
461 } else if ( added->get_base() == 0 ) {
462 return true;
463 } else {
464 throw SemanticError( "redeclaration of ", added );
465 }
466 }
467
468 void Indexer::addType( NamedTypeDecl *decl ) {
469 debugPrint( "Adding type " << decl->name << std::endl );
470 makeWritable();
471
472 const std::string &id = decl->get_name();
473 TypeTable::iterator existing = tables->typeTable.find( id );
474 if ( existing == tables->typeTable.end() ) {
475 NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
476 if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
477 tables->typeTable.insert( existing, std::make_pair( id, decl ) );
478 ++tables->size;
479 }
480 } else {
481 if ( ! addedTypeConflicts( existing->second, decl ) ) {
482 existing->second = decl;
483 }
484 }
485 }
486
487 bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
488 if ( existing->get_members().empty() ) {
489 return false;
490 } else if ( ! added->get_members().empty() ) {
491 throw SemanticError( "redeclaration of ", added );
492 } // if
493 return true;
494 }
495
496 void Indexer::addStruct( const std::string &id ) {
497 debugPrint( "Adding fwd decl for struct " << id << std::endl );
498 addStruct( new StructDecl( id ) );
499 }
500
501 void Indexer::addStruct( StructDecl *decl ) {
502 debugPrint( "Adding struct " << decl->name << std::endl );
503 makeWritable();
504
505 const std::string &id = decl->get_name();
506 StructTable::iterator existing = tables->structTable.find( id );
507 if ( existing == tables->structTable.end() ) {
508 StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
509 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
510 tables->structTable.insert( existing, std::make_pair( id, decl ) );
511 ++tables->size;
512 }
513 } else {
514 if ( ! addedDeclConflicts( existing->second, decl ) ) {
515 existing->second = decl;
516 }
517 }
518 }
519
520 void Indexer::addEnum( EnumDecl *decl ) {
521 debugPrint( "Adding enum " << decl->name << std::endl );
522 makeWritable();
523
524 const std::string &id = decl->get_name();
525 EnumTable::iterator existing = tables->enumTable.find( id );
526 if ( existing == tables->enumTable.end() ) {
527 EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
528 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
529 tables->enumTable.insert( existing, std::make_pair( id, decl ) );
530 ++tables->size;
531 }
532 } else {
533 if ( ! addedDeclConflicts( existing->second, decl ) ) {
534 existing->second = decl;
535 }
536 }
537 }
538
539 void Indexer::addUnion( const std::string &id ) {
540 debugPrint( "Adding fwd decl for union " << id << std::endl );
541 addUnion( new UnionDecl( id ) );
542 }
543
544 void Indexer::addUnion( UnionDecl *decl ) {
545 debugPrint( "Adding union " << decl->name << std::endl );
546 makeWritable();
547
548 const std::string &id = decl->get_name();
549 UnionTable::iterator existing = tables->unionTable.find( id );
550 if ( existing == tables->unionTable.end() ) {
551 UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
552 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
553 tables->unionTable.insert( existing, std::make_pair( id, decl ) );
554 ++tables->size;
555 }
556 } else {
557 if ( ! addedDeclConflicts( existing->second, decl ) ) {
558 existing->second = decl;
559 }
560 }
561 }
562
563 void Indexer::addTrait( TraitDecl *decl ) {
564 debugPrint( "Adding trait " << decl->name << std::endl );
565 makeWritable();
566
567 const std::string &id = decl->get_name();
568 TraitTable::iterator existing = tables->traitTable.find( id );
569 if ( existing == tables->traitTable.end() ) {
570 TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
571 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
572 tables->traitTable.insert( existing, std::make_pair( id, decl ) );
573 ++tables->size;
574 }
575 } else {
576 if ( ! addedDeclConflicts( existing->second, decl ) ) {
577 existing->second = decl;
578 }
579 }
580 }
581
582 void Indexer::enterScope() {
583 ++scope;
584
585 if ( doDebug ) {
586 std::cout << "--- Entering scope " << scope << std::endl;
587 }
588 }
589
590 void Indexer::leaveScope() {
591 using std::cout;
592
593 assert( scope > 0 && "cannot leave initial scope" );
594 --scope;
595
596 while ( tables && tables->scope > scope ) {
597 if ( doDebug ) {
598 cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
599 dump( tables->idTable, cout );
600 dump( tables->typeTable, cout );
601 dump( tables->structTable, cout );
602 dump( tables->enumTable, cout );
603 dump( tables->unionTable, cout );
604 dump( tables->traitTable, cout );
605 }
606
607 // swap tables for base table until we find one at an appropriate scope
608 Indexer::Impl *base = newRef( tables->base.tables );
609 deleteRef( tables );
610 tables = base;
611 }
612 }
613
614 void Indexer::print( std::ostream &os, int indent ) const {
615 using std::cerr;
616
617 if ( tables ) {
618 os << "--- scope " << tables->scope << " ---" << std::endl;
619
620 os << "===idTable===" << std::endl;
621 dump( tables->idTable, os );
622 os << "===typeTable===" << std::endl;
623 dump( tables->typeTable, os );
624 os << "===structTable===" << std::endl;
625 dump( tables->structTable, os );
626 os << "===enumTable===" << std::endl;
627 dump( tables->enumTable, os );
628 os << "===unionTable===" << std::endl;
629 dump( tables->unionTable, os );
630 os << "===contextTable===" << std::endl;
631 dump( tables->traitTable, os );
632
633 tables->base.print( os, indent );
634 } else {
635 os << "--- end ---" << std::endl;
636 }
637
638 }
639} // namespace SymTab
640
641// Local Variables: //
642// tab-width: 4 //
643// mode: c++ //
644// compile-command: "make install" //
645// End: //
Note: See TracBrowser for help on using the repository browser.