#include "androidresourcebundle.h"
#include "androidtools.h"
#include "component.h"
-#include "externaltask.h"
#include "sourcepackage.h"
using namespace std;
if(sdk.get_platform_jar().empty())
problems.push_back("Android platform not found");
- set_run(_run);
+ set_run_external(_run);
}
Target *AndroidAssetPackagingTool::create_target(const vector<Target *> &sources, const string &)
return res;
}
-Task *AndroidAssetPackagingTool::_run(const AndroidResourceBundle &res)
+ExternalTask::Arguments AndroidAssetPackagingTool::_run(const AndroidResourceBundle &res, FS::Path &work_dir)
{
const AndroidAssetPackagingTool &tool = dynamic_cast<const AndroidAssetPackagingTool &>(*res.get_tool());
argv.push_back(tool.get_executable()->get_path().str());
argv.push_back("package");
- FS::Path work_dir = res.get_component()->get_package().get_source_directory();
-
argv.push_back("-I");
argv.push_back(tool.sdk.get_platform_jar().str());
argv.push_back(FS::relative(d, work_dir).str());
}
- return new ExternalTask(argv, work_dir);
+ return argv;
}
Target *create_target(const std::vector<Target *> &, const std::string &) override;
private:
- static Task *_run(const AndroidResourceBundle &);
+ static ExternalTask::Arguments _run(const AndroidResourceBundle &, Msp::FS::Path &);
};
#endif
tool.extra_data = jarsigner;
}
-Task *ApkBuilder::_run(const AndroidPackageFile &apk)
+Task *ApkBuilder::_run(const Target &tgt)
{
+ const AndroidPackageFile &apk = dynamic_cast<const AndroidPackageFile &>(tgt);
const ApkBuilder &tool = dynamic_cast<const ApkBuilder &>(*apk.get_tool());
ExternalTask::Arguments argv;
void do_prepare(ToolData &) const override;
private:
- static Task *_run(const AndroidPackageFile &);
+ static Task *_run(const Target &);
};
#endif
#include <stdexcept>
#include "builder.h"
#include "component.h"
-#include "externaltask.h"
#include "gnuarchiver.h"
#include "objectfile.h"
#include "sourcepackage.h"
set_command("ar", true);
input_suffixes.push_back(".o");
processing_unit = COMPONENT;
- set_run(_run);
+ set_run_external(_run);
}
Target *GnuArchiver::create_target(const vector<Target *> &sources, const string &)
return lib;
}
-Task *GnuArchiver::_run(const StaticLibrary &lib)
+ExternalTask::Arguments GnuArchiver::_run(const StaticLibrary &lib, FS::Path &work_dir)
{
const Tool &tool = *lib.get_tool();
- const Component &comp = *lib.get_component();
vector<string> argv;
argv.push_back(tool.get_executable()->get_path().str());
argv.push_back("rc");
- FS::Path work_dir = comp.get_package().get_source_directory();
-
argv.push_back(relative(lib.get_path(), work_dir).str());
for(Target *d: lib.get_dependencies())
if(ObjectFile *obj = dynamic_cast<ObjectFile *>(d))
argv.push_back(relative(obj->get_path(), work_dir).str());
- return new ExternalTask(argv, work_dir);
+ return argv;
}
Target *create_target(const std::vector<Target *> &, const std::string &) override;
private:
- static Task *_run(const StaticLibrary &);
+ static ExternalTask::Arguments _run(const StaticLibrary &, Msp::FS::Path &);
};
#endif
#include "builder.h"
#include "component.h"
#include "csourcefile.h"
-#include "externaltask.h"
#include "gnucompiler.h"
#include "objcsourcefile.h"
#include "objectfile.h"
throw invalid_argument("GnuCompiler::GnuCompiler");
set_command((tag=="CXX" ? "g++" : "gcc"), true);
- set_run(_run);
+ set_run_external(_run);
}
Target *GnuCompiler::create_source(const Component &comp, const FS::Path &path) const
return ver;
}
-Task *GnuCompiler::_run(const ObjectFile &object)
+ExternalTask::Arguments GnuCompiler::_run(const ObjectFile &object, FS::Path &work_dir)
{
const Tool &tool = *object.get_tool();
const Architecture &arch = *tool.get_architecture();
FS::Path obj_path = object.get_path();
FS::Path src_path = object.get_source().get_path();
- FS::Path work_dir = object.get_component()->get_package().get_source_directory();
argv.push_back("-o");
argv.push_back(relative(obj_path, work_dir).str());
argv.push_back(relative(src_path, work_dir).str());
- return new ExternalTask(argv, work_dir);
+ return argv;
}
unsigned query_version(const std::string &, const std::string &) const;
private:
- static Task *_run(const ObjectFile &);
+ static ExternalTask::Arguments _run(const ObjectFile &, Msp::FS::Path &);
};
#endif
#include "component.h"
#include "executable.h"
#include "exportdefinitions.h"
-#include "externaltask.h"
#include "gnucompiler.h"
#include "gnulinker.h"
#include "importlibrary.h"
processing_unit = COMPONENT;
set_command("gcc", true);
- set_run(_run);
+ set_run_external(_run);
}
Target *GnuLinker::create_target(const vector<Target *> &sources, const string &arg)
}
}
-Task *GnuLinker::_run(const Binary &bin)
+ExternalTask::Arguments GnuLinker::_run(const Binary &bin, FS::Path &work_dir)
{
const Tool &tool = *bin.get_tool();
const Builder &builder = tool.get_builder();
ExternalTask::Arguments argv;
argv.push_back(tool.get_executable()->get_path().str());
- FS::Path work_dir = bin.get_component()->get_package().get_source_directory();
-
if(const SharedLibrary *shlib = dynamic_cast<const SharedLibrary *>(&bin))
{
argv.push_back("-shared");
argv.push_back("-Wl,--enable-auto-import");
}
- return new ExternalTask(argv, work_dir);
+ return argv;
}
protected:
void do_prepare(ToolData &) const override;
private:
- static Task *_run(const Binary &);
+ static ExternalTask::Arguments _run(const Binary &, Msp::FS::Path &);
};
#endif
#include <msp/core/environ.h>
#include <msp/fs/utils.h>
#include "component.h"
-#include "externaltask.h"
#include "filetarget.h"
#include "jarsigner.h"
#include "sourcepackage.h"
Tool(b, "JSGN")
{
set_command("jarsigner");
- set_run(_run);
+ set_run_external(_run);
}
Target *JarSigner::create_target(const vector<Target *> &, const string &)
throw logic_error("not implemented");
}
-Task *JarSigner::_run(const FileTarget &file)
+ExternalTask::Arguments JarSigner::_run(const FileTarget &file, FS::Path &work_dir)
{
const Tool &tool = *file.get_tool();
argv.push_back("-storepass");
argv.push_back("android");
- FS::Path work_dir = file.get_component()->get_package().get_source_directory();
-
argv.push_back(FS::relative(file.get_path(), work_dir).str());
argv.push_back("androiddebugkey");
- return new ExternalTask(argv, work_dir);
+ return argv;
}
Target *create_target(const std::vector<Target *> &, const std::string &) override;
private:
- static Task *_run(const FileTarget &);
+ static ExternalTask::Arguments _run(const FileTarget &, Msp::FS::Path &);
};
#endif
#include <msp/fs/utils.h>
#include "component.h"
-#include "externaltask.h"
#include "microsofttools.h"
#include "msvcarchiver.h"
#include "objectfile.h"
input_suffixes.push_back(".o");
processing_unit = COMPONENT;
set_command((ms_tools.get_vc_bin_dir()/"lib.exe").str(), false);
- set_run(_run);
+ set_run_external(_run);
}
Target *MsvcArchiver::create_target(const vector<Target *> &sources, const string &)
return lib;
}
-Task *MsvcArchiver::_run(const StaticLibrary &lib)
+ExternalTask::Arguments MsvcArchiver::_run(const StaticLibrary &lib, FS::Path &work_dir)
{
- const Component &comp = *lib.get_component();
const Tool &tool = *lib.get_tool();
vector<string> argv;
argv.push_back(tool.get_executable()->get_path().str());
argv.push_back("/NOLOGO");
- FS::Path work_dir = comp.get_package().get_source_directory();
-
argv.push_back("/OUT:"+relative(lib.get_path(), work_dir).str());
for(Target *d: lib.get_dependencies())
if(ObjectFile *obj = dynamic_cast<ObjectFile *>(d))
argv.push_back(relative(obj->get_path(), work_dir).str());
- return new ExternalTask(argv, work_dir);
+ return argv;
}
Target *create_target(const std::vector<Target *> &, const std::string &) override;
private:
- static Task *_run(const StaticLibrary &);
+ static ExternalTask::Arguments _run(const StaticLibrary &, Msp::FS::Path &);
};
#endif
#include "builder.h"
#include "component.h"
#include "csourcefile.h"
-#include "externaltask.h"
#include "microsofttools.h"
#include "msvccompiler.h"
#include "objectfile.h"
throw invalid_argument("MsvcCompiler::MsvcCompiler");
set_command((ms_tools.get_vc_bin_dir()/"cl.exe").str(), false);
- set_run(_run);
+ set_run_external(_run);
}
Target *MsvcCompiler::create_source(const Component &comp, const FS::Path &path) const
setenv("INCLUDE", path);
}
-Task *MsvcCompiler::_run(const ObjectFile &object)
+ExternalTask::Arguments MsvcCompiler::_run(const ObjectFile &object, FS::Path &work_dir)
{
const Tool &tool = *object.get_tool();
FS::Path obj_path = object.get_path();
FS::Path src_path = object.get_source().get_path();
- FS::Path work_dir = object.get_component()->get_package().get_source_directory();
argv.push_back("/Fo"+relative(obj_path, work_dir).str());
argv.push_back(relative(src_path, work_dir).str());
- return new ExternalTask(argv, work_dir);
+ return argv;
}
void do_prepare(ToolData &) const override;
public:
- static Task *_run(const ObjectFile &);
+ static ExternalTask::Arguments _run(const ObjectFile &, Msp::FS::Path &);
};
#endif
#include "builder.h"
#include "component.h"
#include "executable.h"
-#include "externaltask.h"
#include "importlibrary.h"
#include "microsofttools.h"
#include "msvclinker.h"
processing_unit = COMPONENT;
set_command((ms_tools.get_vc_bin_dir()/"link.exe").str(), false);
- set_run(_run);
+ set_run_external(_run);
}
Target *MsvcLinker::create_target(const vector<Target *> &sources, const string &arg)
setenv("LIB", path);
}
-Task *MsvcLinker::_run(const Binary &bin)
+ExternalTask::Arguments MsvcLinker::_run(const Binary &bin, FS::Path &work_dir)
{
const Tool &tool = *bin.get_tool();
argv.push_back(tool.get_executable()->get_path().str());
argv.push_back("/NOLOGO");
- FS::Path work_dir = bin.get_component()->get_package().get_source_directory();
-
if(dynamic_cast<const SharedLibrary *>(&bin))
argv.push_back("/DLL");
argv.push_back("/SUBSYSTEM:CONSOLE");
- return new ExternalTask(argv, work_dir);
+ return argv;
}
void do_prepare(ToolData &data) const override;
public:
- static Task *_run(const Binary &);
+ static ExternalTask::Arguments _run(const Binary &, Msp::FS::Path &);
};
#endif
#include <msp/strings/format.h>
#include "builder.h"
#include "executable.h"
-#include "externaltask.h"
#include "sourcegenerator.h"
#include "sourcepackage.h"
#include "templatefile.h"
Tool(b, t),
package(p)
{
- set_run(&_run);
+ set_run_external(&_run);
}
Target *SourceGenerator::create_source(const Component &comp, const FS::Path &path) const
return primary;
}
-Task *SourceGenerator::_run(const SourceFile &out_src)
+ExternalTask::Arguments SourceGenerator::_run(const SourceFile &out_src, FS::Path &work_dir)
{
- const FS::Path &work_dir = out_src.get_package()->get_source_directory();
const SourceGenerator &tool = dynamic_cast<const SourceGenerator &>(*out_src.get_tool());
vector<string> args;
args.push_back(tool.out_argument);
args.push_back(FS::relative(out_src.get_path(), work_dir).str());
- return new ExternalTask(args, work_dir);
+ return args;
}
Target *create_target(const std::vector<Target *> &, const std::string &) override;
private:
- static Task *_run(const SourceFile &);
+ static ExternalTask::Arguments _run(const SourceFile &, Msp::FS::Path &);
};
#endif
#include <vector>
#include <msp/fs/path.h>
#include "buildinfo.h"
+#include "externaltask.h"
#include "internaltask.h"
+#include "sourcepackage.h"
+#include "target.h"
#include "virtualfilesystem.h"
class Architecture;
class BuildInfo;
class Component;
class FileTarget;
-class Target;
class ToolData
{
void set_run(std::function<Task *(const Target &)>);
template<typename T>
- void set_run(Task *(*)(const T &));
+ void set_run_external(ExternalTask::Arguments (*)(const T &, Msp::FS::Path &));
template<typename T>
void set_run_internal(bool (*)(const T &));
template<typename T>
-void Tool::set_run(Task *(*f)(const T &))
+void Tool::set_run_external(ExternalTask::Arguments (*f)(const T &, Msp::FS::Path &))
{
- set_run([f](const Target &t){ return f(dynamic_cast<const T &>(t)); });
+ set_run([f](const Target &t){
+ Msp::FS::Path work_dir = t.get_package()->get_source_directory();
+ ExternalTask::Arguments args = f(dynamic_cast<const T &>(t), work_dir);
+ return new ExternalTask(args, work_dir);
+ });
}
template<typename T>