Implement rdeps mode and sorting in Analyzer

[builder.git] / source / analyzer.cpp

diff --git a/source/analyzer.cpp b/source/analyzer.cpp
index 563143f11c56d2c0b5a72b7f5e4fc58327d23f72..75c08849b39c61fdb222bbdcae8ab981bedfb770 100644 (file)
--- a/source/analyzer.cpp
+++ b/source/analyzer.cpp
@@ -27,6 +27,18 @@ Analyzer::Analyzer(Builder &b):
 
 void Analyzer::analyze()
 {
+       if(mode==RDEPS)
+       {
+               rdepends.clear();
+               const TargetMap &targets = builder.get_targets();
+               for(TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
+               {
+                       const TargetList &depends = i->second->get_depends();
+                       for(TargetList::const_iterator j=depends.begin(); j!=depends.end(); ++j)
+                               rdepends[*j].insert(i->second);
+               }
+       }
+
        table.clear();
 
        TableRow row;
@@ -36,19 +48,27 @@ void Analyzer::analyze()
        row.push_back("Rebuild");
        table.push_back(row);
        
-       build_depend_table(*builder.get_target("cmdline"), 0);
+       const Target &cmdline = *builder.get_target("cmdline");
+       if(mode==RDEPS)
+       {
+               const TargetList &deps = cmdline.get_depends();
+               for(TargetList::const_iterator i=deps.begin(); i!=deps.end(); ++i)
+                       build_depend_table(**i, 0);
+       }
+       else
+               build_depend_table(cmdline, 0);
 
        print_table();
 }
 
-void Analyzer::build_depend_table(Target &tgt, unsigned depth)
+void Analyzer::build_depend_table(const Target &tgt, unsigned depth)
 {
-       if(mode!=REBUILD && mode!=ALLDEPS)
+       if(mode==DEPS)
        {
                // Skip trivial targets
-               if(ObjectFile *obj = dynamic_cast<ObjectFile *>(&tgt))
+               if(const ObjectFile *obj = dynamic_cast<const ObjectFile *>(&tgt))
                        return build_depend_table(obj->get_source(), depth);
-               else if(Install *inst = dynamic_cast<Install *>(&tgt))
+               else if(const Install *inst = dynamic_cast<const Install *>(&tgt))
                        return build_depend_table(inst->get_source(), depth);
        }
        else if(mode==REBUILD && !tgt.get_rebuild())
@@ -59,7 +79,7 @@ void Analyzer::build_depend_table(Target &tgt, unsigned depth)
        TableRow row;
 
        string name;
-       FileTarget *ft = dynamic_cast<FileTarget *>(&tgt);
+       const FileTarget *ft = dynamic_cast<const FileTarget *>(&tgt);
        if(full_paths && ft)
                name = ft->get_path().str();
        else
@@ -86,9 +106,17 @@ void Analyzer::build_depend_table(Target &tgt, unsigned depth)
 
        if(!max_depth || depth<max_depth-1)
        {
-               const TargetList &depends = tgt.get_depends();
-               //XXX If we want to sort the targets, we need to take the value of full_paths into account
-               //depends.sort(target_order);
+               TargetList depends;
+               if(mode==RDEPS)
+               {
+                       const set<Target *> &rdeps = rdepends[&tgt];
+                       depends.assign(rdeps.begin(), rdeps.end());
+               }
+               else
+                       depends = tgt.get_depends();
+
+               depends.sort(full_paths ? target_order_full : target_order);
+
                for(TargetList::const_iterator i=depends.begin(); i!=depends.end(); ++i)
                        build_depend_table(**i, depth+1);
        }
@@ -120,5 +148,22 @@ void Analyzer::print_table() const
        }
 }
 
-bool Analyzer::target_order(Target *t1, Target *t2)
-{ return t1->get_name()<t2->get_name(); }
+bool Analyzer::target_order(const Target *t1, const Target *t2)
+{
+       return t1->get_name()<t2->get_name();
+}
+
+bool Analyzer::target_order_full(const Target *t1, const Target *t2)
+{
+       const FileTarget *ft1 = dynamic_cast<const FileTarget *>(t1);
+       const FileTarget *ft2 = dynamic_cast<const FileTarget *>(t2);
+       if(!ft1)
+       {
+               if(ft2)
+                       return true;
+               return target_order(t1, t2);
+       }
+       else if(!ft2)
+               return false;
+       return ft1->get_path().str()<ft2->get_path().str();
+}