def getGeneralFlags(self, conf): flags = super(GccBasicFlags, self).getGeneralFlags(conf) flags['CXXFLAGS'] += ['-std=c++14'] if Utils.unversioned_sys_platform() == 'linux': flags['LINKFLAGS'] += ['-fuse-ld=gold'] elif Utils.unversioned_sys_platform() == 'freebsd': flags['LINKFLAGS'] += ['-fuse-ld=lld'] return flags
def getGeneralFlags(self, conf): flags = super(ClangFlags, self).getGeneralFlags(conf) if Utils.unversioned_sys_platform() == 'darwin' and self.getCompilerVersion(conf) >= (9, 0, 0): # Bug #4296 flags['CXXFLAGS'] += [['-isystem', '/usr/local/include'], # for Homebrew ['-isystem', '/opt/local/include']] # for MacPorts if Utils.unversioned_sys_platform() == 'freebsd': flags['CXXFLAGS'] += [['-isystem', '/usr/local/include']] # Bug #4790 return flags
def get_test_env(self): """ In general, tests may require any library built anywhere in the project. Override this method if fewer paths are needed """ try: fu = getattr(self.generator.bld, 'all_test_paths') except AttributeError: # this operation may be performed by at most #maxjobs fu = os.environ.copy() lst = [] for g in self.generator.bld.groups: for tg in g: if getattr(tg, 'link_task', None): s = tg.link_task.outputs[0].parent.abspath() if s not in lst: lst.append(s) if Utils.is_win32: self.add_path(fu, lst, 'PATH') elif Utils.unversioned_sys_platform() == 'darwin': self.add_path(fu, lst, 'DYLD_LIBRARY_PATH') self.add_path(fu, lst, 'LD_LIBRARY_PATH') else: self.add_path(fu, lst, 'LD_LIBRARY_PATH') self.generator.bld.all_test_paths = fu return fu
def __init__(self, **kw): super(OptionsContext, self).__init__(**kw) self.parser = opt_parser(self) """Instance of :py:class:`waflib.Options.opt_parser`""" self.option_groups = {} jobs = self.jobs() p = self.add_option color = os.environ.get('NOCOLOR', '') and 'no' or 'auto' if os.environ.get('CLICOLOR', '') == '0': color = 'no' elif os.environ.get('CLICOLOR_FORCE', '') == '1': color = 'yes' p('-c', '--color', dest='colors', default=color, action='store', help='whether to use colors (yes/no/auto) [default: auto]', choices=('yes', 'no', 'auto')) p('-j', '--jobs', dest='jobs', default=jobs, type='int', help='amount of parallel jobs (%r)' % jobs) p('-k', '--keep', dest='keep', default=0, action='count', help='continue despite errors (-kk to try harder)') p('-v', '--verbose', dest='verbose', default=0, action='count', help='verbosity level -v -vv or -vvv [default: 0]') p('--zones', dest='zones', default='', action='store', help='debugging zones (task_gen, deps, tasks, etc)') p('--profile', dest='profile', default='', action='store_true', help=optparse.SUPPRESS_HELP) gr = self.add_option_group('Configuration options') self.option_groups['configure options'] = gr gr.add_option('-o', '--out', action='store', default='', help='build dir for the project', dest='out') gr.add_option('-t', '--top', action='store', default='', help='src dir for the project', dest='top') gr.add_option('--no-lock-in-run', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_run') gr.add_option('--no-lock-in-out', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_out') gr.add_option('--no-lock-in-top', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_top') default_prefix = getattr(Context.g_module, 'default_prefix', os.environ.get('PREFIX')) if not default_prefix: if Utils.unversioned_sys_platform() == 'win32': d = tempfile.gettempdir() default_prefix = d[0].upper() + d[1:] # win32 preserves the case, but gettempdir does not else: default_prefix = '/usr/local/' gr.add_option('--prefix', dest='prefix', default=default_prefix, help='installation prefix [default: %r]' % default_prefix) gr.add_option('--bindir', dest='bindir', help='bindir') gr.add_option('--libdir', dest='libdir', help='libdir') gr = self.add_option_group('Build and installation options') self.option_groups['build and install options'] = gr gr.add_option('-p', '--progress', dest='progress_bar', default=0, action='count', help= '-p: progress bar; -pp: ide output') gr.add_option('--targets', dest='targets', default='', action='store', help='task generators, e.g. "target1,target2"') gr = self.add_option_group('Step options') self.option_groups['step options'] = gr gr.add_option('--files', dest='files', default='', action='store', help='files to process, by regexp, e.g. "*/main.c,*/test/main.o"') default_destdir = os.environ.get('DESTDIR', '') gr = self.add_option_group('Installation and uninstallation options') self.option_groups['install/uninstall options'] = gr gr.add_option('--destdir', help='installation root [default: %r]' % default_destdir, default=default_destdir, dest='destdir') gr.add_option('-f', '--force', dest='force', default=False, action='store_true', help='force file installation') gr.add_option('--distcheck-args', metavar='ARGS', help='arguments to pass to distcheck', default=None, action='store')
def getGeneralFlags(self, conf): flags = super(ClangFlags, self).getGeneralFlags(conf) flags['CXXFLAGS'] += ['-std=c++11'] if Utils.unversioned_sys_platform() == 'darwin': flags['CXXFLAGS'] += ['-stdlib=libc++'] flags['LINKFLAGS'] += ['-stdlib=libc++'] return flags
def configure(self): self.find_qt5_binaries() self.set_qt5_libs_to_check() self.set_qt5_defines() self.find_qt5_libraries() self.add_qt5_rpath() self.simplify_qt5_libs() if not has_xml: Logs.error('No xml.sax support was found, rcc dependencies will be incomplete!') frag='#include <QApplication>\nint main(int argc, char **argv) {return 0;}\n' uses='QT5CORE QT5WIDGETS QT5GUI' for flag in[[],'-fPIE','-fPIC','-std=c++11',['-std=c++11','-fPIE'],['-std=c++11','-fPIC']]: msg='See if Qt files compile ' if flag: msg+='with %s'%flag try: self.check(features='qt5 cxx',use=uses,uselib_store='qt5',cxxflags=flag,fragment=frag,msg=msg) except self.errors.ConfigurationError: pass else: break else: self.fatal('Could not build a simple Qt application') from waflib import Utils if Utils.unversioned_sys_platform()=='freebsd': frag='#include <QApplication>\nint main(int argc, char **argv) { QApplication app(argc, argv); return NULL != (void*) (&app);}\n' try: self.check(features='qt5 cxx cxxprogram',use=uses,fragment=frag,msg='Can we link Qt programs on FreeBSD directly?') except self.errors.ConfigurationError: self.check(features='qt5 cxx cxxprogram',use=uses,uselib_store='qt5',libpath='/usr/local/lib',fragment=frag,msg='Is /usr/local/lib required?')
def run(self): """Execute the test. The execution is always successful, but the results are stored on ``self.generator.bld.utest_results`` for postprocessing. """ self.testdriver_node = self.inputs[0] try: fu = getattr(self.generator.bld, "all_test_paths") except AttributeError: # this operation may be performed by at most #maxjobs fu = os.environ.copy() lst = [] for g in self.generator.bld.groups: for tg in g: if getattr(tg, "link_task", None): s = tg.link_task.outputs[0].parent.abspath() if s not in lst: lst.append(s) def add_path(dct, path, var): dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, "")]) if Utils.is_win32: add_path(fu, lst, "PATH") elif Utils.unversioned_sys_platform() == "darwin": add_path(fu, lst, "DYLD_LIBRARY_PATH") add_path(fu, lst, "LD_LIBRARY_PATH") else: add_path(fu, lst, "LD_LIBRARY_PATH") self.generator.bld.all_test_paths = fu cwd = self.testdriver_node.parent.abspath() testcmd = self.get_testcmd() start_time = time.time() proc = Utils.subprocess.Popen( testcmd, cwd=cwd, env=fu, stderr=Utils.subprocess.STDOUT, stdout=Utils.subprocess.PIPE ) stdout = proc.communicate()[0] end_time = time.time() if not isinstance(stdout, str): stdout = stdout.decode(sys.stdout.encoding or "iso8859-1") tup = (self.testdriver_node, proc.returncode, stdout, end_time - start_time, self.generator.source[0]) self.generator.utest_result = tup testlock.acquire() try: bld = self.generator.bld Logs.debug("ut: %r", tup) try: bld.utest_results.append(tup) except AttributeError: bld.utest_results = [tup] finally: testlock.release()
def cc_load_tools(conf): """ Load the c tool """ if not conf.env.DEST_OS: conf.env.DEST_OS = Utils.unversioned_sys_platform() conf.load('c')
def cxx_load_tools(conf): """ Loads the Waf c++ extensions """ if not conf.env.DEST_OS: conf.env.DEST_OS = Utils.unversioned_sys_platform() conf.load('cxx')
def _use_incredibuild(ctx, section_name, option_name, value, verification_fn): """ If Incredibuild should be used, check for required packages """ if not ctx.is_option_true('ask_for_user_input'): (isValid, warning, error) = verification_fn(ctx, option_name, value) if not isValid: return 'False' return value # GUI if not ctx.is_option_true('console_mode'): return ctx.gui_get_attribute(section_name, option_name, value) if not value or value != 'True': return value if not Utils.unversioned_sys_platform() == 'win32': return value _incredibuild_disclaimer(ctx) ctx.start_msg('Incredibuild Licence Check') (res, warning, error) = verification_fn(ctx, option_name, value) if not res: if warning: Logs.warn(warning) if error: ctx.end_msg(error, color='YELLOW') return 'False' ctx.end_msg('ok') return value
def _defaultValue( _VALUES ): PLATFORM = Utils.unversioned_sys_platform() if PLATFORM in _VALUES: return _VALUES[ PLATFORM ] return None
def configure_paths(ctx): """Setup blender paths""" # Get the username user = getuser() _platform = Utils.unversioned_sys_platform() config_path = {"user": "", "system": ""} if _platform.startswith("linux"): config_path["user"] = "******" % user config_path["system"] = "/usr/share/blender/" elif _platform == "darwin": # MAC OS X config_path["user"] = "******" % user config_path["system"] = "/Library/Application Support/Blender/" elif Utils.is_win32: # Windows appdata_path = ctx.getenv("APPDATA").replace("\\", "/") homedrive = ctx.getenv("HOMEDRIVE").replace("\\", "/") config_path["user"] = "******" % appdata_path config_path["system"] = "%sAll Users/AppData/Roaming/Blender Foundation/Blender/" % homedrive else: ctx.fatal("Unsupported platform. " "Available platforms: Linux, OSX, MS-Windows.") blender_version = ctx.env["BLENDER_VERSION"] config_path["user"] += blender_version + "/" config_path["system"] += blender_version + "/" ctx.env["BLENDER_CONFIG_DIR"] = os.path.abspath(config_path["user"]) if ctx.options.directory_system: ctx.env["BLENDER_CONFIG_DIR"] = config_path["system"] ctx.env["BLENDER_ADDONS_DIR"] = os.path.join(ctx.env["BLENDER_CONFIG_DIR"], "scripts/addons") Utils.check_dir(ctx.env["BLENDER_ADDONS_DIR"])
def getGeneralFlags(self, conf): flags = super(ClangFlags, self).getGeneralFlags(conf) flags["CXXFLAGS"] += ["-std=c++11"] if Utils.unversioned_sys_platform() == "darwin": flags["CXXFLAGS"] += ["-stdlib=libc++"] flags["LINKFLAGS"] += ["-stdlib=libc++"] return flags
def _defaultValue( _values ): PLATFORM = Utils.unversioned_sys_platform() if PLATFORM in _values: return _values[ PLATFORM ] return None
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 configure_env(self, cfg, env): super(sitl, self).configure_env(cfg, env) env.DEFINES.update( CONFIG_HAL_BOARD = 'HAL_BOARD_SITL', CONFIG_HAL_BOARD_SUBTYPE = 'HAL_BOARD_SUBTYPE_NONE', AP_SCRIPTING_CHECKS = 1, # SITL should always do runtime scripting checks ) env.CXXFLAGS += [ '-Werror=float-equal' ] if not cfg.env.DEBUG: env.CXXFLAGS += [ '-O3', ] env.LIB += [ 'm', ] cfg.check_librt(env) env.LINKFLAGS += ['-pthread',] env.AP_LIBRARIES += [ 'AP_HAL_SITL', 'SITL', ] if cfg.options.enable_sfml: if not cfg.check_SFML(env): cfg.fatal("Failed to find SFML libraries") env.CXXFLAGS += ['-DWITH_SITL_OSD','-DOSD_ENABLED=ENABLED','-DHAL_HAVE_AP_ROMFS_EMBEDDED_H'] import fnmatch for f in os.listdir('libraries/AP_OSD/fonts'): if fnmatch.fnmatch(f, "font*bin"): env.ROMFS_FILES += [(f,'libraries/AP_OSD/fonts/'+f)] if cfg.options.enable_sfml_audio: if not cfg.check_SFML_Audio(env): cfg.fatal("Failed to find SFML Audio libraries") env.CXXFLAGS += ['-DWITH_SITL_TONEALARM'] if cfg.options.sitl_flash_storage: env.CXXFLAGS += ['-DSTORAGE_USE_FLASH=1'] if cfg.env.DEST_OS == 'cygwin': env.LIB += [ 'winmm', ] if Utils.unversioned_sys_platform() == 'cygwin': env.CXXFLAGS += ['-DCYGWIN_BUILD'] if 'clang++' in cfg.env.COMPILER_CXX: print("Disabling SLP for clang++") env.CXXFLAGS += [ '-fno-slp-vectorize' # compiler bug when trying to use SLP ]
def init_dirs(self): # Waf calls this function to set the output directory. # Waf sets the output dir in the following order # 1) Check whether the -o option has been specified # 2) Check whether the wscript has an out variable defined # 3) Fall-back and use the name of the lock-file # # In order to not surprise anybody we will disallow the out variable # but allow our output dir to be overwritten by using the -o option assert(getattr(Context.g_module, Context.OUT, None) is None) if not Options.options.out: if self.has_tool_option('cxx_mkspec'): mkspec = self.get_tool_option('cxx_mkspec') self.out_dir = os.path.join("build", mkspec) else: build_platform = Utils.unversioned_sys_platform() self.out_dir = os.path.join("build", build_platform) # Use the _debug postfix for debug builds if self.has_tool_option('cxx_debug'): self.out_dir += '_debug' super(ToolchainConfigurationContext, self).init_dirs()
def find_qt5_libraries(self): env = self.env qtincludes = self.environ.get('QT5_INCLUDES') or self.cmd_and_log(env.QMAKE + ['-query', 'QT_INSTALL_HEADERS']).strip() force_static = self.environ.get('QT5_FORCE_STATIC') try: if self.environ.get('QT5_XCOMPILE'): self.fatal('QT5_XCOMPILE Disables pkg-config detection') self.check_cfg(atleast_pkgconfig_version='0.1') except self.errors.ConfigurationError: for i in self.qt5_vars: uselib = i.upper() if Utils.unversioned_sys_platform() == 'darwin': # Since at least qt 4.7.3 each library locates in separate directory fwk = i.replace('Qt5', 'Qt') frameworkName = fwk + '.framework' qtDynamicLib = os.path.join(env.QTLIBS, frameworkName, fwk) if os.path.exists(qtDynamicLib): env.append_unique('FRAMEWORK_' + uselib, fwk) env.append_unique('FRAMEWORKPATH_' + uselib, env.QTLIBS) self.msg('Checking for %s' % i, qtDynamicLib, 'GREEN') else: self.msg('Checking for %s' % i, False, 'YELLOW') env.append_unique('INCLUDES_' + uselib, os.path.join(env.QTLIBS, frameworkName, 'Headers')) else: ret = self.find_single_qt5_lib(i, uselib, env.QTLIBS, qtincludes, force_static) if not force_static and not ret: ret = self.find_single_qt5_lib(i, uselib, env.QTLIBS, qtincludes, True) self.msg('Checking for %s' % i, ret, 'GREEN' if ret else 'YELLOW') else: path = '%s:%s:%s/pkgconfig:/usr/lib/qt5/lib/pkgconfig:/opt/qt5/lib/pkgconfig:/usr/lib/qt5/lib:/opt/qt5/lib' % ( self.environ.get('PKG_CONFIG_PATH', ''), env.QTLIBS, env.QTLIBS) for i in self.qt5_vars: self.check_cfg(package=i, args='--cflags --libs', mandatory=False, force_static=force_static, pkg_config_path=path)
def configure(ctx): ctx.load('bdeunittest', tooldir = os.path.join('tools', 'waf', 'bde')) ufid = _make_ufid_from_options(ctx.options) platform = Utils.unversioned_sys_platform() if platform == 'win32': if '64' in ufid.ufid: ctx.options.msvc_targets = 'x64' else: ctx.options.msvc_targets = 'x86' bde_configure = BdeWafConfigure(ctx) bde_configure.load_metadata() bde_configure.configure_external_libs(ufid) ctx.load('compiler_cxx') uplid = _make_uplid_from_context(ctx) ctx.msg('os_type', uplid.uplid['os_type']) ctx.msg('os_name', uplid.uplid['os_name']) ctx.msg('cpu_type', uplid.uplid['cpu_type']) ctx.msg('os_ver', uplid.uplid['os_ver']) ctx.msg('comp_type', uplid.uplid['comp_type']) ctx.msg('comp_ver', uplid.uplid['comp_ver']) ctx.msg('uplid', uplid) ctx.msg('ufid', '_'.join(ufid.ufid)) ctx.msg('prefix', ctx.options.prefix) bde_configure.configure_options(uplid) bde_configure.save()
def _make_uplid_from_context(ctx): platform = Utils.unversioned_sys_platform() from bdeoptions import get_linux_osinfo, get_aix_osinfo, get_sunos_osinfo, get_darwin_osinfo, get_windows_osinfo osinfo_getters = { 'linux': get_linux_osinfo, 'aix': get_aix_osinfo, 'sunos': get_sunos_osinfo, 'darwin': get_darwin_osinfo, 'win32': get_windows_osinfo } comp_getters = { 'linux': _get_linux_comp, 'aix': _get_aix_comp, 'sunos': _get_sunos_comp, 'win32': _get_windows_comp, 'darwin': _get_darwin_comp } if platform not in osinfo_getters: ctx.fatal('Unsupported platform: %s' % platform) (os_type, os_name, os_ver) = osinfo_getters[platform](ctx) (cpu_type, cxx, cxx_version) = _sanitize_comp(ctx, comp_getters[platform](ctx)) uplid = Uplid(os_type, os_name, cpu_type, os_ver, cxx, cxx_version) return uplid
def _check_pthread_flag(self, *k, **kw): ''' Computes which flags should be added to CXXFLAGS and LINKFLAGS to compile in multi-threading mode Yes, we *need* to put the -pthread thing in CPPFLAGS because with GCC3, boost/thread.hpp will trigger a #error if -pthread isn't used: boost/config/requires_threads.hpp:47:5: #error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)" Based on _BOOST_PTHREAD_FLAG(): https://github.com/tsuna/boost.m4/blob/master/build-aux/boost.m4 ''' var = kw.get('uselib_store', 'BOOST') self.start_msg('Checking the flags needed to use pthreads') # The ordering *is* (sometimes) important. Some notes on the # individual items follow: # (none): in case threads are in libc; should be tried before -Kthread and # other compiler flags to prevent continual compiler warnings # -lpthreads: AIX (must check this before -lpthread) # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) # -llthread: LinuxThreads port on FreeBSD (also preferred to -pthread) # -pthread: GNU Linux/GCC (kernel threads), BSD/GCC (userland threads) # -pthreads: Solaris/GCC # -mthreads: MinGW32/GCC, Lynx/GCC # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it # doesn't hurt to check since this sometimes defines pthreads too; # also defines -D_REENTRANT) # ... -mt is also the pthreads flag for HP/aCC # -lpthread: GNU Linux, etc. # --thread-safe: KAI C++ if Utils.unversioned_sys_platform() == "sunos": # On Solaris (at least, for some versions), libc contains stubbed # (non-functional) versions of the pthreads routines, so link-based # tests will erroneously succeed. (We need to link with -pthreads/-mt/ # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather # a function called by this macro, so we could check for that, but # who knows whether they'll stub that too in a future libc.) So, # we'll just look for -pthreads and -lpthread first: boost_pthread_flags = ["-pthreads", "-lpthread", "-mt", "-pthread"] else: boost_pthread_flags = ["", "-lpthreads", "-Kthread", "-kthread", "-llthread", "-pthread", "-pthreads", "-mthreads", "-lpthread", "--thread-safe", "-mt"] for boost_pthread_flag in boost_pthread_flags: try: self.env.stash() self.env['CXXFLAGS_%s' % var] += [boost_pthread_flag] self.env['LINKFLAGS_%s' % var] += [boost_pthread_flag] self.check_cxx(code=PTHREAD_CODE, msg=None, use=var, execute=False) self.end_msg(boost_pthread_flag) return except self.errors.ConfigurationError: self.env.revert() self.end_msg('None')
def skip_unbuildable_variant(self): # skip variants that cannot be built on this OS for k in Options.commands: a, _, b = k.partition('_') if b in Context.g_module.variants: c, _, _ = b.partition('_') if c != Utils.unversioned_sys_platform(): Options.commands.remove(k)
def gxx_modifier_platform(conf): # * set configurations specific for a platform. # * the destination platform is detected automatically by looking at the macros the compiler predefines, # and if it's not recognised, it fallbacks to sys.platform. dest_os = conf.env['DEST_OS'] or Utils.unversioned_sys_platform() gxx_modifier_func = globals().get('gxx_modifier_' + dest_os) if gxx_modifier_func: gxx_modifier_func(conf)
def options(opt): global mpi_c_compiler build_platform=Utils.unversioned_sys_platform() test_for_compiler=' '.join(mpi_c_compilers) mpicc_compiler_opts=opt.add_option_group("MPI C Compiler Options") mpicc_compiler_opts.add_option('--check-mpi-c-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following MPI C-Compiler will be checked by default: "%s"'%(build_platform,test_for_compiler),dest="check_mpi_c_compiler") for x in test_for_compiler.split(): opt.load('%s'%x, tooldir='waf-tools')
def configure(conf): '''Create and configure C/C++ build environment(s). :param conf: configuration context :type conf: waflib.Configure.ConfigurationContext ''' conf.check_waf_version(mini='1.7.6', maxi='1.9.0') conf.env.PREFIX = str(conf.env.PREFIX).replace('\\', '/') conf.env.CCENVINI = getattr(conf.options, CCENV_OPT) conf.env.CCENV = get_ccenv(conf.env.CCENVINI) conf.env.HOST = Utils.unversioned_sys_platform() c = c_compiler.copy() cxx = cxx_compiler.copy() host = Utils.unversioned_sys_platform() if host not in c_compiler: host = 'default' configure_variants(conf, host) configure_host(conf, host, c, cxx)
def getOptimizedFlags(self, conf): flags = super(ClangFlags, self).getOptimizedFlags(conf) version = tuple(int(i) for i in conf.env['CC_VERSION']) if Utils.unversioned_sys_platform() == 'darwin' and version < (7, 0, 0): flags['CXXFLAGS'] += ['-Wno-missing-field-initializers'] flags['CXXFLAGS'] += ['-fcolor-diagnostics', '-Wno-unused-local-typedef', # Bugs #2657 and #3209 ] return flags
def set_macosx_deployment_target(self): """ see WAF issue 285 and also and also http://trac.macports.org/ticket/17059 """ if self.env['MACOSX_DEPLOYMENT_TARGET']: os.environ['MACOSX_DEPLOYMENT_TARGET'] = self.env['MACOSX_DEPLOYMENT_TARGET'] elif 'MACOSX_DEPLOYMENT_TARGET' not in os.environ: if Utils.unversioned_sys_platform() == 'darwin': os.environ['MACOSX_DEPLOYMENT_TARGET'] = '.'.join(platform.mac_ver()[0].split('.')[:2])
def options(opt): build_platform=Utils.unversioned_sys_platform() detected_platform=Options.platform possible_compiler_list=__list_possible_compiler(detected_platform) test_for_compiler=' '.join(possible_compiler_list) fortran_compiler_opts=opt.add_option_group("Fortran Compiler Options") fortran_compiler_opts.add_option('--check-fortran-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following Fortran Compiler will be checked by default: "%s"'%(detected_platform,test_for_compiler),dest="check_fc") for compiler in test_for_compiler.split(): opt.load('%s'%compiler)
def set_macosx_deployment_target(self): """ see WAF issue 285 and also and also http://trac.macports.org/ticket/17059 """ if self.env["MACOSX_DEPLOYMENT_TARGET"]: os.environ["MACOSX_DEPLOYMENT_TARGET"] = self.env["MACOSX_DEPLOYMENT_TARGET"] elif "MACOSX_DEPLOYMENT_TARGET" not in os.environ: if Utils.unversioned_sys_platform() == "darwin": os.environ["MACOSX_DEPLOYMENT_TARGET"] = ".".join(platform.mac_ver()[0].split(".")[:2])
def options(opt): global cxx_compiler build_platform=Utils.unversioned_sys_platform() possible_compiler_list=cxx_compiler[build_platform in cxx_compiler and build_platform or'default'] test_for_compiler=' '.join(possible_compiler_list) cxx_compiler_opts=opt.add_option_group('C++ Compiler Options') cxx_compiler_opts.add_option('--check-cxx-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following C++ Compiler will be checked by default: "%s"'%(build_platform,test_for_compiler),dest="check_cxx_compiler") for x in test_for_compiler.split(): opt.load('%s'%x)
def run(self): """ Execute the test. The execution is always successful, but the results are stored on ``self.generator.bld.utest_results`` for postprocessing. """ filename = self.inputs[0].abspath() self.ut_exec = getattr(self.generator, 'ut_exec', [filename]) if getattr(self.generator, 'ut_fun', None): # FIXME waf 1.8 - add a return statement here? self.generator.ut_fun(self) try: fu = getattr(self.generator.bld, 'all_test_paths') except AttributeError: # this operation may be performed by at most #maxjobs fu = os.environ.copy() lst = [] for g in self.generator.bld.groups: for tg in g: if getattr(tg, 'link_task', None): s = tg.link_task.outputs[0].parent.abspath() if s not in lst: lst.append(s) def add_path(dct, path, var): dct[var] = os.pathsep.join( Utils.to_list(path) + [os.environ.get(var, '')]) if Utils.is_win32: add_path(fu, lst, 'PATH') elif Utils.unversioned_sys_platform() == 'darwin': add_path(fu, lst, 'DYLD_LIBRARY_PATH') add_path(fu, lst, 'LD_LIBRARY_PATH') else: add_path(fu, lst, 'LD_LIBRARY_PATH') self.generator.bld.all_test_paths = fu cwd = (getattr(self.generator, 'ut_cwd', '') or self.inputs[0].parent.abspath()) testcmd = getattr(Options.options, 'testcmd', False) if testcmd: ut_exec = self.ut_exec[0] self.ut_exec = (testcmd % ut_exec).split(' ') if Options.options.test_junit: self.ut_exec += ('--junit=%s-junit.xml' % ut_exec).split(' ') proc = Utils.subprocess.Popen(self.ut_exec, cwd=cwd, env=fu, stderr=Utils.subprocess.STDOUT, stdout=Utils.subprocess.PIPE) stdout = proc.communicate()[0] if stdout: stdout = stdout.decode(sys.stdout.encoding or 'iso8859-1') tup = (filename, proc.returncode, stdout) self.generator.utest_result = tup testlock.acquire() try: bld = self.generator.bld Logs.debug("ut: %r", tup) try: bld.utest_results.append(tup) except AttributeError: bld.utest_results = [tup] finally: testlock.release()
last_build_engine_version_node.write(ctx.engine_root_version) @conf def is_engine_local(conf): """ Determine if we are within an engine path :param conf: The configuration context :return: True if we are running from the engine folder, False if not """ current_dir = os.path.normcase(os.path.abspath(os.path.curdir)) engine_dir = os.path.normcase(os.path.abspath(conf.engine_path)) return current_dir == engine_dir # Create Build Context Commands for multiple platforms/configurations for platform in PLATFORMS[Utils.unversioned_sys_platform()]: for configuration in CONFIGURATIONS: platform_config_key = platform + '_' + configuration # for platform/for configuration generates invalid configurations # if a filter exists, don't generate all combinations if platform in PLATFORM_CONFIGURATION_FILTER: if configuration not in PLATFORM_CONFIGURATION_FILTER[platform]: # Dont add the command but track it to report that this platform + configuration is explicitly not supported (yet) UNSUPPORTED_PLATFORM_CONFIGURATIONS.add(platform_config_key) continue # Create new class to execute clean with variant name = CleanContext.__name__.replace('Context','').lower() class tmp_clean(CleanContext): cmd = name + '_' + platform_config_key variant = platform_config_key
def set_bundle(self): """Mac-specific pyext extension that enables bundles from c_osx.py""" if Utils.unversioned_sys_platform() == 'darwin': self.mac_bundle = True
def configure(self): """ Besides the configuration options, the environment variable QT5_ROOT may be used to give the location of the qt5 libraries (absolute path). The detection uses the program ``pkg-config`` through :py:func:`waflib.Tools.config_c.check_cfg` """ self.find_qt5_binaries() self.set_qt5_libs_dir() self.set_qt5_libs_to_check() self.set_qt5_defines() self.find_qt5_libraries() self.add_qt5_rpath() self.simplify_qt5_libs() # warn about this during the configuration too if not has_xml: Logs.error( 'No xml.sax support was found, rcc dependencies will be incomplete!' ) if 'COMPILER_CXX' not in self.env: self.fatal( 'No CXX compiler defined: did you forget to configure compiler_cxx first?' ) # Qt5 may be compiled with '-reduce-relocations' which requires dependent programs to have -fPIE or -fPIC? frag = '#include <QApplication>\nint main(int argc, char **argv) {return 0;}\n' uses = 'QT5CORE QT5WIDGETS QT5GUI' for flag in [[], '-fPIE', '-fPIC', '-std=c++11', ['-std=c++11', '-fPIE'], ['-std=c++11', '-fPIC']]: msg = 'See if Qt files compile ' if flag: msg += 'with %s' % flag try: self.check(features='qt5 cxx', use=uses, uselib_store='qt5', cxxflags=flag, fragment=frag, msg=msg) except self.errors.ConfigurationError: pass else: break else: self.fatal('Could not build a simple Qt application') # FreeBSD does not add /usr/local/lib and the pkg-config files do not provide it either :-/ if Utils.unversioned_sys_platform() == 'freebsd': frag = '#include <QApplication>\nint main(int argc, char **argv) { QApplication app(argc, argv); return NULL != (void*) (&app);}\n' try: self.check(features='qt5 cxx cxxprogram', use=uses, fragment=frag, msg='Can we link Qt programs on FreeBSD directly?') except self.errors.ConfigurationError: self.check(features='qt5 cxx cxxprogram', use=uses, uselib_store='qt5', libpath='/usr/local/lib', fragment=frag, msg='Is /usr/local/lib required?')
def cxx_load_tools(conf): if not conf.env.DEST_OS: conf.env.DEST_OS=Utils.unversioned_sys_platform() conf.load('cxx')
def openf95_modifier_platform(conf): dest_os = conf.env["DEST_OS"] or Utils.unversioned_sys_platform() openf95_modifier_func = getattr(conf, "openf95_modifier_" + dest_os, None) if openf95_modifier_func: openf95_modifier_func()
def configure_env(self, cfg, env): super(sitl, self).configure_env(cfg, env) env.DEFINES.update( CONFIG_HAL_BOARD='HAL_BOARD_SITL', CONFIG_HAL_BOARD_SUBTYPE='HAL_BOARD_SUBTYPE_NONE', AP_SCRIPTING_CHECKS= 1, # SITL should always do runtime scripting checks ) env.CXXFLAGS += ['-Werror=float-equal'] if not cfg.env.DEBUG: env.CXXFLAGS += [ '-O3', ] env.LIB += ['m', 'hinj'] env.LIBPATH += ['/usr/local/lib/'] cfg.check_librt(env) env.LINKFLAGS += ['-pthread'] env.AP_LIBRARIES += [ 'AP_HAL_SITL', 'SITL', ] if cfg.options.enable_sfml: if not cfg.check_SFML(env): cfg.fatal("Failed to find SFML libraries") if cfg.options.sitl_osd: env.CXXFLAGS += [ '-DWITH_SITL_OSD', '-DOSD_ENABLED=ENABLED', '-DHAL_HAVE_AP_ROMFS_EMBEDDED_H' ] import fnmatch for f in os.listdir('libraries/AP_OSD/fonts'): if fnmatch.fnmatch(f, "font*bin"): env.ROMFS_FILES += [(f, 'libraries/AP_OSD/fonts/' + f)] if cfg.options.sitl_rgbled: env.CXXFLAGS += ['-DWITH_SITL_RGBLED'] if cfg.options.enable_sfml_audio: if not cfg.check_SFML_Audio(env): cfg.fatal("Failed to find SFML Audio libraries") env.CXXFLAGS += ['-DWITH_SITL_TONEALARM'] if cfg.options.sitl_flash_storage: env.CXXFLAGS += ['-DSTORAGE_USE_FLASH=1'] if cfg.env.DEST_OS == 'cygwin': env.LIB += [ 'winmm', ] if Utils.unversioned_sys_platform() == 'cygwin': env.CXXFLAGS += ['-DCYGWIN_BUILD'] if 'clang++' in cfg.env.COMPILER_CXX: print("Disabling SLP for clang++") env.CXXFLAGS += [ '-fno-slp-vectorize' # compiler bug when trying to use SLP ]
def _get_project_overrides(ctx, target): if ctx.cmd == 'generate_uber_files' or ctx.cmd == 'msvs' or ctx.cmd == 'configure': return ({}, {}) # Only perform on VS executed builds if not getattr(ctx.options, 'execsolution', None): return ({}, {}) if Utils.unversioned_sys_platform() != 'win32': return ({}, {}) if not hasattr(ctx, 'project_options_overrides'): ctx.project_options_overrides = {} if not hasattr(ctx, 'project_file_options_overrides'): ctx.project_file_options_overrides = {} try: return (ctx.project_options_overrides[target], ctx.project_file_options_overrides[target]) except: pass # Check if project is valid for current spec, config and platform waf_spec = ctx.options.project_spec waf_platform = ctx.env['PLATFORM'] waf_configuration = ctx.env['CONFIGURATION'] if not ctx.is_valid_build_target(target, waf_spec, waf_configuration, waf_platform): return ({}, {}) ctx.project_options_overrides[target] = {} ctx.project_file_options_overrides[target] = {} project_options_overrides = ctx.project_options_overrides[target] project_file_options_overrides = ctx.project_file_options_overrides[target] vs_spec = ctx.convert_waf_spec_to_vs_spec(waf_spec) vs_platform = ctx.convert_waf_platform_to_vs_platform(waf_platform) vs_configuration = ctx.convert_waf_configuration_to_vs_configuration( waf_configuration) vs_valid_spec_for_build = '[%s] %s|%s' % (vs_spec, vs_configuration, vs_platform) vcxproj_file = (ctx.get_project_output_folder().make_node( '%s%s' % (target, '.vcxproj'))).abspath() # Example: <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='[Hunt] Profile|Win64'"> project_override = '<ItemDefinitionGroup Condition="\'$(Configuration)|$(Platform)\'==\'%s\'"' % vs_valid_spec_for_build # Open file try: file = open(vcxproj_file) except Exception as e: Logs.warn( 'warning: Unable to parse .vcxproj file to extract configuration overrides. [File:%s] [Exception:%s, %s]' % (vcxproj_file, sys.exc_info()[0], e)) return ({}, {}) # Iterate line by line #(Note: skipping lines inside loop) file_iter = iter(file) for line in file_iter: stripped_line = line.lstrip() #[Per Project] # Example: # <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='[Hunt] Profile|x64'"> # <ClCompile> # <WAF_DisableCompilerOptimization>true</WAF_DisableCompilerOptimization> # <WAF_AdditionalPreprocessorDefinitions>/MyProjectDefinition</WAF_AdditionalPreprocessorDefinitions> # </ClCompile> #</ItemDefinitionGroup> if stripped_line.startswith(project_override) == True: # Extract WAF items while True: next_line = file_iter.next().strip() if next_line.startswith('<WAF_'): element_name = get_element_name(next_line) element_value = get_element_value(next_line) # Cache override _set_override(project_options_overrides, element_name, element_value, ctx.env, ctx.path) elif next_line.startswith('</ItemDefinitionGroup>'): break #[Per Item] # Example: # <ItemGroup> # <ClCompile Include="e:\P4\CE_STREAMS\Code\CryEngine\CryAnimation\Attachment.cpp"> # <WAF_AdditionalPreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='[Hunt] Profile|x64'">/MyItemDefinition</WAF_AdditionalPreprocessorDefinitions> # <WAF_AdditionalCompilerOptions_CXX Condition="'$(Configuration)|$(Platform)'=='[Hunt] Profile|x64'">/MyItemCompilerOption</WAF_AdditionalCompilerOptions_CXX> # </ClCompile> # </ItemGroup> elif stripped_line.startswith('<ItemGroup>') == True: while True: next_line = file_iter.next().strip() # Check that element is a "ClCompile" element that has child elements i.e. not <ClCompile ... /> if next_line.endswith('/>') == False and next_line.startswith( '<ClCompile') == True: item_tasks = [] # Is WAF Element while True: next_line_child = file_iter.next().strip() if next_line_child.startswith('<WAF_'): # Condition meets platform specs (optimize if needed) if vs_valid_spec_for_build in next_line_child: # For first valid item, collect tasks if not item_tasks: # Get include path pos_include_name_start = next_line.find( '"') + 1 pos_include_name_end = next_line.find( '"', pos_include_name_start) vs_file_path = next_line[ pos_include_name_start: pos_include_name_end].lower() # Get element info element_name = get_element_name( next_line_child) element_value = get_element_value( next_line_child) # Cache override try: override_map = project_file_options_overrides[ vs_file_path] except: project_file_options_overrides[ vs_file_path] = {} override_map = project_file_options_overrides[ vs_file_path] _set_override(override_map, element_name, element_value, ctx.env, ctx.path) #end of ClCompile Element elif next_line_child.startswith('</ClCompile>'): break # end of "ItemGroup" Element elif next_line.startswith('</ItemGroup>'): break return (project_options_overrides, project_file_options_overrides)
def find_qt4_libraries(self): qtlibs = getattr(Options.options, 'qtlibs', None) or os.environ.get("QT4_LIBDIR") if not qtlibs: try: qtlibs = self.cmd_and_log(self.env.QMAKE + ['-query', 'QT_INSTALL_LIBS']).strip() except Errors.WafError: qtdir = self.cmd_and_log( self.env.QMAKE + ['-query', 'QT_INSTALL_PREFIX']).strip() + os.sep qtlibs = os.path.join(qtdir, 'lib') self.msg('Found the Qt4 libraries in', qtlibs) qtincludes = os.environ.get("QT4_INCLUDES") or self.cmd_and_log( self.env.QMAKE + ['-query', 'QT_INSTALL_HEADERS']).strip() env = self.env 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) try: if os.environ.get("QT4_XCOMPILE"): raise self.errors.ConfigurationError() self.check_cfg(atleast_pkgconfig_version='0.1') except self.errors.ConfigurationError: for i in self.qt4_vars: uselib = i.upper() if Utils.unversioned_sys_platform() == "darwin": # Since at least qt 4.7.3 each library locates in separate directory frameworkName = i + ".framework" qtDynamicLib = os.path.join(qtlibs, frameworkName, i) if os.path.exists(qtDynamicLib): env.append_unique('FRAMEWORK_' + uselib, i) self.msg('Checking for %s' % i, qtDynamicLib, 'GREEN') else: self.msg('Checking for %s' % i, False, 'YELLOW') env.append_unique( 'INCLUDES_' + uselib, os.path.join(qtlibs, frameworkName, 'Headers')) elif env.DEST_OS != "win32": qtDynamicLib = os.path.join(qtlibs, "lib" + i + ".so") qtStaticLib = os.path.join(qtlibs, "lib" + i + ".a") if os.path.exists(qtDynamicLib): env.append_unique('LIB_' + uselib, i) self.msg('Checking for %s' % i, qtDynamicLib, 'GREEN') elif os.path.exists(qtStaticLib): env.append_unique('LIB_' + uselib, i) self.msg('Checking for %s' % i, qtStaticLib, 'GREEN') else: self.msg('Checking for %s' % i, False, 'YELLOW') env.append_unique('LIBPATH_' + uselib, qtlibs) env.append_unique('INCLUDES_' + uselib, qtincludes) env.append_unique('INCLUDES_' + uselib, os.path.join(qtincludes, i)) else: # Release library names are like QtCore4 for k in ("lib%s.a", "lib%s4.a", "%s.lib", "%s4.lib"): lib = os.path.join(qtlibs, k % i) if os.path.exists(lib): env.append_unique('LIB_' + uselib, i + k[k.find("%s") + 2:k.find('.')]) self.msg('Checking for %s' % i, lib, 'GREEN') break else: self.msg('Checking for %s' % i, False, 'YELLOW') env.append_unique('LIBPATH_' + uselib, qtlibs) env.append_unique('INCLUDES_' + uselib, qtincludes) env.append_unique('INCLUDES_' + uselib, os.path.join(qtincludes, i)) # Debug library names are like QtCore4d uselib = i.upper() + "_debug" for k in ("lib%sd.a", "lib%sd4.a", "%sd.lib", "%sd4.lib"): lib = os.path.join(qtlibs, k % i) if os.path.exists(lib): env.append_unique('LIB_' + uselib, i + k[k.find("%s") + 2:k.find('.')]) self.msg('Checking for %s' % i, lib, 'GREEN') break else: self.msg('Checking for %s' % i, False, 'YELLOW') env.append_unique('LIBPATH_' + uselib, qtlibs) env.append_unique('INCLUDES_' + uselib, qtincludes) env.append_unique('INCLUDES_' + uselib, os.path.join(qtincludes, i)) else: for i in self.qt4_vars_debug + self.qt4_vars: self.check_cfg(package=i, args='--cflags --libs', mandatory=False)
BOOST_LIBS = [ '/usr/lib', '/usr/local/lib', '/opt/local/lib', '/sw/lib', '/lib' ] BOOST_INCLUDES = [ '/usr/include', '/usr/local/include', '/opt/local/include', '/sw/include' ] BOOST_VERSION_FILE = 'boost/version.hpp' BOOST_VERSION_CODE = ''' #include <iostream> #include <boost/version.hpp> int main() { std::cout << BOOST_LIB_VERSION << std::endl; } ''' # toolsets from {boost_dir}/tools/build/v2/tools/common.jam PLATFORM = Utils.unversioned_sys_platform() detect_intel = lambda env: (PLATFORM == 'win32') and 'iw' or 'il' detect_clang = lambda env: (PLATFORM == 'darwin') and 'clang-darwin' or 'clang' detect_mingw = lambda env: (re.search('MinGW', env.CXX[0])) and 'mgw' or 'gcc' BOOST_TOOLSETS = { 'borland': 'bcb', 'clang': detect_clang, 'como': 'como', 'cw': 'cw', 'darwin': 'xgcc', 'edg': 'edg', 'g++': detect_mingw, 'gcc': detect_mingw, 'icpc': detect_intel, 'intel': detect_intel, 'kcc': 'kcc',
def set_bundle(self): if Utils.unversioned_sys_platform()=='darwin': self.mac_bundle=True
def _check_pthread_flag(self, *k, **kw): ''' Computes which flags should be added to CXXFLAGS and LINKFLAGS to compile in multi-threading mode Yes, we *need* to put the -pthread thing in CPPFLAGS because with GCC3, boost/thread.hpp will trigger a #error if -pthread isn't used: boost/config/requires_threads.hpp:47:5: #error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)" Based on _BOOST_PTHREAD_FLAG(): https://github.com/tsuna/boost.m4/blob/master/build-aux/boost.m4 ''' var = kw.get('uselib_store', 'BOOST') self.start_msg('Checking the flags needed to use pthreads') # The ordering *is* (sometimes) important. Some notes on the # individual items follow: # (none): in case threads are in libc; should be tried before -Kthread and # other compiler flags to prevent continual compiler warnings # -lpthreads: AIX (must check this before -lpthread) # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) # -llthread: LinuxThreads port on FreeBSD (also preferred to -pthread) # -pthread: GNU Linux/GCC (kernel threads), BSD/GCC (userland threads) # -pthreads: Solaris/GCC # -mthreads: MinGW32/GCC, Lynx/GCC # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it # doesn't hurt to check since this sometimes defines pthreads too; # also defines -D_REENTRANT) # ... -mt is also the pthreads flag for HP/aCC # -lpthread: GNU Linux, etc. # --thread-safe: KAI C++ if Utils.unversioned_sys_platform() == "sunos": # On Solaris (at least, for some versions), libc contains stubbed # (non-functional) versions of the pthreads routines, so link-based # tests will erroneously succeed. (We need to link with -pthreads/-mt/ # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather # a function called by this macro, so we could check for that, but # who knows whether they'll stub that too in a future libc.) So, # we'll just look for -pthreads and -lpthread first: boost_pthread_flags = ["-pthreads", "-lpthread", "-mt", "-pthread"] else: boost_pthread_flags = [ "-lpthreads", "-Kthread", "-kthread", "-llthread", "-pthread", "-pthreads", "-mthreads", "-lpthread", "--thread-safe", "-mt" ] for boost_pthread_flag in boost_pthread_flags: try: self.env.stash() self.env['CXXFLAGS_%s' % var] += [boost_pthread_flag] self.env['LINKFLAGS_%s' % var] += [boost_pthread_flag] self.check_cxx(code=PTHREAD_CODE, msg=None, use=var, execute=False) self.end_msg(boost_pthread_flag) return except self.errors.ConfigurationError: self.env.revert() self.end_msg('None')
def configure_env(self, cfg, env): super(chibios, self).configure_env(cfg, env) cfg.load('chibios') env.BOARD = self.name env.DEFINES.update( CONFIG_HAL_BOARD='HAL_BOARD_CHIBIOS', HAVE_OCLOEXEC=0, HAVE_STD_NULLPTR_T=0, ) env.AP_LIBRARIES += [ 'AP_HAL_ChibiOS', ] # make board name available for USB IDs env.CHIBIOS_BOARD_NAME = 'HAL_BOARD_NAME="%s"' % self.name env.CFLAGS += cfg.env.CPU_FLAGS + [ '-Wno-cast-align', '-Wlogical-op', '-Wframe-larger-than=1300', '-fsingle-precision-constant', '-Wno-attributes', '-Wno-error=double-promotion', '-Wno-error=missing-declarations', '-Wno-error=float-equal', '-Wno-error=undef', '-Wno-error=cpp', '-fno-exceptions', '-Wall', '-Wextra', '-Wno-sign-compare', '-Wfloat-equal', '-Wpointer-arith', '-Wmissing-declarations', '-Wno-unused-parameter', '-Werror=array-bounds', '-Wfatal-errors', '-Werror=unused-variable', '-Werror=uninitialized', '-Werror=init-self', '-Wframe-larger-than=1024', '-Werror=unused-but-set-variable', '-Wno-missing-field-initializers', '-Wno-trigraphs', '-Os', '-fno-strict-aliasing', '-fomit-frame-pointer', '-falign-functions=16', '-ffunction-sections', '-fdata-sections', '-fno-strength-reduce', '-fno-builtin-printf', '-fno-builtin-fprintf', '-fno-builtin-vprintf', '-fno-builtin-vfprintf', '-fno-builtin-puts', '-mno-thumb-interwork', '-mthumb', '--specs=nano.specs', '-specs=nosys.specs', '-DCHIBIOS_BOARD_NAME="%s"' % self.name, ] env.CXXFLAGS += env.CFLAGS + [ '-fno-rtti', '-fno-threadsafe-statics', ] if Utils.unversioned_sys_platform() == 'cygwin': env.CXXFLAGS += ['-DCYGWIN_BUILD'] bldnode = cfg.bldnode.make_node(self.name) env.BUILDROOT = bldnode.make_node('').abspath() env.LINKFLAGS = cfg.env.CPU_FLAGS + [ '-Os', '-fomit-frame-pointer', '-falign-functions=16', '-ffunction-sections', '-fdata-sections', '-u_port_lock', '-u_port_unlock', '-u_exit', '-u_kill', '-u_getpid', '-u_errno', '-uchThdExit', '-fno-common', '-nostartfiles', '-mno-thumb-interwork', '-mthumb', '-specs=nano.specs', '-specs=nosys.specs', '-L%s' % env.BUILDROOT, '-L%s' % cfg.srcnode.make_node( 'modules/ChibiOS/os/common/startup/ARMCMx/compilers/GCC/ld/' ).abspath(), '-L%s' % cfg.srcnode.make_node( 'libraries/AP_HAL_ChibiOS/hwdef/common/').abspath(), '-Wl,--gc-sections,--no-warn-mismatch,--library-path=/ld,--script=ldscript.ld,--defsym=__process_stack_size__=%s,--defsym=__main_stack_size__=%s' % (cfg.env.PROCESS_STACK, cfg.env.MAIN_STACK) ] if cfg.env.DEBUG: env.CFLAGS += [ '-gdwarf-4', '-g3', ] env.LINKFLAGS += [ '-gdwarf-4', '-g3', ] if cfg.env.ENABLE_ASSERTS: cfg.msg("Enabling ChibiOS asserts", "yes") env.CFLAGS += ['-DHAL_CHIBIOS_ENABLE_ASSERTS'] env.CXXFLAGS += ['-DHAL_CHIBIOS_ENABLE_ASSERTS'] else: cfg.msg("Enabling ChibiOS asserts", "no") env.LIB += ['gcc', 'm'] env.GIT_SUBMODULES += [ 'ChibiOS', ] try: import intelhex env.HAVE_INTEL_HEX = True cfg.msg("Checking for intelhex module:", 'OK') except Exception: cfg.msg("Checking for intelhex module:", 'disabled', color='YELLOW') env.HAVE_INTEL_HEX = False
def run(self): self.ut_exec = getattr(self, 'ut_exec', [ self.inputs[0].abspath() ]) if getattr(self.generator, 'ut_fun', None): self.generator.ut_fun(self) try: fu = getattr(self.generator.bld, 'all_test_paths') except AttributeError: fu = os.environ.copy() self.generator.bld.all_test_paths = fu lst = [] asm = [] for g in self.generator.bld.groups: for tg in g: if getattr(tg, 'link_task', None): if tg.link_task.__class__.__name__ == 'fake_csshlib': asm.append(tg.link_task.outputs[0].parent.abspath()) lst.append(tg.link_task.outputs[0].parent.abspath()) if getattr(tg, 'cs_task', None): if tg.gen.endswith('.dll'): asm.append(tg.cs_task.outputs[0].parent.abspath()) lst.append(tg.cs_task.outputs[0].parent.abspath()) if getattr(tg, 'install', None): lst.append(tg.path.get_src().abspath()) def add_path(dct, path, var): dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, '')]) add_path(fu, lst, 'PATH') if Utils.unversioned_sys_platform() == 'darwin': add_path(fu, lst, 'DYLD_LIBRARY_PATH') add_path(fu, lst, 'LD_LIBRARY_PATH') else: add_path(fu, lst, 'LD_LIBRARY_PATH') path_var = self.generator.env.CS_NAME == 'mono' and 'MONO_PATH' or 'DEVPATH' fu[path_var] = os.pathsep.join(asm) Logs.debug('runner: %r' % self.ut_exec) cwd = getattr(self.generator, 'ut_cwd', '') or self.inputs[0].parent.abspath() stderr = stdout = None if Logs.verbose == 0: stderr = stdout = Utils.subprocess.PIPE proc = Utils.subprocess.Popen(self.ut_exec, cwd=cwd, env=fu, stderr=stderr, stdout=stdout) (stdout, stderr) = proc.communicate() xml = getattr(self.generator, 'ut_nunit', False) and self.outputs[0].abspath() or None tup = (self.inputs[0].name, proc.returncode, xml) self.generator.utest_result = tup testlock.acquire() try: bld = self.generator.bld Logs.debug("ut: %r", tup) try: bld.utest_results.append(tup) except AttributeError: bld.utest_results = [tup] finally: testlock.release()
def configure_env(self, cfg, env): super(sitl, self).configure_env(cfg, env) env.DEFINES.update( CONFIG_HAL_BOARD='HAL_BOARD_SITL', CONFIG_HAL_BOARD_SUBTYPE='HAL_BOARD_SUBTYPE_NONE', AP_SCRIPTING_CHECKS= 1, # SITL should always do runtime scripting checks ) if self.with_can: cfg.define('HAL_NUM_CAN_IFACES', 2) cfg.define('UAVCAN_EXCEPTIONS', 0) env.CXXFLAGS += ['-Werror=float-equal'] if not cfg.env.DEBUG: env.CXXFLAGS += [ '-O3', ] if 'clang++' in cfg.env.COMPILER_CXX and cfg.options.asan: env.CXXFLAGS += [ '-fsanitize=address', '-fno-omit-frame-pointer', ] env.LIB += [ 'm', ] cfg.check_librt(env) cfg.check_feenableexcept() env.LINKFLAGS += [ '-pthread', ] if cfg.env.DEBUG and 'clang++' in cfg.env.COMPILER_CXX and cfg.options.asan: env.LINKFLAGS += ['-fsanitize=address'] env.AP_LIBRARIES += [ 'AP_HAL_SITL', ] if not cfg.env.AP_PERIPH: env.AP_LIBRARIES += [ 'SITL', ] if cfg.options.enable_sfml: if not cfg.check_SFML(env): cfg.fatal("Failed to find SFML libraries") if cfg.options.sitl_osd: env.CXXFLAGS += ['-DWITH_SITL_OSD', '-DOSD_ENABLED=1'] for f in os.listdir('libraries/AP_OSD/fonts'): if fnmatch.fnmatch(f, "font*bin"): env.ROMFS_FILES += [(f, 'libraries/AP_OSD/fonts/' + f)] for f in os.listdir('Tools/autotest/models'): if fnmatch.fnmatch(f, "*.json") or fnmatch.fnmatch(f, "*.parm"): env.ROMFS_FILES += [('models/' + f, 'Tools/autotest/models/' + f)] # embed any scripts from ROMFS/scripts if os.path.exists('ROMFS/scripts'): for f in os.listdir('ROMFS/scripts'): if fnmatch.fnmatch(f, "*.lua"): env.ROMFS_FILES += [('scripts/' + f, 'ROMFS/scripts/' + f)] if len(env.ROMFS_FILES) > 0: env.CXXFLAGS += ['-DHAL_HAVE_AP_ROMFS_EMBEDDED_H'] if cfg.options.sitl_rgbled: env.CXXFLAGS += ['-DWITH_SITL_RGBLED'] if cfg.options.enable_sfml_audio: if not cfg.check_SFML_Audio(env): cfg.fatal("Failed to find SFML Audio libraries") env.CXXFLAGS += ['-DWITH_SITL_TONEALARM'] if cfg.options.sitl_flash_storage: env.CXXFLAGS += ['-DSTORAGE_USE_FLASH=1'] if cfg.env.DEST_OS == 'cygwin': env.LIB += [ 'winmm', ] if Utils.unversioned_sys_platform() == 'cygwin': env.CXXFLAGS += ['-DCYGWIN_BUILD'] if 'clang++' in cfg.env.COMPILER_CXX: print("Disabling SLP for clang++") env.CXXFLAGS += [ '-fno-slp-vectorize' # compiler bug when trying to use SLP ] def srcpath(path): return cfg.srcnode.make_node(path).abspath() env.SRCROOT = srcpath('')
""" commands = [] """ List of commands to execute extracted from the command-line. This list is consumed during the execution, see :py:func:`waflib.Scripting.run_commands`. """ envvars = [] """ List of environment variable declarations placed after the Waf executable name. These are detected by searching for "=" in the rest arguments. """ lockfile = os.environ.get('WAFLOCK', '.lock-waf_%s_build' % sys.platform) platform = Utils.unversioned_sys_platform() class opt_parser(optparse.OptionParser): """ Command-line options parser. """ def __init__(self, ctx): optparse.OptionParser.__init__( self, conflict_handler="resolve", version='waf %s (%s)' % (Context.WAFVERSION, Context.WAFREVISION)) self.formatter.width = Logs.get_term_cols() self.ctx = ctx
def __init__(self): if Utils.unversioned_sys_platform().startswith("linux"): self.with_can = True else: self.with_can = False
def configure_env(self, cfg, env): if hasattr(self, 'hwdef'): cfg.env.HWDEF = self.hwdef super(chibios, self).configure_env(cfg, env) cfg.load('chibios') env.BOARD = self.name env.DEFINES.update( CONFIG_HAL_BOARD = 'HAL_BOARD_CHIBIOS', HAVE_STD_NULLPTR_T = 0, USE_LIBC_REALLOC = 0, ) env.AP_LIBRARIES += [ 'AP_HAL_ChibiOS', ] # make board name available for USB IDs env.CHIBIOS_BOARD_NAME = 'HAL_BOARD_NAME="%s"' % self.name env.HAL_MAX_STACK_FRAME_SIZE = 'HAL_MAX_STACK_FRAME_SIZE=%d' % 1300 # set per Wframe-larger-than, ensure its same env.CFLAGS += cfg.env.CPU_FLAGS + [ '-Wlogical-op', '-Wframe-larger-than=1300', '-fsingle-precision-constant', '-Wno-attributes', '-fno-exceptions', '-Wall', '-Wextra', '-Wno-sign-compare', '-Wfloat-equal', '-Wpointer-arith', '-Wmissing-declarations', '-Wno-unused-parameter', '-Werror=array-bounds', '-Wfatal-errors', '-Werror=uninitialized', '-Werror=init-self', '-Werror=unused-but-set-variable', '-Wno-missing-field-initializers', '-Wno-trigraphs', '-fno-strict-aliasing', '-fomit-frame-pointer', '-falign-functions=16', '-ffunction-sections', '-fdata-sections', '-fno-strength-reduce', '-fno-builtin-printf', '-fno-builtin-fprintf', '-fno-builtin-vprintf', '-fno-builtin-vfprintf', '-fno-builtin-puts', '-mno-thumb-interwork', '-mthumb', '--specs=nano.specs', '--specs=nosys.specs', '-DCHIBIOS_BOARD_NAME="%s"' % self.name, '-D__USE_CMSIS', '-Werror=deprecated-declarations', '-DNDEBUG=1' ] if not cfg.options.Werror: env.CFLAGS += [ '-Wno-error=double-promotion', '-Wno-error=missing-declarations', '-Wno-error=float-equal', '-Wno-error=cpp', ] env.CXXFLAGS += env.CFLAGS + [ '-fno-rtti', '-fno-threadsafe-statics', ] env.CFLAGS += [ '-std=c11' ] if Utils.unversioned_sys_platform() == 'cygwin': env.CXXFLAGS += ['-DCYGWIN_BUILD'] bldnode = cfg.bldnode.make_node(self.name) env.BUILDROOT = bldnode.make_node('').abspath() env.LINKFLAGS = cfg.env.CPU_FLAGS + [ '-fomit-frame-pointer', '-falign-functions=16', '-ffunction-sections', '-fdata-sections', '-u_port_lock', '-u_port_unlock', '-u_exit', '-u_kill', '-u_getpid', '-u_errno', '-uchThdExit', '-fno-common', '-nostartfiles', '-mno-thumb-interwork', '-mthumb', '--specs=nano.specs', '--specs=nosys.specs', '-L%s' % env.BUILDROOT, '-L%s' % cfg.srcnode.make_node('modules/ChibiOS/os/common/startup/ARMCMx/compilers/GCC/ld/').abspath(), '-L%s' % cfg.srcnode.make_node('libraries/AP_HAL_ChibiOS/hwdef/common/').abspath(), '-Wl,--gc-sections,--no-warn-mismatch,--library-path=/ld,--script=ldscript.ld,--defsym=__process_stack_size__=%s,--defsym=__main_stack_size__=%s' % (cfg.env.PROCESS_STACK, cfg.env.MAIN_STACK) ] if cfg.env.DEBUG: env.CFLAGS += [ '-gdwarf-4', '-g3', ] env.LINKFLAGS += [ '-gdwarf-4', '-g3', ] if cfg.env.ENABLE_ASSERTS: cfg.msg("Enabling ChibiOS asserts", "yes") env.CFLAGS += [ '-DHAL_CHIBIOS_ENABLE_ASSERTS' ] env.CXXFLAGS += [ '-DHAL_CHIBIOS_ENABLE_ASSERTS' ] else: cfg.msg("Enabling ChibiOS asserts", "no") if cfg.options.disable_watchdog: cfg.msg("Disabling Watchdog", "yes") env.CFLAGS += [ '-DDISABLE_WATCHDOG' ] env.CXXFLAGS += [ '-DDISABLE_WATCHDOG' ] else: cfg.msg("Disabling Watchdog", "no") if cfg.env.ENABLE_MALLOC_GUARD: cfg.msg("Enabling malloc guard", "yes") env.CFLAGS += [ '-DHAL_CHIBIOS_ENABLE_MALLOC_GUARD' ] env.CXXFLAGS += [ '-DHAL_CHIBIOS_ENABLE_MALLOC_GUARD' ] else: cfg.msg("Enabling malloc guard", "no") if cfg.env.ENABLE_STATS: cfg.msg("Enabling ChibiOS thread statistics", "yes") env.CFLAGS += [ '-DHAL_ENABLE_THREAD_STATISTICS' ] env.CXXFLAGS += [ '-DHAL_ENABLE_THREAD_STATISTICS' ] else: cfg.msg("Enabling ChibiOS thread statistics", "no") env.LIB += ['gcc', 'm'] env.GIT_SUBMODULES += [ 'ChibiOS', ] env.INCLUDES += [ cfg.srcnode.find_dir('libraries/AP_GyroFFT/CMSIS_5/include').abspath() ] # whitelist of compilers which we should build with -Werror gcc_whitelist = [ ('4','9','3'), ('6','3','1'), ('9','2','1'), ('9','3','1'), ('10','2','1'), ] if cfg.options.Werror or cfg.env.CC_VERSION in gcc_whitelist: cfg.msg("Enabling -Werror", "yes") if '-Werror' not in env.CXXFLAGS: env.CXXFLAGS += [ '-Werror' ] else: cfg.msg("Enabling -Werror", "no") try: import intelhex env.HAVE_INTEL_HEX = True cfg.msg("Checking for intelhex module:", 'OK') except Exception: cfg.msg("Checking for intelhex module:", 'disabled', color='YELLOW') env.HAVE_INTEL_HEX = False
def configure(ctx): if Logs.verbose == 0: def null_fatal(self, msg, ex=None): raise self.errors.ConfigurationError(msg, ex) setattr(Configure.ConfigurationContext, 'fatal', null_fatal) out = getattr(Context.g_module, 'out') inst = getattr(Context.g_module, 'inst') appname = getattr(Context.g_module, 'appname') supported_variant = getattr(Context.g_module, 'supported_variant') base_env = ctx.env base_env.APPNAME = appname base_env.OUTPUT = base_env.PREFIX = base_env.BINDIR = base_env.LIBDIR = base_env.DOCDIR = inst base_env.BUILDTAG = Options.options.buildtag tool_dir = [ os.path.join(Context.waf_dir, 'waflib', 'Tools'), os.path.join(Context.waf_dir, 'waflib', 'extras'), ] platform = Utils.unversioned_sys_platform() for tgt in targets: try: config = Context.load_tool('config.%s' % tgt) ctx.msg("Loading '%s' config" % tgt, config.__file__) except: ctx.msg("Loading '%s' config" % tgt, 'not found', color='YELLOW') continue platforms = getattr(config, 'host_plat', []) archs = getattr(config, 'archs', None) options = [('%s_%s' % (tgt, arch), arch) for arch in archs] or [(tgt, None)] for (name, arch) in options: if not supported_variant(name): continue if Logs.verbose == 0: Logs.pprint('NORMAL', 'Configuring variant %s :' % name.ljust(20), sep='') try: if platform not in platforms: raise Exception('Unsupported build host') ctx.setenv(name, env=base_env) arch_env = ctx.get_env() arch_env.BASENAME = name arch_env.TARGET = tgt arch_env.SUBARCH = arch arch_env.PREFIX = os.path.join(base_env.PREFIX, name) arch_env.BINDIR = os.path.join(base_env.BINDIR, name) arch_env.LIBDIR = os.path.join(base_env.LIBDIR, name) arch_env.DOCDIR = os.path.join(base_env.DOCDIR, name) config.prepare(ctx) for tool in getattr(config, 'tools', []): ctx.load(tool, tool_dir) config.configure(ctx) cfgs = ctx.env.VARIANTS if not cfgs: base_env.append_value('variants', name) for cfg in cfgs: variant = '%s_%s' % (name, cfg) ctx.setenv(variant, env=arch_env) cfg_env = ctx.get_env() cfg_env.PREFIX = os.path.join(base_env.BINDIR, variant) cfg_env.BINDIR = os.path.join(base_env.BINDIR, variant, 'bin') cfg_env.LIBDIR = os.path.join(base_env.LIBDIR, variant, 'bin') cfg_env.DOCDIR = os.path.join(base_env.DOCDIR, variant, 'doc') cfg_env.VARIANT = cfg cfg_func = getattr(config, cfg) cfg_func(cfg_env) base_env.append_value('variants', variant) if Logs.verbose == 0: missing = cfg_env['missing_features'] or '' if missing: missing = ' - Missing Features: %s' % ','.join(missing) Logs.pprint('GREEN', 'Available%s' % missing) except Exception, e: if Logs.verbose == 0: Logs.pprint('YELLOW', 'Not Available - %s' % e) else: if str(e).startswith('msvc:'): Logs.warn('Could not find %s: %s' % (ctx.env['MSVC_VERSIONS'][0], ctx.env['MSVC_TARGETS'][0])) Logs.warn('Available compilers:') for msvc_ver, msvc_tgts in ctx.env[ 'MSVC_INSTALLED_VERSIONS']: msvs_tgt = ' '.join([k for k, v in msvc_tgts]) Logs.warn("\t%s: %s" % (msvc_ver, msvs_tgt)) if Logs.verbose > 1: import traceback traceback.print_exc() Logs.warn('%s is not available: %s' % (name, e))
def configure(conf): platform = Utils.unversioned_sys_platform() if platform == 'win32' and not conf.options.fi_path: return conf.check_freeimage(conf.options.fi_path, conf.options.fip)
def prepare_task(self): # Create the directory if it doesn't already exist self.output_dir.mkdir() # We expect json output for friendlier parsing self.add_argument("-output-using-json") self.add_argument('-input-path "{}"'.format( clean_path(self.input_dir.abspath()))) self.add_argument('-output-path "{}"'.format( clean_path(self.output_dir.abspath()))) # Write input files to a file (command line version is too long) for input_file in self.inputs: input_file_rel_path = clean_path( input_file.path_from(self.input_dir)) self.add_argument('-input-file "{}"'.format(input_file_rel_path)) input_file.parent.get_bld().mkdir() def pypath(python_path): # Absolute paths are good to go as-is # Relative paths are assumed relative to src if not os.path.isabs(python_path): # Toss it in a node to figure out an absolute path python_path_node = self.generator.bld.srcnode.make_node( python_path) python_path = python_path_node.abspath() if not os.path.exists(python_path): Logs.warn( 'az_code_gen: Path given as python path does not exist: {}' .format(python_path)) return clean_path(python_path) # Python paths self.add_argument('-python-home "{}"'.format( pypath(self.env['CODE_GENERATOR_PYTHON_HOME']))) for python_path in self.env['CODE_GENERATOR_PYTHON_PATHS']: self.add_argument('-python-path "{}"'.format(pypath(python_path))) # Debug python paths self.add_argument('-python-home-debug "{}"'.format( pypath(self.env['CODE_GENERATOR_PYTHON_HOME_DEBUG']))) for python_debug_path in self.env['CODE_GENERATOR_PYTHON_DEBUG_PATHS']: self.add_argument('-python-debug-path "{}"'.format( pypath(python_debug_path))) if code_generator_ignore_includes: self.add_argument('-ignore-includes') if code_generator_suppress_errors_as_warnings: self.add_argument('-suppress-errors-as-warnings') if code_generator_verbose: self.add_argument('-v') if Utils.unversioned_sys_platform().startswith('linux'): self.add_argument('-include-path /usr/include/c++/v1') for include in self.includes: self.add_argument('-include-path "{}"'.format( clean_path(include.abspath()))) for include_path in self.env['CODE_GENERATOR_INCLUDE_PATHS']: self.add_argument('-include-path "{}"'.format( pypath(include_path))) if 'CODE_GENERATOR_CLANG_INCLUDE_PATH' in self.env: for clang_include_path in self.env[ 'CODE_GENERATOR_CLANG_INCLUDE_PATH']: self.add_argument('-include-path "{}"'.format( clean_path(clang_include_path))) for define in self.defines: self.add_argument('-define {}'.format(quote(define))) for script_node in self.script_nodes: self.add_argument('-codegen-script "{}"'.format( clean_path(script_node.get_src().abspath()))) # Include file that contains code generation tag definitions codegen_tags = self.env['CODE_GENERATOR_TAGS'] if not codegen_tags: codegen_tags = 'Code/Framework/AzCore/AzCore/Preprocessor/CodeGen.h' self.add_argument('-force-include "{}"'.format( clean_path( self.generator.bld.CreateRootRelativePath(codegen_tags)))) if self.error_output_file_node: self.add_argument('-redirect-output-file "{}"'.format( clean_path(self.error_output_file_node.abspath()))) if 'CLANG_SEARCH_PATHS' in self.env: self.add_argument('-resource-dir "{}"'.format( self.env['CLANG_SEARCH_PATHS']['libraries'][0])) if 'ISYSROOT' in self.env: self.add_argument('-isysroot "{}"'.format(self.env['ISYSROOT'])) if 'ANDROID' in self.defines: self.add_argument('-is-android-build') for flag in self.env['CXXFLAGS']: if flag.startswith('--gcc-toolchain='): gcc_toolchain = flag.split('=', 2) self.add_argument('-android-toolchain "{}"'.format( clean_path(gcc_toolchain[1]))) continue if flag.startswith('--target='): android_target = flag.split('=', 2) self.add_argument('-android-target "{}"'.format( clean_path(android_target[1]))) continue if flag.startswith('--sysroot='): android_sysroot = flag.split('=', 2) self.add_argument('-android-sysroot "{}"'.format( clean_path(android_sysroot[1]))) continue status, self.argument_file = self.write_argument_list_to_file() if not status: raise Errors.WafError('[ERROR] az_code_gen task creation failed')
def gfortran_modifier_platform(conf): dest_os = conf.env.DEST_OS or Utils.unversioned_sys_platform() gfortran_modifier_func = getattr(conf, 'gfortran_modifier_' + dest_os, None) if gfortran_modifier_func: gfortran_modifier_func()
def __init__(self, **kw): super(OptionsContext, self).__init__(**kw) self.parser = opt_parser(self) self.option_groups = {} jobs = self.jobs() p = self.add_option color = os.environ.get('NOCOLOR', '') and 'no' or 'auto' p('-c', '--color', dest='colors', default=color, action='store', help='whether to use colors (yes/no/auto) [default: auto]', choices=('yes', 'no', 'auto')) p('-j', '--jobs', dest='jobs', default=jobs, type='int', help='amount of parallel jobs (%r)' % jobs) p('-k', '--keep', dest='keep', default=0, action='count', help='continue despite errors (-kk to try harder)') p('-v', '--verbose', dest='verbose', default=0, action='count', help='verbosity level -v -vv or -vvv [default: 0]') p('--zones', dest='zones', default='', action='store', help='debugging zones (task_gen, deps, tasks, etc)') p('--profile', dest='profile', default='', action='store_true', help=optparse.SUPPRESS_HELP) gr = self.add_option_group('Configuration options') self.option_groups['configure options'] = gr gr.add_option('-o', '--out', action='store', default='', help='build dir for the project', dest='out') gr.add_option('-t', '--top', action='store', default='', help='src dir for the project', dest='top') gr.add_option('--no-lock-in-run', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_run') gr.add_option('--no-lock-in-out', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_out') gr.add_option('--no-lock-in-top', action='store_true', default='', help=optparse.SUPPRESS_HELP, dest='no_lock_in_top') default_prefix = getattr(Context.g_module, 'default_prefix', os.environ.get('PREFIX')) if not default_prefix: if Utils.unversioned_sys_platform() == 'win32': d = tempfile.gettempdir() default_prefix = d[0].upper() + d[1:] else: default_prefix = '/usr/local/' gr.add_option('--prefix', dest='prefix', default=default_prefix, help='installation prefix [default: %r]' % default_prefix) gr.add_option('--bindir', dest='bindir', help='bindir') gr.add_option('--libdir', dest='libdir', help='libdir') gr = self.add_option_group('Build and installation options') self.option_groups['build and install options'] = gr gr.add_option('-p', '--progress', dest='progress_bar', default=0, action='count', help='-p: progress bar; -pp: ide output') gr.add_option('--targets', dest='targets', default='', action='store', help='task generators, e.g. "target1,target2"') gr = self.add_option_group('Step options') self.option_groups['step options'] = gr gr.add_option( '--files', dest='files', default='', action='store', help='files to process, by regexp, e.g. "*/main.c,*/test/main.o"') default_destdir = os.environ.get('DESTDIR', '') gr = self.add_option_group('Installation and uninstallation options') self.option_groups['install/uninstall options'] = gr gr.add_option('--destdir', help='installation root [default: %r]' % default_destdir, default=default_destdir, dest='destdir') gr.add_option('-f', '--force', dest='force', default=False, action='store_true', help='force file installation') gr.add_option('--distcheck-args', metavar='ARGS', help='arguments to pass to distcheck', default=None, action='store')
def solstudio_modifier_platform(conf): dest_os = conf.env['DEST_OS'] or Utils.unversioned_sys_platform() solstudio_modifier_func = getattr(conf, 'solstudio_modifier_' + dest_os, None) if solstudio_modifier_func: solstudio_modifier_func()
def prepare_build_environment(bld): """ Prepare the build environment for the current build command and setup optional additional commands if necessary :param bld: The BuildContext """ if bld.cmd in NON_BUILD_COMMANDS: bld.env['PLATFORM'] = 'project_generator' bld.env['CONFIGURATION'] = 'project_generator' else: if not bld.variant: bld.fatal("[ERROR] Invalid build variant. Please use a valid build configuration. " "Type in '{} --help' for more information".format(CURRENT_WAF_EXECUTABLE)) (platform, configuration) = bld.get_platform_and_configuration() bld.env['PLATFORM'] = platform bld.env['CONFIGURATION'] = configuration if platform in PLATFORM_CONFIGURATION_FILTER: if configuration not in PLATFORM_CONFIGURATION_FILTER[platform]: bld.fatal('[ERROR] Configuration ({}) for platform ({}) currently not supported'.format(configuration, platform)) if not platform in bld.get_supported_platforms(): bld.fatal('[ERROR] Target platform "%s" not supported. [on host platform: %s]' % (platform, Utils.unversioned_sys_platform())) # make sure the android launchers are included in the build if bld.is_android_platform(bld.env['PLATFORM']): android_path = os.path.join(bld.path.abspath(), bld.get_android_project_relative_path(), 'wscript') if not os.path.exists(android_path): bld.fatal('[ERROR] Android launchers not correctly configured. Run \'configure\' again') SUBFOLDERS.append(bld.get_android_project_absolute_path()) # If a spec was supplied, check for platform limitations if bld.options.project_spec != '': validated_platforms = bld.preprocess_platform_list(bld.spec_platforms(), True) if platform not in validated_platforms: bld.fatal('[ERROR] Target platform "{}" not supported for spec {}'.format(platform, bld.options.project_spec)) validated_configurations = bld.preprocess_configuration_list(None, platform, bld.spec_configurations(), True) if configuration not in validated_configurations: bld.fatal('[ERROR] Target configuration "{}" not supported for spec {}'.format(configuration, bld.options.project_spec)) if bld.is_cmd_monolithic(): if len(bld.spec_modules()) == 0: bld.fatal('[ERROR] no available modules to build for that spec "%s" in "%s|%s"' % (bld.options.project_spec, platform, configuration)) # Ensure that, if specified, target is supported in this spec if bld.options.targets: for target in bld.options.targets.split(','): if not target in bld.spec_modules(): bld.fatal('[ERROR] Module "%s" is not configured to build in spec "%s" in "%s|%s"' % (target, bld.options.project_spec, platform, configuration)) deploy_cmd = 'deploy_' + platform + '_' + configuration # Only deploy to specific target platforms if 'build' in bld.cmd and platform in [ 'android_armv7_gcc', 'android_armv7_clang', 'android_armv8_clang'] and deploy_cmd not in Options.commands: # Only deploy if we are not trying to rebuild 3rd party libraries for the platforms above if '3rd_party' != getattr(bld.options, 'project_spec', ''): Options.commands.append(deploy_cmd)
def get_solution_overrides(self): if self.cmd == 'generate_uber_files' or self.cmd == 'msvs': return {} # Only perform on VS executed builds try: sln_file = self.options.execsolution except: return {} if not sln_file: return {} if Utils.unversioned_sys_platform() != 'win32': return # Open sln file try: file = open(sln_file) except Exception as e: Logs.debug( 'warning: Unable to parse .sln file to extract configuration overrides: [File:%s] [Exception:%s,%s]' % (sln_file, sys.exc_info()[0], e)) return {} ret_vs_project_override = {} vs_spec = self.convert_waf_spec_to_vs_spec(self.options.project_spec) vs_platform = self.convert_waf_platform_to_vs_platform( self.env['PLATFORM']) vs_configuration = self.convert_waf_configuration_to_vs_configuration( self.env['CONFIGURATION']) vs_build_configuration = '[%s] %s|%s' % ( vs_spec, vs_configuration, vs_platform) # Example: [Hunt] Debug|x64 vs_project_identifier = 'Project("{8BC9CEB8' # C++ project: 8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942 # Iterate over all basic project information # Example: # Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Cry3DEngine", "e:\P4\CE_STREAMS\Solutions\.depproj\Cry3DEngine.vcxproj", "{60178AE3-57FD-488C-9A53-4AE4F66419AA}" project_guid_to_name = {} file_iter = iter(file) for line in file_iter: stripped_line = line.lstrip() if stripped_line.startswith(vs_project_identifier) == True: project_info = stripped_line[51:].split( ',' ) # skip first 51 character ... "Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") =" project_name = project_info[0].strip()[ 1:-1] # trim left and right and remove '"' project_path = project_info[1].strip()[1:-1] project_guid = project_info[2].strip()[2:-2] # Store project GUID and Name pair project_guid_to_name[project_guid] = project_name elif stripped_line.startswith('Global') == True: file_iter.next() break else: continue # Skip to beginning of project configurations information for line in file_iter: if line.lstrip().startswith( 'GlobalSection(ProjectConfigurationPlatforms) = postSolution' ) == True: file_iter.next() break # Loop over all project # Example: # {60178AE3-57FD-488C-9A53-4AE4F66419AA}.[Hunt] Debug|x64.ActiveCfg = [GameSDK and Tools] Debug|x64 # or # {60178AE3-57FD-488C-9A53-4AE4F66419AA}.[Hunt] Debug|x64.Build.0 = [GameSDK and Tools] Debug|x64 for line in file_iter: stripped_line = line.strip() # Reached end of section if stripped_line.startswith('EndGlobalSection'): break if stripped_line[39:].startswith(vs_build_configuration) == True: project_build_info = stripped_line.split('.') starts_of_override_configuration = project_build_info[-1].find('[') project_build_info[-1] = project_build_info[-1][ starts_of_override_configuration:] # remove anything prior to [xxx] e.g. "ActiveCfg = " vs_project_configuration = project_build_info[1] vs_project_override_configuation = project_build_info[-1] # Check for no override condition if vs_project_configuration == vs_project_override_configuation: continue project_guid = project_build_info[0][ 1:-1] # remove surrounding '{' and '}' try: project_name = project_guid_to_name[project_guid] except: # Continue if project GUID not in list. # Since we only store C++ projects in the list this project is most likely of an other type e.g. C#. The user will have added this project to the solution manualy. Logs.debug( 'Warning: Override Handling: Unsupported project id "%s" found. Project is most likely not a C++ project' % project_gui) continue # Check that spec is the same vs_override_spec_end = vs_project_override_configuation.find(']') vs_override_spec = vs_project_override_configuation[ 1:vs_override_spec_end] if vs_spec != vs_override_spec: self.cry_error( 'Project "%s" : Invalid override spec is of type "%s" when it should be "%s"' % (project_name, vs_override_spec, vs_spec)) # Get WAF configuration from VS project configuration e.g. [Hunt] Debug|x64 -> debug vs_project_configuration_end = vs_project_override_configuation.rfind( '|') vs_project_configuration_start = vs_project_override_configuation.rfind( ']', 0, vs_project_configuration_end) + 2 vs_project_configuration = vs_project_override_configuation[ vs_project_configuration_start:vs_project_configuration_end] waf_configuration = self.convert_vs_configuration_to_waf_configuration( vs_project_configuration) # Store override ret_vs_project_override[project_name] = waf_configuration return ret_vs_project_override
def _validate_incredibuild_registry_settings(ctx): """ Helper function to verify the correct incredibuild settings """ if Utils.unversioned_sys_platform() != 'win32': return # Check windows registry only if not ctx.is_option_true('use_incredibuild'): return # No need to check IB settings if there is no IB allowUserInput = True if not ctx.is_option_true('ask_for_user_input'): allowUserInput = False if Options.options.execsolution: allowUserInput = False if ctx.is_option_true('internal_dont_check_recursive_execution'): allowUserInput = False try: import _winreg IB_settings_read_only = _winreg.OpenKey( _winreg.HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder", 0, _winreg.KEY_READ) except: Logs.warn( '[WARNING] Cannot open registry entry "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder" for reading, please check your incredibuild installation' ) return def _check_ib_setting(setting_name, required_value, desc): """ Helper function to read (and potentially modify a registry setting for IB """ (data, type) = (None, _winreg.REG_SZ) try: (data, type) = _winreg.QueryValueEx(IB_settings_read_only, setting_name) except: import traceback traceback.print_exc(file=sys.stdout) Logs.warn( '[WARNING] Cannot find a registry entry for "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder\\%s"' % setting_name) # Do we have the right value? if str(data) != required_value: if not allowUserInput: # Dont try anything if no input is allowed Logs.warn( '[WARNING] "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder\\%s" set to "%s" but should be "%s"; run WAF outside of Visual Studio to fix automatically' % (setting_name, data, required_value)) return try: # Try to open the registry for writing IB_settings_writing = _winreg.OpenKey( _winreg.HKEY_LOCAL_MACHINE, "Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder", 0, _winreg.KEY_SET_VALUE | _winreg.KEY_READ) except: Logs.warn( '[WARNING] Cannot access a registry entry "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder\\%s" for writing.' % setting_name) Logs.warn( '[WARNING] Please run cry_waf.exe as an administrator or change the value to "%s" in the registry to ensure a correct operation of WAF' % required_value) return if data is None: info_str = [( 'Should WAF create "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder\\%s" with value "%s"?' % (setting_name, required_value))] else: info_str = [( 'Should WAF change "HKEY_LOCAL_MACHINE\\Software\\Wow6432Node\\Xoreax\\Incredibuild\\Builder\\%s" from "%s" to "%s"?' % (setting_name, data, required_value))] info_str.append(desc) # Get user choice if not ctx.is_option_true('console_mode'): # gui retVal = 'True' if ctx.gui_get_choice( '\n'.join(info_str)) else 'False' else: # console Logs.info('\n'.join(info_str)) retVal = _get_boolean_value(ctx, 'Input', 'Yes') if retVal == 'True' or retVal == 'Yes': _winreg.SetValueEx(IB_settings_writing, setting_name, 0, type, str(required_value)) else: Logs.warn( '[WARNING] WAF is running with "unsupported" IncrediBuild settings. Expect to encounter IncrediBuild errors during compilation.' ) _check_ib_setting( 'MaxConcurrentPDBs', '0', '"MaxConcurrentPDBs" controls how many files can be processed in parallel (an optimization also useful for MSBuild)' ) _check_ib_setting( 'AllowDoubleTargets', '0', '"AllowDoubleTargets" controls if remote processes can be restarted on local machine when possible\nThis option is mandatory since it causes compiler crashed with WAF' )
def process_custom_configure_commands(conf): """ Add any additional custom commands that need to be run during the configure phase :param conf: Configuration context """ host = Utils.unversioned_sys_platform() if host == 'win32': # Win32 platform optional commands # Generate the visual studio projects & solution if specified if conf.is_option_true('generate_vs_projects_automatically'): Options.commands.insert(0, 'msvs') elif host == 'darwin': # Darwin/Mac platform optional commands # Create Xcode-iOS-Projects automatically during configure when running on mac if conf.is_option_true('generate_ios_projects_automatically'): # Workflow improvement: for all builds generate projects after the build # except when using the default build target 'utilities' then do it before if 'build' in Options.commands: build_cmd_idx = Options.commands.index('build') Options.commands.insert(build_cmd_idx, 'xcode_ios') else: Options.commands.append('xcode_ios') # Create Xcode-AppleTV-Projects automatically during configure when running on mac if conf.is_option_true('generate_appletv_projects_automatically'): # Workflow improvement: for all builds generate projects after the build # except when using the default build target 'utilities' then do it before if 'build' in Options.commands: build_cmd_idx = Options.commands.index('build') Options.commands.insert(build_cmd_idx, 'xcode_appletv') else: Options.commands.append('xcode_appletv') # Create Xcode-darwin-Projects automatically during configure when running on mac if conf.is_option_true('generate_mac_projects_automatically'): # Workflow improvement: for all builds generate projects after the build # except when using the default build target 'utilities' then do it before if 'build' in Options.commands: build_cmd_idx = Options.commands.index('build') Options.commands.insert(build_cmd_idx, 'xcode_mac') else: Options.commands.append('xcode_mac') # Android target platform commands if any(platform for platform in conf.get_supported_platforms() if platform.startswith('android')): # this is required for building any android projects. It adds the Android launchers # to the list of build directories android_builder_func = getattr(conf, 'create_and_add_android_launchers_to_build', None) if android_builder_func != None and android_builder_func(): SUBFOLDERS.append(conf.get_android_project_absolute_path()) # rebuild the project if invoked from android studio or sepcifically requested to do so if conf.options.from_android_studio or conf.is_option_true('generate_android_studio_projects_automatically'): if 'build' in Options.commands: build_cmd_idx = Options.commands.index('build') Options.commands.insert(build_cmd_idx, 'android_studio') else: Options.commands.append('android_studio') # Make sure the intermediate files are generated and updated if len(Options.commands) == 0: Options.commands.insert(0, 'generate_uber_files') Options.commands.insert(1, 'generate_module_def_files') else: has_generate_uber_files = 'generate_uber_files' in Options.commands has_generate_module_def_files = 'generate_module_def_files' in Options.commands if not has_generate_uber_files: Options.commands.insert(0, 'generate_uber_files') if not has_generate_module_def_files: Options.commands.insert(1, 'generate_module_def_files')
def default_compilers(): build_platform = Utils.unversioned_sys_platform() possible_compiler_list = cxx_compiler.get(build_platform, cxx_compiler['default']) return ' '.join(possible_compiler_list)
def ifort_modifier_platform(conf): dest_os = conf.env['DEST_OS'] or Utils.unversioned_sys_platform() ifort_modifier_func = getattr(conf, 'ifort_modifier_' + dest_os, None) if ifort_modifier_func: ifort_modifier_func()