Changes in / [35cd219:9bb90a86]


Ignore:
Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • src/CodeTools/DeclStats.cc

    r35cd219 r9bb90a86  
    1818#include <iostream>
    1919#include <map>
    20 #include <sstream>
    2120#include <string>
    2221#include <unordered_map>
    … …  
    7271                                return *this;
    7372                        }
     73
     74                        /// Update based on a declaration list
     75                        ArgPackStats& operator+= ( std::list<DeclarationWithType*>& decls ) {
     76                                unsigned nn = 0;
     77                                unsigned nn_basic = 0;
     78                                unsigned nn_poly = 0;
     79                                for ( auto decl : decls ) {
     80                                        nn += decl->get_type()->size();
     81                                        if ( dynamic_cast<BasicType*>( decl->get_type() ) ) ++nn_basic;
     82                                        else if ( GenPoly::hasPolyBase( decl->get_type() ) ) ++nn_poly;
     83                                }
     84                                ++n.at( nn );
     85                                ++n_basic.at( nn_basic );
     86                                ++n_poly.at( nn_poly );
     87                                if ( nn > 0 ) {
     88                                        ++p_basic[ nn_basic*100/nn ];
     89                                        ++p_poly[ nn_poly*100/nn ];
     90                                }
     91                               
     92                                return *this;
     93                        }
    7494                };
    7595               
    … …  
    80100                        /// Count of declarations with each name
    81101                        std::unordered_map<std::string, unsigned> by_name;
    82                         /// Count of uses of each basic type
    83                         std::unordered_map<std::string, unsigned> basic_type_names;
    84                         /// Count of uses of each non-basic type
    85                         std::unordered_map<std::string, unsigned> compound_type_names;
    86102                        /// Stats for the parameter list
    87103                        ArgPackStats params;
    … …  
    96112                        ArgPackStats assn_returns;
    97113                       
    98                         Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
     114                        Stats() : n_decls(0), n_type_params(), by_name(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
    99115
    100116                public:
    … …  
    103119                                sum( n_type_params, o.n_type_params );
    104120                                sum( by_name, o.by_name );
    105                                 sum( basic_type_names, o.basic_type_names );
    106                                 sum( compound_type_names, o.compound_type_names );
    107121                                sum( params, o.params );
    108122                                sum( returns, o.returns );
    … …  
    119133                Stats total;
    120134
    121                 /// Update arg pack stats based on a declaration list
    122                 void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
    123                         unsigned n = 0;
    124                         unsigned n_basic = 0;
    125                         unsigned n_poly = 0;
    126                         for ( auto decl : decls ) {
    127                                 n += decl->get_type()->size();
    128                                 if ( BasicType* bt = dynamic_cast<BasicType*>( decl->get_type() ) ) {
    129                                         ++n_basic;
    130                                         std::stringstream ss;
    131                                         bt->print( ss );
    132                                         ++stats.basic_type_names[ ss.str() ];
    133                                 } else if ( GenPoly::hasPolyBase( decl->get_type() ) ) {
    134                                         ++n_poly;
    135                                 } else {
    136                                         std::stringstream ss;
    137                                         decl->get_type()->print( ss );
    138                                         ++stats.compound_type_names[ ss.str() ];
    139                                 }
    140                         }
    141                         ++pstats.n.at( n );
    142                         ++pstats.n_basic.at( n_basic );
    143                         ++pstats.n_poly.at( n_poly );
    144                         if ( n > 0 ) {
    145                                 ++pstats.p_basic[ n_basic*100/n ];
    146                                 ++pstats.p_poly[ n_poly*100/n ];
    147                         }
    148                 }
    149                
    150                 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
    151                         analyze( stats, params, fnTy->get_parameters() );
    152                         analyze( stats, returns, fnTy->get_returnVals() );
     135                void analyzeFunc( FunctionType* fnTy, ArgPackStats& params, ArgPackStats& returns ) {
     136                        params += fnTy->get_parameters();
     137                        returns += fnTy->get_returnVals();
    153138                }
    154139
    … …  
    179164                                                assnTy = assnDecl->get_functionType();
    180165                                        }
    181                                         if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
     166                                        if ( assnTy ) analyzeFunc( assnTy, stats.assn_params, stats.assn_returns );
    182167                                }
    183168                        }
    … …  
    186171                        ++stats.by_name[ decl->get_name() ];
    187172
    188                         analyzeFunc( fnTy, stats, stats.params, stats.returns );
     173                        analyzeFunc( fnTy, stats.params, stats.returns );
    189174                }
    190175
    … …  
    281266                        printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); });
    282267                        printAllSparseHisto("overloads", [](const Stats& stats) { return stats.by_name; });
    283                         printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
    284                         printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; });
    285                         printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
    286                         printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; });
    287268                        printAllPack("params", [](const Stats& stats) { return stats.params; });
    288269                        printAllPack("returns", [](const Stats& stats) { return stats.returns; });

  • src/Common/ScopedMap.h

    r35cd219 r9bb90a86  
    230230        }
    231231
    232         /// Finds the given key in the provided scope; returns end() for none such
    233         iterator findAt( size_type scope, const Key& key ) {
    234                 typename Scope::iterator val = scopes[scope].find( key );
    235                 if ( val != scopes[scope].end() ) return iterator( scopes, val, scope );
    236                 return end();
    237         }
    238         const_iterator findAt( size_type scope, const Key& key ) const {
    239                 return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findAt( scope, key ) );
    240         }
    241 
    242232        /// Finds the given key in the outermost scope inside the given scope where it occurs
    243233        iterator findNext( const_iterator &it, const Key &key ) {

  • src/Common/VectorMap.h

    r35cd219 r9bb90a86  
    3838        typedef const const_value_type* const_pointer;
    3939       
    40         class iterator : public std::iterator< std::random_access_iterator_tag,
     40        class iterator : public std::iterator< std::bidirectional_iterator_tag,
    4141                                               value_type,
    42                                                                                    difference_type,
    43                                                                                    pointer,
    44                                                                                    reference > {
     42                                                                                    difference_type,
     43                                                                                        pointer,
     44                                                                                        reference > {
    4545        friend class VectorMap;
    4646        friend class const_iterator;
    … …  
    7474                iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
    7575
    76                 iterator& operator+= (difference_type i) {
    77                         // SHENANIGANS: same reasons as operator++
    78                         new(&data) value_type{ (data.first + i), *(&data.second + i) };
    79                         return *this;
    80                 }
    81 
    82                 iterator operator+ (difference_type i) const { iterator tmp = *this; return tmp += i; }
    83 
    84                 iterator& operator-= (difference_type i) {
    85                         // SHENANIGANS: same reasons as operator++
    86                         new(&data) value_type{ (data.first - i), *(&data.second - i) };
    87                         return *this;
    88                 }
    89 
    90                 iterator operator- (difference_type i) const { iterator tmp = *this; return tmp -= i; }
    91 
    92                 difference_type operator- (const iterator& o) const { return data.first - o.data.first; }
    93 
    94                 value_type operator[] (difference_type i) const {
    95                         // SHENANIGANS: same reasons as operator++
    96                         return value_type{ (data.first + i), *(&data.second + i) };
    97                 }
    98 
    9976                bool operator== (const iterator& o) const {
    10077                        return data.first == o.data.first && &data.second == &o.data.second;
    10178                }
    102                
    10379                bool operator!= (const iterator& that) const { return !(*this == that); }
    104 
    105                 bool operator< (const iterator& o) const { return data.first < o.data.first; }
    106 
    107                 bool operator> (const iterator& o) const { return data.first > o.data.first; }
    108 
    109                 bool operator<= (const iterator& o) const { return data.first <= o.data.first; }
    110 
    111                 bool operator>= (const iterator& o) const { return data.first >= o.data.first; }
    11280        };
    11381
    … …  
    150118                const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
    151119
    152                 const_iterator& operator+= (difference_type i) {
    153                         // SHENANIGANS: same reasons as iterator::operator++
    154                         new(&data) const_value_type{ (data.first + i), *(&data.second + i) };
    155                         return *this;
    156                 }
    157 
    158                 const_iterator operator+ (difference_type i) const {
    159                         const_iterator tmp = *this; return tmp += i;
    160                 }
    161 
    162                 const_iterator& operator-= (difference_type i) {
    163                         // SHENANIGANS: same reasons as iterator::operator++
    164                         new(&data) const_value_type{ (data.first - i), *(&data.second - i) };
    165                         return *this;
    166                 }
    167 
    168                 const_iterator operator- (difference_type i) const {
    169                         const_iterator tmp = *this; return tmp -= i;
    170                 }
    171 
    172                 difference_type operator- (const const_iterator& o) const {
    173                         return data.first - o.data.first;
    174                 }
    175 
    176                 const_value_type operator[] (difference_type i) const {
    177                         // SHENANIGANS: same reasons as iterator::operator++
    178                         return const_value_type{ (data.first + i), *(&data.second + i) };
    179                 }
    180 
    181120                bool operator== (const const_iterator& o) const {
    182121                        return data.first == o.data.first && &data.second == &o.data.second;
    183122                }
    184                
    185123                bool operator!= (const const_iterator& that) const { return !(*this == that); }
    186 
    187                 bool operator< (const const_iterator& o) const { return data.first < o.data.first; }
    188 
    189                 bool operator> (const const_iterator& o) const { return data.first > o.data.first; }
    190 
    191                 bool operator<= (const const_iterator& o) const { return data.first <= o.data.first; }
    192 
    193                 bool operator>= (const const_iterator& o) const { return data.first >= o.data.first; }
    194124        };
    195125
    … …  
    233163};
    234164
    235 template<typename T>
    236 typename VectorMap<T>::iterator operator+ (typename VectorMap<T>::difference_type i,
    237                                            const typename VectorMap<T>::iterator& it) {
    238         return it + i;
    239 }
    240 
    241 template<typename T>
    242 typename VectorMap<T>::const_iterator operator+ (typename VectorMap<T>::difference_type i,
    243                                                  const typename VectorMap<T>::const_iterator& it) {
    244         return it + i;
    245 }
    246 
    247165#endif // _VECTORMAP_H
    248166

  • src/GenPoly/InstantiateGeneric.cc

    r35cd219 r9bb90a86  
    122122                /// Adds a value for a (key, typeList) pair to the current scope
    123123                void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
    124                         auto it = instantiations.findAt( instantiations.currentScope(), key );
    125                         if ( it == instantiations.end() ) {
    126                                 instantiations.insert( key, ValueList{ Instantiation{ TypeList( params ), value } } );
    127                         } else {
    128                                 it->second.push_back( Instantiation{ TypeList( params ), value } );
    129                         }
     124                        instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
    130125                }
    131126        };
Note: See TracChangeset for help on using the changeset viewer.