X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fbuilder.cpp;h=6eeaa2fa3ca3b39e05298b3bd780ff5401cccbaa;hb=878f5e0572a561c1fc342228970889a192d06256;hp=cf335c1a93a6c0f7248e20b2f46cb19d3c4efafb;hpb=3aad704c2d2fac737424a0a2697874927bd95c37;p=builder.git

diff --git a/source/builder.cpp b/source/builder.cpp
index cf335c1..6eeaa2f 100644
--- a/source/builder.cpp
+++ b/source/builder.cpp
@@ -1,751 +1,231 @@
-/* $Id$
-
-This file is part of builder
-Copyright © 2006-2009  Mikko Rasa, Mikkosoft Productions
-Distributed under the LGPL
-*/
-
-#include <iostream>
 #include <set>
-#include <sys/utsname.h>
-#include <msp/core/except.h>
-#include <msp/core/getopt.h>
+#include <msp/core/maputils.h>
 #include <msp/datafile/parser.h>
 #include <msp/fs/dir.h>
-#include <msp/fs/stat.h>
 #include <msp/fs/utils.h>
 #include <msp/io/buffered.h>
-#include <msp/io/except.h>
 #include <msp/io/file.h>
-#include <msp/strings/formatter.h>
-#include <msp/strings/regex.h>
-#include <msp/strings/utils.h>
-#include <msp/time/units.h>
+#include <msp/io/print.h>
+#include <msp/strings/format.h>
+#include <msp/time/timedelta.h>
 #include <msp/time/utils.h>
-#include "action.h"
-#include "analyzer.h"
+#include "androidtools.h"
 #include "binarypackage.h"
 #include "builder.h"
-#include "header.h"
-#include "install.h"
-#include "misc.h"
+#include "builtintools.h"
+#include "datatool.h"
+#include "installedfile.h"
 #include "package.h"
-#include "pkgconfig.h"
 #include "sharedlibrary.h"
 #include "sourcepackage.h"
-#include "systemlibrary.h"
-#include "tarball.h"
-#include "unlink.h"
+#include "systemtools.h"
+#include "task.h"
 #include "virtualtarget.h"
 
 using namespace std;
 using namespace Msp;
 
-namespace {
-
-void update_hash(string &hash, const string &value)
+Builder::Builder():
+	package_manager(*this),
+	native_arch(*this, string()),
+	current_arch(0),
+	build_type(0),
+	vfs(*this),
+	build_graph(*this),
+	logger(&default_logger),
+	tempdir("temp"),
+	top_loader(0)
 {
-	for(unsigned i=0; i<value.size(); ++i)
-		hash[i%hash.size()]^=value[i];
-}
-
-}
-
-
-Builder::Builder(int argc, char **argv):
-	main_pkg(0),
-	analyzer(0),
-	build(false),
-	clean(0),
-	dry_run(false),
-	help(false),
-	verbose(1),
-	show_progress(false),
-	build_file("Build"),
-	jobs(1),
-	conf_all(false),
-	conf_only(false),
-	build_all(false),
-	create_makefile(false)
-{
-	string analyze_mode;
-	string work_dir;
-	bool full_paths=false;
-	unsigned max_depth=5;
-	StringList cmdline_warn;
-	string prfx;
-	string arch;
-
-	GetOpt getopt;
-	getopt.add_option('a', "analyze",    analyze_mode, GetOpt::REQUIRED_ARG);
-	getopt.add_option('b', "build",      build,        GetOpt::NO_ARG);
-	getopt.add_option('c', "clean",      clean,        GetOpt::NO_ARG);
-	getopt.add_option('f', "file",       build_file,   GetOpt::REQUIRED_ARG);
-	getopt.add_option('h', "help",       help,         GetOpt::NO_ARG);
-	getopt.add_option('j', "jobs",       jobs,         GetOpt::REQUIRED_ARG);
-	getopt.add_option('n', "dry-run",    dry_run,      GetOpt::NO_ARG);
-	getopt.add_option('v', "verbose",    verbose,      GetOpt::NO_ARG);
-	getopt.add_option('A', "conf-all",   conf_all,     GetOpt::NO_ARG);
-	getopt.add_option('B', "build-all",  build_all,    GetOpt::NO_ARG);
-	getopt.add_option('C', "chdir",      work_dir,     GetOpt::REQUIRED_ARG);
-	getopt.add_option('P', "progress",   show_progress, GetOpt::NO_ARG);
-	getopt.add_option('W', "what-if",    what_if,      GetOpt::REQUIRED_ARG);
-	getopt.add_option(     "arch",       arch,         GetOpt::REQUIRED_ARG);
-	getopt.add_option(     "conf-only",  conf_only,    GetOpt::NO_ARG);
-	getopt.add_option(     "full-paths", full_paths,   GetOpt::NO_ARG);
-	//getopt.add_option(     "makefile",   create_makefile, GetOpt::NO_ARG);
-	getopt.add_option(     "max-depth",  max_depth,    GetOpt::REQUIRED_ARG);
-	getopt.add_option(     "prefix",     prfx,         GetOpt::REQUIRED_ARG);
-	getopt.add_option(     "warnings",   cmdline_warn, GetOpt::REQUIRED_ARG);
-	getopt(argc, argv);
-
-	if(!analyze_mode.empty())
-	{
-		analyzer=new Analyzer(*this);
-
-		if(analyze_mode=="deps")
-			analyzer->set_mode(Analyzer::DEPS);
-		else if(analyze_mode=="alldeps")
-			analyzer->set_mode(Analyzer::ALLDEPS);
-		else if(analyze_mode=="rebuild")
-			analyzer->set_mode(Analyzer::REBUILD);
-		else if(analyze_mode=="rdeps")
-			analyzer->set_mode(Analyzer::RDEPS);
-		else
-			throw UsageError("Invalid analyze mode");
-
-		analyzer->set_max_depth(max_depth);
-		analyzer->set_full_paths(full_paths);
-	}
-	else if(!clean && !create_makefile)
-		build=true;
-
-	const vector<string> &args=getopt.get_args();
-	for(vector<string>::const_iterator i=args.begin(); i!=args.end(); ++i)
-	{
-		unsigned equal=i->find('=');
-		if(equal!=string::npos)
-			cmdline_options.insert(StringMap::value_type(i->substr(0, equal), i->substr(equal+1)));
-		else
-			cmdline_targets.push_back(*i);
-	}
-
-	if(cmdline_targets.empty())
-		cmdline_targets.push_back("default");
-
-	if(!work_dir.empty())
-		FS::chdir(work_dir);
-
-	cwd=FS::getcwd();
-
-	utsname un;
-	string sysname="native";
-	if(uname(&un)==0)
-		sysname=tolower(un.sysname);
-
-	native_arch=&archs.insert(ArchMap::value_type(sysname, Architecture(*this, sysname, true))).first->second;
-	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");
-
-	load_build_file((FS::get_sys_data_dir(argv[0], "builder")/"builderrc").str());
-	load_build_file((FS::get_home_dir()/".builderrc").str());
-
-	if(arch.empty())
-		current_arch=native_arch;
-	else
-		current_arch=&get_architecture(arch);
-
-	if(prfx.empty())
-	{
-		if(current_arch->is_native())
-			prefix=(FS::get_home_dir()/"local").str();
-		else
-			prefix=(FS::get_home_dir()/"local"/current_arch->get_name()).str();
-	}
-	else
-		prefix=FS::getcwd()/prfx;
-
-	warnings.push_back("all");
-	warnings.push_back("extra");
-	warnings.push_back("shadow");
-	warnings.push_back("pointer-arith");
-	warnings.push_back("error");
-	for(StringList::iterator i=cmdline_warn.begin(); i!=cmdline_warn.end(); ++i)
-	{
-		vector<string> warns=split(*i, ',');
-		warnings.insert(warnings.end(), warns.begin(), warns.end());
-	}
-
-	pkg_path.push_back(cwd/".");
-	pkg_path.push_back(cwd/"..");
+	set_architecture(string());
 }
 
 Builder::~Builder()
 {
-	for(PackageMap::iterator i=packages.begin(); i!=packages.end(); ++i)
-		delete i->second;
-	for(TargetMap::iterator i=targets.begin(); i!=targets.end(); ++i)
-		delete i->second;
-	delete analyzer;
-}
-
-int Builder::main()
-{
-	if(load_build_file(cwd/build_file))
-	{
-		cerr<<"No build info here.\n";
-		return 1;
-	}
-
-	main_pkg->configure(cmdline_options, conf_all?2:1);
-
-	if(help)
-	{
-		usage(0, "builder", false);
-		cout<<'\n';
-		package_help();
-		return 0;
-	}
-
-	if(!conf_only && create_targets())
-		return 1;
-
-	PackageList all_reqs=main_pkg->collect_requires();
-
-	if(conf_only)
-		return 0;
-
-	if(verbose>=2)
-		cout<<"Building on "<<native_arch->get_name()<<", for "<<current_arch->get_name()<<'\n';
-	if(verbose>=1)
-		cout<<all_reqs.size()<<" active packages, "<<targets.size()<<" targets\n";
-	if(verbose>=2)
-	{
-		for(PackageList::const_iterator i=all_reqs.begin(); i!=all_reqs.end(); ++i)
-		{
-			cout<<' '<<(*i)->get_name();
-			if(dynamic_cast<SourcePackage *>(*i))
-				cout<<'*';
-			unsigned count=0;
-			unsigned ood_count=0;
-			for(TargetMap::iterator j=targets.begin(); j!=targets.end(); ++j)
-				if(j->second->get_package()==*i)
-				{
-					++count;
-					if(j->second->get_rebuild())
-						++ood_count;
-				}
-			if(count)
-			{
-				cout<<" ("<<count<<" targets";
-				if(ood_count)
-					cout<<", "<<ood_count<<" out-of-date";
-				cout<<')';
-			}
-			cout<<'\n';
-		}
-	}
-
-	if(analyzer)
-		analyzer->analyze();
-
-	if(!problems.empty())
-	{
-		cerr<<"The following problems were detected:\n";
-		for(ProblemList::iterator i=problems.begin(); i!=problems.end(); ++i)
-			cerr<<"  "<<i->package<<": "<<i->descr<<'\n';
-		cerr<<"Please fix them and try again.\n";
-		return 1;
-	}
-
-	//if(create_makefile
-
-	if(clean)
-		exit_code=do_clean();
-	else if(build)
-		exit_code=do_build();
-
-	return exit_code;
-}
-
-Package *Builder::get_package(const string &name)
-{
-	PackageMap::iterator i=packages.find(format("%s/%s", name, current_arch->get_name()));
-	if(i==packages.end())
-		i=packages.find(name);
-	if(i!=packages.end())
-		return i->second;
-
-	FS::Path path=get_package_location(name);
-	if(!path.empty() && !load_build_file(path/"Build"))
-	{
-		i=packages.find(name);
-		if(i!=packages.end())
-			return i->second;
-	}
-
-	// Package source not found - create a binary package
-	Package *pkg=BinaryPackage::from_pkgconfig(*this, name);
-
-	packages.insert(PackageMap::value_type(name, pkg));
-
-	if(!pkg)
-		problem(name, "not found");
-
-	return pkg;
-}
-
-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;
+	if(current_arch!=&native_arch)
+		delete current_arch;
 }
 
-Target *Builder::get_header(const string &include, const FS::Path &from, const list<string> &path)
+void Builder::set_architecture(const string &name)
 {
-	string hash(8, 0);
-	if(include[0]=='\"')
-		update_hash(hash, from.str());
-	for(list<string>::const_iterator i=path.begin(); i!=path.end(); ++i)
-		update_hash(hash, *i);
-
-	string id=hash+include;
-	TargetMap::iterator i=includes.find(id);
-	if(i!=includes.end())
-		return i->second;
-
-	static string cxx_ver;
-	if(cxx_ver.empty())
+	if(name.empty())
 	{
-		StringList argv;
-		argv.push_back(current_arch->get_tool("CXX"));
-		argv.push_back("--version");
-		cxx_ver=Regex("[0-9]\\.[0-9.]+").match(run_command(argv))[0].str;
-		while(!cxx_ver.empty() && !FS::is_dir(FS::Path("/usr/include/c++")/cxx_ver))
-		{
-			unsigned dot=cxx_ver.rfind('.');
-			if(dot==string::npos)
-				break;
-			cxx_ver.erase(dot);
-		}
-		if(verbose>=5)
-			cout<<"C++ version is "<<cxx_ver<<'\n';
+		current_arch = &native_arch;
+		prefix = FS::get_home_dir()/"local";
 	}
-
-	string fn=include.substr(1);
-	if(verbose>=5)
-		cout<<"Looking for include "<<fn<<" from "<<from<<" with path "<<join(path.begin(), path.end())<<'\n';
-
-	StringList syspath;
-	if(current_arch->is_native())
-		syspath.push_back("/usr/include");
 	else
-		syspath.push_back("/usr/"+current_arch->get_prefix()+"/include");
-	syspath.push_back((FS::Path("/usr/include/c++/")/cxx_ver).str());
-
-	Target *tgt=0;
-	if(include[0]=='\"')
-		tgt=get_header(FS::Path(from)/fn);
-	for(list<string>::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j)
-		tgt=get_header(cwd/ *j/fn);
-	for(list<string>::const_iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j)
-		tgt=get_header(FS::Path(*j)/fn);
-
-	includes.insert(TargetMap::value_type(id, tgt));
-
-	return tgt;
-}
-
-Target *Builder::get_library(const string &lib, const list<string> &path, LibMode mode)
-{
-	string hash(8, 0);
-	for(list<string>::const_iterator i=path.begin(); i!=path.end(); ++i)
-		update_hash(hash, *i);
-
-	string id=hash+string(1, mode)+lib;
-	TargetMap::iterator i=libraries.find(id);
-	if(i!=libraries.end())
-		return i->second;
-
-	StringList syspath;
-	if(current_arch->is_native())
 	{
-		syspath.push_back("/lib");
-		syspath.push_back("/usr/lib");
+		current_arch = new Architecture(*this, name);
+		prefix = FS::get_home_dir()/"local"/current_arch->get_name();
 	}
-	else
-		syspath.push_back("/usr/"+current_arch->get_prefix()+"/lib");
-
-	if(verbose>=5)
-		cout<<"Looking for library "<<lib<<" with path "<<join(path.begin(), path.end())<<'\n';
-
-	Target *tgt=0;
-	for(StringList::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j)
-		tgt=get_library(lib, cwd/ *j, mode);
-	for(StringList::iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j)
-		tgt=get_library(lib, *j, mode);
-
-	libraries.insert(TargetMap::value_type(id, tgt));
-
-	return tgt;
 }
 
-const Architecture &Builder::get_architecture(const string &arch) const
+void Builder::set_build_type(const string &name)
 {
-	ArchMap::const_iterator i=archs.find(arch);
-	if(i==archs.end())
-		throw KeyError("Unknown architecture", arch);
-
-	return i->second;
+	build_type = &get_item(build_types, name);
 }
 
-void Builder::apply_profile_template(Config &config, const string &pt) const
+void Builder::set_prefix(const FS::Path &p)
 {
-	vector<string> parts=split(pt, '-');
-
-	for(vector<string>::iterator i=parts.begin(); i!=parts.end(); ++i)
-	{
-		ProfileTemplateMap::const_iterator j=profile_tmpl.find(*i);
-		if(j==profile_tmpl.end())
-			continue;
-
-		config.update(j->second);
-	}
+	prefix = p;
 }
 
-void Builder::problem(const string &p, const string &d)
+void Builder::set_temp_directory(const FS::Path &p)
 {
-	problems.push_back(Problem(p, d));
+	tempdir = p;
 }
 
-void Builder::add_target(Target *t)
+void Builder::add_default_tools()
 {
-	targets.insert(TargetMap::value_type(t->get_name(), t));
-	new_tgts.push_back(t);
+	if(current_arch->get_system()=="android")
+		toolchain.add_toolchain(new AndroidTools(*this, *current_arch));
+	toolchain.add_toolchain(new SystemTools(*this, *current_arch));
+	toolchain.add_toolchain(new BuiltinTools(*this));
+	toolchain.add_tool(new DataTool(*this));
 }
 
-void Builder::usage(const char *reason, const char *argv0, bool brief)
+void Builder::set_logger(const Logger *l)
 {
-	if(reason)
-		cerr<<reason<<'\n';
-
-	if(brief)
-		cerr<<"Usage: "<<argv0<<" [-a|--analyze MODE] [-b|--build] [-c|--clean] [-f|--file FILE] [-h|--help] [-j|--jobs NUM] [-n||--dry-run] [-v|--verbose] [-A|--conf-all] [-B|--build-all] [-C|--chdir DIRECTORY] [-W|--what-if FILE] [--chrome] [--conf-only] [--full-paths] [--max-depth NUM] [<target> ...]\n";
-	else
-	{
-		cerr<<
-			"Usage: "<<argv0<<" [options] [<target> ...]\n"
-			"\n"
-			"Options:\n"
-			"  -a, --analyze MODE  Perform analysis.  MODE can be deps, alldeps or rebuild.\n"
-			"  -b, --build         Perform build even if doing analysis.\n"
-			"  -c, --clean         Clean buildable targets.\n"
-			"  -f, --file FILE     Read info from FILE instead of Build.\n"
-			"  -h, --help          Print this message.\n"
-			"  -j, --jobs NUM      Run NUM commands at once, whenever possible.\n"
-			"  -n, --dry-run       Don't actually do anything, only show what would be done.\n"
-			"  -v, --verbose       Print more information about what's going on.\n"
-			"  -A, --conf-all      Apply configuration to all packages.\n"
-			"  -B, --build-all     Build all targets unconditionally.\n"
-			"  -C, --chdir DIR     Change to DIR before doing anything else.\n"
-			"  -P, --progress      Display progress while building.\n"
-			"  -W, --what-if FILE  Pretend that FILE has changed.\n"
-			"  --arch ARCH         Architecture to build for.\n"
-			"  --conf-only         Stop after configuring packages.\n"
-			"  --full-paths        Output full paths in analysis.\n"
-			//"  --makefile          Create a makefile for this package.\n"
-			"  --max-depth NUM     Maximum depth to show in analysis.\n"
-			"  --prefix DIR        Directory to install things to.\n"
-			"  --warnings LIST     Compiler warnings to use.\n";
-	}
+	logger = (l ? l : &default_logger);
 }
 
-FS::Path Builder::get_package_location(const string &name)
+list<string> Builder::collect_problems() const
 {
-	if(verbose>=3)
-		cout<<"Looking for package "<<name<<'\n';
-
-	// Try to get source directory with pkgconfig
-	list<string> argv;
-	argv.push_back("pkg-config");
-	argv.push_back("--variable=source");
-	argv.push_back(name);
-	if(verbose>=4)
-		cout<<"Running "<<join(argv.begin(), argv.end())<<'\n';
-	string srcdir=strip(run_command(argv));
-	if(!srcdir.empty())
-		return srcdir;
-
-	if(pkg_dirs.empty())
-	{
-		for(list<FS::Path>::const_iterator i=pkg_path.begin(); i!=pkg_path.end(); ++i)
+	list<string> problems;
+	set<const Package *> broken_packages;
+	set<const Component *> broken_components;
+	set<const Tool *> broken_tools;
+
+	const BuildGraph::TargetMap &targets = build_graph.get_targets();
+	for(BuildGraph::TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
+		if(i->second->is_broken())
 		{
-			list<string> files=list_files(*i);
-			for(list<string>::const_iterator j=files.begin(); j!=files.end(); ++j)
-			{
-				FS::Path full=*i / *j;
-				if(FS::exists(full/"Build"))
-					pkg_dirs.push_back(full);
-			}
-		}
-		if(verbose>=3)
-			cout<<pkg_dirs.size()<<" packages found in path\n";
-	}
-
-	bool msp=!name.compare(0, 3, "msp");
-	for(list<FS::Path>::const_iterator i=pkg_dirs.begin(); i!=pkg_dirs.end(); ++i)
-	{
-		string base=basename(*i);
-		unsigned dash=base.rfind('-');
-
-		if(!base.compare(0, dash, name))
-			return *i;
-		else if(msp && !base.compare(0, dash-3, name, 3, string::npos))
-			return *i;
-	}
-
-	return FS::Path();
-}
-
-int Builder::load_build_file(const FS::Path &fn)
-{
-	try
-	{
-		IO::BufferedFile in(fn.str());
-
-		if(verbose>=3)
-			cout<<"Reading "<<fn<<'\n';
-
-		DataFile::Parser parser(in, fn.str());
-		Loader loader(*this, fn.subpath(0, fn.size()-1));
-		loader.load(parser);
-	}
-	catch(const IO::FileNotFound &)
-	{
-		return -1;
-	}
-
-	return 0;
-}
-
-int Builder::create_targets()
-{
-	Target *world=new VirtualTarget(*this, "world");
-
-	Target *def_tgt=new VirtualTarget(*this, "default");
-	world->add_depend(def_tgt);
+			const list<string> &tgt_problems = i->second->get_problems();
+			for(list<string>::const_iterator j=tgt_problems.begin(); j!=tgt_problems.end(); ++j)
+				problems.push_back(format("%s: %s", i->second->get_name(), *j));
 
-	Target *install=new VirtualTarget(*this, "install");
-	world->add_depend(install);
+			const Package *package = i->second->get_package();
+			if(package && !package->get_problems().empty())
+				broken_packages.insert(package);
 
-	Target *tarballs=new VirtualTarget(*this, "tarballs");
-	world->add_depend(tarballs);
-
-	PackageList all_reqs=main_pkg->collect_requires();
-	for(PackageList::iterator i=all_reqs.begin(); i!=all_reqs.end(); ++i)
-	{
-		SourcePackage *spkg=dynamic_cast<SourcePackage *>(*i);
-		if(!spkg)
-			continue;
+			const Component *component = i->second->get_component();
+			if(component && !component->get_problems().empty())
+				broken_components.insert(component);
 
-		const ComponentList &components=spkg->get_components();
-		for(ComponentList::const_iterator j=components.begin(); j!=components.end(); ++j)
-			j->create_targets();
-
-		if(spkg->get_install_flags()&(SourcePackage::LIB|SourcePackage::INCLUDE))
-		{
-			PkgConfig *pc=new PkgConfig(*this, *spkg);
-			install->add_depend(new Install(*this, *spkg, *pc));
+			const Tool *tool = i->second->get_tool();
+			if(tool && !tool->get_problems().empty())
+				broken_tools.insert(tool);
 		}
 
-		tarballs->add_depend(new TarBall(*this, *spkg));
-	}
-
-	// Find dependencies until no new targets are created
-	while(!new_tgts.empty())
+	// TODO Sort components after their packages, and targets last
+	for(set<const Package *>::const_iterator i=broken_packages.begin(); i!=broken_packages.end(); ++i)
 	{
-		Target *tgt=new_tgts.front();
-		new_tgts.erase(new_tgts.begin());
-		tgt->find_depends();
-		if(!tgt->get_depends_ready())
-			new_tgts.push_back(tgt);
+		const list<string> &pkg_problems = (*i)->get_problems();
+		for(list<string>::const_iterator j=pkg_problems.begin(); j!=pkg_problems.end(); ++j)
+			problems.push_back(format("%s: %s", (*i)->get_name(), *j));
 	}
 
-	// Apply what-ifs
-	for(StringList::iterator i=what_if.begin(); i!=what_if.end(); ++i)
+	for(set<const Component *>::const_iterator i=broken_components.begin(); i!=broken_components.end(); ++i)
 	{
-		Target *tgt=get_target((cwd/ *i).str());
-		if(!tgt)
-		{
-			cerr<<"Unknown what-if target "<<*i<<'\n';
-			return -1;
-		}
-		tgt->touch();
+		const list<string> &comp_problems = (*i)->get_problems();
+		for(list<string>::const_iterator j=comp_problems.begin(); j!=comp_problems.end(); ++j)
+			problems.push_back(format("%s/%s: %s", (*i)->get_package().get_name(), (*i)->get_name(), *j));
 	}
 
-	// Make the cmdline target depend on all targets mentioned on the command line
-	Target *cmdline=new VirtualTarget(*this, "cmdline");
-	bool build_world=false;
-	for(list<string>::iterator i=cmdline_targets.begin(); i!=cmdline_targets.end(); ++i)
+	for(set<const Tool *>::const_iterator i=broken_tools.begin(); i!=broken_tools.end(); ++i)
 	{
-		Target *tgt=get_target(*i);
-		if(!tgt)
-			tgt=get_target((cwd/ *i).str());
-		if(!tgt)
-		{
-			cerr<<"I don't know anything about "<<*i<<'\n';
-			return -1;
-		}
-		if(tgt==world)
-			build_world=true;
-		cmdline->add_depend(tgt);
+		const list<string> &tool_problems = (*i)->get_problems();
+		for(list<string>::const_iterator j=tool_problems.begin(); j!=tool_problems.end(); ++j)
+			problems.push_back(format("%s: %s", (*i)->get_tag(), *j));
 	}
 
-	/* If world is to be built, prepare cmdline.  If not, add cmdline to world
-	and prepare world.  I don't really like this, but it keeps the graph
-	acyclic.
-	
-	XXX Could we skip preparing targets we are not interested in? */
-	if(build_world)
-		cmdline->prepare();
-	else
-	{
-		world->add_depend(cmdline);
-		world->prepare();
-	}
-
-	for(PackageMap::iterator i=packages.begin(); i!=packages.end(); ++i)
-		if(SourcePackage *spkg=dynamic_cast<SourcePackage *>(i->second))
-			spkg->get_deps_cache().save();
-
-	return 0;
-}
-
-Target *Builder::get_header(const Msp::FS::Path &fn)
-{
-	Target *tgt=get_target(fn.str());
-	if(tgt) return tgt;
-
-	if(FS::is_reg(fn))
-	{
-		tgt=new SystemHeader(*this, fn.str());
-		return tgt;
-	}
-	return 0;
+	return problems;
 }
 
-Target *Builder::get_library(const string &lib, const FS::Path &path, LibMode mode)
+void Builder::load_build_file(const FS::Path &fn, const Config::InputOptions *opts, bool all)
 {
-	// Populate a list of candidate filenames
-	StringList candidates;
+	IO::BufferedFile in(fn.str());
 
-	if(mode!=ALL_STATIC)
-	{
-		if(current_arch->get_name()=="win32")
-		{
-			candidates.push_back("lib"+lib+".dll");
-			candidates.push_back(lib+".dll");
-		}
-		else
-			candidates.push_back("lib"+lib+".so");
-	}
-
-	/* Static libraries are always considered, since sometimes shared versions
-	may not be available */
-	candidates.push_back("lib"+lib+".a");
-	if(current_arch->get_name()=="win32")
-		candidates.push_back("lib"+lib+".dll.a");
+	get_logger().log("files", format("Reading %s", fn));
 
-	for(StringList::iterator i=candidates.begin(); i!=candidates.end(); ++i)
-	{
-		string full=(path/ *i).str();
-		Target *tgt=get_target(full);
-
-		if(tgt)
-		{
-			Target *real_tgt=tgt;
-			if(Install *inst=dynamic_cast<Install *>(tgt))
-				real_tgt=&inst->get_source();
-
-			/* Ignore dynamic libraries from local packages unless library mode is
-			DYNAMIC */
-			if(dynamic_cast<SharedLibrary *>(real_tgt) && mode!=DYNAMIC)
-				continue;
-			else if(tgt)
-				return tgt;
-		}
-		else if(FS::is_reg(full))
-		{
-			tgt=new SystemLibrary(*this, full);
-			return tgt;
-		}
-	}
-
-	return 0;
+	DataFile::Parser parser(in, fn.str());
+	Loader loader(*this, opts, all);
+	loader.load(parser);
 }
 
-int Builder::do_build()
+int Builder::build(unsigned jobs, bool dry_run, bool show_progress)
 {
-	Target *cmdline=get_target("cmdline");
+	unsigned total = build_graph.count_rebuild_targets();
 
-	unsigned total=cmdline->count_rebuild();
 	if(!total)
 	{
-		cout<<"Already up to date\n";
+		get_logger().log("summary", "Already up to date");
 		return 0;
 	}
-	if(verbose>=1)
-		cout<<"Will build "<<total<<" target(s)\n";
+	get_logger().log("summary", format("Will build %d target%s", total, (total!=1 ? "s" : "")));
 
-	vector<Action *> actions;
+	vector<Task *> tasks;
 
-	unsigned count=0;
+	unsigned count = 0;
 
-	bool fail=false;
-	bool finish=false;
+	bool fail = false;
+	bool finish = false;
+	bool starved = false;
 
 	while(!finish)
 	{
-		if(actions.size()<jobs && !fail)
+		if(tasks.size()<jobs && !fail && !starved)
 		{
-			Target *tgt=cmdline->get_buildable_target();
+			Target *tgt = build_graph.get_buildable_target();
 			if(tgt)
 			{
-				Action *action=tgt->build();
-				if(action)
-					actions.push_back(action);
-
-				if(show_progress)
+				if(tgt->get_tool())
+					get_logger().log("tasks", format("%-4s  %s", tgt->get_tool()->get_tag(), tgt->get_name()));
+				Task *task = tgt->build();
+				if(task)
 				{
-					cout<<count<<" of "<<total<<" targets built\033[1G";
-					cout.flush();
+					get_logger().log("commands", format("%s", task->get_command()));
+					if(dry_run)
+					{
+						task->signal_finished.emit(true);
+						delete task;
+					}
+					else
+					{
+						task->start();
+						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())
-				finish=true;
+			else if(tasks.empty())
+				finish = true;
+			else
+				starved = 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;
+			if(jobs==1 || (tasks.size()==1 && starved))
+				status = tasks[i]->wait();
+			else
+				status = tasks[i]->check();
+
+			if(status!=Task::RUNNING)
 			{
 				++count;
 
-				delete actions[i];
-				actions.erase(actions.begin()+i);
-				if(status>0)
-					fail=true;
-				if(actions.empty() && fail)
-					finish=true;
+				delete tasks[i];
+				tasks.erase(tasks.begin()+i);
+				if(status==Task::ERROR)
+					fail = true;
+				if(tasks.empty() && fail)
+					finish = true;
+				starved = false;
 			}
 			else
 				++i;
@@ -753,123 +233,107 @@ int Builder::do_build()
 	}
 
 	if(show_progress)
-		cout<<"\033[K";
+		IO::print("\033[K");
 	if(fail)
-		cout<<"Build failed\n";
+		get_logger().log("summary", "Build failed");
 	else if(show_progress)
-		cout<<"Build complete\n";
+		get_logger().log("summary", "Build complete");
+
+	if(!dry_run)
+	{
+		const PackageManager::PackageMap &packages = package_manager.get_packages();
+		for(PackageManager::PackageMap::const_iterator i=packages.begin(); i!=packages.end(); ++i)
+			i->second->save_caches();
+	}
 
-	return fail?1:0;
+	return fail;
 }
 
-int Builder::do_clean()
+int Builder::clean(bool all, bool dry_run)
 {
 	// Cleaning doesn't care about ordering, so a simpler method can be used
 
 	set<Target *> clean_tgts;
-	TargetList queue;
-	queue.push_back(get_target("cmdline"));
+	list<Target *> queue;
+	queue.push_back(&build_graph.get_goals());
 
 	while(!queue.empty())
 	{
-		Target *tgt=queue.front();
-		queue.erase(queue.begin());
+		Target *tgt = queue.front();
+		queue.pop_front();
 
-		if(tgt->get_buildable() && (tgt->get_package()==main_pkg || clean>=2))
+		if(tgt->is_buildable() && (tgt->get_package()==&package_manager.get_main_package() || all))
 			clean_tgts.insert(tgt);
 
-		const TargetList &deps=tgt->get_depends();
-		for(TargetList::const_iterator i=deps.begin(); i!=deps.end(); ++i)
+		const Target::Dependencies &deps = tgt->get_dependencies();
+		for(list<Target *>::const_iterator i=deps.begin(); i!=deps.end(); ++i)
 			if(!clean_tgts.count(*i))
 				queue.push_back(*i);
 	}
 
 	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;
-		}
-
-	return 0;
-}
-
-void Builder::package_help()
-{
-	const Config &config=main_pkg->get_config();
-	const Config::OptionMap &options=config.get_options();
-
-	cout<<"Required packages:\n  ";
-	const PackageList &requires=main_pkg->get_requires();
-	for(PackageList::const_iterator i=requires.begin(); i!=requires.end(); ++i)
-	{
-		if(i!=requires.begin())
-			cout<<", ";
-		cout<<(*i)->get_name();
-	}
-	cout<<"\n\n";
-	cout<<"Package configuration:\n";
-	for(Config::OptionMap::const_iterator i=options.begin(); i!=options.end(); ++i)
 	{
-		const Config::Option &opt=i->second;
-		cout<<"  "<<opt.name<<": "<<opt.descr<<" ("<<opt.value<<") ["<<opt.defv<<"]\n";
+		get_logger().log("tasks", format("RM    %s", (*i)->get_name()));
+		if(!dry_run)
+			(*i)->clean();
 	}
-}
 
-Application::RegApp<Builder> Builder::reg;
+	return 0;
+}
 
 
-Builder::Loader::Loader(Builder &b, const FS::Path &s):
-	bld(b),
-	src(s)
+Builder::Loader::Loader(Builder &b, const Config::InputOptions *o, bool a):
+	DataFile::ObjectLoader<Builder>(b),
+	options(o),
+	conf_all(a)
 {
 	add("architecture", &Loader::architecture);
 	add("binary_package", &Loader::binpkg);
-	add("profile", &Loader::profile);
+	add("build_type", &Loader::build_type);
 	add("package", &Loader::package);
+
+	if(!obj.top_loader)
+		obj.top_loader = this;
+	else if(!options && obj.top_loader!=this && obj.top_loader->conf_all)
+		options = obj.top_loader->options;
+}
+
+Builder::Loader::~Loader()
+{
+	if(obj.top_loader==this)
+		obj.top_loader = 0;
 }
 
 void Builder::Loader::architecture(const string &n)
 {
-	Architecture arch(bld, n);
-	load_sub(arch);
-	bld.archs.insert(ArchMap::value_type(n, arch));
+	if(obj.current_arch->match_name(n))
+		load_sub(*obj.current_arch);
 }
 
 void Builder::Loader::binpkg(const string &n)
 {
-	BinaryPackage *pkg=new BinaryPackage(bld, n);
+	BinaryPackage *pkg = new BinaryPackage(obj, n);
 	load_sub(*pkg);
-	bld.packages.insert(PackageMap::value_type(n, pkg));
 }
 
-void Builder::Loader::profile(const string &n)
+void Builder::Loader::build_type(const string &n)
 {
-	StringMap prf;
-	ProfileLoader ldr(prf);
-	load_sub_with(ldr);
-	bld.profile_tmpl.insert(ProfileTemplateMap::value_type(n, prf));
+	BuildType btype(n);
+	load_sub(btype);
+	BuildTypeMap::iterator i = obj.build_types.insert(BuildTypeMap::value_type(n, btype)).first;
+	if(!obj.build_type)
+		obj.build_type = &i->second;
 }
 
 void Builder::Loader::package(const string &n)
 {
-	SourcePackage *pkg=new SourcePackage(bld, n, src);
-	if(!bld.main_pkg)
-		bld.main_pkg=pkg;
-
-	load_sub(*pkg);
-	bld.packages.insert(PackageMap::value_type(n, pkg));
-}
-
+	SourcePackage *pkg = new SourcePackage(obj, n, get_source());
 
-Builder::ProfileLoader::ProfileLoader(StringMap &p):
-	profile(p)
-{
-	add("option", &ProfileLoader::option);
-}
+	if(options)
+		load_sub(*pkg, *options);
+	else
+		load_sub(*pkg);
 
-void Builder::ProfileLoader::option(const string &o, const string &v)
-{
-	profile.insert(StringMap::value_type(o, v));
+	if(obj.build_type)
+		pkg->set_build_type(*obj.build_type);
 }