source/analyzer.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/fs/utils.h>
   3 #include <msp/io/print.h>
   4 #include "analyzer.h"
   5 #include "builder.h"
   6 #include "buildgraph.h"
   7 #include "objectfile.h"
   8 #include "sourcefile.h"
   9 #include "sourcepackage.h"
  10 #include "target.h"
  11 #include "tool.h"
  12
  13 using namespace std;
  14 using namespace Msp;
  15
  16 void Analyzer::analyze()
  17 {
  18         if(mode==RDEPS)
  19         {
  20                 rdepends.clear();
  21                 for(const auto &kvp: builder.get_build_graph().get_targets())
  22                 {
  23                         for(Target *d: kvp.second->get_dependencies())
  24                                 rdepends[d].insert(kvp.second);
  25                         for(Target *d: kvp.second->get_transitive_dependencies())
  26                                 rdepends[d].insert(kvp.second);
  27                 }
  28         }
  29
  30         table.clear();
  31
  32         TableRow row;
  33         row.push_back("Name");
  34         row.push_back("Package");
  35         row.push_back("Type");
  36         row.push_back("Tool");
  37         row.push_back("Rebuild");
  38         table.push_back(row);
  39
  40         Target &goals = builder.get_build_graph().get_goals();
  41         if(mode==RDEPS)
  42         {
  43                 for(Target *d: goals.get_dependencies())
  44                         build_depend_table(*d, 0);
  45         }
  46         else
  47                 build_depend_table(goals, 0);
  48
  49         print_table();
  50 }
  51
  52 void Analyzer::build_depend_table(Target &tgt, unsigned depth)
  53 {
  54         Target *real = tgt.get_real_target();
  55         if(mode==DEPS)
  56         {
  57                 // Skip trivial targets
  58                 if(real!=&tgt)
  59                         return build_depend_table(*real, depth);
  60                 if(const ObjectFile *obj = dynamic_cast<const ObjectFile *>(&tgt))
  61                         return build_depend_table(obj->get_source(), depth);
  62         }
  63         else if(mode==REBUILD && !tgt.needs_rebuild())
  64                 /* All targets that depend on to-be-built targets will be rebuilt
  65                 themselves, so we can stop here. */
  66                 return;
  67
  68         TableRow row;
  69
  70         string name;
  71         const FileTarget *ft = dynamic_cast<const FileTarget *>(&tgt);
  72         if(full_paths && ft)
  73                 name = ft->get_path().str();
  74         else
  75                 name = tgt.get_name();
  76         row.push_back(string(depth*2, ' ')+name);
  77
  78         const Package *pkg = tgt.get_package();
  79         if(pkg)
  80                 row.push_back(pkg->get_name());
  81         else
  82                 row.push_back("");
  83
  84         row.push_back(tgt.get_type());
  85         const Tool *tool = tgt.get_tool();
  86         if(tool)
  87                 row.push_back(tool->get_tag());
  88         else
  89                 row.push_back("");
  90
  91         if(tgt.needs_rebuild())
  92                 row.push_back(tgt.get_rebuild_reason());
  93
  94         table.push_back(row);
  95
  96         if(!max_depth || depth<max_depth-1)
  97         {
  98                 Target::Dependencies depends;
  99                 if(mode==RDEPS)
 100                 {
 101                         const set<Target *> &rdeps = rdepends[&tgt];
 102                         depends.assign(rdeps.begin(), rdeps.end());
 103                 }
 104                 else
 105                 {
 106                         depends = tgt.get_dependencies();
 107                         const Target::Dependencies &tdeps = tgt.get_transitive_dependencies();
 108                         depends.insert(depends.end(), tdeps.begin(), tdeps.end());
 109                 }
 110
 111                 sort(depends, (full_paths ? target_order_full : target_order));
 112
 113                 for(Target *d: depends)
 114                         build_depend_table(*d, depth+1);
 115         }
 116 }
 117
 118 void Analyzer::print_table() const
 119 {
 120         vector<string::size_type> col_width;
 121
 122         // Determine column widths
 123         for(const vector<string> &r: table)
 124         {
 125                 if(col_width.size()<r.size())
 126                         col_width.resize(r.size(), 0);
 127                 for(unsigned j=0; j<r.size(); ++j)
 128                         col_width[j] = max(col_width[j], r[j].size());
 129         }
 130
 131         for(const vector<string> &r: table)
 132         {
 133                 string line;
 134                 for(unsigned j=0; j<r.size(); ++j)
 135                 {
 136                         if(j>0)
 137                                 line += "  ";
 138                         line += lexical_cast<string>(r[j], Fmt("%-s").width(col_width[j]));
 139                 }
 140                 IO::print("%s\n", line);
 141         }
 142 }
 143
 144 bool Analyzer::target_order(const Target *t1, const Target *t2)
 145 {
 146         return t1->get_name()<t2->get_name();
 147 }
 148
 149 bool Analyzer::target_order_full(const Target *t1, const Target *t2)
 150 {
 151         const FileTarget *ft1 = dynamic_cast<const FileTarget *>(t1);
 152         const FileTarget *ft2 = dynamic_cast<const FileTarget *>(t2);
 153         if(!ft1)
 154         {
 155                 if(ft2)
 156                         return true;
 157                 return target_order(t1, t2);
 158         }
 159         else if(!ft2)
 160                 return false;
 161         return ft1->get_path().str()<ft2->get_path().str();
 162 }