def configure(conf):
conf.use_tools(["ctasks"])
log_filename = os.path.join("build", "config.log")
ensure_dir(log_filename)
conf.log = open(log_filename, "w")
try:
# TODO
# - support for env update
# - config header support
# - confdefs header support
check_compiler(conf)
check_header(conf, "stdio.h")
check_header(conf, "stdio")
check_type(conf, "char")
#check_type(conf, "complex")
check_type(conf, "complex", headers=["complex.h"])
if check_func(conf, "exp"):
mlib = []
else:
if not check_lib(conf, "m", "exp"):
raise ValueError("What is mlib ?")
else:
mlib = ["m"]
check_lib(conf, mlib, "exp")
#check_lib(conf, lib="mm")
check_func(conf, "floor", libs=mlib)
check_func(conf, "floor")
generate_config_h(conf.conf_results, "build/conf/config.h")
finally:
conf.log.close()
def configure(conf):
conf.use_tools(["ctasks"])
log_filename = os.path.join("build", "config.log")
ensure_dir(log_filename)
conf.log = open(log_filename, "w")
try:
check_compiler(conf)
conf.env["CPPPATH"].append(distutils.sysconfig.get_python_inc())
if not check_header(conf, "Python.h"):
raise RuntimeError("Python header not found !")
check_header(conf, "math.h")
for mlibs in [[], ["m"]]:
if check_func(conf, "floor", libs=mlibs):
break
for tp in ("short", "int", "long"):
check_type_size(conf, tp)
for tp in ("float", "double", "long double"):
check_type_size(conf, tp)
check_type(conf, "Py_intptr_t", headers=["Python.h"])
define(conf, "NPY_NO_SMP")
mfuncs = ('expl', 'expf', 'log1p', 'expm1', 'asinh', 'atanhf',
'atanhl', 'rint', 'trunc')
check_funcs_at_once(conf, mfuncs)
generate_config_h(conf.conf_results, "build/conf/config.h")
finally:
conf.log.close()
def configure(conf):
from yaku.tools.gcc import detect
conf.use_tools(["ctasks"])
log_filename = os.path.join("build", "config.log")
ensure_dir(log_filename)
detect(conf)
conf.log = open(log_filename, "w")
try:
# TODO
# - support for env update
# - config header support
# - confdefs header support
check_compiler(conf)
check_header(conf, "stdio.h")
check_header(conf, "stdio")
check_type(conf, "char")
#check_type(conf, "complex")
check_type(conf, "complex", headers=["complex.h"])
check_lib(conf, lib="m")
#check_lib(conf, lib="mm")
check_func(conf, "floor", libs=["m"])
check_func(conf, "floor")
generate_config_h(conf.conf_results, "build/conf/config.h")
finally:
conf.log.close()
def configure(conf):
conf.use_tools(["ctasks"])
log_filename = os.path.join("build", "config.log")
ensure_dir(log_filename)
conf.log = open(log_filename, "w")
try:
check_compiler(conf)
conf.env["CPPPATH"].append(distutils.sysconfig.get_python_inc())
if not check_header(conf, "Python.h"):
raise RuntimeError("Python header not found !")
check_header(conf, "math.h")
for mlibs in [[], ["m"]]:
if check_func(conf, "floor", libs=mlibs):
break
for tp in ("short", "int", "long"):
check_type_size(conf, tp)
for tp in ("float", "double", "long double"):
check_type_size(conf, tp)
check_type(conf, "Py_intptr_t", headers=["Python.h"])
define(conf, "NPY_NO_SMP")
mfuncs = ('expl', 'expf', 'log1p', 'expm1', 'asinh', 'atanhf',
'atanhl', 'rint', 'trunc')
check_funcs_at_once(conf, mfuncs)
generate_config_h(conf.conf_results, "build/conf/config.h")
finally:
conf.log.close()
def configure(conf):
conf.use_tools(["ctasks"])
log_filename = os.path.join("build", "config.log")
ensure_dir(log_filename)
conf.log = open(log_filename, "w")
try:
# TODO
# - support for env update
# - config header support
# - confdefs header support
check_compiler(conf)
check_header(conf, "stdio.h")
check_header(conf, "stdio")
check_type(conf, "char")
#check_type(conf, "complex")
check_type(conf, "complex", headers=["complex.h"])
if check_func(conf, "exp"):
mlib = []
else:
if not check_lib(conf, "m", "exp"):
raise ValueError("What is mlib ?")
else:
mlib = ["m"]
check_lib(conf, mlib, "exp")
#check_lib(conf, lib="mm")
check_func(conf, "floor", libs=mlib)
check_func(conf, "floor")
generate_config_h(conf.conf_results, "build/conf/config.h")
finally:
conf.log.close()
def pylink_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
target = os.path.join(self.env["BLDDIR"], name + ".so")
ensure_dir(target)
task = Task("pylink", inputs=objects, outputs=target)
task.func = pylink
task.env_vars = pylink_vars
return [task]
def shared_ccompile_task(self, node):
base = self.env["CC_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("shcc")(inputs=[node], outputs=[target], func=shccompile, env=self.env)
task.gen = self
task.env_vars = cc_vars
return [task]
def store(self, filename):
tmp = filename + ".tmp"
ensure_dir(tmp)
fid = open(tmp, "w")
try:
for k in sorted(self.keys()):
fid.write("%s = %r\n" % (k, self[k]))
finally:
fid.close()
rename(tmp, filename)
def store(self, filename):
tmp = filename + ".tmp"
ensure_dir(tmp)
fid = open(tmp, "w")
try:
for k in sorted(self.keys()):
fid.write("%s = %r\n" % (k, self[k]))
finally:
fid.close()
rename(tmp, filename)
def pycc_task(self, node):
base = self.env["CC_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = Task("pycc", inputs=[node], outputs=[target])
task.gen = self
task.env_vars = pycc_vars
task.env = self.env
task.func = pycc
return [task]
def pycxx_task(self, node):
base = self.env["CXX_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("pycxx")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = pycxx_vars
task.env = self.env
task.func = pycxx
return [task]
def pycxx_task(self, node):
base = self.env["CXX_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("pycxx")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = pycxx_vars
task.env = self.env
task.func = pycxx
return [task]
def shared_ccompile_task(self, node):
base = self.env["CC_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("shcc")(inputs=[node],
outputs=[target],
func=shccompile,
env=self.env)
task.gen = self
task.env_vars = cc_vars
return [task]
def cython_task(self, node):
base = os.path.splitext(node)[0]
target = os.path.join(self.env["BLDDIR"], base + ".c")
ensure_dir(target)
task = Task("cython", inputs=node, outputs=target)
task.env_vars = []
task.env = self.env
task.func = compile_fun("cython", "cython ${SRC} -o ${TGT}",
False)[0]
compile_task = get_extension_hook(".c")
ctask = compile_task(self, target)
return [task] + ctask
def static_link_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["STATICLIB_FMT"] % base
target = self.bld.path.declare(tmp)
ensure_dir(target.abspath())
task = task_factory("cc_stlink")(inputs=objects, outputs=[target], func=clink, env=self.env)
task.gen = self
task.env_vars = clink_vars
return [task]
def fcompile_task(self, node):
base = self.env["F77_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("f77")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = f77_vars
task.env = self.env
task.func = f77_compile
self.object_tasks.append(task)
return [task]
def fcompile_task(self, node):
base = "%s.o" % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = Task("f77", inputs=[node], outputs=[target])
task.gen = self
task.env_vars = f77_vars
task.env = self.env
task.func = f77_compile
self.object_tasks.append(task)
return [task]
def fcompile_task(self, node):
base = self.env["F77_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("f77")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = f77_vars
task.env = self.env
task.func = f77_compile
self.object_tasks.append(task)
return [task]
def store(self, filename):
tmp = filename + ".tmp"
ensure_dir(tmp)
fid = open(tmp, "w")
for k in sorted(self.keys()):
fid.write("%s = %r\n" % (k, self[k]))
try:
os.unlink(filename)
except OSError:
pass
os.rename(tmp, filename)
def ccprogram_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
def declare_target():
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["PROGRAM_FMT"] % base
return self.bld.path.declare(tmp)
target = declare_target()
ensure_dir(target.abspath())
task = task_factory("cc_program")(inputs=objects, outputs=[target], func=ccprogram, env=self.env)
task.gen = self
task.env_vars = ccprogram_vars
return [task]
def pycc_task(self, node):
base = os.path.splitext(node)[0]
# XXX: hack to avoid creating build/build/... when source is
# generated. Dealing with this most likely requires a node concept
if not os.path.commonprefix([self.env["BLDDIR"], base]):
target = os.path.join(self.env["BLDDIR"], base + ".o")
else:
target = base + ".o"
ensure_dir(target)
task = Task("pycc", inputs=node, outputs=target)
task.env_vars = pycc_vars
task.env = self.env
task.func = pycc
return [task]
def shlink_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["SHAREDLIB_FMT"] % base
target = self.bld.bld_root.declare(tmp)
ensure_dir(target.abspath())
task = task_factory("cc_shlink")(inputs=objects, outputs=[target])
task.gen = self
task.env = self.env
task.func = cshlink
task.env_vars = cshlink_vars
return [task]
def cxxcompile_task(self, node):
base = self.env["CXX_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("cxx")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = cxx_vars
#print find_deps("foo.c", ["."])
#task.scan = lambda : find_deps(node, ["."])
#task.deps.extend(task.scan())
task.env = self.env
task.func = cxxcompile
return [task]
def template(self):
if not len(self.inputs) == 1:
raise ValueError("template func needs exactly one input")
pprint('GREEN', "%-16s%s" % (self.name.upper(),
" ".join([str(s) for s in self.inputs])))
subs_re = dict([(k, re.compile("@" + k + "@"))
for k in self.env["SUBST_DICT"]])
cnt = self.inputs[0].read()
for k, v in self.env["SUBST_DICT"].items():
cnt = subs_re[k].sub(v, cnt)
ensure_dir(self.outputs[0].abspath())
self.outputs[0].write(cnt)
def ccompile_task(self, node):
base = self.env["CC_OBJECT_FMT"] % node.name
target = node.parent.declare(base)
ensure_dir(target.abspath())
task = task_factory("cc")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = cc_vars
#print find_deps("foo.c", ["."])
#task.scan = lambda : find_deps(node, ["."])
#task.deps.extend(task.scan())
task.env = self.env
task.func = ccompile
return [task]
def fprogram_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
def declare_target():
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["F77_PROGRAM_FMT"] % base
return self.bld.bld_root.declare(tmp)
target = declare_target()
ensure_dir(target.abspath())
task = Task("fprogram", inputs=objects, outputs=[target])
task.gen = self
task.env = self.env
task.func = fprogram
task.env_vars = fprogram_vars
return [task]
def cython_task(self, node):
out = node.change_ext(".c")
target = node.parent.declare(out.name)
ensure_dir(target.name)
task = Task("cython", inputs=[node], outputs=[target])
task.gen = self
task.env_vars = []
task.env = self.env
self.env["CYTHON_INCPATH"] = ["-I%s" % p for p in
self.env["CYTHON_CPPPATH"]]
task.func = compile_fun("cython", "${CYTHON} ${SRC} -o ${TGT} ${CYTHON_INCPATH}",
False)[0]
return [task]
def shlink_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["SHAREDLIB_FMT"] % base
target = self.bld.path.declare(tmp)
ensure_dir(target.abspath())
task = task_factory("cc_shlink")(inputs=objects,
outputs=[target],
func=cshlink,
env=self.env)
task.gen = self
task.env_vars = cshlink_vars
return [task]
def swig_hook(self, name):
# FIXME: only handle C extension (no C++)
base = os.path.splitext(name)[0]
target = os.path.join(self.env["BLDDIR"], base)
targets = [target + "_wrap.c", target + ".py"]
for t in targets:
ensure_dir(t)
task = Task("swig", inputs=name, outputs=targets)
task.func = swig_func
task.env_vars = swig_vars
task.env = self.env
compile_task = get_extension_hook(".c")
ctask = compile_task(self, targets[0])
return [task] + ctask
def cxxprogram_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
def declare_target():
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["PROGRAM_FMT"] % base
return self.bld.path.declare(tmp)
target = declare_target()
ensure_dir(target.abspath())
task = task_factory("cxxprogram")(inputs=objects, outputs=[target])
task.gen = self
task.env = self.env
task.func = cxxprogram
task.env_vars = cxxprogram_vars
return [task]
def swig_hook(self, name):
# FIXME: only handle C extension (no C++)
base = os.path.splitext(name)[0]
target = os.path.join(self.env["BLDDIR"], base)
targets = [target + "_wrap.c", target + ".py"]
for t in targets:
ensure_dir(t)
task = task_factory("swig")(inputs=name, outputs=targets)
task.func = swig_func
task.env_vars = swig_vars
task.env = self.env
compile_task = get_extension_hook(".c")
ctask = compile_task(self, targets[0])
return [task] + ctask
def ccompile_task(self, node):
base = os.path.splitext(node)[0]
# XXX: hack to avoid creating build/build/... when source is
# generated. Dealing with this most likely requires a node concept
if not os.path.commonprefix([self.env["BLDDIR"], base]):
target = os.path.join(self.env["BLDDIR"], base + ".o")
else:
target = base + ".o"
ensure_dir(target)
task = Task("cc", inputs=node, outputs=target)
task.env_vars = cc_vars
#print find_deps("foo.c", ["."])
#task.scan = lambda : find_deps(node, ["."])
#task.deps.extend(task.scan())
task.env = self.env
task.func = ccompile
return [task]
def cython_task(self, node):
out = node.change_ext(".c")
target = node.parent.declare(out.name)
ensure_dir(target.name)
task = task_factory("cython")(inputs=[node], outputs=[target])
task.gen = self
task.env_vars = []
task.env = self.env
self.env["CYTHON_INCPATH"] = [
"-I%s" % p for p in self.env["CYTHON_CPPPATH"]
]
task.func = compile_fun("cython",
"${CYTHON} ${SRC} -o ${TGT} ${CYTHON_INCPATH}",
False)[0]
return [task]
def fortran_task(self, node):
base = os.path.splitext(node)[0]
# XXX: hack to avoid creating build/build/... when source is
# generated. Dealing with this most likely requires a node concept
if not base.startswith(self.env["BLDDIR"]):
target = os.path.join(self.env["BLDDIR"], base + ".o")
else:
target = base + ".o"
ensure_dir(target)
func, env_vars = compile_fun("f77",
"${F77} ${F77FLAGS} -c ${SRC} -o ${TGT[0]}", False)
task = Task("f77", inputs=node, outputs=target)
task.env_vars = env_vars
task.env = self.env
task.func = func
self.object_tasks.append(task)
return [task]
def pylink_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
if len(objects) < 1:
warnings.warn("task %s has no inputs !" % name)
def declare_target():
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["PYEXT_FMT"] % base
return self.bld.path.declare(tmp)
target = declare_target()
ensure_dir(target.abspath())
task = task_factory("pylink")(inputs=objects, outputs=[target])
task.gen = self
task.func = pylink
task.env_vars = pylink_vars
self.link_task = task
return [task]
def pylink_task(self, name):
objects = [tsk.outputs[0] for tsk in self.object_tasks]
if len(objects) < 1:
warnings.warn("task %s has no inputs !" % name)
def declare_target():
folder, base = os.path.split(name)
tmp = folder + os.path.sep + self.env["PYEXT_FMT"] % base
return self.bld.path.declare(tmp)
target = declare_target()
ensure_dir(target.abspath())
task = task_factory("pylink")(inputs=objects, outputs=[target])
task.gen = self
task.func = pylink
task.env_vars = pylink_vars
self.link_task = task
return [task]
def template(self):
if not len(self.inputs) == 1:
raise ValueError("template func needs exactly one input")
pprint('GREEN', "%-16s%s" % (self.name.upper(), " ".join(self.inputs)))
subs_re = dict([(k, re.compile("@" + k + "@"))
for k in self.env["SUBST_DICT"]])
fid = open(self.inputs[0])
try:
cnt = fid.read()
for k, v in self.env["SUBST_DICT"].items():
cnt = subs_re[k].sub(v, cnt)
finally:
fid.close()
ensure_dir(self.outputs[0])
fid = open(self.outputs[0], "w")
try:
fid.write(cnt)
finally:
fid.close()
def generate_config_h(conf_res, name):
def var_name(entry):
if entry["type"] == "header":
return "HAVE_%s" % entry["value"].upper().replace(".", "_")
elif entry["type"] == "type":
return "HAVE_%s" % entry["value"].upper().replace(" ", "_")
elif entry["type"] == "lib":
return "HAVE_LIB%s" % entry["value"].upper()
elif entry["type"] == "func":
return "HAVE_FUNC_%s" % entry["value"].upper()
ensure_dir(name)
fid = open(name, "w")
try:
for entry in conf_res:
var = var_name(entry)
if entry["result"]:
fid.write("#define %s 1\n\n" % var)
else:
fid.write("/*#undef %s*/\n\n" % var)
finally:
fid.close()
def create_file(conf, code, prefix="", suffix=""):
filename = "%s%s%s" % (prefix, md5(code).hexdigest(), suffix)
filename = join(conf.env["BLDDIR"], filename)
ensure_dir(filename)
open(filename, "w").write(code)
return filename
def generate_config_h(conf_res, name):
def value_to_string(value):
s = value.upper()
return VALUE_SUB.sub("_", s)
def var_name(entry):
if entry["type"] == "header":
return "HAVE_%s 1" % entry["value"].upper().replace(".", "_")
elif entry["type"] == "type":
return "HAVE_%s 1" % entry["value"].upper().replace(" ", "_")
elif entry["type"] == "type_size":
return "SIZEOF_%s %s" % (
value_to_string(entry["value"]),
entry["result"])
elif entry["type"] == "lib":
return "HAVE_LIB%s 1" % entry["value"].upper()
elif entry["type"] == "func":
return "HAVE_%s 1" % entry["value"].upper()
elif entry["type"] == "decl":
return "HAVE_DECL_%s 1" % entry["value"].upper()
else:
raise ValueError("Bug: entry %s not handled" % entry)
def comment(entry):
if entry["type"] == "header":
return r"""
/* Define to 1 if you have the <%s> header file. */
""" % entry["value"]
elif entry["type"] == "lib":
return r"""
/* Define to 1 if you have the `%s' library. */
""" % entry["value"]
elif entry["type"] == "func":
return r"""
/* Define to 1 if you have the `%s' function. */
""" % entry["value"]
elif entry["type"] == "decl":
return r"""
/* Set to 1 if %s is defined. */
""" % entry["value"]
elif entry["type"] == "type":
return r"""
/* Define if your compiler provides %s */
""" % entry["value"]
elif entry["type"] == "type_size":
return r"""
/* The size of `%s', as computed by sizeof. */
""" % entry["value"]
else:
raise ValueError("Bug: entry %s not handled" % entry)
buf = StringIO()
for entry in conf_res:
if entry["type"] == "define":
buf.write(entry["value"])
else:
var = var_name(entry)
if entry["result"]:
buf.write(comment(entry))
buf.write("#define %s\n" % var)
ensure_dir(name)
fid = open(name, "w")
try:
fid.write(buf.getvalue())
finally:
fid.close()
def myopen(filename, mode="r"):
if "w" in mode:
ensure_dir(filename)
return open(filename, mode)
def myopen(filename, mode="r"):
if "w" in mode:
ensure_dir(filename)
return open(filename, mode)
