mirror of
https://github.com/cookiengineer/audacity
synced 2025-10-18 08:31:13 +02:00
Update local LV2 libraries to latest versions
lilv-0.24.6 lv2-1.16.0 serd-0.30.2 sord-0.16.4 sratom-0.6.4 suil-0.10.6
This commit is contained in:
Leland Lucius
@@ -1,49 +1,413 @@
|
||||
#! /usr/bin/env python
|
||||
# encoding: utf-8
|
||||
# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
|
||||
# DC 2008
|
||||
# Thomas Nagy 2016-2018 (ita)
|
||||
|
||||
import re
|
||||
from waflib import Utils
|
||||
from waflib.Tools import fc,fc_config,fc_scan,ar
|
||||
import os, re, traceback
|
||||
from waflib import Utils, Logs, Errors
|
||||
from waflib.Tools import fc, fc_config, fc_scan, ar, ccroot
|
||||
from waflib.Configure import conf
|
||||
from waflib.TaskGen import after_method, feature
|
||||
|
||||
@conf
|
||||
def find_ifort(conf):
|
||||
fc=conf.find_program('ifort',var='FC')
|
||||
fc=conf.cmd_to_list(fc)
|
||||
fc = conf.find_program('ifort', var='FC')
|
||||
conf.get_ifort_version(fc)
|
||||
conf.env.FC_NAME='IFORT'
|
||||
conf.env.FC_NAME = 'IFORT'
|
||||
|
||||
@conf
|
||||
def ifort_modifier_cygwin(conf):
|
||||
raise NotImplementedError("Ifort on cygwin not yet implemented")
|
||||
@conf
|
||||
def ifort_modifier_win32(conf):
|
||||
fc_config.fortran_modifier_win32(conf)
|
||||
def ifort_modifier_win32(self):
|
||||
v = self.env
|
||||
v.IFORT_WIN32 = True
|
||||
v.FCSTLIB_MARKER = ''
|
||||
v.FCSHLIB_MARKER = ''
|
||||
|
||||
v.FCLIB_ST = v.FCSTLIB_ST = '%s.lib'
|
||||
v.FCLIBPATH_ST = v.STLIBPATH_ST = '/LIBPATH:%s'
|
||||
v.FCINCPATH_ST = '/I%s'
|
||||
v.FCDEFINES_ST = '/D%s'
|
||||
|
||||
v.fcprogram_PATTERN = v.fcprogram_test_PATTERN = '%s.exe'
|
||||
v.fcshlib_PATTERN = '%s.dll'
|
||||
v.fcstlib_PATTERN = v.implib_PATTERN = '%s.lib'
|
||||
|
||||
v.FCLNK_TGT_F = '/out:'
|
||||
v.FC_TGT_F = ['/c', '/o', '']
|
||||
v.FCFLAGS_fcshlib = ''
|
||||
v.LINKFLAGS_fcshlib = '/DLL'
|
||||
v.AR_TGT_F = '/out:'
|
||||
v.IMPLIB_ST = '/IMPLIB:%s'
|
||||
|
||||
v.append_value('LINKFLAGS', '/subsystem:console')
|
||||
if v.IFORT_MANIFEST:
|
||||
v.append_value('LINKFLAGS', ['/MANIFEST'])
|
||||
|
||||
@conf
|
||||
def ifort_modifier_darwin(conf):
|
||||
fc_config.fortran_modifier_darwin(conf)
|
||||
|
||||
@conf
|
||||
def ifort_modifier_platform(conf):
|
||||
dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform()
|
||||
ifort_modifier_func=getattr(conf,'ifort_modifier_'+dest_os,None)
|
||||
dest_os = conf.env.DEST_OS or Utils.unversioned_sys_platform()
|
||||
ifort_modifier_func = getattr(conf, 'ifort_modifier_' + dest_os, None)
|
||||
if ifort_modifier_func:
|
||||
ifort_modifier_func()
|
||||
|
||||
@conf
|
||||
def get_ifort_version(conf,fc):
|
||||
version_re=re.compile(r"ifort\s*\(IFORT\)\s*(?P<major>\d*)\.(?P<minor>\d*)",re.I).search
|
||||
cmd=fc+['--version']
|
||||
out,err=fc_config.getoutput(conf,cmd,stdin=False)
|
||||
if out:
|
||||
match=version_re(out)
|
||||
def get_ifort_version(conf, fc):
|
||||
"""
|
||||
Detects the compiler version and sets ``conf.env.FC_VERSION``
|
||||
"""
|
||||
version_re = re.compile(r"\bIntel\b.*\bVersion\s*(?P<major>\d*)\.(?P<minor>\d*)",re.I).search
|
||||
if Utils.is_win32:
|
||||
cmd = fc
|
||||
else:
|
||||
match=version_re(err)
|
||||
cmd = fc + ['-logo']
|
||||
|
||||
out, err = fc_config.getoutput(conf, cmd, stdin=False)
|
||||
match = version_re(out) or version_re(err)
|
||||
if not match:
|
||||
conf.fatal('cannot determine ifort version.')
|
||||
k=match.groupdict()
|
||||
conf.env['FC_VERSION']=(k['major'],k['minor'])
|
||||
k = match.groupdict()
|
||||
conf.env.FC_VERSION = (k['major'], k['minor'])
|
||||
|
||||
def configure(conf):
|
||||
conf.find_ifort()
|
||||
conf.find_program('xiar',var='AR')
|
||||
conf.env.ARFLAGS='rcs'
|
||||
conf.fc_flags()
|
||||
conf.fc_add_flags()
|
||||
conf.ifort_modifier_platform()
|
||||
"""
|
||||
Detects the Intel Fortran compilers
|
||||
"""
|
||||
if Utils.is_win32:
|
||||
compiler, version, path, includes, libdirs, arch = conf.detect_ifort()
|
||||
v = conf.env
|
||||
v.DEST_CPU = arch
|
||||
v.PATH = path
|
||||
v.INCLUDES = includes
|
||||
v.LIBPATH = libdirs
|
||||
v.MSVC_COMPILER = compiler
|
||||
try:
|
||||
v.MSVC_VERSION = float(version)
|
||||
except ValueError:
|
||||
v.MSVC_VERSION = float(version[:-3])
|
||||
|
||||
conf.find_ifort_win32()
|
||||
conf.ifort_modifier_win32()
|
||||
else:
|
||||
conf.find_ifort()
|
||||
conf.find_program('xiar', var='AR')
|
||||
conf.find_ar()
|
||||
conf.fc_flags()
|
||||
conf.fc_add_flags()
|
||||
conf.ifort_modifier_platform()
|
||||
|
||||
|
||||
all_ifort_platforms = [ ('intel64', 'amd64'), ('em64t', 'amd64'), ('ia32', 'x86'), ('Itanium', 'ia64')]
|
||||
"""List of icl platforms"""
|
||||
|
||||
@conf
|
||||
def gather_ifort_versions(conf, versions):
|
||||
"""
|
||||
List compiler versions by looking up registry keys
|
||||
"""
|
||||
version_pattern = re.compile(r'^...?.?\....?.?')
|
||||
try:
|
||||
all_versions = Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Intel\\Compilers\\Fortran')
|
||||
except OSError:
|
||||
try:
|
||||
all_versions = Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Intel\\Compilers\\Fortran')
|
||||
except OSError:
|
||||
return
|
||||
index = 0
|
||||
while 1:
|
||||
try:
|
||||
version = Utils.winreg.EnumKey(all_versions, index)
|
||||
except OSError:
|
||||
break
|
||||
index += 1
|
||||
if not version_pattern.match(version):
|
||||
continue
|
||||
targets = {}
|
||||
for target,arch in all_ifort_platforms:
|
||||
if target=='intel64':
|
||||
targetDir='EM64T_NATIVE'
|
||||
else:
|
||||
targetDir=target
|
||||
try:
|
||||
Utils.winreg.OpenKey(all_versions,version+'\\'+targetDir)
|
||||
icl_version=Utils.winreg.OpenKey(all_versions,version)
|
||||
path,type=Utils.winreg.QueryValueEx(icl_version,'ProductDir')
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
batch_file=os.path.join(path,'bin','ifortvars.bat')
|
||||
if os.path.isfile(batch_file):
|
||||
targets[target] = target_compiler(conf, 'intel', arch, version, target, batch_file)
|
||||
|
||||
for target,arch in all_ifort_platforms:
|
||||
try:
|
||||
icl_version = Utils.winreg.OpenKey(all_versions, version+'\\'+target)
|
||||
path,type = Utils.winreg.QueryValueEx(icl_version,'ProductDir')
|
||||
except OSError:
|
||||
continue
|
||||
else:
|
||||
batch_file=os.path.join(path,'bin','ifortvars.bat')
|
||||
if os.path.isfile(batch_file):
|
||||
targets[target] = target_compiler(conf, 'intel', arch, version, target, batch_file)
|
||||
major = version[0:2]
|
||||
versions['intel ' + major] = targets
|
||||
|
||||
@conf
|
||||
def setup_ifort(conf, versiondict):
|
||||
"""
|
||||
Checks installed compilers and targets and returns the first combination from the user's
|
||||
options, env, or the global supported lists that checks.
|
||||
|
||||
:param versiondict: dict(platform -> dict(architecture -> configuration))
|
||||
:type versiondict: dict(string -> dict(string -> target_compiler)
|
||||
:return: the compiler, revision, path, include dirs, library paths and target architecture
|
||||
:rtype: tuple of strings
|
||||
"""
|
||||
platforms = Utils.to_list(conf.env.MSVC_TARGETS) or [i for i,j in all_ifort_platforms]
|
||||
desired_versions = conf.env.MSVC_VERSIONS or list(reversed(list(versiondict.keys())))
|
||||
for version in desired_versions:
|
||||
try:
|
||||
targets = versiondict[version]
|
||||
except KeyError:
|
||||
continue
|
||||
for arch in platforms:
|
||||
try:
|
||||
cfg = targets[arch]
|
||||
except KeyError:
|
||||
continue
|
||||
cfg.evaluate()
|
||||
if cfg.is_valid:
|
||||
compiler,revision = version.rsplit(' ', 1)
|
||||
return compiler,revision,cfg.bindirs,cfg.incdirs,cfg.libdirs,cfg.cpu
|
||||
conf.fatal('ifort: Impossible to find a valid architecture for building %r - %r' % (desired_versions, list(versiondict.keys())))
|
||||
|
||||
@conf
|
||||
def get_ifort_version_win32(conf, compiler, version, target, vcvars):
|
||||
# FIXME hack
|
||||
try:
|
||||
conf.msvc_cnt += 1
|
||||
except AttributeError:
|
||||
conf.msvc_cnt = 1
|
||||
batfile = conf.bldnode.make_node('waf-print-msvc-%d.bat' % conf.msvc_cnt)
|
||||
batfile.write("""@echo off
|
||||
set INCLUDE=
|
||||
set LIB=
|
||||
call "%s" %s
|
||||
echo PATH=%%PATH%%
|
||||
echo INCLUDE=%%INCLUDE%%
|
||||
echo LIB=%%LIB%%;%%LIBPATH%%
|
||||
""" % (vcvars,target))
|
||||
sout = conf.cmd_and_log(['cmd.exe', '/E:on', '/V:on', '/C', batfile.abspath()])
|
||||
batfile.delete()
|
||||
lines = sout.splitlines()
|
||||
|
||||
if not lines[0]:
|
||||
lines.pop(0)
|
||||
|
||||
MSVC_PATH = MSVC_INCDIR = MSVC_LIBDIR = None
|
||||
for line in lines:
|
||||
if line.startswith('PATH='):
|
||||
path = line[5:]
|
||||
MSVC_PATH = path.split(';')
|
||||
elif line.startswith('INCLUDE='):
|
||||
MSVC_INCDIR = [i for i in line[8:].split(';') if i]
|
||||
elif line.startswith('LIB='):
|
||||
MSVC_LIBDIR = [i for i in line[4:].split(';') if i]
|
||||
if None in (MSVC_PATH, MSVC_INCDIR, MSVC_LIBDIR):
|
||||
conf.fatal('ifort: Could not find a valid architecture for building (get_ifort_version_win32)')
|
||||
|
||||
# Check if the compiler is usable at all.
|
||||
# The detection may return 64-bit versions even on 32-bit systems, and these would fail to run.
|
||||
env = dict(os.environ)
|
||||
env.update(PATH = path)
|
||||
compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler)
|
||||
fc = conf.find_program(compiler_name, path_list=MSVC_PATH)
|
||||
|
||||
# delete CL if exists. because it could contain parameters which can change cl's behaviour rather catastrophically.
|
||||
if 'CL' in env:
|
||||
del(env['CL'])
|
||||
|
||||
try:
|
||||
conf.cmd_and_log(fc + ['/help'], env=env)
|
||||
except UnicodeError:
|
||||
st = traceback.format_exc()
|
||||
if conf.logger:
|
||||
conf.logger.error(st)
|
||||
conf.fatal('ifort: Unicode error - check the code page?')
|
||||
except Exception as e:
|
||||
Logs.debug('ifort: get_ifort_version: %r %r %r -> failure %s', compiler, version, target, str(e))
|
||||
conf.fatal('ifort: cannot run the compiler in get_ifort_version (run with -v to display errors)')
|
||||
else:
|
||||
Logs.debug('ifort: get_ifort_version: %r %r %r -> OK', compiler, version, target)
|
||||
finally:
|
||||
conf.env[compiler_name] = ''
|
||||
|
||||
return (MSVC_PATH, MSVC_INCDIR, MSVC_LIBDIR)
|
||||
|
||||
class target_compiler(object):
|
||||
"""
|
||||
Wraps a compiler configuration; call evaluate() to determine
|
||||
whether the configuration is usable.
|
||||
"""
|
||||
def __init__(self, ctx, compiler, cpu, version, bat_target, bat, callback=None):
|
||||
"""
|
||||
:param ctx: configuration context to use to eventually get the version environment
|
||||
:param compiler: compiler name
|
||||
:param cpu: target cpu
|
||||
:param version: compiler version number
|
||||
:param bat_target: ?
|
||||
:param bat: path to the batch file to run
|
||||
:param callback: optional function to take the realized environment variables tup and map it (e.g. to combine other constant paths)
|
||||
"""
|
||||
self.conf = ctx
|
||||
self.name = None
|
||||
self.is_valid = False
|
||||
self.is_done = False
|
||||
|
||||
self.compiler = compiler
|
||||
self.cpu = cpu
|
||||
self.version = version
|
||||
self.bat_target = bat_target
|
||||
self.bat = bat
|
||||
self.callback = callback
|
||||
|
||||
def evaluate(self):
|
||||
if self.is_done:
|
||||
return
|
||||
self.is_done = True
|
||||
try:
|
||||
vs = self.conf.get_ifort_version_win32(self.compiler, self.version, self.bat_target, self.bat)
|
||||
except Errors.ConfigurationError:
|
||||
self.is_valid = False
|
||||
return
|
||||
if self.callback:
|
||||
vs = self.callback(self, vs)
|
||||
self.is_valid = True
|
||||
(self.bindirs, self.incdirs, self.libdirs) = vs
|
||||
|
||||
def __str__(self):
|
||||
return str((self.bindirs, self.incdirs, self.libdirs))
|
||||
|
||||
def __repr__(self):
|
||||
return repr((self.bindirs, self.incdirs, self.libdirs))
|
||||
|
||||
@conf
|
||||
def detect_ifort(self):
|
||||
return self.setup_ifort(self.get_ifort_versions(False))
|
||||
|
||||
@conf
|
||||
def get_ifort_versions(self, eval_and_save=True):
|
||||
"""
|
||||
:return: platforms to compiler configurations
|
||||
:rtype: dict
|
||||
"""
|
||||
dct = {}
|
||||
self.gather_ifort_versions(dct)
|
||||
return dct
|
||||
|
||||
def _get_prog_names(self, compiler):
|
||||
if compiler=='intel':
|
||||
compiler_name = 'ifort'
|
||||
linker_name = 'XILINK'
|
||||
lib_name = 'XILIB'
|
||||
else:
|
||||
# assumes CL.exe
|
||||
compiler_name = 'CL'
|
||||
linker_name = 'LINK'
|
||||
lib_name = 'LIB'
|
||||
return compiler_name, linker_name, lib_name
|
||||
|
||||
@conf
|
||||
def find_ifort_win32(conf):
|
||||
# the autodetection is supposed to be performed before entering in this method
|
||||
v = conf.env
|
||||
path = v.PATH
|
||||
compiler = v.MSVC_COMPILER
|
||||
version = v.MSVC_VERSION
|
||||
|
||||
compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler)
|
||||
v.IFORT_MANIFEST = (compiler == 'intel' and version >= 11)
|
||||
|
||||
# compiler
|
||||
fc = conf.find_program(compiler_name, var='FC', path_list=path)
|
||||
|
||||
# before setting anything, check if the compiler is really intel fortran
|
||||
env = dict(conf.environ)
|
||||
if path:
|
||||
env.update(PATH = ';'.join(path))
|
||||
if not conf.cmd_and_log(fc + ['/nologo', '/help'], env=env):
|
||||
conf.fatal('not intel fortran compiler could not be identified')
|
||||
|
||||
v.FC_NAME = 'IFORT'
|
||||
|
||||
if not v.LINK_FC:
|
||||
conf.find_program(linker_name, var='LINK_FC', path_list=path, mandatory=True)
|
||||
|
||||
if not v.AR:
|
||||
conf.find_program(lib_name, path_list=path, var='AR', mandatory=True)
|
||||
v.ARFLAGS = ['/nologo']
|
||||
|
||||
# manifest tool. Not required for VS 2003 and below. Must have for VS 2005 and later
|
||||
if v.IFORT_MANIFEST:
|
||||
conf.find_program('MT', path_list=path, var='MT')
|
||||
v.MTFLAGS = ['/nologo']
|
||||
|
||||
try:
|
||||
conf.load('winres')
|
||||
except Errors.WafError:
|
||||
Logs.warn('Resource compiler not found. Compiling resource file is disabled')
|
||||
|
||||
#######################################################################################################
|
||||
##### conf above, build below
|
||||
|
||||
@after_method('apply_link')
|
||||
@feature('fc')
|
||||
def apply_flags_ifort(self):
|
||||
"""
|
||||
Adds additional flags implied by msvc, such as subsystems and pdb files::
|
||||
|
||||
def build(bld):
|
||||
bld.stlib(source='main.c', target='bar', subsystem='gruik')
|
||||
"""
|
||||
if not self.env.IFORT_WIN32 or not getattr(self, 'link_task', None):
|
||||
return
|
||||
|
||||
is_static = isinstance(self.link_task, ccroot.stlink_task)
|
||||
|
||||
subsystem = getattr(self, 'subsystem', '')
|
||||
if subsystem:
|
||||
subsystem = '/subsystem:%s' % subsystem
|
||||
flags = is_static and 'ARFLAGS' or 'LINKFLAGS'
|
||||
self.env.append_value(flags, subsystem)
|
||||
|
||||
if not is_static:
|
||||
for f in self.env.LINKFLAGS:
|
||||
d = f.lower()
|
||||
if d[1:] == 'debug':
|
||||
pdbnode = self.link_task.outputs[0].change_ext('.pdb')
|
||||
self.link_task.outputs.append(pdbnode)
|
||||
|
||||
if getattr(self, 'install_task', None):
|
||||
self.pdb_install_task = self.add_install_files(install_to=self.install_task.install_to, install_from=pdbnode)
|
||||
|
||||
break
|
||||
|
||||
@feature('fcprogram', 'fcshlib', 'fcprogram_test')
|
||||
@after_method('apply_link')
|
||||
def apply_manifest_ifort(self):
|
||||
"""
|
||||
Enables manifest embedding in Fortran DLLs when using ifort on Windows
|
||||
See: http://msdn2.microsoft.com/en-us/library/ms235542(VS.80).aspx
|
||||
"""
|
||||
if self.env.IFORT_WIN32 and getattr(self, 'link_task', None):
|
||||
# it seems ifort.exe cannot be called for linking
|
||||
self.link_task.env.FC = self.env.LINK_FC
|
||||
|
||||
if self.env.IFORT_WIN32 and self.env.IFORT_MANIFEST and getattr(self, 'link_task', None):
|
||||
out_node = self.link_task.outputs[0]
|
||||
man_node = out_node.parent.find_or_declare(out_node.name + '.manifest')
|
||||
self.link_task.outputs.append(man_node)
|
||||
self.env.DO_MANIFEST = True
|
||||
|
||||
|
||||
Reference in New Issue
Block a user