diff options
Diffstat (limited to 'third_party/waf/wafadmin/Tools')
48 files changed, 0 insertions, 9286 deletions
diff --git a/third_party/waf/wafadmin/Tools/__init__.py b/third_party/waf/wafadmin/Tools/__init__.py deleted file mode 100644 index 8f026e187ff..00000000000 --- a/third_party/waf/wafadmin/Tools/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) diff --git a/third_party/waf/wafadmin/Tools/ar.py b/third_party/waf/wafadmin/Tools/ar.py deleted file mode 100644 index 3571670d5b5..00000000000 --- a/third_party/waf/wafadmin/Tools/ar.py +++ /dev/null @@ -1,34 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) -# Ralf Habacker, 2006 (rh) - -"ar and ranlib" - -import os, sys -import Task, Utils -from Configure import conftest - -ar_str = '${AR} ${ARFLAGS} ${AR_TGT_F}${TGT} ${AR_SRC_F}${SRC}' -cls = Task.simple_task_type('static_link', ar_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) -cls.maxjobs = 1 -cls.install = Utils.nada - -# remove the output in case it already exists -old = cls.run -def wrap(self): - try: os.remove(self.outputs[0].abspath(self.env)) - except OSError: pass - return old(self) -setattr(cls, 'run', wrap) - -def detect(conf): - conf.find_program('ar', var='AR') - conf.find_program('ranlib', var='RANLIB') - conf.env.ARFLAGS = 'rcs' - -@conftest -def find_ar(conf): - v = conf.env - conf.check_tool('ar') - if not v['AR']: conf.fatal('ar is required for static libraries - not found') diff --git a/third_party/waf/wafadmin/Tools/bison.py b/third_party/waf/wafadmin/Tools/bison.py deleted file mode 100644 index c281e61ddaf..00000000000 --- a/third_party/waf/wafadmin/Tools/bison.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# John O'Meara, 2006 -# Thomas Nagy 2009 - -"Bison processing" - -import Task -from TaskGen import extension - -bison = '${BISON} ${BISONFLAGS} ${SRC[0].abspath()} -o ${TGT[0].name}' -cls = Task.simple_task_type('bison', bison, 'GREEN', ext_in='.yc .y .yy', ext_out='.c .cxx .h .l', shell=False) - -@extension(['.y', '.yc', '.yy']) -def big_bison(self, node): - """when it becomes complicated (unlike flex), the old recipes work better (cwd)""" - has_h = '-d' in self.env['BISONFLAGS'] - - outs = [] - if node.name.endswith('.yc'): - outs.append(node.change_ext('.tab.cc')) - if has_h: - outs.append(node.change_ext('.tab.hh')) - else: - outs.append(node.change_ext('.tab.c')) - if has_h: - outs.append(node.change_ext('.tab.h')) - - tsk = self.create_task('bison', node, outs) - tsk.cwd = node.bld_dir(tsk.env) - - # and the c/cxx file must be compiled too - self.allnodes.append(outs[0]) - -def detect(conf): - bison = conf.find_program('bison', var='BISON', mandatory=True) - conf.env['BISONFLAGS'] = '-d' diff --git a/third_party/waf/wafadmin/Tools/cc.py b/third_party/waf/wafadmin/Tools/cc.py deleted file mode 100644 index 7eb5272d69a..00000000000 --- a/third_party/waf/wafadmin/Tools/cc.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -"Base for c programs/libraries" - -import os -import TaskGen, Build, Utils, Task -from Logs import debug -import ccroot -from TaskGen import feature, before, extension, after - -g_cc_flag_vars = [ -'CCDEPS', 'FRAMEWORK', 'FRAMEWORKPATH', -'STATICLIB', 'LIB', 'LIBPATH', 'LINKFLAGS', 'RPATH', -'CCFLAGS', 'CPPPATH', 'CPPFLAGS', 'CCDEFINES'] - -EXT_CC = ['.c'] - -g_cc_type_vars = ['CCFLAGS', 'LINKFLAGS'] - -# TODO remove in waf 1.6 -class cc_taskgen(ccroot.ccroot_abstract): - pass - -@feature('c', 'cc') -@before('apply_type_vars') -@after('default_cc') -def init_cc(self): - self.p_flag_vars = set(self.p_flag_vars).union(g_cc_flag_vars) - self.p_type_vars = set(self.p_type_vars).union(g_cc_type_vars) - - if not self.env['CC_NAME']: - raise Utils.WafError("At least one compiler (gcc, ..) must be selected") - -@feature('c', 'cc') -@after('apply_incpaths') -def apply_obj_vars_cc(self): - """after apply_incpaths for INC_PATHS""" - env = self.env - app = env.append_unique - cpppath_st = env['CPPPATH_ST'] - - # local flags come first - # set the user-defined includes paths - for i in env['INC_PATHS']: - app('_CCINCFLAGS', cpppath_st % i.bldpath(env)) - app('_CCINCFLAGS', cpppath_st % i.srcpath(env)) - - # set the library include paths - for i in env['CPPPATH']: - app('_CCINCFLAGS', cpppath_st % i) - -@feature('c', 'cc') -@after('apply_lib_vars') -def apply_defines_cc(self): - """after uselib is set for CCDEFINES""" - self.defines = getattr(self, 'defines', []) - lst = self.to_list(self.defines) + self.to_list(self.env['CCDEFINES']) - milst = [] - - # now process the local defines - for defi in lst: - if not defi in milst: - milst.append(defi) - - # CCDEFINES_ - libs = self.to_list(self.uselib) - for l in libs: - val = self.env['CCDEFINES_'+l] - if val: milst += val - self.env['DEFLINES'] = ["%s %s" % (x[0], Utils.trimquotes('='.join(x[1:]))) for x in [y.split('=') for y in milst]] - y = self.env['CCDEFINES_ST'] - self.env.append_unique('_CCDEFFLAGS', [y%x for x in milst]) - -@extension(EXT_CC) -def c_hook(self, node): - # create the compilation task: cpp or cc - if getattr(self, 'obj_ext', None): - obj_ext = self.obj_ext - else: - obj_ext = '_%d.o' % self.idx - - task = self.create_task('cc', node, node.change_ext(obj_ext)) - try: - self.compiled_tasks.append(task) - except AttributeError: - raise Utils.WafError('Have you forgotten to set the feature "cc" on %s?' % str(self)) - return task - -cc_str = '${CC} ${CCFLAGS} ${CPPFLAGS} ${_CCINCFLAGS} ${_CCDEFFLAGS} ${CC_SRC_F}${SRC} ${CC_TGT_F}${TGT}' -cls = Task.simple_task_type('cc', cc_str, 'GREEN', ext_out='.o', ext_in='.c', shell=False) -cls.scan = ccroot.scan -cls.vars.append('CCDEPS') - -link_str = '${LINK_CC} ${CCLNK_SRC_F}${SRC} ${CCLNK_TGT_F}${TGT[0].abspath(env)} ${LINKFLAGS}' -cls = Task.simple_task_type('cc_link', link_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) -cls.maxjobs = 1 -cls.install = Utils.nada diff --git a/third_party/waf/wafadmin/Tools/ccroot.py b/third_party/waf/wafadmin/Tools/ccroot.py deleted file mode 100644 index 2240b2f3ae2..00000000000 --- a/third_party/waf/wafadmin/Tools/ccroot.py +++ /dev/null @@ -1,639 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2005-2008 (ita) - -"base for all c/c++ programs and libraries" - -import os, sys, re -import TaskGen, Task, Utils, preproc, Logs, Build, Options -from Logs import error, debug, warn -from Utils import md5 -from TaskGen import taskgen, after, before, feature -from Constants import * -from Configure import conftest -try: - from cStringIO import StringIO -except ImportError: - from io import StringIO - -import config_c # <- necessary for the configuration, do not touch - -USE_TOP_LEVEL = False - -def get_cc_version(conf, cc, gcc=False, icc=False): - - cmd = cc + ['-dM', '-E', '-'] - try: - p = Utils.pproc.Popen(cmd, stdin=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE) - p.stdin.write('\n') - out = p.communicate()[0] - except: - conf.fatal('could not determine the compiler version %r' % cmd) - - # PY3K: do not touch - out = str(out) - - if gcc: - if out.find('__INTEL_COMPILER') >= 0: - conf.fatal('The intel compiler pretends to be gcc') - if out.find('__GNUC__') < 0: - conf.fatal('Could not determine the compiler type') - - if icc and out.find('__INTEL_COMPILER') < 0: - conf.fatal('Not icc/icpc') - - k = {} - if icc or gcc: - out = out.split('\n') - import shlex - - for line in out: - lst = shlex.split(line) - if len(lst)>2: - key = lst[1] - val = lst[2] - k[key] = val - - def isD(var): - return var in k - - def isT(var): - return var in k and k[var] != '0' - - # Some documentation is available at http://predef.sourceforge.net - # The names given to DEST_OS must match what Utils.unversioned_sys_platform() returns. - mp1 = { - '__linux__' : 'linux', - '__GNU__' : 'gnu', - '__FreeBSD__' : 'freebsd', - '__NetBSD__' : 'netbsd', - '__OpenBSD__' : 'openbsd', - '__sun' : 'sunos', - '__hpux' : 'hpux', - '__sgi' : 'irix', - '_AIX' : 'aix', - '__CYGWIN__' : 'cygwin', - '__MSYS__' : 'msys', - '_UWIN' : 'uwin', - '_WIN64' : 'win32', - '_WIN32' : 'win32', - '__POWERPC__' : 'powerpc', - } - - for i in mp1: - if isD(i): - conf.env.DEST_OS = mp1[i] - break - else: - if isD('__APPLE__') and isD('__MACH__'): - conf.env.DEST_OS = 'darwin' - elif isD('__unix__'): # unix must be tested last as it's a generic fallback - conf.env.DEST_OS = 'generic' - - if isD('__ELF__'): - conf.env.DEST_BINFMT = 'elf' - elif isD('__WINNT__') or isD('__CYGWIN__'): - conf.env.DEST_BINFMT = 'pe' - elif isD('__APPLE__'): - conf.env.DEST_BINFMT = 'mac-o' - - mp2 = { - '__x86_64__' : 'x86_64', - '__i386__' : 'x86', - '__ia64__' : 'ia', - '__mips__' : 'mips', - '__sparc__' : 'sparc', - '__alpha__' : 'alpha', - '__arm__' : 'arm', - '__hppa__' : 'hppa', - '__powerpc__' : 'powerpc', - } - for i in mp2: - if isD(i): - conf.env.DEST_CPU = mp2[i] - break - - debug('ccroot: dest platform: ' + ' '.join([conf.env[x] or '?' for x in ('DEST_OS', 'DEST_BINFMT', 'DEST_CPU')])) - conf.env['CC_VERSION'] = (k['__GNUC__'], k['__GNUC_MINOR__'], k['__GNUC_PATCHLEVEL__']) - return k - -class DEBUG_LEVELS: - """Will disappear in waf 1.6""" - ULTRADEBUG = "ultradebug" - DEBUG = "debug" - RELEASE = "release" - OPTIMIZED = "optimized" - CUSTOM = "custom" - - ALL = [ULTRADEBUG, DEBUG, RELEASE, OPTIMIZED, CUSTOM] - -def scan(self): - "look for .h the .cpp need" - debug('ccroot: _scan_preprocessor(self, node, env, path_lst)') - - # TODO waf 1.6 - assume the default input has exactly one file - - if len(self.inputs) == 1: - node = self.inputs[0] - (nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS']) - if Logs.verbose: - debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names) - return (nodes, names) - - all_nodes = [] - all_names = [] - seen = set() - for node in self.inputs: - (nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS']) - if Logs.verbose: - debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names) - for x in nodes: - if id(x) in seen: continue - seen.add(id(x)) - all_nodes.append(x) - for x in names: - if not x in all_names: - all_names.append(x) - return (all_nodes, all_names) - -class ccroot_abstract(TaskGen.task_gen): - "Parent class for programs and libraries in languages c, c++ and moc (Qt)" - def __init__(self, *k, **kw): - # COMPAT remove in waf 1.6 TODO - if len(k) > 1: - k = list(k) - if k[1][0] != 'c': - k[1] = 'c' + k[1] - TaskGen.task_gen.__init__(self, *k, **kw) - -def get_target_name(self): - tp = 'program' - for x in self.features: - if x in ['cshlib', 'cstaticlib']: - tp = x.lstrip('c') - - pattern = self.env[tp + '_PATTERN'] - if not pattern: pattern = '%s' - - dir, name = os.path.split(self.target) - - if 'cshlib' in self.features and getattr(self, 'vnum', None): - nums = self.vnum.split('.') - if self.env.DEST_BINFMT == 'pe': - # include the version in the dll file name, - # the import lib file name stays unversionned. - name = name + '-' + nums[0] - elif self.env.DEST_OS == 'openbsd': - pattern = '%s.%s' % (pattern, nums[0]) - if len(nums) >= 2: - pattern += '.%s' % nums[1] - - return os.path.join(dir, pattern % name) - -@feature('c', 'cc', 'cxx') -@before('apply_core') -def default_cc(self): - """compiled_tasks attribute must be set before the '.c->.o' tasks can be created""" - Utils.def_attrs(self, - includes = '', - defines= '', - rpaths = '', - uselib = '', - uselib_local = '', - add_objects = '', - p_flag_vars = [], - p_type_vars = [], - compiled_tasks = [], - link_task = None) - - # The only thing we need for cross-compilation is DEST_BINFMT. - # At some point, we may reach a case where DEST_BINFMT is not enough, but for now it's sufficient. - # Currently, cross-compilation is auto-detected only for the gnu and intel compilers. - if not self.env.DEST_BINFMT: - # Infer the binary format from the os name. - self.env.DEST_BINFMT = Utils.unversioned_sys_platform_to_binary_format( - self.env.DEST_OS or Utils.unversioned_sys_platform()) - - if not self.env.BINDIR: self.env.BINDIR = Utils.subst_vars('${PREFIX}/bin', self.env) - if not self.env.LIBDIR: self.env.LIBDIR = Utils.subst_vars('${PREFIX}/lib${LIB_EXT}', self.env) - -@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib') -def apply_verif(self): - """no particular order, used for diagnostic""" - if not (self.source or getattr(self, 'add_objects', None) or getattr(self, 'uselib_local', None) or getattr(self, 'obj_files', None)): - raise Utils.WafError('no source files specified for %s' % self) - if not self.target: - raise Utils.WafError('no target for %s' % self) - -# TODO reference the d programs, shlibs in d.py, not here - -@feature('cprogram', 'dprogram') -@after('default_cc') -@before('apply_core') -def vars_target_cprogram(self): - self.default_install_path = self.env.BINDIR - self.default_chmod = O755 - -@after('default_cc') -@feature('cshlib', 'dshlib') -@before('apply_core') -def vars_target_cshlib(self): - if self.env.DEST_BINFMT == 'pe': - # set execute bit on libs to avoid 'permission denied' (issue 283) - self.default_chmod = O755 - self.default_install_path = self.env.BINDIR - else: - self.default_install_path = self.env.LIBDIR - -@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib') -@after('apply_link', 'vars_target_cprogram', 'vars_target_cshlib') -def default_link_install(self): - """you may kill this method to inject your own installation for the first element - any other install should only process its own nodes and not those from the others""" - if self.install_path: - self.bld.install_files(self.install_path, self.link_task.outputs[0], env=self.env, chmod=self.chmod) - -@feature('c', 'cc', 'cxx') -@after('apply_type_vars', 'apply_lib_vars', 'apply_core') -def apply_incpaths(self): - """used by the scanner - after processing the uselib for CPPPATH - after apply_core because some processing may add include paths - """ - lst = [] - # TODO move the uselib processing out of here - for lib in self.to_list(self.uselib): - for path in self.env['CPPPATH_' + lib]: - if not path in lst: - lst.append(path) - if preproc.go_absolute: - for path in preproc.standard_includes: - if not path in lst: - lst.append(path) - - for path in self.to_list(self.includes): - if not path in lst: - if preproc.go_absolute or not os.path.isabs(path): - lst.append(path) - else: - self.env.prepend_value('CPPPATH', path) - - for path in lst: - node = None - if os.path.isabs(path): - if preproc.go_absolute: - node = self.bld.root.find_dir(path) - elif path[0] == '#': - node = self.bld.srcnode - if len(path) > 1: - node = node.find_dir(path[1:]) - else: - node = self.path.find_dir(path) - - if node: - self.env.append_value('INC_PATHS', node) - - # TODO WAF 1.6 - if USE_TOP_LEVEL: - self.env.append_value('INC_PATHS', self.bld.srcnode) - -@feature('c', 'cc', 'cxx') -@after('init_cc', 'init_cxx') -@before('apply_lib_vars') -def apply_type_vars(self): - """before apply_lib_vars because we modify uselib - after init_cc and init_cxx because web need p_type_vars - """ - for x in self.features: - if not x in ['cprogram', 'cstaticlib', 'cshlib']: - continue - x = x.lstrip('c') - - # if the type defines uselib to add, add them - st = self.env[x + '_USELIB'] - if st: self.uselib = self.uselib + ' ' + st - - # each compiler defines variables like 'shlib_CXXFLAGS', 'shlib_LINKFLAGS', etc - # so when we make a task generator of the type shlib, CXXFLAGS are modified accordingly - for var in self.p_type_vars: - compvar = '%s_%s' % (x, var) - #print compvar - value = self.env[compvar] - if value: self.env.append_value(var, value) - -@feature('cprogram', 'cshlib', 'cstaticlib') -@after('apply_core') -def apply_link(self): - """executes after apply_core for collecting 'compiled_tasks' - use a custom linker if specified (self.link='name-of-custom-link-task')""" - link = getattr(self, 'link', None) - if not link: - if 'cstaticlib' in self.features: link = 'static_link' - elif 'cxx' in self.features: link = 'cxx_link' - else: link = 'cc_link' - - tsk = self.create_task(link) - outputs = [t.outputs[0] for t in self.compiled_tasks] - tsk.set_inputs(outputs) - tsk.set_outputs(self.path.find_or_declare(get_target_name(self))) - - self.link_task = tsk - -@feature('c', 'cc', 'cxx') -@after('apply_link', 'init_cc', 'init_cxx', 'apply_core') -def apply_lib_vars(self): - """after apply_link because of 'link_task' - after default_cc because of the attribute 'uselib'""" - - # after 'apply_core' in case if 'cc' if there is no link - - env = self.env - - # 1. the case of the libs defined in the project (visit ancestors first) - # the ancestors external libraries (uselib) will be prepended - self.uselib = self.to_list(self.uselib) - names = self.to_list(self.uselib_local) - - seen = set([]) - tmp = Utils.deque(names) # consume a copy of the list of names - while tmp: - lib_name = tmp.popleft() - # visit dependencies only once - if lib_name in seen: - continue - - y = self.name_to_obj(lib_name) - if not y: - raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name)) - y.post() - seen.add(lib_name) - - # object has ancestors to process (shared libraries): add them to the end of the list - if getattr(y, 'uselib_local', None): - lst = y.to_list(y.uselib_local) - if 'cshlib' in y.features or 'cprogram' in y.features: - lst = [x for x in lst if not 'cstaticlib' in self.name_to_obj(x).features] - tmp.extend(lst) - - # link task and flags - if getattr(y, 'link_task', None): - - link_name = y.target[y.target.rfind(os.sep) + 1:] - if 'cstaticlib' in y.features: - env.append_value('STATICLIB', link_name) - elif 'cshlib' in y.features or 'cprogram' in y.features: - # WARNING some linkers can link against programs - env.append_value('LIB', link_name) - - # the order - self.link_task.set_run_after(y.link_task) - - # for the recompilation - dep_nodes = getattr(self.link_task, 'dep_nodes', []) - self.link_task.dep_nodes = dep_nodes + y.link_task.outputs - - # add the link path too - tmp_path = y.link_task.outputs[0].parent.bldpath(self.env) - if not tmp_path in env['LIBPATH']: env.prepend_value('LIBPATH', tmp_path) - - # add ancestors uselib too - but only propagate those that have no staticlib - for v in self.to_list(y.uselib): - if not env['STATICLIB_' + v]: - if not v in self.uselib: - self.uselib.insert(0, v) - - # if the library task generator provides 'export_incdirs', add to the include path - # the export_incdirs must be a list of paths relative to the other library - if getattr(y, 'export_incdirs', None): - for x in self.to_list(y.export_incdirs): - node = y.path.find_dir(x) - if not node: - raise Utils.WafError('object %r: invalid folder %r in export_incdirs' % (y.target, x)) - self.env.append_unique('INC_PATHS', node) - - # 2. the case of the libs defined outside - for x in self.uselib: - for v in self.p_flag_vars: - val = self.env[v + '_' + x] - if val: self.env.append_value(v, val) - -@feature('cprogram', 'cstaticlib', 'cshlib') -@after('init_cc', 'init_cxx', 'apply_link') -def apply_objdeps(self): - "add the .o files produced by some other object files in the same manner as uselib_local" - if not getattr(self, 'add_objects', None): return - - seen = [] - names = self.to_list(self.add_objects) - while names: - x = names[0] - - # visit dependencies only once - if x in seen: - names = names[1:] - continue - - # object does not exist ? - y = self.name_to_obj(x) - if not y: - raise Utils.WafError('object %r was not found in uselib_local (required by add_objects %r)' % (x, self.name)) - - # object has ancestors to process first ? update the list of names - if getattr(y, 'add_objects', None): - added = 0 - lst = y.to_list(y.add_objects) - lst.reverse() - for u in lst: - if u in seen: continue - added = 1 - names = [u]+names - if added: continue # list of names modified, loop - - # safe to process the current object - y.post() - seen.append(x) - - for t in y.compiled_tasks: - self.link_task.inputs.extend(t.outputs) - -@feature('cprogram', 'cshlib', 'cstaticlib') -@after('apply_lib_vars') -def apply_obj_vars(self): - """after apply_lib_vars for uselib""" - v = self.env - lib_st = v['LIB_ST'] - staticlib_st = v['STATICLIB_ST'] - libpath_st = v['LIBPATH_ST'] - staticlibpath_st = v['STATICLIBPATH_ST'] - rpath_st = v['RPATH_ST'] - - app = v.append_unique - - if v['FULLSTATIC']: - v.append_value('LINKFLAGS', v['FULLSTATIC_MARKER']) - - for i in v['RPATH']: - if i and rpath_st: - app('LINKFLAGS', rpath_st % i) - - for i in v['LIBPATH']: - app('LINKFLAGS', libpath_st % i) - app('LINKFLAGS', staticlibpath_st % i) - - if v['STATICLIB']: - v.append_value('LINKFLAGS', v['STATICLIB_MARKER']) - k = [(staticlib_st % i) for i in v['STATICLIB']] - app('LINKFLAGS', k) - - # fully static binaries ? - if not v['FULLSTATIC']: - if v['STATICLIB'] or v['LIB']: - v.append_value('LINKFLAGS', v['SHLIB_MARKER']) - - app('LINKFLAGS', [lib_st % i for i in v['LIB']]) - -@after('apply_link') -def process_obj_files(self): - if not hasattr(self, 'obj_files'): return - for x in self.obj_files: - node = self.path.find_resource(x) - self.link_task.inputs.append(node) - -@taskgen -def add_obj_file(self, file): - """Small example on how to link object files as if they were source - obj = bld.create_obj('cc') - obj.add_obj_file('foo.o')""" - if not hasattr(self, 'obj_files'): self.obj_files = [] - if not 'process_obj_files' in self.meths: self.meths.append('process_obj_files') - self.obj_files.append(file) - -c_attrs = { -'cxxflag' : 'CXXFLAGS', -'cflag' : 'CCFLAGS', -'ccflag' : 'CCFLAGS', -'linkflag' : 'LINKFLAGS', -'ldflag' : 'LINKFLAGS', -'lib' : 'LIB', -'libpath' : 'LIBPATH', -'staticlib': 'STATICLIB', -'staticlibpath': 'STATICLIBPATH', -'rpath' : 'RPATH', -'framework' : 'FRAMEWORK', -'frameworkpath' : 'FRAMEWORKPATH' -} - -@feature('c', 'cc', 'cxx') -@before('init_cxx', 'init_cc') -@before('apply_lib_vars', 'apply_obj_vars', 'apply_incpaths', 'init_cc') -def add_extra_flags(self): - """case and plural insensitive - before apply_obj_vars for processing the library attributes - """ - for x in self.__dict__.keys(): - y = x.lower() - if y[-1] == 's': - y = y[:-1] - if c_attrs.get(y, None): - self.env.append_unique(c_attrs[y], getattr(self, x)) - -# ============ the code above must not know anything about import libs ========== - -@feature('cshlib') -@after('apply_link', 'default_cc') -@before('apply_lib_vars', 'apply_objdeps', 'default_link_install') -def apply_implib(self): - """On mswindows, handle dlls and their import libs - the .dll.a is the import lib and it is required for linking so it is installed too - """ - if not self.env.DEST_BINFMT == 'pe': - return - - self.meths.remove('default_link_install') - - bindir = self.install_path - if not bindir: return - - # install the dll in the bin dir - dll = self.link_task.outputs[0] - self.bld.install_files(bindir, dll, self.env, self.chmod) - - # add linker flags to generate the import lib - implib = self.env['implib_PATTERN'] % os.path.split(self.target)[1] - - implib = dll.parent.find_or_declare(implib) - self.link_task.outputs.append(implib) - self.bld.install_as('${LIBDIR}/%s' % implib.name, implib, self.env) - - self.env.append_value('LINKFLAGS', (self.env['IMPLIB_ST'] % implib.bldpath(self.env)).split()) - -# ============ the code above must not know anything about vnum processing on unix platforms ========= - -@feature('cshlib') -@after('apply_link') -@before('apply_lib_vars', 'default_link_install') -def apply_vnum(self): - """ - libfoo.so is installed as libfoo.so.1.2.3 - """ - if not getattr(self, 'vnum', '') or not 'cshlib' in self.features or os.name != 'posix' or self.env.DEST_BINFMT not in ('elf', 'mac-o'): - return - - self.meths.remove('default_link_install') - - link = self.link_task - nums = self.vnum.split('.') - node = link.outputs[0] - - libname = node.name - if libname.endswith('.dylib'): - name3 = libname.replace('.dylib', '.%s.dylib' % self.vnum) - name2 = libname.replace('.dylib', '.%s.dylib' % nums[0]) - else: - name3 = libname + '.' + self.vnum - name2 = libname + '.' + nums[0] - - if self.env.SONAME_ST: - v = self.env.SONAME_ST % name2 - self.env.append_value('LINKFLAGS', v.split()) - - bld = self.bld - nums = self.vnum.split('.') - - path = self.install_path - if not path: return - - if self.env.DEST_OS == 'openbsd': - libname = self.link_task.outputs[0].name - bld.install_as('%s%s%s' % (path, os.sep, libname), node, env=self.env) - else: - bld.install_as(path + os.sep + name3, node, env=self.env) - bld.symlink_as(path + os.sep + name2, name3) - bld.symlink_as(path + os.sep + libname, name3) - - # the following task is just to enable execution from the build dir :-/ - if self.env.DEST_OS != 'openbsd': - self.create_task('vnum', node, [node.parent.find_or_declare(name2), node.parent.find_or_declare(name3)]) - -def exec_vnum_link(self): - for x in self.outputs: - path = x.abspath(self.env) - try: - os.remove(path) - except OSError: - pass - - try: - os.symlink(self.inputs[0].name, path) - except OSError: - return 1 - -cls = Task.task_type_from_func('vnum', func=exec_vnum_link, ext_in='.bin', color='CYAN') -cls.quiet = 1 - -# ============ the --as-needed flag should added during the configuration, not at runtime ========= - -@conftest -def add_as_needed(conf): - if conf.env.DEST_BINFMT == 'elf' and 'gcc' in (conf.env.CXX_NAME, conf.env.CC_NAME): - conf.env.append_unique('LINKFLAGS', '--as-needed') diff --git a/third_party/waf/wafadmin/Tools/compiler_cc.py b/third_party/waf/wafadmin/Tools/compiler_cc.py deleted file mode 100644 index 642458aba61..00000000000 --- a/third_party/waf/wafadmin/Tools/compiler_cc.py +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Matthias Jahn jahn dôt matthias ât freenet dôt de, 2007 (pmarat) - -import os, sys, imp, types, ccroot -import optparse -import Utils, Configure, Options -from Logs import debug - -c_compiler = { - 'win32': ['msvc', 'gcc'], - 'cygwin': ['gcc'], - 'darwin': ['gcc'], - 'aix': ['xlc', 'gcc'], - 'linux': ['gcc', 'icc', 'suncc'], - 'sunos': ['gcc', 'suncc'], - 'irix': ['gcc'], - 'hpux': ['gcc'], - 'gnu': ['gcc'], - 'default': ['gcc'] -} - -def __list_possible_compiler(platform): - try: - return c_compiler[platform] - except KeyError: - return c_compiler["default"] - -def detect(conf): - """ - for each compiler for the platform, try to configure the compiler - in theory the tools should raise a configuration error if the compiler - pretends to be something it is not (setting CC=icc and trying to configure gcc) - """ - try: test_for_compiler = Options.options.check_c_compiler - except AttributeError: conf.fatal("Add set_options(opt): opt.tool_options('compiler_cc')") - orig = conf.env - for compiler in test_for_compiler.split(): - conf.env = orig.copy() - try: - conf.check_tool(compiler) - except Configure.ConfigurationError, e: - debug('compiler_cc: %r' % e) - else: - if conf.env['CC']: - orig.table = conf.env.get_merged_dict() - conf.env = orig - conf.check_message(compiler, '', True) - conf.env['COMPILER_CC'] = compiler - break - conf.check_message(compiler, '', False) - break - else: - conf.fatal('could not configure a c compiler!') - -def set_options(opt): - build_platform = Utils.unversioned_sys_platform() - possible_compiler_list = __list_possible_compiler(build_platform) - test_for_compiler = ' '.join(possible_compiler_list) - cc_compiler_opts = opt.add_option_group("C Compiler Options") - cc_compiler_opts.add_option('--check-c-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_c_compiler") - - for c_compiler in test_for_compiler.split(): - opt.tool_options('%s' % c_compiler, option_group=cc_compiler_opts) diff --git a/third_party/waf/wafadmin/Tools/compiler_cxx.py b/third_party/waf/wafadmin/Tools/compiler_cxx.py deleted file mode 100644 index aa0b0e7d460..00000000000 --- a/third_party/waf/wafadmin/Tools/compiler_cxx.py +++ /dev/null @@ -1,61 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Matthias Jahn jahn dôt matthias ât freenet dôt de 2007 (pmarat) - -import os, sys, imp, types, ccroot -import optparse -import Utils, Configure, Options -from Logs import debug - -cxx_compiler = { -'win32': ['msvc', 'g++'], -'cygwin': ['g++'], -'darwin': ['g++'], -'aix': ['xlc++', 'g++'], -'linux': ['g++', 'icpc', 'sunc++'], -'sunos': ['g++', 'sunc++'], -'irix': ['g++'], -'hpux': ['g++'], -'gnu': ['g++'], -'default': ['g++'] -} - -def __list_possible_compiler(platform): - try: - return cxx_compiler[platform] - except KeyError: - return cxx_compiler["default"] - -def detect(conf): - try: test_for_compiler = Options.options.check_cxx_compiler - except AttributeError: raise Configure.ConfigurationError("Add set_options(opt): opt.tool_options('compiler_cxx')") - orig = conf.env - for compiler in test_for_compiler.split(): - try: - conf.env = orig.copy() - conf.check_tool(compiler) - except Configure.ConfigurationError, e: - debug('compiler_cxx: %r' % e) - else: - if conf.env['CXX']: - orig.table = conf.env.get_merged_dict() - conf.env = orig - conf.check_message(compiler, '', True) - conf.env['COMPILER_CXX'] = compiler - break - conf.check_message(compiler, '', False) - break - else: - conf.fatal('could not configure a cxx compiler!') - -def set_options(opt): - build_platform = Utils.unversioned_sys_platform() - possible_compiler_list = __list_possible_compiler(build_platform) - 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 cxx_compiler in test_for_compiler.split(): - opt.tool_options('%s' % cxx_compiler, option_group=cxx_compiler_opts) diff --git a/third_party/waf/wafadmin/Tools/compiler_d.py b/third_party/waf/wafadmin/Tools/compiler_d.py deleted file mode 100644 index 378277a25aa..00000000000 --- a/third_party/waf/wafadmin/Tools/compiler_d.py +++ /dev/null @@ -1,32 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2007 (dv) - -import os, sys, imp, types -import Utils, Configure, Options - -def detect(conf): - if getattr(Options.options, 'check_dmd_first', None): - test_for_compiler = ['dmd', 'gdc'] - else: - test_for_compiler = ['gdc', 'dmd'] - - for d_compiler in test_for_compiler: - try: - conf.check_tool(d_compiler) - except: - pass - else: - break - else: - conf.fatal('no suitable d compiler was found') - -def set_options(opt): - d_compiler_opts = opt.add_option_group('D Compiler Options') - d_compiler_opts.add_option('--check-dmd-first', action='store_true', - help='checks for the gdc compiler before dmd (default is the other way round)', - dest='check_dmd_first', - default=False) - - for d_compiler in ['gdc', 'dmd']: - opt.tool_options('%s' % d_compiler, option_group=d_compiler_opts) diff --git a/third_party/waf/wafadmin/Tools/config_c.py b/third_party/waf/wafadmin/Tools/config_c.py deleted file mode 100644 index cdf3b3ebb68..00000000000 --- a/third_party/waf/wafadmin/Tools/config_c.py +++ /dev/null @@ -1,754 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2005-2008 (ita) - -""" -c/c++ configuration routines -""" - -import os, imp, sys, shlex, shutil -from Utils import md5 -import Build, Utils, Configure, Task, Options, Logs, TaskGen -from Constants import * -from Configure import conf, conftest - -cfg_ver = { - 'atleast-version': '>=', - 'exact-version': '==', - 'max-version': '<=', -} - -SNIP1 = ''' - int main() { - void *p; - p=(void*)(%s); - return 0; -} -''' - -SNIP2 = ''' -int main() { - if ((%(type_name)s *) 0) return 0; - if (sizeof (%(type_name)s)) return 0; -} -''' - -SNIP3 = ''' -int main() { - return 0; -} -''' - -def parse_flags(line, uselib, env): - """pkg-config still has bugs on some platforms, and there are many -config programs, parsing flags is necessary :-/""" - - lst = shlex.split(line) - while lst: - x = lst.pop(0) - st = x[:2] - ot = x[2:] - app = env.append_value - if st == '-I' or st == '/I': - if not ot: ot = lst.pop(0) - app('CPPPATH_' + uselib, ot) - elif st == '-D': - if not ot: ot = lst.pop(0) - app('CXXDEFINES_' + uselib, ot) - app('CCDEFINES_' + uselib, ot) - elif st == '-l': - if not ot: ot = lst.pop(0) - app('LIB_' + uselib, ot) - elif st == '-L': - if not ot: ot = lst.pop(0) - app('LIBPATH_' + uselib, ot) - elif x == '-pthread' or x.startswith('+'): - app('CCFLAGS_' + uselib, x) - app('CXXFLAGS_' + uselib, x) - app('LINKFLAGS_' + uselib, x) - elif x == '-framework': - app('FRAMEWORK_' + uselib, lst.pop(0)) - elif x.startswith('-F'): - app('FRAMEWORKPATH_' + uselib, x[2:]) - elif x.startswith('-std'): - app('CCFLAGS_' + uselib, x) - app('CXXFLAGS_' + uselib, x) - app('LINKFLAGS_' + uselib, x) - # - # NOTE on special treatment of -Wl,-R and -Wl,-rpath: - # - # It is important to not put a library provided RPATH - # into the LINKFLAGS but in the RPATH instead, since - # the provided LINKFLAGS get prepended to our own internal - # RPATH later, and hence can potentially lead to linking - # in too old versions of our internal libs. - # - elif x == '-Wl,-rpath' or x == '-Wl,-R': - app('RPATH_' + uselib, lst.pop(0).lstrip('-Wl,')) - elif x.startswith('-Wl,-R,'): - app('RPATH_' + uselib, x[7:]) - elif x.startswith('-Wl,-R'): - app('RPATH_' + uselib, x[6:]) - elif x.startswith('-Wl,-rpath,'): - app('RPATH_' + uselib, x[11:]) - elif x.startswith('-Wl'): - app('LINKFLAGS_' + uselib, x) - elif x.startswith('-m') or x.startswith('-f'): - app('CCFLAGS_' + uselib, x) - app('CXXFLAGS_' + uselib, x) - -@conf -def ret_msg(self, f, kw): - """execute a function, when provided""" - if isinstance(f, str): - return f - return f(kw) - -@conf -def validate_cfg(self, kw): - if not 'path' in kw: - if not self.env.PKGCONFIG: - self.find_program('pkg-config', var='PKGCONFIG') - kw['path'] = self.env.PKGCONFIG - - # pkg-config version - if 'atleast_pkgconfig_version' in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for pkg-config version >= %s' % kw['atleast_pkgconfig_version'] - return - - # pkg-config --modversion - if 'modversion' in kw: - return - - if 'variables' in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for %s variables' % kw['package'] - return - - # checking for the version of a module, for the moment, one thing at a time - for x in cfg_ver.keys(): - y = x.replace('-', '_') - if y in kw: - if not 'package' in kw: - raise ValueError('%s requires a package' % x) - - if not 'msg' in kw: - kw['msg'] = 'Checking for %s %s %s' % (kw['package'], cfg_ver[x], kw[y]) - return - - if not 'msg' in kw: - kw['msg'] = 'Checking for %s' % (kw['package'] or kw['path']) - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - if not 'errmsg' in kw: - kw['errmsg'] = 'not found' - -@conf -def cmd_and_log(self, cmd, kw): - Logs.debug('runner: %s\n' % cmd) - if self.log: - self.log.write('%s\n' % cmd) - - try: - p = Utils.pproc.Popen(cmd, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE, shell=True) - (out, err) = p.communicate() - except OSError, e: - self.log.write('error %r' % e) - self.fatal(str(e)) - - # placeholder, don't touch - out = str(out) - err = str(err) - - if self.log: - self.log.write(out) - self.log.write(err) - - if p.returncode: - if not kw.get('errmsg', ''): - if kw.get('mandatory', False): - kw['errmsg'] = out.strip() - else: - kw['errmsg'] = 'no' - self.fatal('fail') - return out - -@conf -def exec_cfg(self, kw): - - # pkg-config version - if 'atleast_pkgconfig_version' in kw: - cmd = '%s --atleast-pkgconfig-version=%s' % (kw['path'], kw['atleast_pkgconfig_version']) - self.cmd_and_log(cmd, kw) - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - return - - # checking for the version of a module - for x in cfg_ver: - y = x.replace('-', '_') - if y in kw: - self.cmd_and_log('%s --%s=%s %s' % (kw['path'], x, kw[y], kw['package']), kw) - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0) - break - - # retrieving the version of a module - if 'modversion' in kw: - version = self.cmd_and_log('%s --modversion %s' % (kw['path'], kw['modversion']), kw).strip() - self.define('%s_VERSION' % Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])), version) - return version - - # retrieving variables of a module - if 'variables' in kw: - env = kw.get('env', self.env) - uselib = kw.get('uselib_store', kw['package'].upper()) - vars = Utils.to_list(kw['variables']) - for v in vars: - val = self.cmd_and_log('%s --variable=%s %s' % (kw['path'], v, kw['package']), kw).strip() - var = '%s_%s' % (uselib, v) - env[var] = val - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - return - - lst = [kw['path']] - - - defi = kw.get('define_variable', None) - if not defi: - defi = self.env.PKG_CONFIG_DEFINES or {} - for key, val in defi.iteritems(): - lst.append('--define-variable=%s=%s' % (key, val)) - - lst.append(kw.get('args', '')) - lst.append(kw['package']) - - # so we assume the command-line will output flags to be parsed afterwards - cmd = ' '.join(lst) - ret = self.cmd_and_log(cmd, kw) - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - - self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0) - parse_flags(ret, kw.get('uselib_store', kw['package'].upper()), kw.get('env', self.env)) - return ret - -@conf -def check_cfg(self, *k, **kw): - """ - for pkg-config mostly, but also all the -config tools - conf.check_cfg(path='mpicc', args='--showme:compile --showme:link', package='', uselib_store='OPEN_MPI') - conf.check_cfg(package='dbus-1', variables='system_bus_default_address session_bus_services_dir') - """ - - self.validate_cfg(kw) - if 'msg' in kw: - self.check_message_1(kw['msg']) - ret = None - try: - ret = self.exec_cfg(kw) - except Configure.ConfigurationError, e: - if 'errmsg' in kw: - self.check_message_2(kw['errmsg'], 'YELLOW') - if 'mandatory' in kw and kw['mandatory']: - if Logs.verbose > 1: - raise - else: - self.fatal('the configuration failed (see %r)' % self.log.name) - else: - kw['success'] = ret - if 'okmsg' in kw: - self.check_message_2(self.ret_msg(kw['okmsg'], kw)) - - return ret - -# the idea is the following: now that we are certain -# that all the code here is only for c or c++, it is -# easy to put all the logic in one function -# -# this should prevent code duplication (ita) - -# env: an optional environment (modified -> provide a copy) -# compiler: cc or cxx - it tries to guess what is best -# type: cprogram, cshlib, cstaticlib -# code: a c code to execute -# uselib_store: where to add the variables -# uselib: parameters to use for building -# define: define to set, like FOO in #define FOO, if not set, add /* #undef FOO */ -# execute: True or False - will return the result of the execution - -@conf -def validate_c(self, kw): - """validate the parameters for the test method""" - - if not 'env' in kw: - kw['env'] = self.env.copy() - - env = kw['env'] - if not 'compiler' in kw: - kw['compiler'] = 'cc' - if env['CXX_NAME'] and Task.TaskBase.classes.get('cxx', None): - kw['compiler'] = 'cxx' - if not self.env['CXX']: - self.fatal('a c++ compiler is required') - else: - if not self.env['CC']: - self.fatal('a c compiler is required') - - if not 'type' in kw: - kw['type'] = 'cprogram' - - assert not(kw['type'] != 'cprogram' and kw.get('execute', 0)), 'can only execute programs' - - - #if kw['type'] != 'program' and kw.get('execute', 0): - # raise ValueError, 'can only execute programs' - - def to_header(dct): - if 'header_name' in dct: - dct = Utils.to_list(dct['header_name']) - return ''.join(['#include <%s>\n' % x for x in dct]) - return '' - - # set the file name - if not 'compile_mode' in kw: - kw['compile_mode'] = (kw['compiler'] == 'cxx') and 'cxx' or 'cc' - - if not 'compile_filename' in kw: - kw['compile_filename'] = 'test.c' + ((kw['compile_mode'] == 'cxx') and 'pp' or '') - - #OSX - if 'framework_name' in kw: - try: TaskGen.task_gen.create_task_macapp - except AttributeError: self.fatal('frameworks require the osx tool') - - fwkname = kw['framework_name'] - if not 'uselib_store' in kw: - kw['uselib_store'] = fwkname.upper() - - if not kw.get('no_header', False): - if not 'header_name' in kw: - kw['header_name'] = [] - fwk = '%s/%s.h' % (fwkname, fwkname) - if kw.get('remove_dot_h', None): - fwk = fwk[:-2] - kw['header_name'] = Utils.to_list(kw['header_name']) + [fwk] - - kw['msg'] = 'Checking for framework %s' % fwkname - kw['framework'] = fwkname - #kw['frameworkpath'] = set it yourself - - if 'function_name' in kw: - fu = kw['function_name'] - if not 'msg' in kw: - kw['msg'] = 'Checking for function %s' % fu - kw['code'] = to_header(kw) + SNIP1 % fu - if not 'uselib_store' in kw: - kw['uselib_store'] = fu.upper() - if not 'define_name' in kw: - kw['define_name'] = self.have_define(fu) - - elif 'type_name' in kw: - tu = kw['type_name'] - if not 'msg' in kw: - kw['msg'] = 'Checking for type %s' % tu - if not 'header_name' in kw: - kw['header_name'] = 'stdint.h' - kw['code'] = to_header(kw) + SNIP2 % {'type_name' : tu} - if not 'define_name' in kw: - kw['define_name'] = self.have_define(tu.upper()) - - elif 'header_name' in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for header %s' % kw['header_name'] - - l = Utils.to_list(kw['header_name']) - assert len(l)>0, 'list of headers in header_name is empty' - - kw['code'] = to_header(kw) + SNIP3 - - if not 'uselib_store' in kw: - kw['uselib_store'] = l[0].upper() - - if not 'define_name' in kw: - kw['define_name'] = self.have_define(l[0]) - - if 'lib' in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for library %s' % kw['lib'] - if not 'uselib_store' in kw: - kw['uselib_store'] = kw['lib'].upper() - - if 'staticlib' in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for static library %s' % kw['staticlib'] - if not 'uselib_store' in kw: - kw['uselib_store'] = kw['staticlib'].upper() - - if 'fragment' in kw: - # an additional code fragment may be provided to replace the predefined code - # in custom headers - kw['code'] = kw['fragment'] - if not 'msg' in kw: - kw['msg'] = 'Checking for custom code' - if not 'errmsg' in kw: - kw['errmsg'] = 'no' - - for (flagsname,flagstype) in [('cxxflags','compiler'), ('cflags','compiler'), ('linkflags','linker')]: - if flagsname in kw: - if not 'msg' in kw: - kw['msg'] = 'Checking for %s flags %s' % (flagstype, kw[flagsname]) - if not 'errmsg' in kw: - kw['errmsg'] = 'no' - - if not 'execute' in kw: - kw['execute'] = False - - if not 'errmsg' in kw: - kw['errmsg'] = 'not found' - - if not 'okmsg' in kw: - kw['okmsg'] = 'yes' - - if not 'code' in kw: - kw['code'] = SNIP3 - - if not kw.get('success'): kw['success'] = None - - assert 'msg' in kw, 'invalid parameters, read http://freehackers.org/~tnagy/wafbook/single.html#config_helpers_c' - -@conf -def post_check(self, *k, **kw): - "set the variables after a test was run successfully" - - is_success = False - if kw['execute']: - if kw['success'] is not None: - is_success = True - else: - is_success = (kw['success'] == 0) - - if 'define_name' in kw: - if 'header_name' in kw or 'function_name' in kw or 'type_name' in kw or 'fragment' in kw: - if kw['execute']: - key = kw['success'] - if isinstance(key, str): - if key: - self.define(kw['define_name'], key, quote=kw.get('quote', 1)) - else: - self.define_cond(kw['define_name'], True) - else: - self.define_cond(kw['define_name'], False) - else: - self.define_cond(kw['define_name'], is_success) - - if is_success and 'uselib_store' in kw: - import cc, cxx - for k in set(cc.g_cc_flag_vars).union(cxx.g_cxx_flag_vars): - lk = k.lower() - # inconsistency: includes -> CPPPATH - if k == 'CPPPATH': lk = 'includes' - if k == 'CXXDEFINES': lk = 'defines' - if k == 'CCDEFINES': lk = 'defines' - if lk in kw: - val = kw[lk] - # remove trailing slash - if isinstance(val, str): - val = val.rstrip(os.path.sep) - self.env.append_unique(k + '_' + kw['uselib_store'], val) - -@conf -def check(self, *k, **kw): - # so this will be the generic function - # it will be safer to use check_cxx or check_cc - self.validate_c(kw) - self.check_message_1(kw['msg']) - ret = None - try: - ret = self.run_c_code(*k, **kw) - except Configure.ConfigurationError, e: - self.check_message_2(kw['errmsg'], 'YELLOW') - if 'mandatory' in kw and kw['mandatory']: - if Logs.verbose > 1: - raise - else: - self.fatal('the configuration failed (see %r)' % self.log.name) - else: - kw['success'] = ret - self.check_message_2(self.ret_msg(kw['okmsg'], kw)) - - self.post_check(*k, **kw) - if not kw.get('execute', False): - return ret == 0 - return ret - -@conf -def run_c_code(self, *k, **kw): - test_f_name = kw['compile_filename'] - - k = 0 - while k < 10000: - # make certain to use a fresh folder - necessary for win32 - dir = os.path.join(self.blddir, '.conf_check_%d' % k) - - # if the folder already exists, remove it - try: - shutil.rmtree(dir) - except OSError: - pass - - try: - os.stat(dir) - except OSError: - break - - k += 1 - - try: - os.makedirs(dir) - except: - self.fatal('cannot create a configuration test folder %r' % dir) - - try: - os.stat(dir) - except: - self.fatal('cannot use the configuration test folder %r' % dir) - - bdir = os.path.join(dir, 'testbuild') - - if not os.path.exists(bdir): - os.makedirs(bdir) - - env = kw['env'] - - dest = open(os.path.join(dir, test_f_name), 'w') - dest.write(kw['code']) - dest.close() - - back = os.path.abspath('.') - - bld = Build.BuildContext() - bld.log = self.log - bld.all_envs.update(self.all_envs) - bld.all_envs['default'] = env - bld.lst_variants = bld.all_envs.keys() - bld.load_dirs(dir, bdir) - - os.chdir(dir) - - bld.rescan(bld.srcnode) - - if not 'features' in kw: - # conf.check(features='cc cprogram pyext', ...) - kw['features'] = [kw['compile_mode'], kw['type']] # "cprogram cc" - - o = bld(features=kw['features'], source=test_f_name, target='testprog') - - for k, v in kw.iteritems(): - setattr(o, k, v) - - self.log.write("==>\n%s\n<==\n" % kw['code']) - - # compile the program - try: - bld.compile() - except Utils.WafError: - ret = Utils.ex_stack() - else: - ret = 0 - - # chdir before returning - os.chdir(back) - - if ret: - self.log.write('command returned %r' % ret) - self.fatal(str(ret)) - - # if we need to run the program, try to get its result - # keep the name of the program to execute - if kw['execute']: - lastprog = o.link_task.outputs[0].abspath(env) - - args = Utils.to_list(kw.get('exec_args', [])) - proc = Utils.pproc.Popen([lastprog] + args, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE) - (out, err) = proc.communicate() - w = self.log.write - w(str(out)) - w('\n') - w(str(err)) - w('\n') - w('returncode %r' % proc.returncode) - w('\n') - if proc.returncode: - self.fatal(Utils.ex_stack()) - ret = out - - return ret - -@conf -def check_cxx(self, *k, **kw): - kw['compiler'] = 'cxx' - return self.check(*k, **kw) - -@conf -def check_cc(self, *k, **kw): - kw['compiler'] = 'cc' - return self.check(*k, **kw) - -@conf -def define(self, define, value, quote=1): - """store a single define and its state into an internal list for later - writing to a config header file. Value can only be - a string or int; other types not supported. String - values will appear properly quoted in the generated - header file.""" - assert define and isinstance(define, str) - - # ordered_dict is for writing the configuration header in order - tbl = self.env[DEFINES] or Utils.ordered_dict() - - # the user forgot to tell if the value is quoted or not - if isinstance(value, str): - if quote: - tbl[define] = '"%s"' % repr('"'+value)[2:-1].replace('"', '\\"') - else: - tbl[define] = value - elif isinstance(value, int): - tbl[define] = value - else: - raise TypeError('define %r -> %r must be a string or an int' % (define, value)) - - # add later to make reconfiguring faster - self.env[DEFINES] = tbl - self.env[define] = value # <- not certain this is necessary - -@conf -def undefine(self, define): - """store a single define and its state into an internal list - for later writing to a config header file""" - assert define and isinstance(define, str) - - tbl = self.env[DEFINES] or Utils.ordered_dict() - - value = UNDEFINED - tbl[define] = value - - # add later to make reconfiguring faster - self.env[DEFINES] = tbl - self.env[define] = value - -@conf -def define_cond(self, name, value): - """Conditionally define a name. - Formally equivalent to: if value: define(name, 1) else: undefine(name)""" - if value: - self.define(name, 1) - else: - self.undefine(name) - -@conf -def is_defined(self, key): - defines = self.env[DEFINES] - if not defines: - return False - try: - value = defines[key] - except KeyError: - return False - else: - return value != UNDEFINED - -@conf -def get_define(self, define): - "get the value of a previously stored define" - try: return self.env[DEFINES][define] - except KeyError: return None - -@conf -def have_define(self, name): - "prefix the define with 'HAVE_' and make sure it has valid characters." - return self.__dict__.get('HAVE_PAT', 'HAVE_%s') % Utils.quote_define_name(name) - -@conf -def write_config_header(self, configfile='', env='', guard='', top=False): - "save the defines into a file" - if not configfile: configfile = WAF_CONFIG_H - waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile) - - # configfile -> absolute path - # there is a good reason to concatenate first and to split afterwards - if not env: env = self.env - if top: - diff = '' - else: - diff = Utils.diff_path(self.srcdir, self.curdir) - full = os.sep.join([self.blddir, env.variant(), diff, configfile]) - full = os.path.normpath(full) - (dir, base) = os.path.split(full) - - try: os.makedirs(dir) - except: pass - - dest = open(full, 'w') - dest.write('/* Configuration header created by Waf - do not edit */\n') - dest.write('#ifndef %s\n#define %s\n\n' % (waf_guard, waf_guard)) - - dest.write(self.get_config_header()) - - # config files are not removed on "waf clean" - env.append_unique(CFG_FILES, os.path.join(diff, configfile)) - - dest.write('\n#endif /* %s */\n' % waf_guard) - dest.close() - -@conf -def get_config_header(self): - """Fill-in the contents of the config header. Override when you need to write your own config header.""" - config_header = [] - - tbl = self.env[DEFINES] or Utils.ordered_dict() - for key in tbl.allkeys: - value = tbl[key] - if value is None: - config_header.append('#define %s' % key) - elif value is UNDEFINED: - config_header.append('/* #undef %s */' % key) - else: - config_header.append('#define %s %s' % (key, value)) - return "\n".join(config_header) - -@conftest -def find_cpp(conf): - v = conf.env - cpp = [] - if v['CPP']: cpp = v['CPP'] - elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] - if not cpp: cpp = conf.find_program('cpp', var='CPP') - #if not cpp: cpp = v['CC'] - #if not cpp: cpp = v['CXX'] - v['CPP'] = cpp - -@conftest -def cc_add_flags(conf): - conf.add_os_flags('CFLAGS', 'CCFLAGS') - conf.add_os_flags('CPPFLAGS') - -@conftest -def cxx_add_flags(conf): - conf.add_os_flags('CXXFLAGS') - conf.add_os_flags('CPPFLAGS') - -@conftest -def link_add_flags(conf): - conf.add_os_flags('LINKFLAGS') - conf.add_os_flags('LDFLAGS', 'LINKFLAGS') - -@conftest -def cc_load_tools(conf): - conf.check_tool('cc') - -@conftest -def cxx_load_tools(conf): - conf.check_tool('cxx') diff --git a/third_party/waf/wafadmin/Tools/cs.py b/third_party/waf/wafadmin/Tools/cs.py deleted file mode 100644 index 4c987d2a875..00000000000 --- a/third_party/waf/wafadmin/Tools/cs.py +++ /dev/null @@ -1,67 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -"C# support" - -import TaskGen, Utils, Task, Options -from Logs import error -from TaskGen import before, after, taskgen, feature - -flag_vars= ['FLAGS', 'ASSEMBLIES'] - -@feature('cs') -def init_cs(self): - Utils.def_attrs(self, - flags = '', - assemblies = '', - resources = '', - uselib = '') - -@feature('cs') -@after('init_cs') -def apply_uselib_cs(self): - if not self.uselib: - return - global flag_vars - for var in self.to_list(self.uselib): - for v in self.flag_vars: - val = self.env[v+'_'+var] - if val: self.env.append_value(v, val) - -@feature('cs') -@after('apply_uselib_cs') -@before('apply_core') -def apply_cs(self): - try: self.meths.remove('apply_core') - except ValueError: pass - - # process the flags for the assemblies - for i in self.to_list(self.assemblies) + self.env['ASSEMBLIES']: - self.env.append_unique('_ASSEMBLIES', '/r:'+i) - - # process the flags for the resources - for i in self.to_list(self.resources): - self.env.append_unique('_RESOURCES', '/resource:'+i) - - # what kind of assembly are we generating? - self.env['_TYPE'] = getattr(self, 'type', 'exe') - - # additional flags - self.env.append_unique('_FLAGS', self.to_list(self.flags)) - self.env.append_unique('_FLAGS', self.env.FLAGS) - - # process the sources - nodes = [self.path.find_resource(i) for i in self.to_list(self.source)] - self.create_task('mcs', nodes, self.path.find_or_declare(self.target)) - -Task.simple_task_type('mcs', '${MCS} ${SRC} /target:${_TYPE} /out:${TGT} ${_FLAGS} ${_ASSEMBLIES} ${_RESOURCES}', color='YELLOW') - -def detect(conf): - csc = getattr(Options.options, 'cscbinary', None) - if csc: - conf.env.MCS = csc - conf.find_program(['gmcs', 'mcs'], var='MCS') - -def set_options(opt): - opt.add_option('--with-csc-binary', type='string', dest='cscbinary') diff --git a/third_party/waf/wafadmin/Tools/cxx.py b/third_party/waf/wafadmin/Tools/cxx.py deleted file mode 100644 index 184fee3e065..00000000000 --- a/third_party/waf/wafadmin/Tools/cxx.py +++ /dev/null @@ -1,103 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2005 (ita) - -"Base for c++ programs and libraries" - -import TaskGen, Task, Utils -from Logs import debug -import ccroot # <- do not remove -from TaskGen import feature, before, extension, after - -g_cxx_flag_vars = [ -'CXXDEPS', 'FRAMEWORK', 'FRAMEWORKPATH', -'STATICLIB', 'LIB', 'LIBPATH', 'LINKFLAGS', 'RPATH', -'CXXFLAGS', 'CCFLAGS', 'CPPPATH', 'CPPFLAGS', 'CXXDEFINES'] -"main cpp variables" - -EXT_CXX = ['.cpp', '.cc', '.cxx', '.C', '.c++'] - -g_cxx_type_vars=['CXXFLAGS', 'LINKFLAGS'] - -# TODO remove in waf 1.6 -class cxx_taskgen(ccroot.ccroot_abstract): - pass - -@feature('cxx') -@before('apply_type_vars') -@after('default_cc') -def init_cxx(self): - if not 'cc' in self.features: - self.mappings['.c'] = TaskGen.task_gen.mappings['.cxx'] - - self.p_flag_vars = set(self.p_flag_vars).union(g_cxx_flag_vars) - self.p_type_vars = set(self.p_type_vars).union(g_cxx_type_vars) - - if not self.env['CXX_NAME']: - raise Utils.WafError("At least one compiler (g++, ..) must be selected") - -@feature('cxx') -@after('apply_incpaths') -def apply_obj_vars_cxx(self): - """after apply_incpaths for INC_PATHS""" - env = self.env - app = env.append_unique - cxxpath_st = env['CPPPATH_ST'] - - # local flags come first - # set the user-defined includes paths - for i in env['INC_PATHS']: - app('_CXXINCFLAGS', cxxpath_st % i.bldpath(env)) - app('_CXXINCFLAGS', cxxpath_st % i.srcpath(env)) - - # set the library include paths - for i in env['CPPPATH']: - app('_CXXINCFLAGS', cxxpath_st % i) - -@feature('cxx') -@after('apply_lib_vars') -def apply_defines_cxx(self): - """after uselib is set for CXXDEFINES""" - self.defines = getattr(self, 'defines', []) - lst = self.to_list(self.defines) + self.to_list(self.env['CXXDEFINES']) - milst = [] - - # now process the local defines - for defi in lst: - if not defi in milst: - milst.append(defi) - - # CXXDEFINES_USELIB - libs = self.to_list(self.uselib) - for l in libs: - val = self.env['CXXDEFINES_'+l] - if val: milst += self.to_list(val) - - self.env['DEFLINES'] = ["%s %s" % (x[0], Utils.trimquotes('='.join(x[1:]))) for x in [y.split('=') for y in milst]] - y = self.env['CXXDEFINES_ST'] - self.env.append_unique('_CXXDEFFLAGS', [y%x for x in milst]) - -@extension(EXT_CXX) -def cxx_hook(self, node): - # create the compilation task: cpp or cc - if getattr(self, 'obj_ext', None): - obj_ext = self.obj_ext - else: - obj_ext = '_%d.o' % self.idx - - task = self.create_task('cxx', node, node.change_ext(obj_ext)) - try: - self.compiled_tasks.append(task) - except AttributeError: - raise Utils.WafError('Have you forgotten to set the feature "cxx" on %s?' % str(self)) - return task - -cxx_str = '${CXX} ${CXXFLAGS} ${CPPFLAGS} ${_CXXINCFLAGS} ${_CXXDEFFLAGS} ${CXX_SRC_F}${SRC} ${CXX_TGT_F}${TGT}' -cls = Task.simple_task_type('cxx', cxx_str, color='GREEN', ext_out='.o', ext_in='.cxx', shell=False) -cls.scan = ccroot.scan -cls.vars.append('CXXDEPS') - -link_str = '${LINK_CXX} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath(env)} ${LINKFLAGS}' -cls = Task.simple_task_type('cxx_link', link_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) -cls.maxjobs = 1 -cls.install = Utils.nada diff --git a/third_party/waf/wafadmin/Tools/d.py b/third_party/waf/wafadmin/Tools/d.py deleted file mode 100644 index 2c2e94857e3..00000000000 --- a/third_party/waf/wafadmin/Tools/d.py +++ /dev/null @@ -1,534 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2007 (dv) -# Thomas Nagy, 2007-2008 (ita) - -import os, sys, re, optparse -import ccroot # <- leave this -import TaskGen, Utils, Task, Configure, Logs, Build -from Logs import debug, error -from TaskGen import taskgen, feature, after, before, extension -from Configure import conftest - -EXT_D = ['.d', '.di', '.D'] -D_METHS = ['apply_core', 'apply_vnum', 'apply_objdeps'] # additional d methods - -DLIB = """ -version(D_Version2) { - import std.stdio; - int main() { - writefln("phobos2"); - return 0; - } -} else { - version(Tango) { - import tango.stdc.stdio; - int main() { - printf("tango"); - return 0; - } - } else { - import std.stdio; - int main() { - writefln("phobos1"); - return 0; - } - } -} -""" - -def filter_comments(filename): - txt = Utils.readf(filename) - i = 0 - buf = [] - max = len(txt) - begin = 0 - while i < max: - c = txt[i] - if c == '"' or c == "'": # skip a string or character literal - buf.append(txt[begin:i]) - delim = c - i += 1 - while i < max: - c = txt[i] - if c == delim: break - elif c == '\\': # skip the character following backslash - i += 1 - i += 1 - i += 1 - begin = i - elif c == '/': # try to replace a comment with whitespace - buf.append(txt[begin:i]) - i += 1 - if i == max: break - c = txt[i] - if c == '+': # eat nesting /+ +/ comment - i += 1 - nesting = 1 - c = None - while i < max: - prev = c - c = txt[i] - if prev == '/' and c == '+': - nesting += 1 - c = None - elif prev == '+' and c == '/': - nesting -= 1 - if nesting == 0: break - c = None - i += 1 - elif c == '*': # eat /* */ comment - i += 1 - c = None - while i < max: - prev = c - c = txt[i] - if prev == '*' and c == '/': break - i += 1 - elif c == '/': # eat // comment - i += 1 - while i < max and txt[i] != '\n': - i += 1 - else: # no comment - begin = i - 1 - continue - i += 1 - begin = i - buf.append(' ') - else: - i += 1 - buf.append(txt[begin:]) - return buf - -class d_parser(object): - def __init__(self, env, incpaths): - #self.code = '' - #self.module = '' - #self.imports = [] - - self.allnames = [] - - self.re_module = re.compile("module\s+([^;]+)") - self.re_import = re.compile("import\s+([^;]+)") - self.re_import_bindings = re.compile("([^:]+):(.*)") - self.re_import_alias = re.compile("[^=]+=(.+)") - - self.env = env - - self.nodes = [] - self.names = [] - - self.incpaths = incpaths - - def tryfind(self, filename): - found = 0 - for n in self.incpaths: - found = n.find_resource(filename.replace('.', '/') + '.d') - if found: - self.nodes.append(found) - self.waiting.append(found) - break - if not found: - if not filename in self.names: - self.names.append(filename) - - def get_strings(self, code): - #self.imports = [] - self.module = '' - lst = [] - - # get the module name (if present) - - mod_name = self.re_module.search(code) - if mod_name: - self.module = re.sub('\s+', '', mod_name.group(1)) # strip all whitespaces - - # go through the code, have a look at all import occurrences - - # first, lets look at anything beginning with "import" and ending with ";" - import_iterator = self.re_import.finditer(code) - if import_iterator: - for import_match in import_iterator: - import_match_str = re.sub('\s+', '', import_match.group(1)) # strip all whitespaces - - # does this end with an import bindings declaration? - # (import bindings always terminate the list of imports) - bindings_match = self.re_import_bindings.match(import_match_str) - if bindings_match: - import_match_str = bindings_match.group(1) - # if so, extract the part before the ":" (since the module declaration(s) is/are located there) - - # split the matching string into a bunch of strings, separated by a comma - matches = import_match_str.split(',') - - for match in matches: - alias_match = self.re_import_alias.match(match) - if alias_match: - # is this an alias declaration? (alias = module name) if so, extract the module name - match = alias_match.group(1) - - lst.append(match) - return lst - - def start(self, node): - self.waiting = [node] - # while the stack is not empty, add the dependencies - while self.waiting: - nd = self.waiting.pop(0) - self.iter(nd) - - def iter(self, node): - path = node.abspath(self.env) # obtain the absolute path - code = "".join(filter_comments(path)) # read the file and filter the comments - names = self.get_strings(code) # obtain the import strings - for x in names: - # optimization - if x in self.allnames: continue - self.allnames.append(x) - - # for each name, see if it is like a node or not - self.tryfind(x) - -def scan(self): - "look for .d/.di the .d source need" - env = self.env - gruik = d_parser(env, env['INC_PATHS']) - gruik.start(self.inputs[0]) - - if Logs.verbose: - debug('deps: nodes found for %s: %s %s' % (str(self.inputs[0]), str(gruik.nodes), str(gruik.names))) - #debug("deps found for %s: %s" % (str(node), str(gruik.deps)), 'deps') - return (gruik.nodes, gruik.names) - -def get_target_name(self): - "for d programs and libs" - v = self.env - tp = 'program' - for x in self.features: - if x in ['dshlib', 'dstaticlib']: - tp = x.lstrip('d') - return v['D_%s_PATTERN' % tp] % self.target - -d_params = { -'dflags': '', -'importpaths':'', -'libs':'', -'libpaths':'', -'generate_headers':False, -} - -@feature('d') -@before('apply_type_vars') -def init_d(self): - for x in d_params: - setattr(self, x, getattr(self, x, d_params[x])) - -class d_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - - # COMPAT - if len(k) > 1: - self.features.append('d' + k[1]) - -# okay, we borrow a few methods from ccroot -TaskGen.bind_feature('d', D_METHS) - -@feature('d') -@before('apply_d_libs') -def init_d(self): - Utils.def_attrs(self, - dflags='', - importpaths='', - libs='', - libpaths='', - uselib='', - uselib_local='', - generate_headers=False, # set to true if you want .di files as well as .o - compiled_tasks=[], - add_objects=[], - link_task=None) - -@feature('d') -@after('apply_d_link', 'init_d') -@before('apply_vnum', 'apply_d_vars') -def apply_d_libs(self): - """after apply_link because of 'link_task' - after default_cc because of the attribute 'uselib'""" - env = self.env - - # 1. the case of the libs defined in the project (visit ancestors first) - # the ancestors external libraries (uselib) will be prepended - self.uselib = self.to_list(self.uselib) - names = self.to_list(self.uselib_local) - - seen = set([]) - tmp = Utils.deque(names) # consume a copy of the list of names - while tmp: - lib_name = tmp.popleft() - # visit dependencies only once - if lib_name in seen: - continue - - y = self.name_to_obj(lib_name) - if not y: - raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name)) - y.post() - seen.add(lib_name) - - # object has ancestors to process (shared libraries): add them to the end of the list - if getattr(y, 'uselib_local', None): - lst = y.to_list(y.uselib_local) - if 'dshlib' in y.features or 'dprogram' in y.features: - lst = [x for x in lst if not 'dstaticlib' in self.name_to_obj(x).features] - tmp.extend(lst) - - # link task and flags - if getattr(y, 'link_task', None): - - link_name = y.target[y.target.rfind(os.sep) + 1:] - if 'dstaticlib' in y.features or 'dshlib' in y.features: - env.append_unique('DLINKFLAGS', env.DLIB_ST % link_name) - env.append_unique('DLINKFLAGS', env.DLIBPATH_ST % y.link_task.outputs[0].parent.bldpath(env)) - - # the order - self.link_task.set_run_after(y.link_task) - - # for the recompilation - dep_nodes = getattr(self.link_task, 'dep_nodes', []) - self.link_task.dep_nodes = dep_nodes + y.link_task.outputs - - # add ancestors uselib too - but only propagate those that have no staticlib - for v in self.to_list(y.uselib): - if not v in self.uselib: - self.uselib.insert(0, v) - - # if the library task generator provides 'export_incdirs', add to the include path - # the export_incdirs must be a list of paths relative to the other library - if getattr(y, 'export_incdirs', None): - for x in self.to_list(y.export_incdirs): - node = y.path.find_dir(x) - if not node: - raise Utils.WafError('object %r: invalid folder %r in export_incdirs' % (y.target, x)) - self.env.append_unique('INC_PATHS', node) - -@feature('dprogram', 'dshlib', 'dstaticlib') -@after('apply_core') -def apply_d_link(self): - link = getattr(self, 'link', None) - if not link: - if 'dstaticlib' in self.features: link = 'static_link' - else: link = 'd_link' - - outputs = [t.outputs[0] for t in self.compiled_tasks] - self.link_task = self.create_task(link, outputs, self.path.find_or_declare(get_target_name(self))) - -@feature('d') -@after('apply_core') -def apply_d_vars(self): - env = self.env - dpath_st = env['DPATH_ST'] - lib_st = env['DLIB_ST'] - libpath_st = env['DLIBPATH_ST'] - - importpaths = self.to_list(self.importpaths) - libpaths = [] - libs = [] - uselib = self.to_list(self.uselib) - - for i in uselib: - if env['DFLAGS_' + i]: - env.append_unique('DFLAGS', env['DFLAGS_' + i]) - - for x in self.features: - if not x in ['dprogram', 'dstaticlib', 'dshlib']: - continue - x.lstrip('d') - d_shlib_dflags = env['D_' + x + '_DFLAGS'] - if d_shlib_dflags: - env.append_unique('DFLAGS', d_shlib_dflags) - - # add import paths - for i in uselib: - if env['DPATH_' + i]: - for entry in self.to_list(env['DPATH_' + i]): - if not entry in importpaths: - importpaths.append(entry) - - # now process the import paths - for path in importpaths: - if os.path.isabs(path): - env.append_unique('_DIMPORTFLAGS', dpath_st % path) - else: - node = self.path.find_dir(path) - self.env.append_unique('INC_PATHS', node) - env.append_unique('_DIMPORTFLAGS', dpath_st % node.srcpath(env)) - env.append_unique('_DIMPORTFLAGS', dpath_st % node.bldpath(env)) - - # add library paths - for i in uselib: - if env['LIBPATH_' + i]: - for entry in self.to_list(env['LIBPATH_' + i]): - if not entry in libpaths: - libpaths.append(entry) - libpaths = self.to_list(self.libpaths) + libpaths - - # now process the library paths - # apply same path manipulation as used with import paths - for path in libpaths: - if not os.path.isabs(path): - node = self.path.find_resource(path) - if not node: - raise Utils.WafError('could not find libpath %r from %r' % (path, self)) - path = node.abspath(self.env) - - env.append_unique('DLINKFLAGS', libpath_st % path) - - # add libraries - for i in uselib: - if env['LIB_' + i]: - for entry in self.to_list(env['LIB_' + i]): - if not entry in libs: - libs.append(entry) - libs.extend(self.to_list(self.libs)) - - # process user flags - for flag in self.to_list(self.dflags): - env.append_unique('DFLAGS', flag) - - # now process the libraries - for lib in libs: - env.append_unique('DLINKFLAGS', lib_st % lib) - - # add linker flags - for i in uselib: - dlinkflags = env['DLINKFLAGS_' + i] - if dlinkflags: - for linkflag in dlinkflags: - env.append_unique('DLINKFLAGS', linkflag) - -@feature('dshlib') -@after('apply_d_vars') -def add_shlib_d_flags(self): - for linkflag in self.env['D_shlib_LINKFLAGS']: - self.env.append_unique('DLINKFLAGS', linkflag) - -@extension(EXT_D) -def d_hook(self, node): - # create the compilation task: cpp or cc - task = self.create_task(self.generate_headers and 'd_with_header' or 'd') - try: obj_ext = self.obj_ext - except AttributeError: obj_ext = '_%d.o' % self.idx - - task.inputs = [node] - task.outputs = [node.change_ext(obj_ext)] - self.compiled_tasks.append(task) - - if self.generate_headers: - header_node = node.change_ext(self.env['DHEADER_ext']) - task.outputs += [header_node] - -d_str = '${D_COMPILER} ${DFLAGS} ${_DIMPORTFLAGS} ${D_SRC_F}${SRC} ${D_TGT_F}${TGT}' -d_with_header_str = '${D_COMPILER} ${DFLAGS} ${_DIMPORTFLAGS} \ -${D_HDR_F}${TGT[1].bldpath(env)} \ -${D_SRC_F}${SRC} \ -${D_TGT_F}${TGT[0].bldpath(env)}' -link_str = '${D_LINKER} ${DLNK_SRC_F}${SRC} ${DLNK_TGT_F}${TGT} ${DLINKFLAGS}' - -def override_exec(cls): - """stupid dmd wants -of stuck to the file name""" - old_exec = cls.exec_command - def exec_command(self, *k, **kw): - if isinstance(k[0], list): - lst = k[0] - for i in xrange(len(lst)): - if lst[i] == '-of': - del lst[i] - lst[i] = '-of' + lst[i] - break - return old_exec(self, *k, **kw) - cls.exec_command = exec_command - -cls = Task.simple_task_type('d', d_str, 'GREEN', before='static_link d_link', shell=False) -cls.scan = scan -override_exec(cls) - -cls = Task.simple_task_type('d_with_header', d_with_header_str, 'GREEN', before='static_link d_link', shell=False) -override_exec(cls) - -cls = Task.simple_task_type('d_link', link_str, color='YELLOW', shell=False) -override_exec(cls) - -# for feature request #104 -@taskgen -def generate_header(self, filename, install_path): - if not hasattr(self, 'header_lst'): self.header_lst = [] - self.meths.append('process_header') - self.header_lst.append([filename, install_path]) - -@before('apply_core') -def process_header(self): - env = self.env - for i in getattr(self, 'header_lst', []): - node = self.path.find_resource(i[0]) - - if not node: - raise Utils.WafError('file not found on d obj '+i[0]) - - task = self.create_task('d_header') - task.set_inputs(node) - task.set_outputs(node.change_ext('.di')) - -d_header_str = '${D_COMPILER} ${D_HEADER} ${SRC}' -Task.simple_task_type('d_header', d_header_str, color='BLUE', shell=False) - -@conftest -def d_platform_flags(conf): - v = conf.env - binfmt = v.DEST_BINFMT or Utils.unversioned_sys_platform_to_binary_format( - v.DEST_OS or Utils.unversioned_sys_platform()) - if binfmt == 'pe': - v['D_program_PATTERN'] = '%s.exe' - v['D_shlib_PATTERN'] = 'lib%s.dll' - v['D_staticlib_PATTERN'] = 'lib%s.a' - else: - v['D_program_PATTERN'] = '%s' - v['D_shlib_PATTERN'] = 'lib%s.so' - v['D_staticlib_PATTERN'] = 'lib%s.a' - -@conftest -def check_dlibrary(conf): - ret = conf.check_cc(features='d dprogram', fragment=DLIB, mandatory=True, compile_filename='test.d', execute=True) - conf.env.DLIBRARY = ret.strip() - -# quick test # -if __name__ == "__main__": - #Logs.verbose = 2 - - try: arg = sys.argv[1] - except IndexError: arg = "file.d" - - print("".join(filter_comments(arg))) - # TODO - paths = ['.'] - - #gruik = filter() - #gruik.start(arg) - - #code = "".join(gruik.buf) - - #print "we have found the following code" - #print code - - #print "now parsing" - #print "-------------------------------------------" - """ - parser_ = d_parser() - parser_.start(arg) - - print "module: %s" % parser_.module - print "imports: ", - for imp in parser_.imports: - print imp + " ", - print -""" diff --git a/third_party/waf/wafadmin/Tools/dbus.py b/third_party/waf/wafadmin/Tools/dbus.py deleted file mode 100644 index 42c4ca2cb7f..00000000000 --- a/third_party/waf/wafadmin/Tools/dbus.py +++ /dev/null @@ -1,33 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Ali Sabil, 2007 - -import Task, Utils -from TaskGen import taskgen, before, after, feature - -@taskgen -def add_dbus_file(self, filename, prefix, mode): - if not hasattr(self, 'dbus_lst'): - self.dbus_lst = [] - self.meths.append('process_dbus') - self.dbus_lst.append([filename, prefix, mode]) - -@before('apply_core') -def process_dbus(self): - for filename, prefix, mode in getattr(self, 'dbus_lst', []): - node = self.path.find_resource(filename) - - if not node: - raise Utils.WafError('file not found ' + filename) - - tsk = self.create_task('dbus_binding_tool', node, node.change_ext('.h')) - - tsk.env.DBUS_BINDING_TOOL_PREFIX = prefix - tsk.env.DBUS_BINDING_TOOL_MODE = mode - -Task.simple_task_type('dbus_binding_tool', - '${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}', - color='BLUE', before='cc') - -def detect(conf): - dbus_binding_tool = conf.find_program('dbus-binding-tool', var='DBUS_BINDING_TOOL') diff --git a/third_party/waf/wafadmin/Tools/dmd.py b/third_party/waf/wafadmin/Tools/dmd.py deleted file mode 100644 index b86ffd6a0f4..00000000000 --- a/third_party/waf/wafadmin/Tools/dmd.py +++ /dev/null @@ -1,63 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2007 (dv) -# Thomas Nagy, 2008 (ita) - -import sys -import Utils, ar -from Configure import conftest - -@conftest -def find_dmd(conf): - conf.find_program(['dmd', 'ldc'], var='D_COMPILER', mandatory=True) - -@conftest -def common_flags_ldc(conf): - v = conf.env - v['DFLAGS'] = ['-d-version=Posix'] - v['DLINKFLAGS'] = [] - v['D_shlib_DFLAGS'] = ['-relocation-model=pic'] - -@conftest -def common_flags_dmd(conf): - v = conf.env - - # _DFLAGS _DIMPORTFLAGS - - # Compiler is dmd so 'gdc' part will be ignored, just - # ensure key is there, so wscript can append flags to it - v['DFLAGS'] = ['-version=Posix'] - - v['D_SRC_F'] = '' - v['D_TGT_F'] = ['-c', '-of'] - v['DPATH_ST'] = '-I%s' # template for adding import paths - - # linker - v['D_LINKER'] = v['D_COMPILER'] - v['DLNK_SRC_F'] = '' - v['DLNK_TGT_F'] = '-of' - - v['DLIB_ST'] = '-L-l%s' # template for adding libs - v['DLIBPATH_ST'] = '-L-L%s' # template for adding libpaths - - # linker debug levels - v['DFLAGS_OPTIMIZED'] = ['-O'] - v['DFLAGS_DEBUG'] = ['-g', '-debug'] - v['DFLAGS_ULTRADEBUG'] = ['-g', '-debug'] - v['DLINKFLAGS'] = ['-quiet'] - - v['D_shlib_DFLAGS'] = ['-fPIC'] - v['D_shlib_LINKFLAGS'] = ['-L-shared'] - - v['DHEADER_ext'] = '.di' - v['D_HDR_F'] = ['-H', '-Hf'] - -def detect(conf): - conf.find_dmd() - conf.check_tool('ar') - conf.check_tool('d') - conf.common_flags_dmd() - conf.d_platform_flags() - - if conf.env.D_COMPILER.find('ldc') > -1: - conf.common_flags_ldc() diff --git a/third_party/waf/wafadmin/Tools/flex.py b/third_party/waf/wafadmin/Tools/flex.py deleted file mode 100644 index cbea42db2c9..00000000000 --- a/third_party/waf/wafadmin/Tools/flex.py +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# John O'Meara, 2006 -# Thomas Nagy, 2006-2008 - -"Flex processing" - -import TaskGen - -def decide_ext(self, node): - if 'cxx' in self.features: return '.lex.cc' - else: return '.lex.c' - -TaskGen.declare_chain( - name = 'flex', - rule = '${FLEX} -o${TGT} ${FLEXFLAGS} ${SRC}', - ext_in = '.l', - ext_out = '.c .cxx', - decider = decide_ext -) - -def detect(conf): - conf.find_program('flex', var='FLEX', mandatory=True) - conf.env['FLEXFLAGS'] = '' diff --git a/third_party/waf/wafadmin/Tools/gas.py b/third_party/waf/wafadmin/Tools/gas.py deleted file mode 100644 index 5dd0b5d7460..00000000000 --- a/third_party/waf/wafadmin/Tools/gas.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2008 (ita) - -"as and gas" - -import os, sys -import Task -from TaskGen import extension, taskgen, after, before - -EXT_ASM = ['.s', '.S', '.asm', '.ASM', '.spp', '.SPP'] - -as_str = '${AS} ${ASFLAGS} ${_ASINCFLAGS} ${SRC} -o ${TGT}' -Task.simple_task_type('asm', as_str, 'PINK', ext_out='.o', shell=False) - -@extension(EXT_ASM) -def asm_hook(self, node): - # create the compilation task: cpp or cc - try: obj_ext = self.obj_ext - except AttributeError: obj_ext = '_%d.o' % self.idx - - task = self.create_task('asm', node, node.change_ext(obj_ext)) - self.compiled_tasks.append(task) - self.meths.append('asm_incflags') - -@after('apply_obj_vars_cc') -@after('apply_obj_vars_cxx') -@before('apply_link') -def asm_incflags(self): - self.env.append_value('_ASINCFLAGS', self.env.ASINCFLAGS) - var = ('cxx' in self.features) and 'CXX' or 'CC' - self.env.append_value('_ASINCFLAGS', self.env['_%sINCFLAGS' % var]) - -def detect(conf): - conf.find_program(['gas', 'as'], var='AS') - if not conf.env.AS: conf.env.AS = conf.env.CC - #conf.env.ASFLAGS = ['-c'] <- may be necesary for .S files diff --git a/third_party/waf/wafadmin/Tools/gcc.py b/third_party/waf/wafadmin/Tools/gcc.py deleted file mode 100644 index 83d5b248ad9..00000000000 --- a/third_party/waf/wafadmin/Tools/gcc.py +++ /dev/null @@ -1,138 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) -# Ralf Habacker, 2006 (rh) -# Yinon Ehrlich, 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar -from Configure import conftest - -@conftest -def find_gcc(conf): - cc = conf.find_program(['gcc', 'cc'], var='CC', mandatory=True) - cc = conf.cmd_to_list(cc) - ccroot.get_cc_version(conf, cc, gcc=True) - conf.env.CC_NAME = 'gcc' - conf.env.CC = cc - -@conftest -def gcc_common_flags(conf): - v = conf.env - - # CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS - - v['CCFLAGS_DEBUG'] = ['-g'] - - v['CCFLAGS_RELEASE'] = ['-O2'] - - v['CC_SRC_F'] = '' - v['CC_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CC']: v['LINK_CC'] = v['CC'] - v['CCLNK_SRC_F'] = '' - v['CCLNK_TGT_F'] = ['-o', ''] # shell hack for -MD - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['RPATH_ST'] = '-Wl,-rpath,%s' - v['CCDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '-Wl,-h,%s' - v['SHLIB_MARKER'] = '-Wl,-Bdynamic' - v['STATICLIB_MARKER'] = '-Wl,-Bstatic' - v['FULLSTATIC_MARKER'] = '-static' - - # program - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CCFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro - v['shlib_LINKFLAGS'] = ['-shared'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = ['-Wl,-Bstatic'] - v['staticlib_PATTERN'] = 'lib%s.a' - - # osx stuff - v['LINKFLAGS_MACBUNDLE'] = ['-bundle', '-undefined', 'dynamic_lookup'] - v['CCFLAGS_MACBUNDLE'] = ['-fPIC'] - v['macbundle_PATTERN'] = '%s.bundle' - -@conftest -def gcc_modifier_win32(conf): - v = conf.env - v['program_PATTERN'] = '%s.exe' - - v['shlib_PATTERN'] = '%s.dll' - v['implib_PATTERN'] = 'lib%s.dll.a' - v['IMPLIB_ST'] = '-Wl,--out-implib,%s' - - dest_arch = v['DEST_CPU'] - v['shlib_CCFLAGS'] = ['-DPIC'] - - v.append_value('shlib_CCFLAGS', '-DDLL_EXPORT') # TODO adding nonstandard defines like this DLL_EXPORT is not a good idea - - # Auto-import is enabled by default even without this option, - # but enabling it explicitly has the nice effect of suppressing the rather boring, debug-level messages - # that the linker emits otherwise. - v.append_value('LINKFLAGS', '-Wl,--enable-auto-import') - -@conftest -def gcc_modifier_cygwin(conf): - gcc_modifier_win32(conf) - v = conf.env - v['shlib_PATTERN'] = 'cyg%s.dll' - v.append_value('shlib_LINKFLAGS', '-Wl,--enable-auto-image-base') - -@conftest -def gcc_modifier_darwin(conf): - v = conf.env - v['shlib_CCFLAGS'] = ['-fPIC', '-compatibility_version', '1', '-current_version', '1'] - v['shlib_LINKFLAGS'] = ['-dynamiclib'] - v['shlib_PATTERN'] = 'lib%s.dylib' - - v['staticlib_LINKFLAGS'] = [] - - v['SHLIB_MARKER'] = '' - v['STATICLIB_MARKER'] = '' - v['SONAME_ST'] = '' - -@conftest -def gcc_modifier_aix(conf): - v = conf.env - v['program_LINKFLAGS'] = ['-Wl,-brtl'] - - v['shlib_LINKFLAGS'] = ['-shared','-Wl,-brtl,-bexpfull'] - - v['SHLIB_MARKER'] = '' - -@conftest -def gcc_modifier_openbsd(conf): - conf.env['SONAME_ST'] = [] - -@conftest -def gcc_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() - gcc_modifier_func = globals().get('gcc_modifier_' + dest_os) - if gcc_modifier_func: - gcc_modifier_func(conf) - -def detect(conf): - conf.find_gcc() - conf.find_cpp() - conf.find_ar() - conf.gcc_common_flags() - conf.gcc_modifier_platform() - conf.cc_load_tools() - conf.cc_add_flags() - conf.link_add_flags() diff --git a/third_party/waf/wafadmin/Tools/gdc.py b/third_party/waf/wafadmin/Tools/gdc.py deleted file mode 100644 index d1e5e7b53cb..00000000000 --- a/third_party/waf/wafadmin/Tools/gdc.py +++ /dev/null @@ -1,51 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2007 (dv) - -import sys -import Utils, ar -from Configure import conftest - -@conftest -def find_gdc(conf): - conf.find_program('gdc', var='D_COMPILER', mandatory=True) - -@conftest -def common_flags_gdc(conf): - v = conf.env - - # _DFLAGS _DIMPORTFLAGS - - # for mory info about the meaning of this dict see dmd.py - v['DFLAGS'] = [] - - v['D_SRC_F'] = '' - v['D_TGT_F'] = ['-c', '-o', ''] - v['DPATH_ST'] = '-I%s' # template for adding import paths - - # linker - v['D_LINKER'] = v['D_COMPILER'] - v['DLNK_SRC_F'] = '' - v['DLNK_TGT_F'] = ['-o', ''] - - v['DLIB_ST'] = '-l%s' # template for adding libs - v['DLIBPATH_ST'] = '-L%s' # template for adding libpaths - - # debug levels - v['DLINKFLAGS'] = [] - v['DFLAGS_OPTIMIZED'] = ['-O3'] - v['DFLAGS_DEBUG'] = ['-O0'] - v['DFLAGS_ULTRADEBUG'] = ['-O0'] - - v['D_shlib_DFLAGS'] = [] - v['D_shlib_LINKFLAGS'] = ['-shared'] - - v['DHEADER_ext'] = '.di' - v['D_HDR_F'] = '-fintfc -fintfc-file=' - -def detect(conf): - conf.find_gdc() - conf.check_tool('ar') - conf.check_tool('d') - conf.common_flags_gdc() - conf.d_platform_flags() diff --git a/third_party/waf/wafadmin/Tools/glib2.py b/third_party/waf/wafadmin/Tools/glib2.py deleted file mode 100644 index d3fc7769740..00000000000 --- a/third_party/waf/wafadmin/Tools/glib2.py +++ /dev/null @@ -1,163 +0,0 @@ -#! /usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) - -"GLib2 support" - -import Task, Utils -from TaskGen import taskgen, before, after, feature - -# -# glib-genmarshal -# - -@taskgen -def add_marshal_file(self, filename, prefix): - if not hasattr(self, 'marshal_list'): - self.marshal_list = [] - self.meths.append('process_marshal') - self.marshal_list.append((filename, prefix)) - -@before('apply_core') -def process_marshal(self): - for f, prefix in getattr(self, 'marshal_list', []): - node = self.path.find_resource(f) - - if not node: - raise Utils.WafError('file not found %r' % f) - - h_node = node.change_ext('.h') - c_node = node.change_ext('.c') - - task = self.create_task('glib_genmarshal', node, [h_node, c_node]) - task.env.GLIB_GENMARSHAL_PREFIX = prefix - self.allnodes.append(c_node) - -def genmarshal_func(self): - - bld = self.inputs[0].__class__.bld - - get = self.env.get_flat - cmd1 = "%s %s --prefix=%s --header > %s" % ( - get('GLIB_GENMARSHAL'), - self.inputs[0].srcpath(self.env), - get('GLIB_GENMARSHAL_PREFIX'), - self.outputs[0].abspath(self.env) - ) - - ret = bld.exec_command(cmd1) - if ret: return ret - - #print self.outputs[1].abspath(self.env) - f = open(self.outputs[1].abspath(self.env), 'wb') - c = '''#include "%s"\n''' % self.outputs[0].name - f.write(c) - f.close() - - cmd2 = "%s %s --prefix=%s --body >> %s" % ( - get('GLIB_GENMARSHAL'), - self.inputs[0].srcpath(self.env), - get('GLIB_GENMARSHAL_PREFIX'), - self.outputs[1].abspath(self.env) - ) - ret = Utils.exec_command(cmd2) - if ret: return ret - -# -# glib-mkenums -# - -@taskgen -def add_enums_from_template(self, source='', target='', template='', comments=''): - if not hasattr(self, 'enums_list'): - self.enums_list = [] - self.meths.append('process_enums') - self.enums_list.append({'source': source, - 'target': target, - 'template': template, - 'file-head': '', - 'file-prod': '', - 'file-tail': '', - 'enum-prod': '', - 'value-head': '', - 'value-prod': '', - 'value-tail': '', - 'comments': comments}) - -@taskgen -def add_enums(self, source='', target='', - file_head='', file_prod='', file_tail='', enum_prod='', - value_head='', value_prod='', value_tail='', comments=''): - if not hasattr(self, 'enums_list'): - self.enums_list = [] - self.meths.append('process_enums') - self.enums_list.append({'source': source, - 'template': '', - 'target': target, - 'file-head': file_head, - 'file-prod': file_prod, - 'file-tail': file_tail, - 'enum-prod': enum_prod, - 'value-head': value_head, - 'value-prod': value_prod, - 'value-tail': value_tail, - 'comments': comments}) - -@before('apply_core') -def process_enums(self): - for enum in getattr(self, 'enums_list', []): - task = self.create_task('glib_mkenums') - env = task.env - - inputs = [] - - # process the source - source_list = self.to_list(enum['source']) - if not source_list: - raise Utils.WafError('missing source ' + str(enum)) - source_list = [self.path.find_resource(k) for k in source_list] - inputs += source_list - env['GLIB_MKENUMS_SOURCE'] = [k.srcpath(env) for k in source_list] - - # find the target - if not enum['target']: - raise Utils.WafError('missing target ' + str(enum)) - tgt_node = self.path.find_or_declare(enum['target']) - if tgt_node.name.endswith('.c'): - self.allnodes.append(tgt_node) - env['GLIB_MKENUMS_TARGET'] = tgt_node.abspath(env) - - - options = [] - - if enum['template']: # template, if provided - template_node = self.path.find_resource(enum['template']) - options.append('--template %s' % (template_node.abspath(env))) - inputs.append(template_node) - params = {'file-head' : '--fhead', - 'file-prod' : '--fprod', - 'file-tail' : '--ftail', - 'enum-prod' : '--eprod', - 'value-head' : '--vhead', - 'value-prod' : '--vprod', - 'value-tail' : '--vtail', - 'comments': '--comments'} - for param, option in params.iteritems(): - if enum[param]: - options.append('%s %r' % (option, enum[param])) - - env['GLIB_MKENUMS_OPTIONS'] = ' '.join(options) - - # update the task instance - task.set_inputs(inputs) - task.set_outputs(tgt_node) - -Task.task_type_from_func('glib_genmarshal', func=genmarshal_func, vars=['GLIB_GENMARSHAL_PREFIX', 'GLIB_GENMARSHAL'], - color='BLUE', before='cc cxx') -Task.simple_task_type('glib_mkenums', - '${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}', - color='PINK', before='cc cxx') - -def detect(conf): - glib_genmarshal = conf.find_program('glib-genmarshal', var='GLIB_GENMARSHAL') - mk_enums_tool = conf.find_program('glib-mkenums', var='GLIB_MKENUMS') diff --git a/third_party/waf/wafadmin/Tools/gnome.py b/third_party/waf/wafadmin/Tools/gnome.py deleted file mode 100644 index da11e91d3d8..00000000000 --- a/third_party/waf/wafadmin/Tools/gnome.py +++ /dev/null @@ -1,222 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) - -"Gnome support" - -import os, re -import TaskGen, Utils, Runner, Task, Build, Options, Logs -import cc -from Logs import error -from TaskGen import taskgen, before, after, feature - -n1_regexp = re.compile('<refentrytitle>(.*)</refentrytitle>', re.M) -n2_regexp = re.compile('<manvolnum>(.*)</manvolnum>', re.M) - -def postinstall_schemas(prog_name): - if Build.bld.is_install: - dir = Build.bld.get_install_path('${PREFIX}/etc/gconf/schemas/%s.schemas' % prog_name) - if not Options.options.destdir: - # add the gconf schema - Utils.pprint('YELLOW', 'Installing GConf schema') - command = 'gconftool-2 --install-schema-file=%s 1> /dev/null' % dir - ret = Utils.exec_command(command) - else: - Utils.pprint('YELLOW', 'GConf schema not installed. After install, run this:') - Utils.pprint('YELLOW', 'gconftool-2 --install-schema-file=%s' % dir) - -def postinstall_icons(): - dir = Build.bld.get_install_path('${DATADIR}/icons/hicolor') - if Build.bld.is_install: - if not Options.options.destdir: - # update the pixmap cache directory - Utils.pprint('YELLOW', "Updating Gtk icon cache.") - command = 'gtk-update-icon-cache -q -f -t %s' % dir - ret = Utils.exec_command(command) - else: - Utils.pprint('YELLOW', 'Icon cache not updated. After install, run this:') - Utils.pprint('YELLOW', 'gtk-update-icon-cache -q -f -t %s' % dir) - -def postinstall_scrollkeeper(prog_name): - if Build.bld.is_install: - # now the scrollkeeper update if we can write to the log file - if os.access('/var/log/scrollkeeper.log', os.W_OK): - dir1 = Build.bld.get_install_path('${PREFIX}/var/scrollkeeper') - dir2 = Build.bld.get_install_path('${DATADIR}/omf/%s' % prog_name) - command = 'scrollkeeper-update -q -p %s -o %s' % (dir1, dir2) - ret = Utils.exec_command(command) - -def postinstall(prog_name='myapp', schemas=1, icons=1, scrollkeeper=1): - if schemas: postinstall_schemas(prog_name) - if icons: postinstall_icons() - if scrollkeeper: postinstall_scrollkeeper(prog_name) - -# OBSOLETE -class gnome_doc_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('gnome_doc') -def init_gnome_doc(self): - self.default_install_path = '${PREFIX}/share' - -@feature('gnome_doc') -@after('init_gnome_doc') -def apply_gnome_doc(self): - self.env['APPNAME'] = self.doc_module - lst = self.to_list(self.doc_linguas) - bld = self.bld - lst.append('C') - - for x in lst: - if not x == 'C': - tsk = self.create_task('xml2po') - node = self.path.find_resource(x+'/'+x+'.po') - src = self.path.find_resource('C/%s.xml' % self.doc_module) - out = self.path.find_or_declare('%s/%s.xml' % (x, self.doc_module)) - tsk.set_inputs([node, src]) - tsk.set_outputs(out) - else: - out = self.path.find_resource('%s/%s.xml' % (x, self.doc_module)) - - tsk2 = self.create_task('xsltproc2po') - out2 = self.path.find_or_declare('%s/%s-%s.omf' % (x, self.doc_module, x)) - tsk2.set_outputs(out2) - node = self.path.find_resource(self.doc_module+".omf.in") - tsk2.inputs = [node, out] - - tsk2.run_after.append(tsk) - - if bld.is_install: - path = self.install_path + '/gnome/help/%s/%s' % (self.doc_module, x) - bld.install_files(self.install_path + '/omf', out2, env=self.env) - for y in self.to_list(self.doc_figures): - try: - os.stat(self.path.abspath() + '/' + x + '/' + y) - bld.install_as(path + '/' + y, self.path.abspath() + '/' + x + '/' + y) - except: - bld.install_as(path + '/' + y, self.path.abspath() + '/C/' + y) - bld.install_as(path + '/%s.xml' % self.doc_module, out.abspath(self.env)) - if x == 'C': - xmls = self.to_list(self.doc_includes) - xmls.append(self.doc_entities) - for z in xmls: - out = self.path.find_resource('%s/%s' % (x, z)) - bld.install_as(path + '/%s' % z, out.abspath(self.env)) - -# OBSOLETE -class xml_to_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('xml_to') -def init_xml_to(self): - Utils.def_attrs(self, - source = 'xmlfile', - xslt = 'xlsltfile', - target = 'hey', - default_install_path = '${PREFIX}', - task_created = None) - -@feature('xml_to') -@after('init_xml_to') -def apply_xml_to(self): - xmlfile = self.path.find_resource(self.source) - xsltfile = self.path.find_resource(self.xslt) - tsk = self.create_task('xmlto', [xmlfile, xsltfile], xmlfile.change_ext('html')) - tsk.install_path = self.install_path - -def sgml_scan(self): - node = self.inputs[0] - - env = self.env - variant = node.variant(env) - - fi = open(node.abspath(env), 'r') - content = fi.read() - fi.close() - - # we should use a sgml parser :-/ - name = n1_regexp.findall(content)[0] - num = n2_regexp.findall(content)[0] - - doc_name = name+'.'+num - - if not self.outputs: - self.outputs = [self.generator.path.find_or_declare(doc_name)] - - return ([], [doc_name]) - -class gnome_sgml2man_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('gnome_sgml2man') -def apply_gnome_sgml2man(self): - """ - we could make it more complicated, but for now we just scan the document each time - """ - assert(getattr(self, 'appname', None)) - - def install_result(task): - out = task.outputs[0] - name = out.name - ext = name[-1] - env = task.env - self.bld.install_files('${DATADIR}/man/man%s/' % ext, out, env) - - self.bld.rescan(self.path) - for name in self.bld.cache_dir_contents[self.path.id]: - base, ext = os.path.splitext(name) - if ext != '.sgml': continue - - task = self.create_task('sgml2man') - task.set_inputs(self.path.find_resource(name)) - task.task_generator = self - if self.bld.is_install: task.install = install_result - # no outputs, the scanner does it - # no caching for now, this is not a time-critical feature - # in the future the scanner can be used to do more things (find dependencies, etc) - task.scan() - -cls = Task.simple_task_type('sgml2man', '${SGML2MAN} -o ${TGT[0].bld_dir(env)} ${SRC} > /dev/null', color='BLUE') -cls.scan = sgml_scan -cls.quiet = 1 - -Task.simple_task_type('xmlto', '${XMLTO} html -m ${SRC[1].abspath(env)} ${SRC[0].abspath(env)}') - -Task.simple_task_type('xml2po', '${XML2PO} ${XML2POFLAGS} ${SRC} > ${TGT}', color='BLUE') - -# how do you expect someone to understand this?! -xslt_magic = """${XSLTPROC2PO} -o ${TGT[0].abspath(env)} \ ---stringparam db2omf.basename ${APPNAME} \ ---stringparam db2omf.format docbook \ ---stringparam db2omf.lang ${TGT[0].abspath(env)[:-4].split('-')[-1]} \ ---stringparam db2omf.dtd '-//OASIS//DTD DocBook XML V4.3//EN' \ ---stringparam db2omf.omf_dir ${PREFIX}/share/omf \ ---stringparam db2omf.help_dir ${PREFIX}/share/gnome/help \ ---stringparam db2omf.omf_in ${SRC[0].abspath(env)} \ ---stringparam db2omf.scrollkeeper_cl ${SCROLLKEEPER_DATADIR}/Templates/C/scrollkeeper_cl.xml \ -${DB2OMF} ${SRC[1].abspath(env)}""" - -#--stringparam db2omf.dtd '-//OASIS//DTD DocBook XML V4.3//EN' \ -Task.simple_task_type('xsltproc2po', xslt_magic, color='BLUE') - -def detect(conf): - conf.check_tool('gnu_dirs glib2 dbus') - sgml2man = conf.find_program('docbook2man', var='SGML2MAN') - - def getstr(varname): - return getattr(Options.options, varname, '') - - # addefine also sets the variable to the env - conf.define('GNOMELOCALEDIR', os.path.join(conf.env['DATADIR'], 'locale')) - - xml2po = conf.find_program('xml2po', var='XML2PO') - xsltproc2po = conf.find_program('xsltproc', var='XSLTPROC2PO') - conf.env['XML2POFLAGS'] = '-e -p' - conf.env['SCROLLKEEPER_DATADIR'] = Utils.cmd_output("scrollkeeper-config --pkgdatadir", silent=1).strip() - conf.env['DB2OMF'] = Utils.cmd_output("/usr/bin/pkg-config --variable db2omf gnome-doc-utils", silent=1).strip() - -def set_options(opt): - opt.add_option('--want-rpath', type='int', default=1, dest='want_rpath', help='set rpath to 1 or 0 [Default 1]') diff --git a/third_party/waf/wafadmin/Tools/gnu_dirs.py b/third_party/waf/wafadmin/Tools/gnu_dirs.py deleted file mode 100644 index ac149dfa46b..00000000000 --- a/third_party/waf/wafadmin/Tools/gnu_dirs.py +++ /dev/null @@ -1,110 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Ali Sabil, 2007 - -""" -To use this module do not forget to call -opt.tool_options('gnu_dirs') -AND -conf.check_tool('gnu_dirs') - -Add options for the standard GNU directories, this tool will add the options -found in autotools, and will update the environment with the following -installation variables: - - * PREFIX : architecture-independent files [/usr/local] - * EXEC_PREFIX : architecture-dependent files [PREFIX] - * BINDIR : user executables [EXEC_PREFIX/bin] - * SBINDIR : user executables [EXEC_PREFIX/sbin] - * LIBEXECDIR : program executables [EXEC_PREFIX/libexec] - * SYSCONFDIR : read-only single-machine data [PREFIX/etc] - * SHAREDSTATEDIR : modifiable architecture-independent data [PREFIX/com] - * LOCALSTATEDIR : modifiable single-machine data [PREFIX/var] - * LIBDIR : object code libraries [EXEC_PREFIX/lib] - * INCLUDEDIR : C header files [PREFIX/include] - * OLDINCLUDEDIR : C header files for non-gcc [/usr/include] - * DATAROOTDIR : read-only arch.-independent data root [PREFIX/share] - * DATADIR : read-only architecture-independent data [DATAROOTDIR] - * INFODIR : info documentation [DATAROOTDIR/info] - * LOCALEDIR : locale-dependent data [DATAROOTDIR/locale] - * MANDIR : man documentation [DATAROOTDIR/man] - * DOCDIR : documentation root [DATAROOTDIR/doc/telepathy-glib] - * HTMLDIR : html documentation [DOCDIR] - * DVIDIR : dvi documentation [DOCDIR] - * PDFDIR : pdf documentation [DOCDIR] - * PSDIR : ps documentation [DOCDIR] -""" - -import Utils, Options - -_options = [x.split(', ') for x in ''' -bindir, user executables, ${EXEC_PREFIX}/bin -sbindir, system admin executables, ${EXEC_PREFIX}/sbin -libexecdir, program executables, ${EXEC_PREFIX}/libexec -sysconfdir, read-only single-machine data, ${PREFIX}/etc -sharedstatedir, modifiable architecture-independent data, ${PREFIX}/com -localstatedir, modifiable single-machine data, ${PREFIX}/var -libdir, object code libraries, ${EXEC_PREFIX}/lib -includedir, C header files, ${PREFIX}/include -oldincludedir, C header files for non-gcc, /usr/include -datarootdir, read-only arch.-independent data root, ${PREFIX}/share -datadir, read-only architecture-independent data, ${DATAROOTDIR} -infodir, info documentation, ${DATAROOTDIR}/info -localedir, locale-dependent data, ${DATAROOTDIR}/locale -mandir, man documentation, ${DATAROOTDIR}/man -docdir, documentation root, ${DATAROOTDIR}/doc/${PACKAGE} -htmldir, html documentation, ${DOCDIR} -dvidir, dvi documentation, ${DOCDIR} -pdfdir, pdf documentation, ${DOCDIR} -psdir, ps documentation, ${DOCDIR} -'''.split('\n') if x] - -def detect(conf): - def get_param(varname, default): - return getattr(Options.options, varname, '') or default - - env = conf.env - env['EXEC_PREFIX'] = get_param('EXEC_PREFIX', env['PREFIX']) - env['PACKAGE'] = Utils.g_module.APPNAME - - complete = False - iter = 0 - while not complete and iter < len(_options) + 1: - iter += 1 - complete = True - for name, help, default in _options: - name = name.upper() - if not env[name]: - try: - env[name] = Utils.subst_vars(get_param(name, default), env) - except TypeError: - complete = False - if not complete: - lst = [name for name, _, _ in _options if not env[name.upper()]] - raise Utils.WafError('Variable substitution failure %r' % lst) - -def set_options(opt): - - inst_dir = opt.add_option_group('Installation directories', -'By default, "waf install" will put the files in\ - "/usr/local/bin", "/usr/local/lib" etc. An installation prefix other\ - than "/usr/local" can be given using "--prefix", for example "--prefix=$HOME"') - - for k in ('--prefix', '--destdir'): - option = opt.parser.get_option(k) - if option: - opt.parser.remove_option(k) - inst_dir.add_option(option) - - inst_dir.add_option('--exec-prefix', - help = 'installation prefix [Default: ${PREFIX}]', - default = '', - dest = 'EXEC_PREFIX') - - dirs_options = opt.add_option_group('Pre-defined installation directories', '') - - for name, help, default in _options: - option_name = '--' + name - str_default = default - str_help = '%s [Default: %s]' % (help, str_default) - dirs_options.add_option(option_name, help=str_help, default='', dest=name.upper()) diff --git a/third_party/waf/wafadmin/Tools/gob2.py b/third_party/waf/wafadmin/Tools/gob2.py deleted file mode 100644 index 96d8e2030ca..00000000000 --- a/third_party/waf/wafadmin/Tools/gob2.py +++ /dev/null @@ -1,17 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Ali Sabil, 2007 - -import TaskGen - -TaskGen.declare_chain( - name = 'gob2', - rule = '${GOB2} -o ${TGT[0].bld_dir(env)} ${GOB2FLAGS} ${SRC}', - ext_in = '.gob', - ext_out = '.c' -) - -def detect(conf): - gob2 = conf.find_program('gob2', var='GOB2', mandatory=True) - conf.env['GOB2'] = gob2 - conf.env['GOB2FLAGS'] = '' diff --git a/third_party/waf/wafadmin/Tools/gxx.py b/third_party/waf/wafadmin/Tools/gxx.py deleted file mode 100644 index 38e8d00ae5b..00000000000 --- a/third_party/waf/wafadmin/Tools/gxx.py +++ /dev/null @@ -1,136 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) -# Ralf Habacker, 2006 (rh) -# Yinon Ehrlich, 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar -from Configure import conftest - -@conftest -def find_gxx(conf): - cxx = conf.find_program(['g++', 'c++'], var='CXX', mandatory=True) - cxx = conf.cmd_to_list(cxx) - ccroot.get_cc_version(conf, cxx, gcc=True) - conf.env.CXX_NAME = 'gcc' - conf.env.CXX = cxx - -@conftest -def gxx_common_flags(conf): - v = conf.env - - # CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS - v['CXXFLAGS_DEBUG'] = ['-g'] - v['CXXFLAGS_RELEASE'] = ['-O2'] - - v['CXX_SRC_F'] = '' - v['CXX_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] - v['CXXLNK_SRC_F'] = '' - v['CXXLNK_TGT_F'] = ['-o', ''] # shell hack for -MD - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['RPATH_ST'] = '-Wl,-rpath,%s' - v['CXXDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '-Wl,-h,%s' - v['SHLIB_MARKER'] = '-Wl,-Bdynamic' - v['STATICLIB_MARKER'] = '-Wl,-Bstatic' - v['FULLSTATIC_MARKER'] = '-static' - - # program - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CXXFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro - v['shlib_LINKFLAGS'] = ['-shared'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = ['-Wl,-Bstatic'] - v['staticlib_PATTERN'] = 'lib%s.a' - - # osx stuff - v['LINKFLAGS_MACBUNDLE'] = ['-bundle', '-undefined', 'dynamic_lookup'] - v['CCFLAGS_MACBUNDLE'] = ['-fPIC'] - v['macbundle_PATTERN'] = '%s.bundle' - -@conftest -def gxx_modifier_win32(conf): - v = conf.env - v['program_PATTERN'] = '%s.exe' - - v['shlib_PATTERN'] = '%s.dll' - v['implib_PATTERN'] = 'lib%s.dll.a' - v['IMPLIB_ST'] = '-Wl,--out-implib,%s' - - dest_arch = v['DEST_CPU'] - v['shlib_CXXFLAGS'] = [] - - v.append_value('shlib_CXXFLAGS', '-DDLL_EXPORT') # TODO adding nonstandard defines like this DLL_EXPORT is not a good idea - - # Auto-import is enabled by default even without this option, - # but enabling it explicitly has the nice effect of suppressing the rather boring, debug-level messages - # that the linker emits otherwise. - v.append_value('LINKFLAGS', '-Wl,--enable-auto-import') - -@conftest -def gxx_modifier_cygwin(conf): - gxx_modifier_win32(conf) - v = conf.env - v['shlib_PATTERN'] = 'cyg%s.dll' - v.append_value('shlib_LINKFLAGS', '-Wl,--enable-auto-image-base') - -@conftest -def gxx_modifier_darwin(conf): - v = conf.env - v['shlib_CXXFLAGS'] = ['-fPIC', '-compatibility_version', '1', '-current_version', '1'] - v['shlib_LINKFLAGS'] = ['-dynamiclib'] - v['shlib_PATTERN'] = 'lib%s.dylib' - - v['staticlib_LINKFLAGS'] = [] - - v['SHLIB_MARKER'] = '' - v['STATICLIB_MARKER'] = '' - v['SONAME_ST'] = '' - -@conftest -def gxx_modifier_aix(conf): - v = conf.env - v['program_LINKFLAGS'] = ['-Wl,-brtl'] - - v['shlib_LINKFLAGS'] = ['-shared', '-Wl,-brtl,-bexpfull'] - - v['SHLIB_MARKER'] = '' - -@conftest -def gxx_modifier_openbsd(conf): - conf.env['SONAME_ST'] = [] - -@conftest -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 detect(conf): - conf.find_gxx() - conf.find_cpp() - conf.find_ar() - conf.gxx_common_flags() - conf.gxx_modifier_platform() - conf.cxx_load_tools() - conf.cxx_add_flags() - conf.link_add_flags() diff --git a/third_party/waf/wafadmin/Tools/icc.py b/third_party/waf/wafadmin/Tools/icc.py deleted file mode 100644 index 9c9a92602c7..00000000000 --- a/third_party/waf/wafadmin/Tools/icc.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Stian Selnes, 2008 -# Thomas Nagy 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar, gcc -from Configure import conftest - -@conftest -def find_icc(conf): - if sys.platform == 'cygwin': - conf.fatal('The Intel compiler does not work on Cygwin') - - v = conf.env - cc = None - if v['CC']: cc = v['CC'] - elif 'CC' in conf.environ: cc = conf.environ['CC'] - if not cc: cc = conf.find_program('icc', var='CC') - if not cc: cc = conf.find_program('ICL', var='CC') - if not cc: conf.fatal('Intel C Compiler (icc) was not found') - cc = conf.cmd_to_list(cc) - - ccroot.get_cc_version(conf, cc, icc=True) - v['CC'] = cc - v['CC_NAME'] = 'icc' - -detect = ''' -find_icc -find_ar -gcc_common_flags -gcc_modifier_platform -cc_load_tools -cc_add_flags -link_add_flags -''' diff --git a/third_party/waf/wafadmin/Tools/icpc.py b/third_party/waf/wafadmin/Tools/icpc.py deleted file mode 100644 index 7d79c57e309..00000000000 --- a/third_party/waf/wafadmin/Tools/icpc.py +++ /dev/null @@ -1,35 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar, gxx -from Configure import conftest - -@conftest -def find_icpc(conf): - if sys.platform == 'cygwin': - conf.fatal('The Intel compiler does not work on Cygwin') - - v = conf.env - cxx = None - if v['CXX']: cxx = v['CXX'] - elif 'CXX' in conf.environ: cxx = conf.environ['CXX'] - if not cxx: cxx = conf.find_program('icpc', var='CXX') - if not cxx: conf.fatal('Intel C++ Compiler (icpc) was not found') - cxx = conf.cmd_to_list(cxx) - - ccroot.get_cc_version(conf, cxx, icc=True) - v['CXX'] = cxx - v['CXX_NAME'] = 'icc' - -detect = ''' -find_icpc -find_ar -gxx_common_flags -gxx_modifier_platform -cxx_load_tools -cxx_add_flags -link_add_flags -''' diff --git a/third_party/waf/wafadmin/Tools/intltool.py b/third_party/waf/wafadmin/Tools/intltool.py deleted file mode 100644 index 5fb3df2cbbb..00000000000 --- a/third_party/waf/wafadmin/Tools/intltool.py +++ /dev/null @@ -1,138 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -"intltool support" - -import os, re -import Configure, TaskGen, Task, Utils, Runner, Options, Build, config_c -from TaskGen import feature, before, taskgen -from Logs import error - -""" -Usage: - -bld(features='intltool_in', source='a.po b.po', podir='po', cache='.intlcache', flags='') - -""" - -class intltool_in_taskgen(TaskGen.task_gen): - """deprecated""" - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@before('apply_core') -@feature('intltool_in') -def iapply_intltool_in_f(self): - try: self.meths.remove('apply_core') - except ValueError: pass - - for i in self.to_list(self.source): - node = self.path.find_resource(i) - - podir = getattr(self, 'podir', 'po') - podirnode = self.path.find_dir(podir) - if not podirnode: - error("could not find the podir %r" % podir) - continue - - cache = getattr(self, 'intlcache', '.intlcache') - self.env['INTLCACHE'] = os.path.join(self.path.bldpath(self.env), podir, cache) - self.env['INTLPODIR'] = podirnode.srcpath(self.env) - self.env['INTLFLAGS'] = getattr(self, 'flags', ['-q', '-u', '-c']) - - task = self.create_task('intltool', node, node.change_ext('')) - task.install_path = self.install_path - -class intltool_po_taskgen(TaskGen.task_gen): - """deprecated""" - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - - -@feature('intltool_po') -def apply_intltool_po(self): - try: self.meths.remove('apply_core') - except ValueError: pass - - self.default_install_path = '${LOCALEDIR}' - appname = getattr(self, 'appname', 'set_your_app_name') - podir = getattr(self, 'podir', '') - - def install_translation(task): - out = task.outputs[0] - filename = out.name - (langname, ext) = os.path.splitext(filename) - inst_file = langname + os.sep + 'LC_MESSAGES' + os.sep + appname + '.mo' - self.bld.install_as(os.path.join(self.install_path, inst_file), out, self.env, self.chmod) - - linguas = self.path.find_resource(os.path.join(podir, 'LINGUAS')) - if linguas: - # scan LINGUAS file for locales to process - file = open(linguas.abspath()) - langs = [] - for line in file.readlines(): - # ignore lines containing comments - if not line.startswith('#'): - langs += line.split() - file.close() - re_linguas = re.compile('[-a-zA-Z_@.]+') - for lang in langs: - # Make sure that we only process lines which contain locales - if re_linguas.match(lang): - node = self.path.find_resource(os.path.join(podir, re_linguas.match(lang).group() + '.po')) - task = self.create_task('po') - task.set_inputs(node) - task.set_outputs(node.change_ext('.mo')) - if self.bld.is_install: task.install = install_translation - else: - Utils.pprint('RED', "Error no LINGUAS file found in po directory") - -Task.simple_task_type('po', '${POCOM} -o ${TGT} ${SRC}', color='BLUE', shell=False) -Task.simple_task_type('intltool', - '${INTLTOOL} ${INTLFLAGS} ${INTLCACHE} ${INTLPODIR} ${SRC} ${TGT}', - color='BLUE', after="cc_link cxx_link", shell=False) - -def detect(conf): - pocom = conf.find_program('msgfmt') - if not pocom: - # if msgfmt should not be mandatory, catch the thrown exception in your wscript - conf.fatal('The program msgfmt (gettext) is mandatory!') - conf.env['POCOM'] = pocom - - # NOTE: it is possible to set INTLTOOL in the environment, but it must not have spaces in it - - intltool = conf.find_program('intltool-merge', var='INTLTOOL') - if not intltool: - # if intltool-merge should not be mandatory, catch the thrown exception in your wscript - if Options.platform == 'win32': - perl = conf.find_program('perl', var='PERL') - if not perl: - conf.fatal('The program perl (required by intltool) could not be found') - - intltooldir = Configure.find_file('intltool-merge', os.environ['PATH'].split(os.pathsep)) - if not intltooldir: - conf.fatal('The program intltool-merge (intltool, gettext-devel) is mandatory!') - - conf.env['INTLTOOL'] = Utils.to_list(conf.env['PERL']) + [intltooldir + os.sep + 'intltool-merge'] - conf.check_message('intltool', '', True, ' '.join(conf.env['INTLTOOL'])) - else: - conf.fatal('The program intltool-merge (intltool, gettext-devel) is mandatory!') - - def getstr(varname): - return getattr(Options.options, varname, '') - - prefix = conf.env['PREFIX'] - datadir = getstr('datadir') - if not datadir: datadir = os.path.join(prefix,'share') - - conf.define('LOCALEDIR', os.path.join(datadir, 'locale')) - conf.define('DATADIR', datadir) - - if conf.env['CC'] or conf.env['CXX']: - # Define to 1 if <locale.h> is present - conf.check(header_name='locale.h') - -def set_options(opt): - opt.add_option('--want-rpath', type='int', default=1, dest='want_rpath', help='set rpath to 1 or 0 [Default 1]') - opt.add_option('--datadir', type='string', default='', dest='datadir', help='read-only application data') diff --git a/third_party/waf/wafadmin/Tools/javaw.py b/third_party/waf/wafadmin/Tools/javaw.py deleted file mode 100644 index 4d9f4c77907..00000000000 --- a/third_party/waf/wafadmin/Tools/javaw.py +++ /dev/null @@ -1,254 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) - -""" -Java support - -Javac is one of the few compilers that behaves very badly: -* it outputs files where it wants to (-d is only for the package root) -* it recompiles files silently behind your back -* it outputs an undefined amount of files (inner classes) - -Fortunately, the convention makes it possible to use the build dir without -too many problems for the moment - -Inner classes must be located and cleaned when a problem arise, -for the moment waf does not track the production of inner classes. - -Adding all the files to a task and executing it if any of the input files -change is only annoying for the compilation times - -Compilation can be run using Jython[1] rather than regular Python. Instead of -running one of the following commands: - ./waf configure - python waf configure -You would have to run: - java -jar /path/to/jython.jar waf configure - -[1] http://www.jython.org/ -""" - -import os, re -from Configure import conf -import TaskGen, Task, Utils, Options, Build -from TaskGen import feature, before, taskgen - -class_check_source = ''' -public class Test { - public static void main(String[] argv) { - Class lib; - if (argv.length < 1) { - System.err.println("Missing argument"); - System.exit(77); - } - try { - lib = Class.forName(argv[0]); - } catch (ClassNotFoundException e) { - System.err.println("ClassNotFoundException"); - System.exit(1); - } - lib = null; - System.exit(0); - } -} -''' - -@feature('jar') -@before('apply_core') -def jar_files(self): - basedir = getattr(self, 'basedir', '.') - destfile = getattr(self, 'destfile', 'test.jar') - jaropts = getattr(self, 'jaropts', []) - jarcreate = getattr(self, 'jarcreate', 'cf') - - dir = self.path.find_dir(basedir) - if not dir: raise - - jaropts.append('-C') - jaropts.append(dir.abspath(self.env)) - jaropts.append('.') - - out = self.path.find_or_declare(destfile) - - tsk = self.create_task('jar_create') - tsk.set_outputs(out) - tsk.inputs = [x for x in dir.find_iter(src=0, bld=1) if x.id != out.id] - tsk.env['JAROPTS'] = jaropts - tsk.env['JARCREATE'] = jarcreate - -@feature('javac') -@before('apply_core') -def apply_java(self): - Utils.def_attrs(self, jarname='', jaropts='', classpath='', - sourcepath='.', srcdir='.', source_re='**/*.java', - jar_mf_attributes={}, jar_mf_classpath=[]) - - if getattr(self, 'source_root', None): - # old stuff - self.srcdir = self.source_root - - - nodes_lst = [] - - if not self.classpath: - if not self.env['CLASSPATH']: - self.env['CLASSPATH'] = '..' + os.pathsep + '.' - else: - self.env['CLASSPATH'] = self.classpath - - srcdir_node = self.path.find_dir(self.srcdir) - if not srcdir_node: - raise Utils.WafError('could not find srcdir %r' % self.srcdir) - - src_nodes = [x for x in srcdir_node.ant_glob(self.source_re, flat=False)] - bld_nodes = [x.change_ext('.class') for x in src_nodes] - - self.env['OUTDIR'] = [srcdir_node.bldpath(self.env)] - - tsk = self.create_task('javac') - tsk.set_inputs(src_nodes) - tsk.set_outputs(bld_nodes) - - if getattr(self, 'compat', None): - tsk.env.append_value('JAVACFLAGS', ['-source', self.compat]) - - if hasattr(self, 'sourcepath'): - fold = [self.path.find_dir(x) for x in self.to_list(self.sourcepath)] - names = os.pathsep.join([x.srcpath() for x in fold]) - else: - names = srcdir_node.srcpath() - - if names: - tsk.env.append_value('JAVACFLAGS', ['-sourcepath', names]) - - if self.jarname: - jtsk = self.create_task('jar_create', bld_nodes, self.path.find_or_declare(self.jarname)) - jtsk.set_run_after(tsk) - - if not self.env.JAROPTS: - if self.jaropts: - self.env.JAROPTS = self.jaropts - else: - dirs = '.' - self.env.JAROPTS = ['-C', ''.join(self.env['OUTDIR']), dirs] - -Task.simple_task_type('jar_create', '${JAR} ${JARCREATE} ${TGT} ${JAROPTS}', color='GREEN', shell=False) -cls = Task.simple_task_type('javac', '${JAVAC} -classpath ${CLASSPATH} -d ${OUTDIR} ${JAVACFLAGS} ${SRC}', shell=False) -cls.color = 'BLUE' -def post_run_javac(self): - """this is for cleaning the folder - javac creates single files for inner classes - but it is not possible to know which inner classes in advance""" - - par = {} - for x in self.inputs: - par[x.parent.id] = x.parent - - inner = {} - for k in par.values(): - path = k.abspath(self.env) - lst = os.listdir(path) - - for u in lst: - if u.find('$') >= 0: - inner_class_node = k.find_or_declare(u) - inner[inner_class_node.id] = inner_class_node - - to_add = set(inner.keys()) - set([x.id for x in self.outputs]) - for x in to_add: - self.outputs.append(inner[x]) - - self.cached = True # disable the cache here - inner classes are a problem - return Task.Task.post_run(self) -cls.post_run = post_run_javac - -def detect(conf): - # If JAVA_PATH is set, we prepend it to the path list - java_path = conf.environ['PATH'].split(os.pathsep) - v = conf.env - - if 'JAVA_HOME' in conf.environ: - java_path = [os.path.join(conf.environ['JAVA_HOME'], 'bin')] + java_path - conf.env['JAVA_HOME'] = [conf.environ['JAVA_HOME']] - - for x in 'javac java jar'.split(): - conf.find_program(x, var=x.upper(), path_list=java_path) - conf.env[x.upper()] = conf.cmd_to_list(conf.env[x.upper()]) - v['JAVA_EXT'] = ['.java'] - - if 'CLASSPATH' in conf.environ: - v['CLASSPATH'] = conf.environ['CLASSPATH'] - - if not v['JAR']: conf.fatal('jar is required for making java packages') - if not v['JAVAC']: conf.fatal('javac is required for compiling java classes') - v['JARCREATE'] = 'cf' # can use cvf - -@conf -def check_java_class(self, classname, with_classpath=None): - """Check if the specified java class is installed""" - - import shutil - - javatestdir = '.waf-javatest' - - classpath = javatestdir - if self.env['CLASSPATH']: - classpath += os.pathsep + self.env['CLASSPATH'] - if isinstance(with_classpath, str): - classpath += os.pathsep + with_classpath - - shutil.rmtree(javatestdir, True) - os.mkdir(javatestdir) - - java_file = open(os.path.join(javatestdir, 'Test.java'), 'w') - java_file.write(class_check_source) - java_file.close() - - # Compile the source - Utils.exec_command(self.env['JAVAC'] + [os.path.join(javatestdir, 'Test.java')], shell=False) - - # Try to run the app - cmd = self.env['JAVA'] + ['-cp', classpath, 'Test', classname] - self.log.write("%s\n" % str(cmd)) - found = Utils.exec_command(cmd, shell=False, log=self.log) - - self.check_message('Java class %s' % classname, "", not found) - - shutil.rmtree(javatestdir, True) - - return found - -@conf -def check_jni_headers(conf): - """ - Check for jni headers and libraries - - On success the environment variable xxx_JAVA is added for uselib - """ - - if not conf.env.CC_NAME and not conf.env.CXX_NAME: - conf.fatal('load a compiler first (gcc, g++, ..)') - - if not conf.env.JAVA_HOME: - conf.fatal('set JAVA_HOME in the system environment') - - # jni requires the jvm - javaHome = conf.env['JAVA_HOME'][0] - - b = Build.BuildContext() - b.load_dirs(conf.srcdir, conf.blddir) - dir = b.root.find_dir(conf.env.JAVA_HOME[0] + '/include') - f = dir.ant_glob('**/(jni|jni_md).h', flat=False) - incDirs = [x.parent.abspath() for x in f] - - dir = b.root.find_dir(conf.env.JAVA_HOME[0]) - f = dir.ant_glob('**/*jvm.(so|dll)', flat=False) - libDirs = [x.parent.abspath() for x in f] or [javaHome] - - for i, d in enumerate(libDirs): - if conf.check(header_name='jni.h', define_name='HAVE_JNI_H', lib='jvm', - libpath=d, includes=incDirs, uselib_store='JAVA', uselib='JAVA'): - break - else: - conf.fatal('could not find lib jvm in %r (see config.log)' % libDirs) diff --git a/third_party/waf/wafadmin/Tools/kde4.py b/third_party/waf/wafadmin/Tools/kde4.py deleted file mode 100644 index 1f3bae783d3..00000000000 --- a/third_party/waf/wafadmin/Tools/kde4.py +++ /dev/null @@ -1,73 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -import os, sys, re -import Options, TaskGen, Task, Utils -from TaskGen import taskgen, feature, after - -class msgfmt_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('msgfmt') -def init_msgfmt(self): - #langs = '' # for example "foo/fr foo/br" - self.default_install_path = '${KDE4_LOCALE_INSTALL_DIR}' - -@feature('msgfmt') -@after('init_msgfmt') -def apply_msgfmt(self): - for lang in self.to_list(self.langs): - node = self.path.find_resource(lang+'.po') - task = self.create_task('msgfmt', node, node.change_ext('.mo')) - - if not self.bld.is_install: continue - langname = lang.split('/') - langname = langname[-1] - task.install_path = self.install_path + os.sep + langname + os.sep + 'LC_MESSAGES' - task.filename = getattr(self, 'appname', 'set_your_appname') + '.mo' - task.chmod = self.chmod - -def detect(conf): - kdeconfig = conf.find_program('kde4-config') - if not kdeconfig: - conf.fatal('we need kde4-config') - prefix = Utils.cmd_output('%s --prefix' % kdeconfig, silent=True).strip() - file = '%s/share/apps/cmake/modules/KDELibsDependencies.cmake' % prefix - try: os.stat(file) - except OSError: - file = '%s/share/kde4/apps/cmake/modules/KDELibsDependencies.cmake' % prefix - try: os.stat(file) - except OSError: conf.fatal('could not open %s' % file) - - try: - txt = Utils.readf(file) - except (OSError, IOError): - conf.fatal('could not read %s' % file) - - txt = txt.replace('\\\n', '\n') - fu = re.compile('#(.*)\n') - txt = fu.sub('', txt) - - setregexp = re.compile('([sS][eE][tT]\s*\()\s*([^\s]+)\s+\"([^"]+)\"\)') - found = setregexp.findall(txt) - - for (_, key, val) in found: - #print key, val - conf.env[key] = val - - # well well, i could just write an interpreter for cmake files - conf.env['LIB_KDECORE']='kdecore' - conf.env['LIB_KDEUI'] ='kdeui' - conf.env['LIB_KIO'] ='kio' - conf.env['LIB_KHTML'] ='khtml' - conf.env['LIB_KPARTS'] ='kparts' - - conf.env['LIBPATH_KDECORE'] = conf.env['KDE4_LIB_INSTALL_DIR'] - conf.env['CPPPATH_KDECORE'] = conf.env['KDE4_INCLUDE_INSTALL_DIR'] - conf.env.append_value('CPPPATH_KDECORE', conf.env['KDE4_INCLUDE_INSTALL_DIR']+"/KDE") - - conf.env['MSGFMT'] = conf.find_program('msgfmt') - -Task.simple_task_type('msgfmt', '${MSGFMT} ${SRC} -o ${TGT}', color='BLUE', shell=False) diff --git a/third_party/waf/wafadmin/Tools/libtool.py b/third_party/waf/wafadmin/Tools/libtool.py deleted file mode 100644 index bcc0e2f318d..00000000000 --- a/third_party/waf/wafadmin/Tools/libtool.py +++ /dev/null @@ -1,329 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Matthias Jahn, 2008, jahn matthias ath freenet punto de -# Thomas Nagy, 2008 (ita) - -import sys, re, os, optparse - -import TaskGen, Task, Utils, preproc -from Logs import error, debug, warn -from TaskGen import taskgen, after, before, feature - -REVISION="0.1.3" - -""" -if you want to use the code here, you must use something like this: -obj = obj.create(...) -obj.features.append("libtool") -obj.vnum = "1.2.3" # optional, but versioned libraries are common -""" - -# fake libtool files -fakelibtool_vardeps = ['CXX', 'PREFIX'] -def fakelibtool_build(task): - # Writes a .la file, used by libtool - env = task.env - dest = open(task.outputs[0].abspath(env), 'w') - sname = task.inputs[0].name - fu = dest.write - fu("# Generated by ltmain.sh - GNU libtool 1.5.18 - (pwn3d by BKsys II code name WAF)\n") - if env['vnum']: - nums = env['vnum'].split('.') - libname = task.inputs[0].name - name3 = libname+'.'+env['vnum'] - name2 = libname+'.'+nums[0] - name1 = libname - fu("dlname='%s'\n" % name2) - strn = " ".join([name3, name2, name1]) - fu("library_names='%s'\n" % (strn) ) - else: - fu("dlname='%s'\n" % sname) - fu("library_names='%s %s %s'\n" % (sname, sname, sname) ) - fu("old_library=''\n") - vars = ' '.join(env['libtoolvars']+env['LINKFLAGS']) - fu("dependency_libs='%s'\n" % vars) - fu("current=0\n") - fu("age=0\nrevision=0\ninstalled=yes\nshouldnotlink=no\n") - fu("dlopen=''\ndlpreopen=''\n") - fu("libdir='%s/lib'\n" % env['PREFIX']) - dest.close() - return 0 - -def read_la_file(path): - sp = re.compile(r'^([^=]+)=\'(.*)\'$') - dc={} - file = open(path, "r") - for line in file.readlines(): - try: - #print sp.split(line.strip()) - _, left, right, _ = sp.split(line.strip()) - dc[left]=right - except ValueError: - pass - file.close() - return dc - -@feature("libtool") -@after('apply_link') -def apply_link_libtool(self): - if self.type != 'program': - linktask = self.link_task - self.latask = self.create_task('fakelibtool', linktask.outputs, linktask.outputs[0].change_ext('.la')) - - if self.bld.is_install: - self.bld.install_files('${PREFIX}/lib', linktask.outputs[0], self.env) - -@feature("libtool") -@before('apply_core') -def apply_libtool(self): - self.env['vnum']=self.vnum - - paths=[] - libs=[] - libtool_files=[] - libtool_vars=[] - - for l in self.env['LINKFLAGS']: - if l[:2]=='-L': - paths.append(l[2:]) - elif l[:2]=='-l': - libs.append(l[2:]) - - for l in libs: - for p in paths: - dict = read_la_file(p+'/lib'+l+'.la') - linkflags2 = dict.get('dependency_libs', '') - for v in linkflags2.split(): - if v.endswith('.la'): - libtool_files.append(v) - libtool_vars.append(v) - continue - self.env.append_unique('LINKFLAGS', v) - break - - self.env['libtoolvars']=libtool_vars - - while libtool_files: - file = libtool_files.pop() - dict = read_la_file(file) - for v in dict['dependency_libs'].split(): - if v[-3:] == '.la': - libtool_files.append(v) - continue - self.env.append_unique('LINKFLAGS', v) - -Task.task_type_from_func('fakelibtool', vars=fakelibtool_vardeps, func=fakelibtool_build, color='BLUE', after="cc_link cxx_link static_link") - -class libtool_la_file: - def __init__ (self, la_filename): - self.__la_filename = la_filename - #remove path and .la suffix - self.linkname = str(os.path.split(la_filename)[-1])[:-3] - if self.linkname.startswith("lib"): - self.linkname = self.linkname[3:] - # The name that we can dlopen(3). - self.dlname = None - # Names of this library - self.library_names = None - # The name of the static archive. - self.old_library = None - # Libraries that this one depends upon. - self.dependency_libs = None - # Version information for libIlmImf. - self.current = None - self.age = None - self.revision = None - # Is this an already installed library? - self.installed = None - # Should we warn about portability when linking against -modules? - self.shouldnotlink = None - # Files to dlopen/dlpreopen - self.dlopen = None - self.dlpreopen = None - # Directory that this library needs to be installed in: - self.libdir = '/usr/lib' - if not self.__parse(): - raise ValueError("file %s not found!!" %(la_filename)) - - def __parse(self): - "Retrieve the variables from a file" - if not os.path.isfile(self.__la_filename): return 0 - la_file=open(self.__la_filename, 'r') - for line in la_file: - ln = line.strip() - if not ln: continue - if ln[0]=='#': continue - (key, value) = str(ln).split('=', 1) - key = key.strip() - value = value.strip() - if value == "no": value = False - elif value == "yes": value = True - else: - try: value = int(value) - except ValueError: value = value.strip("'") - setattr(self, key, value) - la_file.close() - return 1 - - def get_libs(self): - """return linkflags for this lib""" - libs = [] - if self.dependency_libs: - libs = str(self.dependency_libs).strip().split() - if libs == None: - libs = [] - # add la lib and libdir - libs.insert(0, "-l%s" % self.linkname.strip()) - libs.insert(0, "-L%s" % self.libdir.strip()) - return libs - - def __str__(self): - return '''\ -dlname = "%(dlname)s" -library_names = "%(library_names)s" -old_library = "%(old_library)s" -dependency_libs = "%(dependency_libs)s" -version = %(current)s.%(age)s.%(revision)s -installed = "%(installed)s" -shouldnotlink = "%(shouldnotlink)s" -dlopen = "%(dlopen)s" -dlpreopen = "%(dlpreopen)s" -libdir = "%(libdir)s"''' % self.__dict__ - -class libtool_config: - def __init__ (self, la_filename): - self.__libtool_la_file = libtool_la_file(la_filename) - tmp = self.__libtool_la_file - self.__version = [int(tmp.current), int(tmp.age), int(tmp.revision)] - self.__sub_la_files = [] - self.__sub_la_files.append(la_filename) - self.__libs = None - - def __cmp__(self, other): - """make it compareable with X.Y.Z versions (Y and Z are optional)""" - if not other: - return 1 - othervers = [int(s) for s in str(other).split(".")] - selfvers = self.__version - return cmp(selfvers, othervers) - - def __str__(self): - return "\n".join([ - str(self.__libtool_la_file), - ' '.join(self.__libtool_la_file.get_libs()), - '* New getlibs:', - ' '.join(self.get_libs()) - ]) - - def __get_la_libs(self, la_filename): - return libtool_la_file(la_filename).get_libs() - - def get_libs(self): - """return the complete uniqe linkflags that do not - contain .la files anymore""" - libs_list = list(self.__libtool_la_file.get_libs()) - libs_map = {} - while len(libs_list) > 0: - entry = libs_list.pop(0) - if entry: - if str(entry).endswith(".la"): - ## prevents duplicate .la checks - if entry not in self.__sub_la_files: - self.__sub_la_files.append(entry) - libs_list.extend(self.__get_la_libs(entry)) - else: - libs_map[entry]=1 - self.__libs = libs_map.keys() - return self.__libs - - def get_libs_only_L(self): - if not self.__libs: self.get_libs() - libs = self.__libs - libs = [s for s in libs if str(s).startswith('-L')] - return libs - - def get_libs_only_l(self): - if not self.__libs: self.get_libs() - libs = self.__libs - libs = [s for s in libs if str(s).startswith('-l')] - return libs - - def get_libs_only_other(self): - if not self.__libs: self.get_libs() - libs = self.__libs - libs = [s for s in libs if not(str(s).startswith('-L')or str(s).startswith('-l'))] - return libs - -def useCmdLine(): - """parse cmdline args and control build""" - usage = '''Usage: %prog [options] PathToFile.la -example: %prog --atleast-version=2.0.0 /usr/lib/libIlmImf.la -nor: %prog --libs /usr/lib/libamarok.la''' - parser = optparse.OptionParser(usage) - a = parser.add_option - a("--version", dest = "versionNumber", - action = "store_true", default = False, - help = "output version of libtool-config" - ) - a("--debug", dest = "debug", - action = "store_true", default = False, - help = "enable debug" - ) - a("--libs", dest = "libs", - action = "store_true", default = False, - help = "output all linker flags" - ) - a("--libs-only-l", dest = "libs_only_l", - action = "store_true", default = False, - help = "output -l flags" - ) - a("--libs-only-L", dest = "libs_only_L", - action = "store_true", default = False, - help = "output -L flags" - ) - a("--libs-only-other", dest = "libs_only_other", - action = "store_true", default = False, - help = "output other libs (e.g. -pthread)" - ) - a("--atleast-version", dest = "atleast_version", - default=None, - help = "return 0 if the module is at least version ATLEAST_VERSION" - ) - a("--exact-version", dest = "exact_version", - default=None, - help = "return 0 if the module is exactly version EXACT_VERSION" - ) - a("--max-version", dest = "max_version", - default=None, - help = "return 0 if the module is at no newer than version MAX_VERSION" - ) - - (options, args) = parser.parse_args() - if len(args) != 1 and not options.versionNumber: - parser.error("incorrect number of arguments") - if options.versionNumber: - print("libtool-config version %s" % REVISION) - return 0 - ltf = libtool_config(args[0]) - if options.debug: - print(ltf) - if options.atleast_version: - if ltf >= options.atleast_version: return 0 - sys.exit(1) - if options.exact_version: - if ltf == options.exact_version: return 0 - sys.exit(1) - if options.max_version: - if ltf <= options.max_version: return 0 - sys.exit(1) - - def p(x): - print(" ".join(x)) - if options.libs: p(ltf.get_libs()) - elif options.libs_only_l: p(ltf.get_libs_only_l()) - elif options.libs_only_L: p(ltf.get_libs_only_L()) - elif options.libs_only_other: p(ltf.get_libs_only_other()) - return 0 - -if __name__ == '__main__': - useCmdLine() diff --git a/third_party/waf/wafadmin/Tools/lua.py b/third_party/waf/wafadmin/Tools/lua.py deleted file mode 100644 index 8a6c1f46e79..00000000000 --- a/third_party/waf/wafadmin/Tools/lua.py +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Sebastian Schlingmann, 2008 -# Thomas Nagy, 2008 (ita) - -import TaskGen -from TaskGen import taskgen, feature -from Constants import * - -TaskGen.declare_chain( - name = 'luac', - rule = '${LUAC} -s -o ${TGT} ${SRC}', - ext_in = '.lua', - ext_out = '.luac', - reentrant = False, - install = 'LUADIR', # env variable -) - -@feature('lua') -def init_lua(self): - self.default_chmod = O755 - -def detect(conf): - conf.find_program('luac', var='LUAC', mandatory = True) diff --git a/third_party/waf/wafadmin/Tools/misc.py b/third_party/waf/wafadmin/Tools/misc.py deleted file mode 100644 index 6ef45aef444..00000000000 --- a/third_party/waf/wafadmin/Tools/misc.py +++ /dev/null @@ -1,429 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -""" -Custom objects: - - execute a function everytime - - copy a file somewhere else -""" - -import shutil, re, os -import TaskGen, Node, Task, Utils, Build, Constants -from TaskGen import feature, taskgen, after, before -from Logs import debug - -def copy_func(tsk): - "Make a file copy. This might be used to make other kinds of file processing (even calling a compiler is possible)" - env = tsk.env - infile = tsk.inputs[0].abspath(env) - outfile = tsk.outputs[0].abspath(env) - try: - shutil.copy2(infile, outfile) - except (OSError, IOError): - return 1 - else: - if tsk.chmod: os.chmod(outfile, tsk.chmod) - return 0 - -def action_process_file_func(tsk): - "Ask the function attached to the task to process it" - if not tsk.fun: raise Utils.WafError('task must have a function attached to it for copy_func to work!') - return tsk.fun(tsk) - -class cmd_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('cmd') -def apply_cmd(self): - "call a command everytime" - if not self.fun: raise Utils.WafError('cmdobj needs a function!') - tsk = Task.TaskBase() - tsk.fun = self.fun - tsk.env = self.env - self.tasks.append(tsk) - tsk.install_path = self.install_path - -class copy_taskgen(TaskGen.task_gen): - "By default, make a file copy, if fun is provided, fun will make the copy (or call a compiler, etc)" - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('copy') -@before('apply_core') -def apply_copy(self): - Utils.def_attrs(self, fun=copy_func) - self.default_install_path = 0 - - lst = self.to_list(self.source) - self.meths.remove('apply_core') - - for filename in lst: - node = self.path.find_resource(filename) - if not node: raise Utils.WafError('cannot find input file %s for processing' % filename) - - target = self.target - if not target or len(lst)>1: target = node.name - - # TODO the file path may be incorrect - newnode = self.path.find_or_declare(target) - - tsk = self.create_task('copy', node, newnode) - tsk.fun = self.fun - tsk.chmod = self.chmod - tsk.install_path = self.install_path - - if not tsk.env: - tsk.debug() - raise Utils.WafError('task without an environment') - -def subst_func(tsk): - "Substitutes variables in a .in file" - - m4_re = re.compile('@(\w+)@', re.M) - - env = tsk.env - infile = tsk.inputs[0].abspath(env) - outfile = tsk.outputs[0].abspath(env) - - code = Utils.readf(infile) - - # replace all % by %% to prevent errors by % signs in the input file while string formatting - code = code.replace('%', '%%') - - s = m4_re.sub(r'%(\1)s', code) - - di = tsk.dict or {} - if not di: - names = m4_re.findall(code) - for i in names: - di[i] = env.get_flat(i) or env.get_flat(i.upper()) - - file = open(outfile, 'w') - file.write(s % di) - file.close() - if tsk.chmod: os.chmod(outfile, tsk.chmod) - -class subst_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('subst') -@before('apply_core') -def apply_subst(self): - Utils.def_attrs(self, fun=subst_func) - self.default_install_path = 0 - lst = self.to_list(self.source) - self.meths.remove('apply_core') - - self.dict = getattr(self, 'dict', {}) - - for filename in lst: - node = self.path.find_resource(filename) - if not node: raise Utils.WafError('cannot find input file %s for processing' % filename) - - if self.target: - newnode = self.path.find_or_declare(self.target) - else: - newnode = node.change_ext('') - - try: - self.dict = self.dict.get_merged_dict() - except AttributeError: - pass - - if self.dict and not self.env['DICT_HASH']: - self.env = self.env.copy() - keys = list(self.dict.keys()) - keys.sort() - lst = [self.dict[x] for x in keys] - self.env['DICT_HASH'] = str(Utils.h_list(lst)) - - tsk = self.create_task('copy', node, newnode) - tsk.fun = self.fun - tsk.dict = self.dict - tsk.dep_vars = ['DICT_HASH'] - tsk.install_path = self.install_path - tsk.chmod = self.chmod - - if not tsk.env: - tsk.debug() - raise Utils.WafError('task without an environment') - -#################### -## command-output #### -#################### - -class cmd_arg(object): - """command-output arguments for representing files or folders""" - def __init__(self, name, template='%s'): - self.name = name - self.template = template - self.node = None - -class input_file(cmd_arg): - def find_node(self, base_path): - assert isinstance(base_path, Node.Node) - self.node = base_path.find_resource(self.name) - if self.node is None: - raise Utils.WafError("Input file %s not found in " % (self.name, base_path)) - - def get_path(self, env, absolute): - if absolute: - return self.template % self.node.abspath(env) - else: - return self.template % self.node.srcpath(env) - -class output_file(cmd_arg): - def find_node(self, base_path): - assert isinstance(base_path, Node.Node) - self.node = base_path.find_or_declare(self.name) - if self.node is None: - raise Utils.WafError("Output file %s not found in " % (self.name, base_path)) - - def get_path(self, env, absolute): - if absolute: - return self.template % self.node.abspath(env) - else: - return self.template % self.node.bldpath(env) - -class cmd_dir_arg(cmd_arg): - def find_node(self, base_path): - assert isinstance(base_path, Node.Node) - self.node = base_path.find_dir(self.name) - if self.node is None: - raise Utils.WafError("Directory %s not found in " % (self.name, base_path)) - -class input_dir(cmd_dir_arg): - def get_path(self, dummy_env, dummy_absolute): - return self.template % self.node.abspath() - -class output_dir(cmd_dir_arg): - def get_path(self, env, dummy_absolute): - return self.template % self.node.abspath(env) - - -class command_output(Task.Task): - color = "BLUE" - def __init__(self, env, command, command_node, command_args, stdin, stdout, cwd, os_env, stderr): - Task.Task.__init__(self, env, normal=1) - assert isinstance(command, (str, Node.Node)) - self.command = command - self.command_args = command_args - self.stdin = stdin - self.stdout = stdout - self.cwd = cwd - self.os_env = os_env - self.stderr = stderr - - if command_node is not None: self.dep_nodes = [command_node] - self.dep_vars = [] # additional environment variables to look - - def run(self): - task = self - #assert len(task.inputs) > 0 - - def input_path(node, template): - if task.cwd is None: - return template % node.bldpath(task.env) - else: - return template % node.abspath() - def output_path(node, template): - fun = node.abspath - if task.cwd is None: fun = node.bldpath - return template % fun(task.env) - - if isinstance(task.command, Node.Node): - argv = [input_path(task.command, '%s')] - else: - argv = [task.command] - - for arg in task.command_args: - if isinstance(arg, str): - argv.append(arg) - else: - assert isinstance(arg, cmd_arg) - argv.append(arg.get_path(task.env, (task.cwd is not None))) - - if task.stdin: - stdin = open(input_path(task.stdin, '%s')) - else: - stdin = None - - if task.stdout: - stdout = open(output_path(task.stdout, '%s'), "w") - else: - stdout = None - - if task.stderr: - stderr = open(output_path(task.stderr, '%s'), "w") - else: - stderr = None - - if task.cwd is None: - cwd = ('None (actually %r)' % os.getcwd()) - else: - cwd = repr(task.cwd) - debug("command-output: cwd=%s, stdin=%r, stdout=%r, argv=%r" % - (cwd, stdin, stdout, argv)) - - if task.os_env is None: - os_env = os.environ - else: - os_env = task.os_env - command = Utils.pproc.Popen(argv, stdin=stdin, stdout=stdout, stderr=stderr, cwd=task.cwd, env=os_env) - return command.wait() - -class cmd_output_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('command-output') -def init_cmd_output(self): - Utils.def_attrs(self, - stdin = None, - stdout = None, - stderr = None, - # the command to execute - command = None, - - # whether it is an external command; otherwise it is assumed - # to be an executable binary or script that lives in the - # source or build tree. - command_is_external = False, - - # extra parameters (argv) to pass to the command (excluding - # the command itself) - argv = [], - - # dependencies to other objects -> this is probably not what you want (ita) - # values must be 'task_gen' instances (not names!) - dependencies = [], - - # dependencies on env variable contents - dep_vars = [], - - # input files that are implicit, i.e. they are not - # stdin, nor are they mentioned explicitly in argv - hidden_inputs = [], - - # output files that are implicit, i.e. they are not - # stdout, nor are they mentioned explicitly in argv - hidden_outputs = [], - - # change the subprocess to this cwd (must use obj.input_dir() or output_dir() here) - cwd = None, - - # OS environment variables to pass to the subprocess - # if None, use the default environment variables unchanged - os_env = None) - -@feature('command-output') -@after('init_cmd_output') -def apply_cmd_output(self): - if self.command is None: - raise Utils.WafError("command-output missing command") - if self.command_is_external: - cmd = self.command - cmd_node = None - else: - cmd_node = self.path.find_resource(self.command) - assert cmd_node is not None, ('''Could not find command '%s' in source tree. -Hint: if this is an external command, -use command_is_external=True''') % (self.command,) - cmd = cmd_node - - if self.cwd is None: - cwd = None - else: - assert isinstance(cwd, CmdDirArg) - self.cwd.find_node(self.path) - - args = [] - inputs = [] - outputs = [] - - for arg in self.argv: - if isinstance(arg, cmd_arg): - arg.find_node(self.path) - if isinstance(arg, input_file): - inputs.append(arg.node) - if isinstance(arg, output_file): - outputs.append(arg.node) - - if self.stdout is None: - stdout = None - else: - assert isinstance(self.stdout, str) - stdout = self.path.find_or_declare(self.stdout) - if stdout is None: - raise Utils.WafError("File %s not found" % (self.stdout,)) - outputs.append(stdout) - - if self.stderr is None: - stderr = None - else: - assert isinstance(self.stderr, str) - stderr = self.path.find_or_declare(self.stderr) - if stderr is None: - raise Utils.WafError("File %s not found" % (self.stderr,)) - outputs.append(stderr) - - if self.stdin is None: - stdin = None - else: - assert isinstance(self.stdin, str) - stdin = self.path.find_resource(self.stdin) - if stdin is None: - raise Utils.WafError("File %s not found" % (self.stdin,)) - inputs.append(stdin) - - for hidden_input in self.to_list(self.hidden_inputs): - node = self.path.find_resource(hidden_input) - if node is None: - raise Utils.WafError("File %s not found in dir %s" % (hidden_input, self.path)) - inputs.append(node) - - for hidden_output in self.to_list(self.hidden_outputs): - node = self.path.find_or_declare(hidden_output) - if node is None: - raise Utils.WafError("File %s not found in dir %s" % (hidden_output, self.path)) - outputs.append(node) - - if not (inputs or getattr(self, 'no_inputs', None)): - raise Utils.WafError('command-output objects must have at least one input file or give self.no_inputs') - if not (outputs or getattr(self, 'no_outputs', None)): - raise Utils.WafError('command-output objects must have at least one output file or give self.no_outputs') - - task = command_output(self.env, cmd, cmd_node, self.argv, stdin, stdout, cwd, self.os_env, stderr) - Utils.copy_attrs(self, task, 'before after ext_in ext_out', only_if_set=True) - self.tasks.append(task) - - task.inputs = inputs - task.outputs = outputs - task.dep_vars = self.to_list(self.dep_vars) - - for dep in self.dependencies: - assert dep is not self - dep.post() - for dep_task in dep.tasks: - task.set_run_after(dep_task) - - if not task.inputs: - # the case for svnversion, always run, and update the output nodes - task.runnable_status = type(Task.TaskBase.run)(runnable_status, task, task.__class__) # always run - task.post_run = type(Task.TaskBase.run)(post_run, task, task.__class__) - - # TODO the case with no outputs? - -def post_run(self): - for x in self.outputs: - h = Utils.h_file(x.abspath(self.env)) - self.generator.bld.node_sigs[self.env.variant()][x.id] = h - -def runnable_status(self): - return Constants.RUN_ME - -Task.task_type_from_func('copy', vars=[], func=action_process_file_func) -TaskGen.task_gen.classes['command-output'] = cmd_output_taskgen diff --git a/third_party/waf/wafadmin/Tools/msvc.py b/third_party/waf/wafadmin/Tools/msvc.py deleted file mode 100644 index 3b82d438bd4..00000000000 --- a/third_party/waf/wafadmin/Tools/msvc.py +++ /dev/null @@ -1,796 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2006 (dv) -# Tamas Pal, 2007 (folti) -# Nicolas Mercier, 2009 -# Microsoft Visual C++/Intel C++ compiler support - beta, needs more testing - -# usage: -# -# conf.env['MSVC_VERSIONS'] = ['msvc 9.0', 'msvc 8.0', 'wsdk 7.0', 'intel 11', 'PocketPC 9.0', 'Smartphone 8.0'] -# conf.env['MSVC_TARGETS'] = ['x64'] -# conf.check_tool('msvc') -# OR conf.check_tool('msvc', funs='no_autodetect') -# conf.check_lib_msvc('gdi32') -# conf.check_libs_msvc('kernel32 user32', mandatory=true) -# ... -# obj.uselib = 'KERNEL32 USER32 GDI32' -# -# platforms and targets will be tested in the order they appear; -# the first good configuration will be used -# supported platforms : -# ia64, x64, x86, x86_amd64, x86_ia64 - -# compilers supported : -# msvc => Visual Studio, versions 7.1 (2003), 8,0 (2005), 9.0 (2008) -# wsdk => Windows SDK, versions 6.0, 6.1, 7.0 -# icl => Intel compiler, versions 9,10,11 -# Smartphone => Compiler/SDK for Smartphone devices (armv4/v4i) -# PocketPC => Compiler/SDK for PocketPC devices (armv4/v4i) - - -import os, sys, re, string, optparse -import Utils, TaskGen, Runner, Configure, Task, Options -from Logs import debug, info, warn, error -from TaskGen import after, before, feature - -from Configure import conftest, conf -import ccroot, cc, cxx, ar, winres -from libtool import read_la_file - -try: - import _winreg -except: - import winreg as _winreg - -pproc = Utils.pproc - -# importlibs provided by MSVC/Platform SDK. Do NOT search them.... -g_msvc_systemlibs = """ -aclui activeds ad1 adptif adsiid advapi32 asycfilt authz bhsupp bits bufferoverflowu cabinet -cap certadm certidl ciuuid clusapi comctl32 comdlg32 comsupp comsuppd comsuppw comsuppwd comsvcs -credui crypt32 cryptnet cryptui d3d8thk daouuid dbgeng dbghelp dciman32 ddao35 ddao35d -ddao35u ddao35ud delayimp dhcpcsvc dhcpsapi dlcapi dnsapi dsprop dsuiext dtchelp -faultrep fcachdll fci fdi framedyd framedyn gdi32 gdiplus glauxglu32 gpedit gpmuuid -gtrts32w gtrtst32hlink htmlhelp httpapi icm32 icmui imagehlp imm32 iphlpapi iprop -kernel32 ksguid ksproxy ksuser libcmt libcmtd libcpmt libcpmtd loadperf lz32 mapi -mapi32 mgmtapi minidump mmc mobsync mpr mprapi mqoa mqrt msacm32 mscms mscoree -msdasc msimg32 msrating mstask msvcmrt msvcurt msvcurtd mswsock msxml2 mtx mtxdm -netapi32 nmapinmsupp npptools ntdsapi ntdsbcli ntmsapi ntquery odbc32 odbcbcp -odbccp32 oldnames ole32 oleacc oleaut32 oledb oledlgolepro32 opends60 opengl32 -osptk parser pdh penter pgobootrun pgort powrprof psapi ptrustm ptrustmd ptrustu -ptrustud qosname rasapi32 rasdlg rassapi resutils riched20 rpcndr rpcns4 rpcrt4 rtm -rtutils runtmchk scarddlg scrnsave scrnsavw secur32 sensapi setupapi sfc shell32 -shfolder shlwapi sisbkup snmpapi sporder srclient sti strsafe svcguid tapi32 thunk32 -traffic unicows url urlmon user32 userenv usp10 uuid uxtheme vcomp vcompd vdmdbg -version vfw32 wbemuuid webpost wiaguid wininet winmm winscard winspool winstrm -wintrust wldap32 wmiutils wow32 ws2_32 wsnmp32 wsock32 wst wtsapi32 xaswitch xolehlp -""".split() - - -all_msvc_platforms = [ ('x64', 'amd64'), ('x86', 'x86'), ('ia64', 'ia64'), ('x86_amd64', 'amd64'), ('x86_ia64', 'ia64') ] -all_wince_platforms = [ ('armv4', 'arm'), ('armv4i', 'arm'), ('mipsii', 'mips'), ('mipsii_fp', 'mips'), ('mipsiv', 'mips'), ('mipsiv_fp', 'mips'), ('sh4', 'sh'), ('x86', 'cex86') ] -all_icl_platforms = [ ('intel64', 'amd64'), ('em64t', 'amd64'), ('ia32', 'x86'), ('Itanium', 'ia64')] - -def setup_msvc(conf, versions): - platforms = Utils.to_list(conf.env['MSVC_TARGETS']) or [i for i,j in all_msvc_platforms+all_icl_platforms+all_wince_platforms] - desired_versions = conf.env['MSVC_VERSIONS'] or [v for v,_ in versions][::-1] - versiondict = dict(versions) - - for version in desired_versions: - try: - targets = dict(versiondict [version]) - for target in platforms: - try: - arch,(p1,p2,p3) = targets[target] - compiler,revision = version.split() - return compiler,revision,p1,p2,p3 - except KeyError: continue - except KeyError: continue - conf.fatal('msvc: Impossible to find a valid architecture for building (in setup_msvc)') - -@conf -def get_msvc_version(conf, compiler, version, target, vcvars): - debug('msvc: get_msvc_version: %r %r %r', compiler, version, target) - batfile = os.path.join(conf.blddir, 'waf-print-msvc.bat') - f = open(batfile, 'w') - f.write("""@echo off -set INCLUDE= -set LIB= -call "%s" %s -echo PATH=%%PATH%% -echo INCLUDE=%%INCLUDE%% -echo LIB=%%LIB%% -""" % (vcvars,target)) - f.close() - sout = Utils.cmd_output(['cmd', '/E:on', '/V:on', '/C', batfile]) - lines = sout.splitlines() - - for x in ('Setting environment', 'Setting SDK environment', 'Intel(R) C++ Compiler'): - if lines[0].find(x) != -1: - break - else: - debug('msvc: get_msvc_version: %r %r %r -> not found', compiler, version, target) - conf.fatal('msvc: Impossible to find a valid architecture for building (in get_msvc_version)') - - for line in lines[1:]: - if line.startswith('PATH='): - path = line[5:] - MSVC_PATH = path.split(';') - elif line.startswith('INCLUDE='): - MSVC_INCDIR = [i for i in line[8:].split(';') if i] - elif line.startswith('LIB='): - MSVC_LIBDIR = [i for i in line[4:].split(';') if i] - - # Check if the compiler is usable at all. - # The detection may return 64-bit versions even on 32-bit systems, and these would fail to run. - env = {} - env.update(os.environ) - env.update(PATH = path) - compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler) - cxx = conf.find_program(compiler_name, path_list=MSVC_PATH) - # delete CL if exists. because it could contain parameters wich can change cl's behaviour rather catastrophically. - if env.has_key('CL'): - del(env['CL']) - - try: - p = pproc.Popen([cxx, '/help'], env=env, stdout=pproc.PIPE, stderr=pproc.PIPE) - out, err = p.communicate() - if p.returncode != 0: - raise Exception('return code: %r: %r' % (p.returncode, err)) - except Exception, e: - debug('msvc: get_msvc_version: %r %r %r -> failure', compiler, version, target) - debug(str(e)) - conf.fatal('msvc: cannot run the compiler (in get_msvc_version)') - else: - debug('msvc: get_msvc_version: %r %r %r -> OK', compiler, version, target) - - return (MSVC_PATH, MSVC_INCDIR, MSVC_LIBDIR) - -@conf -def gather_wsdk_versions(conf, versions): - version_pattern = re.compile('^v..?.?\...?.?') - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Microsoft\\Microsoft SDKs\\Windows') - except WindowsError: - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows') - except WindowsError: - return - index = 0 - while 1: - try: - version = _winreg.EnumKey(all_versions, index) - except WindowsError: - break - index = index + 1 - if not version_pattern.match(version): - continue - try: - msvc_version = _winreg.OpenKey(all_versions, version) - path,type = _winreg.QueryValueEx(msvc_version,'InstallationFolder') - except WindowsError: - continue - if os.path.isfile(os.path.join(path, 'bin', 'SetEnv.cmd')): - targets = [] - for target,arch in all_msvc_platforms: - try: - targets.append((target, (arch, conf.get_msvc_version('wsdk', version, '/'+target, os.path.join(path, 'bin', 'SetEnv.cmd'))))) - except Configure.ConfigurationError: - pass - versions.append(('wsdk ' + version[1:], targets)) - -@conf -def gather_msvc_versions(conf, versions): - # checks SmartPhones SDKs - try: - ce_sdk = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Microsoft\\Windows CE Tools\\SDKs') - except WindowsError: - try: - ce_sdk = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\Windows CE Tools\\SDKs') - except WindowsError: - ce_sdk = '' - if ce_sdk: - supported_wince_platforms = [] - ce_index = 0 - while 1: - try: - sdk_device = _winreg.EnumKey(ce_sdk, ce_index) - except WindowsError: - break - ce_index = ce_index + 1 - sdk = _winreg.OpenKey(ce_sdk, sdk_device) - path,type = _winreg.QueryValueEx(sdk, 'SDKRootDir') - path=str(path) - path,device = os.path.split(path) - if not device: - path,device = os.path.split(path) - for arch,compiler in all_wince_platforms: - platforms = [] - if os.path.isdir(os.path.join(path, device, 'Lib', arch)): - platforms.append((arch, compiler, os.path.join(path, device, 'Include', arch), os.path.join(path, device, 'Lib', arch))) - if platforms: - supported_wince_platforms.append((device, platforms)) - # checks MSVC - version_pattern = re.compile('^..?\...?') - for vcver,vcvar in [('VCExpress','exp'), ('VisualStudio','')]: - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Microsoft\\'+vcver) - except WindowsError: - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\'+vcver) - except WindowsError: - continue - index = 0 - while 1: - try: - version = _winreg.EnumKey(all_versions, index) - except WindowsError: - break - index = index + 1 - if not version_pattern.match(version): - continue - try: - msvc_version = _winreg.OpenKey(all_versions, version + "\\Setup\\VS") - path,type = _winreg.QueryValueEx(msvc_version, 'ProductDir') - path=str(path) - targets = [] - if ce_sdk: - for device,platforms in supported_wince_platforms: - cetargets = [] - for platform,compiler,include,lib in platforms: - winCEpath = os.path.join(path, 'VC', 'ce') - if os.path.isdir(winCEpath): - common_bindirs,_1,_2 = conf.get_msvc_version('msvc', version, 'x86', os.path.join(path, 'Common7', 'Tools', 'vsvars32.bat')) - if os.path.isdir(os.path.join(winCEpath, 'lib', platform)): - bindirs = [os.path.join(winCEpath, 'bin', compiler), os.path.join(winCEpath, 'bin', 'x86_'+compiler)] + common_bindirs - incdirs = [include, os.path.join(winCEpath, 'include'), os.path.join(winCEpath, 'atlmfc', 'include')] - libdirs = [lib, os.path.join(winCEpath, 'lib', platform), os.path.join(winCEpath, 'atlmfc', 'lib', platform)] - cetargets.append((platform, (platform, (bindirs,incdirs,libdirs)))) - versions.append((device+' '+version, cetargets)) - if os.path.isfile(os.path.join(path, 'VC', 'vcvarsall.bat')): - for target,realtarget in all_msvc_platforms[::-1]: - try: - targets.append((target, (realtarget, conf.get_msvc_version('msvc', version, target, os.path.join(path, 'VC', 'vcvarsall.bat'))))) - except: - pass - elif os.path.isfile(os.path.join(path, 'Common7', 'Tools', 'vsvars32.bat')): - try: - targets.append(('x86', ('x86', conf.get_msvc_version('msvc', version, 'x86', os.path.join(path, 'Common7', 'Tools', 'vsvars32.bat'))))) - except Configure.ConfigurationError: - pass - versions.append(('msvc '+version, targets)) - - except WindowsError: - continue - -@conf -def gather_icl_versions(conf, versions): - version_pattern = re.compile('^...?.?\....?.?') - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Wow6432node\\Intel\\Compilers\\C++') - except WindowsError: - try: - all_versions = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Intel\\Compilers\\C++') - except WindowsError: - return - index = 0 - while 1: - try: - version = _winreg.EnumKey(all_versions, index) - except WindowsError: - break - index = index + 1 - if not version_pattern.match(version): - continue - targets = [] - for target,arch in all_icl_platforms: - try: - icl_version = _winreg.OpenKey(all_versions, version+'\\'+target) - path,type = _winreg.QueryValueEx(icl_version,'ProductDir') - if os.path.isfile(os.path.join(path, 'bin', 'iclvars.bat')): - try: - targets.append((target, (arch, conf.get_msvc_version('intel', version, target, os.path.join(path, 'bin', 'iclvars.bat'))))) - except Configure.ConfigurationError: - pass - except WindowsError: - continue - major = version[0:2] - versions.append(('intel ' + major, targets)) - -@conf -def get_msvc_versions(conf): - if not conf.env.MSVC_INSTALLED_VERSIONS: - lst = [] - conf.gather_msvc_versions(lst) - conf.gather_wsdk_versions(lst) - conf.gather_icl_versions(lst) - conf.env.MSVC_INSTALLED_VERSIONS = lst - return conf.env.MSVC_INSTALLED_VERSIONS - -@conf -def print_all_msvc_detected(conf): - for version,targets in conf.env['MSVC_INSTALLED_VERSIONS']: - info(version) - for target,l in targets: - info("\t"+target) - -def detect_msvc(conf): - versions = get_msvc_versions(conf) - return setup_msvc(conf, versions) - -@conf -def find_lt_names_msvc(self, libname, is_static=False): - """ - Win32/MSVC specific code to glean out information from libtool la files. - this function is not attached to the task_gen class - """ - lt_names=[ - 'lib%s.la' % libname, - '%s.la' % libname, - ] - - for path in self.env['LIBPATH']: - for la in lt_names: - laf=os.path.join(path,la) - dll=None - if os.path.exists(laf): - ltdict=read_la_file(laf) - lt_libdir=None - if ltdict.get('libdir', ''): - lt_libdir = ltdict['libdir'] - if not is_static and ltdict.get('library_names', ''): - dllnames=ltdict['library_names'].split() - dll=dllnames[0].lower() - dll=re.sub('\.dll$', '', dll) - return (lt_libdir, dll, False) - elif ltdict.get('old_library', ''): - olib=ltdict['old_library'] - if os.path.exists(os.path.join(path,olib)): - return (path, olib, True) - elif lt_libdir != '' and os.path.exists(os.path.join(lt_libdir,olib)): - return (lt_libdir, olib, True) - else: - return (None, olib, True) - else: - raise Utils.WafError('invalid libtool object file: %s' % laf) - return (None, None, None) - -@conf -def libname_msvc(self, libname, is_static=False, mandatory=False): - lib = libname.lower() - lib = re.sub('\.lib$','',lib) - - if lib in g_msvc_systemlibs: - return lib - - lib=re.sub('^lib','',lib) - - if lib == 'm': - return None - - (lt_path, lt_libname, lt_static) = self.find_lt_names_msvc(lib, is_static) - - if lt_path != None and lt_libname != None: - if lt_static == True: - # file existence check has been made by find_lt_names - return os.path.join(lt_path,lt_libname) - - if lt_path != None: - _libpaths=[lt_path] + self.env['LIBPATH'] - else: - _libpaths=self.env['LIBPATH'] - - static_libs=[ - 'lib%ss.lib' % lib, - 'lib%s.lib' % lib, - '%ss.lib' % lib, - '%s.lib' %lib, - ] - - dynamic_libs=[ - 'lib%s.dll.lib' % lib, - 'lib%s.dll.a' % lib, - '%s.dll.lib' % lib, - '%s.dll.a' % lib, - 'lib%s_d.lib' % lib, - '%s_d.lib' % lib, - '%s.lib' %lib, - ] - - libnames=static_libs - if not is_static: - libnames=dynamic_libs + static_libs - - for path in _libpaths: - for libn in libnames: - if os.path.exists(os.path.join(path, libn)): - debug('msvc: lib found: %s', os.path.join(path,libn)) - return re.sub('\.lib$', '',libn) - - #if no lib can be found, just return the libname as msvc expects it - if mandatory: - self.fatal("The library %r could not be found" % libname) - return re.sub('\.lib$', '', libname) - -@conf -def check_lib_msvc(self, libname, is_static=False, uselib_store=None, mandatory=False): - "This is the api to use" - libn = self.libname_msvc(libname, is_static, mandatory) - - if not uselib_store: - uselib_store = libname.upper() - - # Note: ideally we should be able to place the lib in the right env var, either STATICLIB or LIB, - # but we don't distinguish static libs from shared libs. - # This is ok since msvc doesn't have any special linker flag to select static libs (no env['STATICLIB_MARKER']) - if False and is_static: # disabled - self.env['STATICLIB_' + uselib_store] = [libn] - else: - self.env['LIB_' + uselib_store] = [libn] - -@conf -def check_libs_msvc(self, libnames, is_static=False, mandatory=False): - for libname in Utils.to_list(libnames): - self.check_lib_msvc(libname, is_static, mandatory=mandatory) - -@conftest -def no_autodetect(conf): - conf.eval_rules(detect.replace('autodetect', '')) - - -detect = ''' -autodetect -find_msvc -msvc_common_flags -cc_load_tools -cxx_load_tools -cc_add_flags -cxx_add_flags -link_add_flags -''' - -@conftest -def autodetect(conf): - v = conf.env - compiler, version, path, includes, libdirs = detect_msvc(conf) - v['PATH'] = path - v['CPPPATH'] = includes - v['LIBPATH'] = libdirs - v['MSVC_COMPILER'] = compiler - -def _get_prog_names(conf, compiler): - if compiler=='intel': - compiler_name = 'ICL' - linker_name = 'XILINK' - lib_name = 'XILIB' - else: - # assumes CL.exe - compiler_name = 'CL' - linker_name = 'LINK' - lib_name = 'LIB' - return compiler_name, linker_name, lib_name - -@conftest -def find_msvc(conf): - # due to path format limitations, limit operation only to native Win32. Yeah it sucks. - if sys.platform != 'win32': - conf.fatal('MSVC module only works under native Win32 Python! cygwin is not supported yet') - - v = conf.env - - compiler, version, path, includes, libdirs = detect_msvc(conf) - - compiler_name, linker_name, lib_name = _get_prog_names(conf, compiler) - has_msvc_manifest = (compiler == 'msvc' and float(version) >= 8) or (compiler == 'wsdk' and float(version) >= 6) or (compiler == 'intel' and float(version) >= 11) - - # compiler - cxx = None - if v.CXX: cxx = v.CXX - elif 'CXX' in conf.environ: cxx = conf.environ['CXX'] - if not cxx: cxx = conf.find_program(compiler_name, var='CXX', path_list=path, mandatory=True) - cxx = conf.cmd_to_list(cxx) - - # before setting anything, check if the compiler is really msvc - env = dict(conf.environ) - env.update(PATH = ';'.join(path)) - if not Utils.cmd_output([cxx, '/nologo', '/?'], silent=True, env=env): - conf.fatal('the msvc compiler could not be identified') - - link = v.LINK_CXX - if not link: - link = conf.find_program(linker_name, path_list=path, mandatory=True) - ar = v.AR - if not ar: - ar = conf.find_program(lib_name, path_list=path, mandatory=True) - - # manifest tool. Not required for VS 2003 and below. Must have for VS 2005 and later - mt = v.MT - if has_msvc_manifest: - mt = conf.find_program('MT', path_list=path, mandatory=True) - - # no more possibility of failure means the data state will be consistent - # we may store the data safely now - - v.MSVC_MANIFEST = has_msvc_manifest - v.PATH = path - v.CPPPATH = includes - v.LIBPATH = libdirs - - # c/c++ compiler - v.CC = v.CXX = cxx - v.CC_NAME = v.CXX_NAME = 'msvc' - - v.LINK = v.LINK_CXX = link - if not v.LINK_CC: - v.LINK_CC = v.LINK_CXX - - v.AR = ar - v.MT = mt - v.MTFLAGS = v.ARFLAGS = ['/NOLOGO'] - - - conf.check_tool('winres') - - if not conf.env.WINRC: - warn('Resource compiler not found. Compiling resource file is disabled') - - # environment flags - try: v.prepend_value('CPPPATH', conf.environ['INCLUDE']) - except KeyError: pass - try: v.prepend_value('LIBPATH', conf.environ['LIB']) - except KeyError: pass - -@conftest -def msvc_common_flags(conf): - v = conf.env - - v['CPPFLAGS'] = ['/W3', '/nologo'] - - v['CCDEFINES_ST'] = '/D%s' - v['CXXDEFINES_ST'] = '/D%s' - - # TODO just use _WIN32, which defined by the compiler itself! - v['CCDEFINES'] = ['WIN32'] # avoid using this, any compiler predefines the _WIN32 marcro anyway - v['CXXDEFINES'] = ['WIN32'] # avoid using this, any compiler predefines the _WIN32 marcro anyway - - v['_CCINCFLAGS'] = [] - v['_CCDEFFLAGS'] = [] - v['_CXXINCFLAGS'] = [] - v['_CXXDEFFLAGS'] = [] - - v['CC_SRC_F'] = '' - v['CC_TGT_F'] = ['/c', '/Fo'] - v['CXX_SRC_F'] = '' - v['CXX_TGT_F'] = ['/c', '/Fo'] - - v['CPPPATH_ST'] = '/I%s' # template for adding include paths - - v['AR_TGT_F'] = v['CCLNK_TGT_F'] = v['CXXLNK_TGT_F'] = '/OUT:' - - # Subsystem specific flags - v['CPPFLAGS_CONSOLE'] = ['/SUBSYSTEM:CONSOLE'] - v['CPPFLAGS_NATIVE'] = ['/SUBSYSTEM:NATIVE'] - v['CPPFLAGS_POSIX'] = ['/SUBSYSTEM:POSIX'] - v['CPPFLAGS_WINDOWS'] = ['/SUBSYSTEM:WINDOWS'] - v['CPPFLAGS_WINDOWSCE'] = ['/SUBSYSTEM:WINDOWSCE'] - - # CRT specific flags - v['CPPFLAGS_CRT_MULTITHREADED'] = ['/MT'] - v['CPPFLAGS_CRT_MULTITHREADED_DLL'] = ['/MD'] - - # TODO these are defined by the compiler itself! - v['CPPDEFINES_CRT_MULTITHREADED'] = ['_MT'] # this is defined by the compiler itself! - v['CPPDEFINES_CRT_MULTITHREADED_DLL'] = ['_MT', '_DLL'] # these are defined by the compiler itself! - - v['CPPFLAGS_CRT_MULTITHREADED_DBG'] = ['/MTd'] - v['CPPFLAGS_CRT_MULTITHREADED_DLL_DBG'] = ['/MDd'] - - # TODO these are defined by the compiler itself! - v['CPPDEFINES_CRT_MULTITHREADED_DBG'] = ['_DEBUG', '_MT'] # these are defined by the compiler itself! - v['CPPDEFINES_CRT_MULTITHREADED_DLL_DBG'] = ['_DEBUG', '_MT', '_DLL'] # these are defined by the compiler itself! - - # compiler debug levels - v['CCFLAGS'] = ['/TC'] - v['CCFLAGS_OPTIMIZED'] = ['/O2', '/DNDEBUG'] - v['CCFLAGS_RELEASE'] = ['/O2', '/DNDEBUG'] - v['CCFLAGS_DEBUG'] = ['/Od', '/RTC1', '/ZI'] - v['CCFLAGS_ULTRADEBUG'] = ['/Od', '/RTC1', '/ZI'] - - v['CXXFLAGS'] = ['/TP', '/EHsc'] - v['CXXFLAGS_OPTIMIZED'] = ['/O2', '/DNDEBUG'] - v['CXXFLAGS_RELEASE'] = ['/O2', '/DNDEBUG'] - - v['CXXFLAGS_DEBUG'] = ['/Od', '/RTC1', '/ZI'] - v['CXXFLAGS_ULTRADEBUG'] = ['/Od', '/RTC1', '/ZI'] - - # linker - v['LIB'] = [] - - v['LIB_ST'] = '%s.lib' # template for adding libs - v['LIBPATH_ST'] = '/LIBPATH:%s' # template for adding libpaths - v['STATICLIB_ST'] = 'lib%s.lib' # Note: to be able to distinguish between a static lib and a dll import lib, it's a good pratice to name the static lib 'lib%s.lib' and the dll import lib '%s.lib' - v['STATICLIBPATH_ST'] = '/LIBPATH:%s' - - v['LINKFLAGS'] = ['/NOLOGO'] - if v['MSVC_MANIFEST']: - v.append_value('LINKFLAGS', '/MANIFEST') - v['LINKFLAGS_DEBUG'] = ['/DEBUG'] - v['LINKFLAGS_ULTRADEBUG'] = ['/DEBUG'] - - # shared library - v['shlib_CCFLAGS'] = [''] - v['shlib_CXXFLAGS'] = [''] - v['shlib_LINKFLAGS']= ['/DLL'] - v['shlib_PATTERN'] = '%s.dll' - v['implib_PATTERN'] = '%s.lib' - v['IMPLIB_ST'] = '/IMPLIB:%s' - - # static library - v['staticlib_LINKFLAGS'] = [''] - v['staticlib_PATTERN'] = 'lib%s.lib' # Note: to be able to distinguish between a static lib and a dll import lib, it's a good pratice to name the static lib 'lib%s.lib' and the dll import lib '%s.lib' - - # program - v['program_PATTERN'] = '%s.exe' - - -####################################################################################################### -##### conf above, build below - -@after('apply_link') -@feature('c', 'cc', 'cxx') -def apply_flags_msvc(self): - if self.env.CC_NAME != 'msvc' or not self.link_task: - return - - subsystem = getattr(self, 'subsystem', '') - if subsystem: - subsystem = '/subsystem:%s' % subsystem - flags = 'cstaticlib' in self.features and 'ARFLAGS' or 'LINKFLAGS' - self.env.append_value(flags, subsystem) - - if getattr(self, 'link_task', None) and not 'cstaticlib' in self.features: - for f in self.env.LINKFLAGS: - d = f.lower() - if d[1:] == 'debug': - pdbnode = self.link_task.outputs[0].change_ext('.pdb') - pdbfile = pdbnode.bldpath(self.env) - self.link_task.outputs.append(pdbnode) - self.bld.install_files(self.install_path, [pdbnode], env=self.env) - break - -@feature('cprogram', 'cshlib', 'cstaticlib') -@after('apply_lib_vars') -@before('apply_obj_vars') -def apply_obj_vars_msvc(self): - if self.env['CC_NAME'] != 'msvc': - return - - try: - self.meths.remove('apply_obj_vars') - except ValueError: - pass - - libpaths = getattr(self, 'libpaths', []) - if not libpaths: self.libpaths = libpaths - - env = self.env - app = env.append_unique - - cpppath_st = env['CPPPATH_ST'] - lib_st = env['LIB_ST'] - staticlib_st = env['STATICLIB_ST'] - libpath_st = env['LIBPATH_ST'] - staticlibpath_st = env['STATICLIBPATH_ST'] - - for i in env['LIBPATH']: - app('LINKFLAGS', libpath_st % i) - if not libpaths.count(i): - libpaths.append(i) - - for i in env['LIBPATH']: - app('LINKFLAGS', staticlibpath_st % i) - if not libpaths.count(i): - libpaths.append(i) - - # i doubt that anyone will make a fully static binary anyway - if not env['FULLSTATIC']: - if env['STATICLIB'] or env['LIB']: - app('LINKFLAGS', env['SHLIB_MARKER']) # TODO does SHLIB_MARKER work? - - for i in env['STATICLIB']: - app('LINKFLAGS', staticlib_st % i) - - for i in env['LIB']: - app('LINKFLAGS', lib_st % i) - -# split the manifest file processing from the link task, like for the rc processing - -@feature('cprogram', 'cshlib') -@after('apply_link') -def apply_manifest(self): - """Special linker for MSVC with support for embedding manifests into DLL's - and executables compiled by Visual Studio 2005 or probably later. Without - the manifest file, the binaries are unusable. - See: http://msdn2.microsoft.com/en-us/library/ms235542(VS.80).aspx""" - - if self.env.CC_NAME == 'msvc' and self.env.MSVC_MANIFEST: - out_node = self.link_task.outputs[0] - man_node = out_node.parent.find_or_declare(out_node.name + '.manifest') - self.link_task.outputs.append(man_node) - self.link_task.do_manifest = True - -def exec_mf(self): - env = self.env - mtool = env['MT'] - if not mtool: - return 0 - - self.do_manifest = False - - outfile = self.outputs[0].bldpath(env) - - manifest = None - for out_node in self.outputs: - if out_node.name.endswith('.manifest'): - manifest = out_node.bldpath(env) - break - if manifest is None: - # Should never get here. If we do, it means the manifest file was - # never added to the outputs list, thus we don't have a manifest file - # to embed, so we just return. - return 0 - - # embedding mode. Different for EXE's and DLL's. - # see: http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx - mode = '' - if 'cprogram' in self.generator.features: - mode = '1' - elif 'cshlib' in self.generator.features: - mode = '2' - - debug('msvc: embedding manifest') - #flags = ' '.join(env['MTFLAGS'] or []) - - lst = [] - lst.extend([env['MT']]) - lst.extend(Utils.to_list(env['MTFLAGS'])) - lst.extend(Utils.to_list("-manifest")) - lst.extend(Utils.to_list(manifest)) - lst.extend(Utils.to_list("-outputresource:%s;%s" % (outfile, mode))) - - #cmd='%s %s -manifest "%s" -outputresource:"%s";#%s' % (mtool, flags, - # manifest, outfile, mode) - lst = [lst] - return self.exec_command(*lst) - -########## stupid evil command modification: concatenate the tokens /Fx, /doc, and /x: with the next token - -def exec_command_msvc(self, *k, **kw): - "instead of quoting all the paths and keep using the shell, we can just join the options msvc is interested in" - if self.env['CC_NAME'] == 'msvc': - if isinstance(k[0], list): - lst = [] - carry = '' - for a in k[0]: - if len(a) == 3 and a.startswith('/F') or a == '/doc' or a[-1] == ':': - carry = a - else: - lst.append(carry + a) - carry = '' - k = [lst] - - env = dict(os.environ) - env.update(PATH = ';'.join(self.env['PATH'])) - kw['env'] = env - - ret = self.generator.bld.exec_command(*k, **kw) - if ret: return ret - if getattr(self, 'do_manifest', None): - ret = exec_mf(self) - return ret - -for k in 'cc cxx winrc cc_link cxx_link static_link qxx'.split(): - cls = Task.TaskBase.classes.get(k, None) - if cls: - cls.exec_command = exec_command_msvc diff --git a/third_party/waf/wafadmin/Tools/nasm.py b/third_party/waf/wafadmin/Tools/nasm.py deleted file mode 100644 index 43b73a7e483..00000000000 --- a/third_party/waf/wafadmin/Tools/nasm.py +++ /dev/null @@ -1,48 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2008 - -""" -Nasm processing -""" - -import os -import TaskGen, Task, Utils -from TaskGen import taskgen, before, extension - -nasm_str = '${NASM} ${NASM_FLAGS} ${NASM_INCLUDES} ${SRC} -o ${TGT}' - -EXT_NASM = ['.s', '.S', '.asm', '.ASM', '.spp', '.SPP'] - -@before('apply_link') -def apply_nasm_vars(self): - - # flags - if hasattr(self, 'nasm_flags'): - for flag in self.to_list(self.nasm_flags): - self.env.append_value('NASM_FLAGS', flag) - - # includes - well, if we suppose it works with c processing - if hasattr(self, 'includes'): - for inc in self.to_list(self.includes): - node = self.path.find_dir(inc) - if not node: - raise Utils.WafError('cannot find the dir' + inc) - self.env.append_value('NASM_INCLUDES', '-I%s' % node.srcpath(self.env)) - self.env.append_value('NASM_INCLUDES', '-I%s' % node.bldpath(self.env)) - -@extension(EXT_NASM) -def nasm_file(self, node): - try: obj_ext = self.obj_ext - except AttributeError: obj_ext = '_%d.o' % self.idx - - task = self.create_task('nasm', node, node.change_ext(obj_ext)) - self.compiled_tasks.append(task) - - self.meths.append('apply_nasm_vars') - -# create our action here -Task.simple_task_type('nasm', nasm_str, color='BLUE', ext_out='.o', shell=False) - -def detect(conf): - nasm = conf.find_program(['nasm', 'yasm'], var='NASM', mandatory=True) diff --git a/third_party/waf/wafadmin/Tools/ocaml.py b/third_party/waf/wafadmin/Tools/ocaml.py deleted file mode 100644 index a0667a4d257..00000000000 --- a/third_party/waf/wafadmin/Tools/ocaml.py +++ /dev/null @@ -1,297 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -"ocaml support" - -import os, re -import TaskGen, Utils, Task, Build -from Logs import error -from TaskGen import taskgen, feature, before, after, extension - -EXT_MLL = ['.mll'] -EXT_MLY = ['.mly'] -EXT_MLI = ['.mli'] -EXT_MLC = ['.c'] -EXT_ML = ['.ml'] - -open_re = re.compile('^\s*open\s+([a-zA-Z]+)(;;){0,1}$', re.M) -foo = re.compile(r"""(\(\*)|(\*\))|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^()*"'\\]*)""", re.M) -def filter_comments(txt): - meh = [0] - def repl(m): - if m.group(1): meh[0] += 1 - elif m.group(2): meh[0] -= 1 - elif not meh[0]: return m.group(0) - return '' - return foo.sub(repl, txt) - -def scan(self): - node = self.inputs[0] - code = filter_comments(node.read(self.env)) - - global open_re - names = [] - import_iterator = open_re.finditer(code) - if import_iterator: - for import_match in import_iterator: - names.append(import_match.group(1)) - found_lst = [] - raw_lst = [] - for name in names: - nd = None - for x in self.incpaths: - nd = x.find_resource(name.lower()+'.ml') - if not nd: nd = x.find_resource(name+'.ml') - if nd: - found_lst.append(nd) - break - else: - raw_lst.append(name) - - return (found_lst, raw_lst) - -native_lst=['native', 'all', 'c_object'] -bytecode_lst=['bytecode', 'all'] -class ocaml_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('ocaml') -def init_ml(self): - Utils.def_attrs(self, - type = 'all', - incpaths_lst = [], - bld_incpaths_lst = [], - mlltasks = [], - mlytasks = [], - mlitasks = [], - native_tasks = [], - bytecode_tasks = [], - linktasks = [], - bytecode_env = None, - native_env = None, - compiled_tasks = [], - includes = '', - uselib = '', - are_deps_set = 0) - -@feature('ocaml') -@after('init_ml') -def init_envs_ml(self): - - self.islibrary = getattr(self, 'islibrary', False) - - global native_lst, bytecode_lst - self.native_env = None - if self.type in native_lst: - self.native_env = self.env.copy() - if self.islibrary: self.native_env['OCALINKFLAGS'] = '-a' - - self.bytecode_env = None - if self.type in bytecode_lst: - self.bytecode_env = self.env.copy() - if self.islibrary: self.bytecode_env['OCALINKFLAGS'] = '-a' - - if self.type == 'c_object': - self.native_env.append_unique('OCALINKFLAGS_OPT', '-output-obj') - -@feature('ocaml') -@before('apply_vars_ml') -@after('init_envs_ml') -def apply_incpaths_ml(self): - inc_lst = self.includes.split() - lst = self.incpaths_lst - for dir in inc_lst: - node = self.path.find_dir(dir) - if not node: - error("node not found: " + str(dir)) - continue - self.bld.rescan(node) - if not node in lst: lst.append(node) - self.bld_incpaths_lst.append(node) - # now the nodes are added to self.incpaths_lst - -@feature('ocaml') -@before('apply_core') -def apply_vars_ml(self): - for i in self.incpaths_lst: - if self.bytecode_env: - app = self.bytecode_env.append_value - app('OCAMLPATH', '-I') - app('OCAMLPATH', i.srcpath(self.env)) - app('OCAMLPATH', '-I') - app('OCAMLPATH', i.bldpath(self.env)) - - if self.native_env: - app = self.native_env.append_value - app('OCAMLPATH', '-I') - app('OCAMLPATH', i.bldpath(self.env)) - app('OCAMLPATH', '-I') - app('OCAMLPATH', i.srcpath(self.env)) - - varnames = ['INCLUDES', 'OCAMLFLAGS', 'OCALINKFLAGS', 'OCALINKFLAGS_OPT'] - for name in self.uselib.split(): - for vname in varnames: - cnt = self.env[vname+'_'+name] - if cnt: - if self.bytecode_env: self.bytecode_env.append_value(vname, cnt) - if self.native_env: self.native_env.append_value(vname, cnt) - -@feature('ocaml') -@after('apply_core') -def apply_link_ml(self): - - if self.bytecode_env: - ext = self.islibrary and '.cma' or '.run' - - linktask = self.create_task('ocalink') - linktask.bytecode = 1 - linktask.set_outputs(self.path.find_or_declare(self.target + ext)) - linktask.obj = self - linktask.env = self.bytecode_env - self.linktasks.append(linktask) - - if self.native_env: - if self.type == 'c_object': ext = '.o' - elif self.islibrary: ext = '.cmxa' - else: ext = '' - - linktask = self.create_task('ocalinkx') - linktask.set_outputs(self.path.find_or_declare(self.target + ext)) - linktask.obj = self - linktask.env = self.native_env - self.linktasks.append(linktask) - - # we produce a .o file to be used by gcc - self.compiled_tasks.append(linktask) - -@extension(EXT_MLL) -def mll_hook(self, node): - mll_task = self.create_task('ocamllex', node, node.change_ext('.ml'), env=self.native_env) - self.mlltasks.append(mll_task) - - self.allnodes.append(mll_task.outputs[0]) - -@extension(EXT_MLY) -def mly_hook(self, node): - mly_task = self.create_task('ocamlyacc', node, [node.change_ext('.ml'), node.change_ext('.mli')], env=self.native_env) - self.mlytasks.append(mly_task) - self.allnodes.append(mly_task.outputs[0]) - - task = self.create_task('ocamlcmi', mly_task.outputs[1], mly_task.outputs[1].change_ext('.cmi'), env=self.native_env) - -@extension(EXT_MLI) -def mli_hook(self, node): - task = self.create_task('ocamlcmi', node, node.change_ext('.cmi'), env=self.native_env) - self.mlitasks.append(task) - -@extension(EXT_MLC) -def mlc_hook(self, node): - task = self.create_task('ocamlcc', node, node.change_ext('.o'), env=self.native_env) - self.compiled_tasks.append(task) - -@extension(EXT_ML) -def ml_hook(self, node): - if self.native_env: - task = self.create_task('ocamlx', node, node.change_ext('.cmx'), env=self.native_env) - task.obj = self - task.incpaths = self.bld_incpaths_lst - self.native_tasks.append(task) - - if self.bytecode_env: - task = self.create_task('ocaml', node, node.change_ext('.cmo'), env=self.bytecode_env) - task.obj = self - task.bytecode = 1 - task.incpaths = self.bld_incpaths_lst - self.bytecode_tasks.append(task) - -def compile_may_start(self): - if not getattr(self, 'flag_deps', ''): - self.flag_deps = 1 - - # the evil part is that we can only compute the dependencies after the - # source files can be read (this means actually producing the source files) - if getattr(self, 'bytecode', ''): alltasks = self.obj.bytecode_tasks - else: alltasks = self.obj.native_tasks - - self.signature() # ensure that files are scanned - unfortunately - tree = self.generator.bld - env = self.env - for node in self.inputs: - lst = tree.node_deps[self.unique_id()] - for depnode in lst: - for t in alltasks: - if t == self: continue - if depnode in t.inputs: - self.set_run_after(t) - - # TODO necessary to get the signature right - for now - delattr(self, 'cache_sig') - self.signature() - - return Task.Task.runnable_status(self) - -b = Task.simple_task_type -cls = b('ocamlx', '${OCAMLOPT} ${OCAMLPATH} ${OCAMLFLAGS} ${INCLUDES} -c -o ${TGT} ${SRC}', color='GREEN', shell=False) -cls.runnable_status = compile_may_start -cls.scan = scan - -b = Task.simple_task_type -cls = b('ocaml', '${OCAMLC} ${OCAMLPATH} ${OCAMLFLAGS} ${INCLUDES} -c -o ${TGT} ${SRC}', color='GREEN', shell=False) -cls.runnable_status = compile_may_start -cls.scan = scan - - -b('ocamlcmi', '${OCAMLC} ${OCAMLPATH} ${INCLUDES} -o ${TGT} -c ${SRC}', color='BLUE', before="ocaml ocamlcc ocamlx") -b('ocamlcc', 'cd ${TGT[0].bld_dir(env)} && ${OCAMLOPT} ${OCAMLFLAGS} ${OCAMLPATH} ${INCLUDES} -c ${SRC[0].abspath(env)}', color='GREEN') - -b('ocamllex', '${OCAMLLEX} ${SRC} -o ${TGT}', color='BLUE', before="ocamlcmi ocaml ocamlcc") -b('ocamlyacc', '${OCAMLYACC} -b ${TGT[0].bld_base(env)} ${SRC}', color='BLUE', before="ocamlcmi ocaml ocamlcc") - - -def link_may_start(self): - if not getattr(self, 'order', ''): - - # now reorder the inputs given the task dependencies - if getattr(self, 'bytecode', 0): alltasks = self.obj.bytecode_tasks - else: alltasks = self.obj.native_tasks - - # this part is difficult, we do not have a total order on the tasks - # if the dependencies are wrong, this may not stop - seen = [] - pendant = []+alltasks - while pendant: - task = pendant.pop(0) - if task in seen: continue - for x in task.run_after: - if not x in seen: - pendant.append(task) - break - else: - seen.append(task) - self.inputs = [x.outputs[0] for x in seen] - self.order = 1 - return Task.Task.runnable_status(self) - -act = b('ocalink', '${OCAMLC} -o ${TGT} ${INCLUDES} ${OCALINKFLAGS} ${SRC}', color='YELLOW', after="ocaml ocamlcc") -act.runnable_status = link_may_start -act = b('ocalinkx', '${OCAMLOPT} -o ${TGT} ${INCLUDES} ${OCALINKFLAGS_OPT} ${SRC}', color='YELLOW', after="ocamlx ocamlcc") -act.runnable_status = link_may_start - -def detect(conf): - opt = conf.find_program('ocamlopt', var='OCAMLOPT') - occ = conf.find_program('ocamlc', var='OCAMLC') - if (not opt) or (not occ): - conf.fatal('The objective caml compiler was not found:\ninstall it or make it available in your PATH') - - v = conf.env - v['OCAMLC'] = occ - v['OCAMLOPT'] = opt - v['OCAMLLEX'] = conf.find_program('ocamllex', var='OCAMLLEX') - v['OCAMLYACC'] = conf.find_program('ocamlyacc', var='OCAMLYACC') - v['OCAMLFLAGS'] = '' - v['OCAMLLIB'] = Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep - v['LIBPATH_OCAML'] = Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep - v['CPPPATH_OCAML'] = Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep - v['LIB_OCAML'] = 'camlrun' diff --git a/third_party/waf/wafadmin/Tools/osx.py b/third_party/waf/wafadmin/Tools/osx.py deleted file mode 100644 index 95184eec015..00000000000 --- a/third_party/waf/wafadmin/Tools/osx.py +++ /dev/null @@ -1,187 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy 2008 - -"""MacOSX related tools - -To compile an executable into a Mac application bundle (a .app), set its 'mac_app' attribute - obj.mac_app = True - -To make a bundled shared library (a .bundle), set the 'mac_bundle' attribute: - obj.mac_bundle = True -""" - -import os, shutil, sys, platform -import TaskGen, Task, Build, Options, Utils -from TaskGen import taskgen, feature, after, before -from Logs import error, debug - -# plist template -app_info = ''' -<?xml version="1.0" encoding="UTF-8"?> -<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd"> -<plist version="0.9"> -<dict> - <key>CFBundlePackageType</key> - <string>APPL</string> - <key>CFBundleGetInfoString</key> - <string>Created by Waf</string> - <key>CFBundleSignature</key> - <string>????</string> - <key>NOTE</key> - <string>THIS IS A GENERATED FILE, DO NOT MODIFY</string> - <key>CFBundleExecutable</key> - <string>%s</string> -</dict> -</plist> -''' - -# see WAF issue 285 -# and also http://trac.macports.org/ticket/17059 -@feature('c', 'cc', 'cxx') -@before('apply_lib_vars') -def set_macosx_deployment_target(self): - 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 sys.platform == 'darwin': - os.environ['MACOSX_DEPLOYMENT_TARGET'] = '.'.join(platform.mac_ver()[0].split('.')[:2]) - -@feature('c', 'cc', 'cxx') -@after('apply_lib_vars') -def apply_framework(self): - for x in self.to_list(self.env['FRAMEWORKPATH']): - frameworkpath_st = '-F%s' - self.env.append_unique('CXXFLAGS', frameworkpath_st % x) - self.env.append_unique('CCFLAGS', frameworkpath_st % x) - self.env.append_unique('LINKFLAGS', frameworkpath_st % x) - - for x in self.to_list(self.env['FRAMEWORK']): - self.env.append_value('LINKFLAGS', ['-framework', x]) - -@taskgen -def create_bundle_dirs(self, name, out): - bld = self.bld - dir = out.parent.get_dir(name) - - if not dir: - dir = out.__class__(name, out.parent, 1) - bld.rescan(dir) - contents = out.__class__('Contents', dir, 1) - bld.rescan(contents) - macos = out.__class__('MacOS', contents, 1) - bld.rescan(macos) - return dir - -def bundle_name_for_output(out): - name = out.name - k = name.rfind('.') - if k >= 0: - name = name[:k] + '.app' - else: - name = name + '.app' - return name - -@taskgen -@after('apply_link') -@feature('cprogram') -def create_task_macapp(self): - """Use env['MACAPP'] to force *all* executables to be transformed into Mac applications - or use obj.mac_app = True to build specific targets as Mac apps""" - if self.env['MACAPP'] or getattr(self, 'mac_app', False): - apptask = self.create_task('macapp') - apptask.set_inputs(self.link_task.outputs) - - out = self.link_task.outputs[0] - - name = bundle_name_for_output(out) - dir = self.create_bundle_dirs(name, out) - - n1 = dir.find_or_declare(['Contents', 'MacOS', out.name]) - - apptask.set_outputs([n1]) - apptask.chmod = 0755 - apptask.install_path = os.path.join(self.install_path, name, 'Contents', 'MacOS') - self.apptask = apptask - -@after('apply_link') -@feature('cprogram') -def create_task_macplist(self): - """Use env['MACAPP'] to force *all* executables to be transformed into Mac applications - or use obj.mac_app = True to build specific targets as Mac apps""" - if self.env['MACAPP'] or getattr(self, 'mac_app', False): - # check if the user specified a plist before using our template - if not getattr(self, 'mac_plist', False): - self.mac_plist = app_info - - plisttask = self.create_task('macplist') - plisttask.set_inputs(self.link_task.outputs) - - out = self.link_task.outputs[0] - self.mac_plist = self.mac_plist % (out.name) - - name = bundle_name_for_output(out) - dir = self.create_bundle_dirs(name, out) - - n1 = dir.find_or_declare(['Contents', 'Info.plist']) - - plisttask.set_outputs([n1]) - plisttask.mac_plist = self.mac_plist - plisttask.install_path = os.path.join(self.install_path, name, 'Contents') - self.plisttask = plisttask - -@after('apply_link') -@feature('cshlib') -def apply_link_osx(self): - name = self.link_task.outputs[0].name - if not self.install_path: - return - if getattr(self, 'vnum', None): - name = name.replace('.dylib', '.%s.dylib' % self.vnum) - - path = os.path.join(Utils.subst_vars(self.install_path, self.env), name) - if '-dynamiclib' in self.env['LINKFLAGS']: - self.env.append_value('LINKFLAGS', '-install_name') - self.env.append_value('LINKFLAGS', path) - -@before('apply_link', 'apply_lib_vars') -@feature('c', 'cc', 'cxx') -def apply_bundle(self): - """use env['MACBUNDLE'] to force all shlibs into mac bundles - or use obj.mac_bundle = True for specific targets only""" - if not ('cshlib' in self.features or 'shlib' in self.features): return - if self.env['MACBUNDLE'] or getattr(self, 'mac_bundle', False): - self.env['shlib_PATTERN'] = self.env['macbundle_PATTERN'] - uselib = self.uselib = self.to_list(self.uselib) - if not 'MACBUNDLE' in uselib: uselib.append('MACBUNDLE') - -@after('apply_link') -@feature('cshlib') -def apply_bundle_remove_dynamiclib(self): - if self.env['MACBUNDLE'] or getattr(self, 'mac_bundle', False): - if not getattr(self, 'vnum', None): - try: - self.env['LINKFLAGS'].remove('-dynamiclib') - self.env['LINKFLAGS'].remove('-single_module') - except ValueError: - pass - -# TODO REMOVE IN 1.6 (global variable) -app_dirs = ['Contents', 'Contents/MacOS', 'Contents/Resources'] - -def app_build(task): - env = task.env - shutil.copy2(task.inputs[0].srcpath(env), task.outputs[0].abspath(env)) - - return 0 - -def plist_build(task): - env = task.env - f = open(task.outputs[0].abspath(env), "w") - f.write(task.mac_plist) - f.close() - - return 0 - -Task.task_type_from_func('macapp', vars=[], func=app_build, after="cxx_link cc_link static_link") -Task.task_type_from_func('macplist', vars=[], func=plist_build, after="cxx_link cc_link static_link") diff --git a/third_party/waf/wafadmin/Tools/perl.py b/third_party/waf/wafadmin/Tools/perl.py deleted file mode 100644 index 85105ead88f..00000000000 --- a/third_party/waf/wafadmin/Tools/perl.py +++ /dev/null @@ -1,108 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# andersg at 0x63.nu 2007 - -import os -import Task, Options, Utils -from Configure import conf -from TaskGen import extension, taskgen, feature, before - -xsubpp_str = '${PERL} ${XSUBPP} -noprototypes -typemap ${EXTUTILS_TYPEMAP} ${SRC} > ${TGT}' -EXT_XS = ['.xs'] - -@before('apply_incpaths', 'apply_type_vars', 'apply_lib_vars') -@feature('perlext') -def init_perlext(self): - self.uselib = self.to_list(getattr(self, 'uselib', '')) - if not 'PERL' in self.uselib: self.uselib.append('PERL') - if not 'PERLEXT' in self.uselib: self.uselib.append('PERLEXT') - self.env['shlib_PATTERN'] = self.env['perlext_PATTERN'] - -@extension(EXT_XS) -def xsubpp_file(self, node): - outnode = node.change_ext('.c') - self.create_task('xsubpp', node, outnode) - self.allnodes.append(outnode) - -Task.simple_task_type('xsubpp', xsubpp_str, color='BLUE', before='cc cxx', shell=False) - -@conf -def check_perl_version(conf, minver=None): - """ - Checks if perl is installed. - - If installed the variable PERL will be set in environment. - - Perl binary can be overridden by --with-perl-binary config variable - - """ - - if getattr(Options.options, 'perlbinary', None): - conf.env.PERL = Options.options.perlbinary - else: - conf.find_program('perl', var='PERL', mandatory=True) - - try: - version = Utils.cmd_output([conf.env.PERL, '-e', 'printf "%vd",$^V']) - except: - conf.fatal('could not determine the perl version') - - conf.env.PERL_VERSION = version - cver = '' - if minver: - try: - ver = tuple(map(int, version.split('.'))) - except: - conf.fatal('unsupported perl version %r' % version) - if ver < minver: - conf.fatal('perl is too old') - - cver = '.'.join(map(str,minver)) - conf.check_message('perl', cver, True, version) - -@conf -def check_perl_module(conf, module): - """ - Check if specified perlmodule is installed. - - Minimum version can be specified by specifying it after modulename - like this: - - conf.check_perl_module("Some::Module 2.92") - """ - cmd = [conf.env['PERL'], '-e', 'use %s' % module] - r = Utils.pproc.call(cmd, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE) == 0 - conf.check_message("perl module %s" % module, "", r) - return r - -@conf -def check_perl_ext_devel(conf): - """ - Check for configuration needed to build perl extensions. - - Sets different xxx_PERLEXT variables in the environment. - - Also sets the ARCHDIR_PERL variable useful as installation path, - which can be overridden by --with-perl-archdir - """ - if not conf.env.PERL: - conf.fatal('perl detection is required first') - - def read_out(cmd): - return Utils.to_list(Utils.cmd_output([conf.env.PERL, '-MConfig', '-e', cmd])) - - conf.env.LINKFLAGS_PERLEXT = read_out('print $Config{lddlflags}') - conf.env.CPPPATH_PERLEXT = read_out('print "$Config{archlib}/CORE"') - conf.env.CCFLAGS_PERLEXT = read_out('print "$Config{ccflags} $Config{cccdlflags}"') - conf.env.XSUBPP = read_out('print "$Config{privlib}/ExtUtils/xsubpp$Config{exe_ext}"') - conf.env.EXTUTILS_TYPEMAP = read_out('print "$Config{privlib}/ExtUtils/typemap"') - conf.env.perlext_PATTERN = '%s.' + read_out('print $Config{dlext}')[0] - - if getattr(Options.options, 'perlarchdir', None): - conf.env.ARCHDIR_PERL = Options.options.perlarchdir - else: - conf.env.ARCHDIR_PERL = read_out('print $Config{sitearch}')[0] - -def set_options(opt): - opt.add_option("--with-perl-binary", type="string", dest="perlbinary", help = 'Specify alternate perl binary', default=None) - opt.add_option("--with-perl-archdir", type="string", dest="perlarchdir", help = 'Specify directory where to install arch specific files', default=None) diff --git a/third_party/waf/wafadmin/Tools/preproc.py b/third_party/waf/wafadmin/Tools/preproc.py deleted file mode 100644 index 71eb05ae092..00000000000 --- a/third_party/waf/wafadmin/Tools/preproc.py +++ /dev/null @@ -1,837 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2009 (ita) - -""" -C/C++ preprocessor for finding dependencies - -Reasons for using the Waf preprocessor by default -1. Some c/c++ extensions (Qt) require a custom preprocessor for obtaining the dependencies (.moc files) -2. Not all compilers provide .d files for obtaining the dependencies (portability) -3. A naive file scanner will not catch the constructs such as "#include foo()" -4. A naive file scanner will catch unnecessary dependencies (change an unused header -> recompile everything) - -Regarding the speed concerns: -a. the preprocessing is performed only when files must be compiled -b. the macros are evaluated only for #if/#elif/#include -c. the time penalty is about 10% -d. system headers are not scanned - -Now if you do not want the Waf preprocessor, the tool "gccdeps" uses the .d files produced -during the compilation to track the dependencies (useful when used with the boost libraries). -It only works with gcc though, and it cannot be used with Qt builds. A dumb -file scanner will be added in the future, so we will have most bahaviours. -""" -# TODO: more varargs, pragma once -# TODO: dumb file scanner tracking all includes - -import re, sys, os, string -import Logs, Build, Utils -from Logs import debug, error -import traceback - -class PreprocError(Utils.WafError): - pass - -POPFILE = '-' - - -recursion_limit = 5000 -"do not loop too much on header inclusion" - -go_absolute = 0 -"set to 1 to track headers on files in /usr/include - else absolute paths are ignored" - -standard_includes = ['/usr/include'] -if sys.platform == "win32": - standard_includes = [] - -use_trigraphs = 0 -'apply the trigraph rules first' - -strict_quotes = 0 -"Keep <> for system includes (do not search for those includes)" - -g_optrans = { -'not':'!', -'and':'&&', -'bitand':'&', -'and_eq':'&=', -'or':'||', -'bitor':'|', -'or_eq':'|=', -'xor':'^', -'xor_eq':'^=', -'compl':'~', -} -"these ops are for c++, to reset, set an empty dict" - -# ignore #warning and #error -re_lines = re.compile(\ - '^[ \t]*(#|%:)[ \t]*(ifdef|ifndef|if|else|elif|endif|include|import|define|undef|pragma)[ \t]*(.*)\r*$', - re.IGNORECASE | re.MULTILINE) - -re_mac = re.compile("^[a-zA-Z_]\w*") -re_fun = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*[(]') -re_pragma_once = re.compile('^\s*once\s*', re.IGNORECASE) -re_nl = re.compile('\\\\\r*\n', re.MULTILINE) -re_cpp = re.compile( - r"""(/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)|//[^\n]*|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|.[^/"'\\]*)""", - re.MULTILINE) -trig_def = [('??'+a, b) for a, b in zip("=-/!'()<>", r'#~\|^[]{}')] -chr_esc = {'0':0, 'a':7, 'b':8, 't':9, 'n':10, 'f':11, 'v':12, 'r':13, '\\':92, "'":39} - -NUM = 'i' -OP = 'O' -IDENT = 'T' -STR = 's' -CHAR = 'c' - -tok_types = [NUM, STR, IDENT, OP] -exp_types = [ - r"""0[xX](?P<hex>[a-fA-F0-9]+)(?P<qual1>[uUlL]*)|L*?'(?P<char>(\\.|[^\\'])+)'|(?P<n1>\d+)[Ee](?P<exp0>[+-]*?\d+)(?P<float0>[fFlL]*)|(?P<n2>\d*\.\d+)([Ee](?P<exp1>[+-]*?\d+))?(?P<float1>[fFlL]*)|(?P<n4>\d+\.\d*)([Ee](?P<exp2>[+-]*?\d+))?(?P<float2>[fFlL]*)|(?P<oct>0*)(?P<n0>\d+)(?P<qual2>[uUlL]*)""", - r'L?"([^"\\]|\\.)*"', - r'[a-zA-Z_]\w*', - r'%:%:|<<=|>>=|\.\.\.|<<|<%|<:|<=|>>|>=|\+\+|\+=|--|->|-=|\*=|/=|%:|%=|%>|==|&&|&=|\|\||\|=|\^=|:>|!=|##|[\(\)\{\}\[\]<>\?\|\^\*\+&=:!#;,%/\-\?\~\.]', -] -re_clexer = re.compile('|'.join(["(?P<%s>%s)" % (name, part) for name, part in zip(tok_types, exp_types)]), re.M) - -accepted = 'a' -ignored = 'i' -undefined = 'u' -skipped = 's' - -def repl(m): - if m.group(1): - return ' ' - s = m.group(2) - if s is None: - return '' - return s - -def filter_comments(filename): - # return a list of tuples : keyword, line - code = Utils.readf(filename) - if use_trigraphs: - for (a, b) in trig_def: code = code.split(a).join(b) - code = re_nl.sub('', code) - code = re_cpp.sub(repl, code) - return [(m.group(2), m.group(3)) for m in re.finditer(re_lines, code)] - -prec = {} -# op -> number, needed for such expressions: #if 1 && 2 != 0 -ops = ['* / %', '+ -', '<< >>', '< <= >= >', '== !=', '& | ^', '&& ||', ','] -for x in range(len(ops)): - syms = ops[x] - for u in syms.split(): - prec[u] = x - -def reduce_nums(val_1, val_2, val_op): - """apply arithmetic rules and try to return an integer result""" - #print val_1, val_2, val_op - - # now perform the operation, make certain a and b are numeric - try: a = 0 + val_1 - except TypeError: a = int(val_1) - try: b = 0 + val_2 - except TypeError: b = int(val_2) - - d = val_op - if d == '%': c = a%b - elif d=='+': c = a+b - elif d=='-': c = a-b - elif d=='*': c = a*b - elif d=='/': c = a/b - elif d=='^': c = a^b - elif d=='|': c = a|b - elif d=='||': c = int(a or b) - elif d=='&': c = a&b - elif d=='&&': c = int(a and b) - elif d=='==': c = int(a == b) - elif d=='!=': c = int(a != b) - elif d=='<=': c = int(a <= b) - elif d=='<': c = int(a < b) - elif d=='>': c = int(a > b) - elif d=='>=': c = int(a >= b) - elif d=='^': c = int(a^b) - elif d=='<<': c = a<<b - elif d=='>>': c = a>>b - else: c = 0 - return c - -def get_num(lst): - if not lst: raise PreprocError("empty list for get_num") - (p, v) = lst[0] - if p == OP: - if v == '(': - count_par = 1 - i = 1 - while i < len(lst): - (p, v) = lst[i] - - if p == OP: - if v == ')': - count_par -= 1 - if count_par == 0: - break - elif v == '(': - count_par += 1 - i += 1 - else: - raise PreprocError("rparen expected %r" % lst) - - (num, _) = get_term(lst[1:i]) - return (num, lst[i+1:]) - - elif v == '+': - return get_num(lst[1:]) - elif v == '-': - num, lst = get_num(lst[1:]) - return (reduce_nums('-1', num, '*'), lst) - elif v == '!': - num, lst = get_num(lst[1:]) - return (int(not int(num)), lst) - elif v == '~': - return (~ int(num), lst) - else: - raise PreprocError("invalid op token %r for get_num" % lst) - elif p == NUM: - return v, lst[1:] - elif p == IDENT: - # all macros should have been replaced, remaining identifiers eval to 0 - return 0, lst[1:] - else: - raise PreprocError("invalid token %r for get_num" % lst) - -def get_term(lst): - if not lst: raise PreprocError("empty list for get_term") - num, lst = get_num(lst) - if not lst: - return (num, []) - (p, v) = lst[0] - if p == OP: - if v == '&&' and not num: - return (num, []) - elif v == '||' and num: - return (num, []) - elif v == ',': - # skip - return get_term(lst[1:]) - elif v == '?': - count_par = 0 - i = 1 - while i < len(lst): - (p, v) = lst[i] - - if p == OP: - if v == ')': - count_par -= 1 - elif v == '(': - count_par += 1 - elif v == ':': - if count_par == 0: - break - i += 1 - else: - raise PreprocError("rparen expected %r" % lst) - - if int(num): - return get_term(lst[1:i]) - else: - return get_term(lst[i+1:]) - - else: - num2, lst = get_num(lst[1:]) - - if not lst: - # no more tokens to process - num2 = reduce_nums(num, num2, v) - return get_term([(NUM, num2)] + lst) - - # operator precedence - p2, v2 = lst[0] - if p2 != OP: - raise PreprocError("op expected %r" % lst) - - if prec[v2] >= prec[v]: - num2 = reduce_nums(num, num2, v) - return get_term([(NUM, num2)] + lst) - else: - num3, lst = get_num(lst[1:]) - num3 = reduce_nums(num2, num3, v2) - return get_term([(NUM, num), (p, v), (NUM, num3)] + lst) - - - raise PreprocError("cannot reduce %r" % lst) - -def reduce_eval(lst): - """take a list of tokens and output true or false (#if/#elif conditions)""" - num, lst = get_term(lst) - return (NUM, num) - -def stringize(lst): - """use for converting a list of tokens to a string""" - lst = [str(v2) for (p2, v2) in lst] - return "".join(lst) - -def paste_tokens(t1, t2): - """ - here is what we can paste: - a ## b -> ab - > ## = -> >= - a ## 2 -> a2 - """ - p1 = None - if t1[0] == OP and t2[0] == OP: - p1 = OP - elif t1[0] == IDENT and (t2[0] == IDENT or t2[0] == NUM): - p1 = IDENT - elif t1[0] == NUM and t2[0] == NUM: - p1 = NUM - if not p1: - raise PreprocError('tokens do not make a valid paste %r and %r' % (t1, t2)) - return (p1, t1[1] + t2[1]) - -def reduce_tokens(lst, defs, ban=[]): - """replace the tokens in lst, using the macros provided in defs, and a list of macros that cannot be re-applied""" - i = 0 - - while i < len(lst): - (p, v) = lst[i] - - if p == IDENT and v == "defined": - del lst[i] - if i < len(lst): - (p2, v2) = lst[i] - if p2 == IDENT: - if v2 in defs: - lst[i] = (NUM, 1) - else: - lst[i] = (NUM, 0) - elif p2 == OP and v2 == '(': - del lst[i] - (p2, v2) = lst[i] - del lst[i] # remove the ident, and change the ) for the value - if v2 in defs: - lst[i] = (NUM, 1) - else: - lst[i] = (NUM, 0) - else: - raise PreprocError("invalid define expression %r" % lst) - - elif p == IDENT and v in defs: - - if isinstance(defs[v], str): - a, b = extract_macro(defs[v]) - defs[v] = b - macro_def = defs[v] - to_add = macro_def[1] - - if isinstance(macro_def[0], list): - # macro without arguments - del lst[i] - for x in xrange(len(to_add)): - lst.insert(i, to_add[x]) - i += 1 - else: - # collect the arguments for the funcall - - args = [] - del lst[i] - - if i >= len(lst): - raise PreprocError("expected '(' after %r (got nothing)" % v) - - (p2, v2) = lst[i] - if p2 != OP or v2 != '(': - raise PreprocError("expected '(' after %r" % v) - - del lst[i] - - one_param = [] - count_paren = 0 - while i < len(lst): - p2, v2 = lst[i] - - del lst[i] - if p2 == OP and count_paren == 0: - if v2 == '(': - one_param.append((p2, v2)) - count_paren += 1 - elif v2 == ')': - if one_param: args.append(one_param) - break - elif v2 == ',': - if not one_param: raise PreprocError("empty param in funcall %s" % p) - args.append(one_param) - one_param = [] - else: - one_param.append((p2, v2)) - else: - one_param.append((p2, v2)) - if v2 == '(': count_paren += 1 - elif v2 == ')': count_paren -= 1 - else: - raise PreprocError('malformed macro') - - # substitute the arguments within the define expression - accu = [] - arg_table = macro_def[0] - j = 0 - while j < len(to_add): - (p2, v2) = to_add[j] - - if p2 == OP and v2 == '#': - # stringize is for arguments only - if j+1 < len(to_add) and to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table: - toks = args[arg_table[to_add[j+1][1]]] - accu.append((STR, stringize(toks))) - j += 1 - else: - accu.append((p2, v2)) - elif p2 == OP and v2 == '##': - # token pasting, how can man invent such a complicated system? - if accu and j+1 < len(to_add): - # we have at least two tokens - - t1 = accu[-1] - - if to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table: - toks = args[arg_table[to_add[j+1][1]]] - - if toks: - accu[-1] = paste_tokens(t1, toks[0]) #(IDENT, accu[-1][1] + toks[0][1]) - accu.extend(toks[1:]) - else: - # error, case "a##" - accu.append((p2, v2)) - accu.extend(toks) - elif to_add[j+1][0] == IDENT and to_add[j+1][1] == '__VA_ARGS__': - # TODO not sure - # first collect the tokens - va_toks = [] - st = len(macro_def[0]) - pt = len(args) - for x in args[pt-st+1:]: - va_toks.extend(x) - va_toks.append((OP, ',')) - if va_toks: va_toks.pop() # extra comma - if len(accu)>1: - (p3, v3) = accu[-1] - (p4, v4) = accu[-2] - if v3 == '##': - # remove the token paste - accu.pop() - if v4 == ',' and pt < st: - # remove the comma - accu.pop() - accu += va_toks - else: - accu[-1] = paste_tokens(t1, to_add[j+1]) - - j += 1 - else: - # invalid paste, case "##a" or "b##" - accu.append((p2, v2)) - - elif p2 == IDENT and v2 in arg_table: - toks = args[arg_table[v2]] - reduce_tokens(toks, defs, ban+[v]) - accu.extend(toks) - else: - accu.append((p2, v2)) - - j += 1 - - - reduce_tokens(accu, defs, ban+[v]) - - for x in xrange(len(accu)-1, -1, -1): - lst.insert(i, accu[x]) - - i += 1 - - -def eval_macro(lst, adefs): - """reduce the tokens from the list lst, and try to return a 0/1 result""" - reduce_tokens(lst, adefs, []) - if not lst: raise PreprocError("missing tokens to evaluate") - (p, v) = reduce_eval(lst) - return int(v) != 0 - -def extract_macro(txt): - """process a macro definition from "#define f(x, y) x * y" into a function or a simple macro without arguments""" - t = tokenize(txt) - if re_fun.search(txt): - p, name = t[0] - - p, v = t[1] - if p != OP: raise PreprocError("expected open parenthesis") - - i = 1 - pindex = 0 - params = {} - prev = '(' - - while 1: - i += 1 - p, v = t[i] - - if prev == '(': - if p == IDENT: - params[v] = pindex - pindex += 1 - prev = p - elif p == OP and v == ')': - break - else: - raise PreprocError("unexpected token (3)") - elif prev == IDENT: - if p == OP and v == ',': - prev = v - elif p == OP and v == ')': - break - else: - raise PreprocError("comma or ... expected") - elif prev == ',': - if p == IDENT: - params[v] = pindex - pindex += 1 - prev = p - elif p == OP and v == '...': - raise PreprocError("not implemented (1)") - else: - raise PreprocError("comma or ... expected (2)") - elif prev == '...': - raise PreprocError("not implemented (2)") - else: - raise PreprocError("unexpected else") - - #~ print (name, [params, t[i+1:]]) - return (name, [params, t[i+1:]]) - else: - (p, v) = t[0] - return (v, [[], t[1:]]) - -re_include = re.compile('^\s*(<(?P<a>.*)>|"(?P<b>.*)")') -def extract_include(txt, defs): - """process a line in the form "#include foo" to return a string representing the file""" - m = re_include.search(txt) - if m: - if m.group('a'): return '<', m.group('a') - if m.group('b'): return '"', m.group('b') - - # perform preprocessing and look at the result, it must match an include - toks = tokenize(txt) - reduce_tokens(toks, defs, ['waf_include']) - - if not toks: - raise PreprocError("could not parse include %s" % txt) - - if len(toks) == 1: - if toks[0][0] == STR: - return '"', toks[0][1] - else: - if toks[0][1] == '<' and toks[-1][1] == '>': - return stringize(toks).lstrip('<').rstrip('>') - - raise PreprocError("could not parse include %s." % txt) - -def parse_char(txt): - if not txt: raise PreprocError("attempted to parse a null char") - if txt[0] != '\\': - return ord(txt) - c = txt[1] - if c == 'x': - if len(txt) == 4 and txt[3] in string.hexdigits: return int(txt[2:], 16) - return int(txt[2:], 16) - elif c.isdigit(): - if c == '0' and len(txt)==2: return 0 - for i in 3, 2, 1: - if len(txt) > i and txt[1:1+i].isdigit(): - return (1+i, int(txt[1:1+i], 8)) - else: - try: return chr_esc[c] - except KeyError: raise PreprocError("could not parse char literal '%s'" % txt) - -@Utils.run_once -def tokenize_private(s): - ret = [] - for match in re_clexer.finditer(s): - m = match.group - for name in tok_types: - v = m(name) - if v: - if name == IDENT: - try: v = g_optrans[v]; name = OP - except KeyError: - # c++ specific - if v.lower() == "true": - v = 1 - name = NUM - elif v.lower() == "false": - v = 0 - name = NUM - elif name == NUM: - if m('oct'): v = int(v, 8) - elif m('hex'): v = int(m('hex'), 16) - elif m('n0'): v = m('n0') - else: - v = m('char') - if v: v = parse_char(v) - else: v = m('n2') or m('n4') - elif name == OP: - if v == '%:': v = '#' - elif v == '%:%:': v = '##' - elif name == STR: - # remove the quotes around the string - v = v[1:-1] - ret.append((name, v)) - break - return ret - -def tokenize(s): - """convert a string into a list of tokens (shlex.split does not apply to c/c++/d)""" - return tokenize_private(s)[:] - -@Utils.run_once -def define_name(line): - return re_mac.match(line).group(0) - -class c_parser(object): - def __init__(self, nodepaths=None, defines=None): - #self.lines = txt.split('\n') - self.lines = [] - - if defines is None: - self.defs = {} - else: - self.defs = dict(defines) # make a copy - self.state = [] - - self.env = None # needed for the variant when searching for files - - self.count_files = 0 - self.currentnode_stack = [] - - self.nodepaths = nodepaths or [] - - self.nodes = [] - self.names = [] - - # file added - self.curfile = '' - self.ban_includes = set([]) - - def cached_find_resource(self, node, filename): - try: - nd = node.bld.cache_nd - except: - nd = node.bld.cache_nd = {} - - tup = (node.id, filename) - try: - return nd[tup] - except KeyError: - ret = node.find_resource(filename) - nd[tup] = ret - return ret - - def tryfind(self, filename): - self.curfile = filename - - # for msvc it should be a for loop on the whole stack - found = self.cached_find_resource(self.currentnode_stack[-1], filename) - - for n in self.nodepaths: - if found: - break - found = self.cached_find_resource(n, filename) - - if found: - self.nodes.append(found) - if filename[-4:] != '.moc': - self.addlines(found) - else: - if not filename in self.names: - self.names.append(filename) - return found - - def addlines(self, node): - - self.currentnode_stack.append(node.parent) - filepath = node.abspath(self.env) - - self.count_files += 1 - if self.count_files > recursion_limit: raise PreprocError("recursion limit exceeded") - pc = self.parse_cache - debug('preproc: reading file %r', filepath) - try: - lns = pc[filepath] - except KeyError: - pass - else: - self.lines.extend(lns) - return - - try: - lines = filter_comments(filepath) - lines.append((POPFILE, '')) - lines.reverse() - pc[filepath] = lines # cache the lines filtered - self.lines.extend(lines) - except IOError: - raise PreprocError("could not read the file %s" % filepath) - except Exception: - if Logs.verbose > 0: - error("parsing %s failed" % filepath) - traceback.print_exc() - - def start(self, node, env): - debug('preproc: scanning %s (in %s)', node.name, node.parent.name) - - self.env = env - variant = node.variant(env) - bld = node.__class__.bld - try: - self.parse_cache = bld.parse_cache - except AttributeError: - bld.parse_cache = {} - self.parse_cache = bld.parse_cache - - self.addlines(node) - if env['DEFLINES']: - lst = [('define', x) for x in env['DEFLINES']] - lst.reverse() - self.lines.extend(lst) - - while self.lines: - (kind, line) = self.lines.pop() - if kind == POPFILE: - self.currentnode_stack.pop() - continue - try: - self.process_line(kind, line) - except Exception, e: - if Logs.verbose: - debug('preproc: line parsing failed (%s): %s %s', e, line, Utils.ex_stack()) - - def process_line(self, token, line): - """ - WARNING: a new state must be added for if* because the endif - """ - ve = Logs.verbose - if ve: debug('preproc: line is %s - %s state is %s', token, line, self.state) - state = self.state - - # make certain we define the state if we are about to enter in an if block - if token in ['ifdef', 'ifndef', 'if']: - state.append(undefined) - elif token == 'endif': - state.pop() - - # skip lines when in a dead 'if' branch, wait for the endif - if not token in ['else', 'elif', 'endif']: - if skipped in self.state or ignored in self.state: - return - - if token == 'if': - ret = eval_macro(tokenize(line), self.defs) - if ret: state[-1] = accepted - else: state[-1] = ignored - elif token == 'ifdef': - m = re_mac.match(line) - if m and m.group(0) in self.defs: state[-1] = accepted - else: state[-1] = ignored - elif token == 'ifndef': - m = re_mac.match(line) - if m and m.group(0) in self.defs: state[-1] = ignored - else: state[-1] = accepted - elif token == 'include' or token == 'import': - (kind, inc) = extract_include(line, self.defs) - if inc in self.ban_includes: return - if token == 'import': self.ban_includes.add(inc) - if ve: debug('preproc: include found %s (%s) ', inc, kind) - if kind == '"' or not strict_quotes: - self.tryfind(inc) - elif token == 'elif': - if state[-1] == accepted: - state[-1] = skipped - elif state[-1] == ignored: - if eval_macro(tokenize(line), self.defs): - state[-1] = accepted - elif token == 'else': - if state[-1] == accepted: state[-1] = skipped - elif state[-1] == ignored: state[-1] = accepted - elif token == 'define': - try: - self.defs[define_name(line)] = line - except: - raise PreprocError("invalid define line %s" % line) - elif token == 'undef': - m = re_mac.match(line) - if m and m.group(0) in self.defs: - self.defs.__delitem__(m.group(0)) - #print "undef %s" % name - elif token == 'pragma': - if re_pragma_once.match(line.lower()): - self.ban_includes.add(self.curfile) - -def get_deps(node, env, nodepaths=[]): - """ - Get the dependencies using a c/c++ preprocessor, this is required for finding dependencies of the kind - #include some_macro() - """ - - gruik = c_parser(nodepaths) - gruik.start(node, env) - return (gruik.nodes, gruik.names) - -#################### dumb dependency scanner - -re_inc = re.compile(\ - '^[ \t]*(#|%:)[ \t]*(include)[ \t]*(.*)\r*$', - re.IGNORECASE | re.MULTILINE) - -def lines_includes(filename): - code = Utils.readf(filename) - if use_trigraphs: - for (a, b) in trig_def: code = code.split(a).join(b) - code = re_nl.sub('', code) - code = re_cpp.sub(repl, code) - return [(m.group(2), m.group(3)) for m in re.finditer(re_inc, code)] - -def get_deps_simple(node, env, nodepaths=[], defines={}): - """ - Get the dependencies by just looking recursively at the #include statements - """ - - nodes = [] - names = [] - - def find_deps(node): - lst = lines_includes(node.abspath(env)) - - for (_, line) in lst: - (t, filename) = extract_include(line, defines) - if filename in names: - continue - - if filename.endswith('.moc'): - names.append(filename) - - found = None - for n in nodepaths: - if found: - break - found = n.find_resource(filename) - - if not found: - if not filename in names: - names.append(filename) - elif not found in nodes: - nodes.append(found) - find_deps(node) - - find_deps(node) - return (nodes, names) diff --git a/third_party/waf/wafadmin/Tools/python.py b/third_party/waf/wafadmin/Tools/python.py deleted file mode 100644 index cd96b658185..00000000000 --- a/third_party/waf/wafadmin/Tools/python.py +++ /dev/null @@ -1,432 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2007 (ita) -# Gustavo Carneiro (gjc), 2007 - -"Python support" - -import os, sys -import TaskGen, Utils, Options -from Logs import debug, warn, info -from TaskGen import extension, before, after, feature -from Configure import conf -from config_c import parse_flags - -EXT_PY = ['.py'] -FRAG_2 = ''' -#include "Python.h" -#ifdef __cplusplus -extern "C" { -#endif - void Py_Initialize(void); - void Py_Finalize(void); -#ifdef __cplusplus -} -#endif -int main() -{ - Py_Initialize(); - Py_Finalize(); - return 0; -} -''' - -@feature('pyext') -@before('apply_incpaths', 'apply_lib_vars', 'apply_type_vars', 'apply_bundle') -@after('vars_target_cshlib') -def init_pyext(self): - self.default_install_path = '${PYTHONARCHDIR}' - self.uselib = self.to_list(getattr(self, 'uselib', '')) - if not 'PYEXT' in self.uselib: - self.uselib.append('PYEXT') - self.env['MACBUNDLE'] = True - -@before('apply_link', 'apply_lib_vars', 'apply_type_vars') -@after('apply_bundle') -@feature('pyext') -def pyext_shlib_ext(self): - # override shlib_PATTERN set by the osx module - self.env['shlib_PATTERN'] = self.env['pyext_PATTERN'] - -@before('apply_incpaths', 'apply_lib_vars', 'apply_type_vars') -@feature('pyembed') -def init_pyembed(self): - self.uselib = self.to_list(getattr(self, 'uselib', '')) - if not 'PYEMBED' in self.uselib: - self.uselib.append('PYEMBED') - -@extension(EXT_PY) -def process_py(self, node): - if not (self.bld.is_install and self.install_path): - return - def inst_py(ctx): - install_pyfile(self, node) - self.bld.add_post_fun(inst_py) - -def install_pyfile(self, node): - path = self.bld.get_install_path(self.install_path + os.sep + node.name, self.env) - - self.bld.install_files(self.install_path, [node], self.env, self.chmod, postpone=False) - if self.bld.is_install < 0: - info("* removing byte compiled python files") - for x in 'co': - try: - os.remove(path + x) - except OSError: - pass - - if self.bld.is_install > 0: - if self.env['PYC'] or self.env['PYO']: - info("* byte compiling %r" % path) - - if self.env['PYC']: - program = (""" -import sys, py_compile -for pyfile in sys.argv[1:]: - py_compile.compile(pyfile, pyfile + 'c') -""") - argv = [self.env['PYTHON'], '-c', program, path] - ret = Utils.pproc.Popen(argv).wait() - if ret: - raise Utils.WafError('bytecode compilation failed %r' % path) - - if self.env['PYO']: - program = (""" -import sys, py_compile -for pyfile in sys.argv[1:]: - py_compile.compile(pyfile, pyfile + 'o') -""") - argv = [self.env['PYTHON'], self.env['PYFLAGS_OPT'], '-c', program, path] - ret = Utils.pproc.Popen(argv).wait() - if ret: - raise Utils.WafError('bytecode compilation failed %r' % path) - -# COMPAT -class py_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@before('apply_core') -@after('vars_target_cprogram', 'vars_target_cshlib') -@feature('py') -def init_py(self): - self.default_install_path = '${PYTHONDIR}' - -def _get_python_variables(python_exe, variables, imports=['import sys']): - """Run a python interpreter and print some variables""" - program = list(imports) - program.append('') - for v in variables: - program.append("print(repr(%s))" % v) - os_env = dict(os.environ) - try: - del os_env['MACOSX_DEPLOYMENT_TARGET'] # see comments in the OSX tool - except KeyError: - pass - proc = Utils.pproc.Popen([python_exe, "-c", '\n'.join(program)], stdout=Utils.pproc.PIPE, env=os_env) - output = proc.communicate()[0].split("\n") # do not touch, python3 - if proc.returncode: - if Options.options.verbose: - warn("Python program to extract python configuration variables failed:\n%s" - % '\n'.join(["line %03i: %s" % (lineno+1, line) for lineno, line in enumerate(program)])) - raise RuntimeError - return_values = [] - for s in output: - s = s.strip() - if not s: - continue - if s == 'None': - return_values.append(None) - elif (s[0] == "'" and s[-1] == "'") or (s[0] == '"' and s[-1] == '"'): - return_values.append(eval(s)) - elif s[0].isdigit(): - return_values.append(int(s)) - else: break - return return_values - -@conf -def check_python_headers(conf, mandatory=True): - """Check for headers and libraries necessary to extend or embed python. - - On success the environment variables xxx_PYEXT and xxx_PYEMBED are added for uselib - - PYEXT: for compiling python extensions - PYEMBED: for embedding a python interpreter""" - - if not conf.env['CC_NAME'] and not conf.env['CXX_NAME']: - conf.fatal('load a compiler first (gcc, g++, ..)') - - if not conf.env['PYTHON_VERSION']: - conf.check_python_version() - - env = conf.env - python = env['PYTHON'] - if not python: - conf.fatal('could not find the python executable') - - ## On Mac OSX we need to use mac bundles for python plugins - if Options.platform == 'darwin': - conf.check_tool('osx') - - try: - # Get some python configuration variables using distutils - v = 'prefix SO SYSLIBS LDFLAGS SHLIBS LIBDIR LIBPL INCLUDEPY Py_ENABLE_SHARED MACOSX_DEPLOYMENT_TARGET LDVERSION'.split() - (python_prefix, python_SO, python_SYSLIBS, python_LDFLAGS, python_SHLIBS, - python_LIBDIR, python_LIBPL, INCLUDEPY, Py_ENABLE_SHARED, - python_MACOSX_DEPLOYMENT_TARGET, python_LDVERSION) = \ - _get_python_variables(python, ["get_config_var('%s') or ''" % x for x in v], - ['from distutils.sysconfig import get_config_var']) - except RuntimeError: - conf.fatal("Python development headers not found (-v for details).") - - conf.log.write("""Configuration returned from %r: -python_prefix = %r -python_SO = %r -python_SYSLIBS = %r -python_LDFLAGS = %r -python_SHLIBS = %r -python_LIBDIR = %r -python_LIBPL = %r -INCLUDEPY = %r -Py_ENABLE_SHARED = %r -MACOSX_DEPLOYMENT_TARGET = %r -LDVERSION = %r -""" % (python, python_prefix, python_SO, python_SYSLIBS, python_LDFLAGS, python_SHLIBS, - python_LIBDIR, python_LIBPL, INCLUDEPY, Py_ENABLE_SHARED, python_MACOSX_DEPLOYMENT_TARGET, - python_LDVERSION)) - - # Allow some python overrides from env vars for cross-compiling - os_env = dict(os.environ) - - override_python_LDFLAGS = os_env.get('python_LDFLAGS', None) - if override_python_LDFLAGS is not None: - conf.log.write("python_LDFLAGS override from environment = %r\n" % (override_python_LDFLAGS)) - python_LDFLAGS = override_python_LDFLAGS - - override_python_LIBDIR = os_env.get('python_LIBDIR', None) - if override_python_LIBDIR is not None: - conf.log.write("python_LIBDIR override from environment = %r\n" % (override_python_LIBDIR)) - python_LIBDIR = override_python_LIBDIR - - if python_MACOSX_DEPLOYMENT_TARGET: - conf.env['MACOSX_DEPLOYMENT_TARGET'] = python_MACOSX_DEPLOYMENT_TARGET - conf.environ['MACOSX_DEPLOYMENT_TARGET'] = python_MACOSX_DEPLOYMENT_TARGET - - env['pyext_PATTERN'] = '%s'+python_SO - - # Check for python libraries for embedding - if python_SYSLIBS is not None: - for lib in python_SYSLIBS.split(): - if lib.startswith('-l'): - lib = lib[2:] # strip '-l' - env.append_value('LIB_PYEMBED', lib) - - if python_SHLIBS is not None: - for lib in python_SHLIBS.split(): - if lib.startswith('-l'): - env.append_value('LIB_PYEMBED', lib[2:]) # strip '-l' - else: - env.append_value('LINKFLAGS_PYEMBED', lib) - - if Options.platform != 'darwin' and python_LDFLAGS: - parse_flags(python_LDFLAGS, 'PYEMBED', env) - - result = False - if not python_LDVERSION: - python_LDVERSION = env['PYTHON_VERSION'] - name = 'python' + python_LDVERSION - - if python_LIBDIR is not None: - path = [python_LIBDIR] - conf.log.write("\n\n# Trying LIBDIR: %r\n" % path) - result = conf.check(lib=name, uselib='PYEMBED', libpath=path) - - if not result and python_LIBPL is not None: - conf.log.write("\n\n# try again with -L$python_LIBPL (some systems don't install the python library in $prefix/lib)\n") - path = [python_LIBPL] - result = conf.check(lib=name, uselib='PYEMBED', libpath=path) - - if not result: - conf.log.write("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n") - path = [os.path.join(python_prefix, "libs")] - name = 'python' + python_LDVERSION.replace('.', '') - result = conf.check(lib=name, uselib='PYEMBED', libpath=path) - - if result: - env['LIBPATH_PYEMBED'] = path - env.append_value('LIB_PYEMBED', name) - else: - conf.log.write("\n\n### LIB NOT FOUND\n") - - # under certain conditions, python extensions must link to - # python libraries, not just python embedding programs. - if (sys.platform == 'win32' or sys.platform.startswith('os2') - or sys.platform == 'darwin' or Py_ENABLE_SHARED): - env['LIBPATH_PYEXT'] = env['LIBPATH_PYEMBED'] - env['LIB_PYEXT'] = env['LIB_PYEMBED'] - - # We check that pythonX.Y-config exists, and if it exists we - # use it to get only the includes, else fall back to distutils. - python_config = conf.find_program( - 'python%s-config' % ('.'.join(env['PYTHON_VERSION'].split('.')[:2])), - var='PYTHON_CONFIG') - if not python_config: - python_config = conf.find_program( - 'python-config-%s' % ('.'.join(env['PYTHON_VERSION'].split('.')[:2])), - var='PYTHON_CONFIG') - - includes = [] - if python_config: - for incstr in Utils.cmd_output("%s --includes" % (python_config,)).strip().split(): - # strip the -I or /I - if (incstr.startswith('-I') - or incstr.startswith('/I')): - incstr = incstr[2:] - # append include path, unless already given - if incstr not in includes: - includes.append(incstr) - conf.log.write("Include path for Python extensions " - "(found via python-config --includes): %r\n" % (includes,)) - env['CPPPATH_PYEXT'] = includes - env['CPPPATH_PYEMBED'] = includes - else: - conf.log.write("Include path for Python extensions " - "(found via distutils module): %r\n" % (INCLUDEPY,)) - env['CPPPATH_PYEXT'] = [INCLUDEPY] - env['CPPPATH_PYEMBED'] = [INCLUDEPY] - - # Code using the Python API needs to be compiled with -fno-strict-aliasing - if env['CC_NAME'] == 'gcc': - env.append_value('CCFLAGS_PYEMBED', '-fno-strict-aliasing') - env.append_value('CCFLAGS_PYEXT', '-fno-strict-aliasing') - if env['CXX_NAME'] == 'gcc': - env.append_value('CXXFLAGS_PYEMBED', '-fno-strict-aliasing') - env.append_value('CXXFLAGS_PYEXT', '-fno-strict-aliasing') - - # See if it compiles - conf.check(define_name='HAVE_PYTHON_H', - uselib='PYEMBED', fragment=FRAG_2, - errmsg='Could not find the python development headers', mandatory=mandatory) - -@conf -def check_python_version(conf, minver=None): - """ - Check if the python interpreter is found matching a given minimum version. - minver should be a tuple, eg. to check for python >= 2.4.2 pass (2,4,2) as minver. - - If successful, PYTHON_VERSION is defined as 'MAJOR.MINOR' - (eg. '2.4') of the actual python version found, and PYTHONDIR is - defined, pointing to the site-packages directory appropriate for - this python version, where modules/packages/extensions should be - installed. - """ - assert minver is None or isinstance(minver, tuple) - python = conf.env['PYTHON'] - if not python: - conf.fatal('could not find the python executable') - - # Get python version string - cmd = [python, "-c", "import sys\nfor x in sys.version_info: print(str(x))"] - debug('python: Running python command %r' % cmd) - proc = Utils.pproc.Popen(cmd, stdout=Utils.pproc.PIPE, shell=False) - lines = proc.communicate()[0].split() - assert len(lines) == 5, "found %i lines, expected 5: %r" % (len(lines), lines) - pyver_tuple = (int(lines[0]), int(lines[1]), int(lines[2]), lines[3], int(lines[4])) - - # compare python version with the minimum required - result = (minver is None) or (pyver_tuple >= minver) - - if result: - # define useful environment variables - pyver = '.'.join([str(x) for x in pyver_tuple[:2]]) - conf.env['PYTHON_VERSION'] = pyver - - if 'PYTHONDIR' in conf.environ: - pydir = conf.environ['PYTHONDIR'] - else: - if sys.platform == 'win32': - (python_LIBDEST, pydir) = \ - _get_python_variables(python, - ["get_config_var('LIBDEST') or ''", - "get_python_lib(standard_lib=0, prefix=%r) or ''" % conf.env['PREFIX']], - ['from distutils.sysconfig import get_config_var, get_python_lib']) - else: - python_LIBDEST = None - (pydir,) = \ - _get_python_variables(python, - ["get_python_lib(standard_lib=0, prefix=%r) or ''" % conf.env['PREFIX']], - ['from distutils.sysconfig import get_config_var, get_python_lib']) - if python_LIBDEST is None: - if conf.env['LIBDIR']: - python_LIBDEST = os.path.join(conf.env['LIBDIR'], "python" + pyver) - else: - python_LIBDEST = os.path.join(conf.env['PREFIX'], "lib", "python" + pyver) - - if 'PYTHONARCHDIR' in conf.environ: - pyarchdir = conf.environ['PYTHONARCHDIR'] - else: - (pyarchdir,) = _get_python_variables(python, - ["get_python_lib(plat_specific=1, standard_lib=0, prefix=%r) or ''" % conf.env['PREFIX']], - ['from distutils.sysconfig import get_config_var, get_python_lib']) - if not pyarchdir: - pyarchdir = pydir - - if hasattr(conf, 'define'): # conf.define is added by the C tool, so may not exist - conf.define('PYTHONDIR', pydir) - conf.define('PYTHONARCHDIR', pyarchdir) - - conf.env['PYTHONDIR'] = pydir - - # Feedback - pyver_full = '.'.join(map(str, pyver_tuple[:3])) - if minver is None: - conf.check_message_custom('Python version', '', pyver_full) - else: - minver_str = '.'.join(map(str, minver)) - conf.check_message('Python version', ">= %s" % minver_str, result, option=pyver_full) - - if not result: - conf.fatal('The python version is too old (%r)' % pyver_full) - -@conf -def check_python_module(conf, module_name): - """ - Check if the selected python interpreter can import the given python module. - """ - result = not Utils.pproc.Popen([conf.env['PYTHON'], "-c", "import %s" % module_name], - stderr=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE).wait() - conf.check_message('Python module', module_name, result) - if not result: - conf.fatal('Could not find the python module %r' % module_name) - -def detect(conf): - - if not conf.env.PYTHON: - conf.env.PYTHON = sys.executable - - python = conf.find_program('python', var='PYTHON') - if not python: - conf.fatal('Could not find the path of the python executable') - - if conf.env.PYTHON != sys.executable: - warn("python executable '%s' different from sys.executable '%s'" % (conf.env.PYTHON, sys.executable)) - - v = conf.env - v['PYCMD'] = '"import sys, py_compile;py_compile.compile(sys.argv[1], sys.argv[2])"' - v['PYFLAGS'] = '' - v['PYFLAGS_OPT'] = '-O' - - v['PYC'] = getattr(Options.options, 'pyc', 1) - v['PYO'] = getattr(Options.options, 'pyo', 1) - -def set_options(opt): - opt.add_option('--nopyc', - action='store_false', - default=1, - help = 'Do not install bytecode compiled .pyc files (configuration) [Default:install]', - dest = 'pyc') - opt.add_option('--nopyo', - action='store_false', - default=1, - help='Do not install optimised compiled .pyo files (configuration) [Default:install]', - dest='pyo') diff --git a/third_party/waf/wafadmin/Tools/qt4.py b/third_party/waf/wafadmin/Tools/qt4.py deleted file mode 100644 index 7d2cad7d9c1..00000000000 --- a/third_party/waf/wafadmin/Tools/qt4.py +++ /dev/null @@ -1,504 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -""" -Qt4 support - -If QT4_ROOT is given (absolute path), the configuration will look in it first - -This module also demonstrates how to add tasks dynamically (when the build has started) -""" - -try: - from xml.sax import make_parser - from xml.sax.handler import ContentHandler -except ImportError: - has_xml = False - ContentHandler = object -else: - has_xml = True - -import os, sys -import ccroot, cxx -import TaskGen, Task, Utils, Runner, Options, Node, Configure -from TaskGen import taskgen, feature, after, extension -from Logs import error -from Constants import * - -MOC_H = ['.h', '.hpp', '.hxx', '.hh'] -EXT_RCC = ['.qrc'] -EXT_UI = ['.ui'] -EXT_QT4 = ['.cpp', '.cc', '.cxx', '.C'] - -class qxx_task(Task.Task): - "A cpp task that may create a moc task dynamically" - - before = ['cxx_link', 'static_link'] - - def __init__(self, *k, **kw): - Task.Task.__init__(self, *k, **kw) - self.moc_done = 0 - - def scan(self): - (nodes, names) = ccroot.scan(self) - # for some reasons (variants) the moc node may end in the list of node deps - for x in nodes: - if x.name.endswith('.moc'): - nodes.remove(x) - names.append(x.relpath_gen(self.inputs[0].parent)) - return (nodes, names) - - def runnable_status(self): - if self.moc_done: - # if there is a moc task, delay the computation of the file signature - for t in self.run_after: - if not t.hasrun: - return ASK_LATER - # the moc file enters in the dependency calculation - # so we need to recompute the signature when the moc file is present - self.signature() - return Task.Task.runnable_status(self) - else: - # yes, really, there are people who generate cxx files - for t in self.run_after: - if not t.hasrun: - return ASK_LATER - self.add_moc_tasks() - return ASK_LATER - - def add_moc_tasks(self): - - node = self.inputs[0] - tree = node.__class__.bld - - try: - # compute the signature once to know if there is a moc file to create - self.signature() - except KeyError: - # the moc file may be referenced somewhere else - pass - else: - # remove the signature, it must be recomputed with the moc task - delattr(self, 'cache_sig') - - moctasks=[] - mocfiles=[] - variant = node.variant(self.env) - try: - tmp_lst = tree.raw_deps[self.unique_id()] - tree.raw_deps[self.unique_id()] = [] - except KeyError: - tmp_lst = [] - for d in tmp_lst: - if not d.endswith('.moc'): continue - # paranoid check - if d in mocfiles: - error("paranoia owns") - continue - - # process that base.moc only once - mocfiles.append(d) - - # find the extension (performed only when the .cpp has changes) - base2 = d[:-4] - for path in [node.parent] + self.generator.env['INC_PATHS']: - tree.rescan(path) - vals = getattr(Options.options, 'qt_header_ext', '') or MOC_H - for ex in vals: - h_node = path.find_resource(base2 + ex) - if h_node: - break - else: - continue - break - else: - raise Utils.WafError("no header found for %s which is a moc file" % str(d)) - - m_node = h_node.change_ext('.moc') - tree.node_deps[(self.inputs[0].parent.id, self.env.variant(), m_node.name)] = h_node - - # create the task - task = Task.TaskBase.classes['moc'](self.env, normal=0) - task.set_inputs(h_node) - task.set_outputs(m_node) - - generator = tree.generator - generator.outstanding.insert(0, task) - generator.total += 1 - - moctasks.append(task) - - # remove raw deps except the moc files to save space (optimization) - tmp_lst = tree.raw_deps[self.unique_id()] = mocfiles - - # look at the file inputs, it is set right above - lst = tree.node_deps.get(self.unique_id(), ()) - for d in lst: - name = d.name - if name.endswith('.moc'): - task = Task.TaskBase.classes['moc'](self.env, normal=0) - task.set_inputs(tree.node_deps[(self.inputs[0].parent.id, self.env.variant(), name)]) # 1st element in a tuple - task.set_outputs(d) - - generator = tree.generator - generator.outstanding.insert(0, task) - generator.total += 1 - - moctasks.append(task) - - # simple scheduler dependency: run the moc task before others - self.run_after = moctasks - self.moc_done = 1 - - run = Task.TaskBase.classes['cxx'].__dict__['run'] - -def translation_update(task): - outs = [a.abspath(task.env) for a in task.outputs] - outs = " ".join(outs) - lupdate = task.env['QT_LUPDATE'] - - for x in task.inputs: - file = x.abspath(task.env) - cmd = "%s %s -ts %s" % (lupdate, file, outs) - Utils.pprint('BLUE', cmd) - task.generator.bld.exec_command(cmd) - -class XMLHandler(ContentHandler): - def __init__(self): - self.buf = [] - self.files = [] - def startElement(self, name, attrs): - if name == 'file': - self.buf = [] - def endElement(self, name): - if name == 'file': - self.files.append(''.join(self.buf)) - def characters(self, cars): - self.buf.append(cars) - -def scan(self): - "add the dependency on the files referenced in the qrc" - node = self.inputs[0] - parser = make_parser() - curHandler = XMLHandler() - parser.setContentHandler(curHandler) - fi = open(self.inputs[0].abspath(self.env)) - parser.parse(fi) - fi.close() - - nodes = [] - names = [] - root = self.inputs[0].parent - for x in curHandler.files: - nd = root.find_resource(x) - if nd: nodes.append(nd) - else: names.append(x) - - return (nodes, names) - -@extension(EXT_RCC) -def create_rcc_task(self, node): - "hook for rcc files" - rcnode = node.change_ext('_rc.cpp') - rcctask = self.create_task('rcc', node, rcnode) - cpptask = self.create_task('cxx', rcnode, rcnode.change_ext('.o')) - self.compiled_tasks.append(cpptask) - return cpptask - -@extension(EXT_UI) -def create_uic_task(self, node): - "hook for uic tasks" - uictask = self.create_task('ui4', node) - uictask.outputs = [self.path.find_or_declare(self.env['ui_PATTERN'] % node.name[:-3])] - return uictask - -class qt4_taskgen(cxx.cxx_taskgen): - def __init__(self, *k, **kw): - cxx.cxx_taskgen.__init__(self, *k, **kw) - self.features.append('qt4') - -@extension('.ts') -def add_lang(self, node): - """add all the .ts file into self.lang""" - self.lang = self.to_list(getattr(self, 'lang', [])) + [node] - -@feature('qt4') -@after('apply_link') -def apply_qt4(self): - if getattr(self, 'lang', None): - update = getattr(self, 'update', None) - lst=[] - trans=[] - for l in self.to_list(self.lang): - - if not isinstance(l, Node.Node): - l = self.path.find_resource(l+'.ts') - - t = self.create_task('ts2qm', l, l.change_ext('.qm')) - lst.append(t.outputs[0]) - - if update: - trans.append(t.inputs[0]) - - trans_qt4 = getattr(Options.options, 'trans_qt4', False) - if update and trans_qt4: - # we need the cpp files given, except the rcc task we create after - # FIXME may be broken - u = Task.TaskCmd(translation_update, self.env, 2) - u.inputs = [a.inputs[0] for a in self.compiled_tasks] - u.outputs = trans - - if getattr(self, 'langname', None): - t = Task.TaskBase.classes['qm2rcc'](self.env) - t.set_inputs(lst) - t.set_outputs(self.path.find_or_declare(self.langname+'.qrc')) - t.path = self.path - k = create_rcc_task(self, t.outputs[0]) - self.link_task.inputs.append(k.outputs[0]) - - self.env.append_value('MOC_FLAGS', self.env._CXXDEFFLAGS) - self.env.append_value('MOC_FLAGS', self.env._CXXINCFLAGS) - -@extension(EXT_QT4) -def cxx_hook(self, node): - # create the compilation task: cpp or cc - try: obj_ext = self.obj_ext - except AttributeError: obj_ext = '_%d.o' % self.idx - - task = self.create_task('qxx', node, node.change_ext(obj_ext)) - self.compiled_tasks.append(task) - return task - -def process_qm2rcc(task): - outfile = task.outputs[0].abspath(task.env) - f = open(outfile, 'w') - f.write('<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n') - for k in task.inputs: - f.write(' <file>') - #f.write(k.name) - f.write(k.path_to_parent(task.path)) - f.write('</file>\n') - f.write('</qresource>\n</RCC>') - f.close() - -b = Task.simple_task_type -b('moc', '${QT_MOC} ${MOC_FLAGS} ${SRC} ${MOC_ST} ${TGT}', color='BLUE', vars=['QT_MOC', 'MOC_FLAGS'], shell=False) -cls = b('rcc', '${QT_RCC} -name ${SRC[0].name} ${SRC[0].abspath(env)} ${RCC_ST} -o ${TGT}', color='BLUE', before='cxx moc qxx_task', after="qm2rcc", shell=False) -cls.scan = scan -b('ui4', '${QT_UIC} ${SRC} -o ${TGT}', color='BLUE', before='cxx moc qxx_task', shell=False) -b('ts2qm', '${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}', color='BLUE', before='qm2rcc', shell=False) - -Task.task_type_from_func('qm2rcc', vars=[], func=process_qm2rcc, color='BLUE', before='rcc', after='ts2qm') - -def detect_qt4(conf): - env = conf.env - opt = Options.options - - qtdir = getattr(opt, 'qtdir', '') - qtbin = getattr(opt, 'qtbin', '') - qtlibs = getattr(opt, 'qtlibs', '') - useframework = getattr(opt, 'use_qt4_osxframework', True) - - paths = [] - - # the path to qmake has been given explicitely - if qtbin: - paths = [qtbin] - - # the qt directory has been given - we deduce the qt binary path - if not qtdir: - qtdir = conf.environ.get('QT4_ROOT', '') - qtbin = os.path.join(qtdir, 'bin') - 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 = os.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']: - qmake = conf.find_program(qmk, path_list=paths) - if qmake: - try: - version = Utils.cmd_output([qmake, '-query', 'QT_VERSION']).strip() - except ValueError: - pass - else: - if version: - new_ver = version.split('.') - if new_ver > prev_ver: - cand = qmake - prev_ver = new_ver - if cand: - qmake = cand - else: - conf.fatal('could not find qmake for qt4') - - conf.env.QMAKE = qmake - qtincludes = Utils.cmd_output([qmake, '-query', 'QT_INSTALL_HEADERS']).strip() - qtdir = Utils.cmd_output([qmake, '-query', 'QT_INSTALL_PREFIX']).strip() + os.sep - qtbin = Utils.cmd_output([qmake, '-query', 'QT_INSTALL_BINS']).strip() + os.sep - - if not qtlibs: - try: - qtlibs = Utils.cmd_output([qmake, '-query', 'QT_INSTALL_LIBS']).strip() + os.sep - except ValueError: - qtlibs = os.path.join(qtdir, 'lib') - - def find_bin(lst, var): - for f in lst: - ret = conf.find_program(f, path_list=paths) - if ret: - env[var]=ret - break - - vars = "QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtWebKit Qt3Support".split() - - find_bin(['uic-qt3', 'uic3'], 'QT_UIC3') - find_bin(['uic-qt4', 'uic'], 'QT_UIC') - if not env['QT_UIC']: - conf.fatal('cannot find the uic compiler for qt4') - - try: - version = Utils.cmd_output(env['QT_UIC'] + " -version 2>&1").strip() - except ValueError: - conf.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: - conf.check_message('uic version', '(too old)', 0, option='(%s)'%version) - sys.exit(1) - conf.check_message('uic version', '', 1, option='(%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_debug = [a+'_debug' for a in vars] - - try: - conf.find_program('pkg-config', var='pkgconfig', path_list=paths, mandatory=True) - - except Configure.ConfigurationError: - - for lib in vars_debug+vars: - uselib = lib.upper() - - d = (lib.find('_debug') > 0) and 'd' or '' - - # original author seems to prefer static to shared libraries - for (pat, kind) in ((conf.env.staticlib_PATTERN, 'STATIC'), (conf.env.shlib_PATTERN, '')): - - conf.check_message_1('Checking for %s %s' % (lib, kind)) - - for ext in ['', '4']: - path = os.path.join(qtlibs, pat % (lib + d + ext)) - if os.path.exists(path): - env.append_unique(kind + 'LIB_' + uselib, lib + d + ext) - conf.check_message_2('ok ' + path, 'GREEN') - break - path = os.path.join(qtbin, pat % (lib + d + ext)) - if os.path.exists(path): - env.append_unique(kind + 'LIB_' + uselib, lib + d + ext) - conf.check_message_2('ok ' + path, 'GREEN') - break - else: - conf.check_message_2('not found', 'YELLOW') - continue - break - - env.append_unique('LIBPATH_' + uselib, qtlibs) - env.append_unique('CPPPATH_' + uselib, qtincludes) - env.append_unique('CPPPATH_' + uselib, qtincludes + os.sep + lib) - else: - for i in vars_debug+vars: - try: - conf.check_cfg(package=i, args='--cflags --libs --silence-errors', path=conf.env.pkgconfig) - except ValueError: - pass - - # the libpaths are set nicely, unfortunately they make really long command-lines - # remove the qtcore ones from qtgui, etc - 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') - - # rpath if wanted - want_rpath = getattr(Options.options, 'want_rpath', 1) - if 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') - - env['QTLOCALE'] = str(env['PREFIX'])+'/share/locale' - -def detect(conf): - detect_qt4(conf) - -def set_options(opt): - opt.add_option('--want-rpath', type='int', default=1, dest='want_rpath', help='set rpath to 1 or 0 [Default 1]') - - opt.add_option('--header-ext', - type='string', - default='', - help='header extension for moc files', - dest='qt_header_ext') - - for i in 'qtdir qtbin qtlibs'.split(): - opt.add_option('--'+i, type='string', default='', dest=i) - - if sys.platform == "darwin": - opt.add_option('--no-qt4-framework', action="store_false", help='do not use the framework version of Qt4 in OS X', dest='use_qt4_osxframework',default=True) - - opt.add_option('--translate', action="store_true", help="collect translation strings", dest="trans_qt4", default=False) diff --git a/third_party/waf/wafadmin/Tools/ruby.py b/third_party/waf/wafadmin/Tools/ruby.py deleted file mode 100644 index afa8a596b0d..00000000000 --- a/third_party/waf/wafadmin/Tools/ruby.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# daniel.svensson at purplescout.se 2008 - -import os -import Task, Options, Utils -from TaskGen import before, feature, after -from Configure import conf - -@feature('rubyext') -@before('apply_incpaths', 'apply_type_vars', 'apply_lib_vars', 'apply_bundle') -@after('default_cc', 'vars_target_cshlib') -def init_rubyext(self): - self.default_install_path = '${ARCHDIR_RUBY}' - self.uselib = self.to_list(getattr(self, 'uselib', '')) - if not 'RUBY' in self.uselib: - self.uselib.append('RUBY') - if not 'RUBYEXT' in self.uselib: - self.uselib.append('RUBYEXT') - -@feature('rubyext') -@before('apply_link') -def apply_ruby_so_name(self): - self.env['shlib_PATTERN'] = self.env['rubyext_PATTERN'] - -@conf -def check_ruby_version(conf, minver=()): - """ - Checks if ruby is installed. - If installed the variable RUBY will be set in environment. - Ruby binary can be overridden by --with-ruby-binary config variable - """ - - if Options.options.rubybinary: - conf.env.RUBY = Options.options.rubybinary - else: - conf.find_program("ruby", var="RUBY", mandatory=True) - - ruby = conf.env.RUBY - - try: - version = Utils.cmd_output([ruby, '-e', 'puts defined?(VERSION) ? VERSION : RUBY_VERSION']).strip() - except: - conf.fatal('could not determine ruby version') - conf.env.RUBY_VERSION = version - - try: - ver = tuple(map(int, version.split("."))) - except: - conf.fatal('unsupported ruby version %r' % version) - - cver = '' - if minver: - if ver < minver: - conf.fatal('ruby is too old') - cver = ".".join([str(x) for x in minver]) - - conf.check_message('ruby', cver, True, version) - -@conf -def check_ruby_ext_devel(conf): - if not conf.env.RUBY: - conf.fatal('ruby detection is required first') - - if not conf.env.CC_NAME and not conf.env.CXX_NAME: - conf.fatal('load a c/c++ compiler first') - - version = tuple(map(int, conf.env.RUBY_VERSION.split("."))) - - def read_out(cmd): - return Utils.to_list(Utils.cmd_output([conf.env.RUBY, '-rrbconfig', '-e', cmd])) - - def read_config(key): - return read_out('puts Config::CONFIG[%r]' % key) - - ruby = conf.env['RUBY'] - archdir = read_config('archdir') - cpppath = archdir - if version >= (1, 9, 0): - ruby_hdrdir = read_config('rubyhdrdir') - cpppath += ruby_hdrdir - cpppath += [os.path.join(ruby_hdrdir[0], read_config('arch')[0])] - - conf.check(header_name='ruby.h', includes=cpppath, mandatory=True, errmsg='could not find ruby header file') - - conf.env.LIBPATH_RUBYEXT = read_config('libdir') - conf.env.LIBPATH_RUBYEXT += archdir - conf.env.CPPPATH_RUBYEXT = cpppath - conf.env.CCFLAGS_RUBYEXT = read_config("CCDLFLAGS") - conf.env.rubyext_PATTERN = '%s.' + read_config('DLEXT')[0] - - # ok this is really stupid, but the command and flags are combined. - # so we try to find the first argument... - flags = read_config('LDSHARED') - while flags and flags[0][0] != '-': - flags = flags[1:] - - # we also want to strip out the deprecated ppc flags - if len(flags) > 1 and flags[1] == "ppc": - flags = flags[2:] - - conf.env.LINKFLAGS_RUBYEXT = flags - conf.env.LINKFLAGS_RUBYEXT += read_config("LIBS") - conf.env.LINKFLAGS_RUBYEXT += read_config("LIBRUBYARG_SHARED") - - if Options.options.rubyarchdir: - conf.env.ARCHDIR_RUBY = Options.options.rubyarchdir - else: - conf.env.ARCHDIR_RUBY = read_config('sitearchdir')[0] - - if Options.options.rubylibdir: - conf.env.LIBDIR_RUBY = Options.options.rubylibdir - else: - conf.env.LIBDIR_RUBY = read_config('sitelibdir')[0] - -def set_options(opt): - opt.add_option('--with-ruby-archdir', type='string', dest='rubyarchdir', help='Specify directory where to install arch specific files') - opt.add_option('--with-ruby-libdir', type='string', dest='rubylibdir', help='Specify alternate ruby library path') - opt.add_option('--with-ruby-binary', type='string', dest='rubybinary', help='Specify alternate ruby binary') diff --git a/third_party/waf/wafadmin/Tools/suncc.py b/third_party/waf/wafadmin/Tools/suncc.py deleted file mode 100644 index b1a2aad4037..00000000000 --- a/third_party/waf/wafadmin/Tools/suncc.py +++ /dev/null @@ -1,76 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) -# Ralf Habacker, 2006 (rh) - -import os, optparse -import Utils, Options, Configure -import ccroot, ar -from Configure import conftest - -@conftest -def find_scc(conf): - v = conf.env - cc = None - if v['CC']: cc = v['CC'] - elif 'CC' in conf.environ: cc = conf.environ['CC'] - #if not cc: cc = conf.find_program('gcc', var='CC') - if not cc: cc = conf.find_program('cc', var='CC') - if not cc: conf.fatal('suncc was not found') - cc = conf.cmd_to_list(cc) - - try: - if not Utils.cmd_output(cc + ['-flags']): - conf.fatal('suncc %r was not found' % cc) - except ValueError: - conf.fatal('suncc -flags could not be executed') - - v['CC'] = cc - v['CC_NAME'] = 'sun' - -@conftest -def scc_common_flags(conf): - v = conf.env - - # CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS - - v['CC_SRC_F'] = '' - v['CC_TGT_F'] = ['-c', '-o', ''] - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CC']: v['LINK_CC'] = v['CC'] - v['CCLNK_SRC_F'] = '' - v['CCLNK_TGT_F'] = ['-o', ''] # solaris hack, separate the -o from the target - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['CCDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '-Wl,-h -Wl,%s' - v['SHLIB_MARKER'] = '-Bdynamic' - v['STATICLIB_MARKER'] = '-Bstatic' - - # program - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CCFLAGS'] = ['-Kpic', '-DPIC'] - v['shlib_LINKFLAGS'] = ['-G'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = ['-Bstatic'] - v['staticlib_PATTERN'] = 'lib%s.a' - -detect = ''' -find_scc -find_cpp -find_ar -scc_common_flags -cc_load_tools -cc_add_flags -link_add_flags -''' diff --git a/third_party/waf/wafadmin/Tools/suncxx.py b/third_party/waf/wafadmin/Tools/suncxx.py deleted file mode 100644 index 8754b6cc2bf..00000000000 --- a/third_party/waf/wafadmin/Tools/suncxx.py +++ /dev/null @@ -1,75 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) -# Ralf Habacker, 2006 (rh) - -import os, optparse -import Utils, Options, Configure -import ccroot, ar -from Configure import conftest - -@conftest -def find_sxx(conf): - v = conf.env - cc = None - if v['CXX']: cc = v['CXX'] - elif 'CXX' in conf.environ: cc = conf.environ['CXX'] - if not cc: cc = conf.find_program('c++', var='CXX') - if not cc: conf.fatal('sunc++ was not found') - cc = conf.cmd_to_list(cc) - - try: - if not Utils.cmd_output(cc + ['-flags']): - conf.fatal('sunc++ %r was not found' % cc) - except ValueError: - conf.fatal('sunc++ -flags could not be executed') - - v['CXX'] = cc - v['CXX_NAME'] = 'sun' - -@conftest -def sxx_common_flags(conf): - v = conf.env - - # CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS - - v['CXX_SRC_F'] = '' - v['CXX_TGT_F'] = ['-c', '-o', ''] - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] - v['CXXLNK_SRC_F'] = '' - v['CXXLNK_TGT_F'] = ['-o', ''] # solaris hack, separate the -o from the target - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['CXXDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '-Wl,-h -Wl,%s' - v['SHLIB_MARKER'] = '-Bdynamic' - v['STATICLIB_MARKER'] = '-Bstatic' - - # program - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CXXFLAGS'] = ['-Kpic', '-DPIC'] - v['shlib_LINKFLAGS'] = ['-G'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = ['-Bstatic'] - v['staticlib_PATTERN'] = 'lib%s.a' - -detect = ''' -find_sxx -find_cpp -find_ar -sxx_common_flags -cxx_load_tools -cxx_add_flags -link_add_flags -''' diff --git a/third_party/waf/wafadmin/Tools/tex.py b/third_party/waf/wafadmin/Tools/tex.py deleted file mode 100644 index 43aee1f4271..00000000000 --- a/third_party/waf/wafadmin/Tools/tex.py +++ /dev/null @@ -1,250 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) - -"TeX/LaTeX/PDFLaTeX support" - -import os, re -import Utils, TaskGen, Task, Runner, Build -from TaskGen import feature, before -from Logs import error, warn, debug - -re_tex = re.compile(r'\\(?P<type>include|input|import|bringin|lstinputlisting){(?P<file>[^{}]*)}', re.M) -def scan(self): - node = self.inputs[0] - env = self.env - - nodes = [] - names = [] - if not node: return (nodes, names) - - code = Utils.readf(node.abspath(env)) - - curdirnode = self.curdirnode - abs = curdirnode.abspath() - for match in re_tex.finditer(code): - path = match.group('file') - if path: - for k in ['', '.tex', '.ltx']: - # add another loop for the tex include paths? - debug('tex: trying %s%s' % (path, k)) - try: - os.stat(abs+os.sep+path+k) - except OSError: - continue - found = path+k - node = curdirnode.find_resource(found) - if node: - nodes.append(node) - else: - debug('tex: could not find %s' % path) - names.append(path) - - debug("tex: found the following : %s and names %s" % (nodes, names)) - return (nodes, names) - -latex_fun, _ = Task.compile_fun('latex', '${LATEX} ${LATEXFLAGS} ${SRCFILE}', shell=False) -pdflatex_fun, _ = Task.compile_fun('pdflatex', '${PDFLATEX} ${PDFLATEXFLAGS} ${SRCFILE}', shell=False) -bibtex_fun, _ = Task.compile_fun('bibtex', '${BIBTEX} ${BIBTEXFLAGS} ${SRCFILE}', shell=False) -makeindex_fun, _ = Task.compile_fun('bibtex', '${MAKEINDEX} ${MAKEINDEXFLAGS} ${SRCFILE}', shell=False) - -g_bibtex_re = re.compile('bibdata', re.M) -def tex_build(task, command='LATEX'): - env = task.env - bld = task.generator.bld - - if not env['PROMPT_LATEX']: - env.append_value('LATEXFLAGS', '-interaction=batchmode') - env.append_value('PDFLATEXFLAGS', '-interaction=batchmode') - - fun = latex_fun - if command == 'PDFLATEX': - fun = pdflatex_fun - - node = task.inputs[0] - reldir = node.bld_dir(env) - - #lst = [] - #for c in Utils.split_path(reldir): - # if c: lst.append('..') - #srcfile = os.path.join(*(lst + [node.srcpath(env)])) - #sr2 = os.path.join(*(lst + [node.parent.srcpath(env)])) - srcfile = node.abspath(env) - sr2 = node.parent.abspath() + os.pathsep + node.parent.abspath(env) + os.pathsep - - aux_node = node.change_ext('.aux') - idx_node = node.change_ext('.idx') - - nm = aux_node.name - docuname = nm[ : len(nm) - 4 ] # 4 is the size of ".aux" - - # important, set the cwd for everybody - task.cwd = task.inputs[0].parent.abspath(task.env) - - - warn('first pass on %s' % command) - - task.env.env = {'TEXINPUTS': sr2} - task.env.SRCFILE = srcfile - ret = fun(task) - if ret: - return ret - - # look in the .aux file if there is a bibfile to process - try: - ct = Utils.readf(aux_node.abspath(env)) - except (OSError, IOError): - error('error bibtex scan') - else: - fo = g_bibtex_re.findall(ct) - - # there is a .aux file to process - if fo: - warn('calling bibtex') - - task.env.env = {'BIBINPUTS': sr2, 'BSTINPUTS': sr2} - task.env.SRCFILE = docuname - ret = bibtex_fun(task) - if ret: - error('error when calling bibtex %s' % docuname) - return ret - - # look on the filesystem if there is a .idx file to process - try: - idx_path = idx_node.abspath(env) - os.stat(idx_path) - except OSError: - error('error file.idx scan') - else: - warn('calling makeindex') - - task.env.SRCFILE = idx_node.name - task.env.env = {} - ret = makeindex_fun(task) - if ret: - error('error when calling makeindex %s' % idx_path) - return ret - - - hash = '' - i = 0 - while i < 10: - # prevent against infinite loops - one never knows - i += 1 - - # watch the contents of file.aux - prev_hash = hash - try: - hash = Utils.h_file(aux_node.abspath(env)) - except KeyError: - error('could not read aux.h -> %s' % aux_node.abspath(env)) - pass - - # debug - #print "hash is, ", hash, " ", old_hash - - # stop if file.aux does not change anymore - if hash and hash == prev_hash: - break - - # run the command - warn('calling %s' % command) - - task.env.env = {'TEXINPUTS': sr2 + os.pathsep} - task.env.SRCFILE = srcfile - ret = fun(task) - if ret: - error('error when calling %s %s' % (command, latex_fun)) - return ret - - return None # ok - -latex_vardeps = ['LATEX', 'LATEXFLAGS'] -def latex_build(task): - return tex_build(task, 'LATEX') - -pdflatex_vardeps = ['PDFLATEX', 'PDFLATEXFLAGS'] -def pdflatex_build(task): - return tex_build(task, 'PDFLATEX') - -class tex_taskgen(TaskGen.task_gen): - def __init__(self, *k, **kw): - TaskGen.task_gen.__init__(self, *k, **kw) - -@feature('tex') -@before('apply_core') -def apply_tex(self): - if not getattr(self, 'type', None) in ['latex', 'pdflatex']: - self.type = 'pdflatex' - - tree = self.bld - outs = Utils.to_list(getattr(self, 'outs', [])) - - # prompt for incomplete files (else the batchmode is used) - self.env['PROMPT_LATEX'] = getattr(self, 'prompt', 1) - - deps_lst = [] - - if getattr(self, 'deps', None): - deps = self.to_list(self.deps) - for filename in deps: - n = self.path.find_resource(filename) - if not n in deps_lst: deps_lst.append(n) - - self.source = self.to_list(self.source) - for filename in self.source: - base, ext = os.path.splitext(filename) - - node = self.path.find_resource(filename) - if not node: raise Utils.WafError('cannot find %s' % filename) - - if self.type == 'latex': - task = self.create_task('latex', node, node.change_ext('.dvi')) - elif self.type == 'pdflatex': - task = self.create_task('pdflatex', node, node.change_ext('.pdf')) - - task.env = self.env - task.curdirnode = self.path - - # add the manual dependencies - if deps_lst: - variant = node.variant(self.env) - try: - lst = tree.node_deps[task.unique_id()] - for n in deps_lst: - if not n in lst: - lst.append(n) - except KeyError: - tree.node_deps[task.unique_id()] = deps_lst - - if self.type == 'latex': - if 'ps' in outs: - tsk = self.create_task('dvips', task.outputs, node.change_ext('.ps')) - tsk.env.env = {'TEXINPUTS' : node.parent.abspath() + os.pathsep + self.path.abspath() + os.pathsep + self.path.abspath(self.env)} - if 'pdf' in outs: - tsk = self.create_task('dvipdf', task.outputs, node.change_ext('.pdf')) - tsk.env.env = {'TEXINPUTS' : node.parent.abspath() + os.pathsep + self.path.abspath() + os.pathsep + self.path.abspath(self.env)} - elif self.type == 'pdflatex': - if 'ps' in outs: - self.create_task('pdf2ps', task.outputs, node.change_ext('.ps')) - self.source = [] - -def detect(conf): - v = conf.env - for p in 'tex latex pdflatex bibtex dvips dvipdf ps2pdf makeindex pdf2ps'.split(): - conf.find_program(p, var=p.upper()) - v[p.upper()+'FLAGS'] = '' - v['DVIPSFLAGS'] = '-Ppdf' - -b = Task.simple_task_type -b('tex', '${TEX} ${TEXFLAGS} ${SRC}', color='BLUE', shell=False) # not used anywhere -b('bibtex', '${BIBTEX} ${BIBTEXFLAGS} ${SRC}', color='BLUE', shell=False) # not used anywhere -b('dvips', '${DVIPS} ${DVIPSFLAGS} ${SRC} -o ${TGT}', color='BLUE', after="latex pdflatex tex bibtex", shell=False) -b('dvipdf', '${DVIPDF} ${DVIPDFFLAGS} ${SRC} ${TGT}', color='BLUE', after="latex pdflatex tex bibtex", shell=False) -b('pdf2ps', '${PDF2PS} ${PDF2PSFLAGS} ${SRC} ${TGT}', color='BLUE', after="dvipdf pdflatex", shell=False) - -b = Task.task_type_from_func -cls = b('latex', latex_build, vars=latex_vardeps) -cls.scan = scan -cls = b('pdflatex', pdflatex_build, vars=pdflatex_vardeps) -cls.scan = scan diff --git a/third_party/waf/wafadmin/Tools/unittestw.py b/third_party/waf/wafadmin/Tools/unittestw.py deleted file mode 100644 index 7cf2ded9918..00000000000 --- a/third_party/waf/wafadmin/Tools/unittestw.py +++ /dev/null @@ -1,308 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Carlos Rafael Giani, 2006 - -""" -Unit tests run in the shutdown() method, and for c/c++ programs - -One should NOT have to give parameters to programs to execute - -In the shutdown method, add the following code: - - >>> def shutdown(): - ... ut = UnitTest.unit_test() - ... ut.run() - ... ut.print_results() - - -Each object to use as a unit test must be a program and must have X{obj.unit_test=1} -""" -import os, sys -import Build, TaskGen, Utils, Options, Logs, Task -from TaskGen import before, after, feature -from Constants import * - -class unit_test(object): - "Unit test representation" - def __init__(self): - self.returncode_ok = 0 # Unit test returncode considered OK. All returncodes differing from this one - # will cause the unit test to be marked as "FAILED". - - # The following variables are filled with data by run(). - - # print_results() uses these for printing the unit test summary, - # but if there is need for direct access to the results, - # they can be retrieved here, after calling run(). - - self.num_tests_ok = 0 # Number of successful unit tests - self.num_tests_failed = 0 # Number of failed unit tests - self.num_tests_err = 0 # Tests that have not even run - self.total_num_tests = 0 # Total amount of unit tests - self.max_label_length = 0 # Maximum label length (pretty-print the output) - - self.unit_tests = Utils.ordered_dict() # Unit test dictionary. Key: the label (unit test filename relative - # to the build dir), value: unit test filename with absolute path - self.unit_test_results = {} # Dictionary containing the unit test results. - # Key: the label, value: result (true = success false = failure) - self.unit_test_erroneous = {} # Dictionary indicating erroneous unit tests. - # Key: the label, value: true = unit test has an error false = unit test is ok - self.change_to_testfile_dir = False #True if the test file needs to be executed from the same dir - self.want_to_see_test_output = False #True to see the stdout from the testfile (for example check suites) - self.want_to_see_test_error = False #True to see the stderr from the testfile (for example check suites) - self.run_if_waf_does = 'check' #build was the old default - - def run(self): - "Run the unit tests and gather results (note: no output here)" - - self.num_tests_ok = 0 - self.num_tests_failed = 0 - self.num_tests_err = 0 - self.total_num_tests = 0 - self.max_label_length = 0 - - self.unit_tests = Utils.ordered_dict() - self.unit_test_results = {} - self.unit_test_erroneous = {} - - ld_library_path = [] - - # If waf is not building, don't run anything - if not Options.commands[self.run_if_waf_does]: return - - # Get the paths for the shared libraries, and obtain the unit tests to execute - for obj in Build.bld.all_task_gen: - try: - link_task = obj.link_task - except AttributeError: - pass - else: - lib_path = link_task.outputs[0].parent.abspath(obj.env) - if lib_path not in ld_library_path: - ld_library_path.append(lib_path) - - unit_test = getattr(obj, 'unit_test', '') - if unit_test and 'cprogram' in obj.features: - try: - output = obj.path - filename = os.path.join(output.abspath(obj.env), obj.target) - srcdir = output.abspath() - label = os.path.join(output.bldpath(obj.env), obj.target) - self.max_label_length = max(self.max_label_length, len(label)) - self.unit_tests[label] = (filename, srcdir) - except KeyError: - pass - self.total_num_tests = len(self.unit_tests) - # Now run the unit tests - Utils.pprint('GREEN', 'Running the unit tests') - count = 0 - result = 1 - - for label in self.unit_tests.allkeys: - file_and_src = self.unit_tests[label] - filename = file_and_src[0] - srcdir = file_and_src[1] - count += 1 - line = Build.bld.progress_line(count, self.total_num_tests, Logs.colors.GREEN, Logs.colors.NORMAL) - if Options.options.progress_bar and line: - sys.stderr.write(line) - sys.stderr.flush() - try: - kwargs = {} - kwargs['env'] = os.environ.copy() - if self.change_to_testfile_dir: - kwargs['cwd'] = srcdir - if not self.want_to_see_test_output: - kwargs['stdout'] = Utils.pproc.PIPE # PIPE for ignoring output - if not self.want_to_see_test_error: - kwargs['stderr'] = Utils.pproc.PIPE # PIPE for ignoring output - if ld_library_path: - v = kwargs['env'] - def add_path(dct, path, var): - dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, '')]) - if sys.platform == 'win32': - add_path(v, ld_library_path, 'PATH') - elif sys.platform == 'darwin': - add_path(v, ld_library_path, 'DYLD_LIBRARY_PATH') - add_path(v, ld_library_path, 'LD_LIBRARY_PATH') - else: - add_path(v, ld_library_path, 'LD_LIBRARY_PATH') - - pp = Utils.pproc.Popen(filename, **kwargs) - (out, err) = pp.communicate() # uh, and the output is ignored?? - fortunately this is going to disappear - - result = int(pp.returncode == self.returncode_ok) - - if result: - self.num_tests_ok += 1 - else: - self.num_tests_failed += 1 - - self.unit_test_results[label] = result - self.unit_test_erroneous[label] = 0 - except OSError: - self.unit_test_erroneous[label] = 1 - self.num_tests_err += 1 - except KeyboardInterrupt: - pass - if Options.options.progress_bar: sys.stdout.write(Logs.colors.cursor_on) - - def print_results(self): - "Pretty-prints a summary of all unit tests, along with some statistics" - - # If waf is not building, don't output anything - if not Options.commands[self.run_if_waf_does]: return - - p = Utils.pprint - # Early quit if no tests were performed - if self.total_num_tests == 0: - p('YELLOW', 'No unit tests present') - return - - for label in self.unit_tests.allkeys: - filename = self.unit_tests[label] - err = 0 - result = 0 - - try: err = self.unit_test_erroneous[label] - except KeyError: pass - - try: result = self.unit_test_results[label] - except KeyError: pass - - n = self.max_label_length - len(label) - if err: n += 4 - elif result: n += 7 - else: n += 3 - - line = '%s %s' % (label, '.' * n) - - if err: p('RED', '%sERROR' % line) - elif result: p('GREEN', '%sOK' % line) - else: p('YELLOW', '%sFAILED' % line) - - percentage_ok = float(self.num_tests_ok) / float(self.total_num_tests) * 100.0 - percentage_failed = float(self.num_tests_failed) / float(self.total_num_tests) * 100.0 - percentage_erroneous = float(self.num_tests_err) / float(self.total_num_tests) * 100.0 - - p('NORMAL', ''' -Successful tests: %i (%.1f%%) -Failed tests: %i (%.1f%%) -Erroneous tests: %i (%.1f%%) - -Total number of tests: %i -''' % (self.num_tests_ok, percentage_ok, self.num_tests_failed, percentage_failed, - self.num_tests_err, percentage_erroneous, self.total_num_tests)) - p('GREEN', 'Unit tests finished') - - -############################################################################################ - -""" -New unit test system - -The targets with feature 'test' are executed after they are built -bld(features='cprogram cc test', ...) - -To display the results: -import UnitTest -bld.add_post_fun(UnitTest.summary) -""" - -import threading -testlock = threading.Lock() - -def set_options(opt): - opt.add_option('--alltests', action='store_true', default=True, help='Exec all unit tests', dest='all_tests') - -@feature('test') -@after('apply_link', 'vars_target_cprogram') -def make_test(self): - if not 'cprogram' in self.features: - Logs.error('test cannot be executed %s' % self) - return - - self.default_install_path = None - self.create_task('utest', self.link_task.outputs) - -def exec_test(self): - - status = 0 - - variant = self.env.variant() - - filename = self.inputs[0].abspath(self.env) - self.ut_exec = getattr(self, 'ut_exec', [filename]) - 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 = [] - for obj in self.generator.bld.all_task_gen: - link_task = getattr(obj, 'link_task', None) - if link_task and link_task.env.variant() == variant: - lst.append(link_task.outputs[0].parent.abspath(obj.env)) - - def add_path(dct, path, var): - dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, '')]) - - if sys.platform == 'win32': - add_path(fu, lst, 'PATH') - elif 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') - - - cwd = getattr(self.generator, 'ut_cwd', '') or self.inputs[0].parent.abspath(self.env) - proc = Utils.pproc.Popen(self.ut_exec, cwd=cwd, env=fu, stderr=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE) - (stdout, stderr) = proc.communicate() - - tup = (filename, proc.returncode, stdout, stderr) - 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() - -cls = Task.task_type_from_func('utest', func=exec_test, color='PINK', ext_in='.bin') - -old = cls.runnable_status -def test_status(self): - ret = old(self) - if ret == SKIP_ME and getattr(Options.options, 'all_tests', False): - return RUN_ME - return ret - -cls.runnable_status = test_status -cls.quiet = 1 - -def summary(bld): - lst = getattr(bld, 'utest_results', []) - if lst: - Utils.pprint('CYAN', 'execution summary') - - total = len(lst) - tfail = len([x for x in lst if x[1]]) - - Utils.pprint('CYAN', ' tests that pass %d/%d' % (total-tfail, total)) - for (f, code, out, err) in lst: - if not code: - Utils.pprint('CYAN', ' %s' % f) - - Utils.pprint('CYAN', ' tests that fail %d/%d' % (tfail, total)) - for (f, code, out, err) in lst: - if code: - Utils.pprint('CYAN', ' %s' % f) diff --git a/third_party/waf/wafadmin/Tools/vala.py b/third_party/waf/wafadmin/Tools/vala.py deleted file mode 100644 index df1d11bb839..00000000000 --- a/third_party/waf/wafadmin/Tools/vala.py +++ /dev/null @@ -1,307 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Ali Sabil, 2007 - -import os.path, shutil -import Task, Runner, Utils, Logs, Build, Node, Options -from TaskGen import extension, after, before - -EXT_VALA = ['.vala', '.gs'] - -class valac_task(Task.Task): - - vars = ("VALAC", "VALAC_VERSION", "VALAFLAGS") - before = ("cc", "cxx") - - def run(self): - env = self.env - inputs = [a.srcpath(env) for a in self.inputs] - valac = env['VALAC'] - vala_flags = env.get_flat('VALAFLAGS') - top_src = self.generator.bld.srcnode.abspath() - top_bld = self.generator.bld.srcnode.abspath(env) - - if env['VALAC_VERSION'] > (0, 1, 6): - cmd = [valac, '-C', '--quiet', vala_flags] - else: - cmd = [valac, '-C', vala_flags] - - if self.threading: - cmd.append('--thread') - - if self.profile: - cmd.append('--profile=%s' % self.profile) - - if self.target_glib: - cmd.append('--target-glib=%s' % self.target_glib) - - features = self.generator.features - - if 'cshlib' in features or 'cstaticlib' in features: - output_dir = self.outputs[0].bld_dir(env) - cmd.append('--library ' + self.target) - if env['VALAC_VERSION'] >= (0, 7, 0): - for x in self.outputs: - if x.name.endswith('.h'): - cmd.append('--header ' + x.bldpath(self.env)) - cmd.append('--basedir ' + top_src) - cmd.append('-d ' + top_bld) - if env['VALAC_VERSION'] > (0, 7, 2) and hasattr(self, 'gir'): - cmd.append('--gir=%s.gir' % self.gir) - - else: - output_dir = self.outputs[0].bld_dir(env) - cmd.append('-d %s' % output_dir) - - for vapi_dir in self.vapi_dirs: - cmd.append('--vapidir=%s' % vapi_dir) - - for package in self.packages: - cmd.append('--pkg %s' % package) - - for package in self.packages_private: - cmd.append('--pkg %s' % package) - - cmd.append(" ".join(inputs)) - result = self.generator.bld.exec_command(" ".join(cmd)) - - if not 'cprogram' in features: - # generate the .deps file - if self.packages: - filename = os.path.join(self.generator.path.abspath(env), "%s.deps" % self.target) - deps = open(filename, 'w') - for package in self.packages: - deps.write(package + '\n') - deps.close() - - # handle vala 0.1.6 who doesn't honor --directory for the generated .vapi - self._fix_output("../%s.vapi" % self.target) - # handle vala >= 0.1.7 who has a weid definition for --directory - self._fix_output("%s.vapi" % self.target) - # handle vala >= 0.2.0 who doesn't honor --directory for the generated .gidl - self._fix_output("%s.gidl" % self.target) - # handle vala >= 0.3.6 who doesn't honor --directory for the generated .gir - self._fix_output("%s.gir" % self.target) - if hasattr(self, 'gir'): - self._fix_output("%s.gir" % self.gir) - - first = None - for node in self.outputs: - if not first: - first = node - else: - if first.parent.id != node.parent.id: - # issue #483 - if env['VALAC_VERSION'] < (0, 7, 0): - shutil.move(first.parent.abspath(self.env) + os.sep + node.name, node.abspath(self.env)) - return result - - def install(self): - bld = self.generator.bld - features = self.generator.features - - if self.attr("install_path") and ("cshlib" in features or "cstaticlib" in features): - headers_list = [o for o in self.outputs if o.suffix() == ".h"] - vapi_list = [o for o in self.outputs if (o.suffix() in (".vapi", ".deps"))] - gir_list = [o for o in self.outputs if o.suffix() == ".gir"] - - for header in headers_list: - top_src = self.generator.bld.srcnode - package = self.env['PACKAGE'] - try: - api_version = Utils.g_module.API_VERSION - except AttributeError: - version = Utils.g_module.VERSION.split(".") - if version[0] == "0": - api_version = "0." + version[1] - else: - api_version = version[0] + ".0" - install_path = '${INCLUDEDIR}/%s-%s/%s' % (package, api_version, header.relpath_gen(top_src)) - bld.install_as(install_path, header, self.env) - bld.install_files('${DATAROOTDIR}/vala/vapi', vapi_list, self.env) - bld.install_files('${DATAROOTDIR}/gir-1.0', gir_list, self.env) - - def _fix_output(self, output): - top_bld = self.generator.bld.srcnode.abspath(self.env) - try: - src = os.path.join(top_bld, output) - dst = self.generator.path.abspath (self.env) - shutil.move(src, dst) - except: - pass - -@extension(EXT_VALA) -def vala_file(self, node): - valatask = getattr(self, "valatask", None) - # there is only one vala task and it compiles all vala files .. :-/ - if not valatask: - valatask = self.create_task('valac') - self.valatask = valatask - self.includes = Utils.to_list(getattr(self, 'includes', [])) - self.uselib = self.to_list(self.uselib) - valatask.packages = [] - valatask.packages_private = Utils.to_list(getattr(self, 'packages_private', [])) - valatask.vapi_dirs = [] - valatask.target = self.target - valatask.threading = False - valatask.install_path = self.install_path - valatask.profile = getattr (self, 'profile', 'gobject') - valatask.target_glib = None #Deprecated - - packages = Utils.to_list(getattr(self, 'packages', [])) - vapi_dirs = Utils.to_list(getattr(self, 'vapi_dirs', [])) - includes = [] - - if hasattr(self, 'uselib_local'): - local_packages = Utils.to_list(self.uselib_local) - seen = [] - while len(local_packages) > 0: - package = local_packages.pop() - if package in seen: - continue - seen.append(package) - - # check if the package exists - package_obj = self.name_to_obj(package) - if not package_obj: - raise Utils.WafError("object '%s' was not found in uselib_local (required by '%s')" % (package, self.name)) - - package_name = package_obj.target - package_node = package_obj.path - package_dir = package_node.relpath_gen(self.path) - - for task in package_obj.tasks: - for output in task.outputs: - if output.name == package_name + ".vapi": - valatask.set_run_after(task) - if package_name not in packages: - packages.append(package_name) - if package_dir not in vapi_dirs: - vapi_dirs.append(package_dir) - if package_dir not in includes: - includes.append(package_dir) - - if hasattr(package_obj, 'uselib_local'): - lst = self.to_list(package_obj.uselib_local) - lst.reverse() - local_packages = [pkg for pkg in lst if pkg not in seen] + local_packages - - valatask.packages = packages - for vapi_dir in vapi_dirs: - try: - valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath()) - valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath(self.env)) - except AttributeError: - Logs.warn("Unable to locate Vala API directory: '%s'" % vapi_dir) - - self.includes.append(node.bld.srcnode.abspath()) - self.includes.append(node.bld.srcnode.abspath(self.env)) - for include in includes: - try: - self.includes.append(self.path.find_dir(include).abspath()) - self.includes.append(self.path.find_dir(include).abspath(self.env)) - except AttributeError: - Logs.warn("Unable to locate include directory: '%s'" % include) - - if valatask.profile == 'gobject': - if hasattr(self, 'target_glib'): - Logs.warn ('target_glib on vala tasks is deprecated --vala-target-glib=MAJOR.MINOR from the vala tool options') - - if getattr(Options.options, 'vala_target_glib', None): - valatask.target_glib = Options.options.vala_target_glib - - if not 'GOBJECT' in self.uselib: - self.uselib.append('GOBJECT') - - if hasattr(self, 'threading'): - if valatask.profile == 'gobject': - valatask.threading = self.threading - if not 'GTHREAD' in self.uselib: - self.uselib.append('GTHREAD') - else: - #Vala doesn't have threading support for dova nor posix - Logs.warn("Profile %s does not have threading support" % valatask.profile) - - if hasattr(self, 'gir'): - valatask.gir = self.gir - - env = valatask.env - - output_nodes = [] - - c_node = node.change_ext('.c') - output_nodes.append(c_node) - self.allnodes.append(c_node) - - if env['VALAC_VERSION'] < (0, 7, 0): - output_nodes.append(node.change_ext('.h')) - else: - if not 'cprogram' in self.features: - output_nodes.append(self.path.find_or_declare('%s.h' % self.target)) - - if not 'cprogram' in self.features: - output_nodes.append(self.path.find_or_declare('%s.vapi' % self.target)) - if env['VALAC_VERSION'] > (0, 7, 2): - if hasattr(self, 'gir'): - output_nodes.append(self.path.find_or_declare('%s.gir' % self.gir)) - elif env['VALAC_VERSION'] > (0, 3, 5): - output_nodes.append(self.path.find_or_declare('%s.gir' % self.target)) - elif env['VALAC_VERSION'] > (0, 1, 7): - output_nodes.append(self.path.find_or_declare('%s.gidl' % self.target)) - if valatask.packages: - output_nodes.append(self.path.find_or_declare('%s.deps' % self.target)) - - valatask.inputs.append(node) - valatask.outputs.extend(output_nodes) - -def detect(conf): - min_version = (0, 1, 6) - min_version_str = "%d.%d.%d" % min_version - - valac = conf.find_program('valac', var='VALAC', mandatory=True) - - if not conf.env["HAVE_GOBJECT"]: - pkg_args = {'package': 'gobject-2.0', - 'uselib_store': 'GOBJECT', - 'args': '--cflags --libs'} - if getattr(Options.options, 'vala_target_glib', None): - pkg_args['atleast_version'] = Options.options.vala_target_glib - - conf.check_cfg(**pkg_args) - - if not conf.env["HAVE_GTHREAD"]: - pkg_args = {'package': 'gthread-2.0', - 'uselib_store': 'GTHREAD', - 'args': '--cflags --libs'} - if getattr(Options.options, 'vala_target_glib', None): - pkg_args['atleast_version'] = Options.options.vala_target_glib - - conf.check_cfg(**pkg_args) - - try: - output = Utils.cmd_output(valac + " --version", silent=True) - version = output.split(' ', 1)[-1].strip().split(".")[0:3] - version = [int(x) for x in version] - valac_version = tuple(version) - except Exception: - valac_version = (0, 0, 0) - - conf.check_message('program version', - 'valac >= ' + min_version_str, - valac_version >= min_version, - "%d.%d.%d" % valac_version) - - conf.check_tool('gnu_dirs') - - if valac_version < min_version: - conf.fatal("valac version too old to be used with this tool") - return - - conf.env['VALAC_VERSION'] = valac_version - conf.env['VALAFLAGS'] = '' - -def set_options (opt): - valaopts = opt.add_option_group('Vala Compiler Options') - valaopts.add_option ('--vala-target-glib', default=None, - dest='vala_target_glib', metavar='MAJOR.MINOR', - help='Target version of glib for Vala GObject code generation') diff --git a/third_party/waf/wafadmin/Tools/winres.py b/third_party/waf/wafadmin/Tools/winres.py deleted file mode 100644 index 6b5aad004cc..00000000000 --- a/third_party/waf/wafadmin/Tools/winres.py +++ /dev/null @@ -1,44 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Brant Young, 2007 - -"This hook is called when the class cpp/cc task generator encounters a '.rc' file: X{.rc -> [.res|.rc.o]}" - -import os, sys, re -import TaskGen, Task -from Utils import quote_whitespace -from TaskGen import extension - -EXT_WINRC = ['.rc'] - -winrc_str = '${WINRC} ${_CPPDEFFLAGS} ${_CCDEFFLAGS} ${WINRCFLAGS} ${_CPPINCFLAGS} ${_CCINCFLAGS} ${WINRC_TGT_F} ${TGT} ${WINRC_SRC_F} ${SRC}' - -@extension(EXT_WINRC) -def rc_file(self, node): - obj_ext = '.rc.o' - if self.env['WINRC_TGT_F'] == '/fo': obj_ext = '.res' - - rctask = self.create_task('winrc', node, node.change_ext(obj_ext)) - self.compiled_tasks.append(rctask) - -# create our action, for use with rc file -Task.simple_task_type('winrc', winrc_str, color='BLUE', before='cc cxx', shell=False) - -def detect(conf): - v = conf.env - - winrc = v['WINRC'] - v['WINRC_TGT_F'] = '-o' - v['WINRC_SRC_F'] = '-i' - # find rc.exe - if not winrc: - if v['CC_NAME'] in ['gcc', 'cc', 'g++', 'c++']: - winrc = conf.find_program('windres', var='WINRC', path_list = v['PATH']) - elif v['CC_NAME'] == 'msvc': - winrc = conf.find_program('RC', var='WINRC', path_list = v['PATH']) - v['WINRC_TGT_F'] = '/fo' - v['WINRC_SRC_F'] = '' - if not winrc: - conf.fatal('winrc was not found!') - - v['WINRCFLAGS'] = '' diff --git a/third_party/waf/wafadmin/Tools/xlc.py b/third_party/waf/wafadmin/Tools/xlc.py deleted file mode 100644 index e33b7a16458..00000000000 --- a/third_party/waf/wafadmin/Tools/xlc.py +++ /dev/null @@ -1,78 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006-2008 (ita) -# Ralf Habacker, 2006 (rh) -# Yinon Ehrlich, 2009 -# Michael Kuhn, 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar -from Configure import conftest - -@conftest -def find_xlc(conf): - cc = conf.find_program(['xlc_r', 'xlc'], var='CC', mandatory=True) - cc = conf.cmd_to_list(cc) - conf.env.CC_NAME = 'xlc' - conf.env.CC = cc - -@conftest -def find_cpp(conf): - v = conf.env - cpp = None - if v['CPP']: cpp = v['CPP'] - elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] - #if not cpp: cpp = v['CC'] - v['CPP'] = cpp - -@conftest -def xlc_common_flags(conf): - v = conf.env - - # CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS - v['CCFLAGS_DEBUG'] = ['-g'] - v['CCFLAGS_RELEASE'] = ['-O2'] - - v['CC_SRC_F'] = '' - v['CC_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CC']: v['LINK_CC'] = v['CC'] - v['CCLNK_SRC_F'] = '' - v['CCLNK_TGT_F'] = ['-o', ''] # shell hack for -MD - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['RPATH_ST'] = '-Wl,-rpath,%s' - v['CCDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '' - v['SHLIB_MARKER'] = '' - v['STATICLIB_MARKER'] = '' - v['FULLSTATIC_MARKER'] = '-static' - - # program - v['program_LINKFLAGS'] = ['-Wl,-brtl'] - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CCFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro - v['shlib_LINKFLAGS'] = ['-G', '-Wl,-brtl,-bexpfull'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = '' - v['staticlib_PATTERN'] = 'lib%s.a' - -def detect(conf): - conf.find_xlc() - conf.find_cpp() - conf.find_ar() - conf.xlc_common_flags() - conf.cc_load_tools() - conf.cc_add_flags() - conf.link_add_flags() diff --git a/third_party/waf/wafadmin/Tools/xlcxx.py b/third_party/waf/wafadmin/Tools/xlcxx.py deleted file mode 100644 index 6e84662a64c..00000000000 --- a/third_party/waf/wafadmin/Tools/xlcxx.py +++ /dev/null @@ -1,78 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 -# Thomas Nagy, 2006 (ita) -# Ralf Habacker, 2006 (rh) -# Yinon Ehrlich, 2009 -# Michael Kuhn, 2009 - -import os, sys -import Configure, Options, Utils -import ccroot, ar -from Configure import conftest - -@conftest -def find_xlcxx(conf): - cxx = conf.find_program(['xlc++_r', 'xlc++'], var='CXX', mandatory=True) - cxx = conf.cmd_to_list(cxx) - conf.env.CXX_NAME = 'xlc++' - conf.env.CXX = cxx - -@conftest -def find_cpp(conf): - v = conf.env - cpp = None - if v['CPP']: cpp = v['CPP'] - elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] - #if not cpp: cpp = v['CXX'] - v['CPP'] = cpp - -@conftest -def xlcxx_common_flags(conf): - v = conf.env - - # CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS - v['CXXFLAGS_DEBUG'] = ['-g'] - v['CXXFLAGS_RELEASE'] = ['-O2'] - - v['CXX_SRC_F'] = '' - v['CXX_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD - v['CPPPATH_ST'] = '-I%s' # template for adding include paths - - # linker - if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] - v['CXXLNK_SRC_F'] = '' - v['CXXLNK_TGT_F'] = ['-o', ''] # shell hack for -MD - - v['LIB_ST'] = '-l%s' # template for adding libs - v['LIBPATH_ST'] = '-L%s' # template for adding libpaths - v['STATICLIB_ST'] = '-l%s' - v['STATICLIBPATH_ST'] = '-L%s' - v['RPATH_ST'] = '-Wl,-rpath,%s' - v['CXXDEFINES_ST'] = '-D%s' - - v['SONAME_ST'] = '' - v['SHLIB_MARKER'] = '' - v['STATICLIB_MARKER'] = '' - v['FULLSTATIC_MARKER'] = '-static' - - # program - v['program_LINKFLAGS'] = ['-Wl,-brtl'] - v['program_PATTERN'] = '%s' - - # shared library - v['shlib_CXXFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro - v['shlib_LINKFLAGS'] = ['-G', '-Wl,-brtl,-bexpfull'] - v['shlib_PATTERN'] = 'lib%s.so' - - # static lib - v['staticlib_LINKFLAGS'] = '' - v['staticlib_PATTERN'] = 'lib%s.a' - -def detect(conf): - conf.find_xlcxx() - conf.find_cpp() - conf.find_ar() - conf.xlcxx_common_flags() - conf.cxx_load_tools() - conf.cxx_add_flags() - conf.link_add_flags() |