const Builder::TargetMap &targets = builder.get_targets();
for(Builder::TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
{
- const Target::Dependencies &depends = i->second->get_depends();
+ const Target::Dependencies &depends = i->second->get_dependencies();
for(Target::Dependencies::const_iterator j=depends.begin(); j!=depends.end(); ++j)
rdepends[*j].insert(i->second);
}
Target &cmdline = *builder.get_target("cmdline");
if(mode==RDEPS)
{
- const Target::Dependencies &deps = cmdline.get_depends();
+ const Target::Dependencies &deps = cmdline.get_dependencies();
for(Target::Dependencies::const_iterator i=deps.begin(); i!=deps.end(); ++i)
build_depend_table(**i, 0);
}
depends.assign(rdeps.begin(), rdeps.end());
}
else
- depends = tgt.get_depends();
+ depends = tgt.get_dependencies();
depends.sort(full_paths ? target_order_full : target_order);
{
component = &c;
for(list<ObjectFile *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
- add_depend(**i);
+ add_dependency(**i);
}
-void Binary::find_depends()
+void Binary::find_dependencies()
{
if(!component)
return;
for(list<Target *>::iterator j=i; (last && j!=dep_libs.end()); ++j)
last = (j==i || *j!=*i);
if(last)
- add_depend(**i);
+ add_dependency(**i);
}
}
Binary(Builder &, const Component &, const std::string &, const std::list<ObjectFile *> &);
public:
- virtual void find_depends();
+ virtual void find_dependencies();
};
#endif
Target *world = new VirtualTarget(*this, "world");
Target *def_tgt = new VirtualTarget(*this, "default");
- world->add_depend(*def_tgt);
+ world->add_dependency(*def_tgt);
Target *install = new VirtualTarget(*this, "install");
- world->add_depend(*install);
+ world->add_dependency(*install);
Target *tarballs = new VirtualTarget(*this, "tarballs");
- world->add_depend(*tarballs);
+ world->add_dependency(*tarballs);
main_pkg->prepare();
return false;
}
- cmdline->add_depend(*tgt);
+ cmdline->add_dependency(*tgt);
}
cmdline->prepare();
if(tgt->is_buildable() && (tgt->get_package()==main_pkg || clean>=2))
clean_tgts.insert(tgt);
- const Target::Dependencies &deps = tgt->get_depends();
+ 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);
const Config::OptionMap &options = config.get_options();
IO::print("Required packages:\n ");
- const PackageList &requires = main_pkg->get_requires();
+ const PackageList &requires = main_pkg->get_required_packages();
for(PackageList::const_iterator i=requires.begin(); i!=requires.end(); ++i)
{
if(i!=requires.begin())
for(Config::OptionMap::const_iterator i=options.begin(); i!=options.end(); ++i)
{
const Config::Option &opt = i->second;
- IO::print(" %s: %s (%s)", opt.name, opt.descr, opt.value);
- if(opt.value!=opt.defv)
- IO::print(" [%s]", opt.defv);
+ IO::print(" %s: %s (%s)", opt.name, opt.description, opt.value);
+ if(opt.value!=opt.default_value)
+ IO::print(" [%s]", opt.default_value);
IO::print("\n");
}
}
const TargetMap &get_targets() const { return targets; }
- const Msp::FS::Path &get_cwd() const { return cwd; }
+ const Msp::FS::Path &get_work_directory() const { return cwd; }
const Architecture &get_current_arch() const { return *current_arch; }
const Architecture &get_native_arch() const { return native_arch; }
const Msp::FS::Path &get_prefix() const { return prefix; }
using namespace Msp;
Component::Component(SourcePackage &p, Type t, const string &n):
- pkg(p),
+ package(p),
type(t),
name(n),
install(false),
void Component::create_build_info()
{
- const PackageList &pkg_reqs = pkg.get_requires();
+ const PackageList &pkg_reqs = package.get_required_packages();
PackageList direct_reqs = requires;
direct_reqs.insert(direct_reqs.end(), pkg_reqs.begin(), pkg_reqs.end());
BuildInfo::UpdateLevel level = BuildInfo::CHAINED;
if(find(direct_reqs.begin(), direct_reqs.end(), *i)!=direct_reqs.end())
level = BuildInfo::DEPENDENCY;
- build_info.update_from((*i)->get_exported_binfo(), level);
+ build_info.update_from((*i)->get_exported_build_info(), level);
- const PackageList &reqs = (*i)->get_requires();
+ const PackageList &reqs = (*i)->get_required_packages();
for(PackageList::const_iterator j=reqs.begin(); j!=reqs.end(); ++j)
if(find(all_reqs.begin(), all_reqs.end(), *j)==all_reqs.end())
all_reqs.push_back(*j);
}
- build_info.update_from(pkg.get_build_info());
+ build_info.update_from(package.get_build_info());
for(BuildInfo::PathList::iterator i=build_info.incpath.begin(); i!=build_info.incpath.end(); ++i)
- *i = (pkg.get_source() / *i).str();
+ *i = (package.get_source_directory() / *i).str();
for(BuildInfo::PathList::iterator i=build_info.libpath.begin(); i!=build_info.libpath.end(); ++i)
- *i = (pkg.get_source() / *i).str();
+ *i = (package.get_source_directory() / *i).str();
if(type==LIBRARY || type==MODULE)
if(build_info.libmode<BuildInfo::DYNAMIC)
{
for(PackageList::iterator i=all_reqs.begin(); i!=all_reqs.end(); ++i)
{
- const BuildInfo &ebi = (*i)->get_exported_binfo();
+ const BuildInfo &ebi = (*i)->get_exported_build_info();
build_info.libpath.insert(build_info.libpath.end(), ebi.libpath.begin(), ebi.libpath.end());
}
}
void Component::create_targets() const
{
- Builder &builder = pkg.get_builder();
+ Builder &builder = package.get_builder();
const Toolchain &toolchain = builder.get_toolchain();
Target *world = builder.get_target("world");
Target *def_tgt = builder.get_target("default");
string tarname = name;
if(name=="@src")
{
- tarname = pkg.get_name()+"-"+pkg.get_version();
- source_filenames.push_back(pkg.get_source()/"Build");
+ tarname = package.get_name()+"-"+package.get_version();
+ source_filenames.push_back(package.get_source_directory()/"Build");
}
list<Target *> files;
{
const Builder::TargetMap &targets = builder.get_targets();
for(Builder::TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
- if(i->second->get_package()==&pkg && !i->second->is_buildable())
+ if(i->second->get_package()==&package && !i->second->is_buildable())
files.push_back(i->second);
}
/*Target *result = tar.create_target(files, tarname);
Target *tarballs_tgt = builder.get_target("tarballs");
- tarballs_tgt->add_depend(*result);*/
+ tarballs_tgt->add_dependency(*result);*/
return;
}
if(Target *tgt = builder.get_vfs().get_target(*i))
ft = dynamic_cast<FileTarget *>(tgt);
else
- ft = new File(builder, pkg, *i);
+ ft = new File(builder, package, *i);
inst_list.push_back(ft);
}
}
if(Target *tgt = builder.get_vfs().get_target(source_filenames.front()))
source = dynamic_cast<File *>(tgt);
else
- source = new File(builder, pkg, source_filenames.front());
+ source = new File(builder, package, source_filenames.front());
Target *result = dcomp.create_target(*source);
- if(&pkg==builder.get_main_package() && deflt)
- def_tgt->add_depend(*result);
+ if(&package==builder.get_main_package() && deflt)
+ def_tgt->add_dependency(*result);
else
- world->add_depend(*result);
+ world->add_dependency(*result);
if(install)
inst_list.push_back(result);
}
for(list<Target *>::const_iterator i=results.begin(); i!=results.end(); ++i)
{
- if(&pkg==builder.get_main_package() && deflt)
- def_tgt->add_depend(**i);
+ if(&package==builder.get_main_package() && deflt)
+ def_tgt->add_dependency(**i);
else
- world->add_depend(**i);
+ world->add_dependency(**i);
if(install)
inst_list.push_back(*i);
}
for(list<Target *>::const_iterator i=inst_list.begin(); i!=inst_list.end(); ++i)
{
Target *inst = copy.create_target(**i, inst_loc);
- inst_tgt->add_depend(*inst);
+ inst_tgt->add_dependency(*inst);
}
}
FS::Path path(*i);
if(FS::is_dir(path))
{
- pkg.get_builder().get_logger().log("files", format("Traversing %s", path));
+ package.get_builder().get_logger().log("files", format("Traversing %s", path));
list<string> sfiles = list_files(path);
for(list<string>::iterator j=sfiles.begin(); j!=sfiles.end(); ++j)
files.push_back(path / *j);
void Component::Loader::source(const string &s)
{
- obj.sources.push_back((obj.pkg.get_source()/s).str());
+ obj.sources.push_back((obj.package.get_source_directory()/s).str());
}
void Component::Loader::require(const string &n)
{
- Package *req = obj.pkg.get_builder().get_package_manager().find_package(n);
+ Package *req = obj.package.get_builder().get_package_manager().find_package(n);
if(req)
obj.requires.push_back(req);
}
void Component::Loader::install_map()
{
- load_sub(obj.install_map, obj.pkg.get_source());
+ load_sub(obj.install_map, obj.package.get_source_directory());
}
};
protected:
- SourcePackage &pkg;
+ SourcePackage &package;
Type type;
std::string name;
StringList sources;
public:
Component(SourcePackage &, Type, const std::string &);
- const SourcePackage &get_package() const { return pkg; }
+ const SourcePackage &get_package() const { return package; }
Type get_type() const { return type; }
const std::string &get_name() const { return name; }
const StringList &get_sources() const { return sources; }
const BuildInfo &get_build_info() const { return build_info; }
bool get_install() const { return install; }
- const PackageList &get_requires() const { return requires; }
+ const PackageList &get_required_packages() const { return requires; }
bool is_default() const { return deflt; }
const InstallMap &get_install_map() const { return install_map; }
if(!changed)
return;
- FS::Path fn = package.get_source()/".config";
+ FS::Path fn = package.get_source_directory()/".config";
package.get_builder().get_logger().log("files", format("Writing %s", fn));
IO::BufferedFile out(fn.str(), IO::M_WRITE);
void Config::load()
{
- FS::Path fn = package.get_source()/".config";
+ FS::Path fn = package.get_source_directory()/".config";
FS::Stat stat = FS::stat(fn);
if(stat)
{
Config::Option::Option(const string &n, const string &v, const string &d):
name(n),
- defv(v),
- descr(d),
+ default_value(v),
+ description(d),
value(v)
{ }
struct Option
{
std::string name;
- std::string defv;
- std::string descr;
+ std::string default_value;
+ std::string description;
std::string value;
Option(const std::string &, const std::string &, const std::string &);
install_location = FS::Path("include")/package->get_name();
}
-void CSourceFile::find_depends()
+void CSourceFile::find_dependencies()
{
if(!component || !mtime)
return;
const SourcePackage &spkg = component->get_package();
- string relname = FS::relative(path, spkg.get_source()).str();
+ string deps_key = FS::relative(path, spkg.get_source_directory()).str();
- DependencyCache &deps_cache = spkg.get_deps_cache();
- if(mtime<deps_cache.get_mtime() && deps_cache.has_deps(relname))
- includes = deps_cache.get_deps(relname);
+ DependencyCache &deps_cache = spkg.get_dependency_cache();
+ if(mtime<deps_cache.get_mtime() && deps_cache.has_deps(deps_key))
+ includes = deps_cache.get_deps(deps_key);
else
{
IO::BufferedFile in(path.str());
if(RegMatch match = r_include.match(line))
includes.push_back(match[1].str);
- deps_cache.set_deps(relname, includes);
+ deps_cache.set_deps(deps_key, includes);
}
const BuildInfo::PathList &incpath = component->get_build_info().incpath;
{
Target *hdr = builder.get_vfs().find_header(i->substr(1), ((*i)[0]=='"' ? local_incpath : incpath));
if(hdr)
- add_depend(*hdr);
+ add_dependency(*hdr);
}
}
virtual const char *get_type() const { return "CSourceFile"; }
const StringList &get_includes() const { return includes; }
- virtual void find_depends();
+ virtual void find_dependencies();
};
#endif
component(c),
source(s)
{
- add_depend(source);
+ add_dependency(source);
install_location = Msp::FS::Path("share")/package->get_name();
}
if(deps.empty() || !changed)
return;
- FS::Path fn = package.get_source()/".deps";
+ FS::Path fn = package.get_source_directory()/".deps";
package.get_builder().get_logger().log("files", format("Writing %s", fn));
IO::BufferedFile out(fn.str(), IO::M_WRITE);
void DependencyCache::load()
{
- FS::Path fn = package.get_source()/".deps";
+ FS::Path fn = package.get_source_directory()/".deps";
if(FS::Stat st = FS::stat(fn))
{
string FileTarget::generate_name(Builder &builder, const SourcePackage *pkg, const FS::Path &path)
{
- if(pkg && FS::descendant_depth(path, pkg->get_source())>=0)
+ if(pkg && FS::descendant_depth(path, pkg->get_source_directory())>=0)
{
- FS::Path relpath = FS::relative(path, pkg->get_source());
+ FS::Path relpath = FS::relative(path, pkg->get_source_directory());
return format("<%s>%s", pkg->get_name(), relpath.str().substr(1));
}
else if(FS::descendant_depth(path, builder.get_prefix())>=0)
argv.push_back(executable->get_path().str());
argv.push_back("rc");
- FS::Path work_dir = comp.get_package().get_source();
+ FS::Path work_dir = comp.get_package().get_source_directory();
argv.push_back(relative(lib.get_path(), work_dir).str());
- const Target::Dependencies &deps = lib.get_depends();
+ const Target::Dependencies &deps = lib.get_dependencies();
for(Target::Dependencies::const_iterator i=deps.begin(); i!=deps.end(); ++i)
if(ObjectFile *obj = dynamic_cast<ObjectFile *>(*i))
argv.push_back(relative(obj->get_path(), work_dir).str());
FS::Path obj_path = object.get_path();
FS::Path src_path = object.get_source().get_path();
- FS::Path work_dir = comp.get_package().get_source();
+ FS::Path work_dir = comp.get_package().get_source_directory();
argv.push_back("-o");
argv.push_back(relative(obj_path, work_dir).str());
if(architecture->get_bits()!=native_arch.get_bits())
argv.push_back(format("-m%d", architecture->get_bits()));
- FS::Path work_dir = comp.get_package().get_source();
+ FS::Path work_dir = comp.get_package().get_source_directory();
argv.push_back("-o");
argv.push_back(relative(bin.get_path(), work_dir).str());
bool static_link_ok = (binfo.libmode<=BuildInfo::STATIC);
- const Target::Dependencies &depends = target.get_depends();
+ const Target::Dependencies &depends = target.get_dependencies();
for(Target::Dependencies::const_iterator i=depends.begin(); i!=depends.end(); ++i)
{
Target *tgt = (*i)->get_real_target();
FileTarget(b, p, generate_target_path(b.get_prefix(), s, loc)),
source(s)
{
- add_depend(source);
+ add_dependency(source);
if(const SharedLibrary *shlib = dynamic_cast<const SharedLibrary *>(&source))
if(!shlib->get_soname().empty())
using namespace Msp;
ObjectFile::ObjectFile(Builder &b, const Component &c, SourceFile &s):
- FileTarget(b, c.get_package(), generate_target_path(c, FS::relative(s.get_path(), c.get_package().get_source()).str())),
+ FileTarget(b, c.get_package(), generate_target_path(c, FS::relative(s.get_path(), c.get_package().get_source_directory()).str())),
source(s)
{
component = &c;
- add_depend(source);
+ add_dependency(source);
}
FS::Path ObjectFile::generate_target_path(const Component &comp, const string &src)
return pkg.get_temp_dir()/comp.get_name()/fn;
}
-void ObjectFile::find_depends()
+void ObjectFile::find_dependencies()
{
for(Dependencies::iterator i=depends.begin(); i!=depends.end(); ++i)
{
(*i)->prepare();
- find_depends(dynamic_cast<FileTarget *>(*i));
+ find_dependencies(dynamic_cast<FileTarget *>(*i));
}
}
-void ObjectFile::find_depends(FileTarget *tgt)
+void ObjectFile::find_dependencies(FileTarget *tgt)
{
FileTarget *rtgt = dynamic_cast<FileTarget *>(tgt->get_real_target());
- const Dependencies &tdeps = rtgt->get_depends();
+ const Dependencies &tdeps = rtgt->get_dependencies();
Dependencies deps_to_add;
if(rtgt==tgt)
{
for(Dependencies::const_iterator i=tdeps.begin(); i!=tdeps.end(); ++i)
{
FileTarget *file = dynamic_cast<FileTarget *>(*i);
- if(file && file->get_package()==tpkg && FS::descendant_depth(file->get_path(), tpkg->get_source())>=0)
+ if(file && file->get_package()==tpkg && FS::descendant_depth(file->get_path(), tpkg->get_source_directory())>=0)
{
FS::Path displaced = tgt->get_path()/FS::relative(file->get_path(), rtgt->get_path());
if(Target *ddep = builder.get_vfs().get_target(displaced))
for(Dependencies::const_iterator i=deps_to_add.begin(); i!=deps_to_add.end(); ++i)
if(find(depends.begin(), depends.end(), *i)==depends.end())
- add_depend(**i);
+ add_dependency(**i);
}
virtual const char *get_type() const { return "ObjectFile"; }
SourceFile &get_source() const { return source; }
- virtual void find_depends();
+ virtual void find_dependencies();
private:
- void find_depends(FileTarget *);
+ void find_dependencies(FileTarget *);
};
#endif
const std::string &get_name() const { return name; }
Builder &get_builder() const { return builder; }
- const PackageList &get_requires() const { return requires; }
+ const PackageList &get_required_packages() const { return requires; }
- const BuildInfo &get_exported_binfo() const { return export_binfo; }
+ const BuildInfo &get_exported_build_info() const { return export_binfo; }
/// Indicates whether or not this package supports pkg-config
bool get_use_pkgconfig() const { return use_pkgconfig; }
no_externals(false),
env_set(false)
{
- pkg_path.push_back(builder.get_cwd()/".");
- pkg_path.push_back(builder.get_cwd()/"..");
+ pkg_path.push_back(builder.get_work_directory()/".");
+ pkg_path.push_back(builder.get_work_directory()/"..");
}
PackageManager::~PackageManager()
#include "pkgconfigfile.h"
PkgConfigFile::PkgConfigFile(Builder &b, const SourcePackage &p):
- FileTarget(b, p, p.get_source()/(p.get_name()+".pc"))
+ FileTarget(b, p, p.get_source_directory()/(p.get_name()+".pc"))
{
tool = &builder.get_toolchain().get_tool("PCG");
IO::BufferedFile out(target.get_path().str(), IO::M_WRITE);
IO::print(out, "prefix=%s\n", builder.get_prefix().str());
- IO::print(out, "source=%s\n\n", spkg.get_source());
+ IO::print(out, "source=%s\n\n", spkg.get_source_directory());
IO::print(out, "Name: %s\n", spkg.get_name());
IO::print(out, "Description: %s\n", spkg.get_description());
IO::print(out, "Version: %s\n", spkg.get_version());
IO::print(out, "Requires:");
- const PackageList &reqs = spkg.get_requires();
+ const PackageList &reqs = spkg.get_required_packages();
for(PackageList::const_iterator i=reqs.begin(); i!=reqs.end(); ++i)
if((*i)->get_use_pkgconfig())
IO::print(out, " %s", (*i)->get_name());
out.put('\n');
- const BuildInfo &binfo = spkg.get_exported_binfo();
+ const BuildInfo &binfo = spkg.get_exported_build_info();
IO::print(out, "Libs:");
for(BuildInfo::PathList::const_iterator i=binfo.libpath.begin(); i!=binfo.libpath.end(); ++i)
IO::print(out, " -L%s", FS::relative(*i, builder.get_prefix()).str());
SourcePackage::SourcePackage(Builder &b, const string &n, const FS::Path &s):
Package(b, n),
- source(s),
+ source_dir(s),
build_type(0),
config(*this),
deps_cache(*this)
if(temp.is_absolute())
return temp/name/subdir;
else
- return source/temp/subdir;
+ return source_dir/temp/subdir;
}
FS::Path SourcePackage::get_out_dir() const
const Architecture &arch = builder.get_current_arch();
string detail = (build_type ? build_type->get_name() : string());
if(arch.is_native())
- return source/detail;
+ return source_dir/detail;
else
- return source/arch.get_name()/detail;
+ return source_dir/arch.get_name()/detail;
}
void SourcePackage::create_build_info()
if(pc_needed)
{
PkgConfigFile *pc = new PkgConfigFile(builder, *this);
- builder.get_target("install")->add_depend(*builder.get_toolchain().get_tool("CP").create_target(*pc));
+ builder.get_target("install")->add_dependency(*builder.get_toolchain().get_tool("CP").create_target(*pc));
}
}
{
if(!i->first.compare(0, k->size(), *k))
{
- const_cast<InstallMap &>(j->get_install_map()).add_mapping(obj.source/i->first, i->second);
+ const_cast<InstallMap &>(j->get_install_map()).add_mapping(obj.source_dir/i->first, i->second);
}
}
}
IO::print("%s: Note: tar_file is deprecated\n", get_source());
for(ComponentList::iterator i=obj.components.begin(); i!=obj.components.end(); ++i)
if(i->get_type()==Component::TARBALL && i->get_name()=="@src")
- const_cast<StringList &>(i->get_sources()).push_back((obj.source/f).str());
+ const_cast<StringList &>(i->get_sources()).push_back((obj.source_dir/f).str());
}
std::string version;
std::string description;
- Msp::FS::Path source;
+ Msp::FS::Path source_dir;
const BuildType *build_type;
FeatureList features;
BuildInfo build_info;
const std::string &get_version() const { return version; }
const std::string &get_description() const { return description; }
- const Msp::FS::Path &get_source() const { return source; }
+ const Msp::FS::Path &get_source_directory() const { return source_dir; }
Msp::FS::Path get_temp_dir() const;
Msp::FS::Path get_out_dir() const;
const ComponentList &get_components() const { return components; }
const BuildInfo &get_build_info() const { return build_info; }
Builder &get_builder() const { return builder; }
- DependencyCache &get_deps_cache() const { return deps_cache; }
+ DependencyCache &get_dependency_cache() const { return deps_cache; }
private:
virtual void create_build_info();
{
component = &c;
for(list<ObjectFile *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
- add_depend(**i);
+ add_dependency(**i);
install_location = "lib";
}
TarBall *tarball = new TarBall(builder, *sources.front()->get_package(), arg);
for(list<Target *>::const_iterator i=sources.begin(); i!=sources.end(); ++i)
- tarball->add_depend(**i);
+ tarball->add_dependency(**i);
return tarball;
}
void Tar::Worker::main()
{
- const FS::Path &pkg_src = tarball.get_package()->get_source();
+ const FS::Path &pkg_src = tarball.get_package()->get_source_directory();
FS::Path basedir = FS::basepart(FS::basename(tarball.get_path()));
IO::File out(tarball.get_path().str(), IO::M_WRITE);
- const Target::Dependencies &deps = tarball.get_depends();
+ const Target::Dependencies &deps = tarball.get_dependencies();
for(Target::Dependencies::const_iterator i=deps.begin(); i!=deps.end(); ++i)
{
FileTarget *ft = dynamic_cast<FileTarget *>(*i);
using namespace std;
TarBall::TarBall(Builder &b, const SourcePackage &p, const string &n):
- FileTarget(b, p, p.get_source()/(n+".tar"))
+ FileTarget(b, p, p.get_source_directory()/(n+".tar"))
{ }
const SourcePackage *TarBall::get_package() const
builder.add_target(this);
}
-void Target::add_depend(Target &dep)
+void Target::add_dependency(Target &dep)
{
if(&dep==this)
throw invalid_argument("Target::add_depend");
}
state = PREPARING;
- find_depends();
+ find_dependencies();
if(tool)
{
if(FileTarget *tool_exe = tool->get_executable())
- add_depend(*tool_exe);
+ add_dependency(*tool_exe);
}
for(Dependencies::iterator i=depends.begin(); i!=depends.end(); ++i)
/** Adds a dependency for the target. Order is preseved and is important
for some target types. It is an error to create dependency cycles, although
this won't be detected until the targets are prepared. */
- void add_depend(Target &);
+ void add_dependency(Target &);
protected:
/** Finds dependencies for the target. Called during preparation. If the
target needs to recursively inspect its dependencies, it should prepare its
direct dependencies first. */
- virtual void find_depends() { }
+ virtual void find_dependencies() { }
public:
/// Returns the dependencies of the target, in the order they were added.
- const Dependencies &get_depends() const { return depends; }
+ const Dependencies &get_dependencies() const { return depends; }
/** Tries to locate a target that will help getting this target built. If
all dependencies are up-to-date, returns this target. If there are no