X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fbuilder.cpp;h=e8f8927d580ea0e2739aadf1bd32b055f420e1a5;hb=4facd021514ab372c23b1b132d6b4b62baa4efbf;hp=7704a9634a0e7b086276086ddac50a236a3fc9d8;hpb=c52efe77690dcf620d3b19f750a91422f771942d;p=builder.git

diff --git a/source/builder.cpp b/source/builder.cpp
index 7704a96..e8f8927 100644
--- a/source/builder.cpp
+++ b/source/builder.cpp
@@ -13,38 +13,32 @@
 #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 "header.h"
-#include "install.h"
-#include "misc.h"
+#include "copy.h"
+#include "externaltask.h"
+#include "gnuarchiver.h"
+#include "gnuccompiler.h"
+#include "gnucxxcompiler.h"
+#include "gnulinker.h"
+#include "installedfile.h"
 #include "package.h"
-#include "pkgconfig.h"
+#include "pkgconfigfile.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;
 using namespace Msp;
 
-namespace {
-
-void update_hash(string &hash, const string &value)
-{
-	for(unsigned i=0; i<value.size(); ++i)
-		hash[i%hash.size()] ^= value[i];
-}
-
-}
-
-
 Builder::Builder(int argc, char **argv):
 	main_pkg(0),
 	native_arch(*this, string()),
+	vfs(*this),
 	analyzer(0),
 	build(false),
 	clean(0),
@@ -131,12 +125,6 @@ Builder::Builder(int argc, char **argv):
 
 	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");
-
 	load_build_file((FS::get_sys_data_dir(argv[0], "builder")/"builderrc").str());
 	load_build_file((FS::get_user_data_dir("builder")/"rc").str());
 
@@ -155,6 +143,14 @@ Builder::Builder(int argc, char **argv):
 			}
 	}
 
+	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));
+
 	if(prfx.empty())
 	{
 		if(current_arch->is_native())
@@ -272,7 +268,7 @@ int Builder::main()
 				if(j->second->get_package()==i->second)
 				{
 					++count;
-					if(j->second->get_rebuild())
+					if(j->second->needs_rebuild())
 						++to_be_built;
 				}
 			if(count)
@@ -309,7 +305,7 @@ int Builder::main()
 
 string Builder::run_pkgconfig(const string &pkg, const string &what)
 {
-	list<string> argv;
+	ExternalTask::Arguments argv;
 	argv.push_back("pkg-config");
 	if(what=="cflags" || what=="libs")
 		argv.push_back("--"+what);
@@ -325,12 +321,17 @@ string Builder::run_pkgconfig(const string &pkg, const string &what)
 	if(verbose>=4)
 		IO::print("Running %s\n", join(argv.begin(), argv.end()));
 
-	int status;
-	string res = run_command(argv, &status);
-	if(status)
+	ExternalTask task(argv);
+	task.set_stdout(ExternalTask::CAPTURE);
+	task.set_stderr(ExternalTask::IGNORE);
+	task.start();
+	Task::Status status;
+	while((status=task.check())==Task::RUNNING)
+		Time::sleep(10*Time::msec);
+	if(status==Task::ERROR)
 		throw runtime_error(format("pkg-config for package %s failed", pkg));
 
-	return res;
+	return task.get_output();
 }
 
 Package *Builder::get_package(const string &name)
@@ -376,113 +377,6 @@ Target *Builder::get_target(const string &n) const
 	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);
-	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())
-	{
-		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)))
-		{
-			cxx_ver = m[0].str;
-			while(!cxx_ver.empty() && !FS::is_dir(FS::Path("/usr/include/c++")/cxx_ver))
-			{
-				string::size_type dot = cxx_ver.rfind('.');
-				if(dot==string::npos)
-					break;
-				cxx_ver.erase(dot);
-			}
-			if(verbose>=5)
-				IO::print("C++ version is %s\n", cxx_ver);
-		}
-		else
-			cxx_ver = "-";
-	}
-
-	string fn = include.substr(1);
-	if(verbose>=5)
-		IO::print("Looking for include %s from %s with path %s\n", fn, from, join(path.begin(), path.end()));
-
-	StringList syspath;
-	if(current_arch->is_native())
-		syspath.push_back("/usr/include");
-	else
-		syspath.push_back("/usr/"+current_arch->get_cross_prefix()+"/include");
-	if(cxx_ver!="-")
-		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");
-		if(current_arch->match_name("pc-32-linux"))
-			syspath.push_back("/usr/lib/i386-linux-gnu");
-		else if(current_arch->match_name("pc-64-linux"))
-			syspath.push_back("/usr/lib/x86_64-linux-gnu");
-	}
-	else
-		syspath.push_back("/usr/"+current_arch->get_cross_prefix()+"/lib");
-
-	if(verbose>=5)
-		IO::print("Looking for library %s with path %s\n", lib, join(path.begin(), path.end()));
-
-	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;
-}
-
 void Builder::apply_profile_template(Config &config, const string &pt) const
 {
 	vector<string> parts = split(pt, '-');
@@ -508,11 +402,6 @@ void Builder::add_target(Target *t)
 	new_tgts.push_back(t);
 }
 
-void Builder::register_path(const FS::Path &path, FileTarget *t)
-{
-	targets_by_path.insert(TargetMap::value_type(path.str(), t));
-}
-
 void Builder::usage(const char *reason, const char *argv0, bool brief)
 {
 	if(reason)
@@ -577,21 +466,17 @@ FS::Path Builder::get_package_location(const string &name)
 
 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;
 }
@@ -624,25 +509,16 @@ int Builder::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));
+			PkgConfigFile *pc = new PkgConfigFile(*this, *spkg);
+			install->add_depend(toolchain.get_tool("CP").create_target(*pc));
 		}
 	}
 
-	// Find dependencies until no new targets are created
-	while(!new_tgts.empty())
-	{
-		Target *tgt = new_tgts.front();
-		new_tgts.erase(new_tgts.begin());
-		tgt->find_depends();
-		if(!tgt->get_depends_ready())
-			new_tgts.push_back(tgt);
-	}
-
 	// Apply what-ifs
+	// XXX This does not currently work with targets found during dependency discovery
 	for(StringList::iterator i=what_if.begin(); i!=what_if.end(); ++i)
 	{
-		FileTarget *tgt = get_target_by_path(cwd/ *i);
+		FileTarget *tgt = vfs.get_target(cwd/ *i);
 		if(!tgt)
 		{
 			IO::print(IO::cerr, "Unknown what-if target %s\n", *i);
@@ -657,9 +533,9 @@ int Builder::create_targets()
 	{
 		Target *tgt = get_target(*i);
 		if(!tgt)
-			tgt = get_target_by_path(*i);
+			tgt = vfs.get_target(*i);
 		if(!tgt)
-			tgt = get_target_by_path(cwd/ *i);
+			tgt = vfs.get_target(cwd/ *i);
 		if(!tgt)
 		{
 			IO::print("I don't know anything about %s\n", *i);
@@ -678,75 +554,13 @@ int Builder::create_targets()
 	return 0;
 }
 
-Target *Builder::get_header(const FS::Path &fn)
-{
-	Target *tgt = get_target_by_path(fn);
-	if(tgt) return tgt;
-
-	if(FS::is_reg(fn))
-	{
-		tgt = new SystemHeader(*this, fn.str());
-		return tgt;
-	}
-	return 0;
-}
-
-Target *Builder::get_library(const string &lib, const FS::Path &path, LibMode mode)
-{
-	// Populate a list of candidate filenames
-	StringList candidates;
-
-	if(mode!=ALL_STATIC)
-	{
-		// XXX Should probably let the Architecture populate the list
-		if(current_arch->get_system()=="windows")
-		{
-			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_system()=="windows")
-		candidates.push_back("lib"+lib+".dll.a");
-
-	for(StringList::iterator i=candidates.begin(); i!=candidates.end(); ++i)
-	{
-		FS::Path full = path/ *i;
-		Target *tgt = get_target_by_path(full);
-
-		if(tgt)
-		{
-			Target *real_tgt = tgt->get_real_target();
-
-			/* 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.str());
-			return tgt;
-		}
-	}
-
-	return 0;
-}
-
 int Builder::do_build()
 {
 	Target *cmdline = get_target("cmdline");
 
 	unsigned total = 0;
 	for(map<string, Target *>::const_iterator i=targets.begin(); i!=targets.end(); ++i)
-		if(i->second->is_buildable() && i->second->get_rebuild())
+		if(i->second->is_buildable() && i->second->needs_rebuild())
 			++total;
 
 	if(!total)
@@ -757,7 +571,7 @@ int Builder::do_build()
 	if(verbose>=1)
 		IO::print("Will build %d target%s\n", total, (total!=1 ? "s" : ""));
 
-	vector<Action *> actions;
+	vector<Task *> tasks;
 
 	unsigned count = 0;
 
@@ -766,36 +580,51 @@ int Builder::do_build()
 
 	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("%-4s  %s\n", tgt->get_tool()->get_tag(), tgt->get_name());
+				Task *task = tgt->build();
+				if(task)
+				{
+					if(verbose>=2)
+						IO::print("%s\n", 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())
+			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
@@ -818,7 +647,7 @@ int Builder::do_clean()
 	// Cleaning doesn't care about ordering, so a simpler method can be used
 
 	set<Target *> clean_tgts;
-	TargetList queue;
+	list<Target *> queue;
 	queue.push_back(get_target("cmdline"));
 
 	while(!queue.empty())
@@ -829,19 +658,16 @@ int Builder::do_clean()
 		if(tgt->is_buildable() && (tgt->get_package()==main_pkg || clean>=2))
 			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_depends();
+		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;
-		}
+			if(ft->get_mtime())
+				FS::unlink(ft->get_path());
 
 	return 0;
 }