summaryrefslogtreecommitdiff
path: root/src/tasks.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/tasks.cc')
-rw-r--r--src/tasks.cc145
1 files changed, 71 insertions, 74 deletions
diff --git a/src/tasks.cc b/src/tasks.cc
index 68b2476..94fe269 100644
--- a/src/tasks.cc
+++ b/src/tasks.cc
@@ -8,8 +8,9 @@
#include <list>
#include <iostream>
#include <algorithm>
+#include <span>
-#include "libctor.h"
+#include "ctor.h"
#include "task.h"
#include "task_cc.h"
#include "task_ld.h"
@@ -18,24 +19,28 @@
#include "task_fn.h"
#include "rebuild.h"
#include "configure.h"
+#include "util.h"
+#include "tools.h"
-const std::deque<Target>& getTargets(const Settings& settings,
+const std::deque<Target>& getTargets(const ctor::settings& settings,
bool resolve_externals)
{
+ auto& config_files = getConfigFileList();
+
static bool initialised{false};
static std::deque<Target> targets;
if(!initialised)
{
- const auto& externals = configuration().externals;
- for(std::size_t i = 0; i < numConfigFiles; ++i)
+ const auto& externals = ctor::get_configuration().externals;
+ for(const auto& config_file : config_files)
{
std::string path =
- std::filesystem::path(configFiles[i].file).parent_path().string();
+ std::filesystem::path(config_file.file).parent_path().string();
if(settings.verbose > 1)
{
- std::cout << configFiles[i].file << " in path " << path << "\n";
+ std::cout << config_file.file << " in path " << path << "\n";
}
- auto configs = configFiles[i].cb(settings);
+ auto configs = config_file.cb(settings);
for(auto& config : configs)
{
if(resolve_externals)
@@ -50,21 +55,12 @@ const std::deque<Target>& getTargets(const Settings& settings,
exit(1);
}
const auto& flags = externals.at(external);
- config.flags.cflags.insert(config.flags.cflags.end(),
- flags.cflags.begin(),
- flags.cflags.end());
- config.flags.cxxflags.insert(config.flags.cxxflags.end(),
- flags.cxxflags.begin(),
- flags.cxxflags.end());
- config.flags.ldflags.insert(config.flags.ldflags.end(),
- flags.ldflags.begin(),
- flags.ldflags.end());
- config.flags.asmflags.insert(config.flags.asmflags.end(),
- flags.asmflags.begin(),
- flags.asmflags.end());
- //config.libs.insert(config.libs.end(),
- // libs.begin(),
- // libs.end());
+ append(config.flags.cflags, flags.cflags);
+ append(config.flags.cxxflags, flags.cxxflags);
+ append(config.flags.ldflags, flags.ldflags);
+ append(config.flags.arflags, flags.arflags);
+ append(config.flags.asmflags, flags.asmflags);
+ //append(config.libs.insert(config.libs libs);
}
}
@@ -77,49 +73,42 @@ const std::deque<Target>& getTargets(const Settings& settings,
return targets;
}
-std::set<std::shared_ptr<Task>> taskFactory(const BuildConfiguration& config,
- const Settings& settings,
- const std::string& sourceDir)
+std::vector<std::shared_ptr<Task>> taskFactory(const ctor::build_configuration& config,
+ const ctor::settings& settings,
+ const std::string& sourceDir,
+ bool is_self)
{
- std::set<std::shared_ptr<Task>> tasks;
+ std::vector<std::shared_ptr<Task>> tasks;
std::filesystem::path targetFile(config.target);
- TargetType target_type{config.type};
- if(target_type == TargetType::Auto)
+ ctor::target_type target_type{config.type};
+ if(target_type == ctor::target_type::automatic)
{
if(config.function != nullptr)
{
- target_type = TargetType::Function;
- }
- else if(targetFile.extension() == ".a")
- {
- target_type = TargetType::StaticLibrary;
- }
- else if(targetFile.extension() == ".so")
- {
- target_type = TargetType::DynamicLibrary;
- }
- else if(targetFile.extension() == "")
- {
- target_type = TargetType::Executable;
+ target_type = ctor::target_type::function;
}
else
{
- std::cerr << "Could not deduce target type from target " <<
- targetFile.string() << " please specify.\n";
- exit(1);
+ target_type = target_type_from_extension(ctor::toolchain::any, targetFile);
}
}
+ const auto& c = ctor::get_configuration();
std::vector<std::string> objects;
- if(target_type != TargetType::Function)
+ if(target_type != ctor::target_type::function)
{
- for(const auto& file : config.sources)
+ for(const auto& source : config.sources)
{
- auto task = std::make_shared<TaskCC>(config, settings, sourceDir, file);
- tasks.insert(task);
- objects.push_back(task->targetFile().string());
+ if(source.toolchain == ctor::toolchain::any ||
+ (config.system == ctor::output_system::build && source.toolchain == c.build_toolchain) ||
+ (config.system == ctor::output_system::host && source.toolchain == c.host_toolchain))
+ {
+ auto task = std::make_shared<TaskCC>(config, settings, sourceDir, source);
+ tasks.push_back(task);
+ objects.push_back(task->targetFile().string());
+ }
}
}
#ifndef BOOTSTRAP
@@ -128,7 +117,7 @@ std::set<std::shared_ptr<Task>> taskFactory(const BuildConfiguration& config,
for(const auto& file : config.sources)
{
auto task = std::make_shared<TaskFn>(config, settings, sourceDir, file);
- tasks.insert(task);
+ tasks.push_back(task);
objects.push_back(task->target());
}
}
@@ -136,35 +125,41 @@ std::set<std::shared_ptr<Task>> taskFactory(const BuildConfiguration& config,
switch(target_type)
{
- case TargetType::Auto:
+ case ctor::target_type::automatic:
// The target_type cannot be Auto
break;
- case TargetType::StaticLibrary:
- case TargetType::UnitTestLib:
- tasks.insert(std::make_shared<TaskAR>(config, settings, config.target,
- objects, sourceDir));
+ case ctor::target_type::unknown:
+ std::cerr << "Could not deduce target type from target " <<
+ targetFile.string() << " please specify.\n";
+ exit(1);
+ break;
+
+ case ctor::target_type::static_library:
+ case ctor::target_type::unit_test_library:
+ tasks.push_back(std::make_shared<TaskAR>(config, settings, config.target,
+ objects, sourceDir));
break;
#ifndef BOOTSTRAP
- case TargetType::DynamicLibrary:
+ case ctor::target_type::dynamic_library:
// TODO: Use C++20 starts_with
if(targetFile.stem().string().substr(0, 3) != "lib")
{
std::cerr << "Dynamic library target must have 'lib' prefix\n";
exit(1);
}
- tasks.insert(std::make_shared<TaskSO>(config, settings, config.target,
- objects, sourceDir));
+ tasks.push_back(std::make_shared<TaskSO>(config, settings, config.target,
+ objects, sourceDir));
break;
- case TargetType::Executable:
- case TargetType::UnitTest:
- tasks.insert(std::make_shared<TaskLD>(config, settings, config.target,
- objects, sourceDir));
+ case ctor::target_type::executable:
+ case ctor::target_type::unit_test:
+ tasks.push_back(std::make_shared<TaskLD>(config, settings, config.target,
+ objects, sourceDir, is_self));
break;
- case TargetType::Object:
- case TargetType::Function:
+ case ctor::target_type::object:
+ case ctor::target_type::function:
break;
#else
default:
@@ -175,18 +170,20 @@ std::set<std::shared_ptr<Task>> taskFactory(const BuildConfiguration& config,
return tasks;
}
-std::shared_ptr<Task> getNextTask(const std::set<std::shared_ptr<Task>>& allTasks,
- std::set<std::shared_ptr<Task>>& dirtyTasks)
+std::shared_ptr<Task> getNextTask([[maybe_unused]]const ctor::settings& settings,
+ [[maybe_unused]]const std::vector<std::shared_ptr<Task>>& allTasks,
+ std::vector<std::shared_ptr<Task>>& dirtyTasks)
{
for(auto dirtyTask = dirtyTasks.begin();
dirtyTask != dirtyTasks.end();
++dirtyTask)
{
+ auto task = *dirtyTask;
//std::cout << "Examining target " << (*dirtyTask)->target() << "\n";
- if((*dirtyTask)->ready())
+ if(task->ready() || settings.dry_run)
{
dirtyTasks.erase(dirtyTask);
- return *dirtyTask;
+ return task;
}
}
@@ -194,20 +191,20 @@ std::shared_ptr<Task> getNextTask(const std::set<std::shared_ptr<Task>>& allTask
return nullptr;
}
-std::set<std::shared_ptr<Task>> getTasks(const Settings& settings,
- const std::vector<std::string> names,
- bool resolve_externals)
+std::vector<std::shared_ptr<Task>> getTasks(const ctor::settings& settings,
+ const std::vector<std::string> names,
+ bool resolve_externals)
{
auto& targets = getTargets(settings, resolve_externals);
- std::set<std::shared_ptr<Task>> tasks;
+ std::vector<std::shared_ptr<Task>> tasks;
for(const auto& target : targets)
{
if(names.empty() ||
std::find(std::begin(names), std::end(names), target.config.target) != std::end(names))
{
std::vector<std::string> objects;
- auto t = taskFactory(target.config, settings, target.path);
- tasks.insert(t.begin(), t.end());
+ auto t = taskFactory(target.config, settings, target.path, false);
+ tasks.insert(tasks.end(), t.begin(), t.end());
}
}