def _check_append_library(libraries, item):
for libitem in libraries:
if is_sequence(libitem):
if is_sequence(item):
if item[0]==libitem[0]:
if item[1] is libitem[1]:
return
warnings.warn("[0] libraries list contains %r with"
" different build_info" % (item[0],))
break
else:
if item==libitem[0]:
warnings.warn("[1] libraries list contains %r with"
" no build_info" % (item[0],))
break
else:
if is_sequence(item):
if item[0]==libitem:
warnings.warn("[2] libraries list contains %r with"
" no build_info" % (item[0],))
break
else:
if item==libitem:
return
libraries.append(item)
def _check_append_ext_library(libraries, lib_info_tuple):
(lib_name, build_info) = lib_info_tuple
for item in libraries:
if is_sequence(item):
if item[0]==lib_name:
if item[1] is build_info:
return
warnings.warn("[3] libraries list contains %r with"
" different build_info" % (lib_name,))
break
elif item==lib_name:
warnings.warn("[4] libraries list contains %r with"
" no build_info" % (lib_name,))
break
libraries.append((lib_name,build_info))
def setup(**attr):
# pylint: disable=W0212
# pylint: disable=W0142
cmdclass = my_cmdclass.copy()
new_attr = attr.copy()
if 'cmdclass' in new_attr:
cmdclass.update(new_attr['cmdclass'])
new_attr['cmdclass'] = cmdclass
if 'configuration' in new_attr:
# To avoid calling configuration if there are any errors
# or help request in command in the line.
configuration = new_attr.pop('configuration')
old_dist = distutils.core._setup_distribution
old_stop = distutils.core._setup_stop_after
distutils.core._setup_distribution = None
distutils.core._setup_stop_after = "commandline"
try:
dist = setup(**new_attr)
finally:
distutils.core._setup_distribution = old_dist
distutils.core._setup_stop_after = old_stop
if dist.help or not _command_line_ok():
# probably displayed help, skip running any commands
return dist
# create setup dictionary and append to new_attr
cfg = configuration()
if hasattr(cfg,'todict'):
cfg = cfg.todict()
_dict_append(new_attr, **cfg) # pylint: disable=W0142
# Move extension source libraries to libraries
libraries = []
for ext in new_attr.get('ext_modules',[]):
new_libraries = []
for item in ext.libraries:
#[item] = convert_ulist([item])
if is_sequence(item):
lib_name, _ = item
_check_append_ext_library(libraries, item)
new_libraries.append(lib_name)
elif is_string(item):
new_libraries.append(item)
else:
raise TypeError("invalid description of extension module "
"library %r" % (item,))
ext.libraries = new_libraries
if libraries:
if 'libraries' not in new_attr:
new_attr['libraries'] = []
for item in libraries:
_check_append_library(new_attr['libraries'], item)
# sources in ext_modules or libraries may contain header files
if ('ext_modules' in new_attr or 'libraries' in new_attr) \
and 'headers' not in new_attr:
new_attr['headers'] = []
# Use our custom Distribution class instead of distutils' one
new_attr['distclass'] = CustomDistribution
if not USING_SETUPTOOLS and setuptools_in_use():
raise Exception("Spurious import of setuptools. Failure in build.")
return old_setup(**new_attr)
def build_target(builder, target, name, mode):
"""
Common function for build_* commands
"""
target_name = name
if mode == SHARED_LIBRARY:
target_name = builder.compiler.library_filename(name, lib_type='shared',
output_dir='')
#libraries = convert_ulist(_get(target, 'libraries', [])) ## unused
library_dirs = convert_ulist(_get(target, 'library_dirs', []))
runtime_library_dirs = convert_ulist(_get(target,
'runtime_library_dirs', []))
extra_preargs = _get(target, 'extra_compile_args', [])
extra_postargs = _get(target, 'extra_link_args', [])
## include libraries built by build_shlib and/or build_clib
library_dirs.append(builder.build_temp)
## Conditional recompile
build_directory = builder.build_clib
target_path = os.path.join(build_directory, name)
recompile = False
if not os.path.exists(target_path) or builder.force:
recompile = True
else:
for src in _get(target, 'sources', []):
if os.path.getmtime(target_path) < os.path.getmtime(src):
recompile = True
break
if not recompile:
return
library_dirs += [builder.build_clib]
########################################
## Copied from numpy.distutils.command.build_clib
# default compilers
compiler = builder.compiler
fcompiler = getattr(builder, '_f_compiler', builder.fcompiler)
sources = _get(target, 'sources')
if sources is None or not is_sequence(sources):
raise DistutilsSetupError(("in 'libraries' option (library '%s'), " +
"'sources' must be present and must be " +
"a list of source filenames") % name)
sources = list(sources)
c_sources, cxx_sources, f_sources, fmodule_sources = filter_sources(sources)
requiref90 = not not fmodule_sources or \
(_get(target, 'language', 'c') == 'f90')
# save source type information so that build_ext can use it.
source_languages = []
if c_sources:
source_languages.append('c')
if cxx_sources:
source_languages.append('c++')
if requiref90:
source_languages.append('f90')
elif f_sources:
source_languages.append('f77')
_put(target, 'source_languages', source_languages)
lib_file = compiler.library_filename(name, output_dir=build_directory)
if mode == SHARED_LIBRARY:
lib_file = compiler.library_filename(name, lib_type='shared',
output_dir=build_directory)
depends = sources + (_get(target, 'depends', []))
if not (builder.force or newer_group(depends, lib_file, 'newer')):
log.debug("skipping '%s' library (up-to-date)", name)
return
else:
log.info("building '%s' library", name)
if have_numpy:
config_fc = _get(target, 'config_fc', {})
if fcompiler is not None and config_fc:
log.info('using additional config_fc from setup script '\
'for fortran compiler: %s' % (config_fc,))
from numpy.distutils.fcompiler import new_fcompiler
fcompiler = new_fcompiler(compiler=fcompiler.compiler_type,
verbose=builder.verbose,
dry_run=builder.dry_run,
force=builder.force,
requiref90=requiref90,
c_compiler=builder.compiler)
if fcompiler is not None:
dist = builder.distribution
base_config_fc = dist.get_option_dict('config_fc').copy()
base_config_fc.update(config_fc)
fcompiler.customize(base_config_fc)
# check availability of Fortran compilers
if (f_sources or fmodule_sources) and fcompiler is None:
ver = '77'
if requiref90:
ver = '90'
raise DistutilsError("target %s has Fortran%s sources" \
" but no Fortran compiler found" % (name, ver))
macros = _get(target, 'define_macros')
include_dirs = convert_ulist(_get(target, 'include_dirs'))
if include_dirs is None:
include_dirs = []
extra_postargs = _get(target, 'extra_compiler_args') or []
if have_numpy:
include_dirs.extend(get_numpy_include_dirs())
# where compiled F90 module files are:
module_dirs = _get(target, 'module_dirs', [])
module_build_dir = os.path.dirname(lib_file)
if requiref90:
builder.mkpath(module_build_dir)
if compiler.compiler_type=='msvc':
# this hack works around the msvc compiler attributes
# problem, msvc uses its own convention :(
c_sources += cxx_sources
cxx_sources = []
objects = []
if c_sources:
log.info("compiling C sources")
objects = compiler.compile(c_sources,
output_dir=builder.build_temp,
macros=macros,
include_dirs=include_dirs,
debug=builder.debug,
extra_postargs=extra_postargs)
if cxx_sources:
log.info("compiling C++ sources")
cxx_compiler = compiler.cxx_compiler()
cxx_objects = cxx_compiler.compile(cxx_sources,
output_dir=builder.build_temp,
macros=macros,
include_dirs=include_dirs,
debug=builder.debug,
extra_postargs=extra_postargs)
objects.extend(cxx_objects)
if f_sources or fmodule_sources:
if not have_numpy:
raise Exception("Fortran sources, but no NumPy to compile them.")
extra_postargs = []
f_objects = []
if requiref90:
if fcompiler.module_dir_switch is None:
existing_modules = glob('*.mod')
extra_postargs += fcompiler.module_options(
module_dirs,module_build_dir)
if fmodule_sources:
log.info("compiling Fortran 90 module sources")
f_objects += fcompiler.compile(fmodule_sources,
output_dir=builder.build_temp,
macros=macros,
include_dirs=include_dirs,
debug=builder.debug,
extra_postargs=extra_postargs)
if requiref90 and fcompiler.module_dir_switch is None:
# move new compiled F90 module files to module_build_dir
for f in glob('*.mod'):
if f in existing_modules:
continue
t = os.path.join(module_build_dir, f)
if os.path.abspath(f)==os.path.abspath(t):
continue
if os.path.isfile(t):
os.remove(t)
try:
builder.move_file(f, module_build_dir)
except DistutilsFileError:
log.warn('failed to move %r to %r' % (f, module_build_dir))
if f_sources:
log.info("compiling Fortran sources")
f_objects += fcompiler.compile(f_sources,
output_dir=builder.build_temp,
macros=macros,
include_dirs=include_dirs,
debug=builder.debug,
extra_postargs=extra_postargs)
else:
f_objects = []
objects.extend(f_objects)
# assume that default linker is suitable for
# linking Fortran object files
########################################
if _get(target, 'link_with_fcompiler', False): # if using PROGRAM
link_compiler = fcompiler
else:
link_compiler = compiler
if cxx_sources:
link_compiler = cxx_compiler
extra_postargs = _get(target, 'extra_link_args') or []
## May be dependent on other libs we're builing
shlib_libraries = []
for libinfo in _get(target, 'libraries', []):
if is_string(libinfo):
shlib_libraries.append(convert_ulist([libinfo])[0])
else:
shlib_libraries.append(libinfo[0])
if mode == EXECUTABLE:
if not hasattr(link_compiler, 'linker_exe') or \
link_compiler.linker_exe is None:
link_compiler.linker_exe = [link_compiler.linker_so[0]]
target_desc = link_compiler.EXECUTABLE
elif mode == SHARED_LIBRARY:
target_desc = link_compiler.SHARED_LIBRARY
linker_args = dict(
target_desc = target_desc,
objects = objects,
output_filename = target_name,
output_dir = build_directory,
libraries = shlib_libraries,
library_dirs = library_dirs,
debug = builder.debug,
extra_preargs = extra_preargs,
extra_postargs = extra_postargs,
)
if not _get(target, 'link_with_fcompiler', False):
linker_args['runtime_library_dirs'] = runtime_library_dirs
link_compiler.link(**linker_args) # pylint: disable=W0142
