From e375a665fc2bac70db8605479f7a062555e26f4e Mon Sep 17 00:00:00 2001 From: Paul Brossier Date: Sat, 7 Dec 2013 14:04:04 -0500 Subject: [PATCH] waf, waflib: import unpacked waf 1.7.13 --- waf | 164 +++++++++ waflib/Build.py | 758 +++++++++++++++++++++++++++++++++++++++++ waflib/Build.pyc | Bin 0 -> 35115 bytes waflib/ConfigSet.py | 152 +++++++++ waflib/ConfigSet.pyc | Bin 0 -> 8317 bytes waflib/Configure.py | 317 +++++++++++++++++ waflib/Configure.pyc | Bin 0 -> 14623 bytes waflib/Context.py | 319 +++++++++++++++++ waflib/Context.pyc | Bin 0 -> 12799 bytes waflib/Errors.py | 37 ++ waflib/Errors.pyc | Bin 0 -> 2843 bytes waflib/Logs.py | 177 ++++++++++ waflib/Logs.pyc | Bin 0 -> 9978 bytes waflib/Node.py | 467 +++++++++++++++++++++++++ waflib/Node.pyc | Bin 0 -> 19366 bytes waflib/Options.py | 135 ++++++++ waflib/Options.pyc | Bin 0 -> 7862 bytes waflib/Runner.py | 197 +++++++++++ waflib/Runner.pyc | Bin 0 -> 8520 bytes waflib/Scripting.py | 373 ++++++++++++++++++++ waflib/Scripting.pyc | Bin 0 -> 16156 bytes waflib/Task.py | 677 ++++++++++++++++++++++++++++++++++++ waflib/Task.pyc | Bin 0 -> 28638 bytes waflib/TaskGen.py | 404 ++++++++++++++++++++++ waflib/TaskGen.pyc | Bin 0 -> 18252 bytes waflib/Tools/__init__.py | 4 + waflib/Tools/__init__.pyc | Bin 0 -> 189 bytes waflib/Tools/ar.py | 11 + waflib/Tools/ar.pyc | Bin 0 -> 773 bytes waflib/Tools/asm.py | 25 ++ waflib/Tools/bison.py | 28 ++ waflib/Tools/c.py | 24 ++ waflib/Tools/c.pyc | Bin 0 -> 2033 bytes waflib/Tools/c_aliases.py | 55 +++ waflib/Tools/c_aliases.pyc | Bin 0 -> 2903 bytes waflib/Tools/c_config.py | 744 ++++++++++++++++++++++++++++++++++++++++ waflib/Tools/c_config.pyc | Bin 0 -> 32674 bytes waflib/Tools/c_osx.py | 120 +++++++ waflib/Tools/c_osx.pyc | Bin 0 -> 6577 bytes waflib/Tools/c_preproc.py | 604 ++++++++++++++++++++++++++++++++ waflib/Tools/c_preproc.pyc | Bin 0 -> 22385 bytes waflib/Tools/c_tests.py | 153 +++++++++ waflib/Tools/c_tests.pyc | Bin 0 -> 6660 bytes waflib/Tools/ccroot.py | 405 ++++++++++++++++++++++ waflib/Tools/ccroot.pyc | Bin 0 -> 18933 bytes waflib/Tools/compiler_c.py | 39 +++ waflib/Tools/compiler_c.pyc | Bin 0 -> 2486 bytes waflib/Tools/compiler_cxx.py | 39 +++ waflib/Tools/compiler_d.py | 29 ++ waflib/Tools/compiler_fc.py | 43 +++ waflib/Tools/cs.py | 132 +++++++ waflib/Tools/cxx.py | 26 ++ waflib/Tools/d.py | 54 +++ waflib/Tools/d_config.py | 52 +++ waflib/Tools/d_scan.py | 133 ++++++++ waflib/Tools/dbus.py | 29 ++ waflib/Tools/dmd.py | 51 +++ waflib/Tools/errcheck.py | 161 +++++++++ waflib/Tools/errcheck.pyc | Bin 0 -> 8847 bytes waflib/Tools/fc.py | 116 +++++++ waflib/Tools/fc_config.py | 285 ++++++++++++++++ waflib/Tools/fc_scan.py | 68 ++++ waflib/Tools/flex.py | 32 ++ waflib/Tools/g95.py | 55 +++ waflib/Tools/gas.py | 12 + waflib/Tools/gcc.py | 98 ++++++ waflib/Tools/gcc.pyc | Bin 0 -> 5049 bytes waflib/Tools/gdc.py | 36 ++ waflib/Tools/gfortran.py | 69 ++++ waflib/Tools/glib2.py | 173 ++++++++++ waflib/Tools/gnu_dirs.py | 65 ++++ waflib/Tools/gnu_dirs.pyc | Bin 0 -> 3737 bytes waflib/Tools/gxx.py | 98 ++++++ waflib/Tools/icc.py | 30 ++ waflib/Tools/icpc.py | 29 ++ waflib/Tools/ifort.py | 49 +++ waflib/Tools/intltool.py | 77 +++++ waflib/Tools/irixcc.py | 48 +++ waflib/Tools/javaw.py | 309 +++++++++++++++++ waflib/Tools/kde4.py | 48 +++ waflib/Tools/ldc2.py | 37 ++ waflib/Tools/lua.py | 18 + waflib/Tools/msvc.py | 749 ++++++++++++++++++++++++++++++++++++++++ waflib/Tools/nasm.py | 14 + waflib/Tools/perl.py | 80 +++++ waflib/Tools/python.py | 343 +++++++++++++++++++ waflib/Tools/qt4.py | 455 +++++++++++++++++++++++++ waflib/Tools/ruby.py | 103 ++++++ waflib/Tools/suncc.py | 54 +++ waflib/Tools/suncxx.py | 55 +++ waflib/Tools/tex.py | 257 ++++++++++++++ waflib/Tools/vala.py | 201 +++++++++++ waflib/Tools/waf_unit_test.py | 97 ++++++ waflib/Tools/waf_unit_test.pyc | Bin 0 -> 5500 bytes waflib/Tools/winres.py | 85 +++++ waflib/Tools/xlc.py | 45 +++ waflib/Tools/xlcxx.py | 45 +++ waflib/Utils.py | 412 ++++++++++++++++++++++ waflib/Utils.pyc | Bin 0 -> 18670 bytes waflib/__init__.py | 4 + waflib/__init__.pyc | Bin 0 -> 183 bytes waflib/ansiterm.py | 177 ++++++++++ waflib/ansiterm.pyc | Bin 0 -> 12022 bytes waflib/extras/__init__.py | 4 + waflib/extras/compat15.py | 220 ++++++++++++ waflib/fixpy2.py | 53 +++ waflib/fixpy2.pyc | Bin 0 -> 2455 bytes 107 files changed, 12343 insertions(+) create mode 100755 waf create mode 100644 waflib/Build.py create mode 100644 waflib/Build.pyc create mode 100644 waflib/ConfigSet.py create mode 100644 waflib/ConfigSet.pyc create mode 100644 waflib/Configure.py create mode 100644 waflib/Configure.pyc create mode 100644 waflib/Context.py create mode 100644 waflib/Context.pyc create mode 100644 waflib/Errors.py create mode 100644 waflib/Errors.pyc create mode 100644 waflib/Logs.py create mode 100644 waflib/Logs.pyc create mode 100644 waflib/Node.py create mode 100644 waflib/Node.pyc create mode 100644 waflib/Options.py create mode 100644 waflib/Options.pyc create mode 100644 waflib/Runner.py create mode 100644 waflib/Runner.pyc create mode 100644 waflib/Scripting.py create mode 100644 waflib/Scripting.pyc create mode 100644 waflib/Task.py create mode 100644 waflib/Task.pyc create mode 100644 waflib/TaskGen.py create mode 100644 waflib/TaskGen.pyc create mode 100644 waflib/Tools/__init__.py create mode 100644 waflib/Tools/__init__.pyc create mode 100644 waflib/Tools/ar.py create mode 100644 waflib/Tools/ar.pyc create mode 100644 waflib/Tools/asm.py create mode 100644 waflib/Tools/bison.py create mode 100644 waflib/Tools/c.py create mode 100644 waflib/Tools/c.pyc create mode 100644 waflib/Tools/c_aliases.py create mode 100644 waflib/Tools/c_aliases.pyc create mode 100755 waflib/Tools/c_config.py create mode 100644 waflib/Tools/c_config.pyc create mode 100644 waflib/Tools/c_osx.py create mode 100644 waflib/Tools/c_osx.pyc create mode 100644 waflib/Tools/c_preproc.py create mode 100644 waflib/Tools/c_preproc.pyc create mode 100644 waflib/Tools/c_tests.py create mode 100644 waflib/Tools/c_tests.pyc create mode 100644 waflib/Tools/ccroot.py create mode 100644 waflib/Tools/ccroot.pyc create mode 100644 waflib/Tools/compiler_c.py create mode 100644 waflib/Tools/compiler_c.pyc create mode 100644 waflib/Tools/compiler_cxx.py create mode 100644 waflib/Tools/compiler_d.py create mode 100644 waflib/Tools/compiler_fc.py create mode 100644 waflib/Tools/cs.py create mode 100644 waflib/Tools/cxx.py create mode 100644 waflib/Tools/d.py create mode 100644 waflib/Tools/d_config.py create mode 100644 waflib/Tools/d_scan.py create mode 100644 waflib/Tools/dbus.py create mode 100644 waflib/Tools/dmd.py create mode 100644 waflib/Tools/errcheck.py create mode 100644 waflib/Tools/errcheck.pyc create mode 100644 waflib/Tools/fc.py create mode 100644 waflib/Tools/fc_config.py create mode 100644 waflib/Tools/fc_scan.py create mode 100644 waflib/Tools/flex.py create mode 100644 waflib/Tools/g95.py create mode 100644 waflib/Tools/gas.py create mode 100644 waflib/Tools/gcc.py create mode 100644 waflib/Tools/gcc.pyc create mode 100644 waflib/Tools/gdc.py create mode 100644 waflib/Tools/gfortran.py create mode 100644 waflib/Tools/glib2.py create mode 100644 waflib/Tools/gnu_dirs.py create mode 100644 waflib/Tools/gnu_dirs.pyc create mode 100644 waflib/Tools/gxx.py create mode 100644 waflib/Tools/icc.py create mode 100644 waflib/Tools/icpc.py create mode 100644 waflib/Tools/ifort.py create mode 100644 waflib/Tools/intltool.py create mode 100644 waflib/Tools/irixcc.py create mode 100644 waflib/Tools/javaw.py create mode 100644 waflib/Tools/kde4.py create mode 100644 waflib/Tools/ldc2.py create mode 100644 waflib/Tools/lua.py create mode 100644 waflib/Tools/msvc.py create mode 100644 waflib/Tools/nasm.py create mode 100644 waflib/Tools/perl.py create mode 100644 waflib/Tools/python.py create mode 100644 waflib/Tools/qt4.py create mode 100644 waflib/Tools/ruby.py create mode 100644 waflib/Tools/suncc.py create mode 100644 waflib/Tools/suncxx.py create mode 100644 waflib/Tools/tex.py create mode 100644 waflib/Tools/vala.py create mode 100644 waflib/Tools/waf_unit_test.py create mode 100644 waflib/Tools/waf_unit_test.pyc create mode 100644 waflib/Tools/winres.py create mode 100644 waflib/Tools/xlc.py create mode 100644 waflib/Tools/xlcxx.py create mode 100644 waflib/Utils.py create mode 100644 waflib/Utils.pyc create mode 100644 waflib/__init__.py create mode 100644 waflib/__init__.pyc create mode 100644 waflib/ansiterm.py create mode 100644 waflib/ansiterm.pyc create mode 100644 waflib/extras/__init__.py create mode 100644 waflib/extras/compat15.py create mode 100644 waflib/fixpy2.py create mode 100644 waflib/fixpy2.pyc diff --git a/waf b/waf new file mode 100755 index 0000000..4ba08d8 --- /dev/null +++ b/waf @@ -0,0 +1,164 @@ +#!/usr/bin/env python +# encoding: ISO8859-1 +# Thomas Nagy, 2005-2012 + +""" +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. +""" + +import os, sys + +VERSION="1.7.13" +REVISION="5a064c2686fe54de4e11018d22148cfc" +INSTALL='' +C1='#(' +C2='#$' +cwd = os.getcwd() +join = os.path.join + + +WAF='waf' +def b(x): + return x +if sys.hexversion>0x300000f: + WAF='waf3' + def b(x): + return x.encode() + +def err(m): + print(('\033[91mError: %s\033[0m' % m)) + sys.exit(1) + +def unpack_wafdir(dir): + f = open(sys.argv[0],'rb') + c = 'corrupt archive (%d)' + while 1: + line = f.readline() + if not line: err('run waf-light from a folder containing waflib') + if line == b('#==>\n'): + txt = f.readline() + if not txt: err(c % 1) + if f.readline() != b('#<==\n'): err(c % 2) + break + if not txt: err(c % 3) + txt = txt[1:-1].replace(b(C1), b('\n')).replace(b(C2), b('\r')) + + import shutil, tarfile + try: shutil.rmtree(dir) + except OSError: pass + try: + for x in ['Tools', 'extras']: + os.makedirs(join(dir, 'waflib', x)) + except OSError: + err("Cannot unpack waf lib into %s\nMove waf in a writable directory" % dir) + + os.chdir(dir) + tmp = 't.bz2' + t = open(tmp,'wb') + try: t.write(txt) + finally: t.close() + + try: + t = tarfile.open(tmp) + except: + try: + os.system('bunzip2 t.bz2') + t = tarfile.open('t') + tmp = 't' + except: + os.chdir(cwd) + try: shutil.rmtree(dir) + except OSError: pass + err("Waf cannot be unpacked, check that bzip2 support is present") + + try: + for x in t: t.extract(x) + finally: + t.close() + + for x in ['Tools', 'extras']: + os.chmod(join('waflib',x), 493) + + if sys.hexversion<0x300000f: + sys.path = [join(dir, 'waflib')] + sys.path + import fixpy2 + fixpy2.fixdir(dir) + + os.remove(tmp) + os.chdir(cwd) + + try: dir = unicode(dir, 'mbcs') + except: pass + try: + from ctypes import windll + windll.kernel32.SetFileAttributesW(dir, 2) + except: + pass + +def test(dir): + try: + os.stat(join(dir, 'waflib')) + return os.path.abspath(dir) + except OSError: + pass + +def find_lib(): + name = sys.argv[0] + base = os.path.dirname(os.path.abspath(name)) + + #devs use $WAFDIR + w=test(os.environ.get('WAFDIR', '')) + if w: return w + + #waf-light + if name.endswith('waf-light'): + w = test(base) + if w: return w + err('waf-light requires waflib -> export WAFDIR=/folder') + + dirname = '%s-%s-%s' % (WAF, VERSION, REVISION) + for i in [INSTALL,'/usr','/usr/local','/opt']: + w = test(i + '/lib/' + dirname) + if w: return w + + #waf-local + dir = join(base, (sys.platform != 'win32' and '.' or '') + dirname) + w = test(dir) + if w: return w + + #unpack + unpack_wafdir(dir) + return dir + +wafdir = find_lib() +sys.path.insert(0, wafdir) + +if __name__ == '__main__': + + from waflib import Scripting + Scripting.waf_entry_point(cwd, VERSION, wafdir) + diff --git a/waflib/Build.py b/waflib/Build.py new file mode 100644 index 0000000..f76933a --- /dev/null +++ b/waflib/Build.py @@ -0,0 +1,758 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,errno,re,shutil +try: + import cPickle +except ImportError: + import pickle as cPickle +from waflib import Runner,TaskGen,Utils,ConfigSet,Task,Logs,Options,Context,Errors +import waflib.Node +CACHE_DIR='c4che' +CACHE_SUFFIX='_cache.py' +INSTALL=1337 +UNINSTALL=-1337 +SAVED_ATTRS='root node_deps raw_deps task_sigs'.split() +CFG_FILES='cfg_files' +POST_AT_ONCE=0 +POST_LAZY=1 +POST_BOTH=2 +class BuildContext(Context.Context): + '''executes the build''' + cmd='build' + variant='' + def __init__(self,**kw): + super(BuildContext,self).__init__(**kw) + self.is_install=0 + self.top_dir=kw.get('top_dir',Context.top_dir) + self.run_dir=kw.get('run_dir',Context.run_dir) + self.post_mode=POST_AT_ONCE + self.out_dir=kw.get('out_dir',Context.out_dir) + self.cache_dir=kw.get('cache_dir',None) + if not self.cache_dir: + self.cache_dir=self.out_dir+os.sep+CACHE_DIR + self.all_envs={} + self.task_sigs={} + self.node_deps={} + self.raw_deps={} + self.cache_dir_contents={} + self.task_gen_cache_names={} + self.launch_dir=Context.launch_dir + self.jobs=Options.options.jobs + self.targets=Options.options.targets + self.keep=Options.options.keep + self.cache_global=Options.cache_global + self.nocache=Options.options.nocache + self.progress_bar=Options.options.progress_bar + self.deps_man=Utils.defaultdict(list) + self.current_group=0 + self.groups=[] + self.group_names={} + def get_variant_dir(self): + if not self.variant: + return self.out_dir + return os.path.join(self.out_dir,self.variant) + variant_dir=property(get_variant_dir,None) + def __call__(self,*k,**kw): + kw['bld']=self + ret=TaskGen.task_gen(*k,**kw) + self.task_gen_cache_names={} + self.add_to_group(ret,group=kw.get('group',None)) + return ret + def rule(self,*k,**kw): + def f(rule): + ret=self(*k,**kw) + ret.rule=rule + return ret + return f + def __copy__(self): + raise Errors.WafError('build contexts are not supposed to be copied') + def install_files(self,*k,**kw): + pass + def install_as(self,*k,**kw): + pass + def symlink_as(self,*k,**kw): + pass + def load_envs(self): + node=self.root.find_node(self.cache_dir) + if not node: + raise Errors.WafError('The project was not configured: run "waf configure" first!') + lst=node.ant_glob('**/*%s'%CACHE_SUFFIX,quiet=True) + if not lst: + raise Errors.WafError('The cache directory is empty: reconfigure the project') + for x in lst: + name=x.path_from(node).replace(CACHE_SUFFIX,'').replace('\\','/') + env=ConfigSet.ConfigSet(x.abspath()) + self.all_envs[name]=env + for f in env[CFG_FILES]: + newnode=self.root.find_resource(f) + try: + h=Utils.h_file(newnode.abspath()) + except(IOError,AttributeError): + Logs.error('cannot find %r'%f) + h=Utils.SIG_NIL + newnode.sig=h + def init_dirs(self): + if not(os.path.isabs(self.top_dir)and os.path.isabs(self.out_dir)): + raise Errors.WafError('The project was not configured: run "waf configure" first!') + self.path=self.srcnode=self.root.find_dir(self.top_dir) + self.bldnode=self.root.make_node(self.variant_dir) + self.bldnode.mkdir() + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.execute_build() + def execute_build(self): + Logs.info("Waf: Entering directory `%s'"%self.variant_dir) + self.recurse([self.run_dir]) + self.pre_build() + self.timer=Utils.Timer() + if self.progress_bar: + sys.stderr.write(Logs.colors.cursor_off) + try: + self.compile() + finally: + if self.progress_bar==1: + c=len(self.returned_tasks)or 1 + self.to_log(self.progress_line(c,c,Logs.colors.BLUE,Logs.colors.NORMAL)) + print('') + sys.stdout.flush() + sys.stderr.write(Logs.colors.cursor_on) + Logs.info("Waf: Leaving directory `%s'"%self.variant_dir) + self.post_build() + def restore(self): + try: + env=ConfigSet.ConfigSet(os.path.join(self.cache_dir,'build.config.py')) + except(IOError,OSError): + pass + else: + if env['version']').ljust(cols) + msg=Utils.indicator%(left,bar,right) + return msg + def declare_chain(self,*k,**kw): + return TaskGen.declare_chain(*k,**kw) + def pre_build(self): + for m in getattr(self,'pre_funs',[]): + m(self) + def post_build(self): + for m in getattr(self,'post_funs',[]): + m(self) + def add_pre_fun(self,meth): + try: + self.pre_funs.append(meth) + except AttributeError: + self.pre_funs=[meth] + def add_post_fun(self,meth): + try: + self.post_funs.append(meth) + except AttributeError: + self.post_funs=[meth] + def get_group(self,x): + if not self.groups: + self.add_group() + if x is None: + return self.groups[self.current_group] + if x in self.group_names: + return self.group_names[x] + return self.groups[x] + def add_to_group(self,tgen,group=None): + assert(isinstance(tgen,TaskGen.task_gen)or isinstance(tgen,Task.TaskBase)) + tgen.bld=self + self.get_group(group).append(tgen) + def get_group_name(self,g): + if not isinstance(g,list): + g=self.groups[g] + for x in self.group_names: + if id(self.group_names[x])==id(g): + return x + return'' + def get_group_idx(self,tg): + se=id(tg) + for i in range(len(self.groups)): + for t in self.groups[i]: + if id(t)==se: + return i + return None + def add_group(self,name=None,move=True): + if name and name in self.group_names: + Logs.error('add_group: name %s already present'%name) + g=[] + self.group_names[name]=g + self.groups.append(g) + if move: + self.current_group=len(self.groups)-1 + def set_group(self,idx): + if isinstance(idx,str): + g=self.group_names[idx] + for i in range(len(self.groups)): + if id(g)==id(self.groups[i]): + self.current_group=i + else: + self.current_group=idx + def total(self): + total=0 + for group in self.groups: + for tg in group: + try: + total+=len(tg.tasks) + except AttributeError: + total+=1 + return total + def get_targets(self): + to_post=[] + min_grp=0 + for name in self.targets.split(','): + tg=self.get_tgen_by_name(name) + if not tg: + raise Errors.WafError('target %r does not exist'%name) + m=self.get_group_idx(tg) + if m>min_grp: + min_grp=m + to_post=[tg] + elif m==min_grp: + to_post.append(tg) + return(min_grp,to_post) + def get_all_task_gen(self): + lst=[] + for g in self.groups: + lst.extend(g) + return lst + def post_group(self): + if self.targets=='*': + for tg in self.groups[self.cur]: + try: + f=tg.post + except AttributeError: + pass + else: + f() + elif self.targets: + if self.cur%r'%(src,tgt)) + Utils.check_dir(d) + srclbl=src.replace(self.srcnode.abspath()+os.sep,'') + if not Options.options.force: + try: + st1=os.stat(tgt) + st2=os.stat(src) + except OSError: + pass + else: + if st1.st_mtime+2>=st2.st_mtime and st1.st_size==st2.st_size: + if not self.progress_bar: + Logs.info('- install %s (from %s)'%(tgt,srclbl)) + return False + if not self.progress_bar: + Logs.info('+ install %s (from %s)'%(tgt,srclbl)) + try: + os.remove(tgt) + except OSError: + pass + try: + shutil.copy2(src,tgt) + os.chmod(tgt,chmod) + except IOError: + try: + os.stat(src) + except(OSError,IOError): + Logs.error('File %r does not exist'%src) + raise Errors.WafError('Could not install the file %r'%tgt) + def do_link(self,src,tgt): + d,_=os.path.split(tgt) + Utils.check_dir(d) + link=False + if not os.path.islink(tgt): + link=True + elif os.readlink(tgt)!=src: + link=True + if link: + try:os.remove(tgt) + except OSError:pass + if not self.progress_bar: + Logs.info('+ symlink %s (to %s)'%(tgt,src)) + os.symlink(src,tgt) + else: + if not self.progress_bar: + Logs.info('- symlink %s (to %s)'%(tgt,src)) + def run_task_now(self,tsk,postpone): + tsk.post() + if not postpone: + if tsk.runnable_status()==Task.ASK_LATER: + raise self.WafError('cannot post the task %r'%tsk) + tsk.run() + def install_files(self,dest,files,env=None,chmod=Utils.O644,relative_trick=False,cwd=None,add=True,postpone=True): + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.path=cwd or self.path + tsk.chmod=chmod + if isinstance(files,waflib.Node.Node): + tsk.source=[files] + else: + tsk.source=Utils.to_list(files) + tsk.dest=dest + tsk.exec_task=tsk.exec_install_files + tsk.relative_trick=relative_trick + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk + def install_as(self,dest,srcfile,env=None,chmod=Utils.O644,cwd=None,add=True,postpone=True): + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.path=cwd or self.path + tsk.chmod=chmod + tsk.source=[srcfile] + tsk.dest=dest + tsk.exec_task=tsk.exec_install_as + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk + def symlink_as(self,dest,src,env=None,cwd=None,add=True,postpone=True,relative_trick=False): + if Utils.is_win32: + return + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.dest=dest + tsk.path=cwd or self.path + tsk.source=[] + tsk.link=src + tsk.relative_trick=relative_trick + tsk.exec_task=tsk.exec_symlink_as + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk +class UninstallContext(InstallContext): + '''removes the targets installed''' + cmd='uninstall' + def __init__(self,**kw): + super(UninstallContext,self).__init__(**kw) + self.is_install=UNINSTALL + def do_install(self,src,tgt,chmod=Utils.O644): + if not self.progress_bar: + Logs.info('- remove %s'%tgt) + self.uninstall.append(tgt) + try: + os.remove(tgt) + except OSError ,e: + if e.errno!=errno.ENOENT: + if not getattr(self,'uninstall_error',None): + self.uninstall_error=True + Logs.warn('build: some files could not be uninstalled (retry with -vv to list them)') + if Logs.verbose>1: + Logs.warn('Could not remove %s (error code %r)'%(e.filename,e.errno)) + while tgt: + tgt=os.path.dirname(tgt) + try: + os.rmdir(tgt) + except OSError: + break + def do_link(self,src,tgt): + try: + if not self.progress_bar: + Logs.info('- remove %s'%tgt) + os.remove(tgt) + except OSError: + pass + while tgt: + tgt=os.path.dirname(tgt) + try: + os.rmdir(tgt) + except OSError: + break + def execute(self): + try: + def runnable_status(self): + return Task.SKIP_ME + setattr(Task.Task,'runnable_status_back',Task.Task.runnable_status) + setattr(Task.Task,'runnable_status',runnable_status) + super(UninstallContext,self).execute() + finally: + setattr(Task.Task,'runnable_status',Task.Task.runnable_status_back) +class CleanContext(BuildContext): + '''cleans the project''' + cmd='clean' + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.recurse([self.run_dir]) + try: + self.clean() + finally: + self.store() + def clean(self): + Logs.debug('build: clean called') + if self.bldnode!=self.srcnode: + lst=[] + for e in self.all_envs.values(): + lst.extend(self.root.find_or_declare(f)for f in e[CFG_FILES]) + for n in self.bldnode.ant_glob('**/*',excl='.lock* *conf_check_*/** config.log c4che/*',quiet=True): + if n in lst: + continue + n.delete() + self.root.children={} + for v in'node_deps task_sigs raw_deps'.split(): + setattr(self,v,{}) +class ListContext(BuildContext): + '''lists the targets to execute''' + cmd='list' + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.recurse([self.run_dir]) + self.pre_build() + self.timer=Utils.Timer() + for g in self.groups: + for tg in g: + try: + f=tg.post + except AttributeError: + pass + else: + f() + try: + self.get_tgen_by_name('') + except Exception: + pass + lst=list(self.task_gen_cache_names.keys()) + lst.sort() + for k in lst: + Logs.pprint('GREEN',k) +class StepContext(BuildContext): + '''executes tasks in a step-by-step fashion, for debugging''' + cmd='step' + def __init__(self,**kw): + super(StepContext,self).__init__(**kw) + self.files=Options.options.files + def compile(self): + if not self.files: + Logs.warn('Add a pattern for the debug build, for example "waf step --files=main.c,app"') + BuildContext.compile(self) + return + targets=None + if self.targets and self.targets!='*': + targets=self.targets.split(',') + for g in self.groups: + for tg in g: + if targets and tg.name not in targets: + continue + try: + f=tg.post + except AttributeError: + pass + else: + f() + for pat in self.files.split(','): + matcher=self.get_matcher(pat) + for tg in g: + if isinstance(tg,Task.TaskBase): + lst=[tg] + else: + lst=tg.tasks + for tsk in lst: + do_exec=False + for node in getattr(tsk,'inputs',[]): + if matcher(node,output=False): + do_exec=True + break + for node in getattr(tsk,'outputs',[]): + if matcher(node,output=True): + do_exec=True + break + if do_exec: + ret=tsk.run() + Logs.info('%s -> exit %r'%(str(tsk),ret)) + def get_matcher(self,pat): + inn=True + out=True + if pat.startswith('in:'): + out=False + pat=pat.replace('in:','') + elif pat.startswith('out:'): + inn=False + pat=pat.replace('out:','') + anode=self.root.find_node(pat) + pattern=None + if not anode: + if not pat.startswith('^'): + pat='^.+?%s'%pat + if not pat.endswith('$'): + pat='%s$'%pat + pattern=re.compile(pat) + def match(node,output): + if output==True and not out: + return False + if output==False and not inn: + return False + if anode: + return anode==node + else: + return pattern.match(node.abspath()) + return match +BuildContext.store=Utils.nogc(BuildContext.store) +BuildContext.restore=Utils.nogc(BuildContext.restore) diff --git a/waflib/Build.pyc b/waflib/Build.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2916a2aca2601f58e189e07a58f64e6818e7dfc8 GIT binary patch literal 35115 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 VqQ0h!MQi>S>NZ^aZTQLs=Rc)!ZGr#* literal 0 HcmV?d00001 diff --git a/waflib/Configure.py b/waflib/Configure.py new file mode 100644 index 0000000..e8148d5 --- /dev/null +++ b/waflib/Configure.py @@ -0,0 +1,317 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shlex,sys,time +from waflib import ConfigSet,Utils,Options,Logs,Context,Build,Errors +try: + from urllib import request +except ImportError: + from urllib import urlopen +else: + urlopen=request.urlopen +BREAK='break' +CONTINUE='continue' +WAF_CONFIG_LOG='config.log' +autoconfig=False +conf_template='''# project %(app)s configured on %(now)s by +# waf %(wafver)s (abi %(abi)s, python %(pyver)x on %(systype)s) +# using %(args)s +#''' +def download_check(node): + pass +def download_tool(tool,force=False,ctx=None): + for x in Utils.to_list(Context.remote_repo): + for sub in Utils.to_list(Context.remote_locs): + url='/'.join((x,sub,tool+'.py')) + try: + web=urlopen(url) + try: + if web.getcode()!=200: + continue + except AttributeError: + pass + except Exception: + continue + else: + tmp=ctx.root.make_node(os.sep.join((Context.waf_dir,'waflib','extras',tool+'.py'))) + tmp.write(web.read(),'wb') + Logs.warn('Downloaded %s from %s'%(tool,url)) + download_check(tmp) + try: + module=Context.load_tool(tool) + except Exception: + Logs.warn('The tool %s from %s is unusable'%(tool,url)) + try: + tmp.delete() + except Exception: + pass + continue + return module + raise Errors.WafError('Could not load the Waf tool') +class ConfigurationContext(Context.Context): + '''configures the project''' + cmd='configure' + error_handlers=[] + def __init__(self,**kw): + super(ConfigurationContext,self).__init__(**kw) + self.environ=dict(os.environ) + self.all_envs={} + self.top_dir=None + self.out_dir=None + self.tools=[] + self.hash=0 + self.files=[] + self.tool_cache=[] + self.setenv('') + def setenv(self,name,env=None): + if name not in self.all_envs or env: + if not env: + env=ConfigSet.ConfigSet() + self.prepare_env(env) + else: + env=env.derive() + self.all_envs[name]=env + self.variant=name + def get_env(self): + return self.all_envs[self.variant] + def set_env(self,val): + self.all_envs[self.variant]=val + env=property(get_env,set_env) + def init_dirs(self): + top=self.top_dir + if not top: + top=Options.options.top + if not top: + top=getattr(Context.g_module,Context.TOP,None) + if not top: + top=self.path.abspath() + top=os.path.abspath(top) + self.srcnode=(os.path.isabs(top)and self.root or self.path).find_dir(top) + assert(self.srcnode) + out=self.out_dir + if not out: + out=Options.options.out + if not out: + out=getattr(Context.g_module,Context.OUT,None) + if not out: + out=Options.lockfile.replace('.lock-waf_%s_'%sys.platform,'').replace('.lock-waf','') + self.bldnode=(os.path.isabs(out)and self.root or self.path).make_node(out) + self.bldnode.mkdir() + if not os.path.isdir(self.bldnode.abspath()): + conf.fatal('Could not create the build directory %s'%self.bldnode.abspath()) + def execute(self): + self.init_dirs() + self.cachedir=self.bldnode.make_node(Build.CACHE_DIR) + self.cachedir.mkdir() + path=os.path.join(self.bldnode.abspath(),WAF_CONFIG_LOG) + self.logger=Logs.make_logger(path,'cfg') + app=getattr(Context.g_module,'APPNAME','') + if app: + ver=getattr(Context.g_module,'VERSION','') + if ver: + app="%s (%s)"%(app,ver) + now=time.ctime() + pyver=sys.hexversion + systype=sys.platform + args=" ".join(sys.argv) + wafver=Context.WAFVERSION + abi=Context.ABI + self.to_log(conf_template%vars()) + self.msg('Setting top to',self.srcnode.abspath()) + self.msg('Setting out to',self.bldnode.abspath()) + if id(self.srcnode)==id(self.bldnode): + Logs.warn('Setting top == out (remember to use "update_outputs")') + elif id(self.path)!=id(self.srcnode): + if self.srcnode.is_child_of(self.path): + Logs.warn('Are you certain that you do not want to set top="." ?') + super(ConfigurationContext,self).execute() + self.store() + Context.top_dir=self.srcnode.abspath() + Context.out_dir=self.bldnode.abspath() + env=ConfigSet.ConfigSet() + env['argv']=sys.argv + env['options']=Options.options.__dict__ + env.run_dir=Context.run_dir + env.top_dir=Context.top_dir + env.out_dir=Context.out_dir + env['hash']=self.hash + env['files']=self.files + env['environ']=dict(self.environ) + if not self.env.NO_LOCK_IN_RUN: + env.store(Context.run_dir+os.sep+Options.lockfile) + if not self.env.NO_LOCK_IN_TOP: + env.store(Context.top_dir+os.sep+Options.lockfile) + if not self.env.NO_LOCK_IN_OUT: + env.store(Context.out_dir+os.sep+Options.lockfile) + def prepare_env(self,env): + if not env.PREFIX: + if Options.options.prefix or Utils.is_win32: + env.PREFIX=os.path.abspath(os.path.expanduser(Options.options.prefix)) + else: + env.PREFIX='' + if not env.BINDIR: + env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env) + if not env.LIBDIR: + env.LIBDIR=Utils.subst_vars('${PREFIX}/lib',env) + def store(self): + n=self.cachedir.make_node('build.config.py') + n.write('version = 0x%x\ntools = %r\n'%(Context.HEXVERSION,self.tools)) + if not self.all_envs: + self.fatal('nothing to store in the configuration context!') + for key in self.all_envs: + tmpenv=self.all_envs[key] + tmpenv.store(os.path.join(self.cachedir.abspath(),key+Build.CACHE_SUFFIX)) + def load(self,input,tooldir=None,funs=None,download=True): + tools=Utils.to_list(input) + if tooldir:tooldir=Utils.to_list(tooldir) + for tool in tools: + mag=(tool,id(self.env),funs) + if mag in self.tool_cache: + self.to_log('(tool %s is already loaded, skipping)'%tool) + continue + self.tool_cache.append(mag) + module=None + try: + module=Context.load_tool(tool,tooldir) + except ImportError ,e: + if Options.options.download: + module=download_tool(tool,ctx=self) + if not module: + self.fatal('Could not load the Waf tool %r or download a suitable replacement from the repository (sys.path %r)\n%s'%(tool,sys.path,e)) + else: + self.fatal('Could not load the Waf tool %r from %r (try the --download option?):\n%s'%(tool,sys.path,e)) + except Exception ,e: + self.to_log('imp %r (%r & %r)'%(tool,tooldir,funs)) + self.to_log(Utils.ex_stack()) + raise + if funs is not None: + self.eval_rules(funs) + else: + func=getattr(module,'configure',None) + if func: + if type(func)is type(Utils.readf):func(self) + else:self.eval_rules(func) + self.tools.append({'tool':tool,'tooldir':tooldir,'funs':funs}) + def post_recurse(self,node): + super(ConfigurationContext,self).post_recurse(node) + self.hash=hash((self.hash,node.read('rb'))) + self.files.append(node.abspath()) + def eval_rules(self,rules): + self.rules=Utils.to_list(rules) + for x in self.rules: + f=getattr(self,x) + if not f:self.fatal("No such method '%s'."%x) + try: + f() + except Exception ,e: + ret=self.err_handler(x,e) + if ret==BREAK: + break + elif ret==CONTINUE: + continue + else: + raise + def err_handler(self,fun,error): + pass +def conf(f): + def fun(*k,**kw): + mandatory=True + if'mandatory'in kw: + mandatory=kw['mandatory'] + del kw['mandatory'] + try: + return f(*k,**kw) + except Errors.ConfigurationError: + if mandatory: + raise + setattr(ConfigurationContext,f.__name__,fun) + setattr(Build.BuildContext,f.__name__,fun) + return f +@conf +def add_os_flags(self,var,dest=None): + try:self.env.append_value(dest or var,shlex.split(self.environ[var])) + except KeyError:pass +@conf +def cmd_to_list(self,cmd): + if isinstance(cmd,str)and cmd.find(' '): + try: + os.stat(cmd) + except OSError: + return shlex.split(cmd) + else: + return[cmd] + return cmd +@conf +def check_waf_version(self,mini='1.6.99',maxi='1.8.0'): + self.start_msg('Checking for waf version in %s-%s'%(str(mini),str(maxi))) + ver=Context.HEXVERSION + if Utils.num2ver(mini)>ver: + self.fatal('waf version should be at least %r (%r found)'%(Utils.num2ver(mini),ver)) + if Utils.num2ver(maxi) %r'%(filename,path_list,var,ret)) + if not ret: + self.fatal(kw.get('errmsg','')or'Could not find the program %s'%','.join(filename)) + if var: + self.env[var]=ret + return ret +@conf +def find_perl_program(self,filename,path_list=[],var=None,environ=None,exts=''): + try: + app=self.find_program(filename,path_list=path_list,var=var,environ=environ,exts=exts) + except Exception: + self.find_program('perl',var='PERL') + app=self.find_file(filename,os.environ['PATH'].split(os.pathsep)) + if not app: + raise + if var: + self.env[var]=Utils.to_list(self.env['PERL'])+[app] + self.msg('Checking for %r'%filename,app) diff --git a/waflib/Configure.pyc b/waflib/Configure.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b564532cd184bf246b7823f0248327e3660ea011 GIT binary patch literal 14623 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 DNxKFk zk0B}fa!~UO!~FqqW#mdEh7Bf0d>}W0Y`T5%q5NXx3>Mg~$yFfb4K3U^;#au5nV+0g zhXe6-9xgNP4sk>ezP=H^D#JDL>oRQ6fq=O;J6sbShFuNjwA#@9Kw3uuo(W3BP1SGF z2sSu2J9&?sD|Wp+01@?AWH4)QLjbo7xMmeeC;{<)zbb*^4yJCxgOoyNKxT_#H{l@pu5gAx8u&V zEQU7qu9KYi^I|3seoh9D4iAnF4!e)K*4m`secb=-sNe0TPy6=M$NeWZeUc`h*r(mY z4s1txzoTw&2h&TX6N60d<9HR1b4@X3wN_JO^=Va*;mrj&akV zowT{#Ytta&-ISLqqa7@lON{{H7}1U62bemd64Prl`ZL~>WNhPDLmkKCB0C>($*A;- ziH+`K6753V0bf>NG$ZSHv?H3j+1^r=$LIMdd%IPT)-es=hp1WwDmoLnMRN=QIiDL9yb8pV$=d9y_f14fiV4OyxvcZ0jlV@o(%Kt6G=oWfK;dA77!!dv#TDhn8P z&3)Cydg#uZOUQ5q_byPVBbnKn$E30Fz_(bSW1ShfHgeHb?jm2mY|Ax#fkuby7P$`P zDwJ}U&Z3Xt9V6!TuHgFu?HKOD4s<74+&xE+Xuw*7Bp=z#u{s*st)qvSMtcxws3OU9 zYA0F5daAb7ZNxW1>)@|D|&}Qi-p#A_?A{I zj4vD4tXMWfPc+Yp$sj*FFOx;*PodR|kkMBsdnJSSA{xyi$L8|u0 k?28z+s71kZ%TF79qkUez!@kfzI7Io-G(^b literal 0 HcmV?d00001 diff --git a/waflib/Logs.py b/waflib/Logs.py new file mode 100644 index 0000000..ef62452 --- /dev/null +++ b/waflib/Logs.py @@ -0,0 +1,177 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re,traceback,sys +_nocolor=os.environ.get('NOCOLOR','no')not in('no','0','false') +try: + if not _nocolor: + import waflib.ansiterm +except ImportError: + pass +try: + import threading +except ImportError: + if not'JOBS'in os.environ: + os.environ['JOBS']='1' +else: + wlock=threading.Lock() + class sync_stream(object): + def __init__(self,stream): + self.stream=stream + self.encoding=self.stream.encoding + def write(self,txt): + try: + wlock.acquire() + self.stream.write(txt) + self.stream.flush() + finally: + wlock.release() + def fileno(self): + return self.stream.fileno() + def flush(self): + self.stream.flush() + def isatty(self): + return self.stream.isatty() + if not os.environ.get('NOSYNC',False): + if id(sys.stdout)==id(sys.__stdout__): + sys.stdout=sync_stream(sys.stdout) + sys.stderr=sync_stream(sys.stderr) +import logging +LOG_FORMAT="%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s" +HOUR_FORMAT="%H:%M:%S" +zones='' +verbose=0 +colors_lst={'USE':True,'BOLD':'\x1b[01;1m','RED':'\x1b[01;31m','GREEN':'\x1b[32m','YELLOW':'\x1b[33m','PINK':'\x1b[35m','BLUE':'\x1b[01;34m','CYAN':'\x1b[36m','NORMAL':'\x1b[0m','cursor_on':'\x1b[?25h','cursor_off':'\x1b[?25l',} +got_tty=not os.environ.get('TERM','dumb')in['dumb','emacs'] +if got_tty: + try: + got_tty=sys.stderr.isatty()and sys.stdout.isatty() + except AttributeError: + got_tty=False +if(not got_tty and os.environ.get('TERM','dumb')!='msys')or _nocolor: + colors_lst['USE']=False +def get_term_cols(): + return 80 +try: + import struct,fcntl,termios +except ImportError: + pass +else: + if got_tty: + def get_term_cols_real(): + dummy_lines,cols=struct.unpack("HHHH",fcntl.ioctl(sys.stderr.fileno(),termios.TIOCGWINSZ,struct.pack("HHHH",0,0,0,0)))[:2] + return cols + try: + get_term_cols_real() + except Exception: + pass + else: + get_term_cols=get_term_cols_real +get_term_cols.__doc__=""" + Get the console width in characters. + + :return: the number of characters per line + :rtype: int + """ +def get_color(cl): + if not colors_lst['USE']:return'' + return colors_lst.get(cl,'') +class color_dict(object): + def __getattr__(self,a): + return get_color(a) + def __call__(self,a): + return get_color(a) +colors=color_dict() +re_log=re.compile(r'(\w+): (.*)',re.M) +class log_filter(logging.Filter): + def __init__(self,name=None): + pass + def filter(self,rec): + rec.c1=colors.PINK + rec.c2=colors.NORMAL + rec.zone=rec.module + if rec.levelno>=logging.INFO: + if rec.levelno>=logging.ERROR: + rec.c1=colors.RED + elif rec.levelno>=logging.WARNING: + rec.c1=colors.YELLOW + else: + rec.c1=colors.GREEN + return True + m=re_log.match(rec.msg) + if m: + rec.zone=m.group(1) + rec.msg=m.group(2) + if zones: + return getattr(rec,'zone','')in zones or'*'in zones + elif not verbose>2: + return False + return True +class formatter(logging.Formatter): + def __init__(self): + logging.Formatter.__init__(self,LOG_FORMAT,HOUR_FORMAT) + def format(self,rec): + if rec.levelno>=logging.WARNING or rec.levelno==logging.INFO: + try: + msg=rec.msg.decode('utf-8') + except Exception: + msg=rec.msg + return'%s%s%s'%(rec.c1,msg,rec.c2) + return logging.Formatter.format(self,rec) +log=None +def debug(*k,**kw): + if verbose: + k=list(k) + k[0]=k[0].replace('\n',' ') + global log + log.debug(*k,**kw) +def error(*k,**kw): + global log + log.error(*k,**kw) + if verbose>2: + st=traceback.extract_stack() + if st: + st=st[:-1] + buf=[] + for filename,lineno,name,line in st: + buf.append(' File "%s", line %d, in %s'%(filename,lineno,name)) + if line: + buf.append(' %s'%line.strip()) + if buf:log.error("\n".join(buf)) +def warn(*k,**kw): + global log + log.warn(*k,**kw) +def info(*k,**kw): + global log + log.info(*k,**kw) +def init_log(): + global log + log=logging.getLogger('waflib') + log.handlers=[] + log.filters=[] + hdlr=logging.StreamHandler() + hdlr.setFormatter(formatter()) + log.addHandler(hdlr) + log.addFilter(log_filter()) + log.setLevel(logging.DEBUG) +def make_logger(path,name): + logger=logging.getLogger(name) + hdlr=logging.FileHandler(path,'w') + formatter=logging.Formatter('%(message)s') + hdlr.setFormatter(formatter) + logger.addHandler(hdlr) + logger.setLevel(logging.DEBUG) + return logger +def make_mem_logger(name,to_log,size=10000): + from logging.handlers import MemoryHandler + logger=logging.getLogger(name) + hdlr=MemoryHandler(size,target=to_log) + formatter=logging.Formatter('%(message)s') + hdlr.setFormatter(formatter) + logger.addHandler(hdlr) + logger.memhandler=hdlr + logger.setLevel(logging.DEBUG) + return logger +def pprint(col,str,label='',sep='\n'): + sys.stderr.write("%s%s%s %s%s"%(colors(col),str,colors.NORMAL,label,sep)) diff --git a/waflib/Logs.pyc b/waflib/Logs.pyc new file mode 100644 index 0000000000000000000000000000000000000000..141b619304cbdc9fdd12c27db5a6ca5f21838394 GIT binary patch literal 9978 zcmc&)+i%9 zxNCrQ>BBH=0|sobd))IL25jiV9`>?7X23RJf57(p9g32gVL&$^j%^-(mqUKvxu5UQ z`G4*z|NgH(vpwnl4CDSGuK3q^5g&h+v_$H?wk35d8_!8Sm$ma!&x;XRE6CcA_!!U2 zGr;#`eTUSGvUNmEQDQH{$KbF8B1^%T6ii9h%MxvhWm$nG54J`#w6fI8z&X>y`I zvAY!B9nD()j&2v@S02w=!H?vDDa+bUd4{czh(9c5mn>u7CHYD?_^`fvV6$a0d$`$n z)-t1F^0GE2&n)S-_p-g7<3a{c^=9+pj7fK7pW&IlP znu+x_slS%BD^dp;K!c{eF7?;Hp%Opk7J^HVC$|6RoPS(jH6dHz-2^GHQU!WLH~dFp zKmK#>0p_qC*FGWUm^j$xJNo3L_$M=EIMq{zx5T`qy7IOdOV+T>DQz4l2kR%qKP_gz zti7W;bf)*%N%5z3;*?ID?M+OP8260$GrH)s_~*27R{ZnYm=XViHqMEEQ5)yQzod-| z;$IejR=$FzU8KJF?}~p#zQRT>@wJQ94`80nf8nQ=>_D@&aD8EZ!A^2$2Vr92b|x7D zTy|TrNeXCvXW`nSPE02|(T%qP&xw=BxNQ$z{o!NRaK+~VAm7x=DK{9gr8~>htT|Gk zakBwKFKDAE_F|Q5dfY{JUFZ8=0rHD#X;?td`X`k*y;hOQ1__VvxXog)lwdpROnx48i zH9d1`#u(!^X3jP)U2M$Ec$XXI!r8_-nvK)*;YvK!+0v~zPBUmG zj! zR^BRGqt;l?qoA`(xkbdDMu1xx_0)xwPV!;7*)l<>YN8}hf58iXqED%9i?0;r*5vcu=uccJwA!)$*LQB zNwaN^$Cb&dH+?*wtbQH_=%RO42iqo&-4%?)!+hZO?Bw0q$wl}ML;?ae^ZSc)F_|;| z$(iYQr`ziJuPw~q&}VdT2BUNc_S}t_-g^9#nX_$mA-C+gxmq?h)7C9MoSUCtSjq;^ zr!V~IPVKt`FFe;>X8!(MhIkoBK=y2sV$Xj^F_z5hT`%j1%zlYr~3A zB6SGKy}xG&Bx%;2m&&7@JQaD0P|KWwyr?O!ZsSLFrb)I`X)IaX-S84^ZUh|{QAcwK zFGyP2YK9(Kd7y*Y-6wn#MQUUkd`Mn1j8%B|?krrtwRESpSl31QzBG!HOh~Z3<+PfC zNySH&^d@z@&Hn$gAo!;++?d`X7Q4wTQkJXang( zvPa_G6fLbhO_Q$5y9^BMJ>FRP{T z>LQv02@z-9?c@bD-f_SUgwV)wzK3pR``mqY{ZCZbm+|Cw5;3eqcy6oZIE#G>)UVi# zarS%POyVSedudq+0@uuz9dhN4{lBS?GBZ)@Dmif%Ia3*I~2Gv`^SytD$Q@gpK zL3Pfy7i{}ThQD;xuHC8Kvd1xC(+w*2y=cSe>m%dfE&5>FO}th0^6fYsS&71pj?R&S zSl8@29c_PRqDF{%0HgX%Rt8j^`-j8`XJ&Guy^WfxRHgQa3Zukt0f;rCzk98{)*fED z5vzcE5!V603CtF(npPY7o<|u~qv)vo_C0_;9oyuBu3*t6TwND5lGFTlIgB8zL61W& ztH=2^fsV+$dbX=-p(z0h3pjd02|zrQe(>l?A=`5Rx`mtB7L+;a2MSd% z8`2{i5n4^;-t_j7>9kzWsE5vcwr?66-C8E!u&z;LeY4NB7cW#7>;4dzp5O)Ebi_KE zQ=ScDl*Xn!`x6@7{Gi7N>=qnD0FAz;&jF8~;dlwQAzFV;2u4=WU%_Zzp4{WmjqlIP zBiI@KhU95cp2EiPD9XmjHo#=$8AUZV2*vsW-*V=%c}(J*s|VhLoP0bd_*=r$(I2{7 zLu{wbLUw6s_3i5YfVdwok$n;MLaMDq0OSQzJvYk)E4Nye2FV&4kWozjmt%p zbBopy>nPwct0<~H%!kN9)t>!mJg+@!LgZ~)=}&n}i`jIeAU&P+__CcO(s{tjyKyHq zh5w(JX0RN-L}C~~fB76SW z7BCPVQ!lEWk|3QJnB1w4kI*L5e1vP)RGZVUDplG{KQ%#yI*-KIM5#v5?pEEvZ=tZF zel$%EW3{wJ{W5erolZu8igdQ0+b|YrZsYoXhD38k7iNzH%)UYlE`jIfnVPGO-k7^~ z|5jQkp+c_ut!NuHQ1_$XmJlX>#l4LJNNx|lFO^_$qlmbp>6a!Zbu=;+4>b?ebl78T&KL*qa1f1fK(FxKv-(ag){5v(aUOcIp5_lTA5prvR9^wcT|+ zTVWHwLARUp=8kg`ZkVyWIw|@6-C8B@(>mg`&xJlxQslUMuPa3rW(q1M#t_a zKnszO2>6DoazIo>7^EZ+?8td!t~#V03>U;fl*1^BzId*bVWr<&YZ~2B?WJYiHSI9k z%G95%P231Z_8$Ud&W59R?_4^y+BG}-#~4g=Sc>*JQL2HpO}mRdAX&1dFVG~^qbm6n zH$OM&OMgU^mm=dmSXpI^t#f0L^KZGey#NCH>PxzWUYZ1W+&nK*roujhMrw1+8&RCk zq>NOtn>ND!^0GW6nzZ;#MAQMM?AL<=k`0^|Xv_9Vf>Q+Q6hCB(B?ZkjHFZSILGQ>T z)K|6K2D}!vFgBg-G!kl3rxT%Q{W~sBqQpv%D2y;R2W;*u4S#R2`zE_AR6=i&rpJ22 z7i_~x(ykuf1fMk{9EA9P2kH!+Ako5XgvHQCS>>{ux)G=29OS!zodm+bfta)pvwo63>(EP!n5~@Z=4jc2h: + lst.append(c1.name) + c1=c1.parent + c1h-=1 + while c2h>c1h: + up+=1 + c2=c2.parent + c2h-=1 + while id(c1)!=id(c2): + lst.append(c1.name) + up+=1 + c1=c1.parent + c2=c2.parent + for i in range(up): + lst.append('..') + lst.reverse() + return os.sep.join(lst)or'.' + def abspath(self): + try: + return self.cache_abspath + except AttributeError: + pass + if os.sep=='/': + if not self.parent: + val=os.sep + elif not self.parent.name: + val=os.sep+self.name + else: + val=self.parent.abspath()+os.sep+self.name + else: + if not self.parent: + val='' + elif not self.parent.name: + val=self.name+os.sep + else: + val=self.parent.abspath().rstrip(os.sep)+os.sep+self.name + self.cache_abspath=val + return val + def is_child_of(self,node): + p=self + diff=self.height()-node.height() + while diff>0: + diff-=1 + p=p.parent + return id(p)==id(node) + def ant_iter(self,accept=None,maxdepth=25,pats=[],dir=False,src=True,remove=True): + dircont=self.listdir() + dircont.sort() + try: + lst=set(self.children.keys()) + except AttributeError: + self.children={} + else: + if remove: + for x in lst-set(dircont): + self.children[x].evict() + for name in dircont: + npats=accept(name,pats) + if npats and npats[0]: + accepted=[]in npats[0] + node=self.make_node([name]) + isdir=os.path.isdir(node.abspath()) + if accepted: + if isdir: + if dir: + yield node + else: + if src: + yield node + if getattr(node,'cache_isdir',None)or isdir: + node.cache_isdir=True + if maxdepth: + for k in node.ant_iter(accept=accept,maxdepth=maxdepth-1,pats=npats,dir=dir,src=src,remove=remove): + yield k + raise StopIteration + def ant_glob(self,*k,**kw): + src=kw.get('src',True) + dir=kw.get('dir',False) + excl=kw.get('excl',exclude_regs) + incl=k and k[0]or kw.get('incl','**') + reflags=kw.get('ignorecase',0)and re.I + def to_pat(s): + lst=Utils.to_list(s) + ret=[] + for x in lst: + x=x.replace('\\','/').replace('//','/') + if x.endswith('/'): + x+='**' + lst2=x.split('/') + accu=[] + for k in lst2: + if k=='**': + accu.append(k) + else: + k=k.replace('.','[.]').replace('*','.*').replace('?','.').replace('+','\\+') + k='^%s$'%k + try: + accu.append(re.compile(k,flags=reflags)) + except Exception ,e: + raise Errors.WafError("Invalid pattern: %s"%k,e) + ret.append(accu) + return ret + def filtre(name,nn): + ret=[] + for lst in nn: + if not lst: + pass + elif lst[0]=='**': + ret.append(lst) + if len(lst)>1: + if lst[1].match(name): + ret.append(lst[2:]) + else: + ret.append([]) + elif lst[0].match(name): + ret.append(lst[1:]) + return ret + def accept(name,pats): + nacc=filtre(name,pats[0]) + nrej=filtre(name,pats[1]) + if[]in nrej: + nacc=[] + return[nacc,nrej] + ret=[x for x in self.ant_iter(accept=accept,pats=[to_pat(incl),to_pat(excl)],maxdepth=kw.get('maxdepth',25),dir=dir,src=src,remove=kw.get('remove',True))] + if kw.get('flat',False): + return' '.join([x.path_from(self)for x in ret]) + return ret + def is_src(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==y: + return False + if id(cur)==x: + return True + cur=cur.parent + return False + def is_bld(self): + cur=self + y=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==y: + return True + cur=cur.parent + return False + def get_src(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + lst=[] + while cur.parent: + if id(cur)==y: + lst.reverse() + return self.ctx.srcnode.make_node(lst) + if id(cur)==x: + return self + lst.append(cur.name) + cur=cur.parent + return self + def get_bld(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + lst=[] + while cur.parent: + if id(cur)==y: + return self + if id(cur)==x: + lst.reverse() + return self.ctx.bldnode.make_node(lst) + lst.append(cur.name) + cur=cur.parent + lst.reverse() + if lst and Utils.is_win32 and len(lst[0])==2 and lst[0].endswith(':'): + lst[0]=lst[0][0] + return self.ctx.bldnode.make_node(['__root__']+lst) + def find_resource(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.get_bld().search_node(lst) + if not node: + self=self.get_src() + node=self.find_node(lst) + if node: + if os.path.isdir(node.abspath()): + return None + return node + def find_or_declare(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.get_bld().search_node(lst) + if node: + if not os.path.isfile(node.abspath()): + node.sig=None + node.parent.mkdir() + return node + self=self.get_src() + node=self.find_node(lst) + if node: + if not os.path.isfile(node.abspath()): + node.sig=None + node.parent.mkdir() + return node + node=self.get_bld().make_node(lst) + node.parent.mkdir() + return node + def find_dir(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.find_node(lst) + try: + if not os.path.isdir(node.abspath()): + return None + except(OSError,AttributeError): + return None + return node + def change_ext(self,ext,ext_in=None): + name=self.name + if ext_in is None: + k=name.rfind('.') + if k>=0: + name=name[:k]+ext + else: + name=name+ext + else: + name=name[:-len(ext_in)]+ext + return self.parent.find_or_declare([name]) + def nice_path(self,env=None): + return self.path_from(self.ctx.launch_node()) + def bldpath(self): + return self.path_from(self.ctx.bldnode) + def srcpath(self): + return self.path_from(self.ctx.srcnode) + def relpath(self): + cur=self + x=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==x: + return self.bldpath() + cur=cur.parent + return self.srcpath() + def bld_dir(self): + return self.parent.bldpath() + def bld_base(self): + s=os.path.splitext(self.name)[0] + return self.bld_dir()+os.sep+s + def get_bld_sig(self): + try: + return self.cache_sig + except AttributeError: + pass + if not self.is_bld()or self.ctx.bldnode is self.ctx.srcnode: + self.sig=Utils.h_file(self.abspath()) + self.cache_sig=ret=self.sig + return ret + search=search_node +pickle_lock=Utils.threading.Lock() +class Nod3(Node): + pass diff --git a/waflib/Node.pyc b/waflib/Node.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a2fadc1aa389aeef70f83996c6af658d5934e13 GIT binary patch literal 19366 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 literal 0 HcmV?d00001 diff --git a/waflib/Options.py b/waflib/Options.py new file mode 100644 index 0000000..21f4254 --- /dev/null +++ b/waflib/Options.py @@ -0,0 +1,135 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,tempfile,optparse,sys,re +from waflib import Logs,Utils,Context +cmds='distclean configure build install clean uninstall check dist distcheck'.split() +options={} +commands=[] +lockfile=os.environ.get('WAFLOCK','.lock-waf_%s_build'%sys.platform) +try:cache_global=os.path.abspath(os.environ['WAFCACHE']) +except KeyError:cache_global='' +platform=Utils.unversioned_sys_platform() +class opt_parser(optparse.OptionParser): + def __init__(self,ctx): + optparse.OptionParser.__init__(self,conflict_handler="resolve",version='waf %s (%s)'%(Context.WAFVERSION,Context.WAFREVISION)) + self.formatter.width=Logs.get_term_cols() + p=self.add_option + self.ctx=ctx + jobs=ctx.jobs() + p('-j','--jobs',dest='jobs',default=jobs,type='int',help='amount of parallel jobs (%r)'%jobs) + p('-k','--keep',dest='keep',default=0,action='count',help='keep running happily even if errors are found') + p('-v','--verbose',dest='verbose',default=0,action='count',help='verbosity level -v -vv or -vvv [default: 0]') + p('--nocache',dest='nocache',default=False,action='store_true',help='ignore the WAFCACHE (if set)') + p('--zones',dest='zones',default='',action='store',help='debugging zones (task_gen, deps, tasks, etc)') + gr=optparse.OptionGroup(self,'configure options') + self.add_option_group(gr) + gr.add_option('-o','--out',action='store',default='',help='build dir for the project',dest='out') + gr.add_option('-t','--top',action='store',default='',help='src dir for the project',dest='top') + default_prefix=os.environ.get('PREFIX') + if not default_prefix: + if platform=='win32': + d=tempfile.gettempdir() + default_prefix=d[0].upper()+d[1:] + else: + default_prefix='/usr/local/' + gr.add_option('--prefix',dest='prefix',default=default_prefix,help='installation prefix [default: %r]'%default_prefix) + gr.add_option('--download',dest='download',default=False,action='store_true',help='try to download the tools if missing') + gr=optparse.OptionGroup(self,'build and install options') + self.add_option_group(gr) + gr.add_option('-p','--progress',dest='progress_bar',default=0,action='count',help='-p: progress bar; -pp: ide output') + gr.add_option('--targets',dest='targets',default='',action='store',help='task generators, e.g. "target1,target2"') + gr=optparse.OptionGroup(self,'step options') + self.add_option_group(gr) + gr.add_option('--files',dest='files',default='',action='store',help='files to process, by regexp, e.g. "*/main.c,*/test/main.o"') + default_destdir=os.environ.get('DESTDIR','') + gr=optparse.OptionGroup(self,'install/uninstall options') + self.add_option_group(gr) + gr.add_option('--destdir',help='installation root [default: %r]'%default_destdir,default=default_destdir,dest='destdir') + gr.add_option('-f','--force',dest='force',default=False,action='store_true',help='force file installation') + gr.add_option('--distcheck-args',help='arguments to pass to distcheck',default=None,action='store') + def get_usage(self): + cmds_str={} + for cls in Context.classes: + if not cls.cmd or cls.cmd=='options': + continue + s=cls.__doc__ or'' + cmds_str[cls.cmd]=s + if Context.g_module: + for(k,v)in Context.g_module.__dict__.items(): + if k in['options','init','shutdown']: + continue + if type(v)is type(Context.create_context): + if v.__doc__ and not k.startswith('_'): + cmds_str[k]=v.__doc__ + just=0 + for k in cmds_str: + just=max(just,len(k)) + lst=[' %s: %s'%(k.ljust(just),v)for(k,v)in cmds_str.items()] + lst.sort() + ret='\n'.join(lst) + return'''waf [commands] [options] + +Main commands (example: ./waf build -j4) +%s +'''%ret +class OptionsContext(Context.Context): + cmd='options' + fun='options' + def __init__(self,**kw): + super(OptionsContext,self).__init__(**kw) + self.parser=opt_parser(self) + self.option_groups={} + def jobs(self): + count=int(os.environ.get('JOBS',0)) + if count<1: + if'NUMBER_OF_PROCESSORS'in os.environ: + count=int(os.environ.get('NUMBER_OF_PROCESSORS',1)) + else: + if hasattr(os,'sysconf_names'): + if'SC_NPROCESSORS_ONLN'in os.sysconf_names: + count=int(os.sysconf('SC_NPROCESSORS_ONLN')) + elif'SC_NPROCESSORS_CONF'in os.sysconf_names: + count=int(os.sysconf('SC_NPROCESSORS_CONF')) + if not count and os.name not in('nt','java'): + try: + tmp=self.cmd_and_log(['sysctl','-n','hw.ncpu'],quiet=0) + except Exception: + pass + else: + if re.match('^[0-9]+$',tmp): + count=int(tmp) + if count<1: + count=1 + elif count>1024: + count=1024 + return count + def add_option(self,*k,**kw): + return self.parser.add_option(*k,**kw) + def add_option_group(self,*k,**kw): + try: + gr=self.option_groups[k[0]] + except KeyError: + gr=self.parser.add_option_group(*k,**kw) + self.option_groups[k[0]]=gr + return gr + def get_option_group(self,opt_str): + try: + return self.option_groups[opt_str] + except KeyError: + for group in self.parser.option_groups: + if group.title==opt_str: + return group + return None + def parse_args(self,_args=None): + global options,commands + (options,leftover_args)=self.parser.parse_args(args=_args) + commands=leftover_args + if options.destdir: + options.destdir=os.path.abspath(os.path.expanduser(options.destdir)) + if options.verbose>=1: + self.load('errcheck') + def execute(self): + super(OptionsContext,self).execute() + self.parse_args() diff --git a/waflib/Options.pyc b/waflib/Options.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35466fc7efba2e38e02a59247d1ae540ea72bff1 GIT binary patch literal 7862 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 literal 0 HcmV?d00001 diff --git a/waflib/Runner.py b/waflib/Runner.py new file mode 100644 index 0000000..15b6a27 --- /dev/null +++ b/waflib/Runner.py @@ -0,0 +1,197 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import random,atexit +try: + from queue import Queue +except ImportError: + from Queue import Queue +from waflib import Utils,Task,Errors,Logs +GAP=10 +class TaskConsumer(Utils.threading.Thread): + def __init__(self): + Utils.threading.Thread.__init__(self) + self.ready=Queue() + self.setDaemon(1) + self.start() + def run(self): + try: + self.loop() + except Exception: + pass + def loop(self): + while 1: + tsk=self.ready.get() + if not isinstance(tsk,Task.TaskBase): + tsk(self) + else: + tsk.process() +pool=Queue() +def get_pool(): + try: + return pool.get(False) + except Exception: + return TaskConsumer() +def put_pool(x): + pool.put(x) +def _free_resources(): + global pool + lst=[] + while pool.qsize(): + lst.append(pool.get()) + for x in lst: + x.ready.put(None) + for x in lst: + x.join() + pool=None +atexit.register(_free_resources) +class Parallel(object): + def __init__(self,bld,j=2): + self.numjobs=j + self.bld=bld + self.outstanding=[] + self.frozen=[] + self.out=Queue(0) + self.count=0 + self.processed=1 + self.stop=False + self.error=[] + self.biter=None + self.dirty=False + def get_next_task(self): + if not self.outstanding: + return None + return self.outstanding.pop(0) + def postpone(self,tsk): + if random.randint(0,1): + self.frozen.insert(0,tsk) + else: + self.frozen.append(tsk) + def refill_task_list(self): + while self.count>self.numjobs*GAP: + self.get_out() + while not self.outstanding: + if self.count: + self.get_out() + elif self.frozen: + try: + cond=self.deadlock==self.processed + except AttributeError: + pass + else: + if cond: + msg='check the build order for the tasks' + for tsk in self.frozen: + if not tsk.run_after: + msg='check the methods runnable_status' + break + lst=[] + for tsk in self.frozen: + lst.append('%s\t-> %r'%(repr(tsk),[id(x)for x in tsk.run_after])) + raise Errors.WafError('Deadlock detected: %s%s'%(msg,''.join(lst))) + self.deadlock=self.processed + if self.frozen: + self.outstanding+=self.frozen + self.frozen=[] + elif not self.count: + self.outstanding.extend(self.biter.next()) + self.total=self.bld.total() + break + def add_more_tasks(self,tsk): + if getattr(tsk,'more_tasks',None): + self.outstanding+=tsk.more_tasks + self.total+=len(tsk.more_tasks) + def get_out(self): + tsk=self.out.get() + if not self.stop: + self.add_more_tasks(tsk) + self.count-=1 + self.dirty=True + return tsk + def error_handler(self,tsk): + if not self.bld.keep: + self.stop=True + self.error.append(tsk) + def add_task(self,tsk): + try: + self.pool + except AttributeError: + self.init_task_pool() + self.ready.put(tsk) + def init_task_pool(self): + pool=self.pool=[get_pool()for i in range(self.numjobs)] + self.ready=Queue(0) + def setq(consumer): + consumer.ready=self.ready + for x in pool: + x.ready.put(setq) + return pool + def free_task_pool(self): + def setq(consumer): + consumer.ready=Queue(0) + self.out.put(self) + try: + pool=self.pool + except AttributeError: + pass + else: + for x in pool: + self.ready.put(setq) + for x in pool: + self.get_out() + for x in pool: + put_pool(x) + self.pool=[] + def start(self): + self.total=self.bld.total() + while not self.stop: + self.refill_task_list() + tsk=self.get_next_task() + if not tsk: + if self.count: + continue + else: + break + if tsk.hasrun: + self.processed+=1 + continue + if self.stop: + break + try: + st=tsk.runnable_status() + except Exception: + self.processed+=1 + tsk.err_msg=Utils.ex_stack() + if not self.stop and self.bld.keep: + tsk.hasrun=Task.SKIPPED + if self.bld.keep==1: + if Logs.verbose>1 or not self.error: + self.error.append(tsk) + self.stop=True + else: + if Logs.verbose>1: + self.error.append(tsk) + continue + tsk.hasrun=Task.EXCEPTION + self.error_handler(tsk) + continue + if st==Task.ASK_LATER: + self.postpone(tsk) + elif st==Task.SKIP_ME: + self.processed+=1 + tsk.hasrun=Task.SKIPPED + self.add_more_tasks(tsk) + else: + tsk.position=(self.processed,self.total) + self.count+=1 + tsk.master=self + self.processed+=1 + if self.numjobs==1: + tsk.process() + else: + self.add_task(tsk) + while self.error and self.count: + self.get_out() + assert(self.count==0 or self.stop) + self.free_task_pool() diff --git a/waflib/Runner.pyc b/waflib/Runner.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90218c3d8cb2f571e0ddb6da5681d7c0af78bd67 GIT binary patch literal 8520 zcmc&(Npl;=6@EQfNKmA>h}tY!rZyX~EwLopmhE_nL^8H)i>8NiQDK#g!qTJw0vKR= zkdU@?u~J#8a#H1xOa4KQx#y4{;>tOdQ+`15eXnOgSiVD)rqRpmp7&mV{g$5Ge`lut z{_j79bxHpU`27VQ_XCOs{u^nF>QEr?qQ`X{!Qg$Y#Q<9yMm_}Z9rle62Ta?x@X-&(nkw#H| zEAmw2S35IebF5X5OJjn)JG0W5)XJPRN?Ms0YoxUxc3z$uEIB3igf4SzxD5C=vQ?gj zjLrYyZ=-BbO(^_V13R$geAfIrX|`R$=KZSMPl~9l$8i+5!guhv%P1@uhCHHt24sRFb_Gnd@vcxng+|MaWuGV(}=p)kd?sr=s20Rzi|WrP*yJ zl}d=Z*9-{{b&|8mTGe)FB)j07A%!Ah1_HLPzv~b^`w*0lTv0LsnZD+X`M=e`V z+;VkLYes2#{WsO!Yd5anx_)Ej+KRQdT3fkUd-qmtWu^XJ&AxN9_Li-`Rj*BQ!Mp?D!{9ts6j)4L!fMw3Hwmt!u9uTk`VMw*X&~R zyLB7#)e0M)fjd$-JL6{*Tn{u8%9R;7i+#%Vl`OpD2xS+ihff-;ejV!d1K z*h)pEs#H2rW6(xZffdezN|!idT5ID#HaR5795b-*?S#tvZHkuV=dr1&P{$@FfhZZQO{uRx7Qj+4Uxq zqQGf}=kPmTCG)ISc4KQRv31cPhV`M_1ZQHJsfPdVI zJ9u0dh0WYG9W^2!cx>;eVH|U*$8O}c0*x260uQX=3L={{LYd4Wlu{OZe!IPgmL3_uc zQZ@yw_(i6(p&4)Z`TC6}3h`kB4T2i=?x53(YEBPSt=&kDVIUeLbOggVVmFSywOt=N za3PGVZK+3tZlazvbq%%=p5elI6fS|6CG0E%tdJ*Po3&j zTVsWp`h}Z#tviK6Oey_0JFJzC!jIt=z6?^RzJ+OC#lC@X&hJ8od&i2uT7l z-MOqcuU#-|0HlwCN8v|Ys3nR4v#6s;WVP8%!q>7fgd;#ocmeIBm?K+qk``=;QgCCz(&Nc8SKcDAmgI|cXC#q zARa`ZSQ7V)TZrM!{xiYKuBz>Jzw-t-rt_{uK z>W^%Fe<^unmuiD%yRj6-4I3}*MzQwsWH@&b)JJq3n>>mdZV5qqw^~C~2|Jk#oQ5=4 zUFq6KOIKsZ0A&r?RXf7!4Vxf8vW@qbuDYuZhX}wui6ZeQoPQGVdD6g9ZjIXAr3 z(bU(&=P4A*`yICQ`s1g{;ewj{gnHXX@ai2H?Yib|N2$+?go)Z@o+|Q1|1iAQIHrk> zo+-*g3&6)kDBz1h`v-rl3>^GydLIPE&>hc79v&X!z!1QJGX?0dS&-k0UY`c?JNW&a zFyRb*!U>)$A`6C((rK&@0vF zqTg`@a(QxVlRlF1EMZq;qS*+-&poRSIXp|Q>BTkW8G(sHN}V7DYkHb5NqCeTtH`7o zgGAvMc+aAnFfqqnEa8cbH@!3Z{T zO6o7Gy&dY`@|O_=4=y7-fnH#n{)6X+Xv;N*G<~N5C!sj%6Mu@T%itFf_sGRDM}ka{ zDF>(k&ZBqXAQrvmAK9`p`t)YQLv4d3!`M+9d z=<||rPeVnQ62BOTX|$<#FhjffJ@|r;!k?MV3Rb}@uyo=Gzq^TnKR`Iy+;OS_p zy}j~=!pOntfSm{i-q4Cqjo76y@)uz4p3X#Oa98>#rGHO087m;>DoVW1u{^Q}zyyKT z1SvSGtHuXPdWZ}G)RWu=1^N$gC?(CBnz%~!>Bi9th|ch-3bdG1L58DCO~;?5DOzhr zP={8S(}2RKWFW#V0KPpSF}`GyIcd#n6S-YZCoafzd@8LWIl)W<7_26Xd<8;Ba6URO zKB=!>U@DVRQ+gGTZ^!WP?MM#OBZ*-;McgZbMYy1UlVrT<&;ZVVoqDjkzIp%dmmA^dq%NVjz4dwJi`)0t!|-i( zF%ag8m3!+N04o>0$Tj&*OEbGp)iEKw0>Y5KI=sh%fho2b>p9-AfY>L5w4EdOaf>7) z>n>4iIX08YJIH5zFTXa5CT3Fz74gNy6oWj>gn+Dxkek}}UQ5Mmj zF%uYJ$UTeJTyPSMJC(N9q}yj)-9Lsh5_JcDj_u_oNFbC-4+YlchO-&u|k&{?b3O2Tgx*+vitta?i^h zk-ME<6eo%SrSzX<^{cW%SMLrKv*9g}hdde~!Ka^;d=#WH(|Pt?LZL{E?H;mm0F3le ujo*nwvORunDLWtd4}l-iDLH=dI0O9fMxkG->hx literal 0 HcmV?d00001 diff --git a/waflib/Scripting.py b/waflib/Scripting.py new file mode 100644 index 0000000..fe5c30c --- /dev/null +++ b/waflib/Scripting.py @@ -0,0 +1,373 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shlex,shutil,traceback,errno,sys,stat +from waflib import Utils,Configure,Logs,Options,ConfigSet,Context,Errors,Build,Node +build_dir_override=None +no_climb_commands=['configure'] +default_cmd="build" +def waf_entry_point(current_directory,version,wafdir): + Logs.init_log() + if Context.WAFVERSION!=version: + Logs.error('Waf script %r and library %r do not match (directory %r)'%(version,Context.WAFVERSION,wafdir)) + sys.exit(1) + if'--version'in sys.argv: + Context.run_dir=current_directory + ctx=Context.create_context('options') + ctx.curdir=current_directory + ctx.parse_args() + sys.exit(0) + Context.waf_dir=wafdir + Context.launch_dir=current_directory + no_climb=os.environ.get('NOCLIMB',None) + if not no_climb: + for k in no_climb_commands: + if k in sys.argv: + no_climb=True + break + cur=current_directory + while cur: + lst=os.listdir(cur) + if Options.lockfile in lst: + env=ConfigSet.ConfigSet() + try: + env.load(os.path.join(cur,Options.lockfile)) + ino=os.stat(cur)[stat.ST_INO] + except Exception: + pass + else: + for x in[env.run_dir,env.top_dir,env.out_dir]: + if Utils.is_win32: + if cur==x: + load=True + break + else: + try: + ino2=os.stat(x)[stat.ST_INO] + except OSError: + pass + else: + if ino==ino2: + load=True + break + else: + Logs.warn('invalid lock file in %s'%cur) + load=False + if load: + Context.run_dir=env.run_dir + Context.top_dir=env.top_dir + Context.out_dir=env.out_dir + break + if not Context.run_dir: + if Context.WSCRIPT_FILE in lst: + Context.run_dir=cur + next=os.path.dirname(cur) + if next==cur: + break + cur=next + if no_climb: + break + if not Context.run_dir: + if'-h'in sys.argv or'--help'in sys.argv: + Logs.warn('No wscript file found: the help message may be incomplete') + Context.run_dir=current_directory + ctx=Context.create_context('options') + ctx.curdir=current_directory + ctx.parse_args() + sys.exit(0) + Logs.error('Waf: Run from a directory containing a file named %r'%Context.WSCRIPT_FILE) + sys.exit(1) + try: + os.chdir(Context.run_dir) + except OSError: + Logs.error('Waf: The folder %r is unreadable'%Context.run_dir) + sys.exit(1) + try: + set_main_module(Context.run_dir+os.sep+Context.WSCRIPT_FILE) + except Errors.WafError ,e: + Logs.pprint('RED',e.verbose_msg) + Logs.error(str(e)) + sys.exit(1) + except Exception ,e: + Logs.error('Waf: The wscript in %r is unreadable'%Context.run_dir,e) + traceback.print_exc(file=sys.stdout) + sys.exit(2) + try: + run_commands() + except Errors.WafError ,e: + if Logs.verbose>1: + Logs.pprint('RED',e.verbose_msg) + Logs.error(e.msg) + sys.exit(1) + except SystemExit: + raise + except Exception ,e: + traceback.print_exc(file=sys.stdout) + sys.exit(2) + except KeyboardInterrupt: + Logs.pprint('RED','Interrupted') + sys.exit(68) +def set_main_module(file_path): + Context.g_module=Context.load_module(file_path) + Context.g_module.root_path=file_path + def set_def(obj): + name=obj.__name__ + if not name in Context.g_module.__dict__: + setattr(Context.g_module,name,obj) + for k in[update,dist,distclean,distcheck,update]: + set_def(k) + if not'init'in Context.g_module.__dict__: + Context.g_module.init=Utils.nada + if not'shutdown'in Context.g_module.__dict__: + Context.g_module.shutdown=Utils.nada + if not'options'in Context.g_module.__dict__: + Context.g_module.options=Utils.nada +def parse_options(): + Context.create_context('options').execute() + if not Options.commands: + Options.commands=[default_cmd] + Options.commands=[x for x in Options.commands if x!='options'] + Logs.verbose=Options.options.verbose + Logs.init_log() + if Options.options.zones: + Logs.zones=Options.options.zones.split(',') + if not Logs.verbose: + Logs.verbose=1 + elif Logs.verbose>0: + Logs.zones=['runner'] + if Logs.verbose>2: + Logs.zones=['*'] +def run_command(cmd_name): + ctx=Context.create_context(cmd_name) + ctx.log_timer=Utils.Timer() + ctx.options=Options.options + ctx.cmd=cmd_name + ctx.execute() + return ctx +def run_commands(): + parse_options() + run_command('init') + while Options.commands: + cmd_name=Options.commands.pop(0) + ctx=run_command(cmd_name) + Logs.info('%r finished successfully (%s)'%(cmd_name,str(ctx.log_timer))) + run_command('shutdown') +def _can_distclean(name): + for k in'.o .moc .exe'.split(): + if name.endswith(k): + return True + return False +def distclean_dir(dirname): + for(root,dirs,files)in os.walk(dirname): + for f in files: + if _can_distclean(f): + fname=root+os.sep+f + try: + os.remove(fname) + except OSError: + Logs.warn('Could not remove %r'%fname) + for x in[Context.DBFILE,'config.log']: + try: + os.remove(x) + except OSError: + pass + try: + shutil.rmtree('c4che') + except OSError: + pass +def distclean(ctx): + '''removes the build directory''' + lst=os.listdir('.') + for f in lst: + if f==Options.lockfile: + try: + proj=ConfigSet.ConfigSet(f) + except IOError: + Logs.warn('Could not read %r'%f) + continue + if proj['out_dir']!=proj['top_dir']: + try: + shutil.rmtree(proj['out_dir']) + except IOError: + pass + except OSError ,e: + if e.errno!=errno.ENOENT: + Logs.warn('project %r cannot be removed'%proj[Context.OUT]) + else: + distclean_dir(proj['out_dir']) + for k in(proj['out_dir'],proj['top_dir'],proj['run_dir']): + try: + os.remove(os.path.join(k,Options.lockfile)) + except OSError ,e: + if e.errno!=errno.ENOENT: + Logs.warn('file %r cannot be removed'%f) + if f.startswith('.waf')and not Options.commands: + shutil.rmtree(f,ignore_errors=True) +class Dist(Context.Context): + '''creates an archive containing the project source code''' + cmd='dist' + fun='dist' + algo='tar.bz2' + ext_algo={} + def execute(self): + self.recurse([os.path.dirname(Context.g_module.root_path)]) + self.archive() + def archive(self): + import tarfile + arch_name=self.get_arch_name() + try: + self.base_path + except AttributeError: + self.base_path=self.path + node=self.base_path.make_node(arch_name) + try: + node.delete() + except Exception: + pass + files=self.get_files() + if self.algo.startswith('tar.'): + tar=tarfile.open(arch_name,'w:'+self.algo.replace('tar.','')) + for x in files: + self.add_tar_file(x,tar) + tar.close() + elif self.algo=='zip': + import zipfile + zip=zipfile.ZipFile(arch_name,'w',compression=zipfile.ZIP_DEFLATED) + for x in files: + archive_name=self.get_base_name()+'/'+x.path_from(self.base_path) + zip.write(x.abspath(),archive_name,zipfile.ZIP_DEFLATED) + zip.close() + else: + self.fatal('Valid algo types are tar.bz2, tar.gz or zip') + try: + from hashlib import sha1 as sha + except ImportError: + from sha import sha + try: + digest=" (sha=%r)"%sha(node.read()).hexdigest() + except Exception: + digest='' + Logs.info('New archive created: %s%s'%(self.arch_name,digest)) + def get_tar_path(self,node): + return node.abspath() + def add_tar_file(self,x,tar): + p=self.get_tar_path(x) + tinfo=tar.gettarinfo(name=p,arcname=self.get_tar_prefix()+'/'+x.path_from(self.base_path)) + tinfo.uid=0 + tinfo.gid=0 + tinfo.uname='root' + tinfo.gname='root' + fu=None + try: + fu=open(p,'rb') + tar.addfile(tinfo,fileobj=fu) + finally: + if fu: + fu.close() + def get_tar_prefix(self): + try: + return self.tar_prefix + except AttributeError: + return self.get_base_name() + def get_arch_name(self): + try: + self.arch_name + except AttributeError: + self.arch_name=self.get_base_name()+'.'+self.ext_algo.get(self.algo,self.algo) + return self.arch_name + def get_base_name(self): + try: + self.base_name + except AttributeError: + appname=getattr(Context.g_module,Context.APPNAME,'noname') + version=getattr(Context.g_module,Context.VERSION,'1.0') + self.base_name=appname+'-'+version + return self.base_name + def get_excl(self): + try: + return self.excl + except AttributeError: + self.excl=Node.exclude_regs+' **/waf-1.7.* **/.waf-1.7* **/waf3-1.7.* **/.waf3-1.7* **/*~ **/*.rej **/*.orig **/*.pyc **/*.pyo **/*.bak **/*.swp **/.lock-w*' + nd=self.root.find_node(Context.out_dir) + if nd: + self.excl+=' '+nd.path_from(self.base_path) + return self.excl + def get_files(self): + try: + files=self.files + except AttributeError: + files=self.base_path.ant_glob('**/*',excl=self.get_excl()) + return files +def dist(ctx): + '''makes a tarball for redistributing the sources''' + pass +class DistCheck(Dist): + fun='distcheck' + cmd='distcheck' + def execute(self): + self.recurse([os.path.dirname(Context.g_module.root_path)]) + self.archive() + self.check() + def check(self): + import tempfile,tarfile + t=None + try: + t=tarfile.open(self.get_arch_name()) + for x in t: + t.extract(x) + finally: + if t: + t.close() + cfg=[] + if Options.options.distcheck_args: + cfg=shlex.split(Options.options.distcheck_args) + else: + cfg=[x for x in sys.argv if x.startswith('-')] + instdir=tempfile.mkdtemp('.inst',self.get_base_name()) + ret=Utils.subprocess.Popen([sys.executable,sys.argv[0],'configure','install','uninstall','--destdir='+instdir]+cfg,cwd=self.get_base_name()).wait() + if ret: + raise Errors.WafError('distcheck failed with code %i'%ret) + if os.path.exists(instdir): + raise Errors.WafError('distcheck succeeded, but files were left in %s'%instdir) + shutil.rmtree(self.get_base_name()) +def distcheck(ctx): + '''checks if the project compiles (tarball from 'dist')''' + pass +def update(ctx): + '''updates the plugins from the *waflib/extras* directory''' + lst=Options.options.files.split(',') + if not lst: + lst=[x for x in Utils.listdir(Context.waf_dir+'/waflib/extras')if x.endswith('.py')] + for x in lst: + tool=x.replace('.py','') + try: + Configure.download_tool(tool,force=True,ctx=ctx) + except Errors.WafError: + Logs.error('Could not find the tool %s in the remote repository'%x) +def autoconfigure(execute_method): + def execute(self): + if not Configure.autoconfig: + return execute_method(self) + env=ConfigSet.ConfigSet() + do_config=False + try: + env.load(os.path.join(Context.top_dir,Options.lockfile)) + except Exception: + Logs.warn('Configuring the project') + do_config=True + else: + if env.run_dir!=Context.run_dir: + do_config=True + else: + h=0 + for f in env['files']: + h=hash((h,Utils.readf(f,'rb'))) + do_config=h!=env.hash + if do_config: + Options.commands.insert(0,self.cmd) + Options.commands.insert(0,'configure') + return + return execute_method(self) + return execute +Build.BuildContext.execute=autoconfigure(Build.BuildContext.execute) diff --git a/waflib/Scripting.pyc b/waflib/Scripting.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ed5b891151b73c54fcb333166cc3c4046bdce8f GIT binary patch literal 16156 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 literal 0 HcmV?d00001 diff --git a/waflib/Task.py b/waflib/Task.py new file mode 100644 index 0000000..1b54a54 --- /dev/null +++ b/waflib/Task.py @@ -0,0 +1,677 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shutil,re,tempfile +from waflib import Utils,Logs,Errors +NOT_RUN=0 +MISSING=1 +CRASHED=2 +EXCEPTION=3 +SKIPPED=8 +SUCCESS=9 +ASK_LATER=-1 +SKIP_ME=-2 +RUN_ME=-3 +COMPILE_TEMPLATE_SHELL=''' +def f(tsk): + env = tsk.env + gen = tsk.generator + bld = gen.bld + wd = getattr(tsk, 'cwd', None) + p = env.get_flat + tsk.last_cmd = cmd = \'\'\' %s \'\'\' % s + return tsk.exec_command(cmd, cwd=wd, env=env.env or None) +''' +COMPILE_TEMPLATE_NOSHELL=''' +def f(tsk): + env = tsk.env + gen = tsk.generator + bld = gen.bld + wd = getattr(tsk, 'cwd', None) + def to_list(xx): + if isinstance(xx, str): return [xx] + return xx + tsk.last_cmd = lst = [] + %s + lst = [x for x in lst if x] + return tsk.exec_command(lst, cwd=wd, env=env.env or None) +''' +def cache_outputs(cls): + m1=cls.run + def run(self): + bld=self.generator.bld + if bld.cache_global and not bld.nocache: + if self.can_retrieve_cache(): + return 0 + return m1(self) + cls.run=run + m2=cls.post_run + def post_run(self): + bld=self.generator.bld + ret=m2(self) + if bld.cache_global and not bld.nocache: + self.put_files_cache() + return ret + cls.post_run=post_run + return cls +classes={} +class store_task_type(type): + def __init__(cls,name,bases,dict): + super(store_task_type,cls).__init__(name,bases,dict) + name=cls.__name__ + if name.endswith('_task'): + name=name.replace('_task','') + if name!='evil'and name!='TaskBase': + global classes + if getattr(cls,'run_str',None): + (f,dvars)=compile_fun(cls.run_str,cls.shell) + cls.hcode=cls.run_str + cls.run_str=None + cls.run=f + cls.vars=list(set(cls.vars+dvars)) + cls.vars.sort() + elif getattr(cls,'run',None)and not'hcode'in cls.__dict__: + cls.hcode=Utils.h_fun(cls.run) + if not getattr(cls,'nocache',None): + cls=cache_outputs(cls) + getattr(cls,'register',classes)[name]=cls +evil=store_task_type('evil',(object,),{}) +class TaskBase(evil): + color='GREEN' + ext_in=[] + ext_out=[] + before=[] + after=[] + hcode='' + def __init__(self,*k,**kw): + self.hasrun=NOT_RUN + try: + self.generator=kw['generator'] + except KeyError: + self.generator=self + def __repr__(self): + return'\n\t{task %r: %s %s}'%(self.__class__.__name__,id(self),str(getattr(self,'fun',''))) + def __str__(self): + if hasattr(self,'fun'): + return'executing: %s\n'%self.fun.__name__ + return self.__class__.__name__+'\n' + def __hash__(self): + return id(self) + def exec_command(self,cmd,**kw): + bld=self.generator.bld + try: + if not kw.get('cwd',None): + kw['cwd']=bld.cwd + except AttributeError: + bld.cwd=kw['cwd']=bld.variant_dir + return bld.exec_command(cmd,**kw) + def runnable_status(self): + return RUN_ME + def process(self): + m=self.master + if m.stop: + m.out.put(self) + return + try: + del self.generator.bld.task_sigs[self.uid()] + except KeyError: + pass + try: + self.generator.bld.returned_tasks.append(self) + self.log_display(self.generator.bld) + ret=self.run() + except Exception: + self.err_msg=Utils.ex_stack() + self.hasrun=EXCEPTION + m.error_handler(self) + m.out.put(self) + return + if ret: + self.err_code=ret + self.hasrun=CRASHED + else: + try: + self.post_run() + except Errors.WafError: + pass + except Exception: + self.err_msg=Utils.ex_stack() + self.hasrun=EXCEPTION + else: + self.hasrun=SUCCESS + if self.hasrun!=SUCCESS: + m.error_handler(self) + m.out.put(self) + def run(self): + if hasattr(self,'fun'): + return self.fun(self) + return 0 + def post_run(self): + pass + def log_display(self,bld): + bld.to_log(self.display()) + def display(self): + col1=Logs.colors(self.color) + col2=Logs.colors.NORMAL + master=self.master + def cur(): + tmp=-1 + if hasattr(master,'ready'): + tmp-=master.ready.qsize() + return master.processed+tmp + if self.generator.bld.progress_bar==1: + return self.generator.bld.progress_line(cur(),master.total,col1,col2) + if self.generator.bld.progress_bar==2: + ela=str(self.generator.bld.timer) + try: + ins=','.join([n.name for n in self.inputs]) + except AttributeError: + ins='' + try: + outs=','.join([n.name for n in self.outputs]) + except AttributeError: + outs='' + return'|Total %s|Current %s|Inputs %s|Outputs %s|Time %s|\n'%(master.total,cur(),ins,outs,ela) + s=str(self) + if not s: + return None + total=master.total + n=len(str(total)) + fs='[%%%dd/%%%dd] %%s%%s%%s'%(n,n) + return fs%(cur(),total,col1,s,col2) + def attr(self,att,default=None): + ret=getattr(self,att,self) + if ret is self:return getattr(self.__class__,att,default) + return ret + def hash_constraints(self): + cls=self.__class__ + tup=(str(cls.before),str(cls.after),str(cls.ext_in),str(cls.ext_out),cls.__name__,cls.hcode) + h=hash(tup) + return h + def format_error(self): + msg=getattr(self,'last_cmd','') + name=getattr(self.generator,'name','') + if getattr(self,"err_msg",None): + return self.err_msg + elif not self.hasrun: + return'task in %r was not executed for some reason: %r'%(name,self) + elif self.hasrun==CRASHED: + try: + return' -> task in %r failed (exit status %r): %r\n%r'%(name,self.err_code,self,msg) + except AttributeError: + return' -> task in %r failed: %r\n%r'%(name,self,msg) + elif self.hasrun==MISSING: + return' -> missing files in %r: %r\n%r'%(name,self,msg) + else: + return'invalid status for task in %r: %r'%(name,self.hasrun) + def colon(self,var1,var2): + tmp=self.env[var1] + if isinstance(var2,str): + it=self.env[var2] + else: + it=var2 + if isinstance(tmp,str): + return[tmp%x for x in it] + else: + if Logs.verbose and not tmp and it: + Logs.warn('Missing env variable %r for task %r (generator %r)'%(var1,self,self.generator)) + lst=[] + for y in it: + lst.extend(tmp) + lst.append(y) + return lst +class Task(TaskBase): + vars=[] + shell=False + def __init__(self,*k,**kw): + TaskBase.__init__(self,*k,**kw) + self.env=kw['env'] + self.inputs=[] + self.outputs=[] + self.dep_nodes=[] + self.run_after=set([]) + def __str__(self): + env=self.env + src_str=' '.join([a.nice_path()for a in self.inputs]) + tgt_str=' '.join([a.nice_path()for a in self.outputs]) + if self.outputs:sep=' -> ' + else:sep='' + return'%s: %s%s%s\n'%(self.__class__.__name__.replace('_task',''),src_str,sep,tgt_str) + def __repr__(self): + try: + ins=",".join([x.name for x in self.inputs]) + outs=",".join([x.name for x in self.outputs]) + except AttributeError: + ins=",".join([str(x)for x in self.inputs]) + outs=",".join([str(x)for x in self.outputs]) + return"".join(['\n\t{task %r: '%id(self),self.__class__.__name__," ",ins," -> ",outs,'}']) + def uid(self): + try: + return self.uid_ + except AttributeError: + m=Utils.md5() + up=m.update + up(self.__class__.__name__) + for x in self.inputs+self.outputs: + up(x.abspath()) + self.uid_=m.digest() + return self.uid_ + def set_inputs(self,inp): + if isinstance(inp,list):self.inputs+=inp + else:self.inputs.append(inp) + def set_outputs(self,out): + if isinstance(out,list):self.outputs+=out + else:self.outputs.append(out) + def set_run_after(self,task): + assert isinstance(task,TaskBase) + self.run_after.add(task) + def signature(self): + try:return self.cache_sig + except AttributeError:pass + self.m=Utils.md5() + self.m.update(self.hcode) + self.sig_explicit_deps() + self.sig_vars() + if self.scan: + try: + self.sig_implicit_deps() + except Errors.TaskRescan: + return self.signature() + ret=self.cache_sig=self.m.digest() + return ret + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return ASK_LATER + bld=self.generator.bld + try: + new_sig=self.signature() + except Errors.TaskNotReady: + return ASK_LATER + key=self.uid() + try: + prev_sig=bld.task_sigs[key] + except KeyError: + Logs.debug("task: task %r must run as it was never run before or the task code changed"%self) + return RUN_ME + for node in self.outputs: + try: + if node.sig!=new_sig: + return RUN_ME + except AttributeError: + Logs.debug("task: task %r must run as the output nodes do not exist"%self) + return RUN_ME + if new_sig!=prev_sig: + return RUN_ME + return SKIP_ME + def post_run(self): + bld=self.generator.bld + sig=self.signature() + for node in self.outputs: + try: + os.stat(node.abspath()) + except OSError: + self.hasrun=MISSING + self.err_msg='-> missing file: %r'%node.abspath() + raise Errors.WafError(self.err_msg) + node.sig=sig + bld.task_sigs[self.uid()]=self.cache_sig + def sig_explicit_deps(self): + bld=self.generator.bld + upd=self.m.update + for x in self.inputs+self.dep_nodes: + try: + upd(x.get_bld_sig()) + except(AttributeError,TypeError): + raise Errors.WafError('Missing node signature for %r (required by %r)'%(x,self)) + if bld.deps_man: + additional_deps=bld.deps_man + for x in self.inputs+self.outputs: + try: + d=additional_deps[id(x)] + except KeyError: + continue + for v in d: + if isinstance(v,bld.root.__class__): + try: + v=v.get_bld_sig() + except AttributeError: + raise Errors.WafError('Missing node signature for %r (required by %r)'%(v,self)) + elif hasattr(v,'__call__'): + v=v() + upd(v) + return self.m.digest() + def sig_vars(self): + bld=self.generator.bld + env=self.env + upd=self.m.update + act_sig=bld.hash_env_vars(env,self.__class__.vars) + upd(act_sig) + dep_vars=getattr(self,'dep_vars',None) + if dep_vars: + upd(bld.hash_env_vars(env,dep_vars)) + return self.m.digest() + scan=None + def sig_implicit_deps(self): + bld=self.generator.bld + key=self.uid() + prev=bld.task_sigs.get((key,'imp'),[]) + if prev: + try: + if prev==self.compute_sig_implicit_deps(): + return prev + except Exception: + for x in bld.node_deps.get(self.uid(),[]): + if x.is_child_of(bld.srcnode): + try: + os.stat(x.abspath()) + except OSError: + try: + del x.parent.children[x.name] + except KeyError: + pass + del bld.task_sigs[(key,'imp')] + raise Errors.TaskRescan('rescan') + (nodes,names)=self.scan() + if Logs.verbose: + Logs.debug('deps: scanner for %s returned %s %s'%(str(self),str(nodes),str(names))) + bld.node_deps[key]=nodes + bld.raw_deps[key]=names + self.are_implicit_nodes_ready() + try: + bld.task_sigs[(key,'imp')]=sig=self.compute_sig_implicit_deps() + except Exception: + if Logs.verbose: + for k in bld.node_deps.get(self.uid(),[]): + try: + k.get_bld_sig() + except Exception: + Logs.warn('Missing signature for node %r (may cause rebuilds)'%k) + else: + return sig + def compute_sig_implicit_deps(self): + upd=self.m.update + bld=self.generator.bld + self.are_implicit_nodes_ready() + for k in bld.node_deps.get(self.uid(),[]): + upd(k.get_bld_sig()) + return self.m.digest() + def are_implicit_nodes_ready(self): + bld=self.generator.bld + try: + cache=bld.dct_implicit_nodes + except AttributeError: + bld.dct_implicit_nodes=cache={} + try: + dct=cache[bld.cur] + except KeyError: + dct=cache[bld.cur]={} + for tsk in bld.cur_tasks: + for x in tsk.outputs: + dct[x]=tsk + modified=False + for x in bld.node_deps.get(self.uid(),[]): + if x in dct: + self.run_after.add(dct[x]) + modified=True + if modified: + for tsk in self.run_after: + if not tsk.hasrun: + raise Errors.TaskNotReady('not ready') + def can_retrieve_cache(self): + if not getattr(self,'outputs',None): + return None + sig=self.signature() + ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig) + dname=os.path.join(self.generator.bld.cache_global,ssig) + try: + t1=os.stat(dname).st_mtime + except OSError: + return None + for node in self.outputs: + orig=os.path.join(dname,node.name) + try: + shutil.copy2(orig,node.abspath()) + os.utime(orig,None) + except(OSError,IOError): + Logs.debug('task: failed retrieving file') + return None + try: + t2=os.stat(dname).st_mtime + except OSError: + return None + if t1!=t2: + return None + for node in self.outputs: + node.sig=sig + if self.generator.bld.progress_bar<1: + self.generator.bld.to_log('restoring from cache %r\n'%node.abspath()) + self.cached=True + return True + def put_files_cache(self): + if getattr(self,'cached',None): + return None + if not getattr(self,'outputs',None): + return None + sig=self.signature() + ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig) + dname=os.path.join(self.generator.bld.cache_global,ssig) + tmpdir=tempfile.mkdtemp(prefix=self.generator.bld.cache_global+os.sep+'waf') + try: + shutil.rmtree(dname) + except Exception: + pass + try: + for node in self.outputs: + dest=os.path.join(tmpdir,node.name) + shutil.copy2(node.abspath(),dest) + except(OSError,IOError): + try: + shutil.rmtree(tmpdir) + except Exception: + pass + else: + try: + os.rename(tmpdir,dname) + except OSError: + try: + shutil.rmtree(tmpdir) + except Exception: + pass + else: + try: + os.chmod(dname,Utils.O755) + except Exception: + pass +def is_before(t1,t2): + to_list=Utils.to_list + for k in to_list(t2.ext_in): + if k in to_list(t1.ext_out): + return 1 + if t1.__class__.__name__ in to_list(t2.after): + return 1 + if t2.__class__.__name__ in to_list(t1.before): + return 1 + return 0 +def set_file_constraints(tasks): + ins=Utils.defaultdict(set) + outs=Utils.defaultdict(set) + for x in tasks: + for a in getattr(x,'inputs',[])+getattr(x,'dep_nodes',[]): + ins[id(a)].add(x) + for a in getattr(x,'outputs',[]): + outs[id(a)].add(x) + links=set(ins.keys()).intersection(outs.keys()) + for k in links: + for a in ins[k]: + a.run_after.update(outs[k]) +def set_precedence_constraints(tasks): + cstr_groups=Utils.defaultdict(list) + for x in tasks: + h=x.hash_constraints() + cstr_groups[h].append(x) + keys=list(cstr_groups.keys()) + maxi=len(keys) + for i in range(maxi): + t1=cstr_groups[keys[i]][0] + for j in range(i+1,maxi): + t2=cstr_groups[keys[j]][0] + if is_before(t1,t2): + a=i + b=j + elif is_before(t2,t1): + a=j + b=i + else: + continue + aval=set(cstr_groups[keys[a]]) + for x in cstr_groups[keys[b]]: + x.run_after.update(aval) +def funex(c): + dc={} + exec(c,dc) + return dc['f'] +reg_act=re.compile(r"(?P\\)|(?P\$\$)|(?P\$\{(?P\w+)(?P.*?)\})",re.M) +def compile_fun_shell(line): + extr=[] + def repl(match): + g=match.group + if g('dollar'):return"$" + elif g('backslash'):return'\\\\' + elif g('subst'):extr.append((g('var'),g('code')));return"%s" + return None + line=reg_act.sub(repl,line)or line + parm=[] + dvars=[] + app=parm.append + for(var,meth)in extr: + if var=='SRC': + if meth:app('tsk.inputs%s'%meth) + else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.inputs])') + elif var=='TGT': + if meth:app('tsk.outputs%s'%meth) + else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.outputs])') + elif meth: + if meth.startswith(':'): + m=meth[1:] + if m=='SRC': + m='[a.path_from(bld.bldnode) for a in tsk.inputs]' + elif m=='TGT': + m='[a.path_from(bld.bldnode) for a in tsk.outputs]' + elif m[:3]not in('tsk','gen','bld'): + dvars.extend([var,meth[1:]]) + m='%r'%m + app('" ".join(tsk.colon(%r, %s))'%(var,m)) + else: + app('%s%s'%(var,meth)) + else: + if not var in dvars:dvars.append(var) + app("p('%s')"%var) + if parm:parm="%% (%s) "%(',\n\t\t'.join(parm)) + else:parm='' + c=COMPILE_TEMPLATE_SHELL%(line,parm) + Logs.debug('action: %s'%c.strip().splitlines()) + return(funex(c),dvars) +def compile_fun_noshell(line): + extr=[] + def repl(match): + g=match.group + if g('dollar'):return"$" + elif g('subst'):extr.append((g('var'),g('code')));return"<<|@|>>" + return None + line2=reg_act.sub(repl,line) + params=line2.split('<<|@|>>') + assert(extr) + buf=[] + dvars=[] + app=buf.append + for x in range(len(extr)): + params[x]=params[x].strip() + if params[x]: + app("lst.extend(%r)"%params[x].split()) + (var,meth)=extr[x] + if var=='SRC': + if meth:app('lst.append(tsk.inputs%s)'%meth) + else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.inputs])") + elif var=='TGT': + if meth:app('lst.append(tsk.outputs%s)'%meth) + else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.outputs])") + elif meth: + if meth.startswith(':'): + m=meth[1:] + if m=='SRC': + m='[a.path_from(bld.bldnode) for a in tsk.inputs]' + elif m=='TGT': + m='[a.path_from(bld.bldnode) for a in tsk.outputs]' + elif m[:3]not in('tsk','gen','bld'): + dvars.extend([var,m]) + m='%r'%m + app('lst.extend(tsk.colon(%r, %s))'%(var,m)) + else: + app('lst.extend(gen.to_list(%s%s))'%(var,meth)) + else: + app('lst.extend(to_list(env[%r]))'%var) + if not var in dvars:dvars.append(var) + if extr: + if params[-1]: + app("lst.extend(%r)"%params[-1].split()) + fun=COMPILE_TEMPLATE_NOSHELL%"\n\t".join(buf) + Logs.debug('action: %s'%fun.strip().splitlines()) + return(funex(fun),dvars) +def compile_fun(line,shell=False): + if line.find('<')>0 or line.find('>')>0 or line.find('&&')>0: + shell=True + if shell: + return compile_fun_shell(line) + else: + return compile_fun_noshell(line) +def task_factory(name,func=None,vars=None,color='GREEN',ext_in=[],ext_out=[],before=[],after=[],shell=False,scan=None): + params={'vars':vars or[],'color':color,'name':name,'ext_in':Utils.to_list(ext_in),'ext_out':Utils.to_list(ext_out),'before':Utils.to_list(before),'after':Utils.to_list(after),'shell':shell,'scan':scan,} + if isinstance(func,str): + params['run_str']=func + else: + params['run']=func + cls=type(Task)(name,(Task,),params) + global classes + classes[name]=cls + return cls +def always_run(cls): + old=cls.runnable_status + def always(self): + ret=old(self) + if ret==SKIP_ME: + ret=RUN_ME + return ret + cls.runnable_status=always + return cls +def update_outputs(cls): + old_post_run=cls.post_run + def post_run(self): + old_post_run(self) + for node in self.outputs: + node.sig=Utils.h_file(node.abspath()) + self.generator.bld.task_sigs[node.abspath()]=self.uid() + cls.post_run=post_run + old_runnable_status=cls.runnable_status + def runnable_status(self): + status=old_runnable_status(self) + if status!=RUN_ME: + return status + try: + bld=self.generator.bld + prev_sig=bld.task_sigs[self.uid()] + if prev_sig==self.signature(): + for x in self.outputs: + if not x.sig or bld.task_sigs[x.abspath()]!=self.uid(): + return RUN_ME + return SKIP_ME + except KeyError: + pass + except IndexError: + pass + except AttributeError: + pass + return RUN_ME + cls.runnable_status=runnable_status + return cls diff --git a/waflib/Task.pyc b/waflib/Task.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1cb88990f69c4edc27035d4948d96407fee0d925 GIT binary patch literal 28638 zcmc(o3vgY>dEfWoeJ=qJd;xrkx}*pRkSJ23-ZDi!2wI{gg31A9P!y4yi+c}%3j!Cw zITs`#lYU9Ir8rI;k5YGHyKbC`ZMkXFP7|k@w27znbdq-3q?w7^jy-MKB$Kf^o=M_# zI_`{<{{G*dbMK`@#mY%`J4e#ZGs=(=B$n^IdMS+nw)rL4_7QuF~Po z=Uj#AysJ>X$yKQCb(J1>zE97e?{}4)JHOdg^6vbAt88-Tx425LJHORc`rOMj*ygIv zmA1P|zl(Ob8D_Itksn(N1f+wb68!t88=8E-T&M zDBbNUJ8YCat}?*q~Q*bY_5c^$ax78kSl|7cZ#YG2Q zWv_dgB^!3pt@^3lD-0(E`&CHtxj3q? z#x*~cwWwSyFD)*XYLyXMA1W}wBbWJ2zmKSIuEJ8Bj+pG?)o=J~Y1!&a#f558A6Z+| z+U2Sp-W*M-LojI8S|K*f45zssfaTvVK0Seh;^)VnFDEm={0t5w#D ztXy1;E=5Hvww{fKl4xNj6fuoxf$AD@@$L~)ms}t@@>~+d$&ux1w0LAWUYd`}_2fut zb-KEgriU+=X70TE@B@eMzUR(+q9`g&-*a^O!3U=Axu^WlbaemG>3gH{z2(w<(L?v# zeT23P)#)Q=OHjh{y1hWWTDx6?iTS#qH`vD29b5yg>#k*Em97E_mXmdTu(7V>vULqu zQGhjJuQzVX7;53{okOi^C=OEJOtQQRsa6-FBwZwHCkA4T{dA*x%R(L9poP*LmY3ih ztkzNTjn&e6^#umaP%9YrlXzCC$(I+BmSPH=Z`wyL6f)g-7;7kxoJ*^97C6z8C7PxS za>3@VT$&mH5*Te%tb-oK`ucKIRxAAzYCgf0Y$1sdgeHe25!+noL0c9M3z9G>V)8MMT!5?UIdwP^3L0%MMW=G#8&TB{rA^`uZXgumw%uK9ck$DK@*Qa& z@k2id^@<7H_`kS%k0D>q(!6@OKqnpUYG<>&i0n5iFVd_-<;7lC?{oEjYqQy1>2yQP zh9A{&&s;aV`2lf?p!SeUhwaLS-4dWnsL>X8vD?L40_c8zo0arty=>BZqz|Hv*nE?t zL4CWLG166-hD|DMlXLYQS}0!k7!^D)F(MorHz{mTVtMJZgCx3CUEs}~6Ky|HN+M%I zplcCXU^r+`&6SrbktaAcj-y%RNED9@svi+!vbr3_p}=gt6^qqcwO%ZyH?`7Yl-@+O zN^-ecpY!8H%L}El9}{^ik!-V)D6Vg!GoolJvmz%ypy9PO5N zSlVeR)P%m;ExLc12GB^mWl-8XEQ8+OX&K13%Q9&1-IhUt@3D;O@Os?Tcx6nJSH_fi zWzgrzqtY{+Df24akt*{j@@VlY84_=k{5I@(GCX;5Jd`Xf3uW55L@;N#5-kI?2pyx5 ztZxyM<5hO)zRgY6cDoL6`eNS2_q!kvtQDI|nc#^SGk(dkGgDr?eTO-X$lQVH} zgba(qo6qwTNYx<^-(zVYQ1ZYXh{N$HoN0H16Sf%Ri9nFgeL!NVFdRQDb$vLwYFtA6 zL?CIZXT_qCKSW`KqLr;yJV${M?o(S$E7ZI;aGg@l6-Uc)u{g!pMm4UvPQoW!r#r}a zTw=A5UNOd>Efs5q2pycz3brfDVhyEh6yB#U`$-~6RAKXF=uOT z3l!c@gLh{|gycnur(zLB-z7qH2b=3}E{dRMiz0sK7X{qNbV-Bb1Jt}b^A`pci>&Az zI7dE%s3t8c7I%1B<=}f0?XR}G^;^Xt1VB@xfN^rSlp+if&p0IRCu_rSjZWhl&l}gE zL6_^GU9s5?2BHViJxsIuRKsX7jK^FZ(JY$^w-qCy!<$w72ni~WbB}`))#=rGWL(80 zHnOl-CI+{4k4^@LrXucmruFe4OzRE15dm3-8$)Y=`^oY@(2m z#8Ai>tC+1y#w|783Xd(GKKbsTkdzY`d#yB$7{`9EuO^FnAE8jn8`{YUlk6Qnz}!6p z^)@mrAqJU@F~Ac%KMg9p<@#=G*x}|og*JMqTgvMrleI12RgdA-gz!p2X#Js<);Twy z&$`lco0@eHpQ-KWw3z7rBb+0I^x07q-Xt`cps(Ce7WFD;v zhsqaCeTd??xR}hE%i`p@6DOZNd+N-1c(+EBNl5il4D+g07I*`Dng?VZ*wZJ%$0wdT zIcDZ;C~UMQlcgEYAjG;So;z{k>)5SAVj*?`Fp_9i*WZLG? zoIBtMyWt1=J&373Kz=hdedIcWE^@tX?FgI!>Q&R%CJlU`$vp(A6I@AwXqEk1N$<`{(Q(OOGa#r@Puoy#_&oG6Ccx}+kPNW-UKwes?Q>&Oo6Vm>yMFiM zZEodj*0c+OFa#^!Y^?b^5(pShN z_EJ|6Z74q-Zl)8>*w0=o$4mFPsN|y+I-ihM~#<(lsUr$GINVceMXJLcLS&x2>?iEze5Y9flbu0`VV^Vj*1LoDDLWG z+=44+U&c|XvTmAsXe{Fes;y!rslFH)A5Ym_R54UHF;ZV#_I%|e%}2O4z@?~(msjI| zpuu`HB%E|J{IwbSF>CaYS!T&SG`Mnhsa{&ZAh~j4HIAcNUD;DLxg(W3<2{qgo~tQMs3o(mP4xT z5&RqO22B`QTX6-H}ye7&}I%7S{{KOizRWR#)n*^_AA z`&G5#_0?s=(K(NolxzSClCRe+@A49~5|@~H@|zmj^P^nw1V~sGMQMtnVO#QVlkuo0 z)0@?@_=7J2-4KImADL;*5Q&#`65|xZY4a@V%UWQ>6hI)L44rj zrMB5$z-p$0hLbD*84=lSBJxWnA`wE?PA%m2I#)C=u{S<39 z|DN@+pC;AXrP4yRl8vB_q+hb4=6qs3CaXx7*_xVM!Pi`~K14GZl@vbGZq=%ZwFu%*q|sQ@f_V>tcq z$p~9WaXCZ$Vj1ACS40kFb#2sjxSHW488xD*Z*;*lyABkx0aNQ>AgEK)>z;BGNF?w* z{*2o9>X+T9)Pi&j%IKOvmtijqNai!DB6{E2h? zlN5LymXI4yWE!7Nkwd#I%pHZ71ehC+8XAxvX@ujc88vk90=0GtT@MUuY>Y7e=amMn z-K8j=ULwdOmVCJsr_S}16JmLX&rspLXIgG+$0WS)CUZ3WaTRN}RUbrJvw_(OVeD{y zBT-2VPO4As_sJx?Nu1fU18vgG_OuNK1w?Wm|F;C=BRi?~%>A%((@NHryr|@|k~Jk_ z{T5mZA5!i;N{%UcT*;V{b4s+%-cukeCzQJ2{fn2B`=FAKD*0)W=Bilk#w#xhNEzq5 zolF<2(EOk4%C+S>xO%v5v0Pj3rrwTRXKujYeU^wrnaAv(gvk?J$v-EF2oD7ov}$t^ z`@Bp{yiB3dgfaxPd>G5DE0x#|G-YfPnliQzO&QyYri|@IQ-*j}E{kX7EkitOlVyl! zZLt_uuib9THmALlNLE86cJLBs^fu!p$U1L#ikREnPs_{K8o`2?A@HI_?3A&foid$L zz^R3Zb<3+t3W+Ah!tse3#<-BGgUeVAjzQ7Gjz-wW(qg=3_e$`Ov#-_HK{f^Jy zj7u@rU8$yaO;fSTw>BNKrWPR+BVG|=VY|Z0(N|=|`l^O4PYJ`IQ5YMSZ7j9JqT%Dl znhJ@aFY)UwG+8La3F0)-|9rTWdk;B-*BrM7G_yf#)pAr^F4gA@gkH1UqZT*mDXobq z;|6{ktzZvcq!eSq(#tqYXf3_eCLfIo$L`&-++Ck6RrZ59QP4J^ci|CK3#bk%rJ z1Aqf)`>2=Zr_dPnw;SWFO~059W5H!m4xa>q-c(S?bWktRE!iuyVbY9()(aJzD4rPU z=B3BOpCI+fA=GaTzJ}&Z%n-;ReAR1V4LtGcCIfr5%M0EIbSrO(NuCx%;*%;{RcB8C7=FY89~p6{sKI_CDA23_ zMwzUAAa%%=UulmU8k-t4Yt3jCpBCh%W-C92Is{IzdC4>0jI~Vo-2#$CnPxpyZlR_-&SZgsg*sz=RbZ{fXyb7?veC0o-V81No18wZXs14Za z8=yR8wYrUk(c#NV4k$4pWh$UXY5EuN`)uGsmQBzP5zlyONS8av8h}^?os)~<@vx6*F zc+CP{;m@jExK^rEno$HJKUpFhxgd((X+auVQeI0U^mW*XCdGuZ4aW5qZdw_a!oQwz z?GxjYm|%gtW&*`%a{=7R0>{d98B0>m;>Q;L?Gaszs&G`0) z<_=?%er#plPpShR^|{DDq5yfJOxS!jsw7fr-o86MF9=ZY~w0E zBrjZheB$ZiGmoD=88+h;26m5}(!+$D<4g5Wk)lv96P{9XR0+7@gB6u%dUZAw+`W<2 zPA(%MQ@@nylruiYd|<; zAW(7R{8*)7OeYF>y~$l_?oV;EH=_&hPCpoY&0)J3bxtY@_G(*|+&<9mg?3GS6q z12>d_uU#x~)qrk0r98wLL~eKwUz(reG9`YKi+{p47j4oZgth{FUla(; zVBu>!%RZhQCe7Tp;ueL5AT{r;9Jg__vRaJ^B22H#b!%LPjg+N@g<^3;dVdREH|2d* z6`v-tol!d5#|bPkChy@FA3e*-6_4Ylx(lhTb14Ny&hmN3g_yVJoG+_^@H$?Cx0;Fi zuqsXBH<)De2ogq>8ANts27Rz9HLi!q^Xa zqkSSPTuN0Mw1^!t&fv{ty5H@d($LSKVk+tQ{#LvT_|SYFeg(}8MI)& zMFoi%SbGo6gKBRvA`1^0T=lx%QKgsm9sM>r^7&O?ukPHQwwI zf80tu%L`b)EZfDBE||Ae%yNgDA9QgkP-e)yVmtNvJW?lPVRdDU!6^`%Ath+ba2BOK zMy+nxMB3(#Y3+7vj9`6#b0ItY$~Pu=jM&#??NVb&_qB-$`^ntWw)XtrvbGOtCzH0n z_PF^yHqhkCx8ddfi zF8mitKCk3ANbE(IOWJc}oW!2v&ig1$b2cgQkMzLnO2om#k16>TB@dF=lX2;?pTSN_ z=&(6ejh%47S6caR>Y0y|c%NvGZjHnIDmjxf(xkoo5Jc=*+hnBkX^B^@6zteYzVkK4 zgGKlw*V}Ur``GcU^@Qb*+XKaRX{>5zEEn#M!n6h2V}F$&_Bx){?N%UWKT$7 zAo;D)F~Nsi7aHh6Q)u@X+wSJx?;U^<(Z16iTlqK|;w8_nAs`s=+B5cScD{gv1ut3H z1EDlFb;Ncan4NX8%f;Wcx9XMO$oIEPutp!IpOtUwM>_`MBf;8{wB^{;{!9{Wc1d@D zw*ZwGwB|uH)EN+h~Y1i7$Z0vuSVViGY<4mC~w;2ehTWTEGL-pZ6;&C`HqEW zAVO2lfL3R!YzZa5QKpzE=+nZ_+chZIsonFkxHCIkcKIM2cDkY|IPgWS2w$Cn7hvW*o4RgQ$VX@BDSHD`c~+hc_?fIj z+4wK^Ix-V>zH;2q+qNiqw^zCgEd8`awvWrU0Vk4@C>VTDz{=yLMKl928Cx&!b%Lfw zF6U;*<)tH$W>;oHkWlkmIs1;kgL2Va+>Y5yv#+3 z@vL0#GZF5N;9y3+>Z@UXeDkg38+-Cii5knp6E%DP|34EohY}%VFuIlGMScBl2$UXr z$pzjijhPPFdeVpgEBxVYi+?SuH!1jDxAv&@vlY6(_gcDdP>0dII)l8S7e37Zidd1b=>)t^mjjj6KcTyx!O9Sm@{w89)e{=_!Qkv z*6wGrgJuZ5_M*WQPl)C>Xu=Ns55Jpd( zsro%_d^Toek1DT2vf;N?@jfM{et$=~>kz8ZXgyk7)>cm=xW$VV-G`sm6aS6Gh$~*K z$59kY^KTMy_}_K=c_mWn!~a3zTStx0I+W)Sg+^v)9=Pwm7D;Mk{KtCiPqN22HNm;o zCSjt#*EfCko)1So$LcK5-GkkGQB}+DKeD9e(c_|a2fsz?*KE67}Y{eUa%%!T~4d% z!FJcE`bDe8Q;{720uA)FI99TU#EU_#Zu*h0mYtdAnlw6GQ_IVGM(-5R>Xn@$Z@~zMDA_lefGH@j}am@KK-UME&6JWZI<-x_yM*4MH1tE z#Oo3}ug{4HJ{-p9!gNH~43E#z#@M21DAM4P=DsU4D8kp&jnpDeLQ%WXh_s!NwY5Pa zg0sktlO2B{oEoH3pNHU-ZZHZy?Fw!V5*xk}{;WvT|Ruqlvz4Pu7-`iC8Xli2nj7?7vetI*f?X%r~RG(ElQe5C)kAlN9}~hWqtBvHeOm?PCV9K zRkivu3|=g8rbL{gYJAPI^PamIda7#LT9!B*(iA^8T=LWka~ z)TU!7s=$g)%55Xv&9xaLScl6=O^UZ{)zP9qp}zN$APRg)8i=Au!W%lCBP*oJc2*yv znSXCdHCv#vnH81tMlOf=1mE9@*0wQ?bX!^%?!V-;=J)8c$ENufLBc_#x#Jfuj9yVm zWocod6d%8E@WMe~kgQH8b=`kJ)$G(ce&O;RqsnWi#qqS$Ro&vA*swOYyd zC_w_e+W0PH_TflR^`Zu|zn5=U1_YxqbgvZV5A~zX6OBC;ydvT9cyNJxJE;tzBAXQp z`Ity7UK3f%%IHeH>pvN&z$^1Br^E!e-ZvUHgMy7Fu`@8xIEhROcq0o=<*E$2B!h5Z-*A@6KtUfq*G=PVRg(2&FXS1nq z0n?|Ov&}q%xx&o(A_r|aH0Yz%!HRz&JQ?mBxC9M1xE^u+f(I3>gz z=)ERc)c9*bg+mBLHt5QRA7st7PaVgtIcb0e6&i!M1}qeh4PUrbbi-V?KJaH83tb*fU{x_8s_S>B4kyWjJba*V;INKKkGxPitlh=M8GJt@MCtX}Ub#?5ExuIJX}{*fQ=``F z*(c8?k`}5+cYM;V?3TZ4x9QXLE9UXAcS;>5`*)j`9hiKFk7PsIhmXVms@D)6a6-+z zxgH1NL>heKZSL5naO~d7p+lG_dM(ted@Ni*-7XJ9gAwKEr zcj)J7M#LIDPe(Wm#S)E6*Woq^CEc+0Cd|$9=ChAQp0L@0uZD(xt8pEiwa+?+pWq?0 z<8eUXtvz%4*;CJ)ES^1i`dRH!EAn-iXP)t~vR~0y5(dci>ay>Ly_I#Hrcc5SX5f$I z3A0odZl=g6gSgycc&8rM6#3#!n9Hhg%FX%cO`AHP+W8~z{oLMoD%iq!E#IsxCi+z6 zPLae@nhH{UbJtE%$#i`&x68>Q&wlIBU7kCI@BNEhRQi%h)Pf4n0d z{&c`s+bOA?)E7PA>l$M^;ERtc#MY;<-xc_Xx}@7@0_2!1Ge*w4Ol~3&^Y%>;$xTEU z($4A|0@A+>&On=RqnK&Zny*)-;doUeycvfY#z97#T+<8jGsz;xd)ruFgyb&ec-q!m z_dW#TW$fNIW&(8~FcsV|4P+1#Aa#V|IAoup!O(B5_F|M>74{hyhBh%O9rik6^cjlZ zff#*CFvn#gX=xKs#w2PcHnUT_;$7omC&U`c$Paszh`Pf(iLth0$F4kf<@j-b$ZwOX zGz)V%`Hj}SD$}OtCgqRN;>MG|ai}Lm?fn{0bZi1p!moAeR?UIm!^mfj48y`l!vVdX zf*&gPAMw)H=^HX~)V%O554}U-;$`gAXt+fKNE>?701a_Dn!G2iO{et^N65t2Xtz3FfrfN_J1MK!m85Jx z)ViH#^X556%F?-=6_WyTf-9LJ@!Srx8bK(Fk578|7!ZCovl-r8X#CC>#!t!W#!Q!N zz}h&c{nm6ySNdE+nyWM-E2e@T!?FkLtiL;MxOVHU=JYd7Xr{^+2fjsBxK98&NaA^* zfqFj`9#mvDfc+I1r6!O_wRFLwfPv*~3y*MDR++F+sAsGBTV(hP9~gGa_K7go^nS^+ zHh$S+-k%!feg!*Rc5i|M@sZt|Vt_f8-J3mz^u8a7S?S>yqCV&DM}~W6EK4na*(c5U zg<#C{o%DQmv&kJ}Wg$s`!ZgV6S6LA0`s54Z6S;|z&gZwuO_*jp9vV1D%IT=C*Sbau6RLCL}0KGp=y?dyy*2*oT{_O)E z5MpdrCtN#M>FFBF#`(!MrGldH_!jKoB0?Oe$)3ClZwJs%Au zLls+SNK>EIH655?uMS?ZCIC<#F$)byk;5U{LVVeFFO3}jGbKXGH=oqf{LIK$!VV&T z?h1qb(hDY=D2BOat)2+EeLpV^fbApt)WOG?En@sWRqNeN9kDH| zEm-w+Dh!MkYyqo^+204*81%A0?N2u0mA6o_k&zg)E?dq2NT#uxO)_HN5Fao_T&=%o z>ual;8kHu%uv1t}?Fp3W2O-*hZ8E=`%?o9)z42e#_tBNkIQ z!P~tFMn1m%%c?K{8!SJsTVoDK$(f7dRIL)N`5ixxQs)0KO^<5jWcHu5@{s>E?oEU8 z@Yb>l-q1_ycbhi|>|z=}E3h9VW75bo%jGzHIz{mHuNT4WSVZ>Fo=-;(p"%(self.name,self.path.abspath()) + def __repr__(self): + lst=[] + for x in self.__dict__.keys(): + if x not in['env','bld','compiled_tasks','tasks']: + lst.append("%s=%s"%(x,repr(getattr(self,x)))) + return"bld(%s) in %s"%(", ".join(lst),self.path.abspath()) + def get_name(self): + try: + return self._name + except AttributeError: + if isinstance(self.target,list): + lst=[str(x)for x in self.target] + name=self._name=','.join(lst) + else: + name=self._name=str(self.target) + return name + def set_name(self,name): + self._name=name + name=property(get_name,set_name) + def to_list(self,val): + if isinstance(val,str):return val.split() + else:return val + def post(self): + if getattr(self,'posted',None): + return False + self.posted=True + keys=set(self.meths) + self.features=Utils.to_list(self.features) + for x in self.features+['*']: + st=feats[x] + if not st: + if not x in Task.classes: + Logs.warn('feature %r does not exist - bind at least one method to it'%x) + keys.update(list(st)) + prec={} + prec_tbl=self.prec or task_gen.prec + for x in prec_tbl: + if x in keys: + prec[x]=prec_tbl[x] + tmp=[] + for a in keys: + for x in prec.values(): + if a in x:break + else: + tmp.append(a) + tmp.sort() + out=[] + while tmp: + e=tmp.pop() + if e in keys:out.append(e) + try: + nlst=prec[e] + except KeyError: + pass + else: + del prec[e] + for x in nlst: + for y in prec: + if x in prec[y]: + break + else: + tmp.append(x) + if prec: + raise Errors.WafError('Cycle detected in the method execution %r'%prec) + out.reverse() + self.meths=out + Logs.debug('task_gen: posting %s %d'%(self,id(self))) + for x in out: + try: + v=getattr(self,x) + except AttributeError: + raise Errors.WafError('%r is not a valid task generator method'%x) + Logs.debug('task_gen: -> %s (%d)'%(x,id(self))) + v() + Logs.debug('task_gen: posted %s'%self.name) + return True + def get_hook(self,node): + name=node.name + for k in self.mappings: + if name.endswith(k): + return self.mappings[k] + for k in task_gen.mappings: + if name.endswith(k): + return task_gen.mappings[k] + raise Errors.WafError("File %r has no mapping in %r (did you forget to load a waf tool?)"%(node,task_gen.mappings.keys())) + def create_task(self,name,src=None,tgt=None): + task=Task.classes[name](env=self.env.derive(),generator=self) + if src: + task.set_inputs(src) + if tgt: + task.set_outputs(tgt) + self.tasks.append(task) + return task + def clone(self,env): + newobj=self.bld() + for x in self.__dict__: + if x in['env','bld']: + continue + elif x in['path','features']: + setattr(newobj,x,getattr(self,x)) + else: + setattr(newobj,x,copy.copy(getattr(self,x))) + newobj.posted=False + if isinstance(env,str): + newobj.env=self.bld.all_envs[env].derive() + else: + newobj.env=env.derive() + return newobj +def declare_chain(name='',rule=None,reentrant=None,color='BLUE',ext_in=[],ext_out=[],before=[],after=[],decider=None,scan=None,install_path=None,shell=False): + ext_in=Utils.to_list(ext_in) + ext_out=Utils.to_list(ext_out) + if not name: + name=rule + cls=Task.task_factory(name,rule,color=color,ext_in=ext_in,ext_out=ext_out,before=before,after=after,scan=scan,shell=shell) + def x_file(self,node): + ext=decider and decider(self,node)or cls.ext_out + if ext_in: + _ext_in=ext_in[0] + tsk=self.create_task(name,node) + cnt=0 + keys=list(self.mappings.keys())+list(self.__class__.mappings.keys()) + for x in ext: + k=node.change_ext(x,ext_in=_ext_in) + tsk.outputs.append(k) + if reentrant!=None: + if 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 CS}kD! literal 0 HcmV?d00001 diff --git a/waflib/Tools/ar.py b/waflib/Tools/ar.py new file mode 100644 index 0000000..7a16dfe --- /dev/null +++ b/waflib/Tools/ar.py @@ -0,0 +1,11 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Configure import conf +@conf +def find_ar(conf): + conf.load('ar') +def configure(conf): + conf.find_program('ar',var='AR') + conf.env.ARFLAGS='rcs' diff --git a/waflib/Tools/ar.pyc b/waflib/Tools/ar.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c65e5d1e5bc309ff62ff52b2351107b700621f5 GIT binary patch literal 773 zcmc&x%TB{E5L`FqRe=EU30!i3L~VFgLWl|pE~tkTF1-}TajT%Dsq7Sl#0`#o4u8dw z4}e)y+CKm*9?#m&u4mT!+-SUiyv2%UqlWby)9wLMe1dYKLQr3j(1Ow$y%N13u2JeS z?|YQispl`@hwKZ(7hqK#pvv)3am14|Utrp8z%$XkOO8weWqLjzcPmC|78&wVrY?$c zK>i%;9cXxKwXxwO(?vKj<-Jyw4dpb+${7Zaa=70Nj)P{jA8D;+619?(<0OhyJJCn2 zWqn?&b$}}iQ6nP@cdEw^?meCO^15@?`#)3G z@H%d6HkumEfn^^^?1-+FFB-gE7XSzX)!EE?(9-*j^og-?qzo#y(CJK^5F HB{scp3xcQU literal 0 HcmV?d00001 diff --git a/waflib/Tools/asm.py b/waflib/Tools/asm.py new file mode 100644 index 0000000..b9ed5f4 --- /dev/null +++ b/waflib/Tools/asm.py @@ -0,0 +1,25 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib import Task,Utils +import waflib.Task +from waflib.Tools.ccroot import link_task,stlink_task +from waflib.TaskGen import extension,feature +class asm(Task.Task): + color='BLUE' + run_str='${AS} ${ASFLAGS} ${ASMPATH_ST:INCPATHS} ${AS_SRC_F}${SRC} ${AS_TGT_F}${TGT}' +@extension('.s','.S','.asm','.ASM','.spp','.SPP') +def asm_hook(self,node): + return self.create_compiled_task('asm',node) +class asmprogram(link_task): + run_str='${ASLINK} ${ASLINKFLAGS} ${ASLNK_TGT_F}${TGT} ${ASLNK_SRC_F}${SRC}' + ext_out=['.bin'] + inst_to='${BINDIR}' +class asmshlib(asmprogram): + inst_to='${LIBDIR}' +class asmstlib(stlink_task): + pass +def configure(conf): + conf.env['ASMPATH_ST']='-I%s' diff --git a/waflib/Tools/bison.py b/waflib/Tools/bison.py new file mode 100644 index 0000000..6ae7898 --- /dev/null +++ b/waflib/Tools/bison.py @@ -0,0 +1,28 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Task +from waflib.TaskGen import extension +class bison(Task.Task): + color='BLUE' + run_str='${BISON} ${BISONFLAGS} ${SRC[0].abspath()} -o ${TGT[0].name}' + ext_out=['.h'] +@extension('.y','.yc','.yy') +def big_bison(self,node): + 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.parent.get_bld().abspath() + self.source.append(outs[0]) +def configure(conf): + conf.find_program('bison',var='BISON') + conf.env.BISONFLAGS=['-d'] diff --git a/waflib/Tools/c.py b/waflib/Tools/c.py new file mode 100644 index 0000000..4d8cbd5 --- /dev/null +++ b/waflib/Tools/c.py @@ -0,0 +1,24 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import TaskGen,Task,Utils +from waflib.Tools import c_preproc +from waflib.Tools.ccroot import link_task,stlink_task +@TaskGen.extension('.c') +def c_hook(self,node): + return self.create_compiled_task('c',node) +class c(Task.Task): + run_str='${CC} ${ARCH_ST:ARCH} ${CFLAGS} ${CPPFLAGS} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${CC_SRC_F}${SRC} ${CC_TGT_F}${TGT}' + vars=['CCDEPS'] + ext_in=['.h'] + scan=c_preproc.scan +class cprogram(link_task): + run_str='${LINK_CC} ${LINKFLAGS} ${CCLNK_SRC_F}${SRC} ${CCLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${SHLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB}' + ext_out=['.bin'] + vars=['LINKDEPS'] + inst_to='${BINDIR}' +class cshlib(cprogram): + inst_to='${LIBDIR}' +class cstlib(stlink_task): + pass diff --git a/waflib/Tools/c.pyc b/waflib/Tools/c.pyc new file mode 100644 index 0000000000000000000000000000000000000000..394d1e09e49a20ea88cfd068d277676da0084b38 GIT binary patch literal 2033 zcmb_dOK;Oa5FR^ql0K<;6p%P@h)}pBh$BLX)J@x{B~+VK2qR><_O^BEN95h|P?}RY z@*DUST=-2K`2jF9PE11)7wUFrXTE*S&Nn+L{a9Z3`u(%;Ve*x*e~wLkLlNM=0TDoK zfMY;xf@4Bl0;dE9jhPV5L2Q9z<#q|8GQ<^dDiBw}se&O57|cU32j>O^7JLFyoCOHV zAWayUaEN$?ae&v(A_P^C6-MU^bP0k5kV}j%7U(hrOCYO^E*Izu1S`<1UqkQ1pZL}3 zLb`&Y@2Qh5ndrHRt}Rsdbr`9-L38F&`0g;1!z}gd<`jy;)J2T+iM2BcbSJOd$e%wt`GwEsR`e{52BN^~9`N`y@lF=c1o1}rP zBLFPaW7L}aN@l7#3}xIze+Sans_C5`gy}@S_YR}*pxIB;NHzV&@S`r{GT%K;(~~M{ z>^+!*QMCCZ_tvqghbSZv=SVYhj#+Soyp@P@QszKfFerml2GQdXt1q~uHnQ#U{o1G{ z>}|K#e?mRk_U3MDtH;{jUZHP_){FM5mttqH)#vFmz-0Dxtkbngu)Q#f2V@nY$^dV!5N4NfC6X+n0I zxJqYC#XB!kypQ~#-7pcHT}+nmCBHfPAEKBN&NXtZY?O_8{9`YDr1~iHVjlGcdi~wby8EIfcG`l**`A(Q7{v(f$0#G)vun|suAHbei{{`e z?8b_s)Hnzejyna1(}rq9ZM5F$Zgj-BPH#snkys|Nf`Su$ok|7&Vh0{E*c#KKjeqL7rXA4$K0|9F<=O@5|SrT)uFfTWDU9$7{G1ZO6~9Y~-bg zO6gyGrAy_$qL-)x7sTIwU6D(-ac621m%99m!H(sXQ_#_Zq9mwvYoa+HX>d)=U;d3h zQ2aT_(o_q|9%0cs3Nhw`OjMXAf~pI@Z$Tsqii;pGuI5slt55UV^^8teMEpHt)mSs` Lll5TCs}|Bss#L_=sLA_$eGQk&F)QWQ`{$`ewME>uBQE9-o>PR}{}+}m~Q zNXb+C2t4r>c;|tS!AIa5@X!Z70Q_do=SJ{GB~sfnH?uptJAZyVKKIXN{ntOf_d{BI z96axW%+FvEeu@&J-cnZ7Q^mMLJx64R5|_pv^*kDvs8=GzD_u&;G_Fvu0^OtM*rrNR zNrW0jWfAJ6D-=~&euljpqE-uaMbuiMHbt!$>LvE>pw)n<@n87tx7d4I0=sYH#EA6e zEKZ`9;t3BdOee#TH5XI{?Sae;?1<=0(fkovqLHFgap>N|LppQl+j;J4j*43&sONTPFX@qDd^vU4zcW@#cu3dcBmaQ zZ&ks35Mc>e+D~F*Z5?uK;)$`rB-HQ%PTNc(ngnBQIg(&H)sskq&W16h8V0|bhk9z` zbRs9oLL^3>nYME9yahWFW{?Ex+&4NiooTGcooSYibZAW{m<{4|!P`%R;mz&#?e=!} zW>;$+47#@lpWYsHyWyRI{^ZtRM~6FM@Ugzr-R{6Pi3go;(=;)iupcCGV6uD+aW6m!27bB%w`{Z3JX4gjWTm3_~ysrfdW-+OqS&Jcx1(V9%WSZsn3Sg*6A zk6#dehm1-W@Vbml?F%|gI?I3@PGR4kOmhr{^SMAFoK6j6D!g$6IL9*-Wb6qK1!hlz zBoH+cbrd`a1ff94Q5KA4WAg~5&Ls;;AZHlH3nRm)i%~AUG?K&TbAKHM{##&jm3@YY z&!}keN^$M@shkhc7!f2Eo*nAI8o$ZLpbNsYnZ(0kpIw<{TA*yU*c-K`>cI3ao^OLz zmgGThg08BN6VJqLY7b=Yf&r#E!grT#X#`*hz|o0N@_Za+gxwF)wAS-$up3d)VEi>~ zWjT?BYb`!S`i#$#pa7TA--MFq{u&$bx(iC@3XV2t4~54cu+F{`QW+L4oPqNV&%6W1 z?EuL^|8+h`ym%?Y@_?%pyPkwnl lMfzXgS*kdHcbrDEM1R45I@02|@UF6^YW3QiHFwqH@89|+OJo25 literal 0 HcmV?d00001 diff --git a/waflib/Tools/c_config.py b/waflib/Tools/c_config.py new file mode 100755 index 0000000..9f29b49 --- /dev/null +++ b/waflib/Tools/c_config.py @@ -0,0 +1,744 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re,shlex,sys +from waflib import Build,Utils,Task,Options,Logs,Errors,ConfigSet,Runner +from waflib.TaskGen import after_method,feature +from waflib.Configure import conf +WAF_CONFIG_H='config.h' +DEFKEYS='define_key' +INCKEYS='include_key' +cfg_ver={'atleast-version':'>=','exact-version':'==','max-version':'<=',} +SNIP_FUNCTION=''' +int main(int argc, char **argv) { + void *p; + (void)argc; (void)argv; + p=(void*)(%s); + return 0; +} +''' +SNIP_TYPE=''' +int main(int argc, char **argv) { + (void)argc; (void)argv; + if ((%(type_name)s *) 0) return 0; + if (sizeof (%(type_name)s)) return 0; + return 1; +} +''' +SNIP_EMPTY_PROGRAM=''' +int main(int argc, char **argv) { + (void)argc; (void)argv; + return 0; +} +''' +SNIP_FIELD=''' +int main(int argc, char **argv) { + char *off; + (void)argc; (void)argv; + off = (char*) &((%(type_name)s*)0)->%(field_name)s; + return (size_t) off < sizeof(%(type_name)s); +} +''' +MACRO_TO_DESTOS={'__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','__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__':'darwin','__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__':'darwin','__QNX__':'qnx','__native_client__':'nacl'} +MACRO_TO_DEST_CPU={'__x86_64__':'x86_64','__amd64__':'x86_64','__i386__':'x86','__ia64__':'ia','__mips__':'mips','__sparc__':'sparc','__alpha__':'alpha','__aarch64__':'aarch64','__thumb__':'thumb','__arm__':'arm','__hppa__':'hppa','__powerpc__':'powerpc','__ppc__':'powerpc','__convex__':'convex','__m68k__':'m68k','__s390x__':'s390x','__s390__':'s390','__sh__':'sh',} +@conf +def parse_flags(self,line,uselib_store,env=None,force_static=False): + assert(isinstance(line,str)) + env=env or self.env + app=env.append_value + appu=env.append_unique + lex=shlex.shlex(line,posix=False) + lex.whitespace_split=True + lex.commenters='' + lst=list(lex) + uselib=uselib_store + while lst: + x=lst.pop(0) + st=x[:2] + ot=x[2:] + if st=='-I'or st=='/I': + if not ot:ot=lst.pop(0) + appu('INCLUDES_'+uselib,[ot]) + elif st=='-include': + tmp=[x,lst.pop(0)] + app('CFLAGS',tmp) + app('CXXFLAGS',tmp) + elif st=='-D'or(env.CXX_NAME=='msvc'and st=='/D'): + if not ot:ot=lst.pop(0) + app('DEFINES_'+uselib,[ot]) + elif st=='-l': + if not ot:ot=lst.pop(0) + prefix=force_static and'STLIB_'or'LIB_' + appu(prefix+uselib,[ot]) + elif st=='-L': + if not ot:ot=lst.pop(0) + appu('LIBPATH_'+uselib,[ot]) + elif x.startswith('/LIBPATH:'): + appu('LIBPATH_'+uselib,[x.replace('/LIBPATH:','')]) + elif x=='-pthread'or x.startswith('+')or x.startswith('-std'): + app('CFLAGS_'+uselib,[x]) + app('CXXFLAGS_'+uselib,[x]) + app('LINKFLAGS_'+uselib,[x]) + elif x=='-framework': + appu('FRAMEWORK_'+uselib,[lst.pop(0)]) + elif x.startswith('-F'): + appu('FRAMEWORKPATH_'+uselib,[x[2:]]) + elif x.startswith('-Wl'): + app('LINKFLAGS_'+uselib,[x]) + elif x.startswith('-m')or x.startswith('-f')or x.startswith('-dynamic'): + app('CFLAGS_'+uselib,[x]) + app('CXXFLAGS_'+uselib,[x]) + elif x.startswith('-bundle'): + app('LINKFLAGS_'+uselib,[x]) + elif x.startswith('-undefined'): + arg=lst.pop(0) + app('LINKFLAGS_'+uselib,[x,arg]) + elif x.startswith('-arch')or x.startswith('-isysroot'): + tmp=[x,lst.pop(0)] + app('CFLAGS_'+uselib,tmp) + app('CXXFLAGS_'+uselib,tmp) + app('LINKFLAGS_'+uselib,tmp) + elif x.endswith('.a')or x.endswith('.so')or x.endswith('.dylib')or x.endswith('.lib'): + appu('LINKFLAGS_'+uselib,[x]) +@conf +def ret_msg(self,f,kw): + 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 + if'atleast_pkgconfig_version'in kw: + if not'msg'in kw: + kw['msg']='Checking for pkg-config version >= %r'%kw['atleast_pkgconfig_version'] + return + if not'okmsg'in kw: + kw['okmsg']='yes' + if not'errmsg'in kw: + kw['errmsg']='not found' + if'modversion'in kw: + if not'msg'in kw: + kw['msg']='Checking for %r version'%kw['modversion'] + return + 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 %r %s %s'%(kw['package'],cfg_ver[x],kw[y]) + return + if not'msg'in kw: + kw['msg']='Checking for %r'%(kw['package']or kw['path']) +@conf +def exec_cfg(self,kw): + def define_it(): + self.define(self.have_define(kw.get('uselib_store',kw['package'])),1,0) + if'atleast_pkgconfig_version'in kw: + cmd=[kw['path'],'--atleast-pkgconfig-version=%s'%kw['atleast_pkgconfig_version']] + self.cmd_and_log(cmd) + if not'okmsg'in kw: + kw['okmsg']='yes' + return + for x in cfg_ver: + y=x.replace('-','_') + if y in kw: + self.cmd_and_log([kw['path'],'--%s=%s'%(x,kw[y]),kw['package']]) + if not'okmsg'in kw: + kw['okmsg']='yes' + define_it() + break + if'modversion'in kw: + version=self.cmd_and_log([kw['path'],'--modversion',kw['modversion']]).strip() + self.define('%s_VERSION'%Utils.quote_define_name(kw.get('uselib_store',kw['modversion'])),version) + return version + lst=[kw['path']] + defi=kw.get('define_variable',None) + if not defi: + defi=self.env.PKG_CONFIG_DEFINES or{} + for key,val in defi.items(): + lst.append('--define-variable=%s=%s'%(key,val)) + if'variables'in kw: + env=kw.get('env',self.env) + uselib=kw.get('uselib_store',kw['package'].upper()) + vars=Utils.to_list(kw['variables']) + for v in vars: + val=self.cmd_and_log(lst+['--variable='+v]).strip() + var='%s_%s'%(uselib,v) + env[var]=val + if not'okmsg'in kw: + kw['okmsg']='yes' + return + static=False + if'args'in kw: + args=Utils.to_list(kw['args']) + if'--static'in args or'--static-libs'in args: + static=True + lst+=args + lst.extend(Utils.to_list(kw['package'])) + ret=self.cmd_and_log(lst) + if not'okmsg'in kw: + kw['okmsg']='yes' + define_it() + self.parse_flags(ret,kw.get('uselib_store',kw['package'].upper()),kw.get('env',self.env),force_static=static) + return ret +@conf +def check_cfg(self,*k,**kw): + if k: + lst=k[0].split() + kw['package']=lst[0] + kw['args']=' '.join(lst[1:]) + self.validate_cfg(kw) + if'msg'in kw: + self.start_msg(kw['msg']) + ret=None + try: + ret=self.exec_cfg(kw) + except self.errors.WafError: + if'errmsg'in kw: + self.end_msg(kw['errmsg'],'YELLOW') + if Logs.verbose>1: + raise + else: + self.fatal('The configuration failed') + else: + kw['success']=ret + if'okmsg'in kw: + self.end_msg(self.ret_msg(kw['okmsg'],kw)) + return ret +@conf +def validate_c(self,kw): + if not'env'in kw: + kw['env']=self.env.derive() + env=kw['env'] + if not'compiler'in kw and not'features'in kw: + kw['compiler']='c' + if env['CXX_NAME']and Task.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'compile_mode'in kw: + kw['compile_mode']='c' + if'cxx'in Utils.to_list(kw.get('features',[]))or kw.get('compiler','')=='cxx': + kw['compile_mode']='cxx' + if not'type'in kw: + kw['type']='cprogram' + if not'features'in kw: + kw['features']=[kw['compile_mode'],kw['type']] + else: + kw['features']=Utils.to_list(kw['features']) + if not'compile_filename'in kw: + kw['compile_filename']='test.c'+((kw['compile_mode']=='cxx')and'pp'or'') + 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'' + if'framework_name'in kw: + 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 + 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)+SNIP_FUNCTION%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'header_name'in kw: + kw['header_name']='stdint.h' + if'field_name'in kw: + field=kw['field_name'] + kw['code']=to_header(kw)+SNIP_FIELD%{'type_name':tu,'field_name':field} + if not'msg'in kw: + kw['msg']='Checking for field %s in %s'%(field,tu) + if not'define_name'in kw: + kw['define_name']=self.have_define((tu+'_'+field).upper()) + else: + kw['code']=to_header(kw)+SNIP_TYPE%{'type_name':tu} + if not'msg'in kw: + kw['msg']='Checking for type %s'%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)+SNIP_EMPTY_PROGRAM + 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'stlib'in kw: + if not'msg'in kw: + kw['msg']='Checking for static library %s'%kw['stlib'] + if not'uselib_store'in kw: + kw['uselib_store']=kw['stlib'].upper() + if'fragment'in kw: + kw['code']=kw['fragment'] + if not'msg'in kw: + kw['msg']='Checking for code snippet' + 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 kw['execute']: + kw['features'].append('test_exec') + if not'errmsg'in kw: + kw['errmsg']='not found' + if not'okmsg'in kw: + kw['okmsg']='yes' + if not'code'in kw: + kw['code']=SNIP_EMPTY_PROGRAM + if self.env[INCKEYS]: + kw['code']='\n'.join(['#include <%s>'%x for x in self.env[INCKEYS]])+'\n'+kw['code'] + if not kw.get('success'):kw['success']=None + if'define_name'in kw: + self.undefine(kw['define_name']) + assert'msg'in kw,'invalid parameters, read http://freehackers.org/~tnagy/wafbook/single.html#config_helpers_c' +@conf +def post_check(self,*k,**kw): + is_success=0 + if kw['execute']: + if kw['success']is not None: + if kw.get('define_ret',False): + is_success=kw['success'] + else: + is_success=(kw['success']==0) + 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']and kw.get('define_ret',None)and isinstance(is_success,str): + self.define(kw['define_name'],is_success,quote=kw.get('quote',1)) + else: + self.define_cond(kw['define_name'],is_success) + else: + self.define_cond(kw['define_name'],is_success) + if'header_name'in kw: + if kw.get('auto_add_header_name',False): + self.env.append_value(INCKEYS,Utils.to_list(kw['header_name'])) + if is_success and'uselib_store'in kw: + from waflib.Tools import ccroot + _vars=set([]) + for x in kw['features']: + if x in ccroot.USELIB_VARS: + _vars|=ccroot.USELIB_VARS[x] + for k in _vars: + lk=k.lower() + if k=='INCLUDES':lk='includes' + if k=='DEFINES':lk='defines' + if lk in kw: + val=kw[lk] + if isinstance(val,str): + val=val.rstrip(os.path.sep) + self.env.append_unique(k+'_'+kw['uselib_store'],val) + return is_success +@conf +def check(self,*k,**kw): + self.validate_c(kw) + self.start_msg(kw['msg']) + ret=None + try: + ret=self.run_c_code(*k,**kw) + except self.errors.ConfigurationError: + self.end_msg(kw['errmsg'],'YELLOW') + if Logs.verbose>1: + raise + else: + self.fatal('The configuration failed') + else: + kw['success']=ret + ret=self.post_check(*k,**kw) + if not ret: + self.end_msg(kw['errmsg'],'YELLOW') + self.fatal('The configuration failed %r'%ret) + else: + self.end_msg(self.ret_msg(kw['okmsg'],kw)) + return ret +class test_exec(Task.Task): + color='PINK' + def run(self): + if getattr(self.generator,'rpath',None): + if getattr(self.generator,'define_ret',False): + self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()]) + else: + self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()]) + else: + env=self.env.env or{} + env.update(dict(os.environ)) + for var in('LD_LIBRARY_PATH','DYLD_LIBRARY_PATH','PATH'): + env[var]=self.inputs[0].parent.abspath()+os.path.pathsep+env.get(var,'') + if getattr(self.generator,'define_ret',False): + self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()],env=env) + else: + self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()],env=env) +@feature('test_exec') +@after_method('apply_link') +def test_exec_fun(self): + self.create_task('test_exec',self.link_task.outputs[0]) +CACHE_RESULTS=1 +COMPILE_ERRORS=2 +@conf +def run_c_code(self,*k,**kw): + lst=[str(v)for(p,v)in kw.items()if p!='env'] + h=Utils.h_list(lst) + dir=self.bldnode.abspath()+os.sep+(not Utils.is_win32 and'.'or'')+'conf_check_'+Utils.to_hex(h) + try: + os.makedirs(dir) + except OSError: + pass + try: + os.stat(dir) + except OSError: + self.fatal('cannot use the configuration test folder %r'%dir) + cachemode=getattr(Options.options,'confcache',None) + if cachemode==CACHE_RESULTS: + try: + proj=ConfigSet.ConfigSet(os.path.join(dir,'cache_run_c_code')) + except OSError: + pass + else: + ret=proj['cache_run_c_code'] + if isinstance(ret,str)and ret.startswith('Test does not build'): + self.fatal(ret) + return ret + bdir=os.path.join(dir,'testbuild') + if not os.path.exists(bdir): + os.makedirs(bdir) + self.test_bld=bld=Build.BuildContext(top_dir=dir,out_dir=bdir) + bld.init_dirs() + bld.progress_bar=0 + bld.targets='*' + if kw['compile_filename']: + node=bld.srcnode.make_node(kw['compile_filename']) + node.write(kw['code']) + bld.logger=self.logger + bld.all_envs.update(self.all_envs) + bld.env=kw['env'] + o=bld(features=kw['features'],source=kw['compile_filename'],target='testprog') + for k,v in kw.items(): + setattr(o,k,v) + self.to_log("==>\n%s\n<=="%kw['code']) + bld.targets='*' + ret=-1 + try: + try: + bld.compile() + except Errors.WafError: + ret='Test does not build: %s'%Utils.ex_stack() + self.fatal(ret) + else: + ret=getattr(bld,'retval',0) + finally: + proj=ConfigSet.ConfigSet() + proj['cache_run_c_code']=ret + proj.store(os.path.join(dir,'cache_run_c_code')) + 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']='c' + return self.check(*k,**kw) +@conf +def define(self,key,val,quote=True): + assert key and isinstance(key,str) + if val is True: + val=1 + elif val in(False,None): + val=0 + if isinstance(val,int)or isinstance(val,float): + s='%s=%s' + else: + s=quote and'%s="%s"'or'%s=%s' + app=s%(key,str(val)) + ban=key+'=' + lst=self.env['DEFINES'] + for x in lst: + if x.startswith(ban): + lst[lst.index(x)]=app + break + else: + self.env.append_value('DEFINES',app) + self.env.append_unique(DEFKEYS,key) +@conf +def undefine(self,key): + assert key and isinstance(key,str) + ban=key+'=' + lst=[x for x in self.env['DEFINES']if not x.startswith(ban)] + self.env['DEFINES']=lst + self.env.append_unique(DEFKEYS,key) +@conf +def define_cond(self,key,val): + assert key and isinstance(key,str) + if val: + self.define(key,1) + else: + self.undefine(key) +@conf +def is_defined(self,key): + assert key and isinstance(key,str) + ban=key+'=' + for x in self.env['DEFINES']: + if x.startswith(ban): + return True + return False +@conf +def get_define(self,key): + assert key and isinstance(key,str) + ban=key+'=' + for x in self.env['DEFINES']: + if x.startswith(ban): + return x[len(ban):] + return None +@conf +def have_define(self,key): + return(self.env.HAVE_PAT or'HAVE_%s')%Utils.quote_define_name(key) +@conf +def write_config_header(self,configfile='',guard='',top=False,env=None,defines=True,headers=False,remove=True,define_prefix=''): + if env: + Logs.warn('Cannot pass env to write_config_header') + if not configfile:configfile=WAF_CONFIG_H + waf_guard=guard or'W_%s_WAF'%Utils.quote_define_name(configfile) + node=top and self.bldnode or self.path.get_bld() + node=node.make_node(configfile) + node.parent.mkdir() + lst=['/* WARNING! All changes made to this file will be lost! */\n'] + lst.append('#ifndef %s\n#define %s\n'%(waf_guard,waf_guard)) + lst.append(self.get_config_header(defines,headers,define_prefix=define_prefix)) + lst.append('\n#endif /* %s */\n'%waf_guard) + node.write('\n'.join(lst)) + self.env.append_unique(Build.CFG_FILES,[node.abspath()]) + if remove: + for key in self.env[DEFKEYS]: + self.undefine(key) + self.env[DEFKEYS]=[] +@conf +def get_config_header(self,defines=True,headers=False,define_prefix=''): + lst=[] + if headers: + for x in self.env[INCKEYS]: + lst.append('#include <%s>'%x) + if defines: + for x in self.env[DEFKEYS]: + if self.is_defined(x): + val=self.get_define(x) + lst.append('#define %s %s'%(define_prefix+x,val)) + else: + lst.append('/* #undef %s */'%(define_prefix+x)) + return"\n".join(lst) +@conf +def cc_add_flags(conf): + conf.add_os_flags('CPPFLAGS','CFLAGS') + conf.add_os_flags('CFLAGS') +@conf +def cxx_add_flags(conf): + conf.add_os_flags('CPPFLAGS','CXXFLAGS') + conf.add_os_flags('CXXFLAGS') +@conf +def link_add_flags(conf): + conf.add_os_flags('LINKFLAGS') + conf.add_os_flags('LDFLAGS','LINKFLAGS') +@conf +def cc_load_tools(conf): + if not conf.env.DEST_OS: + conf.env.DEST_OS=Utils.unversioned_sys_platform() + conf.load('c') +@conf +def cxx_load_tools(conf): + if not conf.env.DEST_OS: + conf.env.DEST_OS=Utils.unversioned_sys_platform() + conf.load('cxx') +@conf +def get_cc_version(conf,cc,gcc=False,icc=False): + cmd=cc+['-dM','-E','-'] + env=conf.env.env or None + try: + p=Utils.subprocess.Popen(cmd,stdin=Utils.subprocess.PIPE,stdout=Utils.subprocess.PIPE,stderr=Utils.subprocess.PIPE,env=env) + p.stdin.write('\n') + out=p.communicate()[0] + except Exception: + conf.fatal('Could not determine the compiler version %r'%cmd) + if not isinstance(out,str): + out=out.decode(sys.stdout.encoding or'iso8859-1') + if gcc: + if out.find('__INTEL_COMPILER')>=0: + conf.fatal('The intel compiler pretends to be gcc') + if out.find('__GNUC__')<0 and out.find('__clang__')<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.splitlines() + 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' + if not conf.env.DEST_OS: + conf.env.DEST_OS='' + for i in MACRO_TO_DESTOS: + if isD(i): + conf.env.DEST_OS=MACRO_TO_DESTOS[i] + break + else: + if isD('__APPLE__')and isD('__MACH__'): + conf.env.DEST_OS='darwin' + elif isD('__unix__'): + conf.env.DEST_OS='generic' + if isD('__ELF__'): + conf.env.DEST_BINFMT='elf' + elif isD('__WINNT__')or isD('__CYGWIN__')or isD('_WIN32'): + conf.env.DEST_BINFMT='pe' + conf.env.LIBDIR=conf.env.BINDIR + elif isD('__APPLE__'): + conf.env.DEST_BINFMT='mac-o' + if not conf.env.DEST_BINFMT: + conf.env.DEST_BINFMT=Utils.destos_to_binfmt(conf.env.DEST_OS) + for i in MACRO_TO_DEST_CPU: + if isD(i): + conf.env.DEST_CPU=MACRO_TO_DEST_CPU[i] + break + Logs.debug('ccroot: dest platform: '+' '.join([conf.env[x]or'?'for x in('DEST_OS','DEST_BINFMT','DEST_CPU')])) + if icc: + ver=k['__INTEL_COMPILER'] + conf.env['CC_VERSION']=(ver[:-2],ver[-2],ver[-1]) + else: + if isD('__clang__'): + conf.env['CC_VERSION']=(k['__clang_major__'],k['__clang_minor__'],k['__clang_patchlevel__']) + else: + conf.env['CC_VERSION']=(k['__GNUC__'],k['__GNUC_MINOR__'],k['__GNUC_PATCHLEVEL__']) + return k +@conf +def get_xlc_version(conf,cc): + cmd=cc+['-qversion'] + try: + out,err=conf.cmd_and_log(cmd,output=0) + except Errors.WafError: + conf.fatal('Could not find xlc %r'%cmd) + for v in(r"IBM XL C/C\+\+.* V(?P\d*)\.(?P\d*)",): + version_re=re.compile(v,re.I).search + match=version_re(out or err) + if match: + k=match.groupdict() + conf.env['CC_VERSION']=(k['major'],k['minor']) + break + else: + conf.fatal('Could not determine the XLC version.') +@conf +def get_suncc_version(conf,cc): + cmd=cc+['-V'] + try: + out,err=conf.cmd_and_log(cmd,output=0) + except Errors.WafError: + conf.fatal('Could not find suncc %r'%cmd) + version=(out or err) + version=version.split('\n')[0] + version_re=re.compile(r'cc:\s+sun\s+(c\+\+|c)\s+(?P\d*)\.(?P\d*)',re.I).search + match=version_re(version) + if match: + k=match.groupdict() + conf.env['CC_VERSION']=(k['major'],k['minor']) + else: + conf.fatal('Could not determine the suncc version.') +@conf +def add_as_needed(self): + if self.env.DEST_BINFMT=='elf'and'gcc'in(self.env.CXX_NAME,self.env.CC_NAME): + self.env.append_unique('LINKFLAGS','--as-needed') +class cfgtask(Task.TaskBase): + def display(self): + return'' + def runnable_status(self): + return Task.RUN_ME + def uid(self): + return Utils.SIG_NIL + def run(self): + conf=self.conf + bld=Build.BuildContext(top_dir=conf.srcnode.abspath(),out_dir=conf.bldnode.abspath()) + bld.env=conf.env + bld.init_dirs() + bld.in_msg=1 + bld.logger=self.logger + try: + bld.check(**self.args) + except Exception: + return 1 +@conf +def multicheck(self,*k,**kw): + self.start_msg(kw.get('msg','Executing %d configuration tests'%len(k))) + class par(object): + def __init__(self): + self.keep=False + self.cache_global=Options.cache_global + self.nocache=Options.options.nocache + self.returned_tasks=[] + self.task_sigs={} + def total(self): + return len(tasks) + def to_log(self,*k,**kw): + return + bld=par() + tasks=[] + for dct in k: + x=cfgtask(bld=bld) + tasks.append(x) + x.args=dct + x.bld=bld + x.conf=self + x.args=dct + x.logger=Logs.make_mem_logger(str(id(x)),self.logger) + def it(): + yield tasks + while 1: + yield[] + p=Runner.Parallel(bld,Options.options.jobs) + p.biter=it() + p.start() + for x in tasks: + x.logger.memhandler.flush() + for x in tasks: + if x.hasrun!=Task.SUCCESS: + self.end_msg(kw.get('errmsg','no'),color='YELLOW') + self.fatal(kw.get('fatalmsg',None)or'One of the tests has failed, see the config.log for more information') + self.end_msg('ok') diff --git a/waflib/Tools/c_config.pyc b/waflib/Tools/c_config.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d100b258ae942709bb7293d315b927247c46861 GIT binary patch literal 32674 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 literal 0 HcmV?d00001 diff --git a/waflib/Tools/c_osx.py b/waflib/Tools/c_osx.py new file mode 100644 index 0000000..579b2a7 --- /dev/null +++ b/waflib/Tools/c_osx.py @@ -0,0 +1,120 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shutil,sys,platform +from waflib import TaskGen,Task,Build,Options,Utils,Errors +from waflib.TaskGen import taskgen_method,feature,after_method,before_method +app_info=''' + + + + + CFBundlePackageType + APPL + CFBundleGetInfoString + Created by Waf + CFBundleSignature + ???? + NOTE + THIS IS A GENERATED FILE, DO NOT MODIFY + CFBundleExecutable + %s + + +''' +@feature('c','cxx') +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 Utils.unversioned_sys_platform()=='darwin': + os.environ['MACOSX_DEPLOYMENT_TARGET']='.'.join(platform.mac_ver()[0].split('.')[:2]) +@taskgen_method +def create_bundle_dirs(self,name,out): + bld=self.bld + dir=out.parent.find_or_declare(name) + dir.mkdir() + macos=dir.find_or_declare(['Contents','MacOS']) + macos.mkdir() + 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 +@feature('cprogram','cxxprogram') +@after_method('apply_link') +def create_task_macapp(self): + if self.env['MACAPP']or getattr(self,'mac_app',False): + 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]) + self.apptask=self.create_task('macapp',self.link_task.outputs,n1) + inst_to=getattr(self,'install_path','/Applications')+'/%s/Contents/MacOS/'%name + self.bld.install_files(inst_to,n1,chmod=Utils.O755) + if getattr(self,'mac_resources',None): + res_dir=n1.parent.parent.make_node('Resources') + inst_to=getattr(self,'install_path','/Applications')+'/%s/Resources'%name + for x in self.to_list(self.mac_resources): + node=self.path.find_node(x) + if not node: + raise Errors.WafError('Missing mac_resource %r in %r'%(x,self)) + parent=node.parent + if os.path.isdir(node.abspath()): + nodes=node.ant_glob('**') + else: + nodes=[node] + for node in nodes: + rel=node.path_from(parent) + tsk=self.create_task('macapp',node,res_dir.make_node(rel)) + self.bld.install_as(inst_to+'/%s'%rel,node) + if getattr(self.bld,'is_install',None): + self.install_task.hasrun=Task.SKIP_ME +@feature('cprogram','cxxprogram') +@after_method('apply_link') +def create_task_macplist(self): + if self.env['MACAPP']or getattr(self,'mac_app',False): + 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','Info.plist']) + self.plisttask=plisttask=self.create_task('macplist',[],n1) + if getattr(self,'mac_plist',False): + node=self.path.find_resource(self.mac_plist) + if node: + plisttask.inputs.append(node) + else: + plisttask.code=self.mac_plist + else: + plisttask.code=app_info%self.link_task.outputs[0].name + inst_to=getattr(self,'install_path','/Applications')+'/%s/Contents/'%name + self.bld.install_files(inst_to,n1) +@feature('cshlib','cxxshlib') +@before_method('apply_link','propagate_uselib_vars') +def apply_bundle(self): + if self.env['MACBUNDLE']or getattr(self,'mac_bundle',False): + self.env['LINKFLAGS_cshlib']=self.env['LINKFLAGS_cxxshlib']=[] + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['macbundle_PATTERN'] + use=self.use=self.to_list(getattr(self,'use',[])) + if not'MACBUNDLE'in use: + use.append('MACBUNDLE') +app_dirs=['Contents','Contents/MacOS','Contents/Resources'] +class macapp(Task.Task): + color='PINK' + def run(self): + self.outputs[0].parent.mkdir() + shutil.copy2(self.inputs[0].srcpath(),self.outputs[0].abspath()) +class macplist(Task.Task): + color='PINK' + ext_in=['.bin'] + def run(self): + if getattr(self,'code',None): + txt=self.code + else: + txt=self.inputs[0].read() + self.outputs[0].write(txt) diff --git a/waflib/Tools/c_osx.pyc b/waflib/Tools/c_osx.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a2f3617d659797aa7b105f5b568dee967d3ab78 GIT binary patch literal 6577 zcmc&&&2k&Z5$**@5P31(s!;#hooUL)tcfh(6hgLB9+50HG_vjAb*zT_aWxPzIVo|&GW?yq|$`=6=e z-~Rn))1mZl48Om_r#c3ai+_UxqUNw}P}3ODGt|rs>RD=LrJkW+jJo609H(xMnmOuD zP;-L1d1~gVTcBovx7P}O0nz}R8oB_ueHD}42B6pnJ z9KFP96Z9?7OGt5@yh(ENgXSE$1+F*eg}+GdHRkuG$(>|=cPi!Nu{VB!XL^KZL3n1! zot1e|!E)C{hPe^8MRMoKy+Q5*9YF_6Jo{IFW;1-?p3_2>0Qb-%RM_5<&e zN+pOKJ2;M1QmLP*#Oqe}{8ntoXO*4Cj;b8SQO}E$vptMlcN2FF^XX}Z>%O=CF;iXN zNgfspnjp|jt#^<~B68^VJPpY-5xz(ud zlpgQyRo^Y`9F#Diw12R(`}q0QsRlc*_C4n`v0K4UHvX2n9J5)`THCCMP9GK%oGUp= zmdk$M;TC_~-o~fSQQ+$c0IbBn9%*1`2aagaX4v2#-9DM1xKEg{Ge$2lDnln3roh8H z;{?m>ObC69Ryuj6vQLgv2|t$;zUWgZNK+Rls3pq~V}EP=p#GJ$Q$5@}c)nk)HLS*# z`J~zqYj^GV8$XoYtovXlKZBxNKp~s+!mksi!0gzg(DdUdG{rl3^3yOiFVD5qnX-C; zoxuLP;&Yt{Q|G}or1BhH+p#c6+)hEANtrb#1C$rE%V>}k%0aF2RKag5Js$?&i=&R` zB&uScw)`k9*T1pbckiu#xPEWr?uO@ic5CB)>!S}_8yn8YE$@T-t@l0WeaC*_eY|n6 z0^Y!HRT@zgsET7ns=wYlOIERt@)8S@fnvE{FNn^%01hj$<0CI&Y*9rNl$kP?j2UCj zaQLJdF8FsFpZXkyKJkkzoo5L6k7GVJ_@FMv=zNSiI5e0E*W~9VWp=(7k_TU7dijuo0t{;m*m`h+0 zO@}t{jOU0>6Y~~RxdA>sf)()^4q^^6I0741OK{18MCwgY6=N-B3Q&E~SimPP$1<~Z zZsSv2qz7QI-f;l%F4jJd0SbpljZ^%9yU;Abg_bT13X4og8>ngZ)=Y+eaR|k>zHaw= zWnRg=gFL9V1W;!HmLr8T03C0Ia=6T_Z z0s*T#7`!5sn~W6Ti7yOhxJB-a%vhuln}mWedy)EI(s>b!*V3grt8`uvzH1_j)*Pfj z^tevvNa&#QEL}h?T0d{FevqJ{YjFwF;yjEOe=(lDm^Ge3HmxZr5_wyytl3O*n>u%7 zf)ZJ8(u>*5Amp(3)&!6ca*#Gi#9*|CHHj;kE8s90O@#|x=#ebSM;c}afz`8iU46n{Lne>A}!-Fyj1L|=rndbm2e0%2Q57(X1Juhf&P78 zDdae%(UGOM;*uYtRP68XyrZ)C!Q$d3zOqtL%WFJ8L#}KSQNm6Vjh>I~0MUfkX9q$I zQ76Kq9a5QZ^T=Ou!7^w>xrSPbd_#U#4#sMD<_!+C#0jC&F_^*W;KK(G1k`I$=$Wga z$l_i5#IwT4^VCi{wG1BY+BrDQ1M zfsGJ(6htkVhpAROjx?YQWVMwk;hl%pzt}yr_NzZSaoH^gv141sr(v1*DPigoRZR{6 zl7)o#L>dXt)LOdYa z0H4^$YUVpA&EKN9ge1xB_#(3|*}b>`&PO-cj~O4NW!^>WX8?+=_D29!z5$BBgUQEh zZgBBF7Z13&0s$X@rhSNgRGj`(Ch@f5ojO(wIu_#uM3zOllNywDZf$DPs>@j(Mp zwIe|nK@jsJj4HFi{G5B4pL0i@i#;xOQIzq$;!K>iHUfj}C8GBl=xUYa8T!dW>LWR0 zJ~NZK311PtIO-S~zD{uZecf2VIAk|H`v@0O>lC*Pzh!-G$4Y#NVV*TAKJ-^q*yeuG zhrVOGXNzZ+EN!N>v0-hTRtDXAjUp=THD#HN?>9O)d?V+hG=iM_Qm79ttWLW)d$1R2yvj9>mXxj znmQhCH5yg3CeI#voHZcvq{tCPpF<)?Mrc!CEjSd8*!m_nku;F`B?_H8^X)@uufek9 ztwyq1y;&Qw=)4#fwQSrm)_}f}pr~nd{W#N5tiB;>m_wNFg6!avKgQ!n_!Mu`!%G^j z6)5GZ_bn<}_?PHGJoOMKB<9D%I3A1n@%YrD0O9%y`4V?V1TMS_aE}yqi zfWZz+>Q!ojZ`$Dnb5=38c^ifJi8?;Tlb6n*qTbnk^C|amlvc6Bq1@a;U9RSW7q8*S zvJe0%L6>D>4Uuuf(3jsl8kQwD9ZSsLvXBIx2A*Z5I|`!Mgoln`m~7xxJt>G~oM3$s zJckf&{sAoqpZpDNrG(}cTS0EmPr(^};cSkv(Xb-SHVSG!Tu@Ky`aMM6Qlu(L!SM(E;#vL{&CLtOIkgqBU1;b2glpWP4Tjgp zh252~Cc6J7_7m^Y-*w8>PhP$K$oVVCr`TKwiPU6f-Y9drWb)CN0T*mt;t*axLBxEm zM#Co3!>2eLvC$L^dDoUS+(g9CuQYgPGdWO-*!o3_(*lx2+vIR&ipB8R=$xJrO*5`H zkbL4z+~g%pIabz=$#KQ}iVJ?#)3=kixpv6Kb1q<}`gXv%1;5LPk&9hl9",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[a-fA-F0-9]+)(?P[uUlL]*)|L*?'(?P(\\.|[^\\'])+)'|(?P\d+)[Ee](?P[+-]*?\d+)(?P[fFlL]*)|(?P\d*\.\d+)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P\d+\.\d*)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P0*)(?P\d+)(?P[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): + s=m.group(0) + if s.startswith('/'): + return' ' + return s +def filter_comments(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_lines,code)] +prec={} +ops=['* / %','+ -','<< >>','< <= >= >','== !=','& | ^','&& ||',','] +for x in range(len(ops)): + syms=ops[x] + for u in syms.split(): + prec[u]=x +def trimquotes(s): + if not s:return'' + s=s.rstrip() + if s[0]=="'"and s[-1]=="'":return s[1:-1] + return s +def reduce_nums(val_1,val_2,val_op): + 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':c=int(a>b) + elif d=='>=':c=int(a>=b) + elif d=='^':c=int(a^b) + elif d=='<<':c=a<>':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=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): + num,lst=get_term(lst) + return(NUM,num) +def stringize(lst): + lst=[str(v2)for(p2,v2)in lst] + return"".join(lst) +def paste_tokens(t1,t2): + 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=[]): + i=0 + while 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 i1: + (p3,v3)=accu[-1] + (p4,v4)=accu[-2] + if v3=='##': + accu.pop() + if v4==','and pt.*)>|"(?P.*)")') +def extract_include(txt,defs): + m=re_include.search(txt) + if m: + if m.group('a'):return'<',m.group('a') + if m.group('b'):return'"',m.group('b') + 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) +def tokenize(s): + return tokenize_private(s)[:] +@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: + 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: + v=v[1:-1] + ret.append((name,v)) + break + return ret +@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=[] + if defines is None: + self.defs={} + else: + self.defs=dict(defines) + self.state=[] + self.count_files=0 + self.currentnode_stack=[] + self.nodepaths=nodepaths or[] + self.nodes=[] + self.names=[] + self.curfile='' + self.ban_includes=set([]) + def cached_find_resource(self,node,filename): + try: + nd=node.ctx.cache_nd + except AttributeError: + nd=node.ctx.cache_nd={} + tup=(node,filename) + try: + return nd[tup] + except KeyError: + ret=node.find_resource(filename) + if ret: + if getattr(ret,'children',None): + ret=None + elif ret.is_child_of(node.ctx.bldnode): + tmp=node.ctx.srcnode.search_node(ret.path_from(node.ctx.bldnode)) + if tmp and getattr(tmp,'children',None): + ret=None + nd[tup]=ret + return ret + def tryfind(self,filename): + self.curfile=filename + 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 and not found in self.ban_includes: + 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.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 + 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) + bld=node.ctx + try: + self.parse_cache=bld.parse_cache + except AttributeError: + bld.parse_cache={} + self.parse_cache=bld.parse_cache + self.current_file=node + self.addlines(node) + if env['DEFINES']: + try: + lst=['%s %s'%(x[0],trimquotes('='.join(x[1:])))for x in[y.split('=')for y in env['DEFINES']]] + lst.reverse() + self.lines.extend([('define',x)for x in lst]) + except AttributeError: + pass + while self.lines: + (token,line)=self.lines.pop() + if token==POPFILE: + self.count_files-=1 + self.currentnode_stack.pop() + continue + try: + ve=Logs.verbose + if ve:debug('preproc: line is %s - %s state is %s',token,line,self.state) + state=self.state + if token[:2]=='if': + state.append(undefined) + elif token=='endif': + state.pop() + if token[0]!='e': + if skipped in self.state or ignored in self.state: + continue + 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 ve:debug('preproc: include found %s (%s) ',inc,kind) + if kind=='"'or not strict_quotes: + self.current_file=self.tryfind(inc) + if token=='import': + self.ban_includes.add(self.current_file) + 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 Exception: + 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)) + elif token=='pragma': + if re_pragma_once.match(line.lower()): + self.ban_includes.add(self.current_file) + except Exception ,e: + if Logs.verbose: + debug('preproc: line parsing failed (%s): %s %s',e,line,Utils.ex_stack()) +def scan(task): + global go_absolute + try: + incn=task.generator.includes_nodes + except AttributeError: + raise Errors.WafError('%r is missing a feature such as "c", "cxx" or "includes": '%task.generator) + if go_absolute: + nodepaths=incn+[task.generator.bld.root.find_dir(x)for x in standard_includes] + else: + nodepaths=[x for x in incn if x.is_child_of(x.ctx.srcnode)or x.is_child_of(x.ctx.bldnode)] + tmp=c_parser(nodepaths) + tmp.start(task.inputs[0],task.env) + if Logs.verbose: + debug('deps: deps for %r: %r; unresolved %r'%(task.inputs,tmp.nodes,tmp.names)) + return(tmp.nodes,tmp.names) diff --git a/waflib/Tools/c_preproc.pyc b/waflib/Tools/c_preproc.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a946c89e1aba9c798e07bb95bcc62d28d4e7f3df GIT binary patch literal 22385 zcmc(HdvILWdEdFac#|LqfW$+j#05!!3y>iAvM7-ND2k+LNfbz3P=*XHxL)kN02c&y z7x!LJpuKR?P&1ZWc^W_Bj1qO?X(wr=*mC1K@x-In_Qdg|)1>Yro;0mzJd;kFc;dEh z-PRqCTle?-ox6*rL?-!5B(Z1DJ?A^G?|iTGo$qe)N9}E2{>xY0yovv{;QI-D!aqwI za(f-T2yJyq);!F-LyCm{foDF{Q_cs*eN8^cXhT zRW01BOs@)eR}1$k^Ke|HF&^Op{XNFpZ@fW5pP$=pGUzE~W(SNnWc-xr^#{yC!dy?7 z)t8;wy;^;%@eW`WY2yv!Ys7d5@pZ^}qxd>(yfJ(oG2T&p9W&l>e4Q}f`|$Os@lN9F zG2=as)$cRjDKm?qPn+36&P$*#pL#G_z^r?>GJd<6{}7w`-g?4F)n2mlg5mW z8t=TB#mq66Jz0rhrGRvBFaFqcvrj>cpcvqD$A22V2el8eqMukrq??q)U zR+0BXQ54oPt8%R9nle~dMww^D5LnYdn8`ZBaR&HPKd- zT?zbhP|6E5k7xaJkUoh|NWp^Lh4gTz)2yk!$L1e9Ie+|k z{_%PL(PQ%`{QQZ0?tT8_$B&KycDXP=cC}Pm4#)D@vR%O8@@GyvjRT$xZoDFCz!B)zXP zcxu>Y3k#mVP$?`F?N`NL4t*qrg^FMFkj5*l6jsWZR0U9lqF-4Pcsa-|uH@p54v!4C zkL(ZIHA-&u!)HflvvZl3M#6{gD!FE>j*LE@og2B9o(s3IIunkRig_PjA<>@6w2!of zCy^T)J3Mk`e`PE)g73`8SS52HedbgqbGUNtdM1-OFgHAsIZ)YKSGE^Ld&5?=ofsV( zIFKG5pVZU7k7g>@ug!gALzp~sM)*5YXa=CNxdJy^+4%ySD;q(t#MxqjQ&s6gffS(Z ztpZo9Y*5G`8*<|^g#*>n1F9=1y{z=A(oktW+zbQKlA#KGYM6;>3FPG-D=!`CkO z>eF8@ADO&%aC8m`L@^;2mP@$^g$qyFF4gK7T8(553#P6uMy|CTK2vLr;=5X(;FxSZ zGMuh!eeB+?QC#1;l#eElpdlxJM3ZNh>jq%F?ywUWy>w=8`r7rqnao@T3+G02BVwAe z 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 +int main(int argc, char **argv) { + (void)argc; (void)argv; + return !(sizeof(off_t) >= 8); +} +''' +@conf +def check_large_file(self,**kw): + if not'define_name'in kw: + kw['define_name']='HAVE_LARGEFILE' + if not'execute'in kw: + kw['execute']=True + if not'features'in kw: + if self.env.CXX: + kw['features']=['cxx','cxxprogram'] + else: + kw['features']=['c','cprogram'] + kw['fragment']=LARGE_FRAGMENT + kw['msg']='Checking for large file support' + ret=True + try: + if self.env.DEST_BINFMT!='pe': + ret=self.check(**kw) + except self.errors.ConfigurationError: + pass + else: + if ret: + return True + kw['msg']='Checking for -D_FILE_OFFSET_BITS=64' + kw['defines']=['_FILE_OFFSET_BITS=64'] + try: + ret=self.check(**kw) + except self.errors.ConfigurationError: + pass + else: + self.define('_FILE_OFFSET_BITS',64) + return ret + self.fatal('There is no support for large files') +ENDIAN_FRAGMENT=''' +short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; +short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; +int use_ascii (int i) { + return ascii_mm[i] + ascii_ii[i]; +} +short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; +short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; +int use_ebcdic (int i) { + return ebcdic_mm[i] + ebcdic_ii[i]; +} +extern int foo; +''' +class grep_for_endianness(Task.Task): + color='PINK' + def run(self): + txt=self.inputs[0].read(flags='rb').decode('iso8859-1') + if txt.find('LiTTleEnDian')>-1: + self.generator.tmp.append('little') + elif txt.find('BIGenDianSyS')>-1: + self.generator.tmp.append('big') + else: + return-1 +@feature('grep_for_endianness') +@after_method('process_source') +def grep_for_endianness_fun(self): + self.create_task('grep_for_endianness',self.compiled_tasks[0].outputs[0]) +@conf +def check_endianness(self): + tmp=[] + def check_msg(self): + return tmp[0] + self.check(fragment=ENDIAN_FRAGMENT,features='c grep_for_endianness',msg="Checking for endianness",define='ENDIANNESS',tmp=tmp,okmsg=check_msg) + return tmp[0] diff --git a/waflib/Tools/c_tests.pyc b/waflib/Tools/c_tests.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9f8ad21ac463946e2c2414b4d3e5ea5adea8464 GIT binary patch literal 6660 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 literal 0 HcmV?d00001 diff --git a/waflib/Tools/ccroot.py b/waflib/Tools/ccroot.py new file mode 100644 index 0000000..6a94573 --- /dev/null +++ b/waflib/Tools/ccroot.py @@ -0,0 +1,405 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re +from waflib import Task,Utils,Node,Errors +from waflib.TaskGen import after_method,before_method,feature,taskgen_method,extension +from waflib.Tools import c_aliases,c_preproc,c_config,c_osx,c_tests +from waflib.Configure import conf +SYSTEM_LIB_PATHS=['/usr/lib64','/usr/lib','/usr/local/lib64','/usr/local/lib'] +USELIB_VARS=Utils.defaultdict(set) +USELIB_VARS['c']=set(['INCLUDES','FRAMEWORKPATH','DEFINES','CPPFLAGS','CCDEPS','CFLAGS','ARCH']) +USELIB_VARS['cxx']=set(['INCLUDES','FRAMEWORKPATH','DEFINES','CPPFLAGS','CXXDEPS','CXXFLAGS','ARCH']) +USELIB_VARS['d']=set(['INCLUDES','DFLAGS']) +USELIB_VARS['includes']=set(['INCLUDES','FRAMEWORKPATH','ARCH']) +USELIB_VARS['cprogram']=USELIB_VARS['cxxprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS','FRAMEWORK','FRAMEWORKPATH','ARCH']) +USELIB_VARS['cshlib']=USELIB_VARS['cxxshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS','FRAMEWORK','FRAMEWORKPATH','ARCH']) +USELIB_VARS['cstlib']=USELIB_VARS['cxxstlib']=set(['ARFLAGS','LINKDEPS']) +USELIB_VARS['dprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +USELIB_VARS['dshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +USELIB_VARS['dstlib']=set(['ARFLAGS','LINKDEPS']) +USELIB_VARS['asm']=set(['ASFLAGS']) +@taskgen_method +def create_compiled_task(self,name,node): + out='%s.%d.o'%(node.name,self.idx) + task=self.create_task(name,node,node.parent.find_or_declare(out)) + try: + self.compiled_tasks.append(task) + except AttributeError: + self.compiled_tasks=[task] + return task +@taskgen_method +def to_incnodes(self,inlst): + lst=[] + seen=set([]) + for x in self.to_list(inlst): + if x in seen or not x: + continue + seen.add(x) + if isinstance(x,Node.Node): + lst.append(x) + else: + if os.path.isabs(x): + lst.append(self.bld.root.make_node(x)or x) + else: + if x[0]=='#': + p=self.bld.bldnode.make_node(x[1:]) + v=self.bld.srcnode.make_node(x[1:]) + else: + p=self.path.get_bld().make_node(x) + v=self.path.make_node(x) + if p.is_child_of(self.bld.bldnode): + p.mkdir() + lst.append(p) + lst.append(v) + return lst +@feature('c','cxx','d','asm','fc','includes') +@after_method('propagate_uselib_vars','process_source') +def apply_incpaths(self): + lst=self.to_incnodes(self.to_list(getattr(self,'includes',[]))+self.env['INCLUDES']) + self.includes_nodes=lst + self.env['INCPATHS']=[x.abspath()for x in lst] +class link_task(Task.Task): + color='YELLOW' + inst_to=None + chmod=Utils.O755 + def add_target(self,target): + if isinstance(target,str): + pattern=self.env[self.__class__.__name__+'_PATTERN'] + if not pattern: + pattern='%s' + folder,name=os.path.split(target) + if self.__class__.__name__.find('shlib')>0 and getattr(self.generator,'vnum',None): + nums=self.generator.vnum.split('.') + if self.env.DEST_BINFMT=='pe': + name=name+'-'+nums[0] + elif self.env.DEST_OS=='openbsd': + pattern='%s.%s.%s'%(pattern,nums[0],nums[1]) + tmp=folder+os.sep+pattern%name + target=self.generator.path.find_or_declare(tmp) + self.set_outputs(target) +class stlink_task(link_task): + run_str='${AR} ${ARFLAGS} ${AR_TGT_F}${TGT} ${AR_SRC_F}${SRC}' +def rm_tgt(cls): + old=cls.run + def wrap(self): + try:os.remove(self.outputs[0].abspath()) + except OSError:pass + return old(self) + setattr(cls,'run',wrap) +rm_tgt(stlink_task) +@feature('c','cxx','d','fc','asm') +@after_method('process_source') +def apply_link(self): + for x in self.features: + if x=='cprogram'and'cxx'in self.features: + x='cxxprogram' + elif x=='cshlib'and'cxx'in self.features: + x='cxxshlib' + if x in Task.classes: + if issubclass(Task.classes[x],link_task): + link=x + break + else: + return + objs=[t.outputs[0]for t in getattr(self,'compiled_tasks',[])] + self.link_task=self.create_task(link,objs) + self.link_task.add_target(self.target) + try: + inst_to=self.install_path + except AttributeError: + inst_to=self.link_task.__class__.inst_to + if inst_to: + self.install_task=self.bld.install_files(inst_to,self.link_task.outputs[:],env=self.env,chmod=self.link_task.chmod) +@taskgen_method +def use_rec(self,name,**kw): + if name in self.tmp_use_not or name in self.tmp_use_seen: + return + try: + y=self.bld.get_tgen_by_name(name) + except Errors.WafError: + self.uselib.append(name) + self.tmp_use_not.add(name) + return + self.tmp_use_seen.append(name) + y.post() + y.tmp_use_objects=objects=kw.get('objects',True) + y.tmp_use_stlib=stlib=kw.get('stlib',True) + try: + link_task=y.link_task + except AttributeError: + y.tmp_use_var='' + else: + objects=False + if not isinstance(link_task,stlink_task): + stlib=False + y.tmp_use_var='LIB' + else: + y.tmp_use_var='STLIB' + p=self.tmp_use_prec + for x in self.to_list(getattr(y,'use',[])): + try: + p[x].append(name) + except KeyError: + p[x]=[name] + self.use_rec(x,objects=objects,stlib=stlib) +@feature('c','cxx','d','use','fc') +@before_method('apply_incpaths','propagate_uselib_vars') +@after_method('apply_link','process_source') +def process_use(self): + use_not=self.tmp_use_not=set([]) + self.tmp_use_seen=[] + use_prec=self.tmp_use_prec={} + self.uselib=self.to_list(getattr(self,'uselib',[])) + self.includes=self.to_list(getattr(self,'includes',[])) + names=self.to_list(getattr(self,'use',[])) + for x in names: + self.use_rec(x) + for x in use_not: + if x in use_prec: + del use_prec[x] + out=[] + tmp=[] + for x in self.tmp_use_seen: + for k in use_prec.values(): + if x in k: + break + else: + tmp.append(x) + while tmp: + e=tmp.pop() + out.append(e) + try: + nlst=use_prec[e] + except KeyError: + pass + else: + del use_prec[e] + for x in nlst: + for y in use_prec: + if x in use_prec[y]: + break + else: + tmp.append(x) + if use_prec: + raise Errors.WafError('Cycle detected in the use processing %r'%use_prec) + out.reverse() + link_task=getattr(self,'link_task',None) + for x in out: + y=self.bld.get_tgen_by_name(x) + var=y.tmp_use_var + if var and link_task: + if var=='LIB'or y.tmp_use_stlib: + self.env.append_value(var,[y.target[y.target.rfind(os.sep)+1:]]) + self.link_task.dep_nodes.extend(y.link_task.outputs) + tmp_path=y.link_task.outputs[0].parent.path_from(self.bld.bldnode) + self.env.append_value(var+'PATH',[tmp_path]) + else: + if y.tmp_use_objects: + self.add_objects_from_tgen(y) + if getattr(y,'export_includes',None): + self.includes.extend(y.to_incnodes(y.export_includes)) + if getattr(y,'export_defines',None): + self.env.append_value('DEFINES',self.to_list(y.export_defines)) + for x in names: + try: + y=self.bld.get_tgen_by_name(x) + except Exception: + if not self.env['STLIB_'+x]and not x in self.uselib: + self.uselib.append(x) + else: + for k in self.to_list(getattr(y,'uselib',[])): + if not self.env['STLIB_'+k]and not k in self.uselib: + self.uselib.append(k) +@taskgen_method +def accept_node_to_link(self,node): + return not node.name.endswith('.pdb') +@taskgen_method +def add_objects_from_tgen(self,tg): + try: + link_task=self.link_task + except AttributeError: + pass + else: + for tsk in getattr(tg,'compiled_tasks',[]): + for x in tsk.outputs: + if self.accept_node_to_link(x): + link_task.inputs.append(x) +@taskgen_method +def get_uselib_vars(self): + _vars=set([]) + for x in self.features: + if x in USELIB_VARS: + _vars|=USELIB_VARS[x] + return _vars +@feature('c','cxx','d','fc','javac','cs','uselib','asm') +@after_method('process_use') +def propagate_uselib_vars(self): + _vars=self.get_uselib_vars() + env=self.env + for x in _vars: + y=x.lower() + env.append_unique(x,self.to_list(getattr(self,y,[]))) + for x in self.features: + for var in _vars: + compvar='%s_%s'%(var,x) + env.append_value(var,env[compvar]) + for x in self.to_list(getattr(self,'uselib',[])): + for v in _vars: + env.append_value(v,env[v+'_'+x]) +@feature('cshlib','cxxshlib','fcshlib') +@after_method('apply_link') +def apply_implib(self): + if not self.env.DEST_BINFMT=='pe': + return + dll=self.link_task.outputs[0] + if isinstance(self.target,Node.Node): + name=self.target.name + else: + name=os.path.split(self.target)[1] + implib=self.env['implib_PATTERN']%name + implib=dll.parent.find_or_declare(implib) + self.env.append_value('LINKFLAGS',self.env['IMPLIB_ST']%implib.bldpath()) + self.link_task.outputs.append(implib) + if getattr(self,'defs',None)and self.env.DEST_BINFMT=='pe': + node=self.path.find_resource(self.defs) + if not node: + raise Errors.WafError('invalid def file %r'%self.defs) + if'msvc'in(self.env.CC_NAME,self.env.CXX_NAME): + self.env.append_value('LINKFLAGS','/def:%s'%node.path_from(self.bld.bldnode)) + self.link_task.dep_nodes.append(node) + else: + self.link_task.inputs.append(node) + try: + inst_to=self.install_path + except AttributeError: + inst_to=self.link_task.__class__.inst_to + if not inst_to: + return + self.implib_install_task=self.bld.install_as('${LIBDIR}/%s'%implib.name,implib,self.env) +re_vnum=re.compile('^([1-9]\\d*|0)[.]([1-9]\\d*|0)[.]([1-9]\\d*|0)$') +@feature('cshlib','cxxshlib','dshlib','fcshlib','vnum') +@after_method('apply_link','propagate_uselib_vars') +def apply_vnum(self): + if not getattr(self,'vnum','')or os.name!='posix'or self.env.DEST_BINFMT not in('elf','mac-o'): + return + link=self.link_task + if not re_vnum.match(self.vnum): + raise Errors.WafError('Invalid version %r for %r'%(self.vnum,self)) + 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()) + if self.env.DEST_OS!='openbsd': + self.create_task('vnum',node,[node.parent.find_or_declare(name2),node.parent.find_or_declare(name3)]) + if getattr(self,'install_task',None): + self.install_task.hasrun=Task.SKIP_ME + bld=self.bld + path=self.install_task.dest + if self.env.DEST_OS=='openbsd': + libname=self.link_task.outputs[0].name + t1=bld.install_as('%s%s%s'%(path,os.sep,libname),node,env=self.env,chmod=self.link_task.chmod) + self.vnum_install_task=(t1,) + else: + t1=bld.install_as(path+os.sep+name3,node,env=self.env,chmod=self.link_task.chmod) + t2=bld.symlink_as(path+os.sep+name2,name3) + t3=bld.symlink_as(path+os.sep+libname,name3) + self.vnum_install_task=(t1,t2,t3) + if'-dynamiclib'in self.env['LINKFLAGS']: + try: + inst_to=self.install_path + except AttributeError: + inst_to=self.link_task.__class__.inst_to + if inst_to: + p=Utils.subst_vars(inst_to,self.env) + path=os.path.join(p,self.link_task.outputs[0].name) + self.env.append_value('LINKFLAGS',['-install_name',path]) +class vnum(Task.Task): + color='CYAN' + quient=True + ext_in=['.bin'] + def run(self): + for x in self.outputs: + path=x.abspath() + try: + os.remove(path) + except OSError: + pass + try: + os.symlink(self.inputs[0].name,path) + except OSError: + return 1 +class fake_shlib(link_task): + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +class fake_stlib(stlink_task): + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +@conf +def read_shlib(self,name,paths=[],export_includes=[],export_defines=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='shlib',export_includes=export_includes,export_defines=export_defines) +@conf +def read_stlib(self,name,paths=[],export_includes=[],export_defines=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='stlib',export_includes=export_includes,export_defines=export_defines) +lib_patterns={'shlib':['lib%s.so','%s.so','lib%s.dylib','lib%s.dll','%s.dll'],'stlib':['lib%s.a','%s.a','lib%s.dll','%s.dll','lib%s.lib','%s.lib'],} +@feature('fake_lib') +def process_lib(self): + node=None + names=[x%self.name for x in lib_patterns[self.lib_type]] + for x in self.lib_paths+[self.path]+SYSTEM_LIB_PATHS: + if not isinstance(x,Node.Node): + x=self.bld.root.find_node(x)or self.path.find_node(x) + if not x: + continue + for y in names: + node=x.find_node(y) + if node: + node.sig=Utils.h_file(node.abspath()) + break + else: + continue + break + else: + raise Errors.WafError('could not find library %r'%self.name) + self.link_task=self.create_task('fake_%s'%self.lib_type,[],[node]) + self.target=self.name +class fake_o(Task.Task): + def runnable_status(self): + return Task.SKIP_ME +@extension('.o','.obj') +def add_those_o_files(self,node): + tsk=self.create_task('fake_o',[],node) + try: + self.compiled_tasks.append(tsk) + except AttributeError: + self.compiled_tasks=[tsk] +@feature('fake_obj') +@before_method('process_source') +def process_objs(self): + for node in self.to_nodes(self.source): + self.add_those_o_files(node) + self.source=[] +@conf +def read_object(self,obj): + if not isinstance(obj,self.path.__class__): + obj=self.path.find_resource(obj) + return self(features='fake_obj',source=obj,name=obj.name) diff --git a/waflib/Tools/ccroot.pyc b/waflib/Tools/ccroot.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae44c4e215e4a2b220a5ae99d69335d84c8e8198 GIT binary patch literal 18933 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 WEMonbd!ymA-BD|51J6%t>C%5v88$Wm literal 0 HcmV?d00001 diff --git a/waflib/Tools/compiler_cxx.py b/waflib/Tools/compiler_cxx.py new file mode 100644 index 0000000..14b7c7d --- /dev/null +++ b/waflib/Tools/compiler_cxx.py @@ -0,0 +1,39 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib.Tools import ccroot +from waflib import Utils,Configure +from waflib.Logs import debug +cxx_compiler={'win32':['msvc','g++'],'cygwin':['g++'],'darwin':['g++'],'aix':['xlc++','g++'],'linux':['g++','icpc'],'sunos':['sunc++','g++'],'irix':['g++'],'hpux':['g++'],'gnu':['g++'],'java':['g++','msvc','icpc'],'default':['g++']} +def configure(conf): + try:test_for_compiler=conf.options.check_cxx_compiler + except AttributeError:conf.fatal("Add options(opt): opt.load('compiler_cxx')") + for compiler in test_for_compiler.split(): + conf.env.stash() + conf.start_msg('Checking for %r (c++ compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + debug('compiler_cxx: %r'%e) + else: + if conf.env['CXX']: + conf.end_msg(conf.env.get_flat('CXX')) + conf.env['COMPILER_CXX']=compiler + break + conf.end_msg(False) + else: + conf.fatal('could not configure a c++ compiler!') +def options(opt): + opt.load_special_tools('cxx_*.py') + global cxx_compiler + build_platform=Utils.unversioned_sys_platform() + possible_compiler_list=cxx_compiler[build_platform in cxx_compiler and build_platform or'default'] + test_for_compiler=' '.join(possible_compiler_list) + cxx_compiler_opts=opt.add_option_group('C++ Compiler Options') + cxx_compiler_opts.add_option('--check-cxx-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following C++ Compiler will be checked by default: "%s"'%(build_platform,test_for_compiler),dest="check_cxx_compiler") + for x in test_for_compiler.split(): + opt.load('%s'%x) diff --git a/waflib/Tools/compiler_d.py b/waflib/Tools/compiler_d.py new file mode 100644 index 0000000..ee173e1 --- /dev/null +++ b/waflib/Tools/compiler_d.py @@ -0,0 +1,29 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib import Utils,Configure,Options,Logs +def configure(conf): + for compiler in conf.options.dcheck.split(','): + conf.env.stash() + conf.start_msg('Checking for %r (d compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + Logs.debug('compiler_d: %r'%e) + else: + if conf.env.D: + conf.end_msg(conf.env.get_flat('D')) + conf.env['COMPILER_D']=compiler + break + conf.end_msg(False) + else: + conf.fatal('no suitable d compiler was found') +def options(opt): + d_compiler_opts=opt.add_option_group('D Compiler Options') + d_compiler_opts.add_option('--check-d-compiler',default='gdc,dmd,ldc2',action='store',help='check for the compiler [Default:gdc,dmd,ldc2]',dest='dcheck') + for d_compiler in['gdc','dmd','ldc2']: + opt.load('%s'%d_compiler) diff --git a/waflib/Tools/compiler_fc.py b/waflib/Tools/compiler_fc.py new file mode 100644 index 0000000..ec5d2ea --- /dev/null +++ b/waflib/Tools/compiler_fc.py @@ -0,0 +1,43 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib import Utils,Configure,Options,Logs,Errors +from waflib.Tools import fc +fc_compiler={'win32':['gfortran','ifort'],'darwin':['gfortran','g95','ifort'],'linux':['gfortran','g95','ifort'],'java':['gfortran','g95','ifort'],'default':['gfortran'],'aix':['gfortran']} +def __list_possible_compiler(platform): + try: + return fc_compiler[platform] + except KeyError: + return fc_compiler["default"] +def configure(conf): + try:test_for_compiler=conf.options.check_fc + except AttributeError:conf.fatal("Add options(opt): opt.load('compiler_fc')") + for compiler in test_for_compiler.split(): + conf.env.stash() + conf.start_msg('Checking for %r (fortran compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + Logs.debug('compiler_fortran: %r'%e) + else: + if conf.env['FC']: + conf.end_msg(conf.env.get_flat('FC')) + conf.env.COMPILER_FORTRAN=compiler + break + conf.end_msg(False) + else: + conf.fatal('could not configure a fortran compiler!') +def options(opt): + opt.load_special_tools('fc_*.py') + build_platform=Utils.unversioned_sys_platform() + detected_platform=Options.platform + possible_compiler_list=__list_possible_compiler(detected_platform) + test_for_compiler=' '.join(possible_compiler_list) + fortran_compiler_opts=opt.add_option_group("Fortran Compiler Options") + fortran_compiler_opts.add_option('--check-fortran-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following Fortran Compiler will be checked by default: "%s"'%(detected_platform,test_for_compiler),dest="check_fc") + for compiler in test_for_compiler.split(): + opt.load('%s'%compiler) diff --git a/waflib/Tools/cs.py b/waflib/Tools/cs.py new file mode 100644 index 0000000..a78e138 --- /dev/null +++ b/waflib/Tools/cs.py @@ -0,0 +1,132 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Utils,Task,Options,Logs,Errors +from waflib.TaskGen import before_method,after_method,feature +from waflib.Tools import ccroot +from waflib.Configure import conf +import os,tempfile +ccroot.USELIB_VARS['cs']=set(['CSFLAGS','ASSEMBLIES','RESOURCES']) +ccroot.lib_patterns['csshlib']=['%s'] +@feature('cs') +@before_method('process_source') +def apply_cs(self): + cs_nodes=[] + no_nodes=[] + for x in self.to_nodes(self.source): + if x.name.endswith('.cs'): + cs_nodes.append(x) + else: + no_nodes.append(x) + self.source=no_nodes + bintype=getattr(self,'bintype',self.gen.endswith('.dll')and'library'or'exe') + self.cs_task=tsk=self.create_task('mcs',cs_nodes,self.path.find_or_declare(self.gen)) + tsk.env.CSTYPE='/target:%s'%bintype + tsk.env.OUT='/out:%s'%tsk.outputs[0].abspath() + self.env.append_value('CSFLAGS','/platform:%s'%getattr(self,'platform','anycpu')) + inst_to=getattr(self,'install_path',bintype=='exe'and'${BINDIR}'or'${LIBDIR}') + if inst_to: + mod=getattr(self,'chmod',bintype=='exe'and Utils.O755 or Utils.O644) + self.install_task=self.bld.install_files(inst_to,self.cs_task.outputs[:],env=self.env,chmod=mod) +@feature('cs') +@after_method('apply_cs') +def use_cs(self): + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except Errors.WafError: + self.env.append_value('CSFLAGS','/reference:%s'%x) + continue + y.post() + tsk=getattr(y,'cs_task',None)or getattr(y,'link_task',None) + if not tsk: + self.bld.fatal('cs task has no link task for use %r'%self) + self.cs_task.dep_nodes.extend(tsk.outputs) + self.cs_task.set_run_after(tsk) + self.env.append_value('CSFLAGS','/reference:%s'%tsk.outputs[0].abspath()) +@feature('cs') +@after_method('apply_cs','use_cs') +def debug_cs(self): + csdebug=getattr(self,'csdebug',self.env.CSDEBUG) + if not csdebug: + return + node=self.cs_task.outputs[0] + if self.env.CS_NAME=='mono': + out=node.parent.find_or_declare(node.name+'.mdb') + else: + out=node.change_ext('.pdb') + self.cs_task.outputs.append(out) + try: + self.install_task.source.append(out) + except AttributeError: + pass + if csdebug=='pdbonly': + val=['/debug+','/debug:pdbonly'] + elif csdebug=='full': + val=['/debug+','/debug:full'] + else: + val=['/debug-'] + self.env.append_value('CSFLAGS',val) +class mcs(Task.Task): + color='YELLOW' + run_str='${MCS} ${CSTYPE} ${CSFLAGS} ${ASS_ST:ASSEMBLIES} ${RES_ST:RESOURCES} ${OUT} ${SRC}' + def exec_command(self,cmd,**kw): + bld=self.generator.bld + try: + if not kw.get('cwd',None): + kw['cwd']=bld.cwd + except AttributeError: + bld.cwd=kw['cwd']=bld.variant_dir + try: + tmp=None + if isinstance(cmd,list)and len(' '.join(cmd))>=8192: + program=cmd[0] + cmd=[self.quote_response_command(x)for x in cmd] + (fd,tmp)=tempfile.mkstemp() + os.write(fd,'\r\n'.join(i.replace('\\','\\\\')for i in cmd[1:])) + os.close(fd) + cmd=[program,'@'+tmp] + ret=self.generator.bld.exec_command(cmd,**kw) + finally: + if tmp: + try: + os.remove(tmp) + except OSError: + pass + return ret + def quote_response_command(self,flag): + if flag.lower()=='/noconfig': + return'' + if flag.find(' ')>-1: + for x in('/r:','/reference:','/resource:','/lib:','/out:'): + if flag.startswith(x): + flag='%s"%s"'%(x,'","'.join(flag[len(x):].split(','))) + break + else: + flag='"%s"'%flag + return flag +def configure(conf): + csc=getattr(Options.options,'cscbinary',None) + if csc: + conf.env.MCS=csc + conf.find_program(['csc','mcs','gmcs'],var='MCS') + conf.env.ASS_ST='/r:%s' + conf.env.RES_ST='/resource:%s' + conf.env.CS_NAME='csc' + if str(conf.env.MCS).lower().find('mcs')>-1: + conf.env.CS_NAME='mono' +def options(opt): + opt.add_option('--with-csc-binary',type='string',dest='cscbinary') +class fake_csshlib(Task.Task): + color='YELLOW' + inst_to=None + def runnable_status(self): + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +@conf +def read_csshlib(self,name,paths=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='csshlib') diff --git a/waflib/Tools/cxx.py b/waflib/Tools/cxx.py new file mode 100644 index 0000000..b744a8d --- /dev/null +++ b/waflib/Tools/cxx.py @@ -0,0 +1,26 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import TaskGen,Task,Utils +from waflib.Tools import c_preproc +from waflib.Tools.ccroot import link_task,stlink_task +@TaskGen.extension('.cpp','.cc','.cxx','.C','.c++') +def cxx_hook(self,node): + return self.create_compiled_task('cxx',node) +if not'.c'in TaskGen.task_gen.mappings: + TaskGen.task_gen.mappings['.c']=TaskGen.task_gen.mappings['.cpp'] +class cxx(Task.Task): + run_str='${CXX} ${ARCH_ST:ARCH} ${CXXFLAGS} ${CPPFLAGS} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${CXX_SRC_F}${SRC} ${CXX_TGT_F}${TGT}' + vars=['CXXDEPS'] + ext_in=['.h'] + scan=c_preproc.scan +class cxxprogram(link_task): + run_str='${LINK_CXX} ${LINKFLAGS} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${SHLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB}' + vars=['LINKDEPS'] + ext_out=['.bin'] + inst_to='${BINDIR}' +class cxxshlib(cxxprogram): + inst_to='${LIBDIR}' +class cxxstlib(stlink_task): + pass diff --git a/waflib/Tools/d.py b/waflib/Tools/d.py new file mode 100644 index 0000000..1838740 --- /dev/null +++ b/waflib/Tools/d.py @@ -0,0 +1,54 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Utils,Task,Errors +from waflib.TaskGen import taskgen_method,feature,extension +from waflib.Tools import d_scan,d_config +from waflib.Tools.ccroot import link_task,stlink_task +class d(Task.Task): + color='GREEN' + run_str='${D} ${DFLAGS} ${DINC_ST:INCPATHS} ${D_SRC_F:SRC} ${D_TGT_F:TGT}' + scan=d_scan.scan +class d_with_header(d): + run_str='${D} ${DFLAGS} ${DINC_ST:INCPATHS} ${D_HDR_F:tgt.outputs[1].bldpath()} ${D_SRC_F:SRC} ${D_TGT_F:tgt.outputs[0].bldpath()}' +class d_header(Task.Task): + color='BLUE' + run_str='${D} ${D_HEADER} ${SRC}' +class dprogram(link_task): + run_str='${D_LINKER} ${LINKFLAGS} ${DLNK_SRC_F}${SRC} ${DLNK_TGT_F:TGT} ${RPATH_ST:RPATH} ${DSTLIB_MARKER} ${DSTLIBPATH_ST:STLIBPATH} ${DSTLIB_ST:STLIB} ${DSHLIB_MARKER} ${DLIBPATH_ST:LIBPATH} ${DSHLIB_ST:LIB}' + inst_to='${BINDIR}' +class dshlib(dprogram): + inst_to='${LIBDIR}' +class dstlib(stlink_task): + pass +@extension('.d','.di','.D') +def d_hook(self,node): + ext=Utils.destos_to_binfmt(self.env.DEST_OS)=='pe'and'obj'or'o' + out='%s.%d.%s'%(node.name,self.idx,ext) + def create_compiled_task(self,name,node): + task=self.create_task(name,node,node.parent.find_or_declare(out)) + try: + self.compiled_tasks.append(task) + except AttributeError: + self.compiled_tasks=[task] + return task + if getattr(self,'generate_headers',None): + tsk=create_compiled_task(self,'d_with_header',node) + tsk.outputs.append(node.change_ext(self.env['DHEADER_ext'])) + else: + tsk=create_compiled_task(self,'d',node) + return tsk +@taskgen_method +def generate_header(self,filename): + try: + self.header_lst.append([filename,self.install_path]) + except AttributeError: + self.header_lst=[[filename,self.install_path]] +@feature('d') +def process_header(self): + for i in getattr(self,'header_lst',[]): + node=self.path.find_resource(i[0]) + if not node: + raise Errors.WafError('file %r not found on d obj'%i[0]) + self.create_task('d_header',node,node.change_ext('.di')) diff --git a/waflib/Tools/d_config.py b/waflib/Tools/d_config.py new file mode 100644 index 0000000..50660ea --- /dev/null +++ b/waflib/Tools/d_config.py @@ -0,0 +1,52 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Utils +from waflib.Configure import conf +@conf +def d_platform_flags(self): + v=self.env + if not v.DEST_OS: + v.DEST_OS=Utils.unversioned_sys_platform() + binfmt=Utils.destos_to_binfmt(self.env.DEST_OS) + if binfmt=='pe': + v['dprogram_PATTERN']='%s.exe' + v['dshlib_PATTERN']='lib%s.dll' + v['dstlib_PATTERN']='lib%s.a' + elif binfmt=='mac-o': + v['dprogram_PATTERN']='%s' + v['dshlib_PATTERN']='lib%s.dylib' + v['dstlib_PATTERN']='lib%s.a' + else: + v['dprogram_PATTERN']='%s' + v['dshlib_PATTERN']='lib%s.so' + v['dstlib_PATTERN']='lib%s.a' +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; + } + } +} +''' +@conf +def check_dlibrary(self,execute=True): + ret=self.check_cc(features='d dprogram',fragment=DLIB,compile_filename='test.d',execute=execute,define_ret=True) + if execute: + self.env.DLIBRARY=ret.strip() diff --git a/waflib/Tools/d_scan.py b/waflib/Tools/d_scan.py new file mode 100644 index 0000000..ee80c5f --- /dev/null +++ b/waflib/Tools/d_scan.py @@ -0,0 +1,133 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils,Logs +def filter_comments(filename): + txt=Utils.readf(filename) + i=0 + buf=[] + max=len(txt) + begin=0 + while i-1: + conf.fatal('dmd2 on Windows is not supported, use gdc or ldc2 instead') + conf.load('ar') + conf.load('d') + conf.common_flags_dmd() + conf.d_platform_flags() + if str(conf.env.D).find('ldc')>-1: + conf.common_flags_ldc() diff --git a/waflib/Tools/errcheck.py b/waflib/Tools/errcheck.py new file mode 100644 index 0000000..3b06493 --- /dev/null +++ b/waflib/Tools/errcheck.py @@ -0,0 +1,161 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +typos={'feature':'features','sources':'source','targets':'target','include':'includes','export_include':'export_includes','define':'defines','importpath':'includes','installpath':'install_path','iscopy':'is_copy',} +meths_typos=['__call__','program','shlib','stlib','objects'] +from waflib import Logs,Build,Node,Task,TaskGen,ConfigSet,Errors,Utils +import waflib.Tools.ccroot +def check_same_targets(self): + mp=Utils.defaultdict(list) + uids={} + def check_task(tsk): + if not isinstance(tsk,Task.Task): + return + for node in tsk.outputs: + mp[node].append(tsk) + try: + uids[tsk.uid()].append(tsk) + except KeyError: + uids[tsk.uid()]=[tsk] + for g in self.groups: + for tg in g: + try: + for tsk in tg.tasks: + check_task(tsk) + except AttributeError: + check_task(tg) + dupe=False + for(k,v)in mp.items(): + if len(v)>1: + dupe=True + msg='* Node %r is created more than once%s. The task generators are:'%(k,Logs.verbose==1 and" (full message on 'waf -v -v')"or"") + Logs.error(msg) + for x in v: + if Logs.verbose>1: + Logs.error(' %d. %r'%(1+v.index(x),x.generator)) + else: + Logs.error(' %d. %r in %r'%(1+v.index(x),x.generator.name,getattr(x.generator,'path',None))) + if not dupe: + for(k,v)in uids.items(): + if len(v)>1: + Logs.error('* Several tasks use the same identifier. Please check the information on\n http://docs.waf.googlecode.com/git/apidocs_16/Task.html#waflib.Task.Task.uid') + for tsk in v: + Logs.error(' - object %r (%r) defined in %r'%(tsk.__class__.__name__,tsk,tsk.generator)) +def check_invalid_constraints(self): + feat=set([]) + for x in list(TaskGen.feats.values()): + feat.union(set(x)) + for(x,y)in TaskGen.task_gen.prec.items(): + feat.add(x) + feat.union(set(y)) + ext=set([]) + for x in TaskGen.task_gen.mappings.values(): + ext.add(x.__name__) + invalid=ext&feat + if invalid: + Logs.error('The methods %r have invalid annotations: @extension <-> @feature/@before_method/@after_method'%list(invalid)) + for cls in list(Task.classes.values()): + for x in('before','after'): + for y in Utils.to_list(getattr(cls,x,[])): + if not Task.classes.get(y,None): + Logs.error('Erroneous order constraint %r=%r on task class %r'%(x,y,cls.__name__)) + if getattr(cls,'rule',None): + Logs.error('Erroneous attribute "rule" on task class %r (rename to "run_str")'%cls.__name__) +def replace(m): + oldcall=getattr(Build.BuildContext,m) + def call(self,*k,**kw): + ret=oldcall(self,*k,**kw) + for x in typos: + if x in kw: + if x=='iscopy'and'subst'in getattr(self,'features',''): + continue + err=True + Logs.error('Fix the typo %r -> %r on %r'%(x,typos[x],ret)) + return ret + setattr(Build.BuildContext,m,call) +def enhance_lib(): + for m in meths_typos: + replace(m) + def ant_glob(self,*k,**kw): + if k: + lst=Utils.to_list(k[0]) + for pat in lst: + if'..'in pat.split('/'): + Logs.error("In ant_glob pattern %r: '..' means 'two dots', not 'parent directory'"%k[0]) + if kw.get('remove',True): + try: + if self.is_child_of(self.ctx.bldnode)and not kw.get('quiet',False): + Logs.error('Using ant_glob on the build folder (%r) is dangerous (quiet=True to disable this warning)'%self) + except AttributeError: + pass + return self.old_ant_glob(*k,**kw) + Node.Node.old_ant_glob=Node.Node.ant_glob + Node.Node.ant_glob=ant_glob + old=Task.is_before + def is_before(t1,t2): + ret=old(t1,t2) + if ret and old(t2,t1): + Logs.error('Contradictory order constraints in classes %r %r'%(t1,t2)) + return ret + Task.is_before=is_before + def check_err_features(self): + lst=self.to_list(self.features) + if'shlib'in lst: + Logs.error('feature shlib -> cshlib, dshlib or cxxshlib') + for x in('c','cxx','d','fc'): + if not x in lst and lst and lst[0]in[x+y for y in('program','shlib','stlib')]: + Logs.error('%r features is probably missing %r'%(self,x)) + TaskGen.feature('*')(check_err_features) + def check_err_order(self): + if not hasattr(self,'rule')and not'subst'in Utils.to_list(self.features): + for x in('before','after','ext_in','ext_out'): + if hasattr(self,x): + Logs.warn('Erroneous order constraint %r on non-rule based task generator %r'%(x,self)) + else: + for x in('before','after'): + for y in self.to_list(getattr(self,x,[])): + if not Task.classes.get(y,None): + Logs.error('Erroneous order constraint %s=%r on %r (no such class)'%(x,y,self)) + TaskGen.feature('*')(check_err_order) + def check_compile(self): + check_invalid_constraints(self) + try: + ret=self.orig_compile() + finally: + check_same_targets(self) + return ret + Build.BuildContext.orig_compile=Build.BuildContext.compile + Build.BuildContext.compile=check_compile + def use_rec(self,name,**kw): + try: + y=self.bld.get_tgen_by_name(name) + except Errors.WafError: + pass + else: + idx=self.bld.get_group_idx(self) + odx=self.bld.get_group_idx(y) + if odx>idx: + msg="Invalid 'use' across build groups:" + if Logs.verbose>1: + msg+='\n target %r\n uses:\n %r'%(self,y) + else: + msg+=" %r uses %r (try 'waf -v -v' for the full error)"%(self.name,name) + raise Errors.WafError(msg) + self.orig_use_rec(name,**kw) + TaskGen.task_gen.orig_use_rec=TaskGen.task_gen.use_rec + TaskGen.task_gen.use_rec=use_rec + def getattri(self,name,default=None): + if name=='append'or name=='add': + raise Errors.WafError('env.append and env.add do not exist: use env.append_value/env.append_unique') + elif name=='prepend': + raise Errors.WafError('env.prepend does not exist: use env.prepend_value') + if name in self.__slots__: + return object.__getattr__(self,name,default) + else: + return self[name] + ConfigSet.ConfigSet.__getattr__=getattri +def options(opt): + enhance_lib() +def configure(conf): + pass diff --git a/waflib/Tools/errcheck.pyc b/waflib/Tools/errcheck.pyc new file mode 100644 index 0000000000000000000000000000000000000000..289f587bba2f04fe5a3a15b9f39a9d3536261dbd GIT binary patch literal 8847 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]\s*;)\s*INCLUDE\s+(?:\w+_)?[<"'](.+?)(?=["'>])""" +USE_REGEX="""(?:^|;)\s*USE(?:\s+|(?:(?:\s*,\s*(?:NON_)?INTRINSIC)?\s*::))\s*(\w+)""" +MOD_REGEX="""(?:^|;)\s*MODULE(?!\s*PROCEDURE)(?:\s+|(?:(?:\s*,\s*(?:NON_)?INTRINSIC)?\s*::))\s*(\w+)""" +re_inc=re.compile(INC_REGEX,re.I) +re_use=re.compile(USE_REGEX,re.I) +re_mod=re.compile(MOD_REGEX,re.I) +class fortran_parser(object): + def __init__(self,incpaths): + self.seen=[] + self.nodes=[] + self.names=[] + self.incpaths=incpaths + def find_deps(self,node): + txt=node.read() + incs=[] + uses=[] + mods=[] + for line in txt.splitlines(): + m=re_inc.search(line) + if m: + incs.append(m.group(1)) + m=re_use.search(line) + if m: + uses.append(m.group(1)) + m=re_mod.search(line) + if m: + mods.append(m.group(1)) + return(incs,uses,mods) + def start(self,node): + self.waiting=[node] + while self.waiting: + nd=self.waiting.pop(0) + self.iter(nd) + def iter(self,node): + path=node.abspath() + incs,uses,mods=self.find_deps(node) + for x in incs: + if x in self.seen: + continue + self.seen.append(x) + self.tryfind_header(x) + for x in uses: + name="USE@%s"%x + if not name in self.names: + self.names.append(name) + for x in mods: + name="MOD@%s"%x + if not name in self.names: + self.names.append(name) + def tryfind_header(self,filename): + found=None + for n in self.incpaths: + found=n.find_resource(filename) + if found: + self.nodes.append(found) + self.waiting.append(found) + break + if not found: + if not filename in self.names: + self.names.append(filename) diff --git a/waflib/Tools/flex.py b/waflib/Tools/flex.py new file mode 100644 index 0000000..13f6207 --- /dev/null +++ b/waflib/Tools/flex.py @@ -0,0 +1,32 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.TaskGen,os,re +def decide_ext(self,node): + if'cxx'in self.features: + return['.lex.cc'] + return['.lex.c'] +def flexfun(tsk): + env=tsk.env + bld=tsk.generator.bld + wd=bld.variant_dir + def to_list(xx): + if isinstance(xx,str):return[xx] + return xx + tsk.last_cmd=lst=[] + lst.extend(to_list(env['FLEX'])) + lst.extend(to_list(env['FLEXFLAGS'])) + inputs=[a.path_from(bld.bldnode)for a in tsk.inputs] + if env.FLEX_MSYS: + inputs=[x.replace(os.sep,'/')for x in inputs] + lst.extend(inputs) + lst=[x for x in lst if x] + txt=bld.cmd_and_log(lst,cwd=wd,env=env.env or None,quiet=0) + tsk.outputs[0].write(txt.replace('\r\n','\n').replace('\r','\n')) +waflib.TaskGen.declare_chain(name='flex',rule=flexfun,ext_in='.l',decider=decide_ext,) +def configure(conf): + conf.find_program('flex',var='FLEX') + conf.env.FLEXFLAGS=['-t'] + if re.search(r"\\msys\\[0-9.]+\\bin\\flex.exe$",conf.env.FLEX): + conf.env.FLEX_MSYS=True diff --git a/waflib/Tools/g95.py b/waflib/Tools/g95.py new file mode 100644 index 0000000..9bc331a --- /dev/null +++ b/waflib/Tools/g95.py @@ -0,0 +1,55 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils +from waflib.Tools import fc,fc_config,fc_scan,ar +from waflib.Configure import conf +@conf +def find_g95(conf): + fc=conf.find_program('g95',var='FC') + fc=conf.cmd_to_list(fc) + conf.get_g95_version(fc) + conf.env.FC_NAME='G95' +@conf +def g95_flags(conf): + v=conf.env + v['FCFLAGS_fcshlib']=['-fPIC'] + v['FORTRANMODFLAG']=['-fmod=',''] + v['FCFLAGS_DEBUG']=['-Werror'] +@conf +def g95_modifier_win32(conf): + fc_config.fortran_modifier_win32(conf) +@conf +def g95_modifier_cygwin(conf): + fc_config.fortran_modifier_cygwin(conf) +@conf +def g95_modifier_darwin(conf): + fc_config.fortran_modifier_darwin(conf) +@conf +def g95_modifier_platform(conf): + dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform() + g95_modifier_func=getattr(conf,'g95_modifier_'+dest_os,None) + if g95_modifier_func: + g95_modifier_func() +@conf +def get_g95_version(conf,fc): + version_re=re.compile(r"g95\s*(?P\d*)\.(?P\d*)").search + cmd=fc+['--version'] + out,err=fc_config.getoutput(conf,cmd,stdin=False) + if out: + match=version_re(out) + else: + match=version_re(err) + if not match: + conf.fatal('cannot determine g95 version') + k=match.groupdict() + conf.env['FC_VERSION']=(k['major'],k['minor']) +def configure(conf): + conf.find_g95() + conf.find_ar() + conf.fc_flags() + conf.fc_add_flags() + conf.g95_flags() + conf.g95_modifier_platform() diff --git a/waflib/Tools/gas.py b/waflib/Tools/gas.py new file mode 100644 index 0000000..b714ca1 --- /dev/null +++ b/waflib/Tools/gas.py @@ -0,0 +1,12 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.Tools.asm +from waflib.Tools import ar +def configure(conf): + conf.find_program(['gas','gcc'],var='AS') + conf.env.AS_TGT_F=['-c','-o'] + conf.env.ASLNK_TGT_F=['-o'] + conf.find_ar() + conf.load('asm') diff --git a/waflib/Tools/gcc.py b/waflib/Tools/gcc.py new file mode 100644 index 0000000..aca49ca --- /dev/null +++ b/waflib/Tools/gcc.py @@ -0,0 +1,98 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +def find_gcc(conf): + cc=conf.find_program(['gcc','cc'],var='CC') + cc=conf.cmd_to_list(cc) + conf.get_cc_version(cc,gcc=True) + conf.env.CC_NAME='gcc' + conf.env.CC=cc +@conf +def gcc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']=[] + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Wl,-Bdynamic' + v['STLIB_MARKER']='-Wl,-Bstatic' + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-fPIC'] + v['LINKFLAGS_cshlib']=['-shared'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=['-Wl,-Bstatic'] + v['cstlib_PATTERN']='lib%s.a' + v['LINKFLAGS_MACBUNDLE']=['-bundle','-undefined','dynamic_lookup'] + v['CFLAGS_MACBUNDLE']=['-fPIC'] + v['macbundle_PATTERN']='%s.bundle' +@conf +def gcc_modifier_win32(conf): + v=conf.env + v['cprogram_PATTERN']='%s.exe' + v['cshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='lib%s.dll.a' + v['IMPLIB_ST']='-Wl,--out-implib,%s' + v['CFLAGS_cshlib']=[] + v.append_value('LINKFLAGS',['-Wl,--enable-auto-import']) +@conf +def gcc_modifier_cygwin(conf): + gcc_modifier_win32(conf) + v=conf.env + v['cshlib_PATTERN']='cyg%s.dll' + v.append_value('LINKFLAGS_cshlib',['-Wl,--enable-auto-image-base']) + v['CFLAGS_cshlib']=[] +@conf +def gcc_modifier_darwin(conf): + v=conf.env + v['CFLAGS_cshlib']=['-fPIC'] + v['LINKFLAGS_cshlib']=['-dynamiclib','-Wl,-compatibility_version,1','-Wl,-current_version,1'] + v['cshlib_PATTERN']='lib%s.dylib' + v['FRAMEWORKPATH_ST']='-F%s' + v['FRAMEWORK_ST']=['-framework'] + v['ARCH_ST']=['-arch'] + v['LINKFLAGS_cstlib']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['SONAME_ST']=[] +@conf +def gcc_modifier_aix(conf): + v=conf.env + v['LINKFLAGS_cprogram']=['-Wl,-brtl'] + v['LINKFLAGS_cshlib']=['-shared','-Wl,-brtl,-bexpfull'] + v['SHLIB_MARKER']=[] +@conf +def gcc_modifier_hpux(conf): + v=conf.env + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']='-Bstatic' + v['CFLAGS_cshlib']=['-fPIC','-DPIC'] + v['cshlib_PATTERN']='lib%s.sl' +@conf +def gcc_modifier_openbsd(conf): + conf.env.SONAME_ST=[] +@conf +def gcc_modifier_platform(conf): + gcc_modifier_func=getattr(conf,'gcc_modifier_'+conf.env.DEST_OS,None) + if gcc_modifier_func: + gcc_modifier_func() +def configure(conf): + conf.find_gcc() + 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/waflib/Tools/gcc.pyc b/waflib/Tools/gcc.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b43c9eeafd4e7f2bac679f5e74de181baa767e17 GIT binary patch literal 5049 zcmd5=+j8616+Iv&%A!TnjuI!1om*QsOe;vW+6l{>- z0HAEmG*8ZBJ||E4r9S2Z(zW(E0LhUjk8))5VDEkIYhQutFOB+7|NGJLmHDgS`49ZE zpV0*PZ>dzp=-F)E<>^qxZZr<6px5F^>`rCK=Uwzr%-uCbJ z!!Pdk?}h$7-}^kgzkO#5W8>`%}&$DH9G^%pbYFg{onpG-; zfQT|SpdPIZU_AsaK<_{;&1P#2|dEj6r)=rf4Q)&2tJuOi+6Mf(#&ER*!d`NBd4jZo8u;;!VytdwSskhw4JCas6a8O2+OW z_J$b|$nK$0l~t>5UA5}!8lDaOUiYsdJ?vcvbv{HnSf~t9jQxm36?mg|R|F?SCdz7{ zR)j+MF;Qt%Lf13&))nFq!qY3AX1gs~WGAEB0PXN)=zIXO;Db1JJ|<6)wH-jTscj(| zP3CQZ+7;8blWA`2PPz{jdHDEP`iaxK-2fUML6bas< zVkOVd6boHGD@p>RFr&?76N9O=jyQ^cHiY&HZ8;zD5Vz21eJsN24MV%{Wud5|#SG{$ zn2R4d8=&4aur#CvU~xNOdlzDp$LkgyYW+1%@(P3Iox~(!?I+0K@DY>W7TjbZOPe`5 zQ5y!i+JN6IDP(OUL)JDFvo_Ns?=Tmy1#594+r&h8&P+py8b~%#KZ>LLtf;a!?qt`o zim1?^rfE3NXI)ywb6$Cd1+}Y6>O3$hWr%Z&Og^8bGoHJguwnPZmy^L10hit@ zVE=v~F49{W>%8dY0gjomsL=RceGQ_2M`wws0nGwvx}L6r(jKY#MUNz~OdTD8LN>BZ z(IiGVD~2?+hq6e!*<7Kcv)AtjN0u=Qq3vWceR%|-32Y2&tQ5pJS;?>(lou4yK!K)< zL{5A-qBBd8bAHKr7oHK{#-{ui~GH* z%8Re1(hZg~2<;Z$v*hBuUPp@Hh5cGwRRR}YSiL+?C8>#EZ@=4fpLFHbwUdnJst2hp z7nT`J$Nq(b_YRJ}aEeLn<%1+0{Rl;$xy=YFwt2: + 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' + conf.env['FC_VERSION']=(k['__GNUC__'],k['__GNUC_MINOR__'],k['__GNUC_PATCHLEVEL__']) +def configure(conf): + conf.find_gfortran() + conf.find_ar() + conf.fc_flags() + conf.fc_add_flags() + conf.gfortran_flags() + conf.gfortran_modifier_platform() diff --git a/waflib/Tools/glib2.py b/waflib/Tools/glib2.py new file mode 100644 index 0000000..1d75510 --- /dev/null +++ b/waflib/Tools/glib2.py @@ -0,0 +1,173 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Utils,Options,Errors,Logs +from waflib.TaskGen import taskgen_method,before_method,after_method,feature +@taskgen_method +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_method('process_source') +def process_marshal(self): + for f,prefix in getattr(self,'marshal_list',[]): + node=self.path.find_resource(f) + if not node: + raise Errors.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.source=self.to_nodes(getattr(self,'source',[])) + self.source.append(c_node) +class glib_genmarshal(Task.Task): + def run(self): + bld=self.inputs[0].__class__.ctx + get=self.env.get_flat + cmd1="%s %s --prefix=%s --header > %s"%(get('GLIB_GENMARSHAL'),self.inputs[0].srcpath(),get('GLIB_GENMARSHAL_PREFIX'),self.outputs[0].abspath()) + ret=bld.exec_command(cmd1) + if ret:return ret + c='''#include "%s"\n'''%self.outputs[0].name + self.outputs[1].write(c) + cmd2="%s %s --prefix=%s --body >> %s"%(get('GLIB_GENMARSHAL'),self.inputs[0].srcpath(),get('GLIB_GENMARSHAL_PREFIX'),self.outputs[1].abspath()) + return bld.exec_command(cmd2) + vars=['GLIB_GENMARSHAL_PREFIX','GLIB_GENMARSHAL'] + color='BLUE' + ext_out=['.h'] +@taskgen_method +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_method +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_method('process_source') +def process_enums(self): + for enum in getattr(self,'enums_list',[]): + task=self.create_task('glib_mkenums') + env=task.env + inputs=[] + source_list=self.to_list(enum['source']) + if not source_list: + raise Errors.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.abspath()for k in source_list] + if not enum['target']: + raise Errors.WafError('missing target '+str(enum)) + tgt_node=self.path.find_or_declare(enum['target']) + if tgt_node.name.endswith('.c'): + self.source.append(tgt_node) + env['GLIB_MKENUMS_TARGET']=tgt_node.abspath() + options=[] + if enum['template']: + template_node=self.path.find_resource(enum['template']) + options.append('--template %s'%(template_node.abspath())) + 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.items(): + if enum[param]: + options.append('%s %r'%(option,enum[param])) + env['GLIB_MKENUMS_OPTIONS']=' '.join(options) + task.set_inputs(inputs) + task.set_outputs(tgt_node) +class glib_mkenums(Task.Task): + run_str='${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}' + color='PINK' + ext_out=['.h'] +@taskgen_method +def add_settings_schemas(self,filename_list): + if not hasattr(self,'settings_schema_files'): + self.settings_schema_files=[] + if not isinstance(filename_list,list): + filename_list=[filename_list] + self.settings_schema_files.extend(filename_list) +@taskgen_method +def add_settings_enums(self,namespace,filename_list): + if hasattr(self,'settings_enum_namespace'): + raise Errors.WafError("Tried to add gsettings enums to '%s' more than once"%self.name) + self.settings_enum_namespace=namespace + if type(filename_list)!='list': + filename_list=[filename_list] + self.settings_enum_files=filename_list +def r_change_ext(self,ext): + name=self.name + k=name.rfind('.') + if k>=0: + name=name[:k]+ext + else: + name=name+ext + return self.parent.find_or_declare([name]) +@feature('glib2') +def process_settings(self): + enums_tgt_node=[] + install_files=[] + settings_schema_files=getattr(self,'settings_schema_files',[]) + if settings_schema_files and not self.env['GLIB_COMPILE_SCHEMAS']: + raise Errors.WafError("Unable to process GSettings schemas - glib-compile-schemas was not found during configure") + if hasattr(self,'settings_enum_files'): + enums_task=self.create_task('glib_mkenums') + source_list=self.settings_enum_files + source_list=[self.path.find_resource(k)for k in source_list] + enums_task.set_inputs(source_list) + enums_task.env['GLIB_MKENUMS_SOURCE']=[k.abspath()for k in source_list] + target=self.settings_enum_namespace+'.enums.xml' + tgt_node=self.path.find_or_declare(target) + enums_task.set_outputs(tgt_node) + enums_task.env['GLIB_MKENUMS_TARGET']=tgt_node.abspath() + enums_tgt_node=[tgt_node] + install_files.append(tgt_node) + options='--comments "" --fhead "" --vhead " <@type@ id=\\"%s.@EnumName@\\">" --vprod " " --vtail " " --ftail "" '%(self.settings_enum_namespace) + enums_task.env['GLIB_MKENUMS_OPTIONS']=options + for schema in settings_schema_files: + schema_task=self.create_task('glib_validate_schema') + schema_node=self.path.find_resource(schema) + if not schema_node: + raise Errors.WafError("Cannot find the schema file '%s'"%schema) + install_files.append(schema_node) + source_list=enums_tgt_node+[schema_node] + schema_task.set_inputs(source_list) + schema_task.env['GLIB_COMPILE_SCHEMAS_OPTIONS']=[("--schema-file="+k.abspath())for k in source_list] + target_node=r_change_ext(schema_node,'.xml.valid') + schema_task.set_outputs(target_node) + schema_task.env['GLIB_VALIDATE_SCHEMA_OUTPUT']=target_node.abspath() + def compile_schemas_callback(bld): + if not bld.is_install:return + Logs.pprint('YELLOW','Updating GSettings schema cache') + command=Utils.subst_vars("${GLIB_COMPILE_SCHEMAS} ${GSETTINGSSCHEMADIR}",bld.env) + ret=self.bld.exec_command(command) + if self.bld.is_install: + if not self.env['GSETTINGSSCHEMADIR']: + raise Errors.WafError('GSETTINGSSCHEMADIR not defined (should have been set up automatically during configure)') + if install_files: + self.bld.install_files(self.env['GSETTINGSSCHEMADIR'],install_files) + if not hasattr(self.bld,'_compile_schemas_registered'): + self.bld.add_post_fun(compile_schemas_callback) + self.bld._compile_schemas_registered=True +class glib_validate_schema(Task.Task): + run_str='rm -f ${GLIB_VALIDATE_SCHEMA_OUTPUT} && ${GLIB_COMPILE_SCHEMAS} --dry-run ${GLIB_COMPILE_SCHEMAS_OPTIONS} && touch ${GLIB_VALIDATE_SCHEMA_OUTPUT}' + color='PINK' +def configure(conf): + conf.find_program('glib-genmarshal',var='GLIB_GENMARSHAL') + conf.find_perl_program('glib-mkenums',var='GLIB_MKENUMS') + conf.find_program('glib-compile-schemas',var='GLIB_COMPILE_SCHEMAS',mandatory=False) + def getstr(varname): + return getattr(Options.options,varname,getattr(conf.env,varname,'')) + gsettingsschemadir=getstr('GSETTINGSSCHEMADIR') + if not gsettingsschemadir: + datadir=getstr('DATADIR') + if not datadir: + prefix=conf.env['PREFIX'] + datadir=os.path.join(prefix,'share') + gsettingsschemadir=os.path.join(datadir,'glib-2.0','schemas') + conf.env['GSETTINGSSCHEMADIR']=gsettingsschemadir +def options(opt): + opt.add_option('--gsettingsschemadir',help='GSettings schema location [Default: ${datadir}/glib-2.0/schemas]',default='',dest='GSETTINGSSCHEMADIR') diff --git a/waflib/Tools/gnu_dirs.py b/waflib/Tools/gnu_dirs.py new file mode 100644 index 0000000..9c8a304 --- /dev/null +++ b/waflib/Tools/gnu_dirs.py @@ -0,0 +1,65 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils,Options,Context +_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 configure(conf): + def get_param(varname,default): + return getattr(Options.options,varname,'')or default + env=conf.env + env.LIBDIR=env.BINDIR=[] + env.EXEC_PREFIX=get_param('EXEC_PREFIX',env.PREFIX) + env.PACKAGE=getattr(Context.g_module,'APPNAME',None)or env.PACKAGE + complete=False + iter=0 + while not complete and iter04 z8Kzq-RHRFsV{SR_m&hTXAm1aOAcq|C0g~T)EiDk+>}?~Yo}Sn5fA{;nruy%B?{EM7 za}d$^Q^WI@_?a9-jIW}U=*Z10lq%|1=%_;dDjij+U!$WMsVIP!hg~pKC*Yrer z-%Il-L;~NS=3AUN3rmh#jOXnh%=u9sYag^SER#2+7b{+pMd=`RE^qlKh!}g)NyfV| z32@BiSp1|}nl3iEarqfq&tsbF07BYDA;fnp0k13Y5r0GNyv4T*Y~R0w!f8&;?V z62=M*6~!1U)T`1fnY3z*E*97XFsd@py{b|X2+yoY&64$KgrypdYIOcr8dhnpTvS6y z-X=T8cm`Cv|B}d2@$v|qcAllqhs?5lZ0XA?jizWcO`{naPEqe2dIcY+*alvg%-3|W zPWBG<7T8UYhBNGA?|TfA_Fd|If9$ez91Ncvp59S4dzW5%RNhwjI8Q-+ar!mkdwANV zL-=b>7@EbA2NOqb(dgFLxbtPntSD$@Y+g|#1dlAigSN4W9WYk-oiIs(l0(#83T49m}3&p(6S1+?*af8m%=FLfI~XbX%X=8!AXPX zE)Mg5JQo~7(#7_@4}VM@1F6}{tXfd_)KAnj{(R+OTvT&-R@J(i$I3LG0%m-IcpC-G z{)LIdFhCjr3l$GkJAX>?9YD#ajBLE@Y7EPYkp^X6E=}lo6}m#%^=iBZCUv?*_#QeM zU<$y3+KzGi!oAC*_%^tzYHWFqscadb_a%em_VK|4I|Rhyc}A)Gj3P4xyoleS;WQ&f zr$UP(j{uNt8rngH_K6t?^`;s8*x2b`=r9I$)E5x*o_P=BF0OWAno9rlQFAzU{ zZ2$9}Wy7a?!fSZX8)*NAuP|m_-uQkw))o8|6gf@fIIns4yKRStKfk;(9!pUK3>{K1 ztXc5Etbp_k_e7)*SIzi(xL4E6rQB#3-jD~zzqIkd91AAj5I|ijk|o199>YniTjqm8 zFaWp-oE8{i7+BUHiUX5*^)4V| zLETk9#%xglWkCs!20s9kB*3*VL2PNNt|_oKQ>2NNRGqt|{tQI1a~a`x9i}Au6W6Rh S6(@Q3=hXYEdUs9DF8&vf;KTg@ literal 0 HcmV?d00001 diff --git a/waflib/Tools/gxx.py b/waflib/Tools/gxx.py new file mode 100644 index 0000000..475f7fd --- /dev/null +++ b/waflib/Tools/gxx.py @@ -0,0 +1,98 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +def find_gxx(conf): + cxx=conf.find_program(['g++','c++'],var='CXX') + cxx=conf.cmd_to_list(cxx) + conf.get_cc_version(cxx,gcc=True) + conf.env.CXX_NAME='gcc' + conf.env.CXX=cxx +@conf +def gxx_common_flags(conf): + v=conf.env + v['CXX_SRC_F']=[] + v['CXX_TGT_F']=['-c','-o'] + if not v['LINK_CXX']:v['LINK_CXX']=v['CXX'] + v['CXXLNK_SRC_F']=[] + v['CXXLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Wl,-Bdynamic' + v['STLIB_MARKER']='-Wl,-Bstatic' + v['cxxprogram_PATTERN']='%s' + v['CXXFLAGS_cxxshlib']=['-fPIC'] + v['LINKFLAGS_cxxshlib']=['-shared'] + v['cxxshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cxxstlib']=['-Wl,-Bstatic'] + v['cxxstlib_PATTERN']='lib%s.a' + v['LINKFLAGS_MACBUNDLE']=['-bundle','-undefined','dynamic_lookup'] + v['CXXFLAGS_MACBUNDLE']=['-fPIC'] + v['macbundle_PATTERN']='%s.bundle' +@conf +def gxx_modifier_win32(conf): + v=conf.env + v['cxxprogram_PATTERN']='%s.exe' + v['cxxshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='lib%s.dll.a' + v['IMPLIB_ST']='-Wl,--out-implib,%s' + v['CXXFLAGS_cxxshlib']=[] + v.append_value('LINKFLAGS',['-Wl,--enable-auto-import']) +@conf +def gxx_modifier_cygwin(conf): + gxx_modifier_win32(conf) + v=conf.env + v['cxxshlib_PATTERN']='cyg%s.dll' + v.append_value('LINKFLAGS_cxxshlib',['-Wl,--enable-auto-image-base']) + v['CXXFLAGS_cxxshlib']=[] +@conf +def gxx_modifier_darwin(conf): + v=conf.env + v['CXXFLAGS_cxxshlib']=['-fPIC'] + v['LINKFLAGS_cxxshlib']=['-dynamiclib','-Wl,-compatibility_version,1','-Wl,-current_version,1'] + v['cxxshlib_PATTERN']='lib%s.dylib' + v['FRAMEWORKPATH_ST']='-F%s' + v['FRAMEWORK_ST']=['-framework'] + v['ARCH_ST']=['-arch'] + v['LINKFLAGS_cxxstlib']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['SONAME_ST']=[] +@conf +def gxx_modifier_aix(conf): + v=conf.env + v['LINKFLAGS_cxxprogram']=['-Wl,-brtl'] + v['LINKFLAGS_cxxshlib']=['-shared','-Wl,-brtl,-bexpfull'] + v['SHLIB_MARKER']=[] +@conf +def gxx_modifier_hpux(conf): + v=conf.env + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']='-Bstatic' + v['CFLAGS_cxxshlib']=['-fPIC','-DPIC'] + v['cxxshlib_PATTERN']='lib%s.sl' +@conf +def gxx_modifier_openbsd(conf): + conf.env.SONAME_ST=[] +@conf +def gxx_modifier_platform(conf): + gxx_modifier_func=getattr(conf,'gxx_modifier_'+conf.env.DEST_OS,None) + if gxx_modifier_func: + gxx_modifier_func() +def configure(conf): + conf.find_gxx() + 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/waflib/Tools/icc.py b/waflib/Tools/icc.py new file mode 100644 index 0000000..7c75e18 --- /dev/null +++ b/waflib/Tools/icc.py @@ -0,0 +1,30 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib.Tools import ccroot,ar,gcc +from waflib.Configure import conf +@conf +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) + conf.get_cc_version(cc,icc=True) + v['CC']=cc + v['CC_NAME']='icc' +def configure(conf): + conf.find_icc() + 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/waflib/Tools/icpc.py b/waflib/Tools/icpc.py new file mode 100644 index 0000000..14a5325 --- /dev/null +++ b/waflib/Tools/icpc.py @@ -0,0 +1,29 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib.Tools import ccroot,ar,gxx +from waflib.Configure import conf +@conf +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) + conf.get_cc_version(cxx,icc=True) + v['CXX']=cxx + v['CXX_NAME']='icc' +def configure(conf): + conf.find_icpc() + 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/waflib/Tools/ifort.py b/waflib/Tools/ifort.py new file mode 100644 index 0000000..a9f2528 --- /dev/null +++ b/waflib/Tools/ifort.py @@ -0,0 +1,49 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils +from waflib.Tools import fc,fc_config,fc_scan,ar +from waflib.Configure import conf +@conf +def find_ifort(conf): + fc=conf.find_program('ifort',var='FC') + fc=conf.cmd_to_list(fc) + conf.get_ifort_version(fc) + conf.env.FC_NAME='IFORT' +@conf +def ifort_modifier_cygwin(conf): + raise NotImplementedError("Ifort on cygwin not yet implemented") +@conf +def ifort_modifier_win32(conf): + fc_config.fortran_modifier_win32(conf) +@conf +def ifort_modifier_darwin(conf): + fc_config.fortran_modifier_darwin(conf) +@conf +def ifort_modifier_platform(conf): + dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform() + ifort_modifier_func=getattr(conf,'ifort_modifier_'+dest_os,None) + if ifort_modifier_func: + ifort_modifier_func() +@conf +def get_ifort_version(conf,fc): + version_re=re.compile(r"ifort\s*\(IFORT\)\s*(?P\d*)\.(?P\d*)",re.I).search + cmd=fc+['--version'] + out,err=fc_config.getoutput(conf,cmd,stdin=False) + if out: + match=version_re(out) + else: + match=version_re(err) + if not match: + conf.fatal('cannot determine ifort version.') + k=match.groupdict() + conf.env['FC_VERSION']=(k['major'],k['minor']) +def configure(conf): + conf.find_ifort() + conf.find_program('xiar',var='AR') + conf.env.ARFLAGS='rcs' + conf.fc_flags() + conf.fc_add_flags() + conf.ifort_modifier_platform() diff --git a/waflib/Tools/intltool.py b/waflib/Tools/intltool.py new file mode 100644 index 0000000..d558674 --- /dev/null +++ b/waflib/Tools/intltool.py @@ -0,0 +1,77 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re +from waflib import Configure,TaskGen,Task,Utils,Runner,Options,Build,Logs +import waflib.Tools.ccroot +from waflib.TaskGen import feature,before_method +from waflib.Logs import error +@before_method('process_source') +@feature('intltool_in') +def apply_intltool_in_f(self): + try:self.meths.remove('process_source') + except ValueError:pass + if not self.env.LOCALEDIR: + self.env.LOCALEDIR=self.env.PREFIX+'/share/locale' + 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(),podir,cache) + self.env['INTLPODIR']=podirnode.bldpath() + self.env['INTLFLAGS']=getattr(self,'flags',['-q','-u','-c']) + task=self.create_task('intltool',node,node.change_ext('')) + inst=getattr(self,'install_path','${LOCALEDIR}') + if inst: + self.bld.install_files(inst,task.outputs) +@feature('intltool_po') +def apply_intltool_po(self): + try:self.meths.remove('process_source') + except ValueError:pass + if not self.env.LOCALEDIR: + self.env.LOCALEDIR=self.env.PREFIX+'/share/locale' + appname=getattr(self,'appname','set_your_app_name') + podir=getattr(self,'podir','') + inst=getattr(self,'install_path','${LOCALEDIR}') + linguas=self.path.find_node(os.path.join(podir,'LINGUAS')) + if linguas: + file=open(linguas.abspath()) + langs=[] + for line in file.readlines(): + if not line.startswith('#'): + langs+=line.split() + file.close() + re_linguas=re.compile('[-a-zA-Z_@.]+') + for lang in langs: + 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',node,node.change_ext('.mo')) + if inst: + filename=task.outputs[0].name + (langname,ext)=os.path.splitext(filename) + inst_file=inst+os.sep+langname+os.sep+'LC_MESSAGES'+os.sep+appname+'.mo' + self.bld.install_as(inst_file,task.outputs[0],chmod=getattr(self,'chmod',Utils.O644),env=task.env) + else: + Logs.pprint('RED',"Error no LINGUAS file found in po directory") +class po(Task.Task): + run_str='${MSGFMT} -o ${TGT} ${SRC}' + color='BLUE' +class intltool(Task.Task): + run_str='${INTLTOOL} ${INTLFLAGS} ${INTLCACHE} ${INTLPODIR} ${SRC} ${TGT}' + color='BLUE' +def configure(conf): + conf.find_program('msgfmt',var='MSGFMT') + conf.find_perl_program('intltool-merge',var='INTLTOOL') + prefix=conf.env.PREFIX + datadir=conf.env.DATADIR + if not datadir: + datadir=os.path.join(prefix,'share') + conf.define('LOCALEDIR',os.path.join(datadir,'locale').replace('\\','\\\\')) + conf.define('DATADIR',datadir.replace('\\','\\\\')) + if conf.env.CC or conf.env.CXX: + conf.check(header_name='locale.h') diff --git a/waflib/Tools/irixcc.py b/waflib/Tools/irixcc.py new file mode 100644 index 0000000..8dbdfca --- /dev/null +++ b/waflib/Tools/irixcc.py @@ -0,0 +1,48 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +def find_irixcc(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('cc',var='CC') + if not cc:conf.fatal('irixcc was not found') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-version']) + except Exception: + conf.fatal('%r -version could not be executed'%cc) + v['CC']=cc + v['CC_NAME']='irix' +@conf +def irixcc_common_flags(conf): + v=conf.env + v['CC_SRC_F']='' + v['CC_TGT_F']=['-c','-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']='' + v['CCLNK_TGT_F']=['-o'] + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['cprogram_PATTERN']='%s' + v['cshlib_PATTERN']='lib%s.so' + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_irixcc() + conf.find_cpp() + conf.find_ar() + conf.irixcc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() diff --git a/waflib/Tools/javaw.py b/waflib/Tools/javaw.py new file mode 100644 index 0000000..15f128c --- /dev/null +++ b/waflib/Tools/javaw.py @@ -0,0 +1,309 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re,tempfile,shutil +from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node,Logs +from waflib.Configure import conf +from waflib.TaskGen import feature,before_method,after_method +from waflib.Tools import ccroot +ccroot.USELIB_VARS['javac']=set(['CLASSPATH','JAVACFLAGS']) +SOURCE_RE='**/*.java' +JAR_RE='**/*' +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('javac') +@before_method('process_source') +def apply_java(self): + Utils.def_attrs(self,jarname='',classpath='',sourcepath='.',srcdir='.',jar_mf_attributes={},jar_mf_classpath=[]) + nodes_lst=[] + outdir=getattr(self,'outdir',None) + if outdir: + if not isinstance(outdir,Node.Node): + outdir=self.path.get_bld().make_node(self.outdir) + else: + outdir=self.path.get_bld() + outdir.mkdir() + self.outdir=outdir + self.env['OUTDIR']=outdir.abspath() + self.javac_task=tsk=self.create_task('javac') + tmp=[] + srcdir=getattr(self,'srcdir','') + if isinstance(srcdir,Node.Node): + srcdir=[srcdir] + for x in Utils.to_list(srcdir): + if isinstance(x,Node.Node): + y=x + else: + y=self.path.find_dir(x) + if not y: + self.bld.fatal('Could not find the folder %s from %s'%(x,self.path)) + tmp.append(y) + tsk.srcdir=tmp + if getattr(self,'compat',None): + tsk.env.append_value('JAVACFLAGS',['-source',self.compat]) + if hasattr(self,'sourcepath'): + fold=[isinstance(x,Node.Node)and x or 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=[x.srcpath()for x in tsk.srcdir] + if names: + tsk.env.append_value('JAVACFLAGS',['-sourcepath',names]) +@feature('javac') +@after_method('apply_java') +def use_javac_files(self): + lst=[] + self.uselib=self.to_list(getattr(self,'uselib',[])) + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except Exception: + self.uselib.append(x) + else: + y.post() + lst.append(y.jar_task.outputs[0].abspath()) + self.javac_task.set_run_after(y.jar_task) + if lst: + self.env.append_value('CLASSPATH',lst) +@feature('javac') +@after_method('apply_java','propagate_uselib_vars','use_javac_files') +def set_classpath(self): + self.env.append_value('CLASSPATH',getattr(self,'classpath',[])) + for x in self.tasks: + x.env.CLASSPATH=os.pathsep.join(self.env.CLASSPATH)+os.pathsep +@feature('jar') +@after_method('apply_java','use_javac_files') +@before_method('process_source') +def jar_files(self): + destfile=getattr(self,'destfile','test.jar') + jaropts=getattr(self,'jaropts',[]) + manifest=getattr(self,'manifest',None) + basedir=getattr(self,'basedir',None) + if basedir: + if not isinstance(self.basedir,Node.Node): + basedir=self.path.get_bld().make_node(basedir) + else: + basedir=self.path.get_bld() + if not basedir: + self.bld.fatal('Could not find the basedir %r for %r'%(self.basedir,self)) + self.jar_task=tsk=self.create_task('jar_create') + if manifest: + jarcreate=getattr(self,'jarcreate','cfm') + node=self.path.find_node(manifest) + tsk.dep_nodes.append(node) + jaropts.insert(0,node.abspath()) + else: + jarcreate=getattr(self,'jarcreate','cf') + if not isinstance(destfile,Node.Node): + destfile=self.path.find_or_declare(destfile) + if not destfile: + self.bld.fatal('invalid destfile %r for %r'%(destfile,self)) + tsk.set_outputs(destfile) + tsk.basedir=basedir + jaropts.append('-C') + jaropts.append(basedir.bldpath()) + jaropts.append('.') + tsk.env['JAROPTS']=jaropts + tsk.env['JARCREATE']=jarcreate + if getattr(self,'javac_task',None): + tsk.set_run_after(self.javac_task) +@feature('jar') +@after_method('jar_files') +def use_jar_files(self): + lst=[] + self.uselib=self.to_list(getattr(self,'uselib',[])) + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except Exception: + self.uselib.append(x) + else: + y.post() + self.jar_task.run_after.update(y.tasks) +class jar_create(Task.Task): + color='GREEN' + run_str='${JAR} ${JARCREATE} ${TGT} ${JAROPTS}' + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + if not self.inputs: + global JAR_RE + try: + self.inputs=[x for x in self.basedir.ant_glob(JAR_RE,remove=False)if id(x)!=id(self.outputs[0])] + except Exception: + raise Errors.WafError('Could not find the basedir %r for %r'%(self.basedir,self)) + return super(jar_create,self).runnable_status() +class javac(Task.Task): + color='BLUE' + nocache=True + vars=['CLASSPATH','JAVACFLAGS','JAVAC','OUTDIR'] + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + if not self.inputs: + global SOURCE_RE + self.inputs=[] + for x in self.srcdir: + self.inputs.extend(x.ant_glob(SOURCE_RE,remove=False)) + return super(javac,self).runnable_status() + def run(self): + env=self.env + gen=self.generator + bld=gen.bld + wd=bld.bldnode.abspath() + def to_list(xx): + if isinstance(xx,str):return[xx] + return xx + cmd=[] + cmd.extend(to_list(env['JAVAC'])) + cmd.extend(['-classpath']) + cmd.extend(to_list(env['CLASSPATH'])) + cmd.extend(['-d']) + cmd.extend(to_list(env['OUTDIR'])) + cmd.extend(to_list(env['JAVACFLAGS'])) + files=[a.path_from(bld.bldnode)for a in self.inputs] + tmp=None + try: + if len(str(files))+len(str(cmd))>8192: + (fd,tmp)=tempfile.mkstemp(dir=bld.bldnode.abspath()) + try: + os.write(fd,'\n'.join(files)) + finally: + if tmp: + os.close(fd) + if Logs.verbose: + Logs.debug('runner: %r'%(cmd+files)) + cmd.append('@'+tmp) + else: + cmd+=files + ret=self.exec_command(cmd,cwd=wd,env=env.env or None) + finally: + if tmp: + os.remove(tmp) + return ret + def post_run(self): + for n in self.generator.outdir.ant_glob('**/*.class'): + n.sig=Utils.h_file(n.abspath()) + self.generator.bld.task_sigs[self.uid()]=self.cache_sig +@feature('javadoc') +@after_method('process_rule') +def create_javadoc(self): + tsk=self.create_task('javadoc') + tsk.classpath=getattr(self,'classpath',[]) + self.javadoc_package=Utils.to_list(self.javadoc_package) + if not isinstance(self.javadoc_output,Node.Node): + self.javadoc_output=self.bld.path.find_or_declare(self.javadoc_output) +class javadoc(Task.Task): + color='BLUE' + def __str__(self): + return'%s: %s -> %s\n'%(self.__class__.__name__,self.generator.srcdir,self.generator.javadoc_output) + def run(self): + env=self.env + bld=self.generator.bld + wd=bld.bldnode.abspath() + srcpath=self.generator.path.abspath()+os.sep+self.generator.srcdir + srcpath+=os.pathsep + srcpath+=self.generator.path.get_bld().abspath()+os.sep+self.generator.srcdir + classpath=env.CLASSPATH + classpath+=os.pathsep + classpath+=os.pathsep.join(self.classpath) + classpath="".join(classpath) + self.last_cmd=lst=[] + lst.extend(Utils.to_list(env['JAVADOC'])) + lst.extend(['-d',self.generator.javadoc_output.abspath()]) + lst.extend(['-sourcepath',srcpath]) + lst.extend(['-classpath',classpath]) + lst.extend(['-subpackages']) + lst.extend(self.generator.javadoc_package) + lst=[x for x in lst if x] + self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None,quiet=0) + def post_run(self): + nodes=self.generator.javadoc_output.ant_glob('**') + for x in nodes: + x.sig=Utils.h_file(x.abspath()) + self.generator.bld.task_sigs[self.uid()]=self.cache_sig +def configure(self): + java_path=self.environ['PATH'].split(os.pathsep) + v=self.env + if'JAVA_HOME'in self.environ: + java_path=[os.path.join(self.environ['JAVA_HOME'],'bin')]+java_path + self.env['JAVA_HOME']=[self.environ['JAVA_HOME']] + for x in'javac java jar javadoc'.split(): + self.find_program(x,var=x.upper(),path_list=java_path) + self.env[x.upper()]=self.cmd_to_list(self.env[x.upper()]) + if'CLASSPATH'in self.environ: + v['CLASSPATH']=self.environ['CLASSPATH'] + if not v['JAR']:self.fatal('jar is required for making java packages') + if not v['JAVAC']:self.fatal('javac is required for compiling java classes') + v['JARCREATE']='cf' + v['JAVACFLAGS']=[] +@conf +def check_java_class(self,classname,with_classpath=None): + 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) + Utils.writef(os.path.join(javatestdir,'Test.java'),class_check_source) + self.exec_command(self.env['JAVAC']+[os.path.join(javatestdir,'Test.java')],shell=False) + cmd=self.env['JAVA']+['-cp',classpath,'Test',classname] + self.to_log("%s\n"%str(cmd)) + found=self.exec_command(cmd,shell=False) + self.msg('Checking for java class %s'%classname,not found) + shutil.rmtree(javatestdir,True) + return found +@conf +def check_jni_headers(conf): + 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') + javaHome=conf.env['JAVA_HOME'][0] + dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/include') + if dir is None: + dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/../Headers') + if dir is None: + conf.fatal('JAVA_HOME does not seem to be set properly') + f=dir.ant_glob('**/(jni|jni_md).h') + incDirs=[x.parent.abspath()for x in f] + dir=conf.root.find_dir(conf.env.JAVA_HOME[0]) + f=dir.ant_glob('**/*jvm.(so|dll|dylib)') + libDirs=[x.parent.abspath()for x in f]or[javaHome] + f=dir.ant_glob('**/*jvm.(lib)') + if f: + libDirs=[[x,y.parent.abspath()]for x in libDirs for y in f] + for d in libDirs: + try: + conf.check(header_name='jni.h',define_name='HAVE_JNI_H',lib='jvm',libpath=d,includes=incDirs,uselib_store='JAVA',uselib='JAVA') + except Exception: + pass + else: + break + else: + conf.fatal('could not find lib jvm in %r (see config.log)'%libDirs) diff --git a/waflib/Tools/kde4.py b/waflib/Tools/kde4.py new file mode 100644 index 0000000..cd51f5f --- /dev/null +++ b/waflib/Tools/kde4.py @@ -0,0 +1,48 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,re +from waflib import Options,TaskGen,Task,Utils +from waflib.TaskGen import feature,after_method +@feature('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')) + langname=lang.split('/') + langname=langname[-1] + inst=getattr(self,'install_path','${KDE4_LOCALE_INSTALL_DIR}') + self.bld.install_as(inst+os.sep+langname+os.sep+'LC_MESSAGES'+os.sep+getattr(self,'appname','set_your_appname')+'.mo',task.outputs[0],chmod=getattr(self,'chmod',Utils.O644)) +class msgfmt(Task.Task): + color='BLUE' + run_str='${MSGFMT} ${SRC} -o ${TGT}' +def configure(self): + kdeconfig=self.find_program('kde4-config') + prefix=self.cmd_and_log('%s --prefix'%kdeconfig).strip() + fname='%s/share/apps/cmake/modules/KDELibsDependencies.cmake'%prefix + try:os.stat(fname) + except OSError: + fname='%s/share/kde4/apps/cmake/modules/KDELibsDependencies.cmake'%prefix + try:os.stat(fname) + except OSError:self.fatal('could not open %s'%fname) + try: + txt=Utils.readf(fname) + except(OSError,IOError): + self.fatal('could not read %s'%fname) + 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: + self.env[key]=val + self.env['LIB_KDECORE']=['kdecore'] + self.env['LIB_KDEUI']=['kdeui'] + self.env['LIB_KIO']=['kio'] + self.env['LIB_KHTML']=['khtml'] + self.env['LIB_KPARTS']=['kparts'] + self.env['LIBPATH_KDECORE']=[os.path.join(self.env.KDE4_LIB_INSTALL_DIR,'kde4','devel'),self.env.KDE4_LIB_INSTALL_DIR] + self.env['INCLUDES_KDECORE']=[self.env['KDE4_INCLUDE_INSTALL_DIR']] + self.env.append_value('INCLUDES_KDECORE',[self.env['KDE4_INCLUDE_INSTALL_DIR']+os.sep+'KDE']) + self.find_program('msgfmt',var='MSGFMT') diff --git a/waflib/Tools/ldc2.py b/waflib/Tools/ldc2.py new file mode 100644 index 0000000..25b99e5 --- /dev/null +++ b/waflib/Tools/ldc2.py @@ -0,0 +1,37 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +from waflib.Tools import ar,d +from waflib.Configure import conf +@conf +def find_ldc2(conf): + conf.find_program(['ldc2'],var='D') + out=conf.cmd_and_log([conf.env.D,'-version']) + if out.find("based on DMD v2.")==-1: + conf.fatal("detected compiler is not ldc2") +@conf +def common_flags_ldc2(conf): + v=conf.env + v['D_SRC_F']=['-c'] + v['D_TGT_F']='-of%s' + v['D_LINKER']=v['D'] + v['DLNK_SRC_F']='' + v['DLNK_TGT_F']='-of%s' + v['DINC_ST']='-I%s' + v['DSHLIB_MARKER']=v['DSTLIB_MARKER']='' + v['DSTLIB_ST']=v['DSHLIB_ST']='-L-l%s' + v['DSTLIBPATH_ST']=v['DLIBPATH_ST']='-L-L%s' + v['LINKFLAGS_dshlib']=['-L-shared'] + v['DHEADER_ext']='.di' + v['DFLAGS_d_with_header']=['-H','-Hf'] + v['D_HDR_F']='%s' + v['LINKFLAGS']=[] + v['DFLAGS_dshlib']=['-relocation-model=pic'] +def configure(conf): + conf.find_ldc2() + conf.load('ar') + conf.load('d') + conf.common_flags_ldc2() + conf.d_platform_flags() diff --git a/waflib/Tools/lua.py b/waflib/Tools/lua.py new file mode 100644 index 0000000..a0a35fc --- /dev/null +++ b/waflib/Tools/lua.py @@ -0,0 +1,18 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.TaskGen import extension +from waflib import Task,Utils +@extension('.lua') +def add_lua(self,node): + tsk=self.create_task('luac',node,node.change_ext('.luac')) + inst_to=getattr(self,'install_path',self.env.LUADIR and'${LUADIR}'or None) + if inst_to: + self.bld.install_files(inst_to,tsk.outputs) + return tsk +class luac(Task.Task): + run_str='${LUAC} -s -o ${TGT} ${SRC}' + color='PINK' +def configure(conf): + conf.find_program('luac',var='LUAC') diff --git a/waflib/Tools/msvc.py b/waflib/Tools/msvc.py new file mode 100644 index 0000000..dd62e40 --- /dev/null +++ b/waflib/Tools/msvc.py @@ -0,0 +1,749 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,re,tempfile +from waflib import Utils,Task,Logs,Options,Errors +from waflib.Logs import debug,warn +from waflib.TaskGen import after_method,feature +from waflib.Configure import conf +from waflib.Tools import ccroot,c,cxx,ar,winres +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'),('x86_arm','arm')] +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 options(opt): + opt.add_option('--msvc_version',type='string',help='msvc version, eg: "msvc 10.0,msvc 9.0"',default='') + opt.add_option('--msvc_targets',type='string',help='msvc targets, eg: "x64,arm"',default='') +def setup_msvc(conf,versions,arch=False): + platforms=getattr(Options.options,'msvc_targets','').split(',') + if platforms==['']: + 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=getattr(Options.options,'msvc_version','').split(',') + if desired_versions==['']: + 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.rsplit(' ',1) + if arch: + return compiler,revision,p1,p2,p3,arch + else: + 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=conf.bldnode.make_node('waf-print-msvc.bat') + batfile.write("""@echo off +set INCLUDE= +set LIB= +call "%s" %s +echo PATH=%%PATH%% +echo INCLUDE=%%INCLUDE%% +echo LIB=%%LIB%%;%%LIBPATH%% +"""%(vcvars,target)) + sout=conf.cmd_and_log(['cmd','/E:on','/V:on','/C',batfile.abspath()]) + lines=sout.splitlines() + if not lines[0]: + lines.pop(0) + MSVC_PATH=MSVC_INCDIR=MSVC_LIBDIR=None + for line in lines: + if line.startswith('PATH='): + path=line[5:] + MSVC_PATH=path.split(';') + elif line.startswith('INCLUDE='): + MSVC_INCDIR=[i for i in line[8:].split(';')if i] + elif line.startswith('LIB='): + MSVC_LIBDIR=[i for i in line[4:].split(';')if i] + if None in(MSVC_PATH,MSVC_INCDIR,MSVC_LIBDIR): + conf.fatal('msvc: Could not find a valid architecture for building (get_msvc_version_3)') + env=dict(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) + cxx=conf.cmd_to_list(cxx) + if'CL'in env: + del(env['CL']) + try: + try: + conf.cmd_and_log(cxx+['/help'],env=env) + 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) + finally: + conf.env[compiler_name]='' + return(MSVC_PATH,MSVC_INCDIR,MSVC_LIBDIR) +@conf +def gather_wsdk_versions(conf,versions): + version_pattern=re.compile('^v..?.?\...?.?') + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Microsoft\\Microsoft SDKs\\Windows') + except WindowsError: + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows') + except WindowsError: + return + index=0 + while 1: + try: + version=Utils.winreg.EnumKey(all_versions,index) + except WindowsError: + break + index=index+1 + if not version_pattern.match(version): + continue + try: + msvc_version=Utils.winreg.OpenKey(all_versions,version) + path,type=Utils.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 conf.errors.ConfigurationError: + pass + versions.append(('wsdk '+version[1:],targets)) +def gather_wince_supported_platforms(): + supported_wince_platforms=[] + try: + ce_sdk=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Microsoft\\Windows CE Tools\\SDKs') + except WindowsError: + try: + ce_sdk=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Microsoft\\Windows CE Tools\\SDKs') + except WindowsError: + ce_sdk='' + if not ce_sdk: + return supported_wince_platforms + ce_index=0 + while 1: + try: + sdk_device=Utils.winreg.EnumKey(ce_sdk,ce_index) + except WindowsError: + break + ce_index=ce_index+1 + sdk=Utils.winreg.OpenKey(ce_sdk,sdk_device) + try: + path,type=Utils.winreg.QueryValueEx(sdk,'SDKRootDir') + except WindowsError: + try: + path,type=Utils.winreg.QueryValueEx(sdk,'SDKInformation') + path,xml=os.path.split(path) + except WindowsError: + continue + 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)) + return supported_wince_platforms +def gather_msvc_detected_versions(): + version_pattern=re.compile('^(\d\d?\.\d\d?)(Exp)?$') + detected_versions=[] + for vcver,vcvar in[('VCExpress','Exp'),('VisualStudio','')]: + try: + prefix='SOFTWARE\\Wow6432node\\Microsoft\\'+vcver + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,prefix) + except WindowsError: + try: + prefix='SOFTWARE\\Microsoft\\'+vcver + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,prefix) + except WindowsError: + continue + index=0 + while 1: + try: + version=Utils.winreg.EnumKey(all_versions,index) + except WindowsError: + break + index=index+1 + match=version_pattern.match(version) + if not match: + continue + else: + versionnumber=float(match.group(1)) + detected_versions.append((versionnumber,version+vcvar,prefix+"\\"+version)) + def fun(tup): + return tup[0] + detected_versions.sort(key=fun) + return detected_versions +@conf +def gather_msvc_targets(conf,versions,version,vc_path): + targets=[] + if os.path.isfile(os.path.join(vc_path,'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(vc_path,'vcvarsall.bat'))))) + except conf.errors.ConfigurationError: + pass + elif os.path.isfile(os.path.join(vc_path,'Common7','Tools','vsvars32.bat')): + try: + targets.append(('x86',('x86',conf.get_msvc_version('msvc',version,'x86',os.path.join(vc_path,'Common7','Tools','vsvars32.bat'))))) + except conf.errors.ConfigurationError: + pass + elif os.path.isfile(os.path.join(vc_path,'Bin','vcvars32.bat')): + try: + targets.append(('x86',('x86',conf.get_msvc_version('msvc',version,'',os.path.join(vc_path,'Bin','vcvars32.bat'))))) + except conf.errors.ConfigurationError: + pass + if targets: + versions.append(('msvc '+version,targets)) +@conf +def gather_wince_targets(conf,versions,version,vc_path,vsvars,supported_platforms): + for device,platforms in supported_platforms: + cetargets=[] + for platform,compiler,include,lib in platforms: + winCEpath=os.path.join(vc_path,'ce') + if not os.path.isdir(winCEpath): + continue + try: + common_bindirs,_1,_2=conf.get_msvc_version('msvc',version,'x86',vsvars) + except conf.errors.ConfigurationError: + continue + 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=[os.path.join(winCEpath,'include'),os.path.join(winCEpath,'atlmfc','include'),include] + libdirs=[os.path.join(winCEpath,'lib',platform),os.path.join(winCEpath,'atlmfc','lib',platform),lib] + cetargets.append((platform,(platform,(bindirs,incdirs,libdirs)))) + if cetargets: + versions.append((device+' '+version,cetargets)) +@conf +def gather_winphone_targets(conf,versions,version,vc_path,vsvars): + targets=[] + for target,realtarget in all_msvc_platforms[::-1]: + try: + targets.append((target,(realtarget,conf.get_msvc_version('winphone',version,target,vsvars)))) + except conf.errors.ConfigurationError ,e: + pass + if targets: + versions.append(('winphone '+version,targets)) +@conf +def gather_msvc_versions(conf,versions): + vc_paths=[] + for(v,version,reg)in gather_msvc_detected_versions(): + try: + try: + msvc_version=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,reg+"\\Setup\\VC") + except WindowsError: + msvc_version=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,reg+"\\Setup\\Microsoft Visual C++") + path,type=Utils.winreg.QueryValueEx(msvc_version,'ProductDir') + vc_paths.append((version,os.path.abspath(str(path)))) + except WindowsError: + continue + wince_supported_platforms=gather_wince_supported_platforms() + for version,vc_path in vc_paths: + vs_path=os.path.dirname(vc_path) + vsvars=os.path.join(vs_path,'Common7','Tools','vsvars32.bat') + if wince_supported_platforms and os.path.isfile(vsvars): + conf.gather_wince_targets(versions,version,vc_path,vsvars,wince_supported_platforms) + vsvars=os.path.join(vs_path,'VC','WPSDK','WP80','vcvarsphoneall.bat') + if os.path.isfile(vsvars): + conf.gather_winphone_targets(versions,'8.0',vc_path,vsvars) + for version,vc_path in vc_paths: + vs_path=os.path.dirname(vc_path) + conf.gather_msvc_targets(versions,version,vc_path) +@conf +def gather_icl_versions(conf,versions): + version_pattern=re.compile('^...?.?\....?.?') + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Intel\\Compilers\\C++') + except WindowsError: + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Intel\\Compilers\\C++') + except WindowsError: + return + index=0 + while 1: + try: + version=Utils.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: + if target=='intel64':targetDir='EM64T_NATIVE' + else:targetDir=target + Utils.winreg.OpenKey(all_versions,version+'\\'+targetDir) + icl_version=Utils.winreg.OpenKey(all_versions,version) + path,type=Utils.winreg.QueryValueEx(icl_version,'ProductDir') + batch_file=os.path.join(path,'bin','iclvars.bat') + if os.path.isfile(batch_file): + try: + targets.append((target,(arch,conf.get_msvc_version('intel',version,target,batch_file)))) + except conf.errors.ConfigurationError: + pass + except WindowsError: + pass + for target,arch in all_icl_platforms: + try: + icl_version=Utils.winreg.OpenKey(all_versions,version+'\\'+target) + path,type=Utils.winreg.QueryValueEx(icl_version,'ProductDir') + batch_file=os.path.join(path,'bin','iclvars.bat') + if os.path.isfile(batch_file): + try: + targets.append((target,(arch,conf.get_msvc_version('intel',version,target,batch_file)))) + except conf.errors.ConfigurationError: + pass + except WindowsError: + continue + major=version[0:2] + versions.append(('intel '+major,targets)) +@conf +def gather_intel_composer_versions(conf,versions): + version_pattern=re.compile('^...?.?\...?.?.?') + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Intel\\Suites') + except WindowsError: + try: + all_versions=Utils.winreg.OpenKey(Utils.winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Intel\\Suites') + except WindowsError: + return + index=0 + while 1: + try: + version=Utils.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: + if target=='intel64':targetDir='EM64T_NATIVE' + else:targetDir=target + try: + defaults=Utils.winreg.OpenKey(all_versions,version+'\\Defaults\\C++\\'+targetDir) + except WindowsError: + if targetDir=='EM64T_NATIVE': + defaults=Utils.winreg.OpenKey(all_versions,version+'\\Defaults\\C++\\EM64T') + else: + raise WindowsError + uid,type=Utils.winreg.QueryValueEx(defaults,'SubKey') + Utils.winreg.OpenKey(all_versions,version+'\\'+uid+'\\C++\\'+targetDir) + icl_version=Utils.winreg.OpenKey(all_versions,version+'\\'+uid+'\\C++') + path,type=Utils.winreg.QueryValueEx(icl_version,'ProductDir') + batch_file=os.path.join(path,'bin','iclvars.bat') + if os.path.isfile(batch_file): + try: + targets.append((target,(arch,conf.get_msvc_version('intel',version,target,batch_file)))) + except conf.errors.ConfigurationError ,e: + pass + compilervars_warning_attr='_compilervars_warning_key' + if version[0:2]=='13'and getattr(conf,compilervars_warning_attr,True): + setattr(conf,compilervars_warning_attr,False) + patch_url='http://software.intel.com/en-us/forums/topic/328487' + compilervars_arch=os.path.join(path,'bin','compilervars_arch.bat') + for vscomntool in['VS110COMNTOOLS','VS100COMNTOOLS']: + if vscomntool in os.environ: + vs_express_path=os.environ[vscomntool]+r'..\IDE\VSWinExpress.exe' + dev_env_path=os.environ[vscomntool]+r'..\IDE\devenv.exe' + if(r'if exist "%VS110COMNTOOLS%..\IDE\VSWinExpress.exe"'in Utils.readf(compilervars_arch)and not os.path.exists(vs_express_path)and not os.path.exists(dev_env_path)): + Logs.warn(('The Intel compilervar_arch.bat only checks for one Visual Studio SKU ''(VSWinExpress.exe) but it does not seem to be installed at %r. ''The intel command line set up will fail to configure unless the file %r''is patched. See: %s')%(vs_express_path,compilervars_arch,patch_url)) + except WindowsError: + pass + 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_icl_versions(lst) + conf.gather_intel_composer_versions(lst) + conf.gather_wsdk_versions(lst) + conf.gather_msvc_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']: + Logs.info(version) + for target,l in targets: + Logs.info("\t"+target) +@conf +def detect_msvc(conf,arch=False): + versions=get_msvc_versions(conf) + return setup_msvc(conf,versions,arch) +@conf +def find_lt_names_msvc(self,libname,is_static=False): + 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=Utils.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 self.errors.WafError('invalid libtool object file: %s'%laf) + return(None,None,None) +@conf +def libname_msvc(self,libname,is_static=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: + 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) + 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): + libn=self.libname_msvc(libname,is_static) + if not uselib_store: + uselib_store=libname.upper() + if False and is_static: + self.env['STLIB_'+uselib_store]=[libn] + else: + self.env['LIB_'+uselib_store]=[libn] +@conf +def check_libs_msvc(self,libnames,is_static=False): + for libname in Utils.to_list(libnames): + self.check_lib_msvc(libname,is_static) +def configure(conf): + conf.autodetect(True) + conf.find_msvc() + conf.msvc_common_flags() + conf.cc_load_tools() + conf.cxx_load_tools() + conf.cc_add_flags() + conf.cxx_add_flags() + conf.link_add_flags() + conf.visual_studio_add_flags() +@conf +def no_autodetect(conf): + conf.env.NO_MSVC_DETECT=1 + configure(conf) +@conf +def autodetect(conf,arch=False): + v=conf.env + if v.NO_MSVC_DETECT: + return + if arch: + compiler,version,path,includes,libdirs,arch=conf.detect_msvc(True) + v['DEST_CPU']=arch + else: + compiler,version,path,includes,libdirs=conf.detect_msvc() + v['PATH']=path + v['INCLUDES']=includes + v['LIBPATH']=libdirs + v['MSVC_COMPILER']=compiler + try: + v['MSVC_VERSION']=float(version) + except Exception: + v['MSVC_VERSION']=float(version[:-3]) +def _get_prog_names(conf,compiler): + if compiler=='intel': + compiler_name='ICL' + linker_name='XILINK' + lib_name='XILIB' + else: + compiler_name='CL' + linker_name='LINK' + lib_name='LIB' + return compiler_name,linker_name,lib_name +@conf +def find_msvc(conf): + if sys.platform=='cygwin': + conf.fatal('MSVC module does not work under cygwin Python!') + v=conf.env + path=v['PATH'] + compiler=v['MSVC_COMPILER'] + version=v['MSVC_VERSION'] + compiler_name,linker_name,lib_name=_get_prog_names(conf,compiler) + v.MSVC_MANIFEST=(compiler=='msvc'and version>=8)or(compiler=='wsdk'and version>=6)or(compiler=='intel'and version>=11) + cxx=None + if v['CXX']:cxx=v['CXX'] + elif'CXX'in conf.environ:cxx=conf.environ['CXX'] + cxx=conf.find_program(compiler_name,var='CXX',path_list=path) + cxx=conf.cmd_to_list(cxx) + env=dict(conf.environ) + if path:env.update(PATH=';'.join(path)) + if not conf.cmd_and_log(cxx+['/nologo','/help'],env=env): + conf.fatal('the msvc compiler could not be identified') + v['CC']=v['CXX']=cxx + v['CC_NAME']=v['CXX_NAME']='msvc' + if not v['LINK_CXX']: + link=conf.find_program(linker_name,path_list=path) + if link:v['LINK_CXX']=link + else:conf.fatal('%s was not found (linker)'%linker_name) + v['LINK']=link + if not v['LINK_CC']: + v['LINK_CC']=v['LINK_CXX'] + if not v['AR']: + stliblink=conf.find_program(lib_name,path_list=path,var='AR') + if not stliblink:return + v['ARFLAGS']=['/NOLOGO'] + if v.MSVC_MANIFEST: + conf.find_program('MT',path_list=path,var='MT') + v['MTFLAGS']=['/NOLOGO'] + try: + conf.load('winres') + except Errors.WafError: + warn('Resource compiler not found. Compiling resource file is disabled') +@conf +def visual_studio_add_flags(self): + v=self.env + try:v.prepend_value('INCLUDES',[x for x in self.environ['INCLUDE'].split(';')if x]) + except Exception:pass + try:v.prepend_value('LIBPATH',[x for x in self.environ['LIB'].split(';')if x]) + except Exception:pass +@conf +def msvc_common_flags(conf): + v=conf.env + v['DEST_BINFMT']='pe' + v.append_value('CFLAGS',['/nologo']) + v.append_value('CXXFLAGS',['/nologo']) + v['DEFINES_ST']='/D%s' + v['CC_SRC_F']='' + v['CC_TGT_F']=['/c','/Fo'] + v['CXX_SRC_F']='' + v['CXX_TGT_F']=['/c','/Fo'] + if(v.MSVC_COMPILER=='msvc'and v.MSVC_VERSION>=8)or(v.MSVC_COMPILER=='wsdk'and v.MSVC_VERSION>=6): + v['CC_TGT_F']=['/FC']+v['CC_TGT_F'] + v['CXX_TGT_F']=['/FC']+v['CXX_TGT_F'] + v['CPPPATH_ST']='/I%s' + v['AR_TGT_F']=v['CCLNK_TGT_F']=v['CXXLNK_TGT_F']='/OUT:' + v['CFLAGS_CONSOLE']=v['CXXFLAGS_CONSOLE']=['/SUBSYSTEM:CONSOLE'] + v['CFLAGS_NATIVE']=v['CXXFLAGS_NATIVE']=['/SUBSYSTEM:NATIVE'] + v['CFLAGS_POSIX']=v['CXXFLAGS_POSIX']=['/SUBSYSTEM:POSIX'] + v['CFLAGS_WINDOWS']=v['CXXFLAGS_WINDOWS']=['/SUBSYSTEM:WINDOWS'] + v['CFLAGS_WINDOWSCE']=v['CXXFLAGS_WINDOWSCE']=['/SUBSYSTEM:WINDOWSCE'] + v['CFLAGS_CRT_MULTITHREADED']=v['CXXFLAGS_CRT_MULTITHREADED']=['/MT'] + v['CFLAGS_CRT_MULTITHREADED_DLL']=v['CXXFLAGS_CRT_MULTITHREADED_DLL']=['/MD'] + v['CFLAGS_CRT_MULTITHREADED_DBG']=v['CXXFLAGS_CRT_MULTITHREADED_DBG']=['/MTd'] + v['CFLAGS_CRT_MULTITHREADED_DLL_DBG']=v['CXXFLAGS_CRT_MULTITHREADED_DLL_DBG']=['/MDd'] + v['LIB_ST']='%s.lib' + v['LIBPATH_ST']='/LIBPATH:%s' + v['STLIB_ST']='%s.lib' + v['STLIBPATH_ST']='/LIBPATH:%s' + v.append_value('LINKFLAGS',['/NOLOGO']) + if v['MSVC_MANIFEST']: + v.append_value('LINKFLAGS',['/MANIFEST']) + v['CFLAGS_cshlib']=[] + v['CXXFLAGS_cxxshlib']=[] + v['LINKFLAGS_cshlib']=v['LINKFLAGS_cxxshlib']=['/DLL'] + v['cshlib_PATTERN']=v['cxxshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='%s.lib' + v['IMPLIB_ST']='/IMPLIB:%s' + v['LINKFLAGS_cstlib']=[] + v['cstlib_PATTERN']=v['cxxstlib_PATTERN']='%s.lib' + v['cprogram_PATTERN']=v['cxxprogram_PATTERN']='%s.exe' +@after_method('apply_link') +@feature('c','cxx') +def apply_flags_msvc(self): + if self.env.CC_NAME!='msvc'or not getattr(self,'link_task',None): + return + is_static=isinstance(self.link_task,ccroot.stlink_task) + subsystem=getattr(self,'subsystem','') + if subsystem: + subsystem='/subsystem:%s'%subsystem + flags=is_static and'ARFLAGS'or'LINKFLAGS' + self.env.append_value(flags,subsystem) + if not is_static: + for f in self.env.LINKFLAGS: + d=f.lower() + if d[1:]=='debug': + pdbnode=self.link_task.outputs[0].change_ext('.pdb') + self.link_task.outputs.append(pdbnode) + try: + self.install_task.source.append(pdbnode) + except AttributeError: + pass + break +@feature('cprogram','cshlib','cxxprogram','cxxshlib') +@after_method('apply_link') +def apply_manifest(self): + if self.env.CC_NAME=='msvc'and self.env.MSVC_MANIFEST and getattr(self,'link_task',None): + out_node=self.link_task.outputs[0] + man_node=out_node.parent.find_or_declare(out_node.name+'.manifest') + self.link_task.outputs.append(man_node) + self.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].abspath() + manifest=None + for out_node in self.outputs: + if out_node.name.endswith('.manifest'): + manifest=out_node.abspath() + break + if manifest is None: + return 0 + mode='' + if'cprogram'in self.generator.features or'cxxprogram'in self.generator.features: + mode='1' + elif'cshlib'in self.generator.features or'cxxshlib'in self.generator.features: + mode='2' + debug('msvc: embedding manifest in mode %r'%mode) + lst=[] + lst.append(env['MT']) + lst.extend(Utils.to_list(env['MTFLAGS'])) + lst.extend(['-manifest',manifest]) + lst.append('-outputresource:%s;%s'%(outfile,mode)) + lst=[lst] + return self.exec_command(*lst) +def quote_response_command(self,flag): + if flag.find(' ')>-1: + for x in('/LIBPATH:','/IMPLIB:','/OUT:','/I'): + if flag.startswith(x): + flag='%s"%s"'%(x,flag[len(x):]) + break + else: + flag='"%s"'%flag + return flag +def exec_response_command(self,cmd,**kw): + try: + tmp=None + if sys.platform.startswith('win')and isinstance(cmd,list)and len(' '.join(cmd))>=8192: + program=cmd[0] + cmd=[self.quote_response_command(x)for x in cmd] + (fd,tmp)=tempfile.mkstemp() + os.write(fd,'\r\n'.join(i.replace('\\','\\\\')for i in cmd[1:])) + os.close(fd) + cmd=[program,'@'+tmp] + ret=self.generator.bld.exec_command(cmd,**kw) + finally: + if tmp: + try: + os.remove(tmp) + except OSError: + pass + return ret +def exec_command_msvc(self,*k,**kw): + if isinstance(k[0],list): + lst=[] + carry='' + for a in k[0]: + if a=='/Fo'or a=='/doc'or a[-1]==':': + carry=a + else: + lst.append(carry+a) + carry='' + k=[lst] + if self.env['PATH']: + env=dict(self.env.env or os.environ) + env.update(PATH=';'.join(self.env['PATH'])) + kw['env']=env + bld=self.generator.bld + try: + if not kw.get('cwd',None): + kw['cwd']=bld.cwd + except AttributeError: + bld.cwd=kw['cwd']=bld.variant_dir + ret=self.exec_response_command(k[0],**kw) + if not ret and getattr(self,'do_manifest',None): + ret=self.exec_mf() + return ret +def wrap_class(class_name): + cls=Task.classes.get(class_name,None) + if not cls: + return None + derived_class=type(class_name,(cls,),{}) + def exec_command(self,*k,**kw): + if self.env['CC_NAME']=='msvc': + return self.exec_command_msvc(*k,**kw) + else: + return super(derived_class,self).exec_command(*k,**kw) + derived_class.exec_command=exec_command + derived_class.exec_response_command=exec_response_command + derived_class.quote_response_command=quote_response_command + derived_class.exec_command_msvc=exec_command_msvc + derived_class.exec_mf=exec_mf + return derived_class +for k in'c cxx cprogram cxxprogram cshlib cxxshlib cstlib cxxstlib'.split(): + wrap_class(k) +def make_winapp(self,family): + append=self.env.append_unique + append('DEFINES','WINAPI_FAMILY=%s'%family) + append('CXXFLAGS','/ZW') + append('CXXFLAGS','/TP') + for lib_path in self.env.LIBPATH: + append('CXXFLAGS','/AI%s'%lib_path) +@feature('winphoneapp') +@after_method('process_use') +@after_method('propagate_uselib_vars') +def make_winphone_app(self): + make_winapp(self,'WINAPI_FAMILY_PHONE_APP') + conf.env.append_unique('LINKFLAGS','/NODEFAULTLIB:ole32.lib') + conf.env.append_unique('LINKFLAGS','PhoneAppModelHost.lib') +@feature('winapp') +@after_method('process_use') +@after_method('propagate_uselib_vars') +def make_windows_app(self): + make_winapp(self,'WINAPI_FAMILY_DESKTOP_APP') diff --git a/waflib/Tools/nasm.py b/waflib/Tools/nasm.py new file mode 100644 index 0000000..e3126dd --- /dev/null +++ b/waflib/Tools/nasm.py @@ -0,0 +1,14 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.Tools.asm +from waflib.TaskGen import feature +@feature('asm') +def apply_nasm_vars(self): + self.env.append_value('ASFLAGS',self.to_list(getattr(self,'nasm_flags',[]))) +def configure(conf): + nasm=conf.find_program(['nasm','yasm'],var='AS') + conf.env.AS_TGT_F=['-o'] + conf.env.ASLNK_TGT_F=['-o'] + conf.load('asm') diff --git a/waflib/Tools/perl.py b/waflib/Tools/perl.py new file mode 100644 index 0000000..8b6c2f8 --- /dev/null +++ b/waflib/Tools/perl.py @@ -0,0 +1,80 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Options,Utils +from waflib.Configure import conf +from waflib.TaskGen import extension,feature,before_method +@before_method('apply_incpaths','apply_link','propagate_uselib_vars') +@feature('perlext') +def init_perlext(self): + self.uselib=self.to_list(getattr(self,'uselib',[])) + if not'PERLEXT'in self.uselib:self.uselib.append('PERLEXT') + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['perlext_PATTERN'] +@extension('.xs') +def xsubpp_file(self,node): + outnode=node.change_ext('.c') + self.create_task('xsubpp',node,outnode) + self.source.append(outnode) +class xsubpp(Task.Task): + run_str='${PERL} ${XSUBPP} -noprototypes -typemap ${EXTUTILS_TYPEMAP} ${SRC} > ${TGT}' + color='BLUE' + ext_out=['.h'] +@conf +def check_perl_version(self,minver=None): + res=True + if minver: + cver='.'.join(map(str,minver)) + else: + cver='' + self.start_msg('Checking for minimum perl version %s'%cver) + perl=getattr(Options.options,'perlbinary',None) + if not perl: + perl=self.find_program('perl',var='PERL') + if not perl: + self.end_msg("Perl not found",color="YELLOW") + return False + self.env['PERL']=perl + version=self.cmd_and_log([perl,"-e",'printf \"%vd\", $^V']) + if not version: + res=False + version="Unknown" + elif not minver is None: + ver=tuple(map(int,version.split("."))) + if ver +#ifdef __cplusplus +extern "C" { +#endif + void Py_Initialize(void); + void Py_Finalize(void); +#ifdef __cplusplus +} +#endif +int main(int argc, char **argv) +{ + (void)argc; (void)argv; + Py_Initialize(); + Py_Finalize(); + return 0; +} +''' +INST=''' +import sys, py_compile +py_compile.compile(sys.argv[1], sys.argv[2], sys.argv[3]) +''' +DISTUTILS_IMP=['from distutils.sysconfig import get_config_var, get_python_lib'] +@extension('.py') +def process_py(self,node): + try: + if not self.bld.is_install: + return + except AttributeError: + return + try: + if not self.install_path: + return + except AttributeError: + self.install_path='${PYTHONDIR}' + def inst_py(ctx): + install_from=getattr(self,'install_from',None) + if install_from: + install_from=self.path.find_dir(install_from) + install_pyfile(self,node,install_from) + self.bld.add_post_fun(inst_py) +def install_pyfile(self,node,install_from=None): + from_node=install_from or node.parent + tsk=self.bld.install_as(self.install_path+'/'+node.path_from(from_node),node,postpone=False) + path=tsk.get_install_path() + if self.bld.is_install<0: + Logs.info("+ removing byte compiled python files") + for x in'co': + try: + os.remove(path+x) + except OSError: + pass + if self.bld.is_install>0: + try: + st1=os.stat(path) + except OSError: + Logs.error('The python file is missing, this should not happen') + for x in['c','o']: + do_inst=self.env['PY'+x.upper()] + try: + st2=os.stat(path+x) + except OSError: + pass + else: + if st1.st_mtime<=st2.st_mtime: + do_inst=False + if do_inst: + lst=(x=='o')and[self.env['PYFLAGS_OPT']]or[] + (a,b,c)=(path,path+x,tsk.get_install_path(destdir=False)+x) + argv=self.env['PYTHON']+lst+['-c',INST,a,b,c] + Logs.info('+ byte compiling %r'%(path+x)) + env=self.env.env or None + ret=Utils.subprocess.Popen(argv,env=env).wait() + if ret: + raise Errors.WafError('py%s compilation failed %r'%(x,path)) +@feature('py') +def feature_py(self): + pass +@feature('pyext') +@before_method('propagate_uselib_vars','apply_link') +@after_method('apply_bundle') +def init_pyext(self): + self.uselib=self.to_list(getattr(self,'uselib',[])) + if not'PYEXT'in self.uselib: + self.uselib.append('PYEXT') + self.env.cshlib_PATTERN=self.env.cxxshlib_PATTERN=self.env.macbundle_PATTERN=self.env.pyext_PATTERN + self.env.fcshlib_PATTERN=self.env.dshlib_PATTERN=self.env.pyext_PATTERN + try: + if not self.install_path: + return + except AttributeError: + self.install_path='${PYTHONARCHDIR}' +@feature('pyext') +@before_method('apply_link','apply_bundle') +def set_bundle(self): + if Utils.unversioned_sys_platform()=='darwin': + self.mac_bundle=True +@before_method('propagate_uselib_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') +@conf +def get_python_variables(self,variables,imports=None): + if not imports: + try: + imports=self.python_imports + except AttributeError: + imports=DISTUTILS_IMP + 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'] + except KeyError: + pass + try: + out=self.cmd_and_log(self.env.PYTHON+['-c','\n'.join(program)],env=os_env) + except Errors.WafError: + self.fatal('The distutils module is unusable: install "python-devel"?') + self.to_log(out) + return_values=[] + for s in out.split('\n'): + 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): + env=conf.env + if not env['CC_NAME']and not env['CXX_NAME']: + conf.fatal('load a compiler first (gcc, g++, ..)') + if not env['PYTHON_VERSION']: + conf.check_python_version() + pybin=conf.env.PYTHON + if not pybin: + conf.fatal('Could not find the python executable') + v='prefix SO LDFLAGS LIBDIR LIBPL INCLUDEPY Py_ENABLE_SHARED MACOSX_DEPLOYMENT_TARGET LDSHARED CFLAGS'.split() + try: + lst=conf.get_python_variables(["get_config_var('%s') or ''"%x for x in v]) + except RuntimeError: + conf.fatal("Python development headers not found (-v for details).") + vals=['%s = %r'%(x,y)for(x,y)in zip(v,lst)] + conf.to_log("Configuration returned from %r:\n%r\n"%(pybin,'\n'.join(vals))) + dct=dict(zip(v,lst)) + x='MACOSX_DEPLOYMENT_TARGET' + if dct[x]: + conf.env[x]=conf.environ[x]=dct[x] + env['pyext_PATTERN']='%s'+dct['SO'] + all_flags=dct['LDFLAGS']+' '+dct['CFLAGS'] + conf.parse_flags(all_flags,'PYEMBED') + all_flags=dct['LDFLAGS']+' '+dct['LDSHARED']+' '+dct['CFLAGS'] + conf.parse_flags(all_flags,'PYEXT') + result=None + for name in('python'+env['PYTHON_VERSION'],'python'+env['PYTHON_VERSION']+'m','python'+env['PYTHON_VERSION'].replace('.','')): + if not result and env['LIBPATH_PYEMBED']: + path=env['LIBPATH_PYEMBED'] + conf.to_log("\n\n# Trying default LIBPATH_PYEMBED: %r\n"%path) + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBPATH_PYEMBED'%name) + if not result and dct['LIBDIR']: + path=[dct['LIBDIR']] + conf.to_log("\n\n# try again with -L$python_LIBDIR: %r\n"%path) + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBDIR'%name) + if not result and dct['LIBPL']: + path=[dct['LIBPL']] + conf.to_log("\n\n# try again with -L$python_LIBPL (some systems don't install the python library in $prefix/lib)\n") + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in python_LIBPL'%name) + if not result: + path=[os.path.join(dct['prefix'],"libs")] + conf.to_log("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n") + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in $prefix/libs'%name) + if result: + break + if result: + env['LIBPATH_PYEMBED']=path + env.append_value('LIB_PYEMBED',[name]) + else: + conf.to_log("\n\n### LIB NOT FOUND\n") + if(Utils.is_win32 or sys.platform.startswith('os2')or dct['Py_ENABLE_SHARED']): + env['LIBPATH_PYEXT']=env['LIBPATH_PYEMBED'] + env['LIB_PYEXT']=env['LIB_PYEMBED'] + num='.'.join(env['PYTHON_VERSION'].split('.')[:2]) + conf.find_program([''.join(pybin)+'-config','python%s-config'%num,'python-config-%s'%num,'python%sm-config'%num],var='PYTHON_CONFIG',mandatory=False) + includes=[] + if conf.env.PYTHON_CONFIG: + for incstr in conf.cmd_and_log([conf.env.PYTHON_CONFIG,'--includes']).strip().split(): + if(incstr.startswith('-I')or incstr.startswith('/I')): + incstr=incstr[2:] + if incstr not in includes: + includes.append(incstr) + conf.to_log("Include path for Python extensions (found via python-config --includes): %r\n"%(includes,)) + env['INCLUDES_PYEXT']=includes + env['INCLUDES_PYEMBED']=includes + else: + conf.to_log("Include path for Python extensions ""(found via distutils module): %r\n"%(dct['INCLUDEPY'],)) + env['INCLUDES_PYEXT']=[dct['INCLUDEPY']] + env['INCLUDES_PYEMBED']=[dct['INCLUDEPY']] + if env['CC_NAME']=='gcc': + env.append_value('CFLAGS_PYEMBED',['-fno-strict-aliasing']) + env.append_value('CFLAGS_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']) + if env.CC_NAME=="msvc": + from distutils.msvccompiler import MSVCCompiler + dist_compiler=MSVCCompiler() + dist_compiler.initialize() + env.append_value('CFLAGS_PYEXT',dist_compiler.compile_options) + env.append_value('CXXFLAGS_PYEXT',dist_compiler.compile_options) + env.append_value('LINKFLAGS_PYEXT',dist_compiler.ldflags_shared) + try: + conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',uselib='PYEMBED',fragment=FRAG,errmsg=':-(') + except conf.errors.ConfigurationError: + xx=conf.env.CXX_NAME and'cxx'or'c' + flags=['--cflags','--libs','--ldflags'] + for f in flags: + conf.check_cfg(msg='Asking python-config for pyembed %s flags'%f,path=conf.env.PYTHON_CONFIG,package='',uselib_store='PYEMBED',args=[f]) + conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',msg='Getting pyembed flags from python-config',fragment=FRAG,errmsg='Could not build a python embedded interpreter',features='%s %sprogram pyembed'%(xx,xx)) + for f in flags: + conf.check_cfg(msg='Asking python-config for pyext %s flags'%f,path=conf.env.PYTHON_CONFIG,package='',uselib_store='PYEXT',args=[f]) + conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',msg='Getting pyext flags from python-config',features='%s %sshlib pyext'%(xx,xx),fragment=FRAG,errmsg='Could not build python extensions') +@conf +def check_python_version(conf,minver=None): + assert minver is None or isinstance(minver,tuple) + pybin=conf.env['PYTHON'] + if not pybin: + conf.fatal('could not find the python executable') + cmd=pybin+['-c','import sys\nfor x in sys.version_info: print(str(x))'] + Logs.debug('python: Running python command %r'%cmd) + lines=conf.cmd_and_log(cmd).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])) + result=(minver is None)or(pyver_tuple>=minver) + if result: + 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 Utils.is_win32: + (python_LIBDEST,pydir)=conf.get_python_variables(["get_config_var('LIBDEST') or ''","get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + else: + python_LIBDEST=None + (pydir,)=conf.get_python_variables(["get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + 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,)=conf.get_python_variables(["get_python_lib(plat_specific=1, standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + if not pyarchdir: + pyarchdir=pydir + if hasattr(conf,'define'): + conf.define('PYTHONDIR',pydir) + conf.define('PYTHONARCHDIR',pyarchdir) + conf.env['PYTHONDIR']=pydir + conf.env['PYTHONARCHDIR']=pyarchdir + pyver_full='.'.join(map(str,pyver_tuple[:3])) + if minver is None: + conf.msg('Checking for python version',pyver_full) + else: + minver_str='.'.join(map(str,minver)) + conf.msg('Checking for python version',pyver_tuple,">= %s"%(minver_str,)and'GREEN'or'YELLOW') + if not result: + conf.fatal('The python version is too old, expecting %r'%(minver,)) +PYTHON_MODULE_TEMPLATE=''' +import %s as current_module +version = getattr(current_module, '__version__', None) +if version is not None: + print(str(version)) +else: + print('unknown version') +''' +@conf +def check_python_module(conf,module_name,condition=''): + msg='Python module %s'%module_name + if condition: + msg='%s (%s)'%(msg,condition) + conf.start_msg(msg) + try: + ret=conf.cmd_and_log(conf.env['PYTHON']+['-c',PYTHON_MODULE_TEMPLATE%module_name]) + except Exception: + conf.end_msg(False) + conf.fatal('Could not find the python module %r'%module_name) + ret=ret.strip() + if condition: + conf.end_msg(ret) + if ret=='unknown version': + conf.fatal('Could not check the %s version'%module_name) + from distutils.version import LooseVersion + def num(*k): + if isinstance(k[0],int): + return LooseVersion('.'.join([str(x)for x in k])) + else: + return LooseVersion(k[0]) + d={'num':num,'ver':LooseVersion(ret)} + ev=eval(condition,{},d) + if not ev: + conf.fatal('The %s version does not satisfy the requirements'%module_name) + else: + if ret=='unknown version': + conf.end_msg(True) + else: + conf.end_msg(ret) +def configure(conf): + try: + conf.find_program('python',var='PYTHON') + except conf.errors.ConfigurationError: + Logs.warn("could not find a python executable, setting to sys.executable '%s'"%sys.executable) + conf.env.PYTHON=sys.executable + if conf.env.PYTHON!=sys.executable: + Logs.warn("python executable %r differs from system %r"%(conf.env.PYTHON,sys.executable)) + conf.env.PYTHON=conf.cmd_to_list(conf.env.PYTHON) + 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 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/waflib/Tools/qt4.py b/waflib/Tools/qt4.py new file mode 100644 index 0000000..b4328e7 --- /dev/null +++ b/waflib/Tools/qt4.py @@ -0,0 +1,455 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +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 +from waflib.Tools import c_preproc,cxx +from waflib import Task,Utils,Options,Errors +from waflib.TaskGen import feature,after_method,extension +from waflib.Configure import conf +from waflib import Logs +MOC_H=['.h','.hpp','.hxx','.hh'] +EXT_RCC=['.qrc'] +EXT_UI=['.ui'] +EXT_QT4=['.cpp','.cc','.cxx','.C'] +QT4_LIBS="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtXmlPatterns QtWebKit Qt3Support QtHelp QtScript QtDeclarative QtDesigner" +class qxx(Task.classes['cxx']): + def __init__(self,*k,**kw): + Task.Task.__init__(self,*k,**kw) + self.moc_done=0 + def scan(self): + (nodes,names)=c_preproc.scan(self) + lst=[] + for x in nodes: + if x.name.endswith('.moc'): + s=x.path_from(self.inputs[0].parent.get_bld()) + if s not in names: + names.append(s) + else: + lst.append(x) + return(lst,names) + def runnable_status(self): + if self.moc_done: + return Task.Task.runnable_status(self) + else: + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + self.add_moc_tasks() + return Task.Task.runnable_status(self) + def create_moc_task(self,h_node,m_node): + try: + moc_cache=self.generator.bld.moc_cache + except AttributeError: + moc_cache=self.generator.bld.moc_cache={} + try: + return moc_cache[h_node] + except KeyError: + tsk=moc_cache[h_node]=Task.classes['moc'](env=self.env,generator=self.generator) + tsk.set_inputs(h_node) + tsk.set_outputs(m_node) + gen=self.generator.bld.producer + gen.outstanding.insert(0,tsk) + gen.total+=1 + return tsk + def add_moc_tasks(self): + node=self.inputs[0] + bld=self.generator.bld + try: + self.signature() + except KeyError: + pass + else: + delattr(self,'cache_sig') + moctasks=[] + mocfiles=[] + try: + tmp_lst=bld.raw_deps[self.uid()] + bld.raw_deps[self.uid()]=[] + except KeyError: + tmp_lst=[] + for d in tmp_lst: + if not d.endswith('.moc'): + continue + if d in mocfiles: + Logs.error("paranoia owns") + continue + mocfiles.append(d) + h_node=None + try:ext=Options.options.qt_header_ext.split() + except AttributeError:pass + if not ext:ext=MOC_H + base2=d[:-4] + for x in[node.parent]+self.generator.includes_nodes: + for e in ext: + h_node=x.find_node(base2+e) + if h_node: + break + if h_node: + m_node=h_node.change_ext('.moc') + break + else: + for k in EXT_QT4: + if base2.endswith(k): + for x in[node.parent]+self.generator.includes_nodes: + h_node=x.find_node(base2) + if h_node: + break + if h_node: + m_node=h_node.change_ext(k+'.moc') + break + if not h_node: + raise Errors.WafError('no header found for %r which is a moc file'%d) + bld.node_deps[(self.inputs[0].parent.abspath(),m_node.name)]=h_node + task=self.create_moc_task(h_node,m_node) + moctasks.append(task) + tmp_lst=bld.raw_deps[self.uid()]=mocfiles + lst=bld.node_deps.get(self.uid(),()) + for d in lst: + name=d.name + if name.endswith('.moc'): + task=self.create_moc_task(bld.node_deps[(self.inputs[0].parent.abspath(),name)],d) + moctasks.append(task) + self.run_after.update(set(moctasks)) + self.moc_done=1 + run=Task.classes['cxx'].__dict__['run'] +class trans_update(Task.Task): + run_str='${QT_LUPDATE} ${SRC} -ts ${TGT}' + color='BLUE' +Task.update_outputs(trans_update) +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(str(''.join(self.buf))) + def characters(self,cars): + self.buf.append(cars) +@extension(*EXT_RCC) +def create_rcc_task(self,node): + rcnode=node.change_ext('_rc.cpp') + rcctask=self.create_task('rcc',node,rcnode) + cpptask=self.create_task('cxx',rcnode,rcnode.change_ext('.o')) + try: + self.compiled_tasks.append(cpptask) + except AttributeError: + self.compiled_tasks=[cpptask] + return cpptask +@extension(*EXT_UI) +def create_uic_task(self,node): + uictask=self.create_task('ui4',node) + uictask.outputs=[self.path.find_or_declare(self.env['ui_PATTERN']%node.name[:-3])] +@extension('.ts') +def add_lang(self,node): + self.lang=self.to_list(getattr(self,'lang',[]))+[node] +@feature('qt4') +@after_method('apply_link') +def apply_qt4(self): + if getattr(self,'lang',None): + qmtasks=[] + for x in self.to_list(self.lang): + if isinstance(x,str): + x=self.path.find_resource(x+'.ts') + qmtasks.append(self.create_task('ts2qm',x,x.change_ext('.qm'))) + if getattr(self,'update',None)and Options.options.trans_qt4: + cxxnodes=[a.inputs[0]for a in self.compiled_tasks]+[a.inputs[0]for a in self.tasks if getattr(a,'inputs',None)and a.inputs[0].name.endswith('.ui')] + for x in qmtasks: + self.create_task('trans_update',cxxnodes,x.inputs) + if getattr(self,'langname',None): + qmnodes=[x.outputs[0]for x in qmtasks] + rcnode=self.langname + if isinstance(rcnode,str): + rcnode=self.path.find_or_declare(rcnode+'.qrc') + t=self.create_task('qm2rcc',qmnodes,rcnode) + k=create_rcc_task(self,t.outputs[0]) + self.link_task.inputs.append(k.outputs[0]) + lst=[] + for flag in self.to_list(self.env['CXXFLAGS']): + if len(flag)<2:continue + f=flag[0:2] + if f in['-D','-I','/D','/I']: + if(f[0]=='/'): + lst.append('-'+flag[1:]) + else: + lst.append(flag) + self.env.append_value('MOC_FLAGS',lst) +@extension(*EXT_QT4) +def cxx_hook(self,node): + return self.create_compiled_task('qxx',node) +class rcc(Task.Task): + color='BLUE' + run_str='${QT_RCC} -name ${SRC[0].name} ${SRC[0].abspath()} ${RCC_ST} -o ${TGT}' + ext_out=['.h'] + def scan(self): + node=self.inputs[0] + if not has_xml: + Logs.error('no xml support was found, the rcc dependencies will be incomplete!') + return([],[]) + parser=make_parser() + curHandler=XMLHandler() + parser.setContentHandler(curHandler) + fi=open(self.inputs[0].abspath(),'r') + try: + parser.parse(fi) + finally: + 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) +class moc(Task.Task): + color='BLUE' + run_str='${QT_MOC} ${MOC_FLAGS} ${MOCCPPPATH_ST:INCPATHS} ${MOCDEFINES_ST:DEFINES} ${SRC} ${MOC_ST} ${TGT}' +class ui4(Task.Task): + color='BLUE' + run_str='${QT_UIC} ${SRC} -o ${TGT}' + ext_out=['.h'] +class ts2qm(Task.Task): + color='BLUE' + run_str='${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}' +class qm2rcc(Task.Task): + color='BLUE' + after='ts2qm' + def run(self): + txt='\n'.join(['%s'%k.path_from(self.outputs[0].parent)for k in self.inputs]) + code='\n\n%s\n\n'%txt + self.outputs[0].write(code) +def configure(self): + self.find_qt4_binaries() + self.set_qt4_libs_to_check() + self.set_qt4_defines() + self.find_qt4_libraries() + self.add_qt4_rpath() + self.simplify_qt4_libs() +@conf +def find_qt4_binaries(self): + env=self.env + opt=Options.options + qtdir=getattr(opt,'qtdir','') + qtbin=getattr(opt,'qtbin','') + paths=[] + if qtdir: + qtbin=os.path.join(qtdir,'bin') + if not qtdir: + qtdir=os.environ.get('QT4_ROOT','') + qtbin=os.environ.get('QT4_BIN',None)or os.path.join(qtdir,'bin') + if qtbin: + paths=[qtbin] + if not qtdir: + paths=os.environ.get('PATH','').split(os.pathsep) + paths.append('/usr/share/qt4/bin/') + try: + lst=Utils.listdir('/usr/local/Trolltech/') + except OSError: + pass + else: + if lst: + lst.sort() + lst.reverse() + qtdir='/usr/local/Trolltech/%s/'%lst[0] + qtbin=os.path.join(qtdir,'bin') + paths.append(qtbin) + cand=None + prev_ver=['4','0','0'] + for qmk in['qmake-qt4','qmake4','qmake']: + try: + qmake=self.find_program(qmk,path_list=paths) + except self.errors.ConfigurationError: + pass + else: + try: + version=self.cmd_and_log([qmake,'-query','QT_VERSION']).strip() + except self.errors.WafError: + pass + else: + if version: + new_ver=version.split('.') + if new_ver>prev_ver: + cand=qmake + prev_ver=new_ver + if cand: + self.env.QMAKE=cand + else: + self.fatal('Could not find qmake for qt4') + qtbin=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_BINS']).strip()+os.sep + def find_bin(lst,var): + if var in env: + return + for f in lst: + try: + ret=self.find_program(f,path_list=paths) + except self.errors.ConfigurationError: + pass + else: + env[var]=ret + break + find_bin(['uic-qt3','uic3'],'QT_UIC3') + find_bin(['uic-qt4','uic'],'QT_UIC') + if not env['QT_UIC']: + self.fatal('cannot find the uic compiler for qt4') + try: + uicver=self.cmd_and_log(env['QT_UIC']+" -version 2>&1").strip() + except self.errors.ConfigurationError: + self.fatal('this uic compiler is for qt3, add uic for qt4 to your path') + uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','') + self.msg('Checking for uic version','%s'%uicver) + if uicver.find(' 3.')!=-1: + self.fatal('this uic compiler is for qt3, add uic for qt4 to your path') + find_bin(['moc-qt4','moc'],'QT_MOC') + find_bin(['rcc'],'QT_RCC') + find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE') + find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE') + env['UIC3_ST']='%s -o %s' + env['UIC_ST']='%s -o %s' + env['MOC_ST']='-o' + env['ui_PATTERN']='ui_%s.h' + env['QT_LRELEASE_FLAGS']=['-silent'] + env.MOCCPPPATH_ST='-I%s' + env.MOCDEFINES_ST='-D%s' +@conf +def find_qt4_libraries(self): + qtlibs=getattr(Options.options,'qtlibs',None)or os.environ.get("QT4_LIBDIR",None) + if not qtlibs: + try: + qtlibs=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_LIBS']).strip() + except Errors.WafError: + qtdir=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_PREFIX']).strip()+os.sep + qtlibs=os.path.join(qtdir,'lib') + self.msg('Found the Qt4 libraries in',qtlibs) + qtincludes=os.environ.get("QT4_INCLUDES",None)or self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_HEADERS']).strip() + env=self.env + if not'PKG_CONFIG_PATH'in os.environ: + os.environ['PKG_CONFIG_PATH']='%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib'%(qtlibs,qtlibs) + try: + if os.environ.get("QT4_XCOMPILE",None): + raise self.errors.ConfigurationError() + self.check_cfg(atleast_pkgconfig_version='0.1') + except self.errors.ConfigurationError: + for i in self.qt4_vars: + uselib=i.upper() + if Utils.unversioned_sys_platform()=="darwin": + frameworkName=i+".framework" + qtDynamicLib=os.path.join(qtlibs,frameworkName,i) + if os.path.exists(qtDynamicLib): + env.append_unique('FRAMEWORK_'+uselib,i) + self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('INCLUDES_'+uselib,os.path.join(qtlibs,frameworkName,'Headers')) + elif env.DEST_OS!="win32": + qtDynamicLib=os.path.join(qtlibs,"lib"+i+".so") + qtStaticLib=os.path.join(qtlibs,"lib"+i+".a") + if os.path.exists(qtDynamicLib): + env.append_unique('LIB_'+uselib,i) + self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') + elif os.path.exists(qtStaticLib): + env.append_unique('LIB_'+uselib,i) + self.msg('Checking for %s'%i,qtStaticLib,'GREEN') + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + else: + for k in("lib%s.a","lib%s4.a","%s.lib","%s4.lib"): + lib=os.path.join(qtlibs,k%i) + if os.path.exists(lib): + env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) + self.msg('Checking for %s'%i,lib,'GREEN') + break + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + uselib=i.upper()+"_debug" + for k in("lib%sd.a","lib%sd4.a","%sd.lib","%sd4.lib"): + lib=os.path.join(qtlibs,k%i) + if os.path.exists(lib): + env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) + self.msg('Checking for %s'%i,lib,'GREEN') + break + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + else: + for i in self.qt4_vars_debug+self.qt4_vars: + self.check_cfg(package=i,args='--cflags --libs',mandatory=False) +@conf +def simplify_qt4_libs(self): + env=self.env + 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(self.qt4_vars,'LIBPATH_QTCORE') + process_lib(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') +@conf +def add_qt4_rpath(self): + env=self.env + if getattr(Options.options,'want_rpath',False): + 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(self.qt4_vars,'LIBPATH_QTCORE') + process_rpath(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') +@conf +def set_qt4_libs_to_check(self): + if not hasattr(self,'qt4_vars'): + self.qt4_vars=QT4_LIBS + self.qt4_vars=Utils.to_list(self.qt4_vars) + if not hasattr(self,'qt4_vars_debug'): + self.qt4_vars_debug=[a+'_debug'for a in self.qt4_vars] + self.qt4_vars_debug=Utils.to_list(self.qt4_vars_debug) +@conf +def set_qt4_defines(self): + if sys.platform!='win32': + return + for x in self.qt4_vars: + y=x[2:].upper() + self.env.append_unique('DEFINES_%s'%x.upper(),'QT_%s_LIB'%y) + self.env.append_unique('DEFINES_%s_DEBUG'%x.upper(),'QT_%s_LIB'%y) +def options(opt): + opt.add_option('--want-rpath',action='store_true',default=False,dest='want_rpath',help='enable the rpath for qt libraries') + 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) + opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False) diff --git a/waflib/Tools/ruby.py b/waflib/Tools/ruby.py new file mode 100644 index 0000000..04cddfb --- /dev/null +++ b/waflib/Tools/ruby.py @@ -0,0 +1,103 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Options,Utils +from waflib.TaskGen import before_method,feature,after_method,Task,extension +from waflib.Configure import conf +@feature('rubyext') +@before_method('apply_incpaths','apply_lib_vars','apply_bundle','apply_link') +def init_rubyext(self): + self.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_method('apply_link','propagate_uselib') +def apply_ruby_so_name(self): + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['rubyext_PATTERN'] +@conf +def check_ruby_version(self,minver=()): + if Options.options.rubybinary: + self.env.RUBY=Options.options.rubybinary + else: + self.find_program('ruby',var='RUBY') + ruby=self.env.RUBY + try: + version=self.cmd_and_log([ruby,'-e','puts defined?(VERSION) ? VERSION : RUBY_VERSION']).strip() + except Exception: + self.fatal('could not determine ruby version') + self.env.RUBY_VERSION=version + try: + ver=tuple(map(int,version.split("."))) + except Exception: + self.fatal('unsupported ruby version %r'%version) + cver='' + if minver: + if ver=(1,9,0): + ruby_hdrdir=read_config('rubyhdrdir') + cpppath+=ruby_hdrdir + cpppath+=[os.path.join(ruby_hdrdir[0],read_config('arch')[0])] + self.check(header_name='ruby.h',includes=cpppath,errmsg='could not find ruby header file') + self.env.LIBPATH_RUBYEXT=read_config('libdir') + self.env.LIBPATH_RUBYEXT+=archdir + self.env.INCLUDES_RUBYEXT=cpppath + self.env.CFLAGS_RUBYEXT=read_config('CCDLFLAGS') + self.env.rubyext_PATTERN='%s.'+read_config('DLEXT')[0] + flags=read_config('LDSHARED') + while flags and flags[0][0]!='-': + flags=flags[1:] + if len(flags)>1 and flags[1]=="ppc": + flags=flags[2:] + self.env.LINKFLAGS_RUBYEXT=flags + self.env.LINKFLAGS_RUBYEXT+=read_config('LIBS') + self.env.LINKFLAGS_RUBYEXT+=read_config('LIBRUBYARG_SHARED') + if Options.options.rubyarchdir: + self.env.ARCHDIR_RUBY=Options.options.rubyarchdir + else: + self.env.ARCHDIR_RUBY=read_config('sitearchdir')[0] + if Options.options.rubylibdir: + self.env.LIBDIR_RUBY=Options.options.rubylibdir + else: + self.env.LIBDIR_RUBY=read_config('sitelibdir')[0] +@conf +def check_ruby_module(self,module_name): + self.start_msg('Ruby module %s'%module_name) + try: + self.cmd_and_log([self.env['RUBY'],'-e','require \'%s\';puts 1'%module_name]) + except Exception: + self.end_msg(False) + self.fatal('Could not find the ruby module %r'%module_name) + self.end_msg(True) +@extension('.rb') +def process(self,node): + tsk=self.create_task('run_ruby',node) +class run_ruby(Task.Task): + run_str='${RUBY} ${RBFLAGS} -I ${SRC[0].parent.abspath()} ${SRC}' +def 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/waflib/Tools/suncc.py b/waflib/Tools/suncc.py new file mode 100644 index 0000000..48f4943 --- /dev/null +++ b/waflib/Tools/suncc.py @@ -0,0 +1,54 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +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('cc',var='CC') + if not cc:conf.fatal('Could not find a Sun C compiler') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-flags']) + except Exception: + conf.fatal('%r is not a Sun compiler'%cc) + v['CC']=cc + v['CC_NAME']='sun' + conf.get_suncc_version(cc) +@conf +def scc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']='' + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Bdynamic' + v['STLIB_MARKER']='-Bstatic' + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-Kpic','-DPIC'] + v['LINKFLAGS_cshlib']=['-G'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=['-Bstatic'] + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_scc() + conf.find_ar() + conf.scc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() diff --git a/waflib/Tools/suncxx.py b/waflib/Tools/suncxx.py new file mode 100644 index 0000000..1736c2d --- /dev/null +++ b/waflib/Tools/suncxx.py @@ -0,0 +1,55 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +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('CC',var='CXX') + if not cc:cc=conf.find_program('c++',var='CXX') + if not cc:conf.fatal('Could not find a Sun C++ compiler') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-flags']) + except Exception: + conf.fatal('%r is not a Sun compiler'%cc) + v['CXX']=cc + v['CXX_NAME']='sun' + conf.get_suncc_version(cc) +@conf +def sxx_common_flags(conf): + v=conf.env + v['CXX_SRC_F']=[] + v['CXX_TGT_F']=['-c','-o'] + if not v['LINK_CXX']:v['LINK_CXX']=v['CXX'] + v['CXXLNK_SRC_F']=[] + v['CXXLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Bdynamic' + v['STLIB_MARKER']='-Bstatic' + v['cxxprogram_PATTERN']='%s' + v['CXXFLAGS_cxxshlib']=['-Kpic','-DPIC'] + v['LINKFLAGS_cxxshlib']=['-G'] + v['cxxshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cxxstlib']=['-Bstatic'] + v['cxxstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_sxx() + conf.find_ar() + conf.sxx_common_flags() + conf.cxx_load_tools() + conf.cxx_add_flags() + conf.link_add_flags() diff --git a/waflib/Tools/tex.py b/waflib/Tools/tex.py new file mode 100644 index 0000000..6813022 --- /dev/null +++ b/waflib/Tools/tex.py @@ -0,0 +1,257 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re +from waflib import Utils,Task,Errors,Logs +from waflib.TaskGen import feature,before_method +re_bibunit=re.compile(r'\\(?Pputbib)\[(?P[^\[\]]*)\]',re.M) +def bibunitscan(self): + node=self.inputs[0] + nodes=[] + if not node:return nodes + code=node.read() + for match in re_bibunit.finditer(code): + path=match.group('file') + if path: + for k in['','.bib']: + Logs.debug('tex: trying %s%s'%(path,k)) + fi=node.parent.find_resource(path+k) + if fi: + nodes.append(fi) + else: + Logs.debug('tex: could not find %s'%path) + Logs.debug("tex: found the following bibunit files: %s"%nodes) + return nodes +exts_deps_tex=['','.ltx','.tex','.bib','.pdf','.png','.eps','.ps'] +exts_tex=['.ltx','.tex'] +re_tex=re.compile(r'\\(?Pinclude|bibliography|putbib|includegraphics|input|import|bringin|lstinputlisting)(\[[^\[\]]*\])?{(?P[^{}]*)}',re.M) +g_bibtex_re=re.compile('bibdata',re.M) +class tex(Task.Task): + bibtex_fun,_=Task.compile_fun('${BIBTEX} ${BIBTEXFLAGS} ${SRCFILE}',shell=False) + bibtex_fun.__doc__=""" + Execute the program **bibtex** + """ + makeindex_fun,_=Task.compile_fun('${MAKEINDEX} ${MAKEINDEXFLAGS} ${SRCFILE}',shell=False) + makeindex_fun.__doc__=""" + Execute the program **makeindex** + """ + def exec_command(self,cmd,**kw): + bld=self.generator.bld + try: + if not kw.get('cwd',None): + kw['cwd']=bld.cwd + except AttributeError: + bld.cwd=kw['cwd']=bld.variant_dir + return Utils.subprocess.Popen(cmd,**kw).wait() + def scan_aux(self,node): + nodes=[node] + re_aux=re.compile(r'\\@input{(?P[^{}]*)}',re.M) + def parse_node(node): + code=node.read() + for match in re_aux.finditer(code): + path=match.group('file') + found=node.parent.find_or_declare(path) + if found and found not in nodes: + Logs.debug('tex: found aux node '+found.abspath()) + nodes.append(found) + parse_node(found) + parse_node(node) + return nodes + def scan(self): + node=self.inputs[0] + nodes=[] + names=[] + seen=[] + if not node:return(nodes,names) + def parse_node(node): + if node in seen: + return + seen.append(node) + code=node.read() + global re_tex + for match in re_tex.finditer(code): + for path in match.group('file').split(','): + if path: + add_name=True + found=None + for k in exts_deps_tex: + Logs.debug('tex: trying %s%s'%(path,k)) + found=node.parent.find_resource(path+k) + for tsk in self.generator.tasks: + if not found or found in tsk.outputs: + break + else: + nodes.append(found) + add_name=False + for ext in exts_tex: + if found.name.endswith(ext): + parse_node(found) + break + if add_name: + names.append(path) + parse_node(node) + for x in nodes: + x.parent.get_bld().mkdir() + Logs.debug("tex: found the following : %s and names %s"%(nodes,names)) + return(nodes,names) + def check_status(self,msg,retcode): + if retcode!=0: + raise Errors.WafError("%r command exit status %r"%(msg,retcode)) + def bibfile(self): + for aux_node in self.aux_nodes: + try: + ct=aux_node.read() + except(OSError,IOError): + Logs.error('Error reading %s: %r'%aux_node.abspath()) + continue + if g_bibtex_re.findall(ct): + Logs.warn('calling bibtex') + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=aux_node.name[:-4] + self.check_status('error when calling bibtex',self.bibtex_fun()) + def bibunits(self): + try: + bibunits=bibunitscan(self) + except OSError: + Logs.error('error bibunitscan') + else: + if bibunits: + fn=['bu'+str(i)for i in xrange(1,len(bibunits)+1)] + if fn: + Logs.warn('calling bibtex on bibunits') + for f in fn: + self.env.env={'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS} + self.env.SRCFILE=f + self.check_status('error when calling bibtex',self.bibtex_fun()) + def makeindex(self): + try: + idx_path=self.idx_node.abspath() + os.stat(idx_path) + except OSError: + Logs.warn('index file %s absent, not calling makeindex'%idx_path) + else: + Logs.warn('calling makeindex') + self.env.SRCFILE=self.idx_node.name + self.env.env={} + self.check_status('error when calling makeindex %s'%idx_path,self.makeindex_fun()) + def bibtopic(self): + p=self.inputs[0].parent.get_bld() + if os.path.exists(os.path.join(p.abspath(),'btaux.aux')): + self.aux_nodes+=p.ant_glob('*[0-9].aux') + def run(self): + env=self.env + if not env['PROMPT_LATEX']: + env.append_value('LATEXFLAGS','-interaction=batchmode') + env.append_value('PDFLATEXFLAGS','-interaction=batchmode') + env.append_value('XELATEXFLAGS','-interaction=batchmode') + fun=self.texfun + node=self.inputs[0] + srcfile=node.abspath() + texinputs=self.env.TEXINPUTS or'' + self.TEXINPUTS=node.parent.get_bld().abspath()+os.pathsep+node.parent.get_src().abspath()+os.pathsep+texinputs+os.pathsep + self.cwd=self.inputs[0].parent.get_bld().abspath() + Logs.warn('first pass on %s'%self.__class__.__name__) + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'TEXINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=srcfile + self.check_status('error when calling latex',fun()) + self.aux_nodes=self.scan_aux(node.change_ext('.aux')) + self.idx_node=node.change_ext('.idx') + self.bibtopic() + self.bibfile() + self.bibunits() + self.makeindex() + hash='' + for i in range(10): + prev_hash=hash + try: + hashes=[Utils.h_file(x.abspath())for x in self.aux_nodes] + hash=Utils.h_list(hashes) + except(OSError,IOError): + Logs.error('could not read aux.h') + pass + if hash and hash==prev_hash: + break + Logs.warn('calling %s'%self.__class__.__name__) + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'TEXINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=srcfile + self.check_status('error when calling %s'%self.__class__.__name__,fun()) +class latex(tex): + texfun,vars=Task.compile_fun('${LATEX} ${LATEXFLAGS} ${SRCFILE}',shell=False) +class pdflatex(tex): + texfun,vars=Task.compile_fun('${PDFLATEX} ${PDFLATEXFLAGS} ${SRCFILE}',shell=False) +class xelatex(tex): + texfun,vars=Task.compile_fun('${XELATEX} ${XELATEXFLAGS} ${SRCFILE}',shell=False) +class dvips(Task.Task): + run_str='${DVIPS} ${DVIPSFLAGS} ${SRC} -o ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +class dvipdf(Task.Task): + run_str='${DVIPDF} ${DVIPDFFLAGS} ${SRC} ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +class pdf2ps(Task.Task): + run_str='${PDF2PS} ${PDF2PSFLAGS} ${SRC} ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +@feature('tex') +@before_method('process_source') +def apply_tex(self): + if not getattr(self,'type',None)in['latex','pdflatex','xelatex']: + self.type='pdflatex' + tree=self.bld + outs=Utils.to_list(getattr(self,'outs',[])) + 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: + self.bld.fatal('Could not find %r for %r'%(filename,self)) + if not n in deps_lst: + deps_lst.append(n) + for node in self.to_nodes(self.source): + 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')) + elif self.type=='xelatex': + task=self.create_task('xelatex',node,node.change_ext('.pdf')) + task.env=self.env + if deps_lst: + try: + lst=tree.node_deps[task.uid()] + for n in deps_lst: + if not n in lst: + lst.append(n) + except KeyError: + tree.node_deps[task.uid()]=deps_lst + v=dict(os.environ) + p=node.parent.abspath()+os.pathsep+self.path.abspath()+os.pathsep+self.path.get_bld().abspath()+os.pathsep+v.get('TEXINPUTS','')+os.pathsep + v['TEXINPUTS']=p + if self.type=='latex': + if'ps'in outs: + tsk=self.create_task('dvips',task.outputs,node.change_ext('.ps')) + tsk.env.env=dict(v) + if'pdf'in outs: + tsk=self.create_task('dvipdf',task.outputs,node.change_ext('.pdf')) + tsk.env.env=dict(v) + elif self.type=='pdflatex': + if'ps'in outs: + self.create_task('pdf2ps',task.outputs,node.change_ext('.ps')) + self.source=[] +def configure(self): + v=self.env + for p in'tex latex pdflatex xelatex bibtex dvips dvipdf ps2pdf makeindex pdf2ps'.split(): + try: + self.find_program(p,var=p.upper()) + except self.errors.ConfigurationError: + pass + v['DVIPSFLAGS']='-Ppdf' diff --git a/waflib/Tools/vala.py b/waflib/Tools/vala.py new file mode 100644 index 0000000..96248c1 --- /dev/null +++ b/waflib/Tools/vala.py @@ -0,0 +1,201 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os.path,shutil,re +from waflib import Context,Task,Utils,Logs,Options,Errors +from waflib.TaskGen import extension,taskgen_method +from waflib.Configure import conf +class valac(Task.Task): + vars=["VALAC","VALAC_VERSION","VALAFLAGS"] + ext_out=['.h'] + def run(self): + cmd=[self.env['VALAC']]+self.env['VALAFLAGS'] + cmd.extend([a.abspath()for a in self.inputs]) + ret=self.exec_command(cmd,cwd=self.outputs[0].parent.abspath()) + if ret: + return ret + for x in self.outputs: + if id(x.parent)!=id(self.outputs[0].parent): + shutil.move(self.outputs[0].parent.abspath()+os.sep+x.name,x.abspath()) + if self.generator.dump_deps_node: + self.generator.dump_deps_node.write('\n'.join(self.generator.packages)) + return ret +valac=Task.update_outputs(valac) +@taskgen_method +def init_vala_task(self): + self.profile=getattr(self,'profile','gobject') + if self.profile=='gobject': + self.uselib=Utils.to_list(getattr(self,'uselib',[])) + if not'GOBJECT'in self.uselib: + self.uselib.append('GOBJECT') + def addflags(flags): + self.env.append_value('VALAFLAGS',flags) + if self.profile: + addflags('--profile=%s'%self.profile) + if hasattr(self,'threading'): + if self.profile=='gobject': + if not'GTHREAD'in self.uselib: + self.uselib.append('GTHREAD') + else: + Logs.warn("Profile %s means no threading support"%self.profile) + self.threading=False + if self.threading: + addflags('--threading') + valatask=self.valatask + self.is_lib='cprogram'not in self.features + if self.is_lib: + addflags('--library=%s'%self.target) + h_node=self.path.find_or_declare('%s.h'%self.target) + valatask.outputs.append(h_node) + addflags('--header=%s'%h_node.name) + valatask.outputs.append(self.path.find_or_declare('%s.vapi'%self.target)) + if getattr(self,'gir',None): + gir_node=self.path.find_or_declare('%s.gir'%self.gir) + addflags('--gir=%s'%gir_node.name) + valatask.outputs.append(gir_node) + self.vala_target_glib=getattr(self,'vala_target_glib',getattr(Options.options,'vala_target_glib',None)) + if self.vala_target_glib: + addflags('--target-glib=%s'%self.vala_target_glib) + addflags(['--define=%s'%x for x in getattr(self,'vala_defines',[])]) + packages_private=Utils.to_list(getattr(self,'packages_private',[])) + addflags(['--pkg=%s'%x for x in packages_private]) + def _get_api_version(): + api_version='1.0' + if hasattr(Context.g_module,'API_VERSION'): + version=Context.g_module.API_VERSION.split(".") + if version[0]=="0": + api_version="0."+version[1] + else: + api_version=version[0]+".0" + return api_version + self.includes=Utils.to_list(getattr(self,'includes',[])) + self.uselib=self.to_list(getattr(self,'uselib',[])) + valatask.install_path=getattr(self,'install_path','') + valatask.vapi_path=getattr(self,'vapi_path','${DATAROOTDIR}/vala/vapi') + valatask.pkg_name=getattr(self,'pkg_name',self.env['PACKAGE']) + valatask.header_path=getattr(self,'header_path','${INCLUDEDIR}/%s-%s'%(valatask.pkg_name,_get_api_version())) + valatask.install_binding=getattr(self,'install_binding',True) + self.packages=packages=Utils.to_list(getattr(self,'packages',[])) + self.vapi_dirs=vapi_dirs=Utils.to_list(getattr(self,'vapi_dirs',[])) + includes=[] + if hasattr(self,'use'): + local_packages=Utils.to_list(self.use)[:] + seen=[] + while len(local_packages)>0: + package=local_packages.pop() + if package in seen: + continue + seen.append(package) + try: + package_obj=self.bld.get_tgen_by_name(package) + except Errors.WafError: + continue + package_name=package_obj.target + package_node=package_obj.path + package_dir=package_node.path_from(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,'use'): + lst=self.to_list(package_obj.use) + lst.reverse() + local_packages=[pkg for pkg in lst if pkg not in seen]+local_packages + addflags(['--pkg=%s'%p for p in packages]) + for vapi_dir in vapi_dirs: + v_node=self.path.find_dir(vapi_dir) + if not v_node: + Logs.warn('Unable to locate Vala API directory: %r'%vapi_dir) + else: + addflags('--vapidir=%s'%v_node.abspath()) + addflags('--vapidir=%s'%v_node.get_bld().abspath()) + self.dump_deps_node=None + if self.is_lib and self.packages: + self.dump_deps_node=self.path.find_or_declare('%s.deps'%self.target) + valatask.outputs.append(self.dump_deps_node) + self.includes.append(self.bld.srcnode.abspath()) + self.includes.append(self.bld.bldnode.abspath()) + for include in includes: + try: + self.includes.append(self.path.find_dir(include).abspath()) + self.includes.append(self.path.find_dir(include).get_bld().abspath()) + except AttributeError: + Logs.warn("Unable to locate include directory: '%s'"%include) + if self.is_lib and valatask.install_binding: + headers_list=[o for o in valatask.outputs if o.suffix()==".h"] + try: + self.install_vheader.source=headers_list + except AttributeError: + self.install_vheader=self.bld.install_files(valatask.header_path,headers_list,self.env) + vapi_list=[o for o in valatask.outputs if(o.suffix()in(".vapi",".deps"))] + try: + self.install_vapi.source=vapi_list + except AttributeError: + self.install_vapi=self.bld.install_files(valatask.vapi_path,vapi_list,self.env) + gir_list=[o for o in valatask.outputs if o.suffix()=='.gir'] + try: + self.install_gir.source=gir_list + except AttributeError: + self.install_gir=self.bld.install_files(getattr(self,'gir_path','${DATAROOTDIR}/gir-1.0'),gir_list,self.env) +@extension('.vala','.gs') +def vala_file(self,node): + try: + valatask=self.valatask + except AttributeError: + valatask=self.valatask=self.create_task('valac') + self.init_vala_task() + valatask.inputs.append(node) + c_node=node.change_ext('.c') + valatask.outputs.append(c_node) + self.source.append(c_node) +@conf +def find_valac(self,valac_name,min_version): + valac=self.find_program(valac_name,var='VALAC') + try: + output=self.cmd_and_log(valac+' --version') + except Exception: + valac_version=None + else: + ver=re.search(r'\d+.\d+.\d+',output).group(0).split('.') + valac_version=tuple([int(x)for x in ver]) + self.msg('Checking for %s version >= %r'%(valac_name,min_version),valac_version,valac_version and valac_version>=min_version) + if valac and valac_version= %r"%(valac_name,valac_version,min_version)) + self.env['VALAC_VERSION']=valac_version + return valac +@conf +def check_vala(self,min_version=(0,8,0),branch=None): + if not branch: + branch=min_version[:2] + try: + find_valac(self,'valac-%d.%d'%(branch[0],branch[1]),min_version) + except self.errors.ConfigurationError: + find_valac(self,'valac',min_version) +@conf +def check_vala_deps(self): + if not self.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 + self.check_cfg(**pkg_args) + if not self.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 + self.check_cfg(**pkg_args) +def configure(self): + self.load('gnu_dirs') + self.check_vala_deps() + self.check_vala() + self.env.VALAFLAGS=['-C','--quiet'] +def options(opt): + opt.load('gnu_dirs') + 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/waflib/Tools/waf_unit_test.py b/waflib/Tools/waf_unit_test.py new file mode 100644 index 0000000..3363172 --- /dev/null +++ b/waflib/Tools/waf_unit_test.py @@ -0,0 +1,97 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib.TaskGen import feature,after_method +from waflib import Utils,Task,Logs,Options +testlock=Utils.threading.Lock() +@feature('test') +@after_method('apply_link') +def make_test(self): + if getattr(self,'link_task',None): + self.create_task('utest',self.link_task.outputs) +class utest(Task.Task): + color='PINK' + after=['vnum','inst'] + vars=[] + def runnable_status(self): + if getattr(Options.options,'no_tests',False): + return Task.SKIP_ME + ret=super(utest,self).runnable_status() + if ret==Task.SKIP_ME: + if getattr(Options.options,'all_tests',False): + return Task.RUN_ME + return ret + def run(self): + filename=self.inputs[0].abspath() + self.ut_exec=getattr(self.generator,'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() + lst=[] + for g in self.generator.bld.groups: + for tg in g: + if getattr(tg,'link_task',None): + s=tg.link_task.outputs[0].parent.abspath() + if s not in lst: + lst.append(s) + def add_path(dct,path,var): + dct[var]=os.pathsep.join(Utils.to_list(path)+[os.environ.get(var,'')]) + if Utils.is_win32: + add_path(fu,lst,'PATH') + elif Utils.unversioned_sys_platform()=='darwin': + add_path(fu,lst,'DYLD_LIBRARY_PATH') + add_path(fu,lst,'LD_LIBRARY_PATH') + else: + add_path(fu,lst,'LD_LIBRARY_PATH') + self.generator.bld.all_test_paths=fu + cwd=getattr(self.generator,'ut_cwd','')or self.inputs[0].parent.abspath() + testcmd=getattr(Options.options,'testcmd',False) + if testcmd: + self.ut_exec=(testcmd%self.ut_exec[0]).split(' ') + proc=Utils.subprocess.Popen(self.ut_exec,cwd=cwd,env=fu,stderr=Utils.subprocess.PIPE,stdout=Utils.subprocess.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() +def summary(bld): + lst=getattr(bld,'utest_results',[]) + if lst: + Logs.pprint('CYAN','execution summary') + total=len(lst) + tfail=len([x for x in lst if x[1]]) + Logs.pprint('CYAN',' tests that pass %d/%d'%(total-tfail,total)) + for(f,code,out,err)in lst: + if not code: + Logs.pprint('CYAN',' %s'%f) + Logs.pprint('CYAN',' tests that fail %d/%d'%(tfail,total)) + for(f,code,out,err)in lst: + if code: + Logs.pprint('CYAN',' %s'%f) +def set_exit_code(bld): + lst=getattr(bld,'utest_results',[]) + for(f,code,out,err)in lst: + if code: + msg=[] + if out: + msg.append('stdout:%s%s'%(os.linesep,out.decode('utf-8'))) + if err: + msg.append('stderr:%s%s'%(os.linesep,err.decode('utf-8'))) + bld.fatal(os.linesep.join(msg)) +def options(opt): + opt.add_option('--notests',action='store_true',default=False,help='Exec no unit tests',dest='no_tests') + opt.add_option('--alltests',action='store_true',default=False,help='Exec all unit tests',dest='all_tests') + opt.add_option('--testcmd',action='store',default=False,help='Run the unit tests using the test-cmd string'' example "--test-cmd="valgrind --error-exitcode=1'' %s" to run under valgrind',dest='testcmd') diff --git a/waflib/Tools/waf_unit_test.pyc b/waflib/Tools/waf_unit_test.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de605b3be3d2d3ccae47b8d307dd29bf5270c367 GIT binary patch literal 5500 zcmc&&&2k&Z5$*v%kRU-)A}LCgB^ja36dV`GlBh&KWvL=dvZGjGSW79CP_{RV-2nt} zu?z0ZN>mECSk5g~smd|uoL%LL4|#+mxsdNcG2OIAr2DJsz`MY=@M1XrRmeN9}!)tsehlJq3? zCaH~~DH$Sq+MJ`P!j0xUMblC_MbV5@PVQ!vM`)~Yh)eETFNfd1z*gVsg$AY%i zncvs;SsK+#EHQ!NvF*mja`RDO_N4MK?HHN;>w)d2i5s=rSUb(j35kX8y&anXpj_U54DZQMrUSY(AE8o zL6-J(Xw62Dx4P+Jx&9((H!iPVTfe;7*wk7Ft<5W~>(^SFo8gU?{@In*RUKXpgP-af zo0m5r8+Th9kJ21xoIt7MZ2mJs}Q4Bx9Q2H7@W%72Ms(9(`2V0-X!Jj92Un*S~QLM$!U=gtv zKN;4tO3b6k7R6u}SZlor+OcI;J*)?F^`;oVBSk~V$?#r*GXKQDSio&~Kcvp6N!;_er3RjW#CMi=2mEI}tK|oadO6`A3xOVsdLc1T zrrrW&>uLyuLIXJIBx^t=_hoF6)r9cLC=E{tRYd4`(zKg|#~rQXx_D7&9b1_se~A)B zPmc9ELs69{4!%(*OmlRcDL%P9L%n5+X33sq(NTql70UjpQ1To&F;uYJJ4ewRAJmx+ zF2g5Vq2Bqi)I1HRD8dF22u_bj-=S#Xxc*9&M$kv%M;pKlHbJGjja6o_6x5Rwa=8XCoUu`})j%m63}o!CCMb=IjET_4FtI1p|@ z5=nt$3hYIcx~wM;)dK`EER=Q=kH;kP*c5pWX^>~=5rtN!@-ou# zJjmW&tbrRtpHU>L{0ZuYPeV$!xP9l*FGTlIkiF<8KpxS(rw{M>4A%)0hbfjQmWSJhoz9<`r=o?m3l(`*}Ch9-mbn5b0Llv3$al6Pl=^R9B&CU>!6Y(DU=fJHVRUU>K$aIVAG zKw=v6su(S*CCpkXxG2Kf^L^Hx?~Cbtzn?}q2#GJY2-7&tq$Xrs^o8(Xgb{d;F#A|V zQhU>6Rj3q)V8e8*j3ZZZSEfRCYG$hp?Yp?mDfA$IB9$PIfe~lQ>>vLNa`b&LMiY3$)Bj9$a&4 zY|!V(Y7;an6Ij7$ifM!S>cnKEfeANd|0}|^d%P|(K61v1HE;g^HM7@0yyk1#e+|NP z_%6ft-|~KmQcQdI>76aZL6wtS&hJt+llS{U_Oi?RG-pxNYV5wIW}gMNHVBNVtwkGa zkwnHC{?^R*#o9qPc4G1#=cuzdyu`3UhFI>rRws3~ns}eLg_?lRrZ$MhgAZJr7nF8e z_AQ}?Jq96K)NRrP_o1fMO#XV1&8K$SBz>q4OV zS5&?a)q_7fYyU|Q1j+;e3zUGvY(+>euu}qkWK4l(fM_H5ff1sU=^L=E93CB=2F|iS zj%9^~vn-g%56KEgamz7N5w45n)cy+L+Krejv9CEa8BTP_p0LNwH3LZSP;T3e>*Env zNJb@W zA{IE08O^j2Z`gba4w{BvrWg^71OET9+=2vlG>&D01cM5bUkO^UCv1q|1LX5NN||3F z@X7!-J!bV4Hu`@FO^Xmd<{S%EMF<~mj#k3!4OW^LA+h8sJa@~mCpH>MDh}^BM#w=y zGKB%D!6$+&*J7?nw*$`a?A6b7Jdh*aM;NIkX^lTGxUeDP5dw&}2tf(jjRxqmJi>6F z%t6nIN!}96y4|oKlQzbJY{9%h&C3%6Bzv@HXGxnb>{F>S9+SwTAyX1JL;z?+=Vnh^YH6w9X&aKGliG;vVBsZ0`nzU&^-) zVQfMjh3VR7__h^6zhdHtpm*Mc_preproc.recursion_limit: + raise c_preproc.PreprocError("recursion limit exceeded") + pc=self.parse_cache + Logs.debug('preproc: reading file %r',filepath) + try: + lns=pc[filepath] + except KeyError: + pass + else: + self.lines.extend(lns) + return + try: + lines=self.filter_comments(filepath) + lines.append((c_preproc.POPFILE,'')) + lines.reverse() + pc[filepath]=lines + self.lines.extend(lines) + except IOError: + raise c_preproc.PreprocError("could not read the file %s"%filepath) + except Exception: + if Logs.verbose>0: + Logs.error("parsing %s failed"%filepath) + traceback.print_exc() +class winrc(Task.Task): + run_str='${WINRC} ${WINRCFLAGS} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${WINRC_TGT_F} ${TGT} ${WINRC_SRC_F} ${SRC}' + color='BLUE' + def scan(self): + tmp=rc_parser(self.generator.includes_nodes) + tmp.start(self.inputs[0],self.env) + nodes=tmp.nodes + names=tmp.names + if Logs.verbose: + Logs.debug('deps: deps for %s: %r; unresolved %r'%(str(self),nodes,names)) + return(nodes,names) +def configure(conf): + v=conf.env + v['WINRC_TGT_F']='-o' + v['WINRC_SRC_F']='-i' + if not conf.env.WINRC: + if v.CC_NAME=='msvc': + conf.find_program('RC',var='WINRC',path_list=v['PATH']) + v['WINRC_TGT_F']='/fo' + v['WINRC_SRC_F']='' + else: + conf.find_program('windres',var='WINRC',path_list=v['PATH']) + if not conf.env.WINRC: + conf.fatal('winrc was not found!') + v['WINRCFLAGS']=[] diff --git a/waflib/Tools/xlc.py b/waflib/Tools/xlc.py new file mode 100644 index 0000000..fbf0fcf --- /dev/null +++ b/waflib/Tools/xlc.py @@ -0,0 +1,45 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +def find_xlc(conf): + cc=conf.find_program(['xlc_r','xlc'],var='CC') + cc=conf.cmd_to_list(cc) + conf.get_xlc_version(cc) + conf.env.CC_NAME='xlc' + conf.env.CC=cc +@conf +def xlc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']=[] + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['LINKFLAGS_cprogram']=['-Wl,-brtl'] + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-fPIC'] + v['LINKFLAGS_cshlib']=['-G','-Wl,-brtl,-bexpfull'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=[] + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_xlc() + conf.find_ar() + conf.xlc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() diff --git a/waflib/Tools/xlcxx.py b/waflib/Tools/xlcxx.py new file mode 100644 index 0000000..b7efb23 --- /dev/null +++ b/waflib/Tools/xlcxx.py @@ -0,0 +1,45 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +@conf +def find_xlcxx(conf): + cxx=conf.find_program(['xlc++_r','xlc++'],var='CXX') + cxx=conf.cmd_to_list(cxx) + conf.get_xlc_version(cxx) + conf.env.CXX_NAME='xlc++' + conf.env.CXX=cxx +@conf +def xlcxx_common_flags(conf): + v=conf.env + v['CXX_SRC_F']=[] + v['CXX_TGT_F']=['-c','-o'] + if not v['LINK_CXX']:v['LINK_CXX']=v['CXX'] + v['CXXLNK_SRC_F']=[] + v['CXXLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['LINKFLAGS_cxxprogram']=['-Wl,-brtl'] + v['cxxprogram_PATTERN']='%s' + v['CXXFLAGS_cxxshlib']=['-fPIC'] + v['LINKFLAGS_cxxshlib']=['-G','-Wl,-brtl,-bexpfull'] + v['cxxshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cxxstlib']=[] + v['cxxstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_xlcxx() + conf.find_ar() + conf.xlcxx_common_flags() + conf.cxx_load_tools() + conf.cxx_add_flags() + conf.link_add_flags() diff --git a/waflib/Utils.py b/waflib/Utils.py new file mode 100644 index 0000000..9532a3b --- /dev/null +++ b/waflib/Utils.py @@ -0,0 +1,412 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,errno,traceback,inspect,re,shutil,datetime,gc +import subprocess +try: + from collections import deque +except ImportError: + class deque(list): + def popleft(self): + return self.pop(0) +try: + import _winreg as winreg +except ImportError: + try: + import winreg + except ImportError: + winreg=None +from waflib import Errors +try: + from collections import UserDict +except ImportError: + from UserDict import UserDict +try: + from hashlib import md5 +except ImportError: + try: + from md5 import md5 + except ImportError: + pass +try: + import threading +except ImportError: + class threading(object): + pass + class Lock(object): + def acquire(self): + pass + def release(self): + pass + threading.Lock=threading.Thread=Lock +else: + run_old=threading.Thread.run + def run(*args,**kwargs): + try: + run_old(*args,**kwargs) + except(KeyboardInterrupt,SystemExit): + raise + except Exception: + sys.excepthook(*sys.exc_info()) + threading.Thread.run=run +SIG_NIL='iluvcuteoverload' +O644=420 +O755=493 +rot_chr=['\\','|','/','-'] +rot_idx=0 +try: + from collections import defaultdict +except ImportError: + class defaultdict(dict): + def __init__(self,default_factory): + super(defaultdict,self).__init__() + self.default_factory=default_factory + def __getitem__(self,key): + try: + return super(defaultdict,self).__getitem__(key) + except KeyError: + value=self.default_factory() + self[key]=value + return value +is_win32=sys.platform in('win32','cli') +indicator='\x1b[K%s%s%s\r' +if is_win32 and'NOCOLOR'in os.environ: + indicator='%s%s%s\r' +def readf(fname,m='r',encoding='ISO8859-1'): + if sys.hexversion>0x3000000 and not'b'in m: + m+='b' + f=open(fname,m) + try: + txt=f.read() + finally: + f.close() + txt=txt.decode(encoding) + else: + f=open(fname,m) + try: + txt=f.read() + finally: + f.close() + return txt +def writef(fname,data,m='w',encoding='ISO8859-1'): + if sys.hexversion>0x3000000 and not'b'in m: + data=data.encode(encoding) + m+='b' + f=open(fname,m) + try: + f.write(data) + finally: + f.close() +def h_file(fname): + f=open(fname,'rb') + m=md5() + try: + while fname: + fname=f.read(200000) + m.update(fname) + finally: + f.close() + return m.digest() +if hasattr(os,'O_NOINHERIT'): + def readf_win32(f,m='r',encoding='ISO8859-1'): + flags=os.O_NOINHERIT|os.O_RDONLY + if'b'in m: + flags|=os.O_BINARY + if'+'in m: + flags|=os.O_RDWR + try: + fd=os.open(f,flags) + except OSError: + raise IOError('Cannot read from %r'%f) + if sys.hexversion>0x3000000 and not'b'in m: + m+='b' + f=os.fdopen(fd,m) + try: + txt=f.read() + finally: + f.close() + txt=txt.decode(encoding) + else: + f=os.fdopen(fd,m) + try: + txt=f.read() + finally: + f.close() + return txt + def writef_win32(f,data,m='w',encoding='ISO8859-1'): + if sys.hexversion>0x3000000 and not'b'in m: + data=data.encode(encoding) + m+='b' + flags=os.O_CREAT|os.O_TRUNC|os.O_WRONLY|os.O_NOINHERIT + if'b'in m: + flags|=os.O_BINARY + if'+'in m: + flags|=os.O_RDWR + try: + fd=os.open(f,flags) + except OSError: + raise IOError('Cannot write to %r'%f) + f=os.fdopen(fd,m) + try: + f.write(data) + finally: + f.close() + def h_file_win32(fname): + try: + fd=os.open(fname,os.O_BINARY|os.O_RDONLY|os.O_NOINHERIT) + except OSError: + raise IOError('Cannot read from %r'%fname) + f=os.fdopen(fd,'rb') + m=md5() + try: + while fname: + fname=f.read(200000) + m.update(fname) + finally: + f.close() + return m.digest() + readf_old=readf + writef_old=writef + h_file_old=h_file + readf=readf_win32 + writef=writef_win32 + h_file=h_file_win32 +try: + x=''.encode('hex') +except LookupError: + import binascii + def to_hex(s): + ret=binascii.hexlify(s) + if not isinstance(ret,str): + ret=ret.decode('utf-8') + return ret +else: + def to_hex(s): + return s.encode('hex') +to_hex.__doc__=""" +Return the hexadecimal representation of a string + +:param s: string to convert +:type s: string +""" +listdir=os.listdir +if is_win32: + def listdir_win32(s): + if not s: + try: + import ctypes + except ImportError: + return[x+':\\'for x in list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')] + else: + dlen=4 + maxdrives=26 + buf=ctypes.create_string_buffer(maxdrives*dlen) + ndrives=ctypes.windll.kernel32.GetLogicalDriveStringsA(maxdrives*dlen,ctypes.byref(buf)) + return[str(buf.raw[4*i:4*i+2].decode('ascii'))for i in range(int(ndrives/dlen))] + if len(s)==2 and s[1]==":": + s+=os.sep + if not os.path.isdir(s): + e=OSError('%s is not a directory'%s) + e.errno=errno.ENOENT + raise e + return os.listdir(s) + listdir=listdir_win32 +def num2ver(ver): + if isinstance(ver,str): + ver=tuple(ver.split('.')) + if isinstance(ver,tuple): + ret=0 + for i in range(4): + if ib4=Bk zd^_)$ypzoJ+UtB8Y0zt`+e~f9XBHzS zKZ04l(0;1 zd+uiEn<)-=#Q1wP+@0-#?GZbD$1FW!yvt@8_}OPXjA*~{_nF{}Der#c8?*E%n^=5+ zO?40-Bf@YVHg5u=2aK0hagU0l#@nme95nu8yxn`m+)kO`Y&yPcpSm4N?%J>7=hEKe>TuHdCt1lU zkE!OA@y3-oZM+F(&KSSfES)tT#)-^RoNWGS;~iG(yNq{4nRCWFs?7PM|1k~wg7J>4 ze$vE@c+xC`T#xqn=S}{csSj#M$9w!q6)_SF@*KzPoz#sNjdx0!OU65`%rnM2qs+6$ zJFCod$xAUj&}zzfPpkfUsW%oXFESLOxdT}ZGz$r@>ZX^rM@di*}KG-L8F z8tid3i{^*hUlPBhn9xa`k_n$m6f6Ol(D;1CXr;Z+;K;LR*e&SkGsfOdt^=Jd$fDu&v za4X;&2(Pf9uK$W}qqZLm$5Dl}>v2>$_yc7hD zAhcx;n>4#vDMcMJ*SzCV1})KI;1|70eW8Sc{63i&wC0GF(pw$o$QW%tf( z@BKst!(wTrRSEn@@$MLg|KCR(_*K6c!t%67JW7&w5aUv&+|5Wj)Ku=?lhmc0?8hZ8 z_c@uAKqDZbc7`q2kgRVrk<`>p$9x2$KU;sw^hAz{Ql^}ejvb>9_C90k`_Pb9)r+hG z8kc$v(?06uw{UappCy2zauI8TR=v=udJ(nfWq*CXQ4GAPdgKQ|s~JhPON=K_Ai??np`0lY}qN#2x20tn!hFjjCzmQpgazyrz! zEg}+z65TS9VXNr}8boX*D)mYPD=~-;@h}VJVkv3_>sE>KjqXE8y2%swLA>y3T#^9; zW|WedQ=e=0Q^>6Eemem$c^d55`e+;T7m0bA^B$7tR?6JO9~kDCv&iMRE=kD5hr16j zA)91a3xx$gssQ33(neH53S_e^O~?x=U7={%Ul);IFIHPpE|zHb9>ea#7{_^BZ2<2E zcsD!!&fE1G39H^6b}H9}F_NTDaf}2b^jcc9TCLQN9uf6Q)k;WZasR8A_lNv%Kq_c@ zW^(4rj2luXCG`}zAf%C<%FUcSdHmGa;SyOv{?25JKe_xrj%Cnrtb zWLoNCew3QerH+-hT=dtVX+kPdlB&`4ZHE4jXjZB=LSO3A^GglSALX3YQl`_Vht{m7 zt)m@2ld8%hbF>z9cz^HNu3>THWqR!4eMpRRKae>HHM=#n$r(x|ISq2P#5v!^NNUr& z7Q!gJAqaQ+p$IMsG4WwfdlbY^ECXXQzom)*1&=S_7y|Unk zk;F$d7C}Ydu2XffP_9&cA0rLvA{fv!1Bzzwy91z>>6j@@&rD4}cgdZ)D(ysW5FeuR zgP^m%yhE388fgmuNzKsLtt z-Yd5cVM4KJ1U!15qmU4k#8Sq1J<^ZgOa=h4`X)z$@kl>n9Q_m=N)4WEq#{wdNx0~> zDiY<*EJH;iIx--k12lR~{Rxfk`+P!9qBJcTlwvp(4wH7pdc6^4sZg@zpi#^252zl} zqr|pA)d=0Q%o9p81^432^p#iQ!iA~n^X@Bx5?f|nE5fuaGdWpxS)8dEYvHMoJ3?Rf zsE7qliMsnZnyq%ATzACWD&lGp9xXv$_T0nliK|=gfY2wMTabBe;?*Ig$~ar$71%57 zj6e-+mo6S^>*6FQElj}j5@7!u84K9hoPJ+g7RasH}%ZF({W=&Vb$3cv0--b0^GAayS=M@G08nH*;#i$exkMffCh<4k02 zE;08ElCDCJD=2GnEcQNxvQ{dI;d$sC2qflWQG;Ku;}u&4co_v393Y>QES)|h{>>3W5b3% zQhrc&XqVp0$0l$MB-iU^#n^#dk3|%j9j0rW&(K=M-~fxqBLkb?oVB zh{yj&rjXpWrqFWxlPJeNUfMYz{W5g7VMGUtEp9^;fZhjnB+Fts1%;dy@5lh_og)Q5 zQYL(Y`~%;?T-ypAftol#8`8SAqVm{D>k*T7^ObrrELAF!HoUW1DX+`Ru7s6(7!~U! zU&9Hbz-n}kM+PTUec*T3U8XokjRHpcdE`P)fzHLCGvtU|3CTn*B8hqnic$oL>EKSI zUa>)G9-GUt4p+B~kjo&|Z{mt$g5kT7?|1#E71XoQqMyYSi&(!@YQ-w-c{A`staFNt z9c3HkY%vRtVCB-^f4W%=inVNbI4+Xg(RTKM=M(t_3!lP#t6TIsz)Gm?H+(GLR5lLNanJ#%T=`U9K= zdW{mpE=AUT1&Ii>W|x$Bha#=D;+n_dS~Z1fO2gITI+C@b+qxQv0vs(TFb8W9eh(Gl zUL*zqRjl}76ZWS1kRNvTJ2TE+)C|cZ%~<_L%8@3MxWbPjfjI!AF%{_l0N#M2Ef77c z@rYOpYuinxJ$Q>wC1iYUitBJ|%P-zI6N@ycZ)Ii~T%DrWLe3!7u>AK8gCS@{b{8JK zoy(tL#mkbxT=W?6hh}FoLh)wITgl+MWAwkyk^o<~>e{wZt?pap(jx z)?nX8Bs@)KfMf{1fKN6c0J_o5Mw563;|;Y3+9tN@1w6rqO|;(PBG2yk1;vs-Uo0&v z248LjwPIAT8wp8dY^hPH%MX%Fb60`tL3gvDFs#;K(R{nITB-Zp-Cv*y_t&70FqgkW zJ|w)2vjhK?D5ku~e9?0cGIt?<7vX3l`+^@(lSHd|QwL~n3&qa1X&5bb9YF9~sK36B zfy9#>box^v$2strwat`8S4Dm+;;Zb3}KcgLOaK=yc1h z!__t2#!Ut3-2zSVzq7=F8#@nXiBQes5;Byx#GwvOs+b@M5P2AAwXrxrXxC0a2ft_W zL+NZoEshrGJrffy$sor^@Ua_f??;`LS&l$dk?!v*X{d5Lq$!lv7vLoQCo4%b8UU*P z9!D#yS10D?Zix4H(d;rh-bJ%BwAPR$fSVF6pIT%?S>(ElY;Ws(C*|hmL^Qk0YDq^q za!ESr^}z3l9i%X9TGA3>-KXVNy!8%RD)RO}tV>8aB2rpER)h{eg694lU4m>eOK@iA z*RvDZMv$Ew&t6@GCtPmTOIi}eUU9Xu>}MM|0ff%udK(rWy?;Dx0{zqAZR z8w|pjgp8vYz=J0b+Dm<6oot|hh2+KBS*HitXgp^c3c!(tQ#%42ttdFxxH@#a$12D6t}Wd@g(zTS1B;enl#9i(wCS2m!cqEmET?B{G|J9xxwb?_R zDQ9?a1VzOd+X^i}#rh`B5oR7IMc&;G1JxJ?!f|6zpsm>eklFgqwr*3T2#`Xx&Y~my zBH1e#blcW`(juS44rq-}n29jgi!$P$~;aQ*{BBnWW*?&2!d$& zg78DwXayx-`v5|l2o4(|pmx{cCp{7RZPoXZ;C5d>?QDXhmNLr4 zym}OO$zhI$OUJN`#In{3et^^CIOP*pLFOGCxu(yS!{MP1+J_1W2mqiBe}KfpV5B`m zS0p3RExuoUcEuc}{+U()EA~(%0vydg8wucCq#hQ62F}Y-YQV!nxmt|eUqHcn#^Xs& z;83vBE>OF0ID^a4B*bm39c1OV-5EaG`Sx`qJ>=xjmp$`;E^am6oSm>p>PgFcgi7@ z(Xwu~`x|I+zlh`xg6(M+k?98M$Z!uq#74-4A9hR1wdf29Xua0WKmxB4hr^k*)#%qz zutJHLPlujAL3(1HR85&0Vm`46(SjSY6?er>9Y}wX-}Xo{@nMrf+X0UIgYtZu4PP%X zGOaSUbaBfnzo1chySViMelVj)=qM{54|kQfZ&ml7Pu_s1;`Z<>l4G2M=$9V&s=977 z%V`rRpM#8Y^KXa^T(}IIUAa-lrKiQ;rQ+*FMZImDg$lr)e+{Xt;g<9GmG*32D3-D_ zx$JfK*U_MwS*-pWt6^5y5j)>XL52oa*b*+ zfPEta!dAUuy|!j!)eo8_sSed1(WB?QL;LPnYyK|oaleE_n6@X)DEdukB1YC^UO2h& zDx%!(@1RLBc4(^?0~~t@qIJ9I;>)XirH#1NJw-QM`bKxGW$6OxAr{yubpy#XK`m|z z@#LKE6(Ea+WP<03XpIKDkvsu0C{$C=B?#xQt;P3o9lYa4d*+&Q>~(@~D8-){aL?2I zDHc`7qzfvK!>Jd&;x*2Uf{6texpTEr^8-n%>X2N(^*tRh=2Us{X_LH3+b%MWa0_os zunG{04iVDmB_!~iR)jYThpnhoZ>)AAU=Sp&){MOSnDTV$xl z4j(vlzse>u3R}ZCKHp8;XhsF@Ar=bwWX#Hs!HFpbLU%ah2!!@w zslFN45H7nyq)6&}Bcaaya}+ycR_@;G1^3H%>numi(dg?D5}X%>Rgm9<3?L5^2Vla= zIaoc|Fil*3yM*&jeg#5ago`bFf+nFaHJadkG3u;D!k{F-2QcW&{N7JmaN=l=Ku;yE z-+<%(HOA}yHj;OW{W@x`_hOd`kayTiZav)SEP!o@;Np!b##q)TVs!w)gCe*M2f;CO z5Mun{L_nVo1xTPFc4uc-_yK}Fec9w10_E$tW+BJa)bGBSihCCJb#)C22!M}K2hg(2xuznV}CngX^L*sRE3PZyOb`$`Sa-k&6 z;8nunJVHPe2*1v(y0~puz(${Wv->$D-4gyM@UHien$~$wV-Y@#)5z9aB{m8LuTd%# zY@~`K)44G#tL@QtL14*~dSjvVgB&cWh^5+wJK|GqcJD_M1oJ}<;{hLVXwM+9?^odN zgNozb&2&zJH`5hTJm3s6>zfVx8aVUz!ytTThB)<;owYqpyq;$JX+P)A4}(OTEFNVk zCq7?o7fDE~gNg|2c8S@N;?Pmnu-r(X$v@T>00IZEJ^Hicp5LrHOdjbJM`yXkhg-;T)bMF zn`{LE4&1zKR~2*To6YQt*i#AT_J`yCns3)wlq~52Eb$Q{5oe~c29er+spSXjQqgjV z;s;Az+e4t`5a~Pv%`_U9pJCVliCAhxGPK zlT6aJG0)HQ_35o{y{eDRT`qv!0e0f8xv6Ih(^FT(-kB$l9kZDe$B(NuXhen5qTN4X zzT&OfuL!B@^y%mC^FickCA4RwB%cTi;OH4XxYSep`sV)9`oKg#5zOg_%!Q%pX~awDmc-tDQ)P6j5C3k@ho zT=A1O@j%uNerdFIFq7%W(coQ!LzykMA5(sZ!~i@@L0<++HN(1L{Pt&hGQGI7Ka=sY-67dXybnasN0n3%WTi2Mz--;ne;FgJ@h2#kqz_i{>-NT1;_W=1poj5 literal 0 HcmV?d00001 diff --git a/waflib/__init__.py b/waflib/__init__.py new file mode 100644 index 0000000..efeed79 --- /dev/null +++ b/waflib/__init__.py @@ -0,0 +1,4 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + diff --git a/waflib/__init__.pyc b/waflib/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8ee773dcf5bde4a9a20b23045db5902b9ce6da5 GIT binary patch literal 183 zcmZSn%*(aqbx%+-0~9aacXL6Vv?~@l7)Gav2n6xQmUCzl1XZ^ wNphlTs->}^K2U8=W|Dq38vp=6 + try: + _type=unicode + except NameError: + _type=str + to_int=lambda number,default:number and int(number)or default + wlock=threading.Lock() + STD_OUTPUT_HANDLE=-11 + STD_ERROR_HANDLE=-12 + class AnsiTerm(object): + def __init__(self): + self.encoding=sys.stdout.encoding + self.hconsole=windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE) + self.cursor_history=[] + self.orig_sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + self.orig_csinfo=CONSOLE_CURSOR_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(self.orig_sbinfo)) + windll.kernel32.GetConsoleCursorInfo(hconsole,byref(self.orig_csinfo)) + def screen_buffer_info(self): + sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(sbinfo)) + return sbinfo + def clear_line(self,param): + mode=param and int(param)or 0 + sbinfo=self.screen_buffer_info() + if mode==1: + line_start=COORD(0,sbinfo.CursorPosition.Y) + line_length=sbinfo.Size.X + elif mode==2: + line_start=COORD(sbinfo.CursorPosition.X,sbinfo.CursorPosition.Y) + line_length=sbinfo.Size.X-sbinfo.CursorPosition.X + else: + line_start=sbinfo.CursorPosition + line_length=sbinfo.Size.X-sbinfo.CursorPosition.X + chars_written=c_int() + windll.kernel32.FillConsoleOutputCharacterA(self.hconsole,c_wchar(' '),line_length,line_start,byref(chars_written)) + windll.kernel32.FillConsoleOutputAttribute(self.hconsole,sbinfo.Attributes,line_length,line_start,byref(chars_written)) + def clear_screen(self,param): + mode=to_int(param,0) + sbinfo=self.screen_buffer_info() + if mode==1: + clear_start=COORD(0,0) + clear_length=sbinfo.CursorPosition.X*sbinfo.CursorPosition.Y + elif mode==2: + clear_start=COORD(0,0) + clear_length=sbinfo.Size.X*sbinfo.Size.Y + windll.kernel32.SetConsoleCursorPosition(self.hconsole,clear_start) + else: + clear_start=sbinfo.CursorPosition + clear_length=((sbinfo.Size.X-sbinfo.CursorPosition.X)+sbinfo.Size.X*(sbinfo.Size.Y-sbinfo.CursorPosition.Y)) + chars_written=c_int() + windll.kernel32.FillConsoleOutputCharacterA(self.hconsole,c_wchar(' '),clear_length,clear_start,byref(chars_written)) + windll.kernel32.FillConsoleOutputAttribute(self.hconsole,sbinfo.Attributes,clear_length,clear_start,byref(chars_written)) + def push_cursor(self,param): + sbinfo=self.screen_buffer_info() + self.cursor_history.append(sbinfo.CursorPosition) + def pop_cursor(self,param): + if self.cursor_history: + old_pos=self.cursor_history.pop() + windll.kernel32.SetConsoleCursorPosition(self.hconsole,old_pos) + def set_cursor(self,param): + y,sep,x=param.partition(';') + x=to_int(x,1)-1 + y=to_int(y,1)-1 + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,x),sbinfo.Size.X),min(max(0,y),sbinfo.Size.Y)) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def set_column(self,param): + x=to_int(param,1)-1 + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,x),sbinfo.Size.X),sbinfo.CursorPosition.Y) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def move_cursor(self,x_offset=0,y_offset=0): + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,sbinfo.CursorPosition.X+x_offset),sbinfo.Size.X),min(max(0,sbinfo.CursorPosition.Y+y_offset),sbinfo.Size.Y)) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def move_up(self,param): + self.move_cursor(y_offset=-to_int(param,1)) + def move_down(self,param): + self.move_cursor(y_offset=to_int(param,1)) + def move_left(self,param): + self.move_cursor(x_offset=-to_int(param,1)) + def move_right(self,param): + self.move_cursor(x_offset=to_int(param,1)) + def next_line(self,param): + sbinfo=self.screen_buffer_info() + self.move_cursor(x_offset=-sbinfo.CursorPosition.X,y_offset=to_int(param,1)) + def prev_line(self,param): + sbinfo=self.screen_buffer_info() + self.move_cursor(x_offset=-sbinfo.CursorPosition.X,y_offset=-to_int(param,1)) + def rgb2bgr(self,c): + return((c&1)<<2)|(c&2)|((c&4)>>2) + def set_color(self,param): + cols=param.split(';') + sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(sbinfo)) + attr=sbinfo.Attributes + for c in cols: + if is_vista: + c=int(c) + else: + c=to_int(c,0) + if c in range(30,38): + attr=(attr&0xfff0)|self.rgb2bgr(c-30) + elif c in range(40,48): + attr=(attr&0xff0f)|(self.rgb2bgr(c-40)<<4) + elif c==0: + attr=self.orig_sbinfo.Attributes + elif c==1: + attr|=0x08 + elif c==4: + attr|=0x80 + elif c==7: + attr=(attr&0xff88)|((attr&0x70)>>4)|((attr&0x07)<<4) + windll.kernel32.SetConsoleTextAttribute(self.hconsole,attr) + def show_cursor(self,param): + csinfo.bVisible=1 + windll.kernel32.SetConsoleCursorInfo(self.hconsole,byref(csinfo)) + def hide_cursor(self,param): + csinfo.bVisible=0 + windll.kernel32.SetConsoleCursorInfo(self.hconsole,byref(csinfo)) + ansi_command_table={'A':move_up,'B':move_down,'C':move_right,'D':move_left,'E':next_line,'F':prev_line,'G':set_column,'H':set_cursor,'f':set_cursor,'J':clear_screen,'K':clear_line,'h':show_cursor,'l':hide_cursor,'m':set_color,'s':push_cursor,'u':pop_cursor,} + ansi_tokens=re.compile('(?:\x1b\[([0-9?;]*)([a-zA-Z])|([^\x1b]+))') + def write(self,text): + try: + wlock.acquire() + for param,cmd,txt in self.ansi_tokens.findall(text): + if cmd: + cmd_func=self.ansi_command_table.get(cmd) + if cmd_func: + cmd_func(self,param) + else: + self.writeconsole(txt) + finally: + wlock.release() + def writeconsole(self,txt): + chars_written=c_int() + writeconsole=windll.kernel32.WriteConsoleA + if isinstance(txt,_type): + writeconsole=windll.kernel32.WriteConsoleW + TINY_STEP=3000 + for x in range(0,len(txt),TINY_STEP): + tiny=txt[x:x+TINY_STEP] + writeconsole(self.hconsole,tiny,len(tiny),byref(chars_written),None) + def flush(self): + pass + def isatty(self): + return True + sys.stderr=sys.stdout=AnsiTerm() + os.environ['TERM']='vt100' diff --git a/waflib/ansiterm.pyc b/waflib/ansiterm.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e7c4f20b4941232f6373668ebbd04299619851ff GIT binary patch literal 12022 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 literal 0 HcmV?d00001 diff --git a/waflib/extras/__init__.py b/waflib/extras/__init__.py new file mode 100644 index 0000000..efeed79 --- /dev/null +++ b/waflib/extras/__init__.py @@ -0,0 +1,4 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + diff --git a/waflib/extras/compat15.py b/waflib/extras/compat15.py new file mode 100644 index 0000000..3343afc --- /dev/null +++ b/waflib/extras/compat15.py @@ -0,0 +1,220 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +from waflib import ConfigSet,Logs,Options,Scripting,Task,Build,Configure,Node,Runner,TaskGen,Utils,Errors,Context +sys.modules['Environment']=ConfigSet +ConfigSet.Environment=ConfigSet.ConfigSet +sys.modules['Logs']=Logs +sys.modules['Options']=Options +sys.modules['Scripting']=Scripting +sys.modules['Task']=Task +sys.modules['Build']=Build +sys.modules['Configure']=Configure +sys.modules['Node']=Node +sys.modules['Runner']=Runner +sys.modules['TaskGen']=TaskGen +sys.modules['Utils']=Utils +from waflib.Tools import c_preproc +sys.modules['preproc']=c_preproc +from waflib.Tools import c_config +sys.modules['config_c']=c_config +ConfigSet.ConfigSet.copy=ConfigSet.ConfigSet.derive +ConfigSet.ConfigSet.set_variant=Utils.nada +Build.BuildContext.add_subdirs=Build.BuildContext.recurse +Build.BuildContext.new_task_gen=Build.BuildContext.__call__ +Build.BuildContext.is_install=0 +Node.Node.relpath_gen=Node.Node.path_from +def name_to_obj(self,s,env=None): + Logs.warn('compat: change "name_to_obj(name, env)" by "get_tgen_by_name(name)"') + return self.get_tgen_by_name(s) +Build.BuildContext.name_to_obj=name_to_obj +def env_of_name(self,name): + try: + return self.all_envs[name] + except KeyError: + Logs.error('no such environment: '+name) + return None +Build.BuildContext.env_of_name=env_of_name +def set_env_name(self,name,env): + self.all_envs[name]=env + return env +Configure.ConfigurationContext.set_env_name=set_env_name +def retrieve(self,name,fromenv=None): + try: + env=self.all_envs[name] + except KeyError: + env=ConfigSet.ConfigSet() + self.prepare_env(env) + self.all_envs[name]=env + else: + if fromenv:Logs.warn("The environment %s may have been configured already"%name) + return env +Configure.ConfigurationContext.retrieve=retrieve +Configure.ConfigurationContext.sub_config=Configure.ConfigurationContext.recurse +Configure.ConfigurationContext.check_tool=Configure.ConfigurationContext.load +Configure.conftest=Configure.conf +Configure.ConfigurationError=Errors.ConfigurationError +Options.OptionsContext.sub_options=Options.OptionsContext.recurse +Options.OptionsContext.tool_options=Context.Context.load +Options.Handler=Options.OptionsContext +Task.simple_task_type=Task.task_type_from_func=Task.task_factory +Task.TaskBase.classes=Task.classes +def setitem(self,key,value): + if key.startswith('CCFLAGS'): + key=key[1:] + self.table[key]=value +ConfigSet.ConfigSet.__setitem__=setitem +@TaskGen.feature('d') +@TaskGen.before('apply_incpaths') +def old_importpaths(self): + if getattr(self,'importpaths',[]): + self.includes=self.importpaths +from waflib import Context +eld=Context.load_tool +def load_tool(*k,**kw): + ret=eld(*k,**kw) + if'set_options'in ret.__dict__: + Logs.warn('compat: rename "set_options" to options') + ret.options=ret.set_options + if'detect'in ret.__dict__: + Logs.warn('compat: rename "detect" to "configure"') + ret.configure=ret.detect + return ret +Context.load_tool=load_tool +rev=Context.load_module +def load_module(path): + ret=rev(path) + if'set_options'in ret.__dict__: + Logs.warn('compat: rename "set_options" to "options" (%r)'%path) + ret.options=ret.set_options + if'srcdir'in ret.__dict__: + Logs.warn('compat: rename "srcdir" to "top" (%r)'%path) + ret.top=ret.srcdir + if'blddir'in ret.__dict__: + Logs.warn('compat: rename "blddir" to "out" (%r)'%path) + ret.out=ret.blddir + return ret +Context.load_module=load_module +old_post=TaskGen.task_gen.post +def post(self): + self.features=self.to_list(self.features) + if'cc'in self.features: + Logs.warn('compat: the feature cc does not exist anymore (use "c")') + self.features.remove('cc') + self.features.append('c') + if'cstaticlib'in self.features: + Logs.warn('compat: the feature cstaticlib does not exist anymore (use "cstlib" or "cxxstlib")') + self.features.remove('cstaticlib') + self.features.append(('cxx'in self.features)and'cxxstlib'or'cstlib') + if getattr(self,'ccflags',None): + Logs.warn('compat: "ccflags" was renamed to "cflags"') + self.cflags=self.ccflags + return old_post(self) +TaskGen.task_gen.post=post +def waf_version(*k,**kw): + Logs.warn('wrong version (waf_version was removed in waf 1.6)') +Utils.waf_version=waf_version +import os +@TaskGen.feature('c','cxx','d') +@TaskGen.before('apply_incpaths','propagate_uselib_vars') +@TaskGen.after('apply_link','process_source') +def apply_uselib_local(self): + env=self.env + from waflib.Tools.ccroot import stlink_task + self.uselib=self.to_list(getattr(self,'uselib',[])) + self.includes=self.to_list(getattr(self,'includes',[])) + names=self.to_list(getattr(self,'uselib_local',[])) + get=self.bld.get_tgen_by_name + seen=set([]) + tmp=Utils.deque(names) + if tmp: + Logs.warn('compat: "uselib_local" is deprecated, replace by "use"') + while tmp: + lib_name=tmp.popleft() + if lib_name in seen: + continue + y=get(lib_name) + y.post() + seen.add(lib_name) + if getattr(y,'uselib_local',None): + for x in self.to_list(getattr(y,'uselib_local',[])): + obj=get(x) + obj.post() + if getattr(obj,'link_task',None): + if not isinstance(obj.link_task,stlink_task): + tmp.append(x) + if getattr(y,'link_task',None): + link_name=y.target[y.target.rfind(os.sep)+1:] + if isinstance(y.link_task,stlink_task): + env.append_value('STLIB',[link_name]) + else: + env.append_value('LIB',[link_name]) + self.link_task.set_run_after(y.link_task) + self.link_task.dep_nodes+=y.link_task.outputs + tmp_path=y.link_task.outputs[0].parent.bldpath() + if not tmp_path in env['LIBPATH']: + env.prepend_value('LIBPATH',[tmp_path]) + for v in self.to_list(getattr(y,'uselib',[])): + if not env['STLIB_'+v]: + if not v in self.uselib: + self.uselib.insert(0,v) + if getattr(y,'export_includes',None): + self.includes.extend(y.to_incnodes(y.export_includes)) +@TaskGen.feature('cprogram','cxxprogram','cstlib','cxxstlib','cshlib','cxxshlib','dprogram','dstlib','dshlib') +@TaskGen.after('apply_link') +def apply_objdeps(self): + names=getattr(self,'add_objects',[]) + if not names: + return + names=self.to_list(names) + get=self.bld.get_tgen_by_name + seen=[] + while names: + x=names[0] + if x in seen: + names=names[1:] + continue + y=get(x) + 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 + y.post() + seen.append(x) + for t in getattr(y,'compiled_tasks',[]): + self.link_task.inputs.extend(t.outputs) +@TaskGen.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.taskgen_method +def add_obj_file(self,file): + 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) +old_define=Configure.ConfigurationContext.__dict__['define'] +@Configure.conf +def define(self,key,val,quote=True): + old_define(self,key,val,quote) + if key.startswith('HAVE_'): + self.env[key]=1 +old_undefine=Configure.ConfigurationContext.__dict__['undefine'] +@Configure.conf +def undefine(self,key): + old_undefine(self,key) + if key.startswith('HAVE_'): + self.env[key]=0 +def set_incdirs(self,val): + Logs.warn('compat: change "export_incdirs" by "export_includes"') + self.export_includes=val +TaskGen.task_gen.export_incdirs=property(None,set_incdirs) diff --git a/waflib/fixpy2.py b/waflib/fixpy2.py new file mode 100644 index 0000000..98f7036 --- /dev/null +++ b/waflib/fixpy2.py @@ -0,0 +1,53 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +all_modifs={} +def fixdir(dir): + global all_modifs + for k in all_modifs: + for v in all_modifs[k]: + modif(os.path.join(dir,'waflib'),k,v) +def modif(dir,name,fun): + if name=='*': + lst=[] + for y in'. Tools extras'.split(): + for x in os.listdir(os.path.join(dir,y)): + if x.endswith('.py'): + lst.append(y+os.sep+x) + for x in lst: + modif(dir,x,fun) + return + filename=os.path.join(dir,name) + f=open(filename,'r') + try: + txt=f.read() + finally: + f.close() + txt=fun(txt) + f=open(filename,'w') + try: + f.write(txt) + finally: + f.close() +def subst(*k): + def do_subst(fun): + global all_modifs + for x in k: + try: + all_modifs[x].append(fun) + except KeyError: + all_modifs[x]=[fun] + return fun + return do_subst +@subst('*') +def r1(code): + code=code.replace(',e:',',e:') + code=code.replace("",'') + code=code.replace('','') + return code +@subst('Runner.py') +def r4(code): + code=code.replace('next(self.biter)','self.biter.next()') + return code diff --git a/waflib/fixpy2.pyc b/waflib/fixpy2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ac59e84300d0bcc06cb470eed4b40be77967f84 GIT binary patch literal 2455 zcmcguZEqVz5S~51yD?2DNuVF7X$ieRW8*lbNfaT}nh&Uwh0dUqqEMah*5RCs&$(R_ z8`+fv6Kl%%wZlIv% zFp3z@Fw9pF)2C#KIwyy;P&94vWUlDF&dC-n9I}e6L&F>m^E8(zuN+>VJ9L#Jb@478 zUzF$=7wEZsrLN_}Fa1Fr_1ywgTZQoB_|uvW+68R(R4i9ZH#Af56lol2`@8zEplpVO$8hp zqsmti7(YOezyxrgIh6iEr$mb!O;0(CLu82I{f-uSntsiI4h7cNn9lPAOp(UU$)~g^ z(7Zsy0_Pp3v_o@XUnDs3&Jt~6c@rz@qC@x|U)-bP>HF-}IoaUtw#|z- zw~>FY<&?o>B+uAbi7|_G3b=^|QLM$0gCB^So!X`HRc^R~*PD+ZNUf-%x}&z#ZS_Fa z)H^D#)}iOrs&fl#tgSf#donUSgynaj{DvzCnSTWdQ0d%6*dgm5tT8z3X`Vw&JM=pf z{D_@r>o@&lh@H}$6gP-Gs{O1==~Gfl!G4OiA~kb_#TVQ`VC=aJUsvkiW7S)Q5P+ZS z*_UaWq!Ng?$!m8ZWP`_%3)ahM3!LsSd1WSjV;?{_j5#-k900CiWLamJBrxwDw9F<~ z5}23JzPKtR$os5tp^&;=_P84d90(7tr)L=E5CRE6uR;$))8e9jZIPdze_7C-vW_7> zJ(u~=HT*^&<$Nfm{0PraU}=OpNJ8zJnQ5SClZkEU5iHT@w4S8(hmlG4_a7hZv>tAQ z5r~C5Yv!WeZAq|{e5%K>ALz`$*O60s$I?>IIZa!SAPuvCoVOMKNyOe{G}0;h*MGs? zfb0K)+Y_dD4YPcNF6bH^4;p>+pmf`;!T4t0ko61>k29Jvp9z?83kofR{(`~YF27AU z1q@uKwDjhzXgPt>jl4Q*AF|kjcoXQ-GRA2-!hai+Sbr`B!Ntm*u~MjPRI2O6zX4K~ B@csY* literal 0 HcmV?d00001 -- 2.11.0