Changeset 46f6134


Ignore:
Timestamp:
Aug 29, 2016, 12:20:45 PM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
ad4581b, b542bfb
Parents:
5e644d3e
Message:

Implemented owning scoped map for typedef elimination phase

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/ScopedMap.h

    r5e644d3e r46f6134  
    4242                typedef typename Scope::pointer pointer;
    4343                typedef typename Scope::const_pointer const_pointer;
    44                
     44
    4545                class iterator : public std::iterator< std::bidirectional_iterator_tag,
    4646                                                       value_type > {
     
    6868                        }
    6969
    70                         iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
     70                        iterator(scope_list &_scopes, const wrapped_iterator &_it, size_type _i)
    7171                                : scopes(&_scopes), it(_it), i(_i) {}
    7272                public:
     
    7676                                return *this;
    7777                        }
    78                        
     78
    7979                        reference operator* () { return *it; }
    8080                        pointer operator-> () { return it.operator->(); }
     
    109109
    110110                private:
    111                         scope_list const *scopes;
     111                        scope_list *scopes;
    112112                        wrapped_iterator it;
    113113                        size_type i;
     
    189189                        size_type i;
    190190                };
    191                
     191
    192192                /// Starts a new scope
    193193                void beginScope() {
    194                         Scope scope;
    195                         scopes.push_back(scope);
     194                        scopes.emplace_back();
    196195                }
    197196
     
    227226                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
    228227                }
    229                
     228
    230229                /// Finds the given key in the outermost scope inside the given scope where it occurs
    231230                iterator findNext( const_iterator &it, const Key &key ) {
     
    247246                        return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
    248247                }
     248
     249                std::pair< iterator, bool > insert( value_type &&value ) {
     250                        std::pair< typename Scope::iterator, bool > res = scopes.back().insert( std::move( value ) );
     251                        return std::make_pair( iterator(scopes, std::move( res.first ), scopes.size()-1), std::move( res.second ) );
     252                }
     253
    249254                std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
     255                std::pair< iterator, bool > insert( const Key &key, Value &&value ) { return insert( std::make_pair( key, std::move( value ) ) ); }
    250256
    251257                Value& operator[] ( const Key &key ) {
     
    254260                        return insert( key, Value() ).first->second;
    255261                }
     262
     263                iterator erase( iterator pos ) {
     264                        Scope& scope = (*pos.scopes) [ pos.i ];
     265                        const typename iterator::wrapped_iterator& new_it = scope.erase( pos.it );
     266                        iterator it( *pos.scopes, new_it, pos.i );
     267                        return it.next_valid();
     268                }
     269
     270                size_type count( const Key &key ) const {
     271                        size_type c = 0;
     272                        auto it = find( key );
     273                        auto end = cend();
     274
     275                        while(it != end) {
     276                                c++;
     277                                it = findNext(it, key);
     278                        }
     279
     280                        return c;
     281                }
     282
    256283        };
    257284} // namespace GenPoly
  • src/SymTab/Validate.cc

    r5e644d3e r46f6134  
    4949#include "SynTree/Statement.h"
    5050#include "SynTree/TypeSubstitution.h"
     51#include "GenPoly/ScopedMap.h"
    5152#include "Indexer.h"
    5253#include "FixFunction.h"
     
    162163                void addImplicitTypedef( AggDecl * aggDecl );
    163164
    164                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
     165                typedef std::unique_ptr<TypedefDecl> TypedefDeclPtr;
     166                typedef GenPoly::ScopedMap< std::string, std::pair< TypedefDeclPtr, int > > TypedefMap;
    165167                typedef std::map< std::string, TypeDecl * > TypeDeclMap;
    166168                TypedefMap typedefNames;
     
    549551                        }
    550552                } else {
    551                         typedefNames[ tyDecl->get_name() ] = std::make_pair( tyDecl, scopeLevel );
     553                        typedefNames[ tyDecl->get_name() ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
    552554                } // if
    553555
     
    567569                        return new EnumDecl( enumDecl->get_name() );
    568570                } else {
    569                         return ret;
     571                        return ret->clone();
    570572                } // if
    571573        }
     
    582584
    583585        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
    584                 TypedefMap oldNames = typedefNames;
     586                typedefNames.beginScope();
    585587                DeclarationWithType *ret = Mutator::mutate( funcDecl );
    586                 typedefNames = oldNames;
     588                typedefNames.endScope();
    587589                return ret;
    588590        }
    589591
    590592        DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
    591                 TypedefMap oldNames = typedefNames;
     593                typedefNames.beginScope();
    592594                DeclarationWithType *ret = Mutator::mutate( objDecl );
    593                 typedefNames = oldNames;
     595                typedefNames.endScope();
    594596                // is the type a function?
    595597                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) {
     
    603605
    604606        Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
    605                 TypedefMap oldNames = typedefNames;
     607                typedefNames.beginScope();
    606608                Expression *ret = Mutator::mutate( castExpr );
    607                 typedefNames = oldNames;
     609                typedefNames.endScope();
    608610                return ret;
    609611        }
    610612
    611613        CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
    612                 TypedefMap oldNames = typedefNames;
     614                typedefNames.beginScope();
    613615                scopeLevel += 1;
    614616                CompoundStmt *ret = Mutator::mutate( compoundStmt );
     
    625627                        i = next;
    626628                } // while
    627                 typedefNames = oldNames;
     629                typedefNames.endScope();
    628630                return ret;
    629631        }
     
    656658                                type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
    657659                        } // if
    658                         TypedefDecl * tyDecl = new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type );
    659                         typedefNames[ aggDecl->get_name() ] = std::make_pair( tyDecl, scopeLevel );
     660                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type ) );
     661                        typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
    660662                } // if
    661663        }
  • src/SynTree/Declaration.h

    r5e644d3e r46f6134  
    153153  public:
    154154        NamedTypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type );
    155         NamedTypeDecl( const TypeDecl &other );
     155        NamedTypeDecl( const NamedTypeDecl &other );
    156156        virtual ~NamedTypeDecl();
    157157
  • src/SynTree/NamedTypeDecl.cc

    r5e644d3e r46f6134  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // NamedTypeDecl.cc -- 
     7// NamedTypeDecl.cc --
    88//
    99// Author           : Richard C. Bilson
     
    2121        : Parent( name, sc, LinkageSpec::Cforall ), base( base ) {}
    2222
    23 NamedTypeDecl::NamedTypeDecl( const TypeDecl &other )
     23NamedTypeDecl::NamedTypeDecl( const NamedTypeDecl &other )
    2424        : Parent( other ), base( maybeClone( other.base ) ) {
    2525        cloneAll( other.parameters, parameters );
     
    3535void NamedTypeDecl::print( std::ostream &os, int indent ) const {
    3636        using namespace std;
    37        
     37
    3838        if ( get_name() != "" ) {
    3939                os << get_name() << ": ";
     
    5959void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
    6060        using namespace std;
    61        
     61
    6262        if ( get_name() != "" ) {
    6363                os << get_name() << ": ";
  • src/main.cc

    r5e644d3e r46f6134  
    8484                 << " backtrace:" << endl;
    8585
    86         char ** messages = backtrace_symbols( array, size );   
     86        char ** messages = backtrace_symbols( array, size );
    8787
    8888        // skip first stack frame (points here)
     
    9191                for ( char *p = messages[i]; *p; ++p ) {        // find parantheses and +offset
    9292                        if (*p == '(') {
    93                                 mangled_name = p; 
     93                                mangled_name = p;
    9494                        } else if (*p == '+') {
    9595                                offset_begin = p;
     
    109109                        char * real_name = __cxxabiv1::__cxa_demangle( mangled_name, 0, 0, &status );
    110110                        if ( status == 0 ) {                                            // demangling successful ?
    111                                 cerr << "(" << i - 2 << ") " << messages[i] << " : " 
     111                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
    112112                                         << real_name << "+" << offset_begin << offset_end << endl;
    113113
    114114                        } else {                                                                        // otherwise, output mangled name
    115                                 cerr << "(" << i - 2 << ") " << messages[i] << " : " 
     115                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
    116116                                         << mangled_name << "+" << offset_begin << offset_end << endl;
    117117                        } // if
     
    198198                SymTab::validate( translationUnit, symtabp );
    199199                if ( symtabp ) {
     200                        deleteAll( translationUnit );
    200201                        return 0;
    201202                } // if
Note: See TracChangeset for help on using the changeset viewer.