def __call__(self, sched_ctx):
from wonderbuild.cxx_tool_chain import PkgConfigCheckTask
from wonderbuild.std_checks.std_math import StdMathCheckTask
from wonderbuild.std_checks.std_cxx import StdCxxCheckTask
from wonderbuild.std_checks.boost import BoostCheckTask
from wonderbuild.std_checks.multithreading_support import MultithreadingSupportCheckTask
from wonderbuild.std_checks.openmp import OpenMPCheckTask
from wonderbuild.std_checks.dynamic_loading_support import DynamicLoadingSupportCheckTask
check_cfg = self.cfg.clone()
std_math = StdMathCheckTask.shared(check_cfg)
std_cxx11 = StdCxxCheckTask.shared(check_cfg, 11)
self._boost = boost = BoostCheckTask.shared(
check_cfg, (1, 40, 0),
('system', 'thread', 'filesystem', 'date_time'))
mt = MultithreadingSupportCheckTask.shared(check_cfg)
openmp = OpenMPCheckTask.shared(check_cfg)
dl = DynamicLoadingSupportCheckTask.shared(check_cfg)
glibmm = PkgConfigCheckTask.shared(
check_cfg, ['glibmm-2.4', 'gmodule-2.0', 'gthread-2.0'])
req = [
std_math, boost
] # required because pre-compiled.private.hpp includes them unconditionaly
opt = [std_cxx11, mt, openmp, dl, glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)):
yield x
self.private_deps += req + [o for o in opt if o]
def __call__(self, sched_ctx):
from wonderbuild.cxx_tool_chain import PkgConfigCheckTask
from wonderbuild.std_checks.std_math import StdMathCheckTask
from wonderbuild.std_checks.std_cxx11 import StdCxx11CheckTask
from wonderbuild.std_checks.boost import BoostCheckTask
from wonderbuild.std_checks.multithreading_support import MultithreadingSupportCheckTask
from wonderbuild.std_checks.openmp import OpenMPCheckTask
from wonderbuild.std_checks.dynamic_loading_support import DynamicLoadingSupportCheckTask
check_cfg = self.cfg.clone()
std_math = StdMathCheckTask.shared(check_cfg)
std_cxx11 = StdCxx11CheckTask.shared(check_cfg)
self._boost = boost = BoostCheckTask.shared(
check_cfg, (1, 40, 0), ("system", "thread", "filesystem", "date_time")
)
mt = MultithreadingSupportCheckTask.shared(check_cfg)
openmp = OpenMPCheckTask.shared(check_cfg)
dl = DynamicLoadingSupportCheckTask.shared(check_cfg)
glibmm = PkgConfigCheckTask.shared(check_cfg, ["glibmm-2.4", "gmodule-2.0", "gthread-2.0"])
req = [std_math, boost] # required because pre-compiled.private.hpp includes them unconditionaly
opt = [std_cxx11, mt, openmp, dl, glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)):
yield x
self.private_deps += req + [o for o in opt if o]
def __call__(self, sched_ctx):
top_src_dir = self.src_dir.parent
src_dir = self.src_dir / 'src'
universalis = ScriptLoaderTask.shared(self.project, top_src_dir / 'universalis')
for x in sched_ctx.parallel_wait(universalis): yield x
universalis = universalis.script_task
self._common = common = universalis.common
universalis = universalis.mod_dep_phases
pch = common.pch
cfg = common.cfg.clone()
from wonderbuild.cxx_tool_chain import UserBuildCfgTask, ModTask, PkgConfigCheckTask
from wonderbuild.std_checks.std_math import StdMathCheckTask
from wonderbuild.std_checks.boost import BoostCheckTask
from wonderbuild.install import InstallTask
check_cfg = cfg.clone()
std_math = StdMathCheckTask.shared(check_cfg)
soxr = PkgConfigCheckTask.shared(check_cfg, ['soxr >= 0.1.1'])
boost_test = BoostCheckTask.shared(check_cfg, (1, 40, 0), ('unit_test_framework',))
class HelpersMathMod(ModTask):
def __init__(self):
name = 'psycle-helpers-math'
ModTask.__init__(self, name, ModTask.Kinds.HEADERS, cfg,
cxx_phase = self.__class__.InstallHeaders(cfg.project, name + '-headers'))
def do_set_deps(self, sched_ctx):
if False: yield
self.private_deps = [pch.lib_task]
self.public_deps = [universalis, std_math]
class InstallHeaders(InstallTask):
@property
def trim_prefix(self): return src_dir
@property
def dest_dir(self): return self.fhs.include
@property
def sources(self):
try: return self._sources
except AttributeError:
self._sources = [self.trim_prefix / 'psycle' / 'helpers' / 'math.hpp'] + \
list((self.trim_prefix / 'psycle' / 'helpers' / 'math').find_iter(
in_pats = ('*.hpp',), ex_pats = ('*.private.hpp',), prune_pats = ('todo',)))
return self._sources
def apply_cxx_to(self, cfg):
if not self.cxx_phase.dest_dir in cfg.include_paths: cfg.include_paths.append(self.cxx_phase.dest_dir)
self._math_mod_dep_phases = helpers_math = HelpersMathMod()
self.default_tasks.append(helpers_math.cxx_phase)
class HelpersMod(ModTask):
def __init__(self): ModTask.__init__(self, 'psycle-helpers', ModTask.Kinds.LIB, cfg)
def do_set_deps(self, sched_ctx):
if False: yield
self.private_deps = [pch.lib_task]
self.public_deps = [universalis, helpers_math, soxr]
self.cxx_phase = HelpersMod.InstallHeaders(self.base_cfg.project, self.name + '-headers')
class InstallHeaders(InstallTask):
@property
def trim_prefix(self): return src_dir
@property
def dest_dir(self): return self.fhs.include
@property
def sources(self):
try: return self._sources
except AttributeError:
self._sources = []
for s in (self.trim_prefix / 'psycle' / 'helpers').find_iter(
in_pats = ('*.hpp',), ex_pats = ('*.private.hpp', 'math.hpp'), prune_pats = ('todo', 'math')): self._sources.append(s)
return self._sources
def apply_cxx_to(self, cfg):
if not self.cxx_phase.dest_dir in cfg.include_paths: cfg.include_paths.append(self.cxx_phase.dest_dir)
def do_mod_phase(self):
self.cfg.include_paths.appendleft(src_dir)
self.cfg.defines['UNIVERSALIS__META__MODULE__NAME'] = '"' + self.name +'"'
self.cfg.defines['UNIVERSALIS__META__MODULE__VERSION'] = 0
for s in (src_dir / 'psycle' / 'helpers').find_iter(in_pats = ('*.cpp',), prune_pats = ('todo', 'math')): self.sources.append(s)
self._mod_dep_phases = helpers = HelpersMod()
self.default_tasks.append(helpers.mod_phase)
for x in sched_ctx.parallel_wait(boost_test): yield x
if boost_test:
class UnitTestMod(ModTask):
def __init__(self): ModTask.__init__(self, 'psycle-helpers-unit-tests', ModTask.Kinds.PROG, cfg)
def do_set_deps(self, sched_ctx):
if False: yield
self.private_deps = [pch.prog_task, helpers, boost_test]
def do_mod_phase(self):
self.cfg.include_paths.appendleft(src_dir)
self.cfg.defines['UNIVERSALIS__META__MODULE__NAME'] = '"' + self.name +'"'
self.cfg.defines['UNIVERSALIS__META__MODULE__VERSION'] = 0
self.sources.append(src_dir / 'unit_tests.cpp')
unit_tests = UnitTestMod()
self.default_tasks.append(unit_tests.mod_phase)
def __call__(self, sched_ctx):
top_src_dir = self.src_dir.parent
src_dir = self.src_dir / 'src'
diversalis = ScriptLoaderTask.shared(self.project, top_src_dir / 'diversalis')
for x in sched_ctx.parallel_wait(diversalis): yield x
diversalis = diversalis.script_task
self._common = common = diversalis.common
diversalis = diversalis.mod_dep_phases
pch = common.pch
cfg = common.cfg.clone()
from wonderbuild.cxx_tool_chain import PkgConfigCheckTask, ModTask
from wonderbuild.std_checks.std_math import StdMathCheckTask
from wonderbuild.std_checks.std_cxx11 import StdCxx11CheckTask
from wonderbuild.std_checks.boost import BoostCheckTask
from wonderbuild.std_checks.multithreading_support import MultithreadingSupportCheckTask
from wonderbuild.std_checks.openmp import OpenMPCheckTask
from wonderbuild.std_checks.dynamic_loading_support import DynamicLoadingSupportCheckTask
from wonderbuild.std_checks.winmm import WinMMCheckTask
check_cfg = cfg.clone()
std_math = StdMathCheckTask.shared(check_cfg)
std_cxx11 = StdCxx11CheckTask.shared(check_cfg)
boost = BoostCheckTask.shared(check_cfg, (1, 40, 0), ('system', 'thread', 'filesystem', 'date_time'))
boost_test = BoostCheckTask.shared(check_cfg, (1, 40, 0), ('unit_test_framework',))
mt = MultithreadingSupportCheckTask.shared(check_cfg)
openmp = OpenMPCheckTask.shared(check_cfg)
dl = DynamicLoadingSupportCheckTask.shared(check_cfg)
glibmm = PkgConfigCheckTask.shared(check_cfg, ['glibmm-2.4', 'gmodule-2.0', 'gthread-2.0'])
winmm = WinMMCheckTask.shared(check_cfg)
from wonderbuild.install import InstallTask
class UniversalisMod(ModTask):
def __init__(self): ModTask.__init__(self, 'universalis', ModTask.Kinds.LIB, cfg)
def do_set_deps(self, sched_ctx):
self.public_deps = [diversalis, std_math, boost, mt, dl]
if self.cfg.dest_platform.os == 'win': self.public_deps.append(winmm)
req = self.all_deps
opt = [std_cxx11, openmp, glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)): yield x
self.public_deps += [o for o in opt if o]
self.cxx_phase = self.__class__.InstallHeaders(self.base_cfg.project, self.name + '-headers')
class InstallHeaders(InstallTask):
@property
def trim_prefix(self): return src_dir
@property
def dest_dir(self): return self.fhs.include
@property
def sources(self):
try: return self._sources
except AttributeError:
self._sources = [self.trim_prefix / 'universalis.hpp'] + \
list((self.trim_prefix / 'universalis').find_iter(
in_pats = ('*.hpp',), ex_pats = ('*.private.hpp',), prune_pats = ('todo',)))
return self._sources
def apply_cxx_to(self, cfg):
if self.cxx_phase.dest_dir not in cfg.include_paths: cfg.include_paths.append(self.cxx_phase.dest_dir)
if not self.cfg.shared: cfg.defines['UNIVERSALIS__SOURCE'] = '-1'
def do_mod_phase(self):
if self.cfg.shared: self.cfg.defines['UNIVERSALIS__SHARED'] = None
self.cfg.defines['UNIVERSALIS__META__MODULE__NAME'] = '"' + self.name +'"'
self.cfg.defines['UNIVERSALIS__META__MODULE__VERSION'] = 0
self.cfg.include_paths.appendleft(src_dir)
for s in (src_dir / 'universalis').find_iter(in_pats = ('*.cpp',), prune_pats = ('todo',)): self.sources.append(s)
self._mod_dep_phases = mod_dep_phases = universalis = UniversalisMod()
common.pch.private_deps.append(mod_dep_phases)
self.default_tasks.append(mod_dep_phases.mod_phase)
for x in sched_ctx.parallel_wait(boost_test): yield x
if boost_test:
class UnitTestMod(ModTask):
def __init__(self): ModTask.__init__(self, 'universalis-unit-tests', ModTask.Kinds.PROG, cfg)
def do_set_deps(self, sched_ctx):
if False: yield
self.private_deps = [pch.prog_task, universalis, boost_test]
def do_mod_phase(self):
self.cfg.include_paths.appendleft(src_dir)
self.cfg.defines['UNIVERSALIS__META__MODULE__NAME'] = '"' + self.name +'"'
self.cfg.defines['UNIVERSALIS__META__MODULE__VERSION'] = 0
self.sources.append(src_dir / 'unit_tests.cpp')
unit_tests = UnitTestMod()
self.default_tasks.append(unit_tests.mod_phase)
def __call__(self, sched_ctx):
test_name = self.src_dir.name
src_dir = self.src_dir / 'src'
from wonderbuild.cxx_tool_chain import UserBuildCfgTask, PkgConfigCheckTask, BuildCheckTask, PreCompileTasks, ModTask
from wonderbuild.std_checks.std_math import StdMathCheckTask
from wonderbuild.install import InstallTask
cfg = UserBuildCfgTask.shared(self.project)
for x in sched_ctx.parallel_wait(cfg): yield x
cfg = cfg.clone()
if not src_dir in cfg.include_paths: cfg.include_paths.append(src_dir)
check_cfg = cfg.clone()
std_math = StdMathCheckTask.shared(check_cfg)
pe = cfg.dest_platform.bin_fmt == 'pe'
if not pe: glibmm = PkgConfigCheckTask.shared(check_cfg, ['glibmm-2.4 >= 2.4'])
class Pch(PreCompileTasks):
def __init__(self): PreCompileTasks.__init__(self, 'pch', cfg)
def do_set_deps(self, sched_ctx):
self.public_deps = [std_math]
req = self.public_deps
opt = []
if not pe: opt += [glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)): yield x
self.public_deps += [x for x in opt if x]
def do_cxx_phase(self):
self.source_text
self._source_text += '\n#include <cmath>'
if not pe and glibmm: self._source_text += '\n#include <glibmm.h>'
@property
def source_text(self):
try: return self._source_text
except AttributeError:
self._source_text = \
'#include <string>\n' \
'#include <sstream>\n' \
'#include <iostream>'
return self._source_text
pch = Pch()
class LibImpl(ModTask):
def __init__(self): ModTask.__init__(self, test_name + '--impl', ModTask.Kinds.LIB, cfg)
def do_set_deps(self, sched_ctx):
self.private_deps = [pch.lib_task]
req = self.private_deps
opt = [std_math]
if not pe: opt += [glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)): yield x
self.public_deps += [x for x in opt if x]
self.cxx_phase = self.__class__.Install(self.cfg.project, self.name + '-headers')
def do_mod_phase(self):
self.cfg.defines['IMPL'] = self.cfg.shared and '1' or '-1'
for s in (src_dir / 'impl').find_iter(('*.cpp',)): self.sources.append(s)
def apply_cxx_to(self, cfg):
if not self.cxx_phase.dest_dir in cfg.include_paths: cfg.include_paths.append(self.cxx_phase.dest_dir)
if not self.cfg.shared: cfg.defines['IMPL'] = '-1'
class Install(InstallTask):
@property
def trim_prefix(self): return src_dir
@property
def sources(self):
try: return self._sources
except AttributeError:
self._sources = []
for s in (self.trim_prefix / 'impl').find_iter(('*.hpp',)): self._sources.append(s)
return self._sources
@property
def dest_dir(self): return self.fhs.include / test_name
lib_impl = LibImpl()
class LibWrapper(ModTask):
def __init__(self): ModTask.__init__(self, test_name + '--wrapper', ModTask.Kinds.LIB, cfg)
def do_set_deps(self, sched_ctx):
self.public_deps = [lib_impl]
self.private_deps = [pch.lib_task]
req = self.public_deps + self.private_deps
opt = [std_math]
if not pe: opt += [glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)): yield x
self.public_deps += [x for x in opt if x]
self.cxx_phase = self.__class__.Install(self.cfg.project, self.name + '-headers')
def do_mod_phase(self):
self.cfg.defines['WRAPPER'] = self.cfg.shared and '1' or '-1'
for s in (src_dir / 'wrapper').find_iter(('*.cpp',)): self.sources.append(s)
def apply_cxx_to(self, cfg):
if not self.cxx_phase.dest_dir in cfg.include_paths: cfg.include_paths.append(self.cxx_phase.dest_dir)
if not self.cfg.shared: cfg.defines['WRAPPER'] = '-1'
class Install(InstallTask):
@property
def trim_prefix(self): return src_dir
@property
def sources(self):
try: return self._sources
except AttributeError:
self._sources = []
for s in (self.trim_prefix / 'wrapper').find_iter(('*.hpp',)): self._sources.append(s)
return self._sources
@property
def dest_dir(self): return self.fhs.include / test_name
lib_wrapper = LibWrapper()
class MainProg(ModTask):
def __init__(self): ModTask.__init__(self, test_name + '--main', ModTask.Kinds.PROG, cfg)
def do_set_deps(self, sched_ctx):
self.public_deps = [lib_wrapper]
self.private_deps = [pch.prog_task]
req = self.public_deps + self.private_deps
opt = []
if not pe: opt += [glibmm]
for x in sched_ctx.parallel_wait(*(req + opt)): yield x
self.public_deps += [x for x in opt if x]
def do_mod_phase(self):
for s in (src_dir / 'main').find_iter(('*.cpp',)): self.sources.append(s)
main_prog = MainProg()
self.default_tasks.append(main_prog.mod_phase)
