Changes in src/CodeTools/DeclStats.cc [f923b5f:424931d]

File:

• src/CodeTools/DeclStats.cc (modified) (9 diffs)

src/CodeTools/DeclStats.cc

@@ -18 +18 @@
 #include <iostream>
 #include <map>
-#include <sstream>
 #include <string>
 #include <unordered_map>
@@ -72 +71 @@
                                 return *this;
                         }
+
+                        /// Update based on a declaration list
+                        ArgPackStats& operator+= ( std::list<DeclarationWithType*>& decls ) {
+                                unsigned nn = 0;
+                                unsigned nn_basic = 0;
+                                unsigned nn_poly = 0;
+                                for ( auto decl : decls ) {
+                                        nn += decl->get_type()->size();
+                                        if ( dynamic_cast<BasicType*>( decl->get_type() ) ) ++nn_basic;
+                                        else if ( GenPoly::hasPolyBase( decl->get_type() ) ) ++nn_poly;
+                                }
+                                ++n.at( nn );
+                                ++n_basic.at( nn_basic );
+                                ++n_poly.at( nn_poly );
+                                if ( nn > 0 ) {
+                                        ++p_basic[ nn_basic*100/nn ];
+                                        ++p_poly[ nn_poly*100/nn ];
+                                }
+                                
+                                return *this;
+                        }
                 };
                 
@@ -80 +100 @@
                         /// Count of declarations with each name
                         std::unordered_map<std::string, unsigned> by_name;
-                        /// Count of uses of each basic type
-                        std::unordered_map<std::string, unsigned> basic_type_names;
-                        /// Count of uses of each non-basic type
-                        std::unordered_map<std::string, unsigned> compound_type_names;
                         /// Stats for the parameter list
                         ArgPackStats params;
@@ -96 +112 @@
                         ArgPackStats assn_returns;
                         
-                        Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
+                        Stats() : n_decls(0), n_type_params(), by_name(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
 
                 public:
@@ -103 +119 @@
                                 sum( n_type_params, o.n_type_params );
                                 sum( by_name, o.by_name );
-                                sum( basic_type_names, o.basic_type_names );
-                                sum( compound_type_names, o.compound_type_names );
                                 sum( params, o.params );
                                 sum( returns, o.returns );
@@ -119 +133 @@
                 Stats total;
 
-                /// Update arg pack stats based on a declaration list
-                void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
-                        unsigned n = 0;
-                        unsigned n_basic = 0;
-                        unsigned n_poly = 0;
-                        for ( auto decl : decls ) {
-                                n += decl->get_type()->size();
-                                if ( BasicType* bt = dynamic_cast<BasicType*>( decl->get_type() ) ) {
-                                        ++n_basic;
-                                        std::stringstream ss;
-                                        bt->print( ss );
-                                        ++stats.basic_type_names[ ss.str() ];
-                                } else if ( GenPoly::hasPolyBase( decl->get_type() ) ) {
-                                        ++n_poly;
-                                } else {
-                                        std::stringstream ss;
-                                        decl->get_type()->print( ss );
-                                        ++stats.compound_type_names[ ss.str() ];
-                                }
-                        }
-                        ++pstats.n.at( n );
-                        ++pstats.n_basic.at( n_basic );
-                        ++pstats.n_poly.at( n_poly );
-                        if ( n > 0 ) {
-                                ++pstats.p_basic[ n_basic*100/n ];
-                                ++pstats.p_poly[ n_poly*100/n ];
-                        }
-                }
-                
-                void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
-                        analyze( stats, params, fnTy->get_parameters() );
-                        analyze( stats, returns, fnTy->get_returnVals() );
+                void analyzeFunc( FunctionType* fnTy, ArgPackStats& params, ArgPackStats& returns ) {
+                        params += fnTy->get_parameters();
+                        returns += fnTy->get_returnVals();
                 }
 
@@ -179 +164 @@
                                                 assnTy = assnDecl->get_functionType();
                                         }
-                                        if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
+                                        if ( assnTy ) analyzeFunc( assnTy, stats.assn_params, stats.assn_returns );
                                 }
                         }
@@ -186 +171 @@
                         ++stats.by_name[ decl->get_name() ];
 
-                        analyzeFunc( fnTy, stats, stats.params, stats.returns );
+                        analyzeFunc( fnTy, stats.params, stats.returns );
                 }
 
@@ -281 +266 @@
                         printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); });
                         printAllSparseHisto("overloads", [](const Stats& stats) { return stats.by_name; });
-                        printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
-                        printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
                         printAllPack("params", [](const Stats& stats) { return stats.params; });
                         printAllPack("returns", [](const Stats& stats) { return stats.returns; });