#include <msp/strings/utils.h>
#include <msp/time/units.h>
#include <msp/time/utils.h>
-#include "action.h"
#include "analyzer.h"
#include "binarypackage.h"
#include "builder.h"
+#include "copy.h"
+#include "gnuarchiver.h"
+#include "gnuccompiler.h"
+#include "gnucxxcompiler.h"
+#include "gnulinker.h"
#include "header.h"
#include "install.h"
#include "misc.h"
#include "package.h"
#include "pkgconfig.h"
+#include "pkgconfiggenerator.h"
#include "sharedlibrary.h"
#include "sourcepackage.h"
#include "systemlibrary.h"
-#include "unlink.h"
+#include "tar.h"
+#include "task.h"
#include "virtualtarget.h"
using namespace std;
cwd = FS::getcwd();
- native_arch.set_tool("CC", "gcc");
- native_arch.set_tool("CXX", "g++");
- native_arch.set_tool("LD", "gcc");
- native_arch.set_tool("LXX", "g++");
- native_arch.set_tool("AR", "ar");
+ toolchain.add_tool(new GnuCCompiler(*this));
+ toolchain.add_tool(new GnuCxxCompiler(*this));
+ toolchain.add_tool(new GnuLinker(*this));
+ toolchain.add_tool(new GnuArchiver(*this));
+ toolchain.add_tool(new Copy(*this));
+ toolchain.add_tool(new Tar(*this));
+ toolchain.add_tool(new PkgConfigGenerator(*this));
load_build_file((FS::get_sys_data_dir(argv[0], "builder")/"builderrc").str());
load_build_file((FS::get_user_data_dir("builder")/"rc").str());
Target *Builder::get_target(const string &n) const
{
- // XXX Used for getting targets by path. get_target(const FS::Path &)?
TargetMap::const_iterator i = targets.find(n);
if(i!=targets.end())
return i->second;
return 0;
}
+FileTarget *Builder::get_target_by_path(const FS::Path &p) const
+{
+ TargetMap::const_iterator i = targets_by_path.find(p.str());
+ if(i!=targets_by_path.end())
+ return static_cast<FileTarget *>(i->second);
+ return 0;
+}
+
Target *Builder::get_header(const string &include, const FS::Path &from, const list<string> &path)
{
string hash(8, 0);
static string cxx_ver;
if(cxx_ver.empty())
{
- StringList argv;
+ // XXX This needs to go elsewhere
+ /*StringList argv;
argv.push_back(current_arch->get_tool("CXX"));
argv.push_back("--version");
if(RegMatch m = Regex("[0-9]\\.[0-9.]+").match(run_command(argv)))
if(verbose>=5)
IO::print("C++ version is %s\n", cxx_ver);
}
- else
+ else*/
cxx_ver = "-";
}
problems.push_back(Problem(p, d));
}
-void Builder::add_target(FileTarget *t)
+void Builder::add_target(Target *t)
{
- targets.insert(TargetMap::value_type(t->get_path().str(), t));
+ targets.insert(TargetMap::value_type(t->get_name(), t));
new_tgts.push_back(t);
}
-void Builder::add_target(VirtualTarget *t)
+void Builder::register_path(const FS::Path &path, FileTarget *t)
{
- targets.insert(TargetMap::value_type(t->get_name(), t));
- new_tgts.push_back(t);
+ targets_by_path.insert(TargetMap::value_type(path.str(), t));
}
void Builder::usage(const char *reason, const char *argv0, bool brief)
int Builder::load_build_file(const FS::Path &fn)
{
- try
- {
- IO::BufferedFile in(fn.str());
+ if(!FS::exists(fn))
+ return -1;
- if(verbose>=3)
- IO::print("Reading %s\n", fn);
+ IO::BufferedFile in(fn.str());
- DataFile::Parser parser(in, fn.str());
- Loader loader(*this, fn.subpath(0, fn.size()-1));
- loader.load(parser);
- }
- catch(const IO::file_not_found &)
- {
- return -1;
- }
+ if(verbose>=3)
+ IO::print("Reading %s\n", fn);
+
+ DataFile::Parser parser(in, fn.str());
+ Loader loader(*this, fn.subpath(0, fn.size()-1));
+ loader.load(parser);
return 0;
}
// Apply what-ifs
for(StringList::iterator i=what_if.begin(); i!=what_if.end(); ++i)
{
- FileTarget *tgt = dynamic_cast<FileTarget *>(get_target((cwd/ *i).str()));
+ FileTarget *tgt = get_target_by_path(cwd/ *i);
if(!tgt)
{
IO::print(IO::cerr, "Unknown what-if target %s\n", *i);
{
Target *tgt = get_target(*i);
if(!tgt)
- tgt = get_target((cwd/ *i).str());
+ tgt = get_target_by_path(*i);
+ if(!tgt)
+ tgt = get_target_by_path(cwd/ *i);
if(!tgt)
{
IO::print("I don't know anything about %s\n", *i);
Target *Builder::get_header(const FS::Path &fn)
{
- Target *tgt = get_target(fn.str());
+ Target *tgt = get_target_by_path(fn);
if(tgt) return tgt;
if(FS::is_reg(fn))
for(StringList::iterator i=candidates.begin(); i!=candidates.end(); ++i)
{
- string full = (path/ *i).str();
- Target *tgt = get_target(full);
+ FS::Path full = path/ *i;
+ Target *tgt = get_target_by_path(full);
if(tgt)
{
}
else if(FS::is_reg(full))
{
- tgt = new SystemLibrary(*this, full);
+ tgt = new SystemLibrary(*this, full.str());
return tgt;
}
}
if(verbose>=1)
IO::print("Will build %d target%s\n", total, (total!=1 ? "s" : ""));
- vector<Action *> actions;
+ vector<Task *> tasks;
unsigned count = 0;
while(!finish)
{
- if(actions.size()<jobs && !fail)
+ if(tasks.size()<jobs && !fail)
{
Target *tgt = cmdline->get_buildable_target();
if(tgt)
{
- Action *action = tgt->build();
- if(action)
- actions.push_back(action);
+ if(tgt->get_tool())
+ IO::print("[%-10s] [%-4s] %s\n", tgt->get_package()->get_name(), tgt->get_tool()->get_tag(), tgt->get_name());
+ Task *task = tgt->build();
+ if(task)
+ tasks.push_back(task);
if(show_progress)
IO::print("%d of %d target%s built\033[1G", count, total, (total!=1 ? "s" : ""));
}
- else if(actions.empty())
+ else if(tasks.empty())
finish = true;
}
else
Time::sleep(10*Time::msec);
- for(unsigned i=0; i<actions.size();)
+ for(unsigned i=0; i<tasks.size();)
{
- int status = actions[i]->check();
- if(status>=0)
+ Task::Status status = tasks[i]->check();
+ if(status!=Task::RUNNING)
{
++count;
- delete actions[i];
- actions.erase(actions.begin()+i);
- if(status>0)
+ delete tasks[i];
+ tasks.erase(tasks.begin()+i);
+ if(status==Task::ERROR)
fail = true;
- if(actions.empty() && fail)
+ if(tasks.empty() && fail)
finish = true;
}
else
for(set<Target *>::iterator i=clean_tgts.begin(); i!=clean_tgts.end(); ++i)
if(FileTarget *ft = dynamic_cast<FileTarget *>(*i))
- {
- Action *action = new Unlink(*this, *ft);
- while(action->check()<0) ;
- delete action;
- }
+ unlink(ft->get_path());
return 0;
}
projects / builder.git / blobdiff