def read_assembly(self, assembly, install_path = None):
"""
Read a foreign .net assembly that was validated via check_assembl
"""
env = self.env
uselib = Utils.quote_define_name(assembly)
if not uselib in getattr(env, 'ext_csshlib', []):
self.fatal('Assembly %s not registered as a C sharp assembly' % assembly)
name = getattr(env, '%s_NAME' % uselib, None)
path = getattr(env, '%s_LIBPATH' % uselib, None)
tg = self(name=name,
features='fake_lib',
lib_paths=[path],
lib_type='csshlib')
if install_path:
d = self.root.find_node(path)
if not d:
self.fatal('Can\'t find assembly path')
f = d.find_node(name)
self.install_files(install_path, f)
return tg
def check_extlib(self, *k, **kw):
env = self.env
if not 'package' in kw:
kw['package'] = k[0]
if not 'msg' in kw:
kw['msg'] = 'Checking for %s' % kw['package']
paths = ['.']
if "path_list" in kw:
for p in Utils.to_list(kw['path_list']):
if p:
paths.append(p)
if not 'lib_type' in kw:
kw['lib_type'] = 'shlib'
names = [x % kw['package'] for x in ccroot.lib_patterns[kw['lib_type']]]
ret = self.find_file(names, path_list=paths)
if ret:
uselib = Utils.quote_define_name(kw.get('uselib_store', kw['package']))
env.append_value('ext_%s' % kw['lib_type'], uselib)
setattr(env, '%s_NAME' % uselib, os.path.basename(ret))
setattr(env, '%s_LIBPATH' % uselib, os.path.dirname(ret))
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
self.msg(kw['msg'], ret, "GREEN")
def write_config_header(self, configfile='', guard='', top=False, env=None, remove=True):
"""
save the defines into a file
with configfile=foo/bar.h and a script in folder xyz
top -> build/foo/bar.h
!top -> build/xyz/foo/bar.h
by default, reset env.DEFINES to []
"""
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = []
lst.append('/* Configuration header created by Waf - do not edit */\n')
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(self.get_config_header())
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
env = env or self.env
# config files are not removed on "waf clean"
env.append_unique(Build.CFG_FILES, [node.path_from(self.bldnode)])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def validate_cfg(self,kw):
if not'path'in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config',var='PKGCONFIG')
kw['path']=self.env.PKGCONFIG
s=('atleast_pkgconfig_version'in kw)+('modversion'in kw)+('package'in kw)
if s!=1:
raise ValueError('exactly one of atleast_pkgconfig_version, modversion and package must be set')
if not'msg'in kw:
if'atleast_pkgconfig_version'in kw:
kw['msg']='Checking for pkg-config version >= %r'%kw['atleast_pkgconfig_version']
elif'modversion'in kw:
kw['msg']='Checking for %r version'%kw['modversion']
else:
kw['msg']='Checking for %r'%(kw['package'])
if not'okmsg'in kw and not'modversion'in kw:
kw['okmsg']='yes'
if not'errmsg'in kw:
kw['errmsg']='not found'
if'atleast_pkgconfig_version'in kw:
pass
elif'modversion'in kw:
if not'uselib_store'in kw:
kw['uselib_store']=kw['modversion']
if not'define_name'in kw:
kw['define_name']='%s_VERSION'%Utils.quote_define_name(kw['uselib_store'])
else:
if not'uselib_store'in kw:
kw['uselib_store']=Utils.to_list(kw['package'])[0].upper()
if not'define_name'in kw:
kw['define_name']=self.have_define(kw['uselib_store'])
def write_config_header(self, configfile='', guard='', top=False, env=None, defines=True, headers=False, remove=True):
"""
save the defines into a file
with configfile=foo/bar.h and a script in folder xyz
top -> build/foo/bar.h
!top -> build/xyz/foo/bar.h
defines: add the defines or not (yes by default)
headers: add #include in the file (if headers are defined by env.INCKEYS)
remove: remove the defines added to the configuration header (yes by default)
"""
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
env = env or self.env
# config files are not removed on "waf clean"
env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def exec_cfg(self, kw):
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
cmd = [kw['path'], '--atleast-pkgconfig-version=%s' % kw['atleast_pkgconfig_version']]
self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# checking for the version of a module
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log([kw['path'], '--%s=%s' % (x, kw[y]), kw['package']])
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
break
# retrieving the version of a module
if 'modversion' in kw:
version = self.cmd_and_log([kw['path'], '--modversion', kw['modversion']]).strip()
self.define('%s_VERSION' % Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])), version)
return version
lst = [kw['path']]
defi = kw.get('define_variable', None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append('--define-variable=%s=%s' % (key, val))
if kw['package']:
lst.extend(Utils.to_list(kw['package']))
# retrieving variables of a module
if 'variables' in kw:
env = kw.get('env', self.env)
uselib = kw.get('uselib_store', kw['package'].upper())
vars = Utils.to_list(kw['variables'])
for v in vars:
val = self.cmd_and_log(lst + ['--variable=' + v]).strip()
var = '%s_%s' % (uselib, v)
env[var] = val
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
if 'args' in kw:
lst += Utils.to_list(kw['args'])
# so we assume the command-line will output flags to be parsed afterwards
ret = self.cmd_and_log(lst)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
self.parse_flags(ret, kw.get('uselib_store', kw['package'].upper()), kw.get('env', self.env))
return ret
def write_config_header(self,
configfile='',
guard='',
top=False,
env=None,
defines=True,
headers=False,
remove=True,
define_prefix=''):
if env:
Logs.warn('Cannot pass env to write_config_header')
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or 'W_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(
self.get_config_header(defines, headers, define_prefix=define_prefix))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
self.env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def have_define(self, key):
"""
:param key: define name
:type key: string
:return: the input key prefixed by *HAVE_* and substitute any invalid characters.
:rtype: string
"""
return self.__dict__.get('HAVE_PAT', 'HAVE_%s') % Utils.quote_define_name(key)
def have_define(self, key):
"""
:param key: define name
:type key: string
:return: the input key prefixed by *HAVE_* and substitute any invalid characters.
:rtype: string
"""
return (self.env.HAVE_PAT or 'HAVE_%s') % Utils.quote_define_name(key)
def have_define(self, key):
"""
:param key: define name
:type key: string
:return: the input key prefixed by *HAVE_* and substitute any invalid characters.
:rtype: string
"""
return (self.env.HAVE_PAT or "HAVE_%s") % Utils.quote_define_name(key)
def write_config_header(
self,
configfile="",
guard="",
top=False,
defines=True,
headers=False,
remove=True,
define_prefix="",
):
"""
Writes a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
This function only adds include guards (if necessary), consult
:py:func:`waflib.Tools.c_config.get_config_header` for details on the body.
:param configfile: path to the file to create (relative or absolute)
:type configfile: string
:param guard: include guard name to add, by default it is computed from the file name
:type guard: string
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default, works like in autoconf)
:type remove: bool
:type define_prefix: string
:param define_prefix: prefix all the defines in the file with a particular prefix
"""
if not configfile:
configfile = WAF_CONFIG_H
waf_guard = guard or "W_%s_WAF" % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ["/* WARNING! All changes made to this file will be lost! */\n"]
lst.append(f"#ifndef {waf_guard}\n#define {waf_guard}\n")
lst.append(
self.get_config_header(defines, headers, define_prefix=define_prefix))
lst.append("\n#endif /* %s */\n" % waf_guard)
node.write("\n".join(lst))
# config files must not be removed on "waf clean"
self.env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def exec_cfg(self,kw):
path=Utils.to_list(kw['path'])
env=self.env.env or None
def define_it():
pkgname=kw.get('uselib_store',kw['package'].upper())
if kw.get('global_define'):
self.define(self.have_define(kw['package']),1,False)
else:
self.env.append_unique('DEFINES_%s'%pkgname,"%s=1"%self.have_define(pkgname))
self.env[self.have_define(pkgname)]=1
if'atleast_pkgconfig_version'in kw:
cmd=path+['--atleast-pkgconfig-version=%s'%kw['atleast_pkgconfig_version']]
self.cmd_and_log(cmd,env=env)
if not'okmsg'in kw:
kw['okmsg']='yes'
return
for x in cfg_ver:
y=x.replace('-','_')
if y in kw:
self.cmd_and_log(path+['--%s=%s'%(x,kw[y]),kw['package']],env=env)
if not'okmsg'in kw:
kw['okmsg']='yes'
define_it()
break
if'modversion'in kw:
version=self.cmd_and_log(path+['--modversion',kw['modversion']],env=env).strip()
self.define('%s_VERSION'%Utils.quote_define_name(kw.get('uselib_store',kw['modversion'])),version)
return version
lst=[]+path
defi=kw.get('define_variable',None)
if not defi:
defi=self.env.PKG_CONFIG_DEFINES or{}
for key,val in defi.items():
lst.append('--define-variable=%s=%s'%(key,val))
static=kw.get('force_static',False)
if'args'in kw:
args=Utils.to_list(kw['args'])
if'--static'in args or'--static-libs'in args:
static=True
lst+=args
lst.extend(Utils.to_list(kw['package']))
if'variables'in kw:
v_env=kw.get('env',self.env)
uselib=kw.get('uselib_store',kw['package'].upper())
vars=Utils.to_list(kw['variables'])
for v in vars:
val=self.cmd_and_log(lst+['--variable='+v],env=env).strip()
var='%s_%s'%(uselib,v)
v_env[var]=val
if not'okmsg'in kw:
kw['okmsg']='yes'
return
ret=self.cmd_and_log(lst,env=env)
if not'okmsg'in kw:
kw['okmsg']='yes'
define_it()
self.parse_flags(ret,kw.get('uselib_store',kw['package'].upper()),kw.get('env',self.env),force_static=static,posix=kw.get('posix',None))
return ret
def write_config_header(self,
configfile='',
guard='',
top=False,
env=None,
defines=True,
headers=False,
remove=True,
define_prefix=''):
"""
Write a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
:param configfile: relative path to the file to create
:type configfile: string
:param guard: include guard name to add, by default it is computed from the file name
:type guard: string
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default, works like in autoconf)
:type remove: bool
:type define_prefix: string
:param define_prefix: prefix all the defines in the file with a particular prefix
"""
# TODO waf 1.8: the parameter env is not used
if env:
Logs.warn('Cannot pass env to write_config_header')
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or 'W_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(
self.get_config_header(defines, headers, define_prefix=define_prefix))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
# config files are not removed on "waf clean"
self.env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not "path" in kw:
if not self.env.PKGCONFIG:
self.find_program("pkg-config", var="PKGCONFIG")
kw["path"] = self.env.PKGCONFIG
# verify that exactly one action is requested
s = ("atleast_pkgconfig_version" in kw) + ("modversion" in kw) + ("package" in kw)
if s != 1:
raise ValueError(
"exactly one of atleast_pkgconfig_version, modversion and package must be set"
)
if not "msg" in kw:
if "atleast_pkgconfig_version" in kw:
kw["msg"] = (
"Checking for pkg-config version >= %r"
% kw["atleast_pkgconfig_version"]
)
elif "modversion" in kw:
kw["msg"] = "Checking for %r version" % kw["modversion"]
else:
kw["msg"] = "Checking for %r" % (kw["package"])
# let the modversion check set the okmsg to the detected version
if not "okmsg" in kw and not "modversion" in kw:
kw["okmsg"] = "yes"
if not "errmsg" in kw:
kw["errmsg"] = "not found"
# pkg-config version
if "atleast_pkgconfig_version" in kw:
pass
elif "modversion" in kw:
if not "uselib_store" in kw:
kw["uselib_store"] = kw["modversion"]
if not "define_name" in kw:
kw["define_name"] = "%s_VERSION" % Utils.quote_define_name(
kw["uselib_store"]
)
else:
if not "uselib_store" in kw:
kw["uselib_store"] = Utils.to_list(kw["package"])[0].upper()
if not "define_name" in kw:
kw["define_name"] = self.have_define(kw["uselib_store"])
def exec_cfg(self, kw):
if 'atleast_pkgconfig_version' in kw:
cmd = [
kw['path'],
'--atleast-pkgconfig-version=%s' % kw['atleast_pkgconfig_version']
]
self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log(
[kw['path'], '--%s=%s' % (x, kw[y]), kw['package']])
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(
self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
break
if 'modversion' in kw:
version = self.cmd_and_log(
[kw['path'], '--modversion', kw['modversion']]).strip()
self.define(
'%s_VERSION' %
Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])),
version)
return version
lst = [kw['path']]
defi = kw.get('define_variable', None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append('--define-variable=%s=%s' % (key, val))
if kw['package']:
lst.extend(Utils.to_list(kw['package']))
if 'variables' in kw:
env = kw.get('env', self.env)
uselib = kw.get('uselib_store', kw['package'].upper())
vars = Utils.to_list(kw['variables'])
for v in vars:
val = self.cmd_and_log(lst + ['--variable=' + v]).strip()
var = '%s_%s' % (uselib, v)
env[var] = val
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
if 'args' in kw:
lst += Utils.to_list(kw['args'])
ret = self.cmd_and_log(lst)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
self.parse_flags(ret, kw.get('uselib_store', kw['package'].upper()),
kw.get('env', self.env))
return ret
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not 'path' in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config', var='PKGCONFIG')
kw['path'] = self.env.PKGCONFIG
# verify that exactly one action is requested
s = ('atleast_pkgconfig_version' in kw) + ('modversion' in kw) + ('package'
in kw)
if s != 1:
raise ValueError(
'exactly one of atleast_pkgconfig_version, modversion and package must be set'
)
if not 'msg' in kw:
if 'atleast_pkgconfig_version' in kw:
kw['msg'] = 'Checking for pkg-config version >= %r' % kw[
'atleast_pkgconfig_version']
elif 'modversion' in kw:
kw['msg'] = 'Checking for %r version' % kw['modversion']
else:
kw['msg'] = 'Checking for %r' % (kw['package'])
# let the modversion check set the okmsg to the detected version
if not 'okmsg' in kw and not 'modversion' in kw:
kw['okmsg'] = 'yes'
if not 'errmsg' in kw:
kw['errmsg'] = 'not found'
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
pass
elif 'modversion' in kw:
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['modversion']
if not 'define_name' in kw:
kw['define_name'] = '%s_VERSION' % Utils.quote_define_name(
kw['uselib_store'])
else:
if not 'uselib_store' in kw:
kw['uselib_store'] = Utils.to_list(kw['package'])[0].upper()
if not 'define_name' in kw:
kw['define_name'] = self.have_define(kw['uselib_store'])
def have_define(self, key): """ Returns a variable suitable for command-line or header use by removing invalid characters and prefixing it with ``HAVE_`` :param key: define name :type key: string :return: the input key prefixed by *HAVE_* and substitute any invalid characters. :rtype: string """ return (self.env.HAVE_PAT or 'HAVE_%s') % Utils.quote_define_name(key)
def have_define(self, key):
"""
Returns a variable suitable for command-line or header use by removing invalid characters
and prefixing it with ``HAVE_``
:param key: define name
:type key: string
:return: the input key prefixed by *HAVE_* and substitute any invalid characters.
:rtype: string
"""
return (self.env.HAVE_PAT or 'HAVE_%s') % Utils.quote_define_name(key)
def pkg_cs(self):
names = self.to_list(getattr(self, 'use', []))
use = names[:]
for x in names:
pkg = 'PKG_%s' % Utils.quote_define_name(x)
if pkg in getattr(self.env, 'packages', []):
self.env.append_value('CSFLAGS', '/pkg:%s' % x)
use.remove(x)
self.use = ' '.join(use)
def check_assembly(self, *k, **kw):
path_list = []
if "path_list" in kw:
for path in kw['path_list']:
if path:
path_list.append(path)
kw['path_list'] = path_list
ret = self.find_file(*k, **kw)
self.msg("Checking for %s" % k[0], ret, "GREEN")
self.env.append_value(Utils.quote_define_name(k[0]), os.path.dirname(ret))
self.define(self.have_define(k[0]), 1, 0)
def exec_cfg(self,kw):
def define_it():
self.define(self.have_define(kw.get('uselib_store',kw['package'])),1,0)
env=kw.get('env',self.env)
run_env=env.env or os.environ
if'atleast_pkgconfig_version'in kw:
cmd=[kw['path'],'--atleast-pkgconfig-version=%s'%kw['atleast_pkgconfig_version']]
self.cmd_and_log(cmd,env=run_env)
if not'okmsg'in kw:
kw['okmsg']='yes'
return
for x in cfg_ver:
y=x.replace('-','_')
if y in kw:
self.cmd_and_log([kw['path'],'--%s=%s'%(x,kw[y]),kw['package']],env=run_env)
if not'okmsg'in kw:
kw['okmsg']='yes'
define_it()
break
if'modversion'in kw:
version=self.cmd_and_log([kw['path'],'--modversion',kw['modversion']],env=run_env).strip()
self.define('%s_VERSION'%Utils.quote_define_name(kw.get('uselib_store',kw['modversion'])),version)
return version
lst=[kw['path']]
defi=kw.get('define_variable',None)
if not defi:
defi=self.env.PKG_CONFIG_DEFINES or{}
for key,val in defi.items():
lst.append('--define-variable=%s=%s'%(key,val))
if'variables'in kw:
uselib=kw.get('uselib_store',kw['package'].upper())
vars=Utils.to_list(kw['variables'])
for v in vars:
val=self.cmd_and_log(lst+['--variable='+v],env=run_env).strip()
var='%s_%s'%(uselib,v)
env[var]=val
if not'okmsg'in kw:
kw['okmsg']='yes'
return
static=False
if'args'in kw:
args=Utils.to_list(kw['args'])
if'--static'in args or'--static-libs'in args:
static=True
lst+=args
lst.extend(Utils.to_list(kw['package']))
ret=self.cmd_and_log(lst,env=run_env)
if not'okmsg'in kw:
kw['okmsg']='yes'
define_it()
self.parse_flags(ret,kw.get('uselib_store',kw['package'].upper()),kw.get('env',self.env),force_static=static)
return ret
def filter_flags(conf, flags, required_flags, features, checkarg, compiler):
check_flags = required_flags + (['-Werror'] if compiler != 'msvc' else [])
tests = map(
lambda x: {
'features': features,
'compiler': compiler,
'msg': '... ' + x,
'define_name': Utils.quote_define_name(x),
checkarg: [x] + check_flags
}, flags)
conf.env.stash()
conf.multicheck(*tests,
msg='Checking supported flags for %s in parallel' %
compiler,
mandatory=False)
supported_flags = [
f for f in flags if conf.env[Utils.quote_define_name(f)]
]
conf.env.revert()
return supported_flags
def write_config_header(self,
configfile='',
guard='',
top=False,
env=None,
defines=True,
headers=False,
remove=True):
"""
Write a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
:param configfile: relative path to the file to create
:type configfile: string
:param env: config set to read the definitions from (default is conf.env)
:type env: :py:class:`waflib.ConfigSet.ConfigSet`
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default)
:type remove: bool
"""
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
env = env or self.env
# config files are not removed on "waf clean"
env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def check_header(self, h, **kw): if isinstance(h, str): code = '#include <%s>' % h else: code = '\n'.join(map(lambda x: '#include <%s>' % x, h)) if 'msg' not in kw: kw['msg'] = 'Checking for %r' % h if 'errmsg' not in kw: kw['errmsg'] = 'not found' if 'define_name' not in kw: kw['define_name'] = 'HAVE_%s' % Utils.quote_define_name(h) self.check_cpp(fragment = code, **kw)
def write_config_header(
self, configfile="", guard="", top=False, defines=True, headers=False, remove=True, define_prefix=""
):
"""
Writes a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
This function only adds include guards (if necessary), consult
:py:func:`waflib.Tools.c_config.get_config_header` for details on the body.
:param configfile: path to the file to create (relative or absolute)
:type configfile: string
:param guard: include guard name to add, by default it is computed from the file name
:type guard: string
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default, works like in autoconf)
:type remove: bool
:type define_prefix: string
:param define_prefix: prefix all the defines in the file with a particular prefix
"""
if not configfile:
configfile = WAF_CONFIG_H
waf_guard = guard or "W_%s_WAF" % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ["/* WARNING! All changes made to this file will be lost! */\n"]
lst.append("#ifndef %s\n#define %s\n" % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers, define_prefix=define_prefix))
lst.append("\n#endif /* %s */\n" % waf_guard)
node.write("\n".join(lst))
# config files must not be removed on "waf clean"
self.env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not 'path' in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config', var='PKGCONFIG')
kw['path'] = self.env.PKGCONFIG
# verify that exactly one action is requested
s = ('atleast_pkgconfig_version' in kw) + ('modversion' in kw) + ('package' in kw)
if s != 1:
raise ValueError('exactly one of atleast_pkgconfig_version, modversion and package must be set')
if not 'msg' in kw:
if 'atleast_pkgconfig_version' in kw:
kw['msg'] = 'Checking for pkg-config version >= %r' % kw['atleast_pkgconfig_version']
elif 'modversion' in kw:
kw['msg'] = 'Checking for %r version' % kw['modversion']
else:
kw['msg'] = 'Checking for %r' %(kw['package'])
# let the modversion check set the okmsg to the detected version
if not 'okmsg' in kw and not 'modversion' in kw:
kw['okmsg'] = 'yes'
if not 'errmsg' in kw:
kw['errmsg'] = 'not found'
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
pass
elif 'modversion' in kw:
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['modversion']
if not 'define_name' in kw:
kw['define_name'] = '%s_VERSION' % Utils.quote_define_name(kw['uselib_store'])
else:
if not 'uselib_store' in kw:
kw['uselib_store'] = Utils.to_list(kw['package'])[0].upper()
if not 'define_name' in kw:
kw['define_name'] = self.have_define(kw['uselib_store'])
def write_config_header(self, configfile='', guard='', top=False, env=None, defines=True, headers=False, remove=True, define_prefix=''):
"""
Write a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
:param configfile: relative path to the file to create
:type configfile: string
:param guard: include guard name to add, by default it is computed from the file name
:type guard: string
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default, works like in autoconf)
:type remove: bool
:type define_prefix: string
:param define_prefix: prefix all the defines in the file with a particular prefix
"""
# TODO waf 1.8: the parameter env is not used
if env:
Logs.warn('Cannot pass env to write_config_header')
if not configfile: configfile = WAF_CONFIG_H
waf_guard = guard or 'W_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers, define_prefix=define_prefix))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
# config files are not removed on "waf clean"
self.env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def write_config_header(self,configfile='',guard='',top=False,defines=True,headers=False,remove=True,define_prefix=''):
if not configfile:configfile=WAF_CONFIG_H
waf_guard=guard or'W_%s_WAF'%Utils.quote_define_name(configfile)
node=top and self.bldnode or self.path.get_bld()
node=node.make_node(configfile)
node.parent.mkdir()
lst=['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n'%(waf_guard,waf_guard))
lst.append(self.get_config_header(defines,headers,define_prefix=define_prefix))
lst.append('\n#endif /* %s */\n'%waf_guard)
node.write('\n'.join(lst))
self.env.append_unique(Build.CFG_FILES,[node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS]=[]
def exec_cfg(self, kw):
if "atleast_pkgconfig_version" in kw:
cmd = [kw["path"], "--atleast-pkgconfig-version=%s" % kw["atleast_pkgconfig_version"]]
self.cmd_and_log(cmd)
if not "okmsg" in kw:
kw["okmsg"] = "yes"
return
for x in cfg_ver:
y = x.replace("-", "_")
if y in kw:
self.cmd_and_log([kw["path"], "--%s=%s" % (x, kw[y]), kw["package"]])
if not "okmsg" in kw:
kw["okmsg"] = "yes"
self.define(self.have_define(kw.get("uselib_store", kw["package"])), 1, 0)
break
if "modversion" in kw:
version = self.cmd_and_log([kw["path"], "--modversion", kw["modversion"]]).strip()
self.define("%s_VERSION" % Utils.quote_define_name(kw.get("uselib_store", kw["modversion"])), version)
return version
lst = [kw["path"]]
defi = kw.get("define_variable", None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append("--define-variable=%s=%s" % (key, val))
if kw["package"]:
lst.extend(Utils.to_list(kw["package"]))
if "variables" in kw:
env = kw.get("env", self.env)
uselib = kw.get("uselib_store", kw["package"].upper())
vars = Utils.to_list(kw["variables"])
for v in vars:
val = self.cmd_and_log(lst + ["--variable=" + v]).strip()
var = "%s_%s" % (uselib, v)
env[var] = val
if not "okmsg" in kw:
kw["okmsg"] = "yes"
return
if "args" in kw:
lst += Utils.to_list(kw["args"])
ret = self.cmd_and_log(lst)
if not "okmsg" in kw:
kw["okmsg"] = "yes"
self.define(self.have_define(kw.get("uselib_store", kw["package"])), 1, 0)
self.parse_flags(ret, kw.get("uselib_store", kw["package"].upper()), kw.get("env", self.env))
return ret
def use_extlib(self):
names = self.to_list(getattr(self, 'use', []))
use = names[:]
for x in names:
lib_name = Utils.quote_define_name(x)
for lib_type in ccroot.lib_patterns.keys():
if lib_name in getattr(self.env, 'ext_%s' % lib_type, []):
name = getattr(self.env, '%s_NAME' % lib_name, None)
# replace uselib with real assembly name
if name:
use.remove(x)
use.append(name);
self.use = ' '.join(use)
def validate_cfg(self, kw):
if not 'path' in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config', var='PKGCONFIG')
kw['path'] = self.env.PKGCONFIG
if 'atleast_pkgconfig_version' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for pkg-config version >= %r' % kw[
'atleast_pkgconfig_version']
return
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
if not 'errmsg' in kw:
kw['errmsg'] = 'not found'
if 'modversion' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for %r version' % kw['modversion']
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['modversion']
if not 'define_name' in kw:
kw['define_name'] = '%s_VERSION' % Utils.quote_define_name(
kw['uselib_store'])
return
if not 'package' in kw:
raise ValueError('a package name is required')
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['package'].upper()
if not 'define_name' in kw:
kw['define_name'] = self.have_define(kw['uselib_store'])
if not 'msg' in kw:
kw['msg'] = 'Checking for %r' % (kw['package'] or kw['path'])
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
package = kw['package']
if Logs.verbose:
Logs.warn(
'Passing %r to conf.check_cfg() is obsolete, pass parameters directly, eg:',
y)
Logs.warn(
" conf.check_cfg(package='%s', args=['--libs', '--cflags', '%s >= 1.6'])",
package, package)
if not 'msg' in kw:
kw['msg'] = 'Checking for %r %s %s' % (package, cfg_ver[x],
kw[y])
break
def write_config_header(self, configfile='', guard='', top=False, env=None, defines=True, headers=False, remove=True):
"""
Write a configuration header containing defines and includes::
def configure(cnf):
cnf.define('A', 1)
cnf.write_config_header('config.h')
:param configfile: relative path to the file to create
:type configfile: string
:param env: config set to read the definitions from (default is conf.env)
:type env: :py:class:`waflib.ConfigSet.ConfigSet`
:param top: write the configuration header from the build directory (default is from the current path)
:type top: bool
:param defines: add the defines (yes by default)
:type defines: bool
:param headers: add #include in the file
:type headers: bool
:param remove: remove the defines after they are added (yes by default)
:type remove: bool
"""
if not configfile:
configfile = WAF_CONFIG_H
waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ['/* WARNING! All changes made to this file will be lost! */\n']
lst.append('#ifndef %s\n#define %s\n' % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers))
lst.append('\n#endif /* %s */\n' % waf_guard)
node.write('\n'.join(lst))
env = env or self.env
# config files are not removed on "waf clean"
env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def write_config_header(self, configfile="", guard="", top=False, env=None, defines=True, headers=False, remove=True):
if not configfile:
configfile = WAF_CONFIG_H
waf_guard = guard or "_%s_WAF" % Utils.quote_define_name(configfile)
node = top and self.bldnode or self.path.get_bld()
node = node.make_node(configfile)
node.parent.mkdir()
lst = ["/* WARNING! All changes made to this file will be lost! */\n"]
lst.append("#ifndef %s\n#define %s\n" % (waf_guard, waf_guard))
lst.append(self.get_config_header(defines, headers))
lst.append("\n#endif /* %s */\n" % waf_guard)
node.write("\n".join(lst))
env = env or self.env
env.append_unique(Build.CFG_FILES, [node.abspath()])
if remove:
for key in self.env[DEFKEYS]:
self.undefine(key)
self.env[DEFKEYS] = []
def exec_cfg(self, kw):
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
cmd = '%s --atleast-pkgconfig-version=%s' % (kw['path'], kw['atleast_pkgconfig_version'])
self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# checking for the version of a module
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log('%s --%s=%s %s' % (kw['path'], x, kw[y], kw['package']))
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
break
# retrieving the version of a module
if 'modversion' in kw:
version = self.cmd_and_log('%s --modversion %s' % (kw['path'], kw['modversion'])).strip()
self.define('%s_VERSION' % Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])), version)
return version
lst = [kw['path']]
for key, val in kw.get('define_variable', {}).items():
lst.append('--define-variable=%s=%s' % (key, val))
lst.append(kw.get('args', ''))
lst.append(kw['package'])
# so we assume the command-line will output flags to be parsed afterwards
cmd = ' '.join(lst)
ret = self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
parse_flags(ret, kw.get('uselib_store', kw['package'].upper()), kw.get('env', self.env))
return ret
def validate_cfg(self,kw):
if not'path'in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config',var='PKGCONFIG')
kw['path']=self.env.PKGCONFIG
if'atleast_pkgconfig_version'in kw:
if not'msg'in kw:
kw['msg']='Checking for pkg-config version >= %r'%kw['atleast_pkgconfig_version']
return
if not'okmsg'in kw:
kw['okmsg']='yes'
if not'errmsg'in kw:
kw['errmsg']='not found'
if'modversion'in kw:
if not'msg'in kw:
kw['msg']='Checking for %r version'%kw['modversion']
if not'uselib_store'in kw:
kw['uselib_store']=kw['modversion']
if not'define_name'in kw:
kw['define_name']='%s_VERSION'%Utils.quote_define_name(kw['uselib_store'])
return
if not'package'in kw:
raise ValueError('a package name is required')
if not'uselib_store'in kw:
kw['uselib_store']=kw['package'].upper()
if not'define_name'in kw:
kw['define_name']=self.have_define(kw['uselib_store'])
if not'msg'in kw:
kw['msg']='Checking for %r'%(kw['package']or kw['path'])
for x in cfg_ver:
y=x.replace('-','_')
if y in kw:
package=kw['package']
if Logs.verbose:
Logs.warn('Passing %r to conf.check_cfg() is obsolete, pass parameters directly, eg:',y)
Logs.warn(" conf.check_cfg(package='%s', args=['--libs', '--cflags', '%s >= 1.6'])",package,package)
if not'msg'in kw:
kw['msg']='Checking for %r %s %s'%(package,cfg_ver[x],kw[y])
break
def have_define(self, key):
return (self.env.HAVE_PAT or 'HAVE_%s') % Utils.quote_define_name(key)
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not 'path' in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config', var='PKGCONFIG')
kw['path'] = self.env.PKGCONFIG
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for pkg-config version >= %r' % kw[
'atleast_pkgconfig_version']
return
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
if not 'errmsg' in kw:
kw['errmsg'] = 'not found'
if 'modversion' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for %r version' % kw['modversion']
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['modversion']
if not 'define_name' in kw:
kw['define_name'] = '%s_VERSION' % Utils.quote_define_name(
kw['uselib_store'])
return
if not 'package' in kw:
raise ValueError('a package name is required')
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['package'].upper()
if not 'define_name' in kw:
kw['define_name'] = self.have_define(kw['uselib_store'])
if not 'msg' in kw:
kw['msg'] = 'Checking for %r' % (kw['package'] or kw['path'])
for x in cfg_ver:
# Gotcha: only one predicate is allowed at a time
# TODO remove in waf 2.0
y = x.replace('-', '_')
if y in kw:
package = kw['package']
if Logs.verbose:
Logs.warn(
'Passing %r to conf.check_cfg() is obsolete, pass parameters directly, eg:',
y)
Logs.warn(
" conf.check_cfg(package='%s', args=['--libs', '--cflags', '%s >= 1.6'])",
package, package)
if not 'msg' in kw:
kw['msg'] = 'Checking for %r %s %s' % (package, cfg_ver[x],
kw[y])
break
def __init__(self,
opt,
name,
help=None,
default=True,
conf_dest=None,
define=None,
style=None):
"""
Class initializing method.
Arguments:
opt OptionsContext
name name of the option, e.g. alsa
help help text that will be displayed in --help output
conf_dest conf.env variable to define to the result
define the preprocessor symbol to define with the result
style the option style to use; see below for options
"""
# The dependencies to check for. The elements are on the form
# (func, k, kw) where func is the function or function name that
# is used for the check and k and kw are the arguments and
# options to give the function.
self.deps = []
# Whether or not the option should be enabled. None indicates
# that the checks have not been performed yet.
self.enable = None
self.help = help
if help:
if default:
help_comment = ' (enabled by default if possible)'
else:
help_comment = ' (disabled by default)'
option_help = help + help_comment
no_option_help = None
else:
option_help = no_option_help = optparse.SUPPRESS_HELP
self.dest = 'auto_option_' + name
self.default = default
safe_name = Utils.quote_define_name(name)
self.conf_dest = conf_dest or safe_name
default_define = opt.get_auto_options_define()
self.define = define or default_define % safe_name
if not style:
style = opt.get_auto_options_style()
self.style = style
# plain (default):
# --foo | --no-foo
# yesno:
# --foo=yes | --foo=no
# yesno_and_hack:
# --foo[=yes] | --foo=no or --no-foo
# enable:
# --enable-foo | --disble-foo
# with:
# --with-foo | --without-foo
if style in ['plain', 'yesno', 'yesno_and_hack']:
self.no_option = '--no-' + name
self.yes_option = '--' + name
elif style == 'enable':
self.no_option = '--disable-' + name
self.yes_option = '--enable-' + name
elif style == 'with':
self.no_option = '--without-' + name
self.yes_option = '--with-' + name
else:
opt.fatal('invalid style')
if style in ['yesno', 'yesno_and_hack']:
opt.add_option(self.yes_option,
dest=self.dest,
action='store',
choices=['auto', 'no', 'yes'],
default='auto',
help=option_help,
metavar='no|yes')
else:
opt.add_option(self.yes_option,
dest=self.dest,
action='store_const',
const='yes',
default='auto',
help=option_help)
opt.add_option(self.no_option,
dest=self.dest,
action='store_const',
const='no',
default='auto',
help=no_option_help)
def have_define(self,key):
return self.__dict__.get('HAVE_PAT','HAVE_%s')%Utils.quote_define_name(key)
def have_define(self,key): return(self.env.HAVE_PAT or'HAVE_%s')%Utils.quote_define_name(key)
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not 'path' in kw:
if not self.env.PKGCONFIG:
self.find_program('pkg-config', var='PKGCONFIG')
kw['path'] = self.env.PKGCONFIG
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for pkg-config version >= %r' % kw['atleast_pkgconfig_version']
return
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
if not 'errmsg' in kw:
kw['errmsg'] = 'not found'
if 'modversion' in kw:
if not 'msg' in kw:
kw['msg'] = 'Checking for %r version' % kw['modversion']
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['modversion']
if not 'define_name' in kw:
kw['define_name'] = '%s_VERSION' % Utils.quote_define_name(kw['uselib_store'])
return
if not 'package' in kw:
raise ValueError('a package name is required')
if not 'uselib_store' in kw:
kw['uselib_store'] = kw['package'].upper()
if not 'define_name' in kw:
kw['define_name'] = self.have_define(kw['uselib_store'])
if not 'msg' in kw:
kw['msg'] = 'Checking for %r' % (kw['package'] or kw['path'])
for x in cfg_ver:
# Gotcha: only one predicate is allowed at a time
# TODO remove in waf 2.0
y = x.replace('-', '_')
if y in kw:
package = kw['package']
if Logs.verbose:
Logs.warn('Passing %r to conf.check_cfg() is obsolete, pass parameters directly, eg:', y)
Logs.warn(" conf.check_cfg(package='%s', args=['--libs', '--cflags', '%s >= 1.6'])", package, package)
if not 'msg' in kw:
kw['msg'] = 'Checking for %r %s %s' % (package, cfg_ver[x], kw[y])
break
def have_define(self, key):
"prefix the define with 'HAVE_' and make sure it has valid characters."
return self.__dict__.get('HAVE_PAT', 'HAVE_%s') % Utils.quote_define_name(key)
def exec_cfg(self, kw):
"""
Execute the program *pkg-config*:
* if atleast_pkgconfig_version is given, check that pkg-config has the version n and return
* if modversion is given, then return the module version
* else, execute the *-config* program with the *args* and *variables* given, and set the flags on the *conf.env.FLAGS_name* variable
:param atleast_pkgconfig_version: minimum pkg-config version to use (disable other tests)
:type atleast_pkgconfig_version: string
:param package: package name, for example *gtk+-2.0*
:type package: string
:param uselib_store: if the test is successful, define HAVE\_*name*. It is also used to define *conf.env.FLAGS_name* variables.
:type uselib_store: string
:param modversion: if provided, return the version of the given module and define *name*\_VERSION
:type modversion: string
:param args: arguments to give to *package* when retrieving flags
:type args: list of string
:param variables: return the values of particular variables
:type variables: list of string
:param define_variable: additional variables to define (also in conf.env.PKG_CONFIG_DEFINES)
:type define_variable: dict(string: string)
"""
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
cmd = [kw['path'], '--atleast-pkgconfig-version=%s' % kw['atleast_pkgconfig_version']]
self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# checking for the version of a module
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log([kw['path'], '--%s=%s' % (x, kw[y]), kw['package']])
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
break
# retrieving the version of a module
if 'modversion' in kw:
version = self.cmd_and_log([kw['path'], '--modversion', kw['modversion']]).strip()
self.define('%s_VERSION' % Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])), version)
return version
lst = [kw['path']]
defi = kw.get('define_variable', None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append('--define-variable=%s=%s' % (key, val))
if kw['package']:
lst.extend(Utils.to_list(kw['package']))
# retrieving variables of a module
if 'variables' in kw:
env = kw.get('env', self.env)
uselib = kw.get('uselib_store', kw['package'].upper())
vars = Utils.to_list(kw['variables'])
for v in vars:
val = self.cmd_and_log(lst + ['--variable=' + v]).strip()
var = '%s_%s' % (uselib, v)
env[var] = val
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
static = False
if 'args' in kw:
args = Utils.to_list(kw['args'])
if '--static' in args or '--static-libs' in args:
static = True
lst += args
# so we assume the command-line will output flags to be parsed afterwards
ret = self.cmd_and_log(lst)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
self.parse_flags(ret, kw.get('uselib_store', kw['package'].upper()), kw.get('env', self.env), force_static=static)
return ret
def have_define(self,key):
return self.__dict__.get('HAVE_PAT','HAVE_%s')%Utils.quote_define_name(key)
def exec_cfg(self, kw):
"""
Execute the program *pkg-config*:
* if atleast_pkgconfig_version is given, check that pkg-config has the version n and return
* if modversion is given, then return the module version
* else, execute the *-config* program with the *args* and *variables* given, and set the flags on the *conf.env.FLAGS_name* variable
:param atleast_pkgconfig_version: minimum pkg-config version to use (disable other tests)
:type atleast_pkgconfig_version: string
:param package: package name, for example *gtk+-2.0*
:type package: string
:param uselib_store: if the test is successful, define HAVE\_*name*. It is also used to define *conf.env.FLAGS_name* variables.
:type uselib_store: string
:param modversion: if provided, return the version of the given module and define *name*\_VERSION
:type modversion: string
:param args: arguments to give to *package* when retrieving flags
:type args: list of string
:param variables: return the values of particular variables
:type variables: list of string
:param define_variable: additional variables to define (also in conf.env.PKG_CONFIG_DEFINES)
:type define_variable: dict(string: string)
"""
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
cmd = [
kw['path'],
'--atleast-pkgconfig-version=%s' % kw['atleast_pkgconfig_version']
]
self.cmd_and_log(cmd)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# checking for the version of a module
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log(
[kw['path'], '--%s=%s' % (x, kw[y]), kw['package']])
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(
self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
break
# retrieving the version of a module
if 'modversion' in kw:
version = self.cmd_and_log(
[kw['path'], '--modversion', kw['modversion']]).strip()
self.define(
'%s_VERSION' %
Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])),
version)
return version
lst = [kw['path']]
defi = kw.get('define_variable', None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append('--define-variable=%s=%s' % (key, val))
if kw['package']:
lst.extend(Utils.to_list(kw['package']))
# retrieving variables of a module
if 'variables' in kw:
env = kw.get('env', self.env)
uselib = kw.get('uselib_store', kw['package'].upper())
vars = Utils.to_list(kw['variables'])
for v in vars:
val = self.cmd_and_log(lst + ['--variable=' + v]).strip()
var = '%s_%s' % (uselib, v)
env[var] = val
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
if 'args' in kw:
lst += Utils.to_list(kw['args'])
# so we assume the command-line will output flags to be parsed afterwards
ret = self.cmd_and_log(lst)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0)
self.parse_flags(ret, kw.get('uselib_store', kw['package'].upper()),
kw.get('env', self.env))
return ret
def __init__(self, opt, name, help=None, default=True,
conf_dest=None, define=None, style=None):
"""
Class initializing method.
Arguments:
opt OptionsContext
name name of the option, e.g. alsa
help help text that will be displayed in --help output
conf_dest conf.env variable to define to the result
define the preprocessor symbol to define with the result
style the option style to use; see below for options
"""
# The dependencies to check for. The elements are on the form
# (func, k, kw) where func is the function or function name that
# is used for the check and k and kw are the arguments and
# options to give the function.
self.deps = []
# Whether or not the option should be enabled. None indicates
# that the checks have not been performed yet.
self.enable = None
self.help = help
if help:
if default:
help_comment = ' (enabled by default if possible)'
else:
help_comment = ' (disabled by default)'
option_help = help + help_comment
no_option_help = None
else:
option_help = no_option_help = optparse.SUPPRESS_HELP
self.dest = 'auto_option_' + name
self.default = default
safe_name = Utils.quote_define_name(name)
self.conf_dest = conf_dest or safe_name
default_define = opt.get_auto_options_define()
self.define = define or default_define % safe_name
if not style:
style = opt.get_auto_options_style()
self.style = style
# plain (default):
# --foo | --no-foo
# yesno:
# --foo=yes | --foo=no
# yesno_and_hack:
# --foo[=yes] | --foo=no or --no-foo
# enable:
# --enable-foo | --disble-foo
# with:
# --with-foo | --without-foo
if style in ['plain', 'yesno', 'yesno_and_hack']:
self.no_option = '--no-' + name
self.yes_option = '--' + name
elif style == 'enable':
self.no_option = '--disable-' + name
self.yes_option = '--enable-' + name
elif style == 'with':
self.no_option = '--without-' + name
self.yes_option = '--with-' + name
else:
opt.fatal('invalid style')
if style in ['yesno', 'yesno_and_hack']:
opt.add_option(
self.yes_option,
dest=self.dest,
action='store',
choices=['auto', 'no', 'yes'],
default='auto',
help=option_help,
metavar='no|yes')
else:
opt.add_option(
self.yes_option,
dest=self.dest,
action='store_const',
const='yes',
default='auto',
help=option_help)
opt.add_option(
self.no_option,
dest=self.dest,
action='store_const',
const='no',
default='auto',
help=no_option_help)
def exec_cfg(self, kw):
"""
Execute the program *pkg-config*:
* if atleast_pkgconfig_version is given, check that pkg-config has the version n and return
* if modversion is given, then return the module version
* else, execute the *-config* program with the *args* and *variables* given, and set the flags on the *conf.env.FLAGS_name* variable
:param atleast_pkgconfig_version: minimum pkg-config version to use (disable other tests)
:type atleast_pkgconfig_version: string
:param package: package name, for example *gtk+-2.0*
:type package: string
:param uselib_store: if the test is successful, define HAVE\_*name*. It is also used to define *conf.env.FLAGS_name* variables.
:type uselib_store: string
:param modversion: if provided, return the version of the given module and define *name*\_VERSION
:type modversion: string
:param args: arguments to give to *package* when retrieving flags
:type args: list of string
:param variables: return the values of particular variables
:type variables: list of string
:param define_variable: additional variables to define (also in conf.env.PKG_CONFIG_DEFINES)
:type define_variable: dict(string: string)
"""
path = Utils.to_list(kw['path'])
env = self.env.env or None
def define_it():
pkgname = kw.get('uselib_store', kw['package'].upper())
if kw.get('global_define'):
# compatibility, replace by pkgname in WAF 1.9?
self.define(self.have_define(kw['package']), 1, False)
else:
self.env.append_unique('DEFINES_%s' % pkgname,
"%s=1" % self.have_define(pkgname))
self.env[self.have_define(pkgname)] = 1
# pkg-config version
if 'atleast_pkgconfig_version' in kw:
cmd = path + [
'--atleast-pkgconfig-version=%s' % kw['atleast_pkgconfig_version']
]
self.cmd_and_log(cmd, env=env)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# checking for the version of a module
for x in cfg_ver:
y = x.replace('-', '_')
if y in kw:
self.cmd_and_log(path + ['--%s=%s' % (x, kw[y]), kw['package']],
env=env)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
define_it()
break
# retrieving the version of a module
if 'modversion' in kw:
version = self.cmd_and_log(path + ['--modversion', kw['modversion']],
env=env).strip()
self.define(
'%s_VERSION' %
Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])),
version)
return version
lst = [] + path
defi = kw.get('define_variable', None)
if not defi:
defi = self.env.PKG_CONFIG_DEFINES or {}
for key, val in defi.items():
lst.append('--define-variable=%s=%s' % (key, val))
static = kw.get('force_static', False)
if 'args' in kw:
args = Utils.to_list(kw['args'])
if '--static' in args or '--static-libs' in args:
static = True
lst += args
# tools like pkgconf expect the package argument after the -- ones -_-
lst.extend(Utils.to_list(kw['package']))
# retrieving variables of a module
if 'variables' in kw:
v_env = kw.get('env', self.env)
uselib = kw.get('uselib_store', kw['package'].upper())
vars = Utils.to_list(kw['variables'])
for v in vars:
val = self.cmd_and_log(lst + ['--variable=' + v], env=env).strip()
var = '%s_%s' % (uselib, v)
v_env[var] = val
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
return
# so we assume the command-line will output flags to be parsed afterwards
ret = self.cmd_and_log(lst, env=env)
if not 'okmsg' in kw:
kw['okmsg'] = 'yes'
define_it()
self.parse_flags(ret,
kw.get('uselib_store', kw['package'].upper()),
kw.get('env', self.env),
force_static=static,
posix=kw.get('posix', None))
return ret
def validate_cfg(self, kw):
"""
Searches for the program *pkg-config* if missing, and validates the
parameters to pass to :py:func:`waflib.Tools.c_config.exec_cfg`.
:param path: the **-config program to use** (default is *pkg-config*)
:type path: list of string
:param msg: message to display to describe the test executed
:type msg: string
:param okmsg: message to display when the test is successful
:type okmsg: string
:param errmsg: message to display in case of error
:type errmsg: string
"""
if not "path" in kw:
if not self.env.PKGCONFIG:
self.find_program("pkg-config", var="PKGCONFIG")
kw["path"] = self.env.PKGCONFIG
# pkg-config version
if "atleast_pkgconfig_version" in kw:
if not "msg" in kw:
kw["msg"] = "Checking for pkg-config version >= %r" % kw["atleast_pkgconfig_version"]
return
if not "okmsg" in kw:
kw["okmsg"] = "yes"
if not "errmsg" in kw:
kw["errmsg"] = "not found"
if "modversion" in kw:
if not "msg" in kw:
kw["msg"] = "Checking for %r version" % kw["modversion"]
if not "uselib_store" in kw:
kw["uselib_store"] = kw["modversion"]
if not "define_name" in kw:
kw["define_name"] = "%s_VERSION" % Utils.quote_define_name(kw["uselib_store"])
return
if not "package" in kw:
raise ValueError("a package name is required")
if not "uselib_store" in kw:
kw["uselib_store"] = kw["package"].upper()
if not "define_name" in kw:
kw["define_name"] = self.have_define(kw["uselib_store"])
if not "msg" in kw:
kw["msg"] = "Checking for %r" % (kw["package"] or kw["path"])
for x in cfg_ver:
# Gotcha: only one predicate is allowed at a time
# TODO remove in waf 2.0
y = x.replace("-", "_")
if y in kw:
package = kw["package"]
if Logs.verbose:
Logs.warn("Passing %r to conf.check_cfg() is obsolete, pass parameters directly, eg:", y)
Logs.warn(" conf.check_cfg(package='%s', args=['--libs', '--cflags', '%s >= 1.6'])", package, package)
if not "msg" in kw:
kw["msg"] = "Checking for %r %s %s" % (package, cfg_ver[x], kw[y])
break
