def load_envs(self):
"""load the data from the project directory into self.allenvs"""
try:
lst = Utils.listdir(self.cache_dir)
except OSError as e:
if e.errno == errno.ENOENT:
raise Errors.WafError('The project was not configured: run "waf configure" first!')
else:
raise
if not lst:
raise Errors.WafError('The cache directory is empty: reconfigure the project')
for fname in lst:
if fname.endswith(CACHE_SUFFIX):
env = ConfigSet.ConfigSet(os.path.join(self.cache_dir, fname))
name = fname[:-len(CACHE_SUFFIX)]
self.all_envs[name] = env
for f in env[CFG_FILES]:
newnode = self.path.find_or_declare(f)
try:
h = Utils.h_file(newnode.abspath())
except (IOError, AttributeError):
Logs.error('cannot find %r' % f)
h = Utils.SIG_NIL
newnode.sig = h
def set_qt5_libs_to_check(self):
self.qt5_vars = Utils.to_list(getattr(self, 'qt5_vars', []))
if not self.qt5_vars:
dirlst = Utils.listdir(self.env.QTLIBS)
pat = self.env.cxxshlib_PATTERN
if Utils.is_win32:
pat = pat.replace('.dll', '.lib')
if self.environ.get('QT5_FORCE_STATIC'):
pat = self.env.cxxstlib_PATTERN
if Utils.unversioned_sys_platform() == 'darwin':
pat = "%s\.framework"
re_qt = re.compile(pat%'Qt5?(?P<name>.*)'+'$')
for x in dirlst:
m = re_qt.match(x)
if m:
self.qt5_vars.append("Qt5%s" % m.group('name'))
if not self.qt5_vars:
self.fatal('cannot find any Qt5 library (%r)' % self.env.QTLIBS)
qtextralibs = getattr(Options.options, 'qtextralibs', None)
if qtextralibs:
self.qt5_vars.extend(qtextralibs.split(','))
if not hasattr(self, 'qt5_vars_debug'):
self.qt5_vars_debug = [a + '_DEBUG' for a in self.qt5_vars]
self.qt5_vars_debug = Utils.to_list(self.qt5_vars_debug)
def load_envs(self):
"""
The configuration command creates files of the form ``build/c4che/NAMEcache.py``. This method
creates a :py:class:`waflib.ConfigSet.ConfigSet` instance for each ``NAME`` by reading those
files. The config sets are then stored in the dict :py:attr:`waflib.Build.BuildContext.allenvs`.
"""
try:
lst = Utils.listdir(self.cache_dir)
except OSError as e:
if e.errno == errno.ENOENT:
raise Errors.WafError('The project was not configured: run "waf configure" first!')
else:
raise
if not lst:
raise Errors.WafError('The cache directory is empty: reconfigure the project')
for fname in lst:
if fname.endswith(CACHE_SUFFIX):
env = ConfigSet.ConfigSet(os.path.join(self.cache_dir, fname))
name = fname[:-len(CACHE_SUFFIX)]
self.all_envs[name] = env
for f in env[CFG_FILES]:
newnode = self.root.find_resource(f)
try:
h = Utils.h_file(newnode.abspath())
except (IOError, AttributeError):
Logs.error('cannot find %r' % f)
h = Utils.SIG_NIL
newnode.sig = h
def load_envs(self):
try:
lst = Utils.listdir(self.cache_dir)
except OSError, e:
if e.errno == errno.ENOENT:
raise Errors.WafError('The project was not configured: run "waf configure" first!')
else:
raise
def listdir(self): """ Lists the folder contents :returns: list of file/folder names ordered alphabetically :rtype: list of string """ lst = Utils.listdir(self.abspath()) lst.sort() return lst
def update(ctx):
lst=Options.options.files.split(',')
if not lst:
lst=[x for x in Utils.listdir(Context.waf_dir+'/waflib/extras')if x.endswith('.py')]
for x in lst:
tool=x.replace('.py','')
try:
Configure.download_tool(tool,force=True,ctx=ctx)
except Errors.WafError:
Logs.error('Could not find the tool %s in the remote repository'%x)
def update(ctx):
'''updates the plugins from the *waflib/extras* directory'''
lst=Options.options.files.split(',')
if not lst:
lst=[x for x in Utils.listdir(Context.waf_dir+'/waflib/extras')if x.endswith('.py')]
for x in lst:
tool=x.replace('.py','')
try:
Configure.download_tool(tool,force=True,ctx=ctx)
except Errors.WafError:
Logs.error('Could not find the tool %s in the remote repository'%x)
def update(ctx):
"""updates the plugins from the *waflib/extras* directory"""
lst = Options.options.files.split(",")
if not lst:
lst = [x for x in Utils.listdir(Context.waf_dir + "/waflib/extras") if x.endswith(".py")]
for x in lst:
tool = x.replace(".py", "")
try:
Configure.download_tool(tool, force=True, ctx=ctx)
except Errors.WafError:
Logs.error("Could not find the tool %s in the remote repository" % x)
def post_run(self):
"""record the inner class files created (Class$Foo) - for cleaning the folders mostly
it is not possible to know which inner classes in advance"""
lst = set([x.parent for x in self.outputs])
inner = []
for k in lst:
lst = Utils.listdir(k.abspath())
for u in lst:
if u.find('$') >= 0:
node = k.find_or_declare(u)
inner.append(node)
to_add = set(inner) - set(self.outputs)
self.outputs.extend(list(to_add))
return super(javac, self).post_run()
def update(ctx):
lst = Options.options.files
if lst:
lst = lst.split(',')
else:
path = os.path.join(Context.waf_dir, 'waflib', 'extras')
lst = [x for x in Utils.listdir(path) if x.endswith('.py')]
for x in lst:
tool = x.replace('.py', '')
if not tool:
continue
try:
dl = Configure.download_tool
except AttributeError:
ctx.fatal('The command "update" is dangerous; include the tool "use_config" in your project!')
try:
dl(tool, force=True, ctx=ctx)
except Errors.WafError:
Logs.error('Could not find the tool %r in the remote repository' % x)
else:
Logs.warn('Updated %r' % tool)
def set_qt5_libs_to_check(self):
self.qt5_vars = Utils.to_list(getattr(self, 'qt5_vars', []))
if not self.qt5_vars:
dirlst = Utils.listdir(self.env.QTLIBS)
pat = self.env.cxxshlib_PATTERN
if Utils.is_win32:
pat = pat.replace('.dll', '.lib')
if self.environ.get('QT5_FORCE_STATIC'):
pat = self.env.cxxstlib_PATTERN
if Utils.unversioned_sys_platform() == 'darwin':
pat = r"%s\.framework"
re_qt = re.compile(pat % 'Qt5?(?P<name>.*)' + '$')
for x in dirlst:
m = re_qt.match(x)
if m:
self.qt5_vars.append("Qt5%s" % m.group('name'))
if not self.qt5_vars:
self.fatal('cannot find any Qt5 library (%r)' % self.env.QTLIBS)
qtextralibs = getattr(Options.options, 'qtextralibs', None)
if qtextralibs:
self.qt5_vars.extend(qtextralibs.split(','))
def set_qt5_libs_to_check(self):
self.qt5_vars = Utils.to_list(getattr(self, "qt5_vars", []))
if not self.qt5_vars:
dirlst = Utils.listdir(self.env.QTLIBS)
pat = self.env.cxxshlib_PATTERN
if Utils.is_win32:
pat = pat.replace(".dll", ".lib")
if self.environ.get("QT5_FORCE_STATIC"):
pat = self.env.cxxstlib_PATTERN
if Utils.unversioned_sys_platform() == "darwin":
pat = r"%s\.framework"
re_qt = re.compile(pat % "Qt5?(?P<name>.*)" + "$")
for x in dirlst:
m = re_qt.match(x)
if m:
self.qt5_vars.append("Qt5%s" % m.group("name"))
if not self.qt5_vars:
self.fatal("cannot find any Qt5 library (%r)" % self.env.QTLIBS)
qtextralibs = getattr(Options.options, "qtextralibs", None)
if qtextralibs:
self.qt5_vars.extend(qtextralibs.split(","))
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env["CXX"]:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {"lib": k and k[0] or kw.get("lib", None)}
for key, value in self.options.__dict__.items():
if not key.startswith("boost_"):
continue
key = key[len("boost_") :]
params[key] = value and value or kw.get(key, "")
var = kw.get("uselib_store", "BOOST")
self.start_msg("Checking boost includes")
try:
self.env["INCLUDES_%s" % var] = self.boost_get_includes(**params)
self.env.BOOST_VERSION = self.boost_get_version(self.env["INCLUDES_%s" % var])
except WafError:
self.end_msg("not found", "YELLOW")
raise
# self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
# self.env.BOOST_VERSION = self.boost_get_version(inc)
self.end_msg(self.env.BOOST_VERSION)
if Logs.verbose:
Logs.pprint("CYAN", " path : %s" % self.env["INCLUDES_%s" % var])
if not params["lib"]:
return
self.start_msg("Checking boost libs")
try:
suffix = params.get("static", "ST") or ""
path, libs = self.boost_get_libs(**params)
except WafError:
self.end_msg("not found", "YELLOW")
raise
# suffix = params.get('static', None) and 'ST' or ''
# path, libs = self.boost_get_libs(**params)
self.env["%sLIBPATH_%s" % (suffix, var)] = [path]
self.env["%sLIB_%s" % (suffix, var)] = libs
self.end_msg("ok")
if Logs.verbose:
Logs.pprint("CYAN", " path : %s" % path)
Logs.pprint("CYAN", " libs : %s" % libs)
def try_link():
if "system" in params["lib"]:
self.check_cxx(
fragment="\n".join(
["#include <boost/system/error_code.hpp>", "int main() { boost::system::error_code c; }"]
),
use=var,
execute=False,
)
if "thread" in params["lib"]:
self.check_cxx(
fragment="\n".join(["#include <boost/thread.hpp>", "int main() { boost::thread t; }"]),
use=var,
execute=False,
)
if params.get("linkage_autodetect", False):
self.start_msg("Attempting to detect boost linkage flags")
toolset = self.boost_get_toolset(kw.get("toolset", ""))
if toolset in ["vc"]:
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env["DEFINES_%s" % var] += ["BOOST_ALL_NO_LIB"]
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ""):
has_dlls = True
break
if not has_dlls:
self.env["STLIBPATH_%s" % var] = [path]
self.env["STLIB_%s" % var] = libs
del self.env["LIB_%s" % var]
del self.env["LIBPATH_%s" % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (["/MD", "/EHsc"], []):
self.env.stash()
self.env["CXXFLAGS_%s" % var] += cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
e = None
break
except Errors.ConfigurationError, exc:
self.env.revert()
e = exc
if e is not None:
self.fatal(
"Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=e
)
else:
self.fatal("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
def check_boost(self,*k,**kw):
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params={'lib':k and k[0]or kw.get('lib',None)}
for key,value in list(self.options.__dict__.items()):
if not key.startswith('boost_'):
continue
key=key[len('boost_'):]
params[key]=value and value or kw.get(key,'')
var=kw.get('uselib_store','BOOST')
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s'%var]=inc=self.boost_get_includes(**params)
self.env.BOOST_VERSION=self.boost_get_version(inc)
self.end_msg(self.env.BOOST_VERSION)
if Logs.verbose:
Logs.pprint('CYAN',' path : %s'%self.env['INCLUDES_%s'%var])
if not params['lib']:
return
self.start_msg('Checking boost libs')
suffix=params.get('static',None)and'ST'or''
path,libs=self.boost_get_libs(**params)
self.env['%sLIBPATH_%s'%(suffix,var)]=[path]
self.env['%sLIB_%s'%(suffix,var)]=libs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN',' path : %s'%path)
Logs.pprint('CYAN',' libs : %s'%libs)
def try_link():
if'system'in params['lib']:
self.check_cxx(fragment="\n".join(['#include <boost/system/error_code.hpp>','int main() { boost::system::error_code c; }',]),use=var,execute=False,)
if'thread'in params['lib']:
self.check_cxx(fragment="\n".join(['#include <boost/thread.hpp>','int main() { boost::thread t; }',]),use=var,execute=False,)
if params.get('linkage_autodetect',False):
self.start_msg("Attempting to detect boost linkage flags")
toolset=self.boost_get_toolset(kw.get('toolset',''))
if toolset in['vc']:
self.env['DEFINES_%s'%var]+=['BOOST_ALL_NO_LIB']
has_dlls=False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN%''):
has_dlls=True
break
if not has_dlls:
self.env['STLIBPATH_%s'%var]=[path]
self.env['STLIB_%s'%var]=libs
del self.env['LIB_%s'%var]
del self.env['LIBPATH_%s'%var]
for cxxflags in(['/MD','/EHsc'],[]):
self.env.stash()
self.env["CXXFLAGS_%s"%var]+=cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s"%(self.env["CXXFLAGS_%s"%var]))
exc=None
break
except Errors.ConfigurationError as e:
self.env.revert()
exc=e
if exc is not None:
self.end_msg("Could not auto-detect boost linking flags combination, you may report it to boost.py author",ex=exc)
self.fatal('The configuration failed')
else:
self.end_msg("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
self.fatal('The configuration failed')
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError as e:
self.end_msg("Could not link against boost libraries using supplied options")
self.fatal('The configuration failed')
self.end_msg('ok')
def find_qt5_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
if not qtdir:
qtdir = os.path.normpath(
self.CreateRootRelativePath('Code/Sandbox/SDKs/Qt'))
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
# the qt directory has been given from QT5_ROOT - deduce the qt binary path
if not qtdir:
qtdir = os.environ.get('QT5_ROOT', '')
qtbin = os.environ.get('QT5_BIN', None) or os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt5/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ['5', '0', '0']
for qmk in ('qmake-qt5', 'qmake5', 'qmake'):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log([qmake] +
['-query', 'QT_VERSION']).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
# qmake could not be found easily, rely on qtchooser
if not cand:
try:
self.find_program('qtchooser')
except self.errors.ConfigurationError:
pass
else:
cmd = [self.env.QTCHOOSER] + ['-qt=5', '-run-tool=qmake']
try:
version = self.cmd_and_log(cmd + ['-query', 'QT_VERSION'])
except self.errors.WafError:
pass
else:
cand = cmd
if cand:
self.env.QMAKE = cand
else:
# If we cannot find qmake, we will assume that QT is not available or a selected option
return False
self.env.QT_INSTALL_BINS = qtbin = self.cmd_and_log(
[self.env.QMAKE] + ['-query', 'QT_INSTALL_BINS']).strip() + os.sep
paths.insert(0, qtbin)
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(['uic-qt5', 'uic'], 'QT_UIC')
if not env.QT_UIC:
# If we find qmake but not the uic compiler, then the QT installation is corrupt/invalid
self.fatal(
'Detected an invalid/corrupt version of QT, please check your installation'
)
self.start_msg('Checking for uic version')
uicver = self.cmd_and_log([env.QT_UIC] + ['-version'], output=Context.BOTH)
uicver = ''.join(uicver).strip()
uicver = uicver.replace('Qt User Interface Compiler ',
'').replace('User Interface Compiler for Qt', '')
self.end_msg(uicver)
if uicver.find(' 3.') != -1 or uicver.find(' 4.') != -1:
self.fatal(
'this uic compiler is for qt3 or qt5, add uic for qt5 to your path'
)
find_bin(['moc-qt5', 'moc'], 'QT_MOC')
find_bin(['rcc-qt5', 'rcc'], 'QT_RCC')
find_bin(['lrelease-qt5', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt5', 'lupdate'], 'QT_LUPDATE')
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
return True
def find_qt4_binaries(self):
env=self.env
opt=Options.options
qtdir=getattr(opt,'qtdir','')
qtbin=getattr(opt,'qtbin','')
paths=[]
if qtdir:
qtbin=os.path.join(qtdir,'bin')
if not qtdir:
qtdir=os.environ.get('QT4_ROOT','')
qtbin=os.environ.get('QT4_BIN',None)or os.path.join(qtdir,'bin')
if qtbin:
paths=[qtbin]
if not qtdir:
paths=os.environ.get('PATH','').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst=Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir='/usr/local/Trolltech/%s/'%lst[0]
qtbin=os.path.join(qtdir,'bin')
paths.append(qtbin)
cand=None
prev_ver=['4','0','0']
for qmk in('qmake-qt4','qmake4','qmake'):
try:
qmake=self.find_program(qmk,path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version=self.cmd_and_log(qmake+['-query','QT_VERSION']).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver=version.split('.')
if new_ver>prev_ver:
cand=qmake
prev_ver=new_ver
if cand:
self.env.QMAKE=cand
else:
self.fatal('Could not find qmake for qt4')
qtbin=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_BINS']).strip()+os.sep
def find_bin(lst,var):
if var in env:
return
for f in lst:
try:
ret=self.find_program(f,path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var]=ret
break
find_bin(['uic-qt3','uic3'],'QT_UIC3')
find_bin(['uic-qt4','uic'],'QT_UIC')
if not env.QT_UIC:
self.fatal('cannot find the uic compiler for qt4')
self.start_msg('Checking for uic version')
uicver=self.cmd_and_log(env.QT_UIC+["-version"],output=Context.BOTH)
uicver=''.join(uicver).strip()
uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','')
self.end_msg(uicver)
if uicver.find(' 3.')!=-1:
self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
find_bin(['moc-qt4','moc'],'QT_MOC')
find_bin(['rcc-qt4','rcc'],'QT_RCC')
find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE')
find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE')
env['UIC3_ST']='%s -o %s'
env['UIC_ST']='%s -o %s'
env['MOC_ST']='-o'
env['ui_PATTERN']='ui_%s.h'
env['QT_LRELEASE_FLAGS']=['-silent']
env.MOCCPPPATH_ST='-I%s'
env.MOCDEFINES_ST='-D%s'
def find_qt5_binaries(self):
"""
Detects Qt programs such as qmake, moc, uic, lrelease
"""
env = self.env
opt = Options.options
qtdir = getattr(opt, "qtdir", "")
qtbin = getattr(opt, "qtbin", "")
paths = []
if qtdir:
qtbin = os.path.join(qtdir, "bin")
# the qt directory has been given from QT5_ROOT - deduce the qt binary path
if not qtdir:
qtdir = self.environ.get("QT5_ROOT", "")
qtbin = self.environ.get("QT5_BIN") or os.path.join(qtdir, "bin")
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = self.environ.get("PATH", "").split(os.pathsep)
paths.extend(["/usr/share/qt5/bin", "/usr/local/lib/qt5/bin"])
try:
lst = Utils.listdir("/usr/local/Trolltech/")
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = "/usr/local/Trolltech/%s/" % lst[0]
qtbin = os.path.join(qtdir, "bin")
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ["5", "0", "0"]
for qmk in ("qmake-qt5", "qmake5", "qmake"):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log(qmake +
["-query", "QT_VERSION"]).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split(".")
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
# qmake could not be found easily, rely on qtchooser
if not cand:
try:
self.find_program("qtchooser")
except self.errors.ConfigurationError:
pass
else:
cmd = self.env.QTCHOOSER + ["-qt=5", "-run-tool=qmake"]
try:
version = self.cmd_and_log(cmd + ["-query", "QT_VERSION"])
except self.errors.WafError:
pass
else:
cand = cmd
if cand:
self.env.QMAKE = cand
else:
self.fatal("Could not find qmake for qt5")
self.env.QT_HOST_BINS = qtbin = self.cmd_and_log(
self.env.QMAKE + ["-query", "QT_HOST_BINS"]).strip()
paths.insert(0, qtbin)
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(["uic-qt5", "uic"], "QT_UIC")
if not env.QT_UIC:
self.fatal("cannot find the uic compiler for qt5")
self.start_msg("Checking for uic version")
uicver = self.cmd_and_log(env.QT_UIC + ["-version"], output=Context.BOTH)
uicver = "".join(uicver).strip()
uicver = uicver.replace("Qt User Interface Compiler ",
"").replace("User Interface Compiler for Qt", "")
self.end_msg(uicver)
if uicver.find(" 3.") != -1 or uicver.find(" 4.") != -1:
self.fatal(
"this uic compiler is for qt3 or qt4, add uic for qt5 to your path"
)
find_bin(["moc-qt5", "moc"], "QT_MOC")
find_bin(["rcc-qt5", "rcc"], "QT_RCC")
find_bin(["lrelease-qt5", "lrelease"], "QT_LRELEASE")
find_bin(["lupdate-qt5", "lupdate"], "QT_LUPDATE")
env.UIC_ST = "%s -o %s"
env.MOC_ST = "-o"
env.ui_PATTERN = "ui_%s.h"
env.QT_LRELEASE_FLAGS = ["-silent"]
env.MOCCPPPATH_ST = "-I%s"
env.MOCDEFINES_ST = "-D%s"
def check_boost(self,*k,**kw):
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params={'lib':k and k[0]or kw.get('lib',None)}
for key,value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key=key[len('boost_'):]
params[key]=value and value or kw.get(key,'')
var=kw.get('uselib_store','BOOST')
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s'%var]=inc=self.boost_get_includes(**params)
self.env.BOOST_VERSION=self.boost_get_version(inc)
self.end_msg(self.env.BOOST_VERSION)
if Logs.verbose:
Logs.pprint('CYAN',' path : %s'%self.env['INCLUDES_%s'%var])
if not params['lib']:
return
self.start_msg('Checking boost libs')
suffix=params.get('static',None)and'ST'or''
path,libs=self.boost_get_libs(**params)
self.env['%sLIBPATH_%s'%(suffix,var)]=[path]
self.env['%sLIB_%s'%(suffix,var)]=libs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN',' path : %s'%path)
Logs.pprint('CYAN',' libs : %s'%libs)
def try_link():
if'system'in params['lib']:
self.check_cxx(fragment="\n".join(['#include <boost/system/error_code.hpp>','int main() { boost::system::error_code c; }',]),use=var,execute=False,)
if'thread'in params['lib']:
self.check_cxx(fragment="\n".join(['#include <boost/thread.hpp>','int main() { boost::thread t; }',]),use=var,execute=False,)
if params.get('linkage_autodetect',False):
self.start_msg("Attempting to detect boost linkage flags")
toolset=self.boost_get_toolset(kw.get('toolset',''))
if toolset in['vc']:
self.env['DEFINES_%s'%var]+=['BOOST_ALL_NO_LIB']
has_dlls=False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN%''):
has_dlls=True
break
if not has_dlls:
self.env['STLIBPATH_%s'%var]=[path]
self.env['STLIB_%s'%var]=libs
del self.env['LIB_%s'%var]
del self.env['LIBPATH_%s'%var]
for cxxflags in(['/MD','/EHsc'],[]):
self.env.stash()
self.env["CXXFLAGS_%s"%var]+=cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s"%(self.env["CXXFLAGS_%s"%var]))
e=None
break
except Errors.ConfigurationError as exc:
self.env.revert()
e=exc
if e is not None:
self.fatal("Could not auto-detect boost linking flags combination, you may report it to boost.py author",ex=e)
else:
self.fatal("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError ,e:
self.fatal("Could not link against boost libraries using supplied options")
self.end_msg('ok')
def listdir(self): """List the folder contents""" lst = Utils.listdir(self.abspath()) lst.sort() return lst
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {
'lib': k and k[0] or kw.get('lib', None),
'stlib': kw.get('stlib', None)
}
for key, value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key = key[len('boost_'):]
params[key] = value and value or kw.get(key, '')
var = kw.get('uselib_store', 'BOOST')
if not self.env.DONE_FIND_BOOST_COMMON:
self.find_program('dpkg-architecture', var='DPKG_ARCHITECTURE', mandatory=False)
if self.env.DPKG_ARCHITECTURE:
deb_host_multiarch = self.cmd_and_log([self.env.DPKG_ARCHITECTURE[0], '-qDEB_HOST_MULTIARCH'])
BOOST_LIBS.insert(0, '/usr/lib/%s' % deb_host_multiarch.strip())
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
versions = self.boost_get_version(inc)
self.env.BOOST_VERSION = versions[0]
self.env.BOOST_VERSION_NUMBER = int(versions[1])
self.end_msg('%d.%d.%d' % (int(versions[1]) / 100000,
int(versions[1]) / 100 % 1000,
int(versions[1]) % 100))
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % self.env['INCLUDES_%s' % var])
self.env.DONE_FIND_BOOST_COMMON = True
if not params['lib'] and not params['stlib']:
return
if 'static' in kw or 'static' in params:
Logs.warn('boost: static parameter is deprecated, use stlib instead.')
self.start_msg('Checking boost libs')
path, libs, stlibs = self.boost_get_libs(**params)
self.env['LIBPATH_%s' % var] = [path]
self.env['STLIBPATH_%s' % var] = [path]
self.env['LIB_%s' % var] = libs
self.env['STLIB_%s' % var] = stlibs
self.end_msg(' '.join(libs + stlibs))
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % path)
Logs.pprint('CYAN', ' shared libs : %s' % libs)
Logs.pprint('CYAN', ' static libs : %s' % stlibs)
def has_shlib(lib):
return params['lib'] and lib in params['lib']
def has_stlib(lib):
return params['stlib'] and lib in params['stlib']
def has_lib(lib):
return has_shlib(lib) or has_stlib(lib)
if has_lib('thread'):
# not inside try_link to make check visible in the output
self._check_pthread_flag(k, kw)
def try_link():
if has_lib('system'):
self.check_cxx(fragment=BOOST_ERROR_CODE, use=var, execute=False)
if has_lib('thread'):
self.check_cxx(fragment=BOOST_THREAD_CODE, use=var, execute=False)
if has_lib('log') or has_lib('log_setup'):
if not has_lib('thread'):
self.env['DEFINES_%s' % var] += ['BOOST_LOG_NO_THREADS']
if has_shlib('log') or has_shlib('log_setup'):
self.env['DEFINES_%s' % var] += ['BOOST_LOG_DYN_LINK']
if has_lib('log_setup'):
self.check_cxx(fragment=BOOST_LOG_SETUP_CODE, use=var, execute=False)
else:
self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
if params.get('linkage_autodetect', False):
self.start_msg('Attempting to detect boost linkage flags')
toolset = self.boost_get_toolset(kw.get('toolset', ''))
if toolset in ('vc',):
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ''):
has_dlls = True
break
if not has_dlls:
self.env['STLIBPATH_%s' % var] = [path]
self.env['STLIB_%s' % var] = libs
del self.env['LIB_%s' % var]
del self.env['LIBPATH_%s' % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (['/MD', '/EHsc'], []):
self.env.stash()
self.env['CXXFLAGS_%s' % var] += cxxflags
try:
try_link()
self.end_msg('ok: winning cxxflags combination: %s' % (self.env['CXXFLAGS_%s' % var]))
exc = None
break
except Errors.ConfigurationError as e:
self.env.revert()
exc = e
if exc is not None:
self.end_msg('Could not auto-detect boost linking flags combination, you may report it to boost.py author', ex=exc)
self.fatal('The configuration failed')
else:
self.end_msg('Boost linkage flags auto-detection not implemented (needed ?) for this toolchain')
self.fatal('The configuration failed')
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError as e:
self.end_msg('Could not link against boost libraries using supplied options', 'YELLOW')
self.fatal('The configuration failed')
self.end_msg('ok')
def run(self):
env = self.env
gen = self.generator
bld = gen.bld
zpy = bld.zpy
out = self.outputs[0].parent
dist = self.dist
signode = self.signode
out_path = out.abspath()
bld_path = bld.bldnode.abspath()
source_url = dist.source_url or ''
url = urlparse.urlsplit(source_url)
# normalize initially to dist.key
name = pth.basename(url.path).lower() or dist.key
# ensure sdist filename matches dist.name!
# otherwise dist.name != dist.metadata.name if the object was created
# from a filename, even if metadata is loaded later!
#FIXME: upstream fix to above...
name = name.replace(dist.key, dist.name, 1)
if dist.name not in name:
# probably a hash
ext = name[name.find('.'):]
if len(ext) > 1:
name = dist.metadata.name_and_version + ext
# no raison other than consistency
if name.endswith('.tgz'):
name = name[:-4] + '.tar.gz'
path = pth.join(zpy.top_xsrc, name)
meta = path + '.' + metadata.METADATA_FILENAME
meta_alt = pth.join(url.path, metadata.METADATA_FILENAME)
meta_out = pth.join(out_path, metadata.METADATA_FILENAME)
if url.scheme and url.path and url.path != path:
path, message = urllib.urlretrieve(url.geturl(), path)
if url.path and pth.isdir(url.path):
try:
git_dir = subprocess.check_output(
['git', 'rev-parse', '--show-toplevel'],
cwd=url.path,
).strip()
# avoid checking out the wrong repo due to nesting; ie. don't
# checkout someone's dotfile repo just because they happen to
# technically be "under" it
if pth.abspath(git_dir) == pth.abspath(url.path):
git_dir = subprocess.check_output(
args=['git', 'rev-parse', '--git-dir'],
cwd=url.path,
)
git_dir = pth.join(url.path, git_dir.strip())
else:
git_dir = None
except subprocess.CalledProcessError:
git_dir = None
if git_dir:
if not pth.exists(out_path):
os.mkdir(out_path)
subprocess.call([
'git',
'--git-dir={0}'.format(git_dir),
'--work-tree={0}'.format(out_path),
'checkout-index',
'--all',
'--quiet',
'--force',
])
if pth.exists(meta):
shutil.copy2(meta, meta_out)
elif pth.exists(meta_alt):
shutil.copy2(meta_alt, meta_out)
else:
# symlink local dist checkout
local_path = pth.join(zpy.top, url.path)
local_path = pth.abspath(local_path)
local_sym = pth.relpath(local_path, bld_path)
try:
# clear broken symlinks
os.unlink(out_path)
except OSError:
pass
finally:
os.symlink(local_sym, out_path)
elif pth.isfile(path):
_zip = ('.zip', )
_whl = ('.whl', )
_tar = tuple(
set(distlib.util.ARCHIVE_EXTENSIONS) - set(_zip + _whl))
if path.endswith(_whl):
dist.metadata = wheel.Wheel(path).metadata
dist_dir = pth.join(out_path, 'dist')
Utils.check_dir(dist_dir)
self.outputs[0].write(
json.dumps(
dist.metadata.dictionary,
ensure_ascii=True,
sort_keys=True,
indent=2,
))
whl_dst = pth.join(dist_dir, pth.basename(path))
whl_sym = pth.relpath(path, dist_dir)
if not pth.exists(whl_dst):
os.symlink(whl_sym, whl_dst)
else:
if pth.isfile(meta):
#TODO: needs to use zpy.dist
dist.metadata = metadata.Metadata(path=meta)
else:
pydist = normalize_pydist(dist.metadata.dictionary)
pydist.update(source_url=pth.relpath(path, zpy.top))
with codecs.open(meta, 'w', 'utf-8') as fp:
json.dump(
pydist,
fp=fp,
ensure_ascii=True,
sort_keys=True,
indent=2,
)
dist.metadata._legacy = None
dist.metadata._data = pydist
sig_path = signode.abspath()
for sfx, cmd in (
(_tar, '{env.TAR}\0-C\0{sig_path}\0-xf\0{path}\0'),
(_zip, '{env.UNZIP}\0-q\0-o\0-d\0{sig_path}\0{path}\0'),
(None, None),
):
if sfx is None:
distlib.util.unarchive(path, bld_path)
break
try:
cmd = cmd.format(**locals())
cmd = cmd.strip('\0').split('\0')
except AttributeError:
continue
rc = self.exec_command(cmd, env=env.env)
if rc == 0:
if not pth.exists(out_path):
tmp = signode.make_node(
Utils.listdir(signode.abspath()))
os.rename(tmp.abspath(), out_path)
break
shutil.copy2(meta,
pth.join(out_path, metadata.METADATA_FILENAME))
if dist.key == 'python':
lib = pth.join(out_path, 'Lib')
zippy_src = pth.join(zpy.top, 'zippy')
zippy_dst = pth.join(lib, 'zippy')
zippy_sym = pth.relpath(zippy_src, lib)
if not pth.lexists(zippy_dst):
os.symlink(zippy_sym, zippy_dst)
incl_src = pth.join(out_path, 'Include')
incl_dst = pth.join(zpy.o_inc, 'python' + dist.version[0:3])
incl_sym = pth.relpath(incl_src, zpy.o_inc)
if not pth.lexists(incl_dst):
os.symlink(incl_sym, incl_dst)
pyconfig = pth.join(out_path, 'Include', 'pyconfig.h')
if not pth.lexists(pyconfig):
os.symlink('../pyconfig.h', pyconfig)
return 0
def find_qt4_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
# the qt directory has been given from QT4_ROOT - deduce the qt binary path
if not qtdir:
qtdir = self.environ.get('QT4_ROOT', '')
qtbin = os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ['4', '0', '0']
for qmk in ['qmake-qt4', 'qmake4', 'qmake']:
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log([qmake, '-query', 'QT_VERSION']).strip()
except self.errors.ConfigurationError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if cand:
self.env.QMAKE = cand
else:
self.fatal('Could not find qmake for qt4')
qtbin = self.cmd_and_log([self.env.QMAKE, '-query', 'QT_INSTALL_BINS']).strip() + os.sep
def find_bin(lst, var):
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var]=ret
break
find_bin(['uic-qt3', 'uic3'], 'QT_UIC3')
find_bin(['uic-qt4', 'uic'], 'QT_UIC')
if not env['QT_UIC']:
self.fatal('cannot find the uic compiler for qt4')
try:
uicver = self.cmd_and_log(env['QT_UIC'] + " -version 2>&1").strip()
except self.errors.ConfigurationError:
self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
uicver = uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt', '')
self.msg('Checking for uic version', '%s' % uicver)
if uicver.find(' 3.') != -1:
self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
find_bin(['moc-qt4', 'moc'], 'QT_MOC')
find_bin(['rcc'], 'QT_RCC')
find_bin(['lrelease-qt4', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt4', 'lupdate'], 'QT_LUPDATE')
env['UIC3_ST']= '%s -o %s'
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {
'lib': k and k[0] or kw.get('lib'),
'stlib': kw.get('stlib')
}
for key, value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key = key[len('boost_'):]
params[key] = value and value or kw.get(key, '')
var = kw.get('uselib_store', 'BOOST')
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
versions = self.boost_get_version(inc)
self.env.BOOST_VERSION = versions[0]
self.env.BOOST_VERSION_NUMBER = int(versions[1])
self.end_msg("%d.%d.%d" % (int(versions[1]) / 100000,
int(versions[1]) / 100 % 1000,
int(versions[1]) % 100))
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % self.env['INCLUDES_%s' % var])
if not params['lib'] and not params['stlib']:
return
if 'static' in kw or 'static' in params:
Logs.warn('boost: static parameter is deprecated, use stlib instead.')
self.start_msg('Checking boost libs')
path, libs, stlibs = self.boost_get_libs(**params)
self.env['LIBPATH_%s' % var] = [path]
self.env['STLIBPATH_%s' % var] = [path]
self.env['LIB_%s' % var] = libs
self.env['STLIB_%s' % var] = stlibs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % path)
Logs.pprint('CYAN', ' shared libs : %s' % libs)
Logs.pprint('CYAN', ' static libs : %s' % stlibs)
def try_link():
if (params['lib'] and 'system' in params['lib']) or \
params['stlib'] and 'system' in params['stlib']:
self.check_cxx(fragment=BOOST_ERROR_CODE, use=var, execute=False)
if (params['lib'] and 'thread' in params['lib']) or \
params['stlib'] and 'thread' in params['stlib']:
self.check_cxx(fragment=BOOST_THREAD_CODE, use=var, execute=False)
def is_log_mt():
'''Check if found boost_log library is multithread-safe'''
for lib in libs:
if lib.startswith('boost_log'):
lib_log = lib
break
return '-mt' in lib_log
if params['lib'] and 'log' in params['lib']:
self.env['DEFINES_%s' % var] += ['BOOST_LOG_DYN_LINK']
if not is_log_mt():
self.env['DEFINES_%s' % var] += ['BOOST_LOG_NO_THREADS']
self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
if params['stlib'] and 'log' in params['stlib']:
# Static linking is assumed by default
if not is_log_mt():
self.env['DEFINES_%s' % var] += ['BOOST_LOG_NO_THREADS']
self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
if params.get('linkage_autodetect', False):
self.start_msg("Attempting to detect boost linkage flags")
toolset = self.boost_get_toolset(kw.get('toolset', ''))
if toolset in ('vc',):
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ''):
has_dlls = True
break
if not has_dlls:
self.env['STLIBPATH_%s' % var] = [path]
self.env['STLIB_%s' % var] = libs
del self.env['LIB_%s' % var]
del self.env['LIBPATH_%s' % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (['/MD', '/EHsc'], []):
self.env.stash()
self.env["CXXFLAGS_%s" % var] += cxxflags
try:
try_link()
except Errors.ConfigurationError as e:
self.env.revert()
exc = e
else:
self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
exc = None
self.env.commit()
break
if exc is not None:
self.end_msg("Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=exc)
self.fatal('The configuration failed')
else:
self.end_msg("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
self.fatal('The configuration failed')
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError as e:
self.end_msg("Could not link against boost libraries using supplied options")
self.fatal('The configuration failed')
self.end_msg('ok')
def find_qt5_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
# the qt directory has been given from QT5_ROOT - deduce the qt binary path
if not qtdir:
qtdir = os.environ.get('QT5_ROOT', '')
qtbin = os.environ.get('QT5_BIN', None) or os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt5/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ['5', '0', '0']
for qmk in ('qmake-qt5', 'qmake5', 'qmake'):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log(qmake + ['-query', 'QT_VERSION']).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
# qmake could not be found easily, rely on qtchooser
if not cand:
try:
self.find_program('qtchooser')
except self.errors.ConfigurationError:
pass
else:
cmd = self.env.QTCHOOSER + ['-qt=5', '-run-tool=qmake']
try:
version = self.cmd_and_log(cmd + ['-query', 'QT_VERSION'])
except self.errors.WafError:
pass
else:
cand = cmd
if cand:
self.env.QMAKE = cand
else:
self.fatal('Could not find qmake for qt5')
self.env.QT_INSTALL_BINS = qtbin = self.cmd_and_log(self.env.QMAKE + ['-query', 'QT_INSTALL_BINS']).strip() + os.sep
paths.insert(0, qtbin)
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var]=ret
break
find_bin(['uic-qt5', 'uic'], 'QT_UIC')
if not env.QT_UIC:
self.fatal('cannot find the uic compiler for qt5')
self.start_msg('Checking for uic version')
uicver = self.cmd_and_log(env.QT_UIC + ['-version'], output=Context.BOTH)
uicver = ''.join(uicver).strip()
uicver = uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt', '')
self.end_msg(uicver)
if uicver.find(' 3.') != -1 or uicver.find(' 4.') != -1:
self.fatal('this uic compiler is for qt3 or qt5, add uic for qt5 to your path')
find_bin(['moc-qt5', 'moc'], 'QT_MOC')
find_bin(['rcc-qt5', 'rcc'], 'QT_RCC')
find_bin(['lrelease-qt5', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt5', 'lupdate'], 'QT_LUPDATE')
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {'lib': k and k[0] or kw.get('lib', None)}
for key, value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key = key[len('boost_'):]
params[key] = value and value or kw.get(key, '')
var = kw.get('uselib_store', 'BOOST')
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
self.env.BOOST_VERSION = self.boost_get_version(inc)
self.end_msg(self.env.BOOST_VERSION)
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % self.env['INCLUDES_%s' % var])
if not params['lib']:
return
self.start_msg('Checking boost libs')
suffix = params.get('static', None) and 'ST' or ''
path, libs = self.boost_get_libs(**params)
self.env['%sLIBPATH_%s' % (suffix, var)] = [path]
self.env['%sLIB_%s' % (suffix, var)] = libs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % path)
Logs.pprint('CYAN', ' libs : %s' % libs)
def try_link():
if 'system' in params['lib']:
self.check_cxx(
fragment="\n".join([
'#include <boost/system/error_code.hpp>',
'int main() { boost::system::error_code c; }',
]),
use=var,
execute=False,
)
if 'thread' in params['lib']:
self.check_cxx(
fragment="\n".join([
'#include <boost/thread.hpp>',
'int main() { boost::thread t; }',
]),
use=var,
execute=False,
)
if params.get('linkage_autodetect', False):
self.start_msg("Attempting to detect boost linkage flags")
toolset = self.boost_get_toolset(kw.get('toolset', ''))
if toolset in ['vc']:
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ''):
has_dlls = True
break
if not has_dlls:
self.env['STLIBPATH_%s' % var] = [path]
self.env['STLIB_%s' % var] = libs
del self.env['LIB_%s' % var]
del self.env['LIBPATH_%s' % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (['/MD', '/EHsc'], []):
self.env.stash()
self.env["CXXFLAGS_%s" % var] += cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
e = None
break
except Errors.ConfigurationError as exc:
self.env.revert()
e = exc
if e is not None:
self.fatal("Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=e)
else:
self.fatal("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError as e:
self.fatal("Could not link against boost libraries using supplied options")
self.end_msg('ok')
def find_qt4_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
# the qt directory has been given from QT4_ROOT - deduce the qt binary path
if not qtdir:
qtdir = os.environ.get('QT4_ROOT', '')
qtbin = os.environ.get('QT4_BIN', None) or os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ['4', '0', '0']
for qmk in ('qmake-qt4', 'qmake4', 'qmake'):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log(qmake +
['-query', 'QT_VERSION']).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if cand:
self.env.QMAKE = cand
else:
self.fatal('Could not find qmake for qt4')
qtbin = self.cmd_and_log(self.env.QMAKE +
['-query', 'QT_INSTALL_BINS']).strip() + os.sep
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(['uic-qt3', 'uic3'], 'QT_UIC3')
find_bin(['uic-qt4', 'uic'], 'QT_UIC')
if not env.QT_UIC:
self.fatal('cannot find the uic compiler for qt4')
self.start_msg('Checking for uic version')
uicver = self.cmd_and_log(env.QT_UIC + ["-version"], output=Context.BOTH)
uicver = ''.join(uicver).strip()
uicver = uicver.replace('Qt User Interface Compiler ',
'').replace('User Interface Compiler for Qt', '')
self.end_msg(uicver)
if uicver.find(' 3.') != -1:
self.fatal(
'this uic compiler is for qt3, add uic for qt4 to your path')
find_bin(['moc-qt4', 'moc'], 'QT_MOC')
find_bin(['rcc-qt4', 'rcc'], 'QT_RCC')
find_bin(['lrelease-qt4', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt4', 'lupdate'], 'QT_LUPDATE')
env['UIC3_ST'] = '%s -o %s'
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
def find_qt4_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, "qtdir", "")
qtbin = getattr(opt, "qtbin", "")
paths = []
if qtdir:
qtbin = os.path.join(qtdir, "bin")
if not qtdir:
qtdir = self.environ.get("QT4_ROOT", "")
qtbin = os.path.join(qtdir, "bin")
if qtbin:
paths = [qtbin]
if not qtdir:
paths = os.environ.get("PATH", "").split(os.pathsep)
paths.append("/usr/share/qt4/bin/")
try:
lst = Utils.listdir("/usr/local/Trolltech/")
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir = "/usr/local/Trolltech/%s/" % lst[0]
qtbin = os.path.join(qtdir, "bin")
paths.append(qtbin)
cand = None
prev_ver = ["4", "0", "0"]
for qmk in ["qmake-qt4", "qmake4", "qmake"]:
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log([qmake, "-query", "QT_VERSION"]).strip()
except self.errors.ConfigurationError:
pass
else:
if version:
new_ver = version.split(".")
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if cand:
self.env.QMAKE = cand
else:
self.fatal("Could not find qmake for qt4")
qtbin = self.cmd_and_log([self.env.QMAKE, "-query", "QT_INSTALL_BINS"]).strip() + os.sep
def find_bin(lst, var):
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(["uic-qt3", "uic3"], "QT_UIC3")
find_bin(["uic-qt4", "uic"], "QT_UIC")
if not env["QT_UIC"]:
self.fatal("cannot find the uic compiler for qt4")
try:
uicver = self.cmd_and_log(env["QT_UIC"] + " -version 2>&1").strip()
except self.errors.ConfigurationError:
self.fatal("this uic compiler is for qt3, add uic for qt4 to your path")
uicver = uicver.replace("Qt User Interface Compiler ", "").replace("User Interface Compiler for Qt", "")
self.msg("Checking for uic version", "%s" % uicver)
if uicver.find(" 3.") != -1:
self.fatal("this uic compiler is for qt3, add uic for qt4 to your path")
find_bin(["moc-qt4", "moc"], "QT_MOC")
find_bin(["rcc"], "QT_RCC")
find_bin(["lrelease-qt4", "lrelease"], "QT_LRELEASE")
find_bin(["lupdate-qt4", "lupdate"], "QT_LUPDATE")
env["UIC3_ST"] = "%s -o %s"
env["UIC_ST"] = "%s -o %s"
env["MOC_ST"] = "-o"
env["ui_PATTERN"] = "ui_%s.h"
env["QT_LRELEASE_FLAGS"] = ["-silent"]
env.MOCCPPPATH_ST = "-I%s"
env.MOCDEFINES_ST = "-D%s"
def listdir(self):
"""List the folder contents"""
lst = Utils.listdir(self.abspath())
lst.sort()
return lst
def configure(self):
env=self.env
opt=Options.options
qtdir=getattr(opt,'qtdir','')
qtbin=getattr(opt,'qtbin','')
qtlibs=getattr(opt,'qtlibs','')
useframework=getattr(opt,'use_qt4_osxframework',True)
paths=[]
if qtdir:
qtbin=os.path.join(qtdir,'bin')
if not qtdir:
qtdir=self.environ.get('QT4_ROOT','')
qtbin=os.path.join(qtdir,'bin')
if qtbin:
paths=[qtbin]
if not qtdir:
paths=os.environ.get('PATH','').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst=Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir='/usr/local/Trolltech/%s/'%lst[0]
qtbin=os.path.join(qtdir,'bin')
paths.append(qtbin)
cand=None
prev_ver=['4','0','0']
for qmk in['qmake-qt4','qmake4','qmake']:
try:
qmake=self.find_program(qmk,path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version=self.cmd_and_log([qmake,'-query','QT_VERSION']).strip()
except self.errors.ConfigurationError:
pass
else:
if version:
new_ver=version.split('.')
if new_ver>prev_ver:
cand=qmake
prev_ver=new_ver
if cand:
qmake=cand
else:
self.fatal('could not find qmake for qt4')
self.env.QMAKE=qmake
qtincludes=self.cmd_and_log([qmake,'-query','QT_INSTALL_HEADERS']).strip()
qtdir=self.cmd_and_log([qmake,'-query','QT_INSTALL_PREFIX']).strip()+os.sep
qtbin=self.cmd_and_log([qmake,'-query','QT_INSTALL_BINS']).strip()+os.sep
if not qtlibs:
try:
qtlibs=self.cmd_and_log([qmake,'-query','QT_INSTALL_LIBS']).strip()
except Errors.WafError:
qtlibs=os.path.join(qtdir,'lib')
def find_bin(lst,var):
for f in lst:
try:
ret=self.find_program(f,path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var]=ret
break
find_bin(['uic-qt3','uic3'],'QT_UIC3')
find_bin(['uic-qt4','uic'],'QT_UIC')
if not env['QT_UIC']:
self.fatal('cannot find the uic compiler for qt4')
try:
version=self.cmd_and_log(env['QT_UIC']+" -version 2>&1").strip()
except self.errors.ConfigurationError:
self.fatal('your uic compiler is for qt3, add uic for qt4 to your path')
version=version.replace('Qt User Interface Compiler ','')
version=version.replace('User Interface Compiler for Qt','')
if version.find(' 3.')!=-1:
self.msg('Checking for uic version','(%s: too old)'%version,False)
self.fatal('uic is too old')
self.msg('Checking for uic version','(%s)'%version)
find_bin(['moc-qt4','moc'],'QT_MOC')
find_bin(['rcc'],'QT_RCC')
find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE')
find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE')
env['UIC3_ST']='%s -o %s'
env['UIC_ST']='%s -o %s'
env['MOC_ST']='-o'
env['ui_PATTERN']='ui_%s.h'
env['QT_LRELEASE_FLAGS']=['-silent']
vars="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtWebKit Qt3Support".split()
vars_debug=[a+'_debug'for a in vars]
if not'PKG_CONFIG_PATH'in os.environ:
os.environ['PKG_CONFIG_PATH']='%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib'%(qtlibs,qtlibs)
for i in vars_debug+vars:
try:
self.check_cfg(package=i,args='--cflags --libs')
except self.errors.ConfigurationError:
pass
def process_lib(vars_,coreval):
for d in vars_:
var=d.upper()
if var=='QTCORE':
continue
value=env['LIBPATH_'+var]
if value:
core=env[coreval]
accu=[]
for lib in value:
if lib in core:
continue
accu.append(lib)
env['LIBPATH_'+var]=accu
process_lib(vars,'LIBPATH_QTCORE')
process_lib(vars_debug,'LIBPATH_QTCORE_DEBUG')
if Options.options.want_rpath:
def process_rpath(vars_,coreval):
for d in vars_:
var=d.upper()
value=env['LIBPATH_'+var]
if value:
core=env[coreval]
accu=[]
for lib in value:
if var!='QTCORE':
if lib in core:
continue
accu.append('-Wl,--rpath='+lib)
env['RPATH_'+var]=accu
process_rpath(vars,'LIBPATH_QTCORE')
process_rpath(vars_debug,'LIBPATH_QTCORE_DEBUG')
def listdir(self): lst=Utils.listdir(self.abspath()) lst.sort() return lst
def configure(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
qtlibs = getattr(opt, 'qtlibs', '')
useframework = getattr(opt, 'use_qt4_osxframework', True)
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
if not qtdir:
qtdir = self.environ.get('QT4_ROOT', '')
qtbin = os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
cand = None
prev_ver = ['4', '0', '0']
for qmk in ['qmake-qt4', 'qmake4', 'qmake']:
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log([qmake, '-query',
'QT_VERSION']).strip()
except self.errors.ConfigurationError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if cand:
qmake = cand
else:
self.fatal('could not find qmake for qt4')
self.env.QMAKE = qmake
qtincludes = self.cmd_and_log([qmake, '-query',
'QT_INSTALL_HEADERS']).strip()
qtdir = self.cmd_and_log([qmake, '-query', 'QT_INSTALL_PREFIX'
]).strip() + os.sep
qtbin = self.cmd_and_log([qmake, '-query', 'QT_INSTALL_BINS'
]).strip() + os.sep
if not qtlibs:
try:
qtlibs = self.cmd_and_log([qmake, '-query',
'QT_INSTALL_LIBS']).strip()
except Errors.WafError:
qtlibs = os.path.join(qtdir, 'lib')
def find_bin(lst, var):
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(['uic-qt3', 'uic3'], 'QT_UIC3')
find_bin(['uic-qt4', 'uic'], 'QT_UIC')
if not env['QT_UIC']:
self.fatal('cannot find the uic compiler for qt4')
try:
version = self.cmd_and_log(env['QT_UIC'] + " -version 2>&1").strip()
except self.errors.ConfigurationError:
self.fatal(
'your uic compiler is for qt3, add uic for qt4 to your path')
version = version.replace('Qt User Interface Compiler ', '')
version = version.replace('User Interface Compiler for Qt', '')
if version.find(' 3.') != -1:
self.msg('Checking for uic version', '(%s: too old)' % version, False)
self.fatal('uic is too old')
self.msg('Checking for uic version', '(%s)' % version)
find_bin(['moc-qt4', 'moc'], 'QT_MOC')
find_bin(['rcc'], 'QT_RCC')
find_bin(['lrelease-qt4', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt4', 'lupdate'], 'QT_LUPDATE')
env['UIC3_ST'] = '%s -o %s'
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
vars = "QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtWebKit Qt3Support".split(
)
vars_debug = [a + '_debug' for a in vars]
if not 'PKG_CONFIG_PATH' in os.environ:
os.environ[
'PKG_CONFIG_PATH'] = '%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib' % (
qtlibs, qtlibs)
for i in vars_debug + vars:
try:
self.check_cfg(package=i, args='--cflags --libs')
except self.errors.ConfigurationError:
pass
def process_lib(vars_, coreval):
for d in vars_:
var = d.upper()
if var == 'QTCORE':
continue
value = env['LIBPATH_' + var]
if value:
core = env[coreval]
accu = []
for lib in value:
if lib in core:
continue
accu.append(lib)
env['LIBPATH_' + var] = accu
process_lib(vars, 'LIBPATH_QTCORE')
process_lib(vars_debug, 'LIBPATH_QTCORE_DEBUG')
if Options.options.want_rpath:
def process_rpath(vars_, coreval):
for d in vars_:
var = d.upper()
value = env['LIBPATH_' + var]
if value:
core = env[coreval]
accu = []
for lib in value:
if var != 'QTCORE':
if lib in core:
continue
accu.append('-Wl,--rpath=' + lib)
env['RPATH_' + var] = accu
process_rpath(vars, 'LIBPATH_QTCORE')
process_rpath(vars_debug, 'LIBPATH_QTCORE_DEBUG')
def find_qt5_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, "qtdir", "")
qtbin = getattr(opt, "qtbin", "")
paths = []
if qtdir:
qtbin = os.path.join(qtdir, "bin")
if not qtdir:
qtdir = os.environ.get("QT5_ROOT", "")
qtbin = os.environ.get("QT5_BIN", None) or os.path.join(qtdir, "bin")
if qtbin:
paths = [qtbin]
if not qtdir:
paths = os.environ.get("PATH", "").split(os.pathsep)
paths.append("/usr/share/qt5/bin/")
try:
lst = Utils.listdir("/usr/local/Trolltech/")
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir = "/usr/local/Trolltech/%s/" % lst[0]
qtbin = os.path.join(qtdir, "bin")
paths.append(qtbin)
cand = None
prev_ver = ["5", "0", "0"]
for qmk in ("qmake-qt5", "qmake5", "qmake"):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log(qmake + ["-query", "QT_VERSION"]).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split(".")
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if not cand:
try:
self.find_program("qtchooser")
except self.errors.ConfigurationError:
pass
else:
cmd = self.env.QTCHOOSER + ["-qt=5", "-run-tool=qmake"]
try:
version = self.cmd_and_log(cmd + ["-query", "QT_VERSION"])
except self.errors.WafError:
pass
else:
cand = cmd
if cand:
self.env.QMAKE = cand
else:
self.fatal("Could not find qmake for qt5")
self.env.QT_INSTALL_BINS = qtbin = self.cmd_and_log(self.env.QMAKE + ["-query", "QT_INSTALL_BINS"]).strip() + os.sep
paths.insert(0, qtbin)
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(["uic-qt5", "uic"], "QT_UIC")
if not env.QT_UIC:
self.fatal("cannot find the uic compiler for qt5")
self.start_msg("Checking for uic version")
uicver = self.cmd_and_log(env.QT_UIC + ["-version"], output=Context.BOTH)
uicver = "".join(uicver).strip()
uicver = uicver.replace("Qt User Interface Compiler ", "").replace("User Interface Compiler for Qt", "")
self.end_msg(uicver)
if uicver.find(" 3.") != -1 or uicver.find(" 4.") != -1:
self.fatal("this uic compiler is for qt3 or qt5, add uic for qt5 to your path")
find_bin(["moc-qt5", "moc"], "QT_MOC")
find_bin(["rcc-qt5", "rcc"], "QT_RCC")
find_bin(["lrelease-qt5", "lrelease"], "QT_LRELEASE")
find_bin(["lupdate-qt5", "lupdate"], "QT_LUPDATE")
env["UIC_ST"] = "%s -o %s"
env["MOC_ST"] = "-o"
env["ui_PATTERN"] = "ui_%s.h"
env["QT_LRELEASE_FLAGS"] = ["-silent"]
env.MOCCPPPATH_ST = "-I%s"
env.MOCDEFINES_ST = "-D%s"
def listdir(self): return Utils.listdir(self.abspath())
def find_qt5_binaries(self):
"""
Detects Qt programs such as qmake, moc, uic, lrelease
"""
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
# the qt directory has been given from QT5_ROOT - deduce the qt binary path
if not qtdir:
qtdir = self.environ.get('QT5_ROOT', '')
qtbin = self.environ.get('QT5_BIN') or os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
# no qtdir, look in the path and in /usr/local/Trolltech
if not qtdir:
paths = self.environ.get('PATH', '').split(os.pathsep)
paths.extend(['/usr/share/qt5/bin', '/usr/local/lib/qt5/bin'])
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
# keep the highest version
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
# at the end, try to find qmake in the paths given
# keep the one with the highest version
cand = None
prev_ver = ['5', '0', '0']
for qmk in ('qmake-qt5', 'qmake5', 'qmake'):
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log(qmake +
['-query', 'QT_VERSION']).strip()
except self.errors.WafError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
# qmake could not be found easily, rely on qtchooser
if not cand:
try:
self.find_program('qtchooser')
except self.errors.ConfigurationError:
pass
else:
cmd = self.env.QTCHOOSER + ['-qt=5', '-run-tool=qmake']
try:
version = self.cmd_and_log(cmd + ['-query', 'QT_VERSION'])
except self.errors.WafError:
pass
else:
cand = cmd
if cand:
self.env.QMAKE = cand
else:
self.fatal('Could not find qmake for qt5')
self.env.QT_HOST_BINS = qtbin = self.cmd_and_log(
self.env.QMAKE + ['-query', 'QT_HOST_BINS']).strip()
paths.insert(0, qtbin)
def find_bin(lst, var):
if var in env:
return
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(['uic-qt5', 'uic'], 'QT_UIC')
if not env.QT_UIC:
self.fatal('cannot find the uic compiler for qt5')
self.start_msg('Checking for uic version')
uicver = self.cmd_and_log(env.QT_UIC + ['-version'], output=Context.BOTH)
uicver = ''.join(uicver).strip()
uicver = uicver.replace('Qt User Interface Compiler ',
'').replace('User Interface Compiler for Qt', '')
self.end_msg(uicver)
if uicver.find(' 3.') != -1 or uicver.find(' 4.') != -1:
self.fatal(
'this uic compiler is for qt3 or qt4, add uic for qt5 to your path'
)
find_bin(['moc-qt5', 'moc'], 'QT_MOC')
find_bin(['rcc-qt5', 'rcc'], 'QT_RCC')
find_bin(['lrelease-qt5', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt5', 'lupdate'], 'QT_LUPDATE')
env.UIC_ST = '%s -o %s'
env.MOC_ST = '-o'
env.ui_PATTERN = 'ui_%s.h'
env.QT_LRELEASE_FLAGS = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
def listdir(self): "list the directory contents" return Utils.listdir(self.abspath())
def listdir(self):
"""List the folder contents"""
return Utils.listdir(self.abspath())
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {'lib': k and k[0] or kw.get('lib', None)}
for key, value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key = key[len('boost_'):]
params[key] = value and value or kw.get(key, '')
var = kw.get('uselib_store', 'BOOST')
self.start_msg('Checking boost includes')
try:
self.env['INCLUDES_%s' % var] = self.boost_get_includes(**params)
self.env.BOOST_VERSION = self.boost_get_version(self.env['INCLUDES_%s' % var])
except WafError:
self.end_msg("not found", 'YELLOW')
raise
#self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
#self.env.BOOST_VERSION = self.boost_get_version(inc)
self.end_msg(self.env.BOOST_VERSION)
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % self.env['INCLUDES_%s' % var])
if not params['lib']:
return
self.start_msg('Checking boost libs')
try:
suffix = params.get('static', 'ST') or ''
path, libs = self.boost_get_libs(**params)
except WafError:
self.end_msg("not found", 'YELLOW')
raise
#suffix = params.get('static', None) and 'ST' or ''
#path, libs = self.boost_get_libs(**params)
self.env['%sLIBPATH_%s' % (suffix, var)] = [path]
self.env['%sLIB_%s' % (suffix, var)] = libs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % path)
Logs.pprint('CYAN', ' libs : %s' % libs)
def try_link():
if 'system' in params['lib']:
self.check_cxx(
fragment="\n".join([
'#include <boost/system/error_code.hpp>',
'int main() { boost::system::error_code c; }',
]),
use=var,
execute=False,
)
if 'thread' in params['lib']:
self.check_cxx(
fragment="\n".join([
'#include <boost/thread.hpp>',
'int main() { boost::thread t; }',
]),
use=var,
execute=False,
)
if params.get('linkage_autodetect', False):
self.start_msg("Attempting to detect boost linkage flags")
toolset = self.boost_get_toolset(kw.get('toolset', ''))
if toolset in ['vc']:
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ''):
has_dlls = True
break
if not has_dlls:
self.env['STLIBPATH_%s' % var] = [path]
self.env['STLIB_%s' % var] = libs
del self.env['LIB_%s' % var]
del self.env['LIBPATH_%s' % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (['/MD', '/EHsc'], []):
self.env.stash()
self.env["CXXFLAGS_%s" % var] += cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
e = None
break
except Errors.ConfigurationError, exc:
self.env.revert()
e = exc
if e is not None:
self.fatal("Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=e)
else:
self.fatal("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
def check_boost(self, *k, **kw):
"""
Initialize boost libraries to be used.
Keywords: you can pass the same parameters as with the command line (without "--boost-").
Note that the command line has the priority, and should preferably be used.
"""
if not self.env['CXX']:
self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
params = {
'lib': k and k[0] or kw.get('lib', None),
'stlib': kw.get('stlib', None)
}
for key, value in self.options.__dict__.items():
if not key.startswith('boost_'):
continue
key = key[len('boost_'):]
params[key] = value and value or kw.get(key, '')
var = kw.get('uselib_store', 'BOOST')
self.find_program('dpkg-architecture',
var='DPKG_ARCHITECTURE',
mandatory=False)
if self.env.DPKG_ARCHITECTURE:
deb_host_multiarch = self.cmd_and_log(
[self.env.DPKG_ARCHITECTURE[0], '-qDEB_HOST_MULTIARCH'])
BOOST_LIBS.insert(0, '/usr/lib/%s' % deb_host_multiarch.strip())
self.start_msg('Checking boost includes')
self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
versions = self.boost_get_version(inc)
self.env.BOOST_VERSION = versions[0]
self.env.BOOST_VERSION_NUMBER = int(versions[1])
self.end_msg("%d.%d.%d" % (int(versions[1]) / 100000, int(versions[1]) /
100 % 1000, int(versions[1]) % 100))
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % self.env['INCLUDES_%s' % var])
if not params['lib'] and not params['stlib']:
return
if 'static' in kw or 'static' in params:
Logs.warn('boost: static parameter is deprecated, use stlib instead.')
self.start_msg('Checking boost libs')
path, libs, stlibs = self.boost_get_libs(**params)
self.env['LIBPATH_%s' % var] = [path]
self.env['STLIBPATH_%s' % var] = [path]
self.env['LIB_%s' % var] = libs
self.env['STLIB_%s' % var] = stlibs
self.end_msg('ok')
if Logs.verbose:
Logs.pprint('CYAN', ' path : %s' % path)
Logs.pprint('CYAN', ' shared libs : %s' % libs)
Logs.pprint('CYAN', ' static libs : %s' % stlibs)
def has_shlib(lib):
return params['lib'] and lib in params['lib']
def has_stlib(lib):
return params['stlib'] and lib in params['stlib']
def has_lib(lib):
return has_shlib(lib) or has_stlib(lib)
if has_lib('thread'):
# not inside try_link to make check visible in the output
self._check_pthread_flag(k, kw)
def try_link():
if has_lib('system'):
self.check_cxx(fragment=BOOST_ERROR_CODE, use=var, execute=False)
if has_lib('thread'):
self.check_cxx(fragment=BOOST_THREAD_CODE, use=var, execute=False)
if has_lib('log'):
if not has_lib('thread'):
self.env['DEFINES_%s' % var] += ['BOOST_LOG_NO_THREADS']
if has_shlib('log'):
self.env['DEFINES_%s' % var] += ['BOOST_LOG_DYN_LINK']
self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
if params.get('linkage_autodetect', False):
self.start_msg("Attempting to detect boost linkage flags")
toolset = self.boost_get_toolset(kw.get('toolset', ''))
if toolset in ('vc', ):
# disable auto-linking feature, causing error LNK1181
# because the code wants to be linked against
self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
# if no dlls are present, we guess the .lib files are not stubs
has_dlls = False
for x in Utils.listdir(path):
if x.endswith(self.env.cxxshlib_PATTERN % ''):
has_dlls = True
break
if not has_dlls:
self.env['STLIBPATH_%s' % var] = [path]
self.env['STLIB_%s' % var] = libs
del self.env['LIB_%s' % var]
del self.env['LIBPATH_%s' % var]
# we attempt to play with some known-to-work CXXFLAGS combinations
for cxxflags in (['/MD', '/EHsc'], []):
self.env.stash()
self.env["CXXFLAGS_%s" % var] += cxxflags
try:
try_link()
self.end_msg("ok: winning cxxflags combination: %s" %
(self.env["CXXFLAGS_%s" % var]))
exc = None
break
except Errors.ConfigurationError as e:
self.env.revert()
exc = e
if exc is not None:
self.end_msg(
"Could not auto-detect boost linking flags combination, you may report it to boost.py author",
ex=exc)
self.fatal('The configuration failed')
else:
self.end_msg(
"Boost linkage flags auto-detection not implemented (needed ?) for this toolchain"
)
self.fatal('The configuration failed')
else:
self.start_msg('Checking for boost linkage')
try:
try_link()
except Errors.ConfigurationError as e:
self.end_msg(
"Could not link against boost libraries using supplied options"
)
self.fatal('The configuration failed')
self.end_msg('ok')
def find_qt4_binaries(self):
env = self.env
opt = Options.options
qtdir = getattr(opt, 'qtdir', '')
qtbin = getattr(opt, 'qtbin', '')
paths = []
if qtdir:
qtbin = os.path.join(qtdir, 'bin')
if not qtdir:
qtdir = self.environ.get('QT4_ROOT', '')
qtbin = os.path.join(qtdir, 'bin')
if qtbin:
paths = [qtbin]
if not qtdir:
paths = os.environ.get('PATH', '').split(os.pathsep)
paths.append('/usr/share/qt4/bin/')
try:
lst = Utils.listdir('/usr/local/Trolltech/')
except OSError:
pass
else:
if lst:
lst.sort()
lst.reverse()
qtdir = '/usr/local/Trolltech/%s/' % lst[0]
qtbin = os.path.join(qtdir, 'bin')
paths.append(qtbin)
cand = None
prev_ver = ['4', '0', '0']
for qmk in ['qmake-qt4', 'qmake4', 'qmake']:
try:
qmake = self.find_program(qmk, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
try:
version = self.cmd_and_log([qmake, '-query',
'QT_VERSION']).strip()
except self.errors.ConfigurationError:
pass
else:
if version:
new_ver = version.split('.')
if new_ver > prev_ver:
cand = qmake
prev_ver = new_ver
if cand:
self.env.QMAKE = cand
else:
self.fatal('Could not find qmake for qt4')
qtbin = self.cmd_and_log([self.env.QMAKE, '-query', 'QT_INSTALL_BINS'
]).strip() + os.sep
def find_bin(lst, var):
for f in lst:
try:
ret = self.find_program(f, path_list=paths)
except self.errors.ConfigurationError:
pass
else:
env[var] = ret
break
find_bin(['uic-qt3', 'uic3'], 'QT_UIC3')
find_bin(['uic-qt4', 'uic'], 'QT_UIC')
if not env['QT_UIC']:
self.fatal('cannot find the uic compiler for qt4')
try:
uicver = self.cmd_and_log(env['QT_UIC'] + " -version 2>&1").strip()
except self.errors.ConfigurationError:
self.fatal(
'this uic compiler is for qt3, add uic for qt4 to your path')
uicver = uicver.replace('Qt User Interface Compiler ',
'').replace('User Interface Compiler for Qt', '')
self.msg('Checking for uic version', '%s' % uicver)
if uicver.find(' 3.') != -1:
self.fatal(
'this uic compiler is for qt3, add uic for qt4 to your path')
find_bin(['moc-qt4', 'moc'], 'QT_MOC')
find_bin(['rcc'], 'QT_RCC')
find_bin(['lrelease-qt4', 'lrelease'], 'QT_LRELEASE')
find_bin(['lupdate-qt4', 'lupdate'], 'QT_LUPDATE')
env['UIC3_ST'] = '%s -o %s'
env['UIC_ST'] = '%s -o %s'
env['MOC_ST'] = '-o'
env['ui_PATTERN'] = 'ui_%s.h'
env['QT_LRELEASE_FLAGS'] = ['-silent']
env.MOCCPPPATH_ST = '-I%s'
env.MOCDEFINES_ST = '-D%s'
def listdir(self):
lst = Utils.listdir(self.abspath())
lst.sort()
return lst
def run(self):
env = self.env
gen = self.generator
bld = gen.bld
zpy = bld.zpy
out = self.outputs[0].parent
dist = self.dist
signode = self.signode
out_path = out.abspath()
bld_path = bld.bldnode.abspath()
source_url = dist.source_url or ''
url = urlparse.urlsplit(source_url)
# normalize initially to dist.key
name = pth.basename(url.path).lower() or dist.key
# ensure sdist filename matches dist.name!
# otherwise dist.name != dist.metadata.name if the object was created
# from a filename, even if metadata is loaded later!
#FIXME: upstream fix to above...
name = name.replace(dist.key, dist.name, 1)
if dist.name not in name:
# probably a hash
ext = name[name.find('.'):]
if len(ext) > 1:
name = dist.metadata.name_and_version + ext
# no raison other than consistency
if name.endswith('.tgz'):
name = name[:-4] + '.tar.gz'
path = pth.join(zpy.top_xsrc, name)
meta = path + '.' + metadata.METADATA_FILENAME
meta_alt = pth.join(url.path, metadata.METADATA_FILENAME)
meta_out = pth.join(out_path, metadata.METADATA_FILENAME)
if url.scheme and url.path and url.path != path:
path, message = urllib.urlretrieve(url.geturl(), path)
if url.path and pth.isdir(url.path):
try:
git_dir = subprocess.check_output(
['git', 'rev-parse', '--show-toplevel'], cwd=url.path,
).strip()
# avoid checking out the wrong repo due to nesting; ie. don't
# checkout someone's dotfile repo just because they happen to
# technically be "under" it
if pth.abspath(git_dir) == pth.abspath(url.path):
git_dir = subprocess.check_output(
args=['git', 'rev-parse', '--git-dir'], cwd=url.path,
)
git_dir = pth.join(url.path, git_dir.strip())
else:
git_dir = None
except subprocess.CalledProcessError:
git_dir = None
if git_dir:
if not pth.exists(out_path):
os.mkdir(out_path)
subprocess.call([
'git',
'--git-dir={0}'.format(git_dir),
'--work-tree={0}'.format(out_path),
'checkout-index',
'--all',
'--quiet',
'--force',
])
if pth.exists(meta):
shutil.copy2(meta, meta_out)
elif pth.exists(meta_alt):
shutil.copy2(meta_alt, meta_out)
else:
# symlink local dist checkout
local_path = pth.join(zpy.top, url.path)
local_path = pth.abspath(local_path)
local_sym = pth.relpath(local_path, bld_path)
try:
# clear broken symlinks
os.unlink(out_path)
except OSError:
pass
finally:
os.symlink(local_sym, out_path)
elif pth.isfile(path):
_zip = ('.zip',)
_whl = ('.whl',)
_tar = tuple(
set(distlib.util.ARCHIVE_EXTENSIONS) - set(_zip + _whl)
)
if path.endswith(_whl):
dist.metadata = wheel.Wheel(path).metadata
dist_dir = pth.join(out_path, 'dist')
Utils.check_dir(dist_dir)
self.outputs[0].write(
json.dumps(
dist.metadata.dictionary,
ensure_ascii=True,
sort_keys=True,
indent=2,
))
whl_dst = pth.join(dist_dir, pth.basename(path))
whl_sym = pth.relpath(path, dist_dir)
if not pth.exists(whl_dst):
os.symlink(whl_sym, whl_dst)
else:
if pth.isfile(meta):
#TODO: needs to use zpy.dist
dist.metadata = metadata.Metadata(path=meta)
else:
pydist = normalize_pydist(dist.metadata.dictionary)
pydist.update(source_url=pth.relpath(path, zpy.top))
with codecs.open(meta, 'w', 'utf-8') as fp:
json.dump(
pydist,
fp=fp,
ensure_ascii=True,
sort_keys=True,
indent=2,
)
dist.metadata._legacy = None
dist.metadata._data = pydist
sig_path = signode.abspath()
for sfx, cmd in (
(_tar, '{env.TAR}\0-C\0{sig_path}\0-xf\0{path}\0'),
(_zip, '{env.UNZIP}\0-q\0-o\0-d\0{sig_path}\0{path}\0'),
(None, None),
):
if sfx is None:
distlib.util.unarchive(path, bld_path)
break
try:
cmd = cmd.format(**locals())
cmd = cmd.strip('\0').split('\0')
except AttributeError:
continue
rc = self.exec_command(cmd, env=env.env)
if rc == 0:
if not pth.exists(out_path):
tmp = signode.make_node(
Utils.listdir(signode.abspath())
)
os.rename(tmp.abspath(), out_path)
break
shutil.copy2(meta, pth.join(out_path, metadata.METADATA_FILENAME))
if dist.key == 'python':
lib = pth.join(out_path, 'Lib')
zippy_src = pth.join(zpy.top, 'zippy')
zippy_dst = pth.join(lib, 'zippy')
zippy_sym = pth.relpath(zippy_src, lib)
if not pth.lexists(zippy_dst):
os.symlink(zippy_sym, zippy_dst)
incl_src = pth.join(out_path, 'Include')
incl_dst = pth.join(zpy.o_inc, 'python'+dist.version[0:3])
incl_sym = pth.relpath(incl_src, zpy.o_inc)
if not pth.lexists(incl_dst):
os.symlink(incl_sym, incl_dst)
pyconfig = pth.join(out_path, 'Include', 'pyconfig.h')
if not pth.lexists(pyconfig):
os.symlink('../pyconfig.h', pyconfig)
return 0
