mirror of https://github.com/lukechilds/node.git
Ben Noordhuis
13 years ago
54 changed files with 0 additions and 13298 deletions
@ -1,17 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
import os, sys |
|
||||
|
|
||||
|
|
||||
join = os.path.join |
|
||||
bindir = os.path.dirname(os.path.realpath(__file__)) |
|
||||
prefix = join(bindir, "..") |
|
||||
wafdir = join(prefix, "lib", "node") |
|
||||
|
|
||||
w = join(wafdir, 'wafadmin') |
|
||||
t = join(w, 'Tools') |
|
||||
sys.path = [w, t] + sys.path |
|
||||
|
|
||||
import Scripting |
|
||||
VERSION="1.5.16" |
|
||||
Scripting.prepare(t, os.getcwd(), VERSION, wafdir) |
|
||||
sys.exit(0) |
|
||||
@ -1,159 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: ISO8859-1 |
|
||||
# Thomas Nagy, 2005-2010 |
|
||||
|
|
||||
""" |
|
||||
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 |
|
||||
if sys.hexversion<0x203000f: raise ImportError("Waf requires Python >= 2.3") |
|
||||
|
|
||||
if 'PSYCOWAF' in os.environ: |
|
||||
try:import psyco;psyco.full() |
|
||||
except:pass |
|
||||
|
|
||||
VERSION="1.5.16" |
|
||||
REVISION="x" |
|
||||
INSTALL="x" |
|
||||
C1='x' |
|
||||
C2='x' |
|
||||
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 = "corrupted waf (%d)" |
|
||||
while 1: |
|
||||
line = f.readline() |
|
||||
if not line: err("run waf-light from a folder containing wafadmin") |
|
||||
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', '3rdparty']: |
|
||||
os.makedirs(join(dir, 'wafadmin', x)) |
|
||||
except OSError: |
|
||||
err("Cannot unpack waf lib into %s\nMove waf into a writeable directory" % dir) |
|
||||
|
|
||||
os.chdir(dir) |
|
||||
tmp = 't.bz2' |
|
||||
t = open(tmp,'wb') |
|
||||
t.write(txt) |
|
||||
t.close() |
|
||||
|
|
||||
t = None |
|
||||
try: |
|
||||
t = tarfile.open(tmp) |
|
||||
except: |
|
||||
try: |
|
||||
os.system('bunzip2 t.bz2') |
|
||||
t = tarfile.open('t') |
|
||||
except: |
|
||||
os.chdir(cwd) |
|
||||
try: shutil.rmtree(dir) |
|
||||
except OSError: pass |
|
||||
err("Waf cannot be unpacked, check that bzip2 support is present") |
|
||||
|
|
||||
for x in t: t.extract(x) |
|
||||
t.close() |
|
||||
|
|
||||
for x in ['Tools', '3rdparty']: |
|
||||
os.chmod(join('wafadmin',x), 493) |
|
||||
|
|
||||
if sys.hexversion>0x300000f: |
|
||||
sys.path = [join(dir, 'wafadmin')] + sys.path |
|
||||
import py3kfixes |
|
||||
py3kfixes.fixdir(dir) |
|
||||
|
|
||||
os.chdir(cwd) |
|
||||
|
|
||||
def test(dir): |
|
||||
try: os.stat(join(dir, 'wafadmin')); 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 wafadmin -> export WAFDIR=/folder") |
|
||||
|
|
||||
dir = "/lib/%s-%s-%s/" % (WAF, VERSION, REVISION) |
|
||||
for i in [INSTALL,'/usr','/usr/local','/opt']: |
|
||||
w = test(i+dir) |
|
||||
if w: return w |
|
||||
|
|
||||
#waf-local |
|
||||
s = '.%s-%s-%s' |
|
||||
if sys.platform == 'win32': s = s[1:] |
|
||||
dir = join(base, s % (WAF, VERSION, REVISION)) |
|
||||
w = test(dir) |
|
||||
if w: return w |
|
||||
|
|
||||
#unpack |
|
||||
unpack_wafdir(dir) |
|
||||
return dir |
|
||||
|
|
||||
wafdir = find_lib() |
|
||||
w = join(wafdir, 'wafadmin') |
|
||||
t = join(w, 'Tools') |
|
||||
f = join(w, '3rdparty') |
|
||||
sys.path = [w, t, f] + sys.path |
|
||||
|
|
||||
if __name__ == '__main__': |
|
||||
import Scripting |
|
||||
Scripting.prepare(t, cwd, VERSION, wafdir) |
|
||||
|
|
||||
File diff suppressed because it is too large
@ -1,387 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005-2008 (ita) |
|
||||
|
|
||||
""" |
|
||||
Configuration system |
|
||||
|
|
||||
A configuration instance is created when "waf configure" is called, it is used to: |
|
||||
* create data dictionaries (Environment instances) |
|
||||
* store the list of modules to import |
|
||||
|
|
||||
The old model (copied from Scons) was to store logic (mapping file extensions to functions) |
|
||||
along with the data. In Waf a way was found to separate that logic by adding an indirection |
|
||||
layer (storing the names in the Environment instances) |
|
||||
|
|
||||
In the new model, the logic is more object-oriented, and the user scripts provide the |
|
||||
logic. The data files (Environments) must contain configuration data only (flags, ..). |
|
||||
|
|
||||
Note: the c/c++ related code is in the module config_c |
|
||||
""" |
|
||||
|
|
||||
import os, shlex, sys, time |
|
||||
try: import cPickle |
|
||||
except ImportError: import pickle as cPickle |
|
||||
import Environment, Utils, Options, Logs |
|
||||
from Logs import warn |
|
||||
from Constants import * |
|
||||
|
|
||||
try: |
|
||||
from urllib import request |
|
||||
except: |
|
||||
from urllib import urlopen |
|
||||
else: |
|
||||
urlopen = request.urlopen |
|
||||
|
|
||||
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 |
|
||||
# |
|
||||
''' |
|
||||
|
|
||||
class ConfigurationError(Utils.WscriptError): |
|
||||
pass |
|
||||
|
|
||||
autoconfig = False |
|
||||
"reconfigure the project automatically" |
|
||||
|
|
||||
def find_file(filename, path_list): |
|
||||
"""find a file in a list of paths |
|
||||
@param filename: name of the file to search for |
|
||||
@param path_list: list of directories to search |
|
||||
@return: the first occurrence filename or '' if filename could not be found |
|
||||
""" |
|
||||
for directory in Utils.to_list(path_list): |
|
||||
if os.path.exists(os.path.join(directory, filename)): |
|
||||
return directory |
|
||||
return '' |
|
||||
|
|
||||
def find_program_impl(env, filename, path_list=[], var=None, environ=None): |
|
||||
"""find a program in folders path_lst, and sets env[var] |
|
||||
@param env: environment |
|
||||
@param filename: name of the program to search for |
|
||||
@param path_list: list of directories to search for filename |
|
||||
@param var: environment value to be checked for in env or os.environ |
|
||||
@return: either the value that is referenced with [var] in env or os.environ |
|
||||
or the first occurrence filename or '' if filename could not be found |
|
||||
""" |
|
||||
|
|
||||
if not environ: |
|
||||
environ = os.environ |
|
||||
|
|
||||
try: path_list = path_list.split() |
|
||||
except AttributeError: pass |
|
||||
|
|
||||
if var: |
|
||||
if env[var]: return env[var] |
|
||||
if var in environ: env[var] = environ[var] |
|
||||
|
|
||||
if not path_list: path_list = environ.get('PATH', '').split(os.pathsep) |
|
||||
|
|
||||
ext = (Options.platform == 'win32') and '.exe,.com,.bat,.cmd' or '' |
|
||||
for y in [filename+x for x in ext.split(',')]: |
|
||||
for directory in path_list: |
|
||||
x = os.path.join(directory, y) |
|
||||
if os.path.isfile(x): |
|
||||
if var: env[var] = x |
|
||||
return x |
|
||||
return '' |
|
||||
|
|
||||
class ConfigurationContext(Utils.Context): |
|
||||
tests = {} |
|
||||
error_handlers = [] |
|
||||
def __init__(self, env=None, blddir='', srcdir=''): |
|
||||
self.env = None |
|
||||
self.envname = '' |
|
||||
|
|
||||
self.environ = dict(os.environ) |
|
||||
|
|
||||
self.line_just = 40 |
|
||||
|
|
||||
self.blddir = blddir |
|
||||
self.srcdir = srcdir |
|
||||
self.all_envs = {} |
|
||||
|
|
||||
# curdir: necessary for recursion |
|
||||
self.cwd = self.curdir = os.getcwd() |
|
||||
|
|
||||
self.tools = [] # tools loaded in the configuration, and that will be loaded when building |
|
||||
|
|
||||
self.setenv(DEFAULT) |
|
||||
|
|
||||
self.lastprog = '' |
|
||||
|
|
||||
self.hash = 0 |
|
||||
self.files = [] |
|
||||
|
|
||||
self.tool_cache = [] |
|
||||
|
|
||||
if self.blddir: |
|
||||
self.post_init() |
|
||||
|
|
||||
def post_init(self): |
|
||||
|
|
||||
self.cachedir = os.path.join(self.blddir, CACHE_DIR) |
|
||||
|
|
||||
path = os.path.join(self.blddir, WAF_CONFIG_LOG) |
|
||||
try: os.unlink(path) |
|
||||
except (OSError, IOError): pass |
|
||||
|
|
||||
try: |
|
||||
self.log = open(path, 'w') |
|
||||
except (OSError, IOError): |
|
||||
self.fatal('could not open %r for writing' % path) |
|
||||
|
|
||||
app = Utils.g_module.APPNAME |
|
||||
if app: |
|
||||
ver = getattr(Utils.g_module, 'VERSION', '') |
|
||||
if ver: |
|
||||
app = "%s (%s)" % (app, ver) |
|
||||
|
|
||||
now = time.ctime() |
|
||||
pyver = sys.hexversion |
|
||||
systype = sys.platform |
|
||||
args = " ".join(sys.argv) |
|
||||
wafver = WAFVERSION |
|
||||
abi = ABI |
|
||||
self.log.write(conf_template % vars()) |
|
||||
|
|
||||
def __del__(self): |
|
||||
"""cleanup function: close config.log""" |
|
||||
|
|
||||
# may be ran by the gc, not always after initialization |
|
||||
if hasattr(self, 'log') and self.log: |
|
||||
self.log.close() |
|
||||
|
|
||||
def fatal(self, msg): |
|
||||
raise ConfigurationError(msg) |
|
||||
|
|
||||
def check_tool(self, input, tooldir=None, funs=None): |
|
||||
"load a waf tool" |
|
||||
|
|
||||
tools = Utils.to_list(input) |
|
||||
if tooldir: tooldir = Utils.to_list(tooldir) |
|
||||
for tool in tools: |
|
||||
tool = tool.replace('++', 'xx') |
|
||||
if tool == 'java': tool = 'javaw' |
|
||||
if tool.lower() == 'unittest': tool = 'unittestw' |
|
||||
# avoid loading the same tool more than once with the same functions |
|
||||
# used by composite projects |
|
||||
|
|
||||
mag = (tool, id(self.env), funs) |
|
||||
if mag in self.tool_cache: |
|
||||
continue |
|
||||
self.tool_cache.append(mag) |
|
||||
|
|
||||
if not tooldir: |
|
||||
# check if the tool exists in the Tools or 3rdparty folders |
|
||||
_Tools = Options.tooldir[0] |
|
||||
_3rdparty = os.sep.join((_Tools, '..', '3rdparty')) |
|
||||
for d in (_Tools, _3rdparty): |
|
||||
lst = os.listdir(d) |
|
||||
if tool + '.py' in lst: |
|
||||
break |
|
||||
else: |
|
||||
# try to download the tool from the repository then |
|
||||
for x in Utils.to_list(Options.remote_repo): |
|
||||
for sub in ['branches/waf-%s/wafadmin/3rdparty' % WAFVERSION, 'trunk/wafadmin/3rdparty']: |
|
||||
url = '/'.join((x, sub, tool + '.py')) |
|
||||
try: |
|
||||
web = urlopen(url) |
|
||||
if web.getcode() != 200: |
|
||||
continue |
|
||||
except Exception, e: |
|
||||
# on python3 urlopen throws an exception |
|
||||
continue |
|
||||
else: |
|
||||
try: |
|
||||
loc = open(_3rdparty + os.sep + tool + '.py', 'wb') |
|
||||
loc.write(web.read()) |
|
||||
web.close() |
|
||||
finally: |
|
||||
loc.close() |
|
||||
Logs.warn('downloaded %s from %s' % (tool, url)) |
|
||||
else: |
|
||||
break |
|
||||
|
|
||||
module = Utils.load_tool(tool, tooldir) |
|
||||
|
|
||||
if funs is not None: |
|
||||
self.eval_rules(funs) |
|
||||
else: |
|
||||
func = getattr(module, 'detect', None) |
|
||||
if func: |
|
||||
if type(func) is type(find_file): func(self) |
|
||||
else: self.eval_rules(func) |
|
||||
|
|
||||
self.tools.append({'tool':tool, 'tooldir':tooldir, 'funs':funs}) |
|
||||
|
|
||||
def sub_config(self, k): |
|
||||
"executes the configure function of a wscript module" |
|
||||
self.recurse(k, name='configure') |
|
||||
|
|
||||
def pre_recurse(self, name_or_mod, path, nexdir): |
|
||||
return {'conf': self, 'ctx': self} |
|
||||
|
|
||||
def post_recurse(self, name_or_mod, path, nexdir): |
|
||||
if not autoconfig: |
|
||||
return |
|
||||
self.hash = hash((self.hash, getattr(name_or_mod, 'waf_hash_val', name_or_mod))) |
|
||||
self.files.append(path) |
|
||||
|
|
||||
def store(self, file=''): |
|
||||
"save the config results into the cache file" |
|
||||
if not os.path.isdir(self.cachedir): |
|
||||
os.makedirs(self.cachedir) |
|
||||
|
|
||||
if not file: |
|
||||
file = open(os.path.join(self.cachedir, 'build.config.py'), 'w') |
|
||||
file.write('version = 0x%x\n' % HEXVERSION) |
|
||||
file.write('tools = %r\n' % self.tools) |
|
||||
file.close() |
|
||||
|
|
||||
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, key + CACHE_SUFFIX)) |
|
||||
|
|
||||
def set_env_name(self, name, env): |
|
||||
"add a new environment called name" |
|
||||
self.all_envs[name] = env |
|
||||
return env |
|
||||
|
|
||||
def retrieve(self, name, fromenv=None): |
|
||||
"retrieve an environment called name" |
|
||||
try: |
|
||||
env = self.all_envs[name] |
|
||||
except KeyError: |
|
||||
env = Environment.Environment() |
|
||||
env['PREFIX'] = os.path.abspath(os.path.expanduser(Options.options.prefix)) |
|
||||
self.all_envs[name] = env |
|
||||
else: |
|
||||
if fromenv: warn("The environment %s may have been configured already" % name) |
|
||||
return env |
|
||||
|
|
||||
def setenv(self, name): |
|
||||
"enable the environment called name" |
|
||||
self.env = self.retrieve(name) |
|
||||
self.envname = name |
|
||||
|
|
||||
def add_os_flags(self, var, dest=None): |
|
||||
# do not use 'get' to make certain the variable is not defined |
|
||||
try: self.env.append_value(dest or var, Utils.to_list(self.environ[var])) |
|
||||
except KeyError: pass |
|
||||
|
|
||||
def check_message_1(self, sr): |
|
||||
self.line_just = max(self.line_just, len(sr)) |
|
||||
for x in ('\n', self.line_just * '-', '\n', sr, '\n'): |
|
||||
self.log.write(x) |
|
||||
Utils.pprint('NORMAL', "%s :" % sr.ljust(self.line_just), sep='') |
|
||||
|
|
||||
def check_message_2(self, sr, color='GREEN'): |
|
||||
self.log.write(sr) |
|
||||
self.log.write('\n') |
|
||||
Utils.pprint(color, sr) |
|
||||
|
|
||||
def check_message(self, th, msg, state, option=''): |
|
||||
sr = 'Checking for %s %s' % (th, msg) |
|
||||
self.check_message_1(sr) |
|
||||
p = self.check_message_2 |
|
||||
if state: p('ok ' + str(option)) |
|
||||
else: p('not found', 'YELLOW') |
|
||||
|
|
||||
# FIXME remove in waf 1.6 |
|
||||
# the parameter 'option' is not used (kept for compatibility) |
|
||||
def check_message_custom(self, th, msg, custom, option='', color='PINK'): |
|
||||
sr = 'Checking for %s %s' % (th, msg) |
|
||||
self.check_message_1(sr) |
|
||||
self.check_message_2(custom, color) |
|
||||
|
|
||||
def find_program(self, filename, path_list=[], var=None, mandatory=False): |
|
||||
"wrapper that adds a configuration message" |
|
||||
|
|
||||
ret = None |
|
||||
if var: |
|
||||
if self.env[var]: |
|
||||
ret = self.env[var] |
|
||||
elif var in os.environ: |
|
||||
ret = os.environ[var] |
|
||||
|
|
||||
if not isinstance(filename, list): filename = [filename] |
|
||||
if not ret: |
|
||||
for x in filename: |
|
||||
ret = find_program_impl(self.env, x, path_list, var, environ=self.environ) |
|
||||
if ret: break |
|
||||
|
|
||||
self.check_message_1('Checking for program %s' % ' or '.join(filename)) |
|
||||
self.log.write(' find program=%r paths=%r var=%r\n -> %r\n' % (filename, path_list, var, ret)) |
|
||||
if ret: |
|
||||
Utils.pprint('GREEN', str(ret)) |
|
||||
else: |
|
||||
Utils.pprint('YELLOW', 'not found') |
|
||||
if mandatory: |
|
||||
self.fatal('The program %r is required' % filename) |
|
||||
|
|
||||
if var: |
|
||||
self.env[var] = ret |
|
||||
return ret |
|
||||
|
|
||||
def cmd_to_list(self, cmd): |
|
||||
"commands may be written in pseudo shell like 'ccache g++'" |
|
||||
if isinstance(cmd, str) and cmd.find(' '): |
|
||||
try: |
|
||||
os.stat(cmd) |
|
||||
except OSError: |
|
||||
return shlex.split(cmd) |
|
||||
else: |
|
||||
return [cmd] |
|
||||
return cmd |
|
||||
|
|
||||
def __getattr__(self, name): |
|
||||
r = self.__class__.__dict__.get(name, None) |
|
||||
if r: return r |
|
||||
if name and name.startswith('require_'): |
|
||||
|
|
||||
for k in ['check_', 'find_']: |
|
||||
n = name.replace('require_', k) |
|
||||
ret = self.__class__.__dict__.get(n, None) |
|
||||
if ret: |
|
||||
def run(*k, **kw): |
|
||||
r = ret(self, *k, **kw) |
|
||||
if not r: |
|
||||
self.fatal('requirement failure') |
|
||||
return r |
|
||||
return run |
|
||||
self.fatal('No such method %r' % name) |
|
||||
|
|
||||
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: |
|
||||
self.fatal(e) |
|
||||
|
|
||||
def err_handler(self, fun, error): |
|
||||
pass |
|
||||
|
|
||||
def conf(f): |
|
||||
"decorator: attach new configuration functions" |
|
||||
setattr(ConfigurationContext, f.__name__, f) |
|
||||
return f |
|
||||
|
|
||||
def conftest(f): |
|
||||
"decorator: attach new configuration tests (registered as strings)" |
|
||||
ConfigurationContext.tests[f.__name__] = f |
|
||||
return conf(f) |
|
||||
|
|
||||
|
|
||||
@ -1,76 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Yinon dot me gmail 2008 |
|
||||
|
|
||||
""" |
|
||||
these constants are somewhat public, try not to mess them |
|
||||
|
|
||||
maintainer: the version number is updated from the top-level wscript file |
|
||||
""" |
|
||||
|
|
||||
# do not touch these three lines, they are updated automatically |
|
||||
HEXVERSION=0x105016 |
|
||||
WAFVERSION="1.5.16" |
|
||||
WAFREVISION = "7610:7647M" |
|
||||
ABI = 7 |
|
||||
|
|
||||
# permissions |
|
||||
O644 = 420 |
|
||||
O755 = 493 |
|
||||
|
|
||||
MAXJOBS = 99999999 |
|
||||
|
|
||||
CACHE_DIR = 'c4che' |
|
||||
CACHE_SUFFIX = '.cache.py' |
|
||||
DBFILE = '.wafpickle-%d' % ABI |
|
||||
WSCRIPT_FILE = 'wscript' |
|
||||
WSCRIPT_BUILD_FILE = 'wscript_build' |
|
||||
WAF_CONFIG_LOG = 'config.log' |
|
||||
WAF_CONFIG_H = 'config.h' |
|
||||
|
|
||||
SIG_NIL = 'iluvcuteoverload' |
|
||||
|
|
||||
VARIANT = '_VARIANT_' |
|
||||
DEFAULT = 'Release' |
|
||||
|
|
||||
SRCDIR = 'srcdir' |
|
||||
BLDDIR = 'blddir' |
|
||||
APPNAME = 'APPNAME' |
|
||||
VERSION = 'VERSION' |
|
||||
|
|
||||
DEFINES = 'defines' |
|
||||
UNDEFINED = () |
|
||||
|
|
||||
BREAK = "break" |
|
||||
CONTINUE = "continue" |
|
||||
|
|
||||
# task scheduler options |
|
||||
JOBCONTROL = "JOBCONTROL" |
|
||||
MAXPARALLEL = "MAXPARALLEL" |
|
||||
NORMAL = "NORMAL" |
|
||||
|
|
||||
# task state |
|
||||
NOT_RUN = 0 |
|
||||
MISSING = 1 |
|
||||
CRASHED = 2 |
|
||||
EXCEPTION = 3 |
|
||||
SKIPPED = 8 |
|
||||
SUCCESS = 9 |
|
||||
|
|
||||
ASK_LATER = -1 |
|
||||
SKIP_ME = -2 |
|
||||
RUN_ME = -3 |
|
||||
|
|
||||
|
|
||||
LOG_FORMAT = "%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s" |
|
||||
HOUR_FORMAT = "%H:%M:%S" |
|
||||
|
|
||||
TEST_OK = True |
|
||||
|
|
||||
CFG_FILES = 'cfg_files' |
|
||||
|
|
||||
# positive '->' install |
|
||||
# negative '<-' uninstall |
|
||||
INSTALL = 1337 |
|
||||
UNINSTALL = -1337 |
|
||||
|
|
||||
@ -1,210 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
"""Environment representation |
|
||||
|
|
||||
There is one gotcha: getitem returns [] if the contents evals to False |
|
||||
This means env['foo'] = {}; print env['foo'] will print [] not {} |
|
||||
""" |
|
||||
|
|
||||
import os, copy, re |
|
||||
import Logs, Options, Utils |
|
||||
from Constants import * |
|
||||
re_imp = re.compile('^(#)*?([^#=]*?)\ =\ (.*?)$', re.M) |
|
||||
|
|
||||
class Environment(object): |
|
||||
"""A safe-to-use dictionary, but do not attach functions to it please (break cPickle) |
|
||||
An environment instance can be stored into a file and loaded easily |
|
||||
""" |
|
||||
__slots__ = ("table", "parent") |
|
||||
def __init__(self, filename=None): |
|
||||
self.table = {} |
|
||||
#self.parent = None |
|
||||
|
|
||||
if filename: |
|
||||
self.load(filename) |
|
||||
|
|
||||
def __contains__(self, key): |
|
||||
if key in self.table: return True |
|
||||
try: return self.parent.__contains__(key) |
|
||||
except AttributeError: return False # parent may not exist |
|
||||
|
|
||||
def __str__(self): |
|
||||
keys = set() |
|
||||
cur = self |
|
||||
while cur: |
|
||||
keys.update(cur.table.keys()) |
|
||||
cur = getattr(cur, 'parent', None) |
|
||||
keys = list(keys) |
|
||||
keys.sort() |
|
||||
return "\n".join(["%r %r" % (x, self.__getitem__(x)) for x in keys]) |
|
||||
|
|
||||
def __getitem__(self, key): |
|
||||
try: |
|
||||
while 1: |
|
||||
x = self.table.get(key, None) |
|
||||
if not x is None: |
|
||||
return x |
|
||||
self = self.parent |
|
||||
except AttributeError: |
|
||||
return [] |
|
||||
|
|
||||
def __setitem__(self, key, value): |
|
||||
self.table[key] = value |
|
||||
|
|
||||
def __delitem__(self, key): |
|
||||
del self.table[key] |
|
||||
|
|
||||
def pop(self, key, *args): |
|
||||
if len(args): |
|
||||
return self.table.pop(key, *args) |
|
||||
return self.table.pop(key) |
|
||||
|
|
||||
def set_variant(self, name): |
|
||||
self.table[VARIANT] = name |
|
||||
|
|
||||
def variant(self): |
|
||||
try: |
|
||||
while 1: |
|
||||
x = self.table.get(VARIANT, None) |
|
||||
if not x is None: |
|
||||
return x |
|
||||
self = self.parent |
|
||||
except AttributeError: |
|
||||
return DEFAULT |
|
||||
|
|
||||
def copy(self): |
|
||||
# TODO waf 1.6 rename this method derive, #368 |
|
||||
newenv = Environment() |
|
||||
newenv.parent = self |
|
||||
return newenv |
|
||||
|
|
||||
def detach(self): |
|
||||
"""TODO try it |
|
||||
modifying the original env will not change the copy""" |
|
||||
tbl = self.get_merged_dict() |
|
||||
try: |
|
||||
delattr(self, 'parent') |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
else: |
|
||||
keys = tbl.keys() |
|
||||
for x in keys: |
|
||||
tbl[x] = copy.deepcopy(tbl[x]) |
|
||||
self.table = tbl |
|
||||
|
|
||||
def get_flat(self, key): |
|
||||
s = self[key] |
|
||||
if isinstance(s, str): return s |
|
||||
return ' '.join(s) |
|
||||
|
|
||||
def _get_list_value_for_modification(self, key): |
|
||||
"""Gets a value that must be a list for further modification. The |
|
||||
list may be modified inplace and there is no need to |
|
||||
"self.table[var] = value" afterwards. |
|
||||
""" |
|
||||
try: |
|
||||
value = self.table[key] |
|
||||
except KeyError: |
|
||||
try: value = self.parent[key] |
|
||||
except AttributeError: value = [] |
|
||||
if isinstance(value, list): |
|
||||
value = value[:] |
|
||||
else: |
|
||||
value = [value] |
|
||||
else: |
|
||||
if not isinstance(value, list): |
|
||||
value = [value] |
|
||||
self.table[key] = value |
|
||||
return value |
|
||||
|
|
||||
def append_value(self, var, value): |
|
||||
current_value = self._get_list_value_for_modification(var) |
|
||||
|
|
||||
if isinstance(value, list): |
|
||||
current_value.extend(value) |
|
||||
else: |
|
||||
current_value.append(value) |
|
||||
|
|
||||
def prepend_value(self, var, value): |
|
||||
current_value = self._get_list_value_for_modification(var) |
|
||||
|
|
||||
if isinstance(value, list): |
|
||||
current_value = value + current_value |
|
||||
# a new list: update the dictionary entry |
|
||||
self.table[var] = current_value |
|
||||
else: |
|
||||
current_value.insert(0, value) |
|
||||
|
|
||||
# prepend unique would be ambiguous |
|
||||
def append_unique(self, var, value): |
|
||||
current_value = self._get_list_value_for_modification(var) |
|
||||
|
|
||||
if isinstance(value, list): |
|
||||
for value_item in value: |
|
||||
if value_item not in current_value: |
|
||||
current_value.append(value_item) |
|
||||
else: |
|
||||
if value not in current_value: |
|
||||
current_value.append(value) |
|
||||
|
|
||||
def get_merged_dict(self): |
|
||||
"""compute a merged table""" |
|
||||
table_list = [] |
|
||||
env = self |
|
||||
while 1: |
|
||||
table_list.insert(0, env.table) |
|
||||
try: env = env.parent |
|
||||
except AttributeError: break |
|
||||
merged_table = {} |
|
||||
for table in table_list: |
|
||||
merged_table.update(table) |
|
||||
return merged_table |
|
||||
|
|
||||
def store(self, filename): |
|
||||
"Write the variables into a file" |
|
||||
file = open(filename, 'w') |
|
||||
merged_table = self.get_merged_dict() |
|
||||
keys = list(merged_table.keys()) |
|
||||
keys.sort() |
|
||||
for k in keys: file.write('%s = %r\n' % (k, merged_table[k])) |
|
||||
file.close() |
|
||||
|
|
||||
def load(self, filename): |
|
||||
"Retrieve the variables from a file" |
|
||||
tbl = self.table |
|
||||
code = Utils.readf(filename) |
|
||||
for m in re_imp.finditer(code): |
|
||||
g = m.group |
|
||||
tbl[g(2)] = eval(g(3)) |
|
||||
Logs.debug('env: %s', self.table) |
|
||||
|
|
||||
def get_destdir(self): |
|
||||
"return the destdir, useful for installing" |
|
||||
if self.__getitem__('NOINSTALL'): return '' |
|
||||
return Options.options.destdir |
|
||||
|
|
||||
def update(self, d): |
|
||||
for k, v in d.iteritems(): |
|
||||
self[k] = v |
|
||||
|
|
||||
|
|
||||
def __getattr__(self, name): |
|
||||
if name in self.__slots__: |
|
||||
return object.__getattr__(self, name) |
|
||||
else: |
|
||||
return self[name] |
|
||||
|
|
||||
def __setattr__(self, name, value): |
|
||||
if name in self.__slots__: |
|
||||
object.__setattr__(self, name, value) |
|
||||
else: |
|
||||
self[name] = value |
|
||||
|
|
||||
def __delattr__(self, name): |
|
||||
if name in self.__slots__: |
|
||||
object.__delattr__(self, name) |
|
||||
else: |
|
||||
del self[name] |
|
||||
|
|
||||
@ -1,134 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
import ansiterm |
|
||||
import os, re, logging, traceback, sys |
|
||||
from Constants import * |
|
||||
|
|
||||
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 = False |
|
||||
term = os.environ.get('TERM', 'dumb') |
|
||||
if not term in ['dumb', 'emacs']: |
|
||||
try: |
|
||||
got_tty = sys.stderr.isatty() or (sys.platform == 'win32' and term in ['xterm', 'msys']) |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
|
|
||||
import Utils |
|
||||
|
|
||||
if not got_tty or 'NOCOLOR' in os.environ: |
|
||||
colors_lst['USE'] = False |
|
||||
|
|
||||
# test |
|
||||
#if sys.platform == 'win32': |
|
||||
# colors_lst['USE'] = True |
|
||||
|
|
||||
def get_color(cl): |
|
||||
if not colors_lst['USE']: return '' |
|
||||
return colors_lst.get(cl, '') |
|
||||
|
|
||||
class foo(object): |
|
||||
def __getattr__(self, a): |
|
||||
return get_color(a) |
|
||||
def __call__(self, a): |
|
||||
return get_color(a) |
|
||||
|
|
||||
colors = foo() |
|
||||
|
|
||||
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 |
|
||||
|
|
||||
zone = '' |
|
||||
m = re_log.match(rec.msg) |
|
||||
if m: |
|
||||
zone = 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: |
|
||||
return '%s%s%s' % (rec.c1, rec.msg.decode('utf-8'), rec.c2) |
|
||||
except: |
|
||||
return rec.c1+rec.msg+rec.c2 |
|
||||
return logging.Formatter.format(self, rec) |
|
||||
|
|
||||
def debug(*k, **kw): |
|
||||
if verbose: |
|
||||
k = list(k) |
|
||||
k[0] = k[0].replace('\n', ' ') |
|
||||
logging.debug(*k, **kw) |
|
||||
|
|
||||
def error(*k, **kw): |
|
||||
logging.error(*k, **kw) |
|
||||
if verbose > 1: |
|
||||
if isinstance(k[0], Utils.WafError): |
|
||||
st = k[0].stack |
|
||||
else: |
|
||||
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: logging.error("\n".join(buf)) |
|
||||
|
|
||||
warn = logging.warn |
|
||||
info = logging.info |
|
||||
|
|
||||
def init_log(): |
|
||||
log = logging.getLogger() |
|
||||
log.handlers = [] |
|
||||
log.filters = [] |
|
||||
hdlr = logging.StreamHandler() |
|
||||
hdlr.setFormatter(formatter()) |
|
||||
log.addHandler(hdlr) |
|
||||
log.addFilter(log_filter()) |
|
||||
log.setLevel(logging.DEBUG) |
|
||||
|
|
||||
# may be initialized more than once |
|
||||
init_log() |
|
||||
|
|
||||
@ -1,693 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
""" |
|
||||
Node: filesystem structure, contains lists of nodes |
|
||||
|
|
||||
IMPORTANT: |
|
||||
1. Each file/folder is represented by exactly one node. |
|
||||
|
|
||||
2. Most would-be class properties are stored in Build: nodes to depend on, signature, flags, .. |
|
||||
unused class members increase the .wafpickle file size sensibly with lots of objects. |
|
||||
|
|
||||
3. The build is launched from the top of the build dir (for example, in _build_/). |
|
||||
|
|
||||
4. Node should not be instantiated directly. |
|
||||
Each instance of Build.BuildContext has a Node subclass. |
|
||||
(aka: 'Nodu', see BuildContext initializer) |
|
||||
The BuildContext is referenced here as self.__class__.bld |
|
||||
Its Node class is referenced here as self.__class__ |
|
||||
|
|
||||
The public and advertised apis are the following: |
|
||||
${TGT} -> dir/to/file.ext |
|
||||
${TGT[0].base()} -> dir/to/file |
|
||||
${TGT[0].dir(env)} -> dir/to |
|
||||
${TGT[0].file()} -> file.ext |
|
||||
${TGT[0].file_base()} -> file |
|
||||
${TGT[0].suffix()} -> .ext |
|
||||
${TGT[0].abspath(env)} -> /path/to/dir/to/file.ext |
|
||||
|
|
||||
""" |
|
||||
|
|
||||
import os, sys, fnmatch, re, stat |
|
||||
import Utils, Constants |
|
||||
|
|
||||
UNDEFINED = 0 |
|
||||
DIR = 1 |
|
||||
FILE = 2 |
|
||||
BUILD = 3 |
|
||||
|
|
||||
type_to_string = {UNDEFINED: "unk", DIR: "dir", FILE: "src", BUILD: "bld"} |
|
||||
|
|
||||
# These fnmatch expressions are used by default to prune the directory tree |
|
||||
# while doing the recursive traversal in the find_iter method of the Node class. |
|
||||
prune_pats = '.git .bzr .hg .svn _MTN _darcs CVS SCCS'.split() |
|
||||
|
|
||||
# These fnmatch expressions are used by default to exclude files and dirs |
|
||||
# while doing the recursive traversal in the find_iter method of the Node class. |
|
||||
exclude_pats = prune_pats + '*~ #*# .#* %*% ._* .gitignore .cvsignore vssver.scc .DS_Store'.split() |
|
||||
|
|
||||
# These Utils.jar_regexp expressions are used by default to exclude files and dirs and also prune the directory tree |
|
||||
# while doing the recursive traversal in the ant_glob method of the Node class. |
|
||||
exclude_regs = ''' |
|
||||
**/*~ |
|
||||
**/#*# |
|
||||
**/.#* |
|
||||
**/%*% |
|
||||
**/._* |
|
||||
**/CVS |
|
||||
**/CVS/** |
|
||||
**/.cvsignore |
|
||||
**/SCCS |
|
||||
**/SCCS/** |
|
||||
**/vssver.scc |
|
||||
**/.svn |
|
||||
**/.svn/** |
|
||||
**/.git |
|
||||
**/.git/** |
|
||||
**/.gitignore |
|
||||
**/.bzr |
|
||||
**/.bzr/** |
|
||||
**/.hg |
|
||||
**/.hg/** |
|
||||
**/_MTN |
|
||||
**/_MTN/** |
|
||||
**/_darcs |
|
||||
**/_darcs/** |
|
||||
**/.DS_Store''' |
|
||||
|
|
||||
class Node(object): |
|
||||
__slots__ = ("name", "parent", "id", "childs") |
|
||||
def __init__(self, name, parent, node_type = UNDEFINED): |
|
||||
self.name = name |
|
||||
self.parent = parent |
|
||||
|
|
||||
# assumption: one build object at a time |
|
||||
self.__class__.bld.id_nodes += 4 |
|
||||
self.id = self.__class__.bld.id_nodes + node_type |
|
||||
|
|
||||
if node_type == DIR: self.childs = {} |
|
||||
|
|
||||
# We do not want to add another type attribute (memory) |
|
||||
# use the id to find out: type = id & 3 |
|
||||
# for setting: new type = type + x - type & 3 |
|
||||
|
|
||||
if parent and name in parent.childs: |
|
||||
raise Utils.WafError('node %s exists in the parent files %r already' % (name, parent)) |
|
||||
|
|
||||
if parent: parent.childs[name] = self |
|
||||
|
|
||||
def __setstate__(self, data): |
|
||||
if len(data) == 4: |
|
||||
(self.parent, self.name, self.id, self.childs) = data |
|
||||
else: |
|
||||
(self.parent, self.name, self.id) = data |
|
||||
|
|
||||
def __getstate__(self): |
|
||||
if getattr(self, 'childs', None) is None: |
|
||||
return (self.parent, self.name, self.id) |
|
||||
else: |
|
||||
return (self.parent, self.name, self.id, self.childs) |
|
||||
|
|
||||
def __str__(self): |
|
||||
if not self.parent: return '' |
|
||||
return "%s://%s" % (type_to_string[self.id & 3], self.abspath()) |
|
||||
|
|
||||
def __repr__(self): |
|
||||
return self.__str__() |
|
||||
|
|
||||
def __hash__(self): |
|
||||
"expensive, make certain it is not used" |
|
||||
raise Utils.WafError('nodes, you are doing it wrong') |
|
||||
|
|
||||
def __copy__(self): |
|
||||
"nodes are not supposed to be copied" |
|
||||
raise Utils.WafError('nodes are not supposed to be cloned') |
|
||||
|
|
||||
def get_type(self): |
|
||||
return self.id & 3 |
|
||||
|
|
||||
def set_type(self, t): |
|
||||
"dangerous, you are not supposed to use this" |
|
||||
self.id = self.id + t - self.id & 3 |
|
||||
|
|
||||
def dirs(self): |
|
||||
return [x for x in self.childs.values() if x.id & 3 == DIR] |
|
||||
|
|
||||
def files(self): |
|
||||
return [x for x in self.childs.values() if x.id & 3 == FILE] |
|
||||
|
|
||||
def get_dir(self, name, default=None): |
|
||||
node = self.childs.get(name, None) |
|
||||
if not node or node.id & 3 != DIR: return default |
|
||||
return node |
|
||||
|
|
||||
def get_file(self, name, default=None): |
|
||||
node = self.childs.get(name, None) |
|
||||
if not node or node.id & 3 != FILE: return default |
|
||||
return node |
|
||||
|
|
||||
def get_build(self, name, default=None): |
|
||||
node = self.childs.get(name, None) |
|
||||
if not node or node.id & 3 != BUILD: return default |
|
||||
return node |
|
||||
|
|
||||
def find_resource(self, lst): |
|
||||
"Find an existing input file: either a build node declared previously or a source node" |
|
||||
if isinstance(lst, str): |
|
||||
lst = Utils.split_path(lst) |
|
||||
|
|
||||
if len(lst) == 1: |
|
||||
parent = self |
|
||||
else: |
|
||||
parent = self.find_dir(lst[:-1]) |
|
||||
if not parent: return None |
|
||||
self.__class__.bld.rescan(parent) |
|
||||
|
|
||||
name = lst[-1] |
|
||||
node = parent.childs.get(name, None) |
|
||||
if node: |
|
||||
tp = node.id & 3 |
|
||||
if tp == FILE or tp == BUILD: |
|
||||
return node |
|
||||
else: |
|
||||
return None |
|
||||
|
|
||||
tree = self.__class__.bld |
|
||||
if not name in tree.cache_dir_contents[parent.id]: |
|
||||
return None |
|
||||
|
|
||||
path = parent.abspath() + os.sep + name |
|
||||
try: |
|
||||
st = Utils.h_file(path) |
|
||||
except IOError: |
|
||||
return None |
|
||||
|
|
||||
child = self.__class__(name, parent, FILE) |
|
||||
tree.node_sigs[0][child.id] = st |
|
||||
return child |
|
||||
|
|
||||
def find_or_declare(self, lst): |
|
||||
"Used for declaring a build node representing a file being built" |
|
||||
if isinstance(lst, str): |
|
||||
lst = Utils.split_path(lst) |
|
||||
|
|
||||
if len(lst) == 1: |
|
||||
parent = self |
|
||||
else: |
|
||||
parent = self.find_dir(lst[:-1]) |
|
||||
if not parent: return None |
|
||||
self.__class__.bld.rescan(parent) |
|
||||
|
|
||||
name = lst[-1] |
|
||||
node = parent.childs.get(name, None) |
|
||||
if node: |
|
||||
tp = node.id & 3 |
|
||||
if tp != BUILD: |
|
||||
raise Utils.WafError('find_or_declare cannot return a build node (build files in the source directory %r?)' % lst) |
|
||||
return node |
|
||||
node = self.__class__(name, parent, BUILD) |
|
||||
return node |
|
||||
|
|
||||
def find_dir(self, lst): |
|
||||
"search a folder in the filesystem" |
|
||||
|
|
||||
if isinstance(lst, str): |
|
||||
lst = Utils.split_path(lst) |
|
||||
|
|
||||
current = self |
|
||||
for name in lst: |
|
||||
self.__class__.bld.rescan(current) |
|
||||
prev = current |
|
||||
|
|
||||
if not current.parent and name == current.name: |
|
||||
continue |
|
||||
elif not name: |
|
||||
continue |
|
||||
elif name == '.': |
|
||||
continue |
|
||||
elif name == '..': |
|
||||
current = current.parent or current |
|
||||
else: |
|
||||
current = prev.childs.get(name, None) |
|
||||
if current is None: |
|
||||
dir_cont = self.__class__.bld.cache_dir_contents |
|
||||
if prev.id in dir_cont and name in dir_cont[prev.id]: |
|
||||
if not prev.name: |
|
||||
if os.sep == '/': |
|
||||
# cygwin //machine/share |
|
||||
dirname = os.sep + name |
|
||||
else: |
|
||||
# windows c: |
|
||||
dirname = name |
|
||||
else: |
|
||||
# regular path |
|
||||
dirname = prev.abspath() + os.sep + name |
|
||||
if not os.path.isdir(dirname): |
|
||||
return None |
|
||||
current = self.__class__(name, prev, DIR) |
|
||||
elif (not prev.name and len(name) == 2 and name[1] == ':') or name.startswith('\\\\'): |
|
||||
# drive letter or \\ path for windows |
|
||||
current = self.__class__(name, prev, DIR) |
|
||||
else: |
|
||||
return None |
|
||||
else: |
|
||||
if current.id & 3 != DIR: |
|
||||
return None |
|
||||
return current |
|
||||
|
|
||||
def ensure_dir_node_from_path(self, lst): |
|
||||
"used very rarely, force the construction of a branch of node instance for representing folders" |
|
||||
|
|
||||
if isinstance(lst, str): |
|
||||
lst = Utils.split_path(lst) |
|
||||
|
|
||||
current = self |
|
||||
for name in lst: |
|
||||
if not name: |
|
||||
continue |
|
||||
elif name == '.': |
|
||||
continue |
|
||||
elif name == '..': |
|
||||
current = current.parent or current |
|
||||
else: |
|
||||
prev = current |
|
||||
current = prev.childs.get(name, None) |
|
||||
if current is None: |
|
||||
current = self.__class__(name, prev, DIR) |
|
||||
return current |
|
||||
|
|
||||
def exclusive_build_node(self, path): |
|
||||
""" |
|
||||
create a hierarchy in the build dir (no source folders) for ill-behaving compilers |
|
||||
the node is not hashed, so you must do it manually |
|
||||
|
|
||||
after declaring such a node, find_dir and find_resource should work as expected |
|
||||
""" |
|
||||
lst = Utils.split_path(path) |
|
||||
name = lst[-1] |
|
||||
if len(lst) > 1: |
|
||||
parent = None |
|
||||
try: |
|
||||
parent = self.find_dir(lst[:-1]) |
|
||||
except OSError: |
|
||||
pass |
|
||||
if not parent: |
|
||||
parent = self.ensure_dir_node_from_path(lst[:-1]) |
|
||||
self.__class__.bld.rescan(parent) |
|
||||
else: |
|
||||
try: |
|
||||
self.__class__.bld.rescan(parent) |
|
||||
except OSError: |
|
||||
pass |
|
||||
else: |
|
||||
parent = self |
|
||||
|
|
||||
node = parent.childs.get(name, None) |
|
||||
if not node: |
|
||||
node = self.__class__(name, parent, BUILD) |
|
||||
|
|
||||
return node |
|
||||
|
|
||||
def path_to_parent(self, parent): |
|
||||
"path relative to a direct ancestor, as string" |
|
||||
lst = [] |
|
||||
p = self |
|
||||
h1 = parent.height() |
|
||||
h2 = p.height() |
|
||||
while h2 > h1: |
|
||||
h2 -= 1 |
|
||||
lst.append(p.name) |
|
||||
p = p.parent |
|
||||
if lst: |
|
||||
lst.reverse() |
|
||||
ret = os.path.join(*lst) |
|
||||
else: |
|
||||
ret = '' |
|
||||
return ret |
|
||||
|
|
||||
def find_ancestor(self, node): |
|
||||
"find a common ancestor for two nodes - for the shortest path in hierarchy" |
|
||||
dist = self.height() - node.height() |
|
||||
if dist < 0: return node.find_ancestor(self) |
|
||||
# now the real code |
|
||||
cand = self |
|
||||
while dist > 0: |
|
||||
cand = cand.parent |
|
||||
dist -= 1 |
|
||||
if cand == node: return cand |
|
||||
cursor = node |
|
||||
while cand.parent: |
|
||||
cand = cand.parent |
|
||||
cursor = cursor.parent |
|
||||
if cand == cursor: return cand |
|
||||
|
|
||||
def relpath_gen(self, from_node): |
|
||||
"string representing a relative path between self to another node" |
|
||||
|
|
||||
if self == from_node: return '.' |
|
||||
if from_node.parent == self: return '..' |
|
||||
|
|
||||
# up_path is '../../../' and down_path is 'dir/subdir/subdir/file' |
|
||||
ancestor = self.find_ancestor(from_node) |
|
||||
lst = [] |
|
||||
cand = self |
|
||||
while not cand.id == ancestor.id: |
|
||||
lst.append(cand.name) |
|
||||
cand = cand.parent |
|
||||
cand = from_node |
|
||||
while not cand.id == ancestor.id: |
|
||||
lst.append('..') |
|
||||
cand = cand.parent |
|
||||
lst.reverse() |
|
||||
return os.sep.join(lst) |
|
||||
|
|
||||
def nice_path(self, env=None): |
|
||||
"printed in the console, open files easily from the launch directory" |
|
||||
tree = self.__class__.bld |
|
||||
ln = tree.launch_node() |
|
||||
|
|
||||
if self.id & 3 == FILE: return self.relpath_gen(ln) |
|
||||
else: return os.path.join(tree.bldnode.relpath_gen(ln), env.variant(), self.relpath_gen(tree.srcnode)) |
|
||||
|
|
||||
def is_child_of(self, node): |
|
||||
"does this node belong to the subtree node" |
|
||||
p = self |
|
||||
diff = self.height() - node.height() |
|
||||
while diff > 0: |
|
||||
diff -= 1 |
|
||||
p = p.parent |
|
||||
return p.id == node.id |
|
||||
|
|
||||
def variant(self, env): |
|
||||
"variant, or output directory for this node, a source has for variant 0" |
|
||||
if not env: return 0 |
|
||||
elif self.id & 3 == FILE: return 0 |
|
||||
else: return env.variant() |
|
||||
|
|
||||
def height(self): |
|
||||
"amount of parents" |
|
||||
# README a cache can be added here if necessary |
|
||||
d = self |
|
||||
val = -1 |
|
||||
while d: |
|
||||
d = d.parent |
|
||||
val += 1 |
|
||||
return val |
|
||||
|
|
||||
# helpers for building things |
|
||||
|
|
||||
def abspath(self, env=None): |
|
||||
""" |
|
||||
absolute path |
|
||||
@param env [Environment]: |
|
||||
* obligatory for build nodes: build/variant/src/dir/bar.o |
|
||||
* optional for dirs: get either src/dir or build/variant/src/dir |
|
||||
* excluded for source nodes: src/dir/bar.c |
|
||||
|
|
||||
Instead of computing the absolute path each time again, |
|
||||
store the already-computed absolute paths in one of (variants+1) dictionaries: |
|
||||
bld.cache_node_abspath[0] holds absolute paths for source nodes. |
|
||||
bld.cache_node_abspath[variant] holds the absolute path for the build nodes |
|
||||
which reside in the variant given by env. |
|
||||
""" |
|
||||
## absolute path - hot zone, so do not touch |
|
||||
|
|
||||
# less expensive |
|
||||
variant = (env and (self.id & 3 != FILE) and env.variant()) or 0 |
|
||||
|
|
||||
ret = self.__class__.bld.cache_node_abspath[variant].get(self.id, None) |
|
||||
if ret: return ret |
|
||||
|
|
||||
if not variant: |
|
||||
# source directory |
|
||||
if not self.parent: |
|
||||
val = os.sep == '/' and os.sep or '' |
|
||||
elif not self.parent.name: # root |
|
||||
val = (os.sep == '/' and os.sep or '') + self.name |
|
||||
else: |
|
||||
val = self.parent.abspath() + os.sep + self.name |
|
||||
else: |
|
||||
# build directory |
|
||||
val = os.sep.join((self.__class__.bld.bldnode.abspath(), variant, self.path_to_parent(self.__class__.bld.srcnode))) |
|
||||
self.__class__.bld.cache_node_abspath[variant][self.id] = val |
|
||||
return val |
|
||||
|
|
||||
def change_ext(self, ext): |
|
||||
"node of the same path, but with a different extension - hot zone so do not touch" |
|
||||
name = self.name |
|
||||
k = name.rfind('.') |
|
||||
if k >= 0: |
|
||||
name = name[:k] + ext |
|
||||
else: |
|
||||
name = name + ext |
|
||||
|
|
||||
return self.parent.find_or_declare([name]) |
|
||||
|
|
||||
def src_dir(self, env): |
|
||||
"src path without the file name" |
|
||||
return self.parent.srcpath(env) |
|
||||
|
|
||||
def bld_dir(self, env): |
|
||||
"build path without the file name" |
|
||||
return self.parent.bldpath(env) |
|
||||
|
|
||||
def bld_base(self, env): |
|
||||
"build path without the extension: src/dir/foo(.cpp)" |
|
||||
s = os.path.splitext(self.name)[0] |
|
||||
return os.path.join(self.bld_dir(env), s) |
|
||||
|
|
||||
def bldpath(self, env=None): |
|
||||
"path seen from the build dir default/src/foo.cpp" |
|
||||
if self.id & 3 == FILE: |
|
||||
return self.relpath_gen(self.__class__.bld.bldnode) |
|
||||
p = self.path_to_parent(self.__class__.bld.srcnode) |
|
||||
if p is not '': |
|
||||
return env.variant() + os.sep + p |
|
||||
return env.variant() |
|
||||
|
|
||||
def srcpath(self, env=None): |
|
||||
"path in the srcdir from the build dir ../src/foo.cpp" |
|
||||
if self.id & 3 == BUILD: |
|
||||
return self.bldpath(env) |
|
||||
return self.relpath_gen(self.__class__.bld.bldnode) |
|
||||
|
|
||||
def read(self, env): |
|
||||
"get the contents of a file, it is not used anywhere for the moment" |
|
||||
return Utils.readf(self.abspath(env)) |
|
||||
|
|
||||
def dir(self, env): |
|
||||
"scons-like" |
|
||||
return self.parent.abspath(env) |
|
||||
|
|
||||
def file(self): |
|
||||
"scons-like" |
|
||||
return self.name |
|
||||
|
|
||||
def file_base(self): |
|
||||
"scons-like" |
|
||||
return os.path.splitext(self.name)[0] |
|
||||
|
|
||||
def suffix(self): |
|
||||
"scons-like - hot zone so do not touch" |
|
||||
k = max(0, self.name.rfind('.')) |
|
||||
return self.name[k:] |
|
||||
|
|
||||
def find_iter_impl(self, src=True, bld=True, dir=True, accept_name=None, is_prune=None, maxdepth=25): |
|
||||
"""find nodes in the filesystem hierarchy, try to instanciate the nodes passively; same gotcha as ant_glob""" |
|
||||
bld_ctx = self.__class__.bld |
|
||||
bld_ctx.rescan(self) |
|
||||
for name in bld_ctx.cache_dir_contents[self.id]: |
|
||||
if accept_name(self, name): |
|
||||
node = self.find_resource(name) |
|
||||
if node: |
|
||||
if src and node.id & 3 == FILE: |
|
||||
yield node |
|
||||
else: |
|
||||
node = self.find_dir(name) |
|
||||
if node and node.id != bld_ctx.bldnode.id: |
|
||||
if dir: |
|
||||
yield node |
|
||||
if not is_prune(self, name): |
|
||||
if maxdepth: |
|
||||
for k in node.find_iter_impl(src, bld, dir, accept_name, is_prune, maxdepth=maxdepth - 1): |
|
||||
yield k |
|
||||
else: |
|
||||
if not is_prune(self, name): |
|
||||
node = self.find_resource(name) |
|
||||
if not node: |
|
||||
# not a file, it is a dir |
|
||||
node = self.find_dir(name) |
|
||||
if node and node.id != bld_ctx.bldnode.id: |
|
||||
if maxdepth: |
|
||||
for k in node.find_iter_impl(src, bld, dir, accept_name, is_prune, maxdepth=maxdepth - 1): |
|
||||
yield k |
|
||||
|
|
||||
if bld: |
|
||||
for node in self.childs.values(): |
|
||||
if node.id == bld_ctx.bldnode.id: |
|
||||
continue |
|
||||
if node.id & 3 == BUILD: |
|
||||
if accept_name(self, node.name): |
|
||||
yield node |
|
||||
raise StopIteration |
|
||||
|
|
||||
def find_iter(self, in_pat=['*'], ex_pat=exclude_pats, prune_pat=prune_pats, src=True, bld=True, dir=False, maxdepth=25, flat=False): |
|
||||
"""find nodes recursively, this returns everything but folders by default; same gotcha as ant_glob""" |
|
||||
|
|
||||
if not (src or bld or dir): |
|
||||
raise StopIteration |
|
||||
|
|
||||
if self.id & 3 != DIR: |
|
||||
raise StopIteration |
|
||||
|
|
||||
in_pat = Utils.to_list(in_pat) |
|
||||
ex_pat = Utils.to_list(ex_pat) |
|
||||
prune_pat = Utils.to_list(prune_pat) |
|
||||
|
|
||||
def accept_name(node, name): |
|
||||
for pat in ex_pat: |
|
||||
if fnmatch.fnmatchcase(name, pat): |
|
||||
return False |
|
||||
for pat in in_pat: |
|
||||
if fnmatch.fnmatchcase(name, pat): |
|
||||
return True |
|
||||
return False |
|
||||
|
|
||||
def is_prune(node, name): |
|
||||
for pat in prune_pat: |
|
||||
if fnmatch.fnmatchcase(name, pat): |
|
||||
return True |
|
||||
return False |
|
||||
|
|
||||
ret = self.find_iter_impl(src, bld, dir, accept_name, is_prune, maxdepth=maxdepth) |
|
||||
if flat: |
|
||||
return " ".join([x.relpath_gen(self) for x in ret]) |
|
||||
|
|
||||
return ret |
|
||||
|
|
||||
def ant_glob(self, *k, **kw): |
|
||||
""" |
|
||||
known gotcha: will enumerate the files, but only if the folder exists in the source directory |
|
||||
""" |
|
||||
|
|
||||
src=kw.get('src', 1) |
|
||||
bld=kw.get('bld', 0) |
|
||||
dir=kw.get('dir', 0) |
|
||||
excl = kw.get('excl', exclude_regs) |
|
||||
incl = k and k[0] or kw.get('incl', '**') |
|
||||
|
|
||||
def to_pat(s): |
|
||||
lst = Utils.to_list(s) |
|
||||
ret = [] |
|
||||
for x in lst: |
|
||||
x = x.replace('//', '/') |
|
||||
if x.endswith('/'): |
|
||||
x += '**' |
|
||||
lst2 = x.split('/') |
|
||||
accu = [] |
|
||||
for k in lst2: |
|
||||
if k == '**': |
|
||||
accu.append(k) |
|
||||
else: |
|
||||
k = k.replace('.', '[.]').replace('*', '.*').replace('?', '.') |
|
||||
k = '^%s$' % k |
|
||||
#print "pattern", k |
|
||||
accu.append(re.compile(k)) |
|
||||
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] |
|
||||
|
|
||||
def ant_iter(nodi, maxdepth=25, pats=[]): |
|
||||
nodi.__class__.bld.rescan(nodi) |
|
||||
for name in nodi.__class__.bld.cache_dir_contents[nodi.id]: |
|
||||
npats = accept(name, pats) |
|
||||
if npats and npats[0]: |
|
||||
accepted = [] in npats[0] |
|
||||
#print accepted, nodi, name |
|
||||
|
|
||||
node = nodi.find_resource(name) |
|
||||
if node and accepted: |
|
||||
if src and node.id & 3 == FILE: |
|
||||
yield node |
|
||||
else: |
|
||||
node = nodi.find_dir(name) |
|
||||
if node and node.id != nodi.__class__.bld.bldnode.id: |
|
||||
if accepted and dir: |
|
||||
yield node |
|
||||
if maxdepth: |
|
||||
for k in ant_iter(node, maxdepth=maxdepth - 1, pats=npats): |
|
||||
yield k |
|
||||
if bld: |
|
||||
for node in nodi.childs.values(): |
|
||||
if node.id == nodi.__class__.bld.bldnode.id: |
|
||||
continue |
|
||||
if node.id & 3 == BUILD: |
|
||||
npats = accept(node.name, pats) |
|
||||
if npats and npats[0] and [] in npats[0]: |
|
||||
yield node |
|
||||
raise StopIteration |
|
||||
|
|
||||
ret = [x for x in ant_iter(self, pats=[to_pat(incl), to_pat(excl)])] |
|
||||
|
|
||||
if kw.get('flat', True): |
|
||||
return " ".join([x.relpath_gen(self) for x in ret]) |
|
||||
|
|
||||
return ret |
|
||||
|
|
||||
def update_build_dir(self, env=None): |
|
||||
|
|
||||
if not env: |
|
||||
for env in bld.all_envs: |
|
||||
self.update_build_dir(env) |
|
||||
return |
|
||||
|
|
||||
path = self.abspath(env) |
|
||||
|
|
||||
lst = Utils.listdir(path) |
|
||||
try: |
|
||||
self.__class__.bld.cache_dir_contents[self.id].update(lst) |
|
||||
except KeyError: |
|
||||
self.__class__.bld.cache_dir_contents[self.id] = set(lst) |
|
||||
self.__class__.bld.cache_scanned_folders[self.id] = True |
|
||||
|
|
||||
for k in lst: |
|
||||
npath = path + os.sep + k |
|
||||
st = os.stat(npath) |
|
||||
if stat.S_ISREG(st[stat.ST_MODE]): |
|
||||
ick = self.find_or_declare(k) |
|
||||
if not (ick.id in self.__class__.bld.node_sigs[env.variant()]): |
|
||||
self.__class__.bld.node_sigs[env.variant()][ick.id] = Constants.SIG_NIL |
|
||||
elif stat.S_ISDIR(st[stat.ST_MODE]): |
|
||||
child = self.find_dir(k) |
|
||||
if not child: |
|
||||
child = self.ensure_dir_node_from_path(k) |
|
||||
child.update_build_dir(env) |
|
||||
|
|
||||
|
|
||||
class Nodu(Node): |
|
||||
pass |
|
||||
|
|
||||
@ -1,279 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Scott Newton, 2005 (scottn) |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
|
|
||||
"Custom command-line options" |
|
||||
|
|
||||
import os, sys, imp, types, tempfile, optparse |
|
||||
import Logs, Utils |
|
||||
from Constants import * |
|
||||
|
|
||||
cmds = 'distclean configure build install clean uninstall check dist distcheck'.split() |
|
||||
|
|
||||
# TODO remove in waf 1.6 the following two |
|
||||
commands = {} |
|
||||
is_install = False |
|
||||
|
|
||||
options = {} |
|
||||
arg_line = [] |
|
||||
launch_dir = '' |
|
||||
tooldir = '' |
|
||||
lockfile = os.environ.get('WAFLOCK', '.lock-wscript') |
|
||||
try: cache_global = os.path.abspath(os.environ['WAFCACHE']) |
|
||||
except KeyError: cache_global = '' |
|
||||
platform = Utils.unversioned_sys_platform() |
|
||||
conf_file = 'conf-runs-%s-%d.pickle' % (platform, ABI) |
|
||||
|
|
||||
remote_repo = ['http://waf.googlecode.com/svn/'] |
|
||||
"""remote directory for the plugins""" |
|
||||
|
|
||||
|
|
||||
# Such a command-line should work: JOBS=4 PREFIX=/opt/ DESTDIR=/tmp/ahoj/ waf configure |
|
||||
default_prefix = os.environ.get('PREFIX') |
|
||||
if not default_prefix: |
|
||||
if platform == 'win32': default_prefix = tempfile.gettempdir() |
|
||||
else: default_prefix = '/usr/local/' |
|
||||
|
|
||||
default_jobs = os.environ.get('JOBS', -1) |
|
||||
if default_jobs < 1: |
|
||||
try: |
|
||||
if 'SC_NPROCESSORS_ONLN' in os.sysconf_names: |
|
||||
default_jobs = os.sysconf('SC_NPROCESSORS_ONLN') |
|
||||
else: |
|
||||
default_jobs = int(Utils.cmd_output(['sysctl', '-n', 'hw.ncpu'])) |
|
||||
except: |
|
||||
if os.name == 'java': # platform.system() == 'Java' |
|
||||
from java.lang import Runtime |
|
||||
default_jobs = Runtime.getRuntime().availableProcessors() |
|
||||
else: |
|
||||
# environment var defined on win32 |
|
||||
default_jobs = int(os.environ.get('NUMBER_OF_PROCESSORS', 1)) |
|
||||
|
|
||||
default_destdir = os.environ.get('DESTDIR', '') |
|
||||
|
|
||||
def get_usage(self): |
|
||||
cmds_str = [] |
|
||||
module = Utils.g_module |
|
||||
if module: |
|
||||
# create the help messages for commands |
|
||||
tbl = module.__dict__ |
|
||||
keys = list(tbl.keys()) |
|
||||
keys.sort() |
|
||||
|
|
||||
if 'build' in tbl: |
|
||||
if not module.build.__doc__: |
|
||||
module.build.__doc__ = 'builds the project' |
|
||||
if 'configure' in tbl: |
|
||||
if not module.configure.__doc__: |
|
||||
module.configure.__doc__ = 'configures the project' |
|
||||
|
|
||||
ban = ['set_options', 'init', 'shutdown'] |
|
||||
|
|
||||
optlst = [x for x in keys if not x in ban |
|
||||
and type(tbl[x]) is type(parse_args_impl) |
|
||||
and tbl[x].__doc__ |
|
||||
and not x.startswith('_')] |
|
||||
|
|
||||
just = max([len(x) for x in optlst]) |
|
||||
|
|
||||
for x in optlst: |
|
||||
cmds_str.append(' %s: %s' % (x.ljust(just), tbl[x].__doc__)) |
|
||||
ret = '\n'.join(cmds_str) |
|
||||
else: |
|
||||
ret = ' '.join(cmds) |
|
||||
return '''waf [command] [options] |
|
||||
|
|
||||
Main commands (example: ./waf build -j4) |
|
||||
%s |
|
||||
''' % ret |
|
||||
|
|
||||
|
|
||||
setattr(optparse.OptionParser, 'get_usage', get_usage) |
|
||||
|
|
||||
def create_parser(module=None): |
|
||||
Logs.debug('options: create_parser is called') |
|
||||
parser = optparse.OptionParser(conflict_handler="resolve", version = 'waf %s (%s)' % (WAFVERSION, WAFREVISION)) |
|
||||
|
|
||||
parser.formatter.width = Utils.get_term_cols() |
|
||||
p = parser.add_option |
|
||||
|
|
||||
p('-j', '--jobs', |
|
||||
type = 'int', |
|
||||
default = default_jobs, |
|
||||
help = 'amount of parallel jobs (%r)' % default_jobs, |
|
||||
dest = 'jobs') |
|
||||
|
|
||||
p('-k', '--keep', |
|
||||
action = 'store_true', |
|
||||
default = False, |
|
||||
help = 'keep running happily on independent task groups', |
|
||||
dest = 'keep') |
|
||||
|
|
||||
p('-v', '--verbose', |
|
||||
action = 'count', |
|
||||
default = 0, |
|
||||
help = 'verbosity level -v -vv or -vvv [default: 0]', |
|
||||
dest = 'verbose') |
|
||||
|
|
||||
p('--nocache', |
|
||||
action = 'store_true', |
|
||||
default = False, |
|
||||
help = 'ignore the WAFCACHE (if set)', |
|
||||
dest = 'nocache') |
|
||||
|
|
||||
p('--zones', |
|
||||
action = 'store', |
|
||||
default = '', |
|
||||
help = 'debugging zones (task_gen, deps, tasks, etc)', |
|
||||
dest = 'zones') |
|
||||
|
|
||||
p('-p', '--progress', |
|
||||
action = 'count', |
|
||||
default = 0, |
|
||||
help = '-p: progress bar; -pp: ide output', |
|
||||
dest = 'progress_bar') |
|
||||
|
|
||||
p('--targets', |
|
||||
action = 'store', |
|
||||
default = '', |
|
||||
help = 'build given task generators, e.g. "target1,target2"', |
|
||||
dest = 'compile_targets') |
|
||||
|
|
||||
gr = optparse.OptionGroup(parser, 'configuration options') |
|
||||
parser.add_option_group(gr) |
|
||||
gr.add_option('-b', '--blddir', |
|
||||
action = 'store', |
|
||||
default = '', |
|
||||
help = 'build dir for the project (configuration)', |
|
||||
dest = 'blddir') |
|
||||
gr.add_option('-s', '--srcdir', |
|
||||
action = 'store', |
|
||||
default = '', |
|
||||
help = 'src dir for the project (configuration)', |
|
||||
dest = 'srcdir') |
|
||||
gr.add_option('--prefix', |
|
||||
help = 'installation prefix (configuration) [default: %r]' % default_prefix, |
|
||||
default = default_prefix, |
|
||||
dest = 'prefix') |
|
||||
|
|
||||
gr = optparse.OptionGroup(parser, 'installation options') |
|
||||
parser.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', |
|
||||
action = 'store_true', |
|
||||
default = False, |
|
||||
help = 'force file installation', |
|
||||
dest = 'force') |
|
||||
|
|
||||
return parser |
|
||||
|
|
||||
def parse_args_impl(parser, _args=None): |
|
||||
global options, commands, arg_line |
|
||||
(options, args) = parser.parse_args(args=_args) |
|
||||
|
|
||||
arg_line = args |
|
||||
#arg_line = args[:] # copy |
|
||||
|
|
||||
# By default, 'waf' is equivalent to 'waf build' |
|
||||
commands = {} |
|
||||
for var in cmds: commands[var] = 0 |
|
||||
if not args: |
|
||||
commands['build'] = 1 |
|
||||
args.append('build') |
|
||||
|
|
||||
# Parse the command arguments |
|
||||
for arg in args: |
|
||||
commands[arg] = True |
|
||||
|
|
||||
# the check thing depends on the build |
|
||||
if 'check' in args: |
|
||||
idx = args.index('check') |
|
||||
try: |
|
||||
bidx = args.index('build') |
|
||||
if bidx > idx: |
|
||||
raise ValueError('build before check') |
|
||||
except ValueError, e: |
|
||||
args.insert(idx, 'build') |
|
||||
|
|
||||
if args[0] != 'init': |
|
||||
args.insert(0, 'init') |
|
||||
|
|
||||
# TODO -k => -j0 |
|
||||
if options.keep: options.jobs = 1 |
|
||||
if options.jobs < 1: options.jobs = 1 |
|
||||
|
|
||||
if 'install' in sys.argv or 'uninstall' in sys.argv: |
|
||||
# absolute path only if set |
|
||||
options.destdir = options.destdir and os.path.abspath(os.path.expanduser(options.destdir)) |
|
||||
|
|
||||
Logs.verbose = options.verbose |
|
||||
Logs.init_log() |
|
||||
|
|
||||
if options.zones: |
|
||||
Logs.zones = options.zones.split(',') |
|
||||
if not Logs.verbose: Logs.verbose = 1 |
|
||||
elif Logs.verbose > 0: |
|
||||
Logs.zones = ['runner'] |
|
||||
if Logs.verbose > 2: |
|
||||
Logs.zones = ['*'] |
|
||||
|
|
||||
# TODO waf 1.6 |
|
||||
# 1. rename the class to OptionsContext |
|
||||
# 2. instead of a class attribute, use a module (static 'parser') |
|
||||
# 3. parse_args_impl was made in times when we did not know about binding new methods to classes |
|
||||
|
|
||||
class Handler(Utils.Context): |
|
||||
"""loads wscript modules in folders for adding options |
|
||||
This class should be named 'OptionsContext' |
|
||||
A method named 'recurse' is bound when used by the module Scripting""" |
|
||||
|
|
||||
parser = None |
|
||||
# make it possible to access the reference, like Build.bld |
|
||||
|
|
||||
def __init__(self, module=None): |
|
||||
self.parser = create_parser(module) |
|
||||
self.cwd = os.getcwd() |
|
||||
Handler.parser = self |
|
||||
|
|
||||
def add_option(self, *k, **kw): |
|
||||
self.parser.add_option(*k, **kw) |
|
||||
|
|
||||
def add_option_group(self, *k, **kw): |
|
||||
return self.parser.add_option_group(*k, **kw) |
|
||||
|
|
||||
def get_option_group(self, opt_str): |
|
||||
return self.parser.get_option_group(opt_str) |
|
||||
|
|
||||
def sub_options(self, *k, **kw): |
|
||||
if not k: raise Utils.WscriptError('folder expected') |
|
||||
self.recurse(k[0], name='set_options') |
|
||||
|
|
||||
def tool_options(self, *k, **kw): |
|
||||
Utils.python_24_guard() |
|
||||
|
|
||||
if not k[0]: |
|
||||
raise Utils.WscriptError('invalid tool_options call %r %r' % (k, kw)) |
|
||||
tools = Utils.to_list(k[0]) |
|
||||
|
|
||||
# TODO waf 1.6 remove the global variable tooldir |
|
||||
path = Utils.to_list(kw.get('tdir', kw.get('tooldir', tooldir))) |
|
||||
|
|
||||
for tool in tools: |
|
||||
tool = tool.replace('++', 'xx') |
|
||||
if tool == 'java': tool = 'javaw' |
|
||||
if tool.lower() == 'unittest': tool = 'unittestw' |
|
||||
module = Utils.load_tool(tool, path) |
|
||||
try: |
|
||||
fun = module.set_options |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
else: |
|
||||
fun(kw.get('option_group', self)) |
|
||||
|
|
||||
def parse_args(self, args=None): |
|
||||
parse_args_impl(self.parser, args) |
|
||||
|
|
||||
@ -1,229 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005-2008 (ita) |
|
||||
|
|
||||
"Execute the tasks" |
|
||||
|
|
||||
import sys, random, time, threading, traceback |
|
||||
try: from Queue import Queue |
|
||||
except ImportError: from queue import Queue |
|
||||
import Build, Utils, Logs, Options |
|
||||
from Logs import debug, error |
|
||||
from Constants import * |
|
||||
|
|
||||
GAP = 15 |
|
||||
|
|
||||
run_old = threading.Thread.run |
|
||||
def run(*args, **kwargs): |
|
||||
try: |
|
||||
run_old(*args, **kwargs) |
|
||||
except (KeyboardInterrupt, SystemExit): |
|
||||
raise |
|
||||
except: |
|
||||
sys.excepthook(*sys.exc_info()) |
|
||||
threading.Thread.run = run |
|
||||
|
|
||||
class TaskConsumer(threading.Thread): |
|
||||
ready = Queue(0) |
|
||||
consumers = [] |
|
||||
|
|
||||
def __init__(self): |
|
||||
threading.Thread.__init__(self) |
|
||||
self.setDaemon(1) |
|
||||
self.start() |
|
||||
|
|
||||
def run(self): |
|
||||
try: |
|
||||
self.loop() |
|
||||
except: |
|
||||
pass |
|
||||
|
|
||||
def loop(self): |
|
||||
while 1: |
|
||||
tsk = TaskConsumer.ready.get() |
|
||||
m = tsk.master |
|
||||
if m.stop: |
|
||||
m.out.put(tsk) |
|
||||
continue |
|
||||
|
|
||||
try: |
|
||||
tsk.generator.bld.printout(tsk.display()) |
|
||||
if tsk.__class__.stat: ret = tsk.__class__.stat(tsk) |
|
||||
# actual call to task's run() function |
|
||||
else: ret = tsk.call_run() |
|
||||
except Exception, e: |
|
||||
tsk.err_msg = Utils.ex_stack() |
|
||||
tsk.hasrun = EXCEPTION |
|
||||
|
|
||||
# TODO cleanup |
|
||||
m.error_handler(tsk) |
|
||||
m.out.put(tsk) |
|
||||
continue |
|
||||
|
|
||||
if ret: |
|
||||
tsk.err_code = ret |
|
||||
tsk.hasrun = CRASHED |
|
||||
else: |
|
||||
try: |
|
||||
tsk.post_run() |
|
||||
except Utils.WafError: |
|
||||
pass |
|
||||
except Exception: |
|
||||
tsk.err_msg = Utils.ex_stack() |
|
||||
tsk.hasrun = EXCEPTION |
|
||||
else: |
|
||||
tsk.hasrun = SUCCESS |
|
||||
if tsk.hasrun != SUCCESS: |
|
||||
m.error_handler(tsk) |
|
||||
|
|
||||
m.out.put(tsk) |
|
||||
|
|
||||
class Parallel(object): |
|
||||
""" |
|
||||
keep the consumer threads busy, and avoid consuming cpu cycles |
|
||||
when no more tasks can be added (end of the build, etc) |
|
||||
""" |
|
||||
def __init__(self, bld, j=2): |
|
||||
|
|
||||
# number of consumers |
|
||||
self.numjobs = j |
|
||||
|
|
||||
self.manager = bld.task_manager |
|
||||
self.manager.current_group = 0 |
|
||||
|
|
||||
self.total = self.manager.total() |
|
||||
|
|
||||
# tasks waiting to be processed - IMPORTANT |
|
||||
self.outstanding = [] |
|
||||
self.maxjobs = MAXJOBS |
|
||||
|
|
||||
# tasks that are awaiting for another task to complete |
|
||||
self.frozen = [] |
|
||||
|
|
||||
# tasks returned by the consumers |
|
||||
self.out = Queue(0) |
|
||||
|
|
||||
self.count = 0 # tasks not in the producer area |
|
||||
|
|
||||
self.processed = 1 # progress indicator |
|
||||
|
|
||||
self.stop = False # error condition to stop the build |
|
||||
self.error = False # error flag |
|
||||
|
|
||||
def get_next(self): |
|
||||
"override this method to schedule the tasks in a particular order" |
|
||||
if not self.outstanding: |
|
||||
return None |
|
||||
return self.outstanding.pop(0) |
|
||||
|
|
||||
def postpone(self, tsk): |
|
||||
"override this method to schedule the tasks in a particular order" |
|
||||
# TODO consider using a deque instead |
|
||||
if random.randint(0, 1): |
|
||||
self.frozen.insert(0, tsk) |
|
||||
else: |
|
||||
self.frozen.append(tsk) |
|
||||
|
|
||||
def refill_task_list(self): |
|
||||
"called to set the next group of tasks" |
|
||||
|
|
||||
while self.count > self.numjobs + GAP or self.count >= self.maxjobs: |
|
||||
self.get_out() |
|
||||
|
|
||||
while not self.outstanding: |
|
||||
if self.count: |
|
||||
self.get_out() |
|
||||
|
|
||||
if self.frozen: |
|
||||
self.outstanding += self.frozen |
|
||||
self.frozen = [] |
|
||||
elif not self.count: |
|
||||
(jobs, tmp) = self.manager.get_next_set() |
|
||||
if jobs != None: self.maxjobs = jobs |
|
||||
if tmp: self.outstanding += tmp |
|
||||
break |
|
||||
|
|
||||
def get_out(self): |
|
||||
"the tasks that are put to execute are all collected using get_out" |
|
||||
ret = self.out.get() |
|
||||
self.manager.add_finished(ret) |
|
||||
if not self.stop and getattr(ret, 'more_tasks', None): |
|
||||
self.outstanding += ret.more_tasks |
|
||||
self.total += len(ret.more_tasks) |
|
||||
self.count -= 1 |
|
||||
|
|
||||
def error_handler(self, tsk): |
|
||||
"by default, errors make the build stop (not thread safe so be careful)" |
|
||||
if not Options.options.keep: |
|
||||
self.stop = True |
|
||||
self.error = True |
|
||||
|
|
||||
def start(self): |
|
||||
"execute the tasks" |
|
||||
|
|
||||
if TaskConsumer.consumers: |
|
||||
# the worker pool is usually loaded lazily (see below) |
|
||||
# in case it is re-used with a different value of numjobs: |
|
||||
while len(TaskConsumer.consumers) < self.numjobs: |
|
||||
TaskConsumer.consumers.append(TaskConsumer()) |
|
||||
|
|
||||
while not self.stop: |
|
||||
|
|
||||
self.refill_task_list() |
|
||||
|
|
||||
# consider the next task |
|
||||
tsk = self.get_next() |
|
||||
if not tsk: |
|
||||
if self.count: |
|
||||
# tasks may add new ones after they are run |
|
||||
continue |
|
||||
else: |
|
||||
# no tasks to run, no tasks running, time to exit |
|
||||
break |
|
||||
|
|
||||
if tsk.hasrun: |
|
||||
# if the task is marked as "run", just skip it |
|
||||
self.processed += 1 |
|
||||
self.manager.add_finished(tsk) |
|
||||
continue |
|
||||
|
|
||||
try: |
|
||||
st = tsk.runnable_status() |
|
||||
except Exception, e: |
|
||||
self.processed += 1 |
|
||||
if self.stop and not Options.options.keep: |
|
||||
tsk.hasrun = SKIPPED |
|
||||
self.manager.add_finished(tsk) |
|
||||
continue |
|
||||
self.error_handler(tsk) |
|
||||
self.manager.add_finished(tsk) |
|
||||
tsk.hasrun = EXCEPTION |
|
||||
tsk.err_msg = Utils.ex_stack() |
|
||||
continue |
|
||||
|
|
||||
if st == ASK_LATER: |
|
||||
self.postpone(tsk) |
|
||||
elif st == SKIP_ME: |
|
||||
self.processed += 1 |
|
||||
tsk.hasrun = SKIPPED |
|
||||
self.manager.add_finished(tsk) |
|
||||
else: |
|
||||
# run me: put the task in ready queue |
|
||||
tsk.position = (self.processed, self.total) |
|
||||
self.count += 1 |
|
||||
tsk.master = self |
|
||||
TaskConsumer.ready.put(tsk) |
|
||||
self.processed += 1 |
|
||||
|
|
||||
# create the consumer threads only if there is something to consume |
|
||||
if not TaskConsumer.consumers: |
|
||||
TaskConsumer.consumers = [TaskConsumer() for i in xrange(self.numjobs)] |
|
||||
|
|
||||
# self.count represents the tasks that have been made available to the consumer threads |
|
||||
# collect all the tasks after an error else the message may be incomplete |
|
||||
while self.error and self.count: |
|
||||
self.get_out() |
|
||||
|
|
||||
#print loop |
|
||||
assert (self.count == 0 or self.stop) |
|
||||
|
|
||||
@ -1,586 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
"Module called for configuring, compiling and installing targets" |
|
||||
|
|
||||
import os, sys, shutil, traceback, datetime, inspect, errno |
|
||||
|
|
||||
import Utils, Configure, Build, Logs, Options, Environment, Task |
|
||||
from Logs import error, warn, info |
|
||||
from Constants import * |
|
||||
|
|
||||
g_gz = 'bz2' |
|
||||
commands = [] |
|
||||
|
|
||||
def prepare_impl(t, cwd, ver, wafdir): |
|
||||
Options.tooldir = [t] |
|
||||
Options.launch_dir = cwd |
|
||||
|
|
||||
# some command-line options can be processed immediately |
|
||||
if '--version' in sys.argv: |
|
||||
opt_obj = Options.Handler() |
|
||||
opt_obj.curdir = cwd |
|
||||
opt_obj.parse_args() |
|
||||
sys.exit(0) |
|
||||
|
|
||||
# now find the wscript file |
|
||||
msg1 = 'Waf: Please run waf from a directory containing a file named "%s" or run distclean' % WSCRIPT_FILE |
|
||||
|
|
||||
# in theory projects can be configured in an autotool-like manner: |
|
||||
# mkdir build && cd build && ../waf configure && ../waf |
|
||||
build_dir_override = None |
|
||||
candidate = None |
|
||||
|
|
||||
lst = os.listdir(cwd) |
|
||||
|
|
||||
search_for_candidate = True |
|
||||
if WSCRIPT_FILE in lst: |
|
||||
candidate = cwd |
|
||||
|
|
||||
elif 'configure' in sys.argv and not WSCRIPT_BUILD_FILE in lst: |
|
||||
# autotool-like configuration |
|
||||
calldir = os.path.abspath(os.path.dirname(sys.argv[0])) |
|
||||
if WSCRIPT_FILE in os.listdir(calldir): |
|
||||
candidate = calldir |
|
||||
search_for_candidate = False |
|
||||
else: |
|
||||
error('arg[0] directory does not contain a wscript file') |
|
||||
sys.exit(1) |
|
||||
build_dir_override = cwd |
|
||||
|
|
||||
# climb up to find a script if it is not found |
|
||||
while search_for_candidate: |
|
||||
if len(cwd) <= 3: |
|
||||
break # stop at / or c: |
|
||||
dirlst = os.listdir(cwd) |
|
||||
if WSCRIPT_FILE in dirlst: |
|
||||
candidate = cwd |
|
||||
if 'configure' in sys.argv and candidate: |
|
||||
break |
|
||||
if Options.lockfile in dirlst: |
|
||||
env = Environment.Environment() |
|
||||
try: |
|
||||
env.load(os.path.join(cwd, Options.lockfile)) |
|
||||
except: |
|
||||
error('could not load %r' % Options.lockfile) |
|
||||
try: |
|
||||
os.stat(env['cwd']) |
|
||||
except: |
|
||||
candidate = cwd |
|
||||
else: |
|
||||
candidate = env['cwd'] |
|
||||
break |
|
||||
cwd = os.path.dirname(cwd) # climb up |
|
||||
|
|
||||
if not candidate: |
|
||||
# check if the user only wanted to display the help |
|
||||
if '-h' in sys.argv or '--help' in sys.argv: |
|
||||
warn('No wscript file found: the help message may be incomplete') |
|
||||
opt_obj = Options.Handler() |
|
||||
opt_obj.curdir = cwd |
|
||||
opt_obj.parse_args() |
|
||||
else: |
|
||||
error(msg1) |
|
||||
sys.exit(0) |
|
||||
|
|
||||
# We have found wscript, but there is no guarantee that it is valid |
|
||||
try: |
|
||||
os.chdir(candidate) |
|
||||
except OSError: |
|
||||
raise Utils.WafError("the folder %r is unreadable" % candidate) |
|
||||
|
|
||||
# define the main module containing the functions init, shutdown, .. |
|
||||
Utils.set_main_module(os.path.join(candidate, WSCRIPT_FILE)) |
|
||||
|
|
||||
if build_dir_override: |
|
||||
d = getattr(Utils.g_module, BLDDIR, None) |
|
||||
if d: |
|
||||
# test if user has set the blddir in wscript. |
|
||||
msg = ' Overriding build directory %s with %s' % (d, build_dir_override) |
|
||||
warn(msg) |
|
||||
Utils.g_module.blddir = build_dir_override |
|
||||
|
|
||||
# bind a few methods and classes by default |
|
||||
|
|
||||
def set_def(obj, name=''): |
|
||||
n = name or obj.__name__ |
|
||||
if not n in Utils.g_module.__dict__: |
|
||||
setattr(Utils.g_module, n, obj) |
|
||||
|
|
||||
for k in [dist, distclean, distcheck, clean, install, uninstall]: |
|
||||
set_def(k) |
|
||||
|
|
||||
set_def(Configure.ConfigurationContext, 'configure_context') |
|
||||
|
|
||||
for k in ['build', 'clean', 'install', 'uninstall']: |
|
||||
set_def(Build.BuildContext, k + '_context') |
|
||||
|
|
||||
# now parse the options from the user wscript file |
|
||||
opt_obj = Options.Handler(Utils.g_module) |
|
||||
opt_obj.curdir = candidate |
|
||||
try: |
|
||||
f = Utils.g_module.set_options |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
else: |
|
||||
opt_obj.sub_options(['']) |
|
||||
opt_obj.parse_args() |
|
||||
|
|
||||
if not 'init' in Utils.g_module.__dict__: |
|
||||
Utils.g_module.init = Utils.nada |
|
||||
if not 'shutdown' in Utils.g_module.__dict__: |
|
||||
Utils.g_module.shutdown = Utils.nada |
|
||||
|
|
||||
main() |
|
||||
|
|
||||
def prepare(t, cwd, ver, wafdir): |
|
||||
if WAFVERSION != ver: |
|
||||
msg = 'Version mismatch: waf %s <> wafadmin %s (wafdir %s)' % (ver, WAFVERSION, wafdir) |
|
||||
print('\033[91mError: %s\033[0m' % msg) |
|
||||
sys.exit(1) |
|
||||
|
|
||||
#""" |
|
||||
try: |
|
||||
prepare_impl(t, cwd, ver, wafdir) |
|
||||
except Utils.WafError, e: |
|
||||
error(str(e)) |
|
||||
sys.exit(1) |
|
||||
except KeyboardInterrupt: |
|
||||
Utils.pprint('RED', 'Interrupted') |
|
||||
sys.exit(68) |
|
||||
""" |
|
||||
import cProfile, pstats |
|
||||
cProfile.runctx("import Scripting; Scripting.prepare_impl(t, cwd, ver, wafdir)", {}, |
|
||||
{'t': t, 'cwd':cwd, 'ver':ver, 'wafdir':wafdir}, |
|
||||
'profi.txt') |
|
||||
p = pstats.Stats('profi.txt') |
|
||||
p.sort_stats('time').print_stats(45) |
|
||||
#""" |
|
||||
|
|
||||
def main(): |
|
||||
global commands |
|
||||
commands = Options.arg_line[:] |
|
||||
|
|
||||
while commands: |
|
||||
x = commands.pop(0) |
|
||||
|
|
||||
ini = datetime.datetime.now() |
|
||||
if x == 'configure': |
|
||||
fun = configure |
|
||||
elif x == 'build': |
|
||||
fun = build |
|
||||
else: |
|
||||
fun = getattr(Utils.g_module, x, None) |
|
||||
|
|
||||
if not fun: |
|
||||
raise Utils.WscriptError('No such command %r' % x) |
|
||||
|
|
||||
ctx = getattr(Utils.g_module, x + '_context', Utils.Context)() |
|
||||
|
|
||||
if x in ['init', 'shutdown', 'dist', 'distclean', 'distcheck']: |
|
||||
# compatibility TODO remove in waf 1.6 |
|
||||
try: |
|
||||
fun(ctx) |
|
||||
except TypeError: |
|
||||
fun() |
|
||||
else: |
|
||||
fun(ctx) |
|
||||
|
|
||||
ela = '' |
|
||||
if not Options.options.progress_bar: |
|
||||
ela = ' (%s)' % Utils.get_elapsed_time(ini) |
|
||||
|
|
||||
if x != 'init' and x != 'shutdown': |
|
||||
info('%r finished successfully%s' % (x, ela)) |
|
||||
|
|
||||
if not commands and x != 'shutdown': |
|
||||
commands.append('shutdown') |
|
||||
|
|
||||
def configure(conf): |
|
||||
|
|
||||
src = getattr(Options.options, SRCDIR, None) |
|
||||
if not src: src = getattr(Utils.g_module, SRCDIR, None) |
|
||||
if not src: src = getattr(Utils.g_module, 'top', None) |
|
||||
if not src: |
|
||||
src = '.' |
|
||||
incomplete_src = 1 |
|
||||
src = os.path.abspath(src) |
|
||||
|
|
||||
bld = getattr(Options.options, BLDDIR, None) |
|
||||
if not bld: bld = getattr(Utils.g_module, BLDDIR, None) |
|
||||
if not bld: bld = getattr(Utils.g_module, 'out', None) |
|
||||
if not bld: |
|
||||
bld = 'build' |
|
||||
incomplete_bld = 1 |
|
||||
if bld == '.': |
|
||||
raise Utils.WafError('Setting blddir="." may cause distclean problems') |
|
||||
bld = os.path.abspath(bld) |
|
||||
|
|
||||
try: os.makedirs(bld) |
|
||||
except OSError: pass |
|
||||
|
|
||||
# It is not possible to compile specific targets in the configuration |
|
||||
# this may cause configuration errors if autoconfig is set |
|
||||
targets = Options.options.compile_targets |
|
||||
Options.options.compile_targets = None |
|
||||
Options.is_install = False |
|
||||
|
|
||||
conf.srcdir = src |
|
||||
conf.blddir = bld |
|
||||
conf.post_init() |
|
||||
|
|
||||
if 'incomplete_src' in vars(): |
|
||||
conf.check_message_1('Setting srcdir to') |
|
||||
conf.check_message_2(src) |
|
||||
if 'incomplete_bld' in vars(): |
|
||||
conf.check_message_1('Setting blddir to') |
|
||||
conf.check_message_2(bld) |
|
||||
|
|
||||
# calling to main wscript's configure() |
|
||||
conf.sub_config(['']) |
|
||||
|
|
||||
conf.store() |
|
||||
|
|
||||
# this will write a configure lock so that subsequent builds will |
|
||||
# consider the current path as the root directory (see prepare_impl). |
|
||||
# to remove: use 'waf distclean' |
|
||||
env = Environment.Environment() |
|
||||
env[BLDDIR] = bld |
|
||||
env[SRCDIR] = src |
|
||||
env['argv'] = sys.argv |
|
||||
env['commands'] = Options.commands |
|
||||
env['options'] = Options.options.__dict__ |
|
||||
|
|
||||
# conf.hash & conf.files hold wscript files paths and hash |
|
||||
# (used only by Configure.autoconfig) |
|
||||
env['hash'] = conf.hash |
|
||||
env['files'] = conf.files |
|
||||
env['environ'] = dict(conf.environ) |
|
||||
env['cwd'] = os.path.split(Utils.g_module.root_path)[0] |
|
||||
|
|
||||
if Utils.g_module.root_path != src: |
|
||||
# in case the source dir is somewhere else |
|
||||
env.store(os.path.join(src, Options.lockfile)) |
|
||||
|
|
||||
env.store(Options.lockfile) |
|
||||
|
|
||||
Options.options.compile_targets = targets |
|
||||
|
|
||||
def clean(bld): |
|
||||
'''removes the build files''' |
|
||||
try: |
|
||||
proj = Environment.Environment(Options.lockfile) |
|
||||
except IOError: |
|
||||
raise Utils.WafError('Nothing to clean (project not configured)') |
|
||||
|
|
||||
bld.load_dirs(proj[SRCDIR], proj[BLDDIR]) |
|
||||
bld.load_envs() |
|
||||
|
|
||||
bld.is_install = 0 # False |
|
||||
|
|
||||
# read the scripts - and set the path to the wscript path (useful for srcdir='/foo/bar') |
|
||||
bld.add_subdirs([os.path.split(Utils.g_module.root_path)[0]]) |
|
||||
|
|
||||
try: |
|
||||
bld.clean() |
|
||||
finally: |
|
||||
bld.save() |
|
||||
|
|
||||
def check_configured(bld): |
|
||||
if not Configure.autoconfig: |
|
||||
return bld |
|
||||
|
|
||||
conf_cls = getattr(Utils.g_module, 'configure_context', Utils.Context) |
|
||||
bld_cls = getattr(Utils.g_module, 'build_context', Utils.Context) |
|
||||
|
|
||||
def reconf(proj): |
|
||||
back = (Options.commands, Options.options.__dict__, Logs.zones, Logs.verbose) |
|
||||
|
|
||||
Options.commands = proj['commands'] |
|
||||
Options.options.__dict__ = proj['options'] |
|
||||
conf = conf_cls() |
|
||||
conf.environ = proj['environ'] |
|
||||
configure(conf) |
|
||||
|
|
||||
(Options.commands, Options.options.__dict__, Logs.zones, Logs.verbose) = back |
|
||||
|
|
||||
try: |
|
||||
proj = Environment.Environment(Options.lockfile) |
|
||||
except IOError: |
|
||||
conf = conf_cls() |
|
||||
configure(conf) |
|
||||
else: |
|
||||
try: |
|
||||
bld = bld_cls() |
|
||||
bld.load_dirs(proj[SRCDIR], proj[BLDDIR]) |
|
||||
bld.load_envs() |
|
||||
except Utils.WafError: |
|
||||
reconf(proj) |
|
||||
return bld_cls() |
|
||||
|
|
||||
try: |
|
||||
proj = Environment.Environment(Options.lockfile) |
|
||||
except IOError: |
|
||||
raise Utils.WafError('Auto-config: project does not configure (bug)') |
|
||||
|
|
||||
h = 0 |
|
||||
try: |
|
||||
for file in proj['files']: |
|
||||
if file.endswith('configure'): |
|
||||
h = hash((h, Utils.readf(file))) |
|
||||
else: |
|
||||
mod = Utils.load_module(file) |
|
||||
h = hash((h, mod.waf_hash_val)) |
|
||||
except (OSError, IOError): |
|
||||
warn('Reconfiguring the project: a file is unavailable') |
|
||||
reconf(proj) |
|
||||
else: |
|
||||
if (h != proj['hash']): |
|
||||
warn('Reconfiguring the project: the configuration has changed') |
|
||||
reconf(proj) |
|
||||
|
|
||||
return bld_cls() |
|
||||
|
|
||||
def install(bld): |
|
||||
'''installs the build files''' |
|
||||
bld = check_configured(bld) |
|
||||
|
|
||||
Options.commands['install'] = True |
|
||||
Options.commands['uninstall'] = False |
|
||||
Options.is_install = True |
|
||||
|
|
||||
bld.is_install = INSTALL |
|
||||
|
|
||||
build_impl(bld) |
|
||||
bld.install() |
|
||||
|
|
||||
def uninstall(bld): |
|
||||
'''removes the installed files''' |
|
||||
Options.commands['install'] = False |
|
||||
Options.commands['uninstall'] = True |
|
||||
Options.is_install = True |
|
||||
|
|
||||
bld.is_install = UNINSTALL |
|
||||
|
|
||||
try: |
|
||||
def runnable_status(self): |
|
||||
return SKIP_ME |
|
||||
setattr(Task.Task, 'runnable_status_back', Task.Task.runnable_status) |
|
||||
setattr(Task.Task, 'runnable_status', runnable_status) |
|
||||
|
|
||||
build_impl(bld) |
|
||||
bld.install() |
|
||||
finally: |
|
||||
setattr(Task.Task, 'runnable_status', Task.Task.runnable_status_back) |
|
||||
|
|
||||
def build(bld): |
|
||||
bld = check_configured(bld) |
|
||||
|
|
||||
Options.commands['install'] = False |
|
||||
Options.commands['uninstall'] = False |
|
||||
Options.is_install = False |
|
||||
|
|
||||
bld.is_install = 0 # False |
|
||||
|
|
||||
return build_impl(bld) |
|
||||
|
|
||||
def build_impl(bld): |
|
||||
# compile the project and/or install the files |
|
||||
try: |
|
||||
proj = Environment.Environment(Options.lockfile) |
|
||||
except IOError: |
|
||||
raise Utils.WafError("Project not configured (run 'waf configure' first)") |
|
||||
|
|
||||
bld.load_dirs(proj[SRCDIR], proj[BLDDIR]) |
|
||||
bld.load_envs() |
|
||||
|
|
||||
info("Waf: Entering directory `%s'" % bld.bldnode.abspath()) |
|
||||
bld.add_subdirs([os.path.split(Utils.g_module.root_path)[0]]) |
|
||||
|
|
||||
# execute something immediately before the build starts |
|
||||
bld.pre_build() |
|
||||
|
|
||||
try: |
|
||||
bld.compile() |
|
||||
finally: |
|
||||
if Options.options.progress_bar: print('') |
|
||||
info("Waf: Leaving directory `%s'" % bld.bldnode.abspath()) |
|
||||
|
|
||||
# execute something immediately after a successful build |
|
||||
bld.post_build() |
|
||||
|
|
||||
bld.install() |
|
||||
|
|
||||
excludes = '.bzr .bzrignore .git .gitignore .svn CVS .cvsignore .arch-ids {arch} SCCS BitKeeper .hg _MTN _darcs Makefile Makefile.in config.log .gitattributes .hgignore .hgtags'.split() |
|
||||
dist_exts = '~ .rej .orig .pyc .pyo .bak .tar.bz2 tar.gz .zip .swp'.split() |
|
||||
def dont_dist(name, src, build_dir): |
|
||||
global excludes, dist_exts |
|
||||
|
|
||||
if (name.startswith(',,') |
|
||||
or name.startswith('++') |
|
||||
or name.startswith('.waf') |
|
||||
or (src == '.' and name == Options.lockfile) |
|
||||
or name in excludes |
|
||||
or name == build_dir |
|
||||
): |
|
||||
return True |
|
||||
|
|
||||
for ext in dist_exts: |
|
||||
if name.endswith(ext): |
|
||||
return True |
|
||||
|
|
||||
return False |
|
||||
|
|
||||
# like shutil.copytree |
|
||||
# exclude files and to raise exceptions immediately |
|
||||
def copytree(src, dst, build_dir): |
|
||||
names = os.listdir(src) |
|
||||
os.makedirs(dst) |
|
||||
for name in names: |
|
||||
srcname = os.path.join(src, name) |
|
||||
dstname = os.path.join(dst, name) |
|
||||
|
|
||||
if dont_dist(name, src, build_dir): |
|
||||
continue |
|
||||
|
|
||||
if os.path.isdir(srcname): |
|
||||
copytree(srcname, dstname, build_dir) |
|
||||
else: |
|
||||
shutil.copy2(srcname, dstname) |
|
||||
|
|
||||
# TODO in waf 1.6, change this method if "srcdir == blddir" is allowed |
|
||||
def distclean(ctx=None): |
|
||||
'''removes the build directory''' |
|
||||
global commands |
|
||||
lst = os.listdir('.') |
|
||||
for f in lst: |
|
||||
if f == Options.lockfile: |
|
||||
try: |
|
||||
proj = Environment.Environment(f) |
|
||||
except: |
|
||||
Logs.warn('could not read %r' % f) |
|
||||
continue |
|
||||
|
|
||||
try: |
|
||||
shutil.rmtree(proj[BLDDIR]) |
|
||||
except IOError: |
|
||||
pass |
|
||||
except OSError, e: |
|
||||
if e.errno != errno.ENOENT: |
|
||||
Logs.warn('project %r cannot be removed' % proj[BLDDIR]) |
|
||||
|
|
||||
try: |
|
||||
os.remove(f) |
|
||||
except OSError, e: |
|
||||
if e.errno != errno.ENOENT: |
|
||||
Logs.warn('file %r cannot be removed' % f) |
|
||||
|
|
||||
# remove the local waf cache |
|
||||
if not commands and f.startswith('.waf'): |
|
||||
shutil.rmtree(f, ignore_errors=True) |
|
||||
|
|
||||
# FIXME waf 1.6 a unique ctx parameter, and remove the optional appname and version |
|
||||
def dist(appname='', version=''): |
|
||||
'''makes a tarball for redistributing the sources''' |
|
||||
# return return (distdirname, tarballname) |
|
||||
import tarfile |
|
||||
|
|
||||
if not appname: appname = Utils.g_module.APPNAME |
|
||||
if not version: version = Utils.g_module.VERSION |
|
||||
|
|
||||
tmp_folder = appname + '-' + version |
|
||||
if g_gz in ['gz', 'bz2']: |
|
||||
arch_name = tmp_folder + '.tar.' + g_gz |
|
||||
else: |
|
||||
arch_name = tmp_folder + '.' + 'zip' |
|
||||
|
|
||||
# remove the previous dir |
|
||||
try: |
|
||||
shutil.rmtree(tmp_folder) |
|
||||
except (OSError, IOError): |
|
||||
pass |
|
||||
|
|
||||
# remove the previous archive |
|
||||
try: |
|
||||
os.remove(arch_name) |
|
||||
except (OSError, IOError): |
|
||||
pass |
|
||||
|
|
||||
# copy the files into the temporary folder |
|
||||
blddir = getattr(Utils.g_module, BLDDIR, None) |
|
||||
if not blddir: |
|
||||
blddir = getattr(Utils.g_module, 'out', None) |
|
||||
copytree('.', tmp_folder, blddir) |
|
||||
|
|
||||
# undocumented hook for additional cleanup |
|
||||
dist_hook = getattr(Utils.g_module, 'dist_hook', None) |
|
||||
if dist_hook: |
|
||||
back = os.getcwd() |
|
||||
os.chdir(tmp_folder) |
|
||||
try: |
|
||||
dist_hook() |
|
||||
finally: |
|
||||
# go back to the root directory |
|
||||
os.chdir(back) |
|
||||
|
|
||||
if g_gz in ['gz', 'bz2']: |
|
||||
tar = tarfile.open(arch_name, 'w:' + g_gz) |
|
||||
tar.add(tmp_folder) |
|
||||
tar.close() |
|
||||
else: |
|
||||
Utils.zip_folder(tmp_folder, arch_name, tmp_folder) |
|
||||
|
|
||||
try: from hashlib import sha1 as sha |
|
||||
except ImportError: from sha import sha |
|
||||
try: |
|
||||
digest = " (sha=%r)" % sha(Utils.readf(arch_name)).hexdigest() |
|
||||
except: |
|
||||
digest = '' |
|
||||
|
|
||||
info('New archive created: %s%s' % (arch_name, digest)) |
|
||||
|
|
||||
if os.path.exists(tmp_folder): shutil.rmtree(tmp_folder) |
|
||||
return arch_name |
|
||||
|
|
||||
# FIXME waf 1.6 a unique ctx parameter, and remove the optional appname and version |
|
||||
def distcheck(appname='', version='', subdir=''): |
|
||||
'''checks if the sources compile (tarball from 'dist')''' |
|
||||
import tempfile, tarfile |
|
||||
|
|
||||
if not appname: appname = Utils.g_module.APPNAME |
|
||||
if not version: version = Utils.g_module.VERSION |
|
||||
|
|
||||
waf = os.path.abspath(sys.argv[0]) |
|
||||
tarball = dist(appname, version) |
|
||||
|
|
||||
path = appname + '-' + version |
|
||||
|
|
||||
# remove any previous instance |
|
||||
if os.path.exists(path): |
|
||||
shutil.rmtree(path) |
|
||||
|
|
||||
t = tarfile.open(tarball) |
|
||||
for x in t: t.extract(x) |
|
||||
t.close() |
|
||||
|
|
||||
# build_path is the directory for the waf invocation |
|
||||
if subdir: |
|
||||
build_path = os.path.join(path, subdir) |
|
||||
else: |
|
||||
build_path = path |
|
||||
|
|
||||
instdir = tempfile.mkdtemp('.inst', '%s-%s' % (appname, version)) |
|
||||
ret = Utils.pproc.Popen([waf, 'configure', 'build', 'install', 'uninstall', '--destdir=' + instdir], cwd=build_path).wait() |
|
||||
if ret: |
|
||||
raise Utils.WafError('distcheck failed with code %i' % ret) |
|
||||
|
|
||||
if os.path.exists(instdir): |
|
||||
raise Utils.WafError('distcheck succeeded, but files were left in %s' % instdir) |
|
||||
|
|
||||
shutil.rmtree(path) |
|
||||
|
|
||||
# FIXME remove in Waf 1.6 (kept for compatibility) |
|
||||
def add_subdir(dir, bld): |
|
||||
bld.recurse(dir, 'build') |
|
||||
|
|
||||
File diff suppressed because it is too large
@ -1,588 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005-2008 (ita) |
|
||||
|
|
||||
""" |
|
||||
The class task_gen encapsulates the creation of task objects (low-level code) |
|
||||
The instances can have various parameters, but the creation of task nodes (Task.py) |
|
||||
is delayed. To achieve this, various methods are called from the method "apply" |
|
||||
|
|
||||
The class task_gen contains lots of methods, and a configuration table: |
|
||||
* the methods to call (self.meths) can be specified dynamically (removing, adding, ..) |
|
||||
* the order of the methods (self.prec or by default task_gen.prec) is configurable |
|
||||
* new methods can be inserted dynamically without pasting old code |
|
||||
|
|
||||
Additionally, task_gen provides the method apply_core |
|
||||
* file extensions are mapped to methods: def meth(self, name_or_node) |
|
||||
* if a mapping is not found in self.mappings, it is searched in task_gen.mappings |
|
||||
* when called, the functions may modify self.allnodes to re-add source to process |
|
||||
* the mappings can map an extension or a filename (see the code below) |
|
||||
|
|
||||
WARNING: subclasses must reimplement the clone method |
|
||||
""" |
|
||||
|
|
||||
import os, traceback, copy |
|
||||
import Build, Task, Utils, Logs, Options |
|
||||
from Logs import debug, error, warn |
|
||||
from Constants import * |
|
||||
|
|
||||
typos = { |
|
||||
'sources':'source', |
|
||||
'targets':'target', |
|
||||
'include':'includes', |
|
||||
'define':'defines', |
|
||||
'importpath':'importpaths', |
|
||||
'install_var':'install_path', |
|
||||
'install_subdir':'install_path', |
|
||||
'inst_var':'install_path', |
|
||||
'inst_dir':'install_path', |
|
||||
'feature':'features', |
|
||||
} |
|
||||
|
|
||||
class register_obj(type): |
|
||||
"""no decorators for classes, so we use a metaclass |
|
||||
we store into task_gen.classes the classes that inherit task_gen |
|
||||
and whose names end in '_taskgen' |
|
||||
""" |
|
||||
def __init__(cls, name, bases, dict): |
|
||||
super(register_obj, cls).__init__(name, bases, dict) |
|
||||
name = cls.__name__ |
|
||||
suffix = '_taskgen' |
|
||||
if name.endswith(suffix): |
|
||||
task_gen.classes[name.replace(suffix, '')] = cls |
|
||||
|
|
||||
class task_gen(object): |
|
||||
""" |
|
||||
Most methods are of the form 'def meth(self):' without any parameters |
|
||||
there are many of them, and they do many different things: |
|
||||
* task creation |
|
||||
* task results installation |
|
||||
* environment modification |
|
||||
* attribute addition/removal |
|
||||
|
|
||||
The inheritance approach is complicated |
|
||||
* mixing several languages at once |
|
||||
* subclassing is needed even for small changes |
|
||||
* inserting new methods is complicated |
|
||||
|
|
||||
This new class uses a configuration table: |
|
||||
* adding new methods easily |
|
||||
* obtaining the order in which to call the methods |
|
||||
* postponing the method calls (post() -> apply) |
|
||||
|
|
||||
Additionally, a 'traits' static attribute is provided: |
|
||||
* this list contains methods |
|
||||
* the methods can remove or add methods from self.meths |
|
||||
Example1: the attribute 'staticlib' is set on an instance |
|
||||
a method set in the list of traits is executed when the |
|
||||
instance is posted, it finds that flag and adds another method for execution |
|
||||
Example2: a method set in the list of traits finds the msvc |
|
||||
compiler (from self.env['MSVC']==1); more methods are added to self.meths |
|
||||
""" |
|
||||
|
|
||||
__metaclass__ = register_obj |
|
||||
mappings = {} |
|
||||
mapped = {} |
|
||||
prec = Utils.DefaultDict(list) |
|
||||
traits = Utils.DefaultDict(set) |
|
||||
classes = {} |
|
||||
|
|
||||
def __init__(self, *kw, **kwargs): |
|
||||
self.prec = Utils.DefaultDict(list) |
|
||||
"map precedence of function names to call" |
|
||||
# so we will have to play with directed acyclic graphs |
|
||||
# detect cycles, etc |
|
||||
|
|
||||
self.source = '' |
|
||||
self.target = '' |
|
||||
|
|
||||
# list of methods to execute - does not touch it by hand unless you know |
|
||||
self.meths = [] |
|
||||
|
|
||||
# list of mappings extension -> function |
|
||||
self.mappings = {} |
|
||||
|
|
||||
# list of features (see the documentation on traits) |
|
||||
self.features = list(kw) |
|
||||
|
|
||||
# not always a good idea |
|
||||
self.tasks = [] |
|
||||
|
|
||||
self.default_chmod = O644 |
|
||||
self.default_install_path = None |
|
||||
|
|
||||
# kind of private, beware of what you put in it, also, the contents are consumed |
|
||||
self.allnodes = [] |
|
||||
|
|
||||
self.bld = kwargs.get('bld', Build.bld) |
|
||||
self.env = self.bld.env.copy() |
|
||||
|
|
||||
self.path = self.bld.path # emulate chdir when reading scripts |
|
||||
self.name = '' # give a name to the target (static+shlib with the same targetname ambiguity) |
|
||||
|
|
||||
# provide a unique id |
|
||||
self.idx = self.bld.idx[self.path.id] = self.bld.idx.get(self.path.id, 0) + 1 |
|
||||
|
|
||||
for key, val in kwargs.iteritems(): |
|
||||
setattr(self, key, val) |
|
||||
|
|
||||
self.bld.task_manager.add_task_gen(self) |
|
||||
self.bld.all_task_gen.append(self) |
|
||||
|
|
||||
def __str__(self): |
|
||||
return ("<task_gen '%s' of type %s defined in %s>" |
|
||||
% (self.name or self.target, self.__class__.__name__, str(self.path))) |
|
||||
|
|
||||
def __setattr__(self, name, attr): |
|
||||
real = typos.get(name, name) |
|
||||
if real != name: |
|
||||
warn('typo %s -> %s' % (name, real)) |
|
||||
if Logs.verbose > 0: |
|
||||
traceback.print_stack() |
|
||||
object.__setattr__(self, real, attr) |
|
||||
|
|
||||
def to_list(self, value): |
|
||||
"helper: returns a list" |
|
||||
if isinstance(value, str): return value.split() |
|
||||
else: return value |
|
||||
|
|
||||
def apply(self): |
|
||||
"order the methods to execute using self.prec or task_gen.prec" |
|
||||
keys = set(self.meths) |
|
||||
|
|
||||
# add the methods listed in the features |
|
||||
self.features = Utils.to_list(self.features) |
|
||||
for x in self.features + ['*']: |
|
||||
st = task_gen.traits[x] |
|
||||
if not st: |
|
||||
warn('feature %r does not exist - bind at least one method to it' % x) |
|
||||
keys.update(st) |
|
||||
|
|
||||
# copy the precedence table |
|
||||
prec = {} |
|
||||
prec_tbl = self.prec or task_gen.prec |
|
||||
for x in prec_tbl: |
|
||||
if x in keys: |
|
||||
prec[x] = prec_tbl[x] |
|
||||
|
|
||||
# elements disconnected |
|
||||
tmp = [] |
|
||||
for a in keys: |
|
||||
for x in prec.values(): |
|
||||
if a in x: break |
|
||||
else: |
|
||||
tmp.append(a) |
|
||||
|
|
||||
# topological 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 Utils.WafError("graph has a cycle %s" % str(prec)) |
|
||||
out.reverse() |
|
||||
self.meths = out |
|
||||
|
|
||||
# then we run the methods in order |
|
||||
debug('task_gen: posting %s %d', self, id(self)) |
|
||||
for x in out: |
|
||||
try: |
|
||||
v = getattr(self, x) |
|
||||
except AttributeError: |
|
||||
raise Utils.WafError("tried to retrieve %s which is not a valid method" % x) |
|
||||
debug('task_gen: -> %s (%d)', x, id(self)) |
|
||||
v() |
|
||||
|
|
||||
def post(self): |
|
||||
"runs the code to create the tasks, do not subclass" |
|
||||
if not self.name: |
|
||||
if isinstance(self.target, list): |
|
||||
self.name = ' '.join(self.target) |
|
||||
else: |
|
||||
self.name = self.target |
|
||||
|
|
||||
if getattr(self, 'posted', None): |
|
||||
#error("OBJECT ALREADY POSTED" + str( self)) |
|
||||
return |
|
||||
self.apply() |
|
||||
debug('task_gen: posted %s', self.name) |
|
||||
self.posted = True |
|
||||
|
|
||||
def get_hook(self, ext): |
|
||||
try: return self.mappings[ext] |
|
||||
except KeyError: |
|
||||
try: return task_gen.mappings[ext] |
|
||||
except KeyError: return None |
|
||||
|
|
||||
# TODO waf 1.6: always set the environment |
|
||||
# TODO waf 1.6: create_task(self, name, inputs, outputs) |
|
||||
def create_task(self, name, src=None, tgt=None, env=None): |
|
||||
env = env or self.env |
|
||||
task = Task.TaskBase.classes[name](env.copy(), generator=self) |
|
||||
if src: |
|
||||
task.set_inputs(src) |
|
||||
if tgt: |
|
||||
task.set_outputs(tgt) |
|
||||
self.tasks.append(task) |
|
||||
return task |
|
||||
|
|
||||
def name_to_obj(self, name): |
|
||||
return self.bld.name_to_obj(name, self.env) |
|
||||
|
|
||||
def find_sources_in_dirs(self, dirnames, excludes=[], exts=[]): |
|
||||
""" |
|
||||
The attributes "excludes" and "exts" must be lists to avoid the confusion |
|
||||
find_sources_in_dirs('a', 'b', 'c') <-> find_sources_in_dirs('a b c') |
|
||||
|
|
||||
do not use absolute paths |
|
||||
do not use paths outside of the source tree |
|
||||
the files or folder beginning by . are not returned |
|
||||
|
|
||||
# TODO: remove in Waf 1.6 |
|
||||
""" |
|
||||
|
|
||||
err_msg = "'%s' attribute must be a list" |
|
||||
if not isinstance(excludes, list): |
|
||||
raise Utils.WscriptError(err_msg % 'excludes') |
|
||||
if not isinstance(exts, list): |
|
||||
raise Utils.WscriptError(err_msg % 'exts') |
|
||||
|
|
||||
lst = [] |
|
||||
|
|
||||
#make sure dirnames is a list helps with dirnames with spaces |
|
||||
dirnames = self.to_list(dirnames) |
|
||||
|
|
||||
ext_lst = exts or list(self.mappings.keys()) + list(task_gen.mappings.keys()) |
|
||||
|
|
||||
for name in dirnames: |
|
||||
anode = self.path.find_dir(name) |
|
||||
|
|
||||
if not anode or not anode.is_child_of(self.bld.srcnode): |
|
||||
raise Utils.WscriptError("Unable to use '%s' - either because it's not a relative path" \ |
|
||||
", or it's not child of '%s'." % (name, self.bld.srcnode)) |
|
||||
|
|
||||
self.bld.rescan(anode) |
|
||||
for name in self.bld.cache_dir_contents[anode.id]: |
|
||||
|
|
||||
# ignore hidden files |
|
||||
if name.startswith('.'): |
|
||||
continue |
|
||||
|
|
||||
(base, ext) = os.path.splitext(name) |
|
||||
if ext in ext_lst and not name in lst and not name in excludes: |
|
||||
lst.append((anode.relpath_gen(self.path) or '.') + os.path.sep + name) |
|
||||
|
|
||||
lst.sort() |
|
||||
self.source = self.to_list(self.source) |
|
||||
if not self.source: self.source = lst |
|
||||
else: self.source += lst |
|
||||
|
|
||||
def clone(self, env): |
|
||||
"" |
|
||||
newobj = task_gen(bld=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.__class__ = self.__class__ |
|
||||
if isinstance(env, str): |
|
||||
newobj.env = self.bld.all_envs[env].copy() |
|
||||
else: |
|
||||
newobj.env = env.copy() |
|
||||
|
|
||||
return newobj |
|
||||
|
|
||||
def get_inst_path(self): |
|
||||
return getattr(self, '_install_path', getattr(self, 'default_install_path', '')) |
|
||||
|
|
||||
def set_inst_path(self, val): |
|
||||
self._install_path = val |
|
||||
|
|
||||
install_path = property(get_inst_path, set_inst_path) |
|
||||
|
|
||||
|
|
||||
def get_chmod(self): |
|
||||
return getattr(self, '_chmod', getattr(self, 'default_chmod', O644)) |
|
||||
|
|
||||
def set_chmod(self, val): |
|
||||
self._chmod = val |
|
||||
|
|
||||
chmod = property(get_chmod, set_chmod) |
|
||||
|
|
||||
def declare_extension(var, func): |
|
||||
try: |
|
||||
for x in Utils.to_list(var): |
|
||||
task_gen.mappings[x] = func |
|
||||
except: |
|
||||
raise Utils.WscriptError('declare_extension takes either a list or a string %r' % var) |
|
||||
task_gen.mapped[func.__name__] = func |
|
||||
|
|
||||
def declare_order(*k): |
|
||||
assert(len(k) > 1) |
|
||||
n = len(k) - 1 |
|
||||
for i in xrange(n): |
|
||||
f1 = k[i] |
|
||||
f2 = k[i+1] |
|
||||
if not f1 in task_gen.prec[f2]: |
|
||||
task_gen.prec[f2].append(f1) |
|
||||
|
|
||||
def declare_chain(name='', action='', ext_in='', ext_out='', reentrant=True, color='BLUE', |
|
||||
install=0, before=[], after=[], decider=None, rule=None, scan=None): |
|
||||
""" |
|
||||
see Tools/flex.py for an example |
|
||||
while i do not like such wrappers, some people really do |
|
||||
""" |
|
||||
|
|
||||
action = action or rule |
|
||||
if isinstance(action, str): |
|
||||
act = Task.simple_task_type(name, action, color=color) |
|
||||
else: |
|
||||
act = Task.task_type_from_func(name, action, color=color) |
|
||||
act.ext_in = tuple(Utils.to_list(ext_in)) |
|
||||
act.ext_out = tuple(Utils.to_list(ext_out)) |
|
||||
act.before = Utils.to_list(before) |
|
||||
act.after = Utils.to_list(after) |
|
||||
act.scan = scan |
|
||||
|
|
||||
def x_file(self, node): |
|
||||
if decider: |
|
||||
ext = decider(self, node) |
|
||||
else: |
|
||||
ext = ext_out |
|
||||
|
|
||||
if isinstance(ext, str): |
|
||||
out_source = node.change_ext(ext) |
|
||||
if reentrant: |
|
||||
self.allnodes.append(out_source) |
|
||||
elif isinstance(ext, list): |
|
||||
out_source = [node.change_ext(x) for x in ext] |
|
||||
if reentrant: |
|
||||
for i in xrange((reentrant is True) and len(out_source) or reentrant): |
|
||||
self.allnodes.append(out_source[i]) |
|
||||
else: |
|
||||
# XXX: useless: it will fail on Utils.to_list above... |
|
||||
raise Utils.WafError("do not know how to process %s" % str(ext)) |
|
||||
|
|
||||
tsk = self.create_task(name, node, out_source) |
|
||||
|
|
||||
if node.__class__.bld.is_install: |
|
||||
tsk.install = install |
|
||||
|
|
||||
declare_extension(act.ext_in, x_file) |
|
||||
|
|
||||
def bind_feature(name, methods): |
|
||||
lst = Utils.to_list(methods) |
|
||||
task_gen.traits[name].update(lst) |
|
||||
|
|
||||
""" |
|
||||
All the following decorators are registration decorators, i.e add an attribute to current class |
|
||||
(task_gen and its derivatives), with same name as func, which points to func itself. |
|
||||
For example: |
|
||||
@taskgen |
|
||||
def sayHi(self): |
|
||||
print("hi") |
|
||||
Now taskgen.sayHi() may be called |
|
||||
|
|
||||
If python were really smart, it could infer itself the order of methods by looking at the |
|
||||
attributes. A prerequisite for execution is to have the attribute set before. |
|
||||
Intelligent compilers binding aspect-oriented programming and parallelization, what a nice topic for studies. |
|
||||
""" |
|
||||
def taskgen(func): |
|
||||
setattr(task_gen, func.__name__, func) |
|
||||
return func |
|
||||
|
|
||||
def feature(*k): |
|
||||
def deco(func): |
|
||||
setattr(task_gen, func.__name__, func) |
|
||||
for name in k: |
|
||||
task_gen.traits[name].update([func.__name__]) |
|
||||
return func |
|
||||
return deco |
|
||||
|
|
||||
def before(*k): |
|
||||
def deco(func): |
|
||||
setattr(task_gen, func.__name__, func) |
|
||||
for fun_name in k: |
|
||||
if not func.__name__ in task_gen.prec[fun_name]: |
|
||||
task_gen.prec[fun_name].append(func.__name__) |
|
||||
return func |
|
||||
return deco |
|
||||
|
|
||||
def after(*k): |
|
||||
def deco(func): |
|
||||
setattr(task_gen, func.__name__, func) |
|
||||
for fun_name in k: |
|
||||
if not fun_name in task_gen.prec[func.__name__]: |
|
||||
task_gen.prec[func.__name__].append(fun_name) |
|
||||
return func |
|
||||
return deco |
|
||||
|
|
||||
def extension(var): |
|
||||
def deco(func): |
|
||||
setattr(task_gen, func.__name__, func) |
|
||||
try: |
|
||||
for x in Utils.to_list(var): |
|
||||
task_gen.mappings[x] = func |
|
||||
except: |
|
||||
raise Utils.WafError('extension takes either a list or a string %r' % var) |
|
||||
task_gen.mapped[func.__name__] = func |
|
||||
return func |
|
||||
return deco |
|
||||
|
|
||||
# TODO make certain the decorators may be used here |
|
||||
|
|
||||
def apply_core(self): |
|
||||
"""Process the attribute source |
|
||||
transform the names into file nodes |
|
||||
try to process the files by name first, later by extension""" |
|
||||
# get the list of folders to use by the scanners |
|
||||
# all our objects share the same include paths anyway |
|
||||
find_resource = self.path.find_resource |
|
||||
|
|
||||
for filename in self.to_list(self.source): |
|
||||
# if self.mappings or task_gen.mappings contains a file of the same name |
|
||||
x = self.get_hook(filename) |
|
||||
if x: |
|
||||
x(self, filename) |
|
||||
else: |
|
||||
node = find_resource(filename) |
|
||||
if not node: raise Utils.WafError("source not found: '%s' in '%s'" % (filename, str(self.path))) |
|
||||
self.allnodes.append(node) |
|
||||
|
|
||||
for node in self.allnodes: |
|
||||
# self.mappings or task_gen.mappings map the file extension to a function |
|
||||
x = self.get_hook(node.suffix()) |
|
||||
|
|
||||
if not x: |
|
||||
raise Utils.WafError("Cannot guess how to process %s (got mappings %r in %r) -> try conf.check_tool(..)?" % \ |
|
||||
(str(node), self.__class__.mappings.keys(), self.__class__)) |
|
||||
x(self, node) |
|
||||
feature('*')(apply_core) |
|
||||
|
|
||||
def exec_rule(self): |
|
||||
"""Process the attribute rule, when provided the method apply_core will be disabled |
|
||||
""" |
|
||||
if not getattr(self, 'rule', None): |
|
||||
return |
|
||||
|
|
||||
# someone may have removed it already |
|
||||
try: |
|
||||
self.meths.remove('apply_core') |
|
||||
except ValueError: |
|
||||
pass |
|
||||
|
|
||||
# get the function and the variables |
|
||||
func = self.rule |
|
||||
|
|
||||
vars2 = [] |
|
||||
if isinstance(func, str): |
|
||||
# use the shell by default for user-defined commands |
|
||||
(func, vars2) = Task.compile_fun('', self.rule, shell=getattr(self, 'shell', True)) |
|
||||
func.code = self.rule |
|
||||
|
|
||||
# create the task class |
|
||||
name = getattr(self, 'name', None) or self.target or self.rule |
|
||||
if not isinstance(name, str): |
|
||||
name = str(self.idx) |
|
||||
cls = Task.task_type_from_func(name, func, getattr(self, 'vars', vars2)) |
|
||||
|
|
||||
# now create one instance |
|
||||
tsk = self.create_task(name) |
|
||||
|
|
||||
dep_vars = getattr(self, 'dep_vars', ['ruledeps']) |
|
||||
if dep_vars: |
|
||||
tsk.dep_vars = dep_vars |
|
||||
if isinstance(self.rule, str): |
|
||||
tsk.env.ruledeps = self.rule |
|
||||
else: |
|
||||
# only works if the function is in a global module such as a waf tool |
|
||||
tsk.env.ruledeps = Utils.h_fun(self.rule) |
|
||||
|
|
||||
# we assume that the user knows that without inputs or outputs |
|
||||
#if not getattr(self, 'target', None) and not getattr(self, 'source', None): |
|
||||
# cls.quiet = True |
|
||||
|
|
||||
if getattr(self, 'target', None): |
|
||||
cls.quiet = True |
|
||||
tsk.outputs = [self.path.find_or_declare(x) for x in self.to_list(self.target)] |
|
||||
|
|
||||
if getattr(self, 'source', None): |
|
||||
cls.quiet = True |
|
||||
tsk.inputs = [] |
|
||||
for x in self.to_list(self.source): |
|
||||
y = self.path.find_resource(x) |
|
||||
if not y: |
|
||||
raise Utils.WafError('input file %r could not be found (%r)' % (x, self.path.abspath())) |
|
||||
tsk.inputs.append(y) |
|
||||
|
|
||||
if self.allnodes: |
|
||||
tsk.inputs.extend(self.allnodes) |
|
||||
|
|
||||
if getattr(self, 'scan', None): |
|
||||
cls.scan = self.scan |
|
||||
|
|
||||
if getattr(self, 'install_path', None): |
|
||||
tsk.install_path = self.install_path |
|
||||
|
|
||||
if getattr(self, 'cwd', None): |
|
||||
tsk.cwd = self.cwd |
|
||||
|
|
||||
if getattr(self, 'on_results', None): |
|
||||
Task.update_outputs(cls) |
|
||||
|
|
||||
if getattr(self, 'always', None): |
|
||||
Task.always_run(cls) |
|
||||
|
|
||||
for x in ['after', 'before', 'ext_in', 'ext_out']: |
|
||||
setattr(cls, x, getattr(self, x, [])) |
|
||||
feature('*')(exec_rule) |
|
||||
before('apply_core')(exec_rule) |
|
||||
|
|
||||
def sequence_order(self): |
|
||||
""" |
|
||||
add a strict sequential constraint between the tasks generated by task generators |
|
||||
it uses the fact that task generators are posted in order |
|
||||
it will not post objects which belong to other folders |
|
||||
there is also an awesome trick for executing the method in last position |
|
||||
|
|
||||
to use: |
|
||||
bld(features='javac seq') |
|
||||
bld(features='jar seq') |
|
||||
|
|
||||
to start a new sequence, set the attribute seq_start, for example: |
|
||||
obj.seq_start = True |
|
||||
""" |
|
||||
if self.meths and self.meths[-1] != 'sequence_order': |
|
||||
self.meths.append('sequence_order') |
|
||||
return |
|
||||
|
|
||||
if getattr(self, 'seq_start', None): |
|
||||
return |
|
||||
|
|
||||
# all the tasks previously declared must be run before these |
|
||||
if getattr(self.bld, 'prev', None): |
|
||||
self.bld.prev.post() |
|
||||
for x in self.bld.prev.tasks: |
|
||||
for y in self.tasks: |
|
||||
y.set_run_after(x) |
|
||||
|
|
||||
self.bld.prev = self |
|
||||
|
|
||||
feature('seq')(sequence_order) |
|
||||
|
|
||||
@ -1,4 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
|
|
||||
@ -1,36 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006-2008 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
|
|
||||
"ar and ranlib" |
|
||||
|
|
||||
import os, sys |
|
||||
import Task, Utils |
|
||||
from Configure import conftest |
|
||||
|
|
||||
ar_str = '${AR} ${ARFLAGS} ${AR_TGT_F}${TGT} ${AR_SRC_F}${SRC}' |
|
||||
cls = Task.simple_task_type('static_link', ar_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) |
|
||||
cls.maxjobs = 1 |
|
||||
cls.install = Utils.nada |
|
||||
|
|
||||
# remove the output in case it already exists |
|
||||
old = cls.run |
|
||||
def wrap(self): |
|
||||
try: os.remove(self.outputs[0].abspath(self.env)) |
|
||||
except OSError: pass |
|
||||
return old(self) |
|
||||
setattr(cls, 'run', wrap) |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_program('ar', var='AR') |
|
||||
conf.find_program('ranlib', var='RANLIB') |
|
||||
conf.env.ARFLAGS = 'rcs' |
|
||||
|
|
||||
@conftest |
|
||||
def find_ar(conf): |
|
||||
v = conf.env |
|
||||
conf.check_tool('ar') |
|
||||
if not v['AR']: conf.fatal('ar is required for static libraries - not found') |
|
||||
|
|
||||
|
|
||||
@ -1,100 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
|
|
||||
"Base for c programs/libraries" |
|
||||
|
|
||||
import os |
|
||||
import TaskGen, Build, Utils, Task |
|
||||
from Logs import debug |
|
||||
import ccroot |
|
||||
from TaskGen import feature, before, extension, after |
|
||||
|
|
||||
g_cc_flag_vars = [ |
|
||||
'CCDEPS', 'FRAMEWORK', 'FRAMEWORKPATH', |
|
||||
'STATICLIB', 'LIB', 'LIBPATH', 'LINKFLAGS', 'RPATH', |
|
||||
'CCFLAGS', 'CPPPATH', 'CPPFLAGS', 'CCDEFINES'] |
|
||||
|
|
||||
EXT_CC = ['.c'] |
|
||||
|
|
||||
g_cc_type_vars = ['CCFLAGS', 'LINKFLAGS'] |
|
||||
|
|
||||
# TODO remove in waf 1.6 |
|
||||
class cc_taskgen(ccroot.ccroot_abstract): |
|
||||
pass |
|
||||
|
|
||||
@feature('cc') |
|
||||
@before('apply_type_vars') |
|
||||
@after('default_cc') |
|
||||
def init_cc(self): |
|
||||
self.p_flag_vars = set(self.p_flag_vars).union(g_cc_flag_vars) |
|
||||
self.p_type_vars = set(self.p_type_vars).union(g_cc_type_vars) |
|
||||
|
|
||||
if not self.env['CC_NAME']: |
|
||||
raise Utils.WafError("At least one compiler (gcc, ..) must be selected") |
|
||||
|
|
||||
@feature('cc') |
|
||||
@after('apply_incpaths') |
|
||||
def apply_obj_vars_cc(self): |
|
||||
"""after apply_incpaths for INC_PATHS""" |
|
||||
env = self.env |
|
||||
app = env.append_unique |
|
||||
cpppath_st = env['CPPPATH_ST'] |
|
||||
|
|
||||
# local flags come first |
|
||||
# set the user-defined includes paths |
|
||||
for i in env['INC_PATHS']: |
|
||||
app('_CCINCFLAGS', cpppath_st % i.bldpath(env)) |
|
||||
app('_CCINCFLAGS', cpppath_st % i.srcpath(env)) |
|
||||
|
|
||||
# set the library include paths |
|
||||
for i in env['CPPPATH']: |
|
||||
app('_CCINCFLAGS', cpppath_st % i) |
|
||||
|
|
||||
@feature('cc') |
|
||||
@after('apply_lib_vars') |
|
||||
def apply_defines_cc(self): |
|
||||
"""after uselib is set for CCDEFINES""" |
|
||||
self.defines = getattr(self, 'defines', []) |
|
||||
lst = self.to_list(self.defines) + self.to_list(self.env['CCDEFINES']) |
|
||||
milst = [] |
|
||||
|
|
||||
# now process the local defines |
|
||||
for defi in lst: |
|
||||
if not defi in milst: |
|
||||
milst.append(defi) |
|
||||
|
|
||||
# CCDEFINES_ |
|
||||
libs = self.to_list(self.uselib) |
|
||||
for l in libs: |
|
||||
val = self.env['CCDEFINES_'+l] |
|
||||
if val: milst += val |
|
||||
self.env['DEFLINES'] = ["%s %s" % (x[0], Utils.trimquotes('='.join(x[1:]))) for x in [y.split('=') for y in milst]] |
|
||||
y = self.env['CCDEFINES_ST'] |
|
||||
self.env['_CCDEFFLAGS'] = [y%x for x in milst] |
|
||||
|
|
||||
@extension(EXT_CC) |
|
||||
def c_hook(self, node): |
|
||||
# create the compilation task: cpp or cc |
|
||||
if getattr(self, 'obj_ext', None): |
|
||||
obj_ext = self.obj_ext |
|
||||
else: |
|
||||
obj_ext = '_%d.o' % self.idx |
|
||||
|
|
||||
task = self.create_task('cc', node, node.change_ext(obj_ext)) |
|
||||
try: |
|
||||
self.compiled_tasks.append(task) |
|
||||
except AttributeError: |
|
||||
raise Utils.WafError('Have you forgotten to set the feature "cc" on %s?' % str(self)) |
|
||||
return task |
|
||||
|
|
||||
cc_str = '${CC} ${CCFLAGS} ${CPPFLAGS} ${_CCINCFLAGS} ${_CCDEFFLAGS} ${CC_SRC_F}${SRC} ${CC_TGT_F}${TGT}' |
|
||||
cls = Task.simple_task_type('cc', cc_str, 'GREEN', ext_out='.o', ext_in='.c', shell=False) |
|
||||
cls.scan = ccroot.scan |
|
||||
cls.vars.append('CCDEPS') |
|
||||
|
|
||||
link_str = '${LINK_CC} ${CCLNK_SRC_F}${SRC} ${CCLNK_TGT_F}${TGT[0].abspath(env)} ${LINKFLAGS}' |
|
||||
cls = Task.simple_task_type('cc_link', link_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) |
|
||||
cls.maxjobs = 1 |
|
||||
cls.install = Utils.nada |
|
||||
|
|
||||
@ -1,625 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005-2008 (ita) |
|
||||
|
|
||||
"base for all c/c++ programs and libraries" |
|
||||
|
|
||||
import os, sys, re |
|
||||
import TaskGen, Task, Utils, preproc, Logs, Build, Options |
|
||||
from Logs import error, debug, warn |
|
||||
from Utils import md5 |
|
||||
from TaskGen import taskgen, after, before, feature |
|
||||
from Constants import * |
|
||||
from Configure import conftest |
|
||||
try: |
|
||||
from cStringIO import StringIO |
|
||||
except ImportError: |
|
||||
from io import StringIO |
|
||||
|
|
||||
import config_c # <- necessary for the configuration, do not touch |
|
||||
|
|
||||
USE_TOP_LEVEL = False |
|
||||
|
|
||||
def get_cc_version(conf, cc, gcc=False, icc=False): |
|
||||
|
|
||||
cmd = cc + ['-dM', '-E', '-'] |
|
||||
try: |
|
||||
p = Utils.pproc.Popen(cmd, stdin=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE) |
|
||||
p.stdin.write('\n') |
|
||||
out = p.communicate()[0] |
|
||||
except: |
|
||||
conf.fatal('could not determine the compiler version %r' % cmd) |
|
||||
|
|
||||
# PY3K: do not touch |
|
||||
out = str(out) |
|
||||
|
|
||||
if gcc: |
|
||||
if out.find('__INTEL_COMPILER') >= 0: |
|
||||
conf.fatal('The intel compiler pretends to be gcc') |
|
||||
if out.find('__GNUC__') < 0: |
|
||||
conf.fatal('Could not determine the compiler type') |
|
||||
|
|
||||
if icc and out.find('__INTEL_COMPILER') < 0: |
|
||||
conf.fatal('Not icc/icpc') |
|
||||
|
|
||||
k = {} |
|
||||
if icc or gcc: |
|
||||
out = out.split('\n') |
|
||||
import shlex |
|
||||
|
|
||||
for line in out: |
|
||||
lst = shlex.split(line) |
|
||||
if len(lst)>2: |
|
||||
key = lst[1] |
|
||||
val = lst[2] |
|
||||
k[key] = val |
|
||||
|
|
||||
def isD(var): |
|
||||
return var in k |
|
||||
|
|
||||
def isT(var): |
|
||||
return var in k and k[var] != '0' |
|
||||
|
|
||||
# Some documentation is available at http://predef.sourceforge.net |
|
||||
# The names given to DEST_OS must match what Utils.unversioned_sys_platform() returns. |
|
||||
mp1 = { |
|
||||
'__linux__' : 'linux', |
|
||||
'__GNU__' : 'hurd', |
|
||||
'__FreeBSD__' : 'freebsd', |
|
||||
'__NetBSD__' : 'netbsd', |
|
||||
'__OpenBSD__' : 'openbsd', |
|
||||
'__sun' : 'sunos', |
|
||||
'__hpux' : 'hpux', |
|
||||
'__sgi' : 'irix', |
|
||||
'_AIX' : 'aix', |
|
||||
'__CYGWIN__' : 'cygwin', |
|
||||
'__MSYS__' : 'msys', |
|
||||
'_UWIN' : 'uwin', |
|
||||
'_WIN64' : 'win32', |
|
||||
'_WIN32' : 'win32', |
|
||||
} |
|
||||
|
|
||||
for i in mp1: |
|
||||
if isD(i): |
|
||||
conf.env.DEST_OS = mp1[i] |
|
||||
break |
|
||||
else: |
|
||||
if isD('__APPLE__') and isD('__MACH__'): |
|
||||
conf.env.DEST_OS = 'darwin' |
|
||||
elif isD('__unix__'): # unix must be tested last as it's a generic fallback |
|
||||
conf.env.DEST_OS = 'generic' |
|
||||
|
|
||||
if isD('__ELF__'): |
|
||||
conf.env.DEST_BINFMT = 'elf' |
|
||||
|
|
||||
mp2 = { |
|
||||
'__x86_64__' : 'x86_64', |
|
||||
'__i386__' : 'x86', |
|
||||
'__ia64__' : 'ia', |
|
||||
'__mips__' : 'mips', |
|
||||
'__sparc__' : 'sparc', |
|
||||
'__alpha__' : 'alpha', |
|
||||
'__arm__' : 'arm', |
|
||||
'__hppa__' : 'hppa', |
|
||||
'__powerpc__' : 'powerpc', |
|
||||
} |
|
||||
for i in mp2: |
|
||||
if isD(i): |
|
||||
conf.env.DEST_CPU = mp2[i] |
|
||||
break |
|
||||
|
|
||||
debug('ccroot: dest platform: ' + ' '.join([conf.env[x] or '?' for x in ('DEST_OS', 'DEST_BINFMT', 'DEST_CPU')])) |
|
||||
conf.env['CC_VERSION'] = (k['__GNUC__'], k['__GNUC_MINOR__'], k['__GNUC_PATCHLEVEL__']) |
|
||||
return k |
|
||||
|
|
||||
class DEBUG_LEVELS: |
|
||||
"""Will disappear in waf 1.6""" |
|
||||
ULTRADEBUG = "ultradebug" |
|
||||
DEBUG = "debug" |
|
||||
RELEASE = "release" |
|
||||
OPTIMIZED = "optimized" |
|
||||
CUSTOM = "custom" |
|
||||
|
|
||||
ALL = [ULTRADEBUG, DEBUG, RELEASE, OPTIMIZED, CUSTOM] |
|
||||
|
|
||||
def scan(self): |
|
||||
"look for .h the .cpp need" |
|
||||
debug('ccroot: _scan_preprocessor(self, node, env, path_lst)') |
|
||||
|
|
||||
# TODO waf 1.6 - assume the default input has exactly one file |
|
||||
|
|
||||
if len(self.inputs) == 1: |
|
||||
node = self.inputs[0] |
|
||||
(nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS']) |
|
||||
if Logs.verbose: |
|
||||
debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names) |
|
||||
return (nodes, names) |
|
||||
|
|
||||
all_nodes = [] |
|
||||
all_names = [] |
|
||||
seen = set() |
|
||||
for node in self.inputs: |
|
||||
(nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS']) |
|
||||
if Logs.verbose: |
|
||||
debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names) |
|
||||
for x in nodes: |
|
||||
if id(x) in seen: continue |
|
||||
seen.add(id(x)) |
|
||||
all_nodes.append(x) |
|
||||
for x in names: |
|
||||
if not x in all_names: |
|
||||
all_names.append(x) |
|
||||
return (all_nodes, all_names) |
|
||||
|
|
||||
class ccroot_abstract(TaskGen.task_gen): |
|
||||
"Parent class for programs and libraries in languages c, c++ and moc (Qt)" |
|
||||
def __init__(self, *k, **kw): |
|
||||
# COMPAT remove in waf 1.6 TODO |
|
||||
if len(k) > 1: |
|
||||
k = list(k) |
|
||||
if k[1][0] != 'c': |
|
||||
k[1] = 'c' + k[1] |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
def get_target_name(self): |
|
||||
tp = 'program' |
|
||||
for x in self.features: |
|
||||
if x in ['cshlib', 'cstaticlib']: |
|
||||
tp = x.lstrip('c') |
|
||||
|
|
||||
pattern = self.env[tp + '_PATTERN'] |
|
||||
if not pattern: pattern = '%s' |
|
||||
|
|
||||
dir, name = os.path.split(self.target) |
|
||||
|
|
||||
if self.env.DEST_BINFMT == 'pe' and getattr(self, 'vnum', None) and 'cshlib' in self.features: |
|
||||
# include the version in the dll file name, |
|
||||
# the import lib file name stays unversionned. |
|
||||
name = name + '-' + self.vnum.split('.')[0] |
|
||||
|
|
||||
return os.path.join(dir, pattern % name) |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@before('apply_core') |
|
||||
def default_cc(self): |
|
||||
"""compiled_tasks attribute must be set before the '.c->.o' tasks can be created""" |
|
||||
Utils.def_attrs(self, |
|
||||
includes = '', |
|
||||
defines= '', |
|
||||
rpaths = '', |
|
||||
uselib = '', |
|
||||
uselib_local = '', |
|
||||
add_objects = '', |
|
||||
p_flag_vars = [], |
|
||||
p_type_vars = [], |
|
||||
compiled_tasks = [], |
|
||||
link_task = None) |
|
||||
|
|
||||
# The only thing we need for cross-compilation is DEST_BINFMT. |
|
||||
# At some point, we may reach a case where DEST_BINFMT is not enough, but for now it's sufficient. |
|
||||
# Currently, cross-compilation is auto-detected only for the gnu and intel compilers. |
|
||||
if not self.env.DEST_BINFMT: |
|
||||
# Infer the binary format from the os name. |
|
||||
self.env.DEST_BINFMT = Utils.unversioned_sys_platform_to_binary_format( |
|
||||
self.env.DEST_OS or Utils.unversioned_sys_platform()) |
|
||||
|
|
||||
if not self.env.BINDIR: self.env.BINDIR = Utils.subst_vars('${PREFIX}/bin', self.env) |
|
||||
if not self.env.LIBDIR: self.env.LIBDIR = Utils.subst_vars('${PREFIX}/lib${LIB_EXT}', self.env) |
|
||||
|
|
||||
@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib') |
|
||||
def apply_verif(self): |
|
||||
"""no particular order, used for diagnostic""" |
|
||||
if not (self.source or getattr(self, 'add_objects', None) or getattr(self, 'uselib_local', None) or getattr(self, 'obj_files', None)): |
|
||||
raise Utils.WafError('no source files specified for %s' % self) |
|
||||
if not self.target: |
|
||||
raise Utils.WafError('no target for %s' % self) |
|
||||
|
|
||||
# TODO reference the d programs, shlibs in d.py, not here |
|
||||
|
|
||||
@feature('cprogram', 'dprogram') |
|
||||
@after('default_cc') |
|
||||
@before('apply_core') |
|
||||
def vars_target_cprogram(self): |
|
||||
self.default_install_path = self.env.BINDIR |
|
||||
self.default_chmod = O755 |
|
||||
|
|
||||
@after('default_cc') |
|
||||
@feature('cshlib', 'dshlib') |
|
||||
@before('apply_core') |
|
||||
def vars_target_cshlib(self): |
|
||||
if self.env.DEST_BINFMT == 'pe': |
|
||||
# set execute bit on libs to avoid 'permission denied' (issue 283) |
|
||||
self.default_chmod = O755 |
|
||||
self.default_install_path = self.env.BINDIR |
|
||||
else: |
|
||||
self.default_install_path = self.env.LIBDIR |
|
||||
|
|
||||
@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib') |
|
||||
@after('apply_link', 'vars_target_cprogram', 'vars_target_cshlib') |
|
||||
def default_link_install(self): |
|
||||
"""you may kill this method to inject your own installation for the first element |
|
||||
any other install should only process its own nodes and not those from the others""" |
|
||||
if self.install_path: |
|
||||
self.bld.install_files(self.install_path, self.link_task.outputs[0], env=self.env, chmod=self.chmod) |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@after('apply_type_vars', 'apply_lib_vars', 'apply_core') |
|
||||
def apply_incpaths(self): |
|
||||
"""used by the scanner |
|
||||
after processing the uselib for CPPPATH |
|
||||
after apply_core because some processing may add include paths |
|
||||
""" |
|
||||
lst = [] |
|
||||
# TODO move the uselib processing out of here |
|
||||
for lib in self.to_list(self.uselib): |
|
||||
for path in self.env['CPPPATH_' + lib]: |
|
||||
if not path in lst: |
|
||||
lst.append(path) |
|
||||
if preproc.go_absolute: |
|
||||
for path in preproc.standard_includes: |
|
||||
if not path in lst: |
|
||||
lst.append(path) |
|
||||
|
|
||||
for path in self.to_list(self.includes): |
|
||||
if not path in lst: |
|
||||
if preproc.go_absolute or not os.path.isabs(path): |
|
||||
lst.append(path) |
|
||||
else: |
|
||||
self.env.prepend_value('CPPPATH', path) |
|
||||
|
|
||||
for path in lst: |
|
||||
node = None |
|
||||
if os.path.isabs(path): |
|
||||
if preproc.go_absolute: |
|
||||
node = self.bld.root.find_dir(path) |
|
||||
elif path[0] == '#': |
|
||||
node = self.bld.srcnode |
|
||||
if len(path) > 1: |
|
||||
node = node.find_dir(path[1:]) |
|
||||
else: |
|
||||
node = self.path.find_dir(path) |
|
||||
|
|
||||
if node: |
|
||||
self.env.append_value('INC_PATHS', node) |
|
||||
|
|
||||
# TODO WAF 1.6 |
|
||||
if USE_TOP_LEVEL: |
|
||||
self.env.append_value('INC_PATHS', self.bld.srcnode) |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@after('init_cc', 'init_cxx') |
|
||||
@before('apply_lib_vars') |
|
||||
def apply_type_vars(self): |
|
||||
"""before apply_lib_vars because we modify uselib |
|
||||
after init_cc and init_cxx because web need p_type_vars |
|
||||
""" |
|
||||
for x in self.features: |
|
||||
if not x in ['cprogram', 'cstaticlib', 'cshlib']: |
|
||||
continue |
|
||||
x = x.lstrip('c') |
|
||||
|
|
||||
# if the type defines uselib to add, add them |
|
||||
st = self.env[x + '_USELIB'] |
|
||||
if st: self.uselib = self.uselib + ' ' + st |
|
||||
|
|
||||
# each compiler defines variables like 'shlib_CXXFLAGS', 'shlib_LINKFLAGS', etc |
|
||||
# so when we make a task generator of the type shlib, CXXFLAGS are modified accordingly |
|
||||
for var in self.p_type_vars: |
|
||||
compvar = '%s_%s' % (x, var) |
|
||||
#print compvar |
|
||||
value = self.env[compvar] |
|
||||
if value: self.env.append_value(var, value) |
|
||||
|
|
||||
@feature('cprogram', 'cshlib', 'cstaticlib') |
|
||||
@after('apply_core') |
|
||||
def apply_link(self): |
|
||||
"""executes after apply_core for collecting 'compiled_tasks' |
|
||||
use a custom linker if specified (self.link='name-of-custom-link-task')""" |
|
||||
link = getattr(self, 'link', None) |
|
||||
if not link: |
|
||||
if 'cstaticlib' in self.features: link = 'static_link' |
|
||||
elif 'cxx' in self.features: link = 'cxx_link' |
|
||||
else: link = 'cc_link' |
|
||||
|
|
||||
tsk = self.create_task(link) |
|
||||
outputs = [t.outputs[0] for t in self.compiled_tasks] |
|
||||
tsk.set_inputs(outputs) |
|
||||
tsk.set_outputs(self.path.find_or_declare(get_target_name(self))) |
|
||||
|
|
||||
self.link_task = tsk |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@after('apply_link', 'init_cc', 'init_cxx', 'apply_core') |
|
||||
def apply_lib_vars(self): |
|
||||
"""after apply_link because of 'link_task' |
|
||||
after default_cc because of the attribute 'uselib'""" |
|
||||
|
|
||||
# after 'apply_core' in case if 'cc' if there is no link |
|
||||
|
|
||||
env = self.env |
|
||||
|
|
||||
# 1. the case of the libs defined in the project (visit ancestors first) |
|
||||
# the ancestors external libraries (uselib) will be prepended |
|
||||
self.uselib = self.to_list(self.uselib) |
|
||||
names = self.to_list(self.uselib_local) |
|
||||
|
|
||||
seen = set([]) |
|
||||
tmp = Utils.deque(names) # consume a copy of the list of names |
|
||||
while tmp: |
|
||||
lib_name = tmp.popleft() |
|
||||
# visit dependencies only once |
|
||||
if lib_name in seen: |
|
||||
continue |
|
||||
|
|
||||
y = self.name_to_obj(lib_name) |
|
||||
if not y: |
|
||||
raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name)) |
|
||||
y.post() |
|
||||
seen.add(lib_name) |
|
||||
|
|
||||
# object has ancestors to process (shared libraries): add them to the end of the list |
|
||||
if getattr(y, 'uselib_local', None): |
|
||||
lst = y.to_list(y.uselib_local) |
|
||||
if 'cshlib' in y.features or 'cprogram' in y.features: |
|
||||
lst = [x for x in lst if not 'cstaticlib' in self.name_to_obj(x).features] |
|
||||
tmp.extend(lst) |
|
||||
|
|
||||
# link task and flags |
|
||||
if getattr(y, 'link_task', None): |
|
||||
|
|
||||
link_name = y.target[y.target.rfind(os.sep) + 1:] |
|
||||
if 'cstaticlib' in y.features: |
|
||||
env.append_value('STATICLIB', link_name) |
|
||||
elif 'cshlib' in y.features or 'cprogram' in y.features: |
|
||||
# WARNING some linkers can link against programs |
|
||||
env.append_value('LIB', link_name) |
|
||||
|
|
||||
# the order |
|
||||
self.link_task.set_run_after(y.link_task) |
|
||||
|
|
||||
# for the recompilation |
|
||||
dep_nodes = getattr(self.link_task, 'dep_nodes', []) |
|
||||
self.link_task.dep_nodes = dep_nodes + y.link_task.outputs |
|
||||
|
|
||||
# add the link path too |
|
||||
tmp_path = y.link_task.outputs[0].parent.bldpath(self.env) |
|
||||
if not tmp_path in env['LIBPATH']: env.prepend_value('LIBPATH', tmp_path) |
|
||||
|
|
||||
# add ancestors uselib too - but only propagate those that have no staticlib |
|
||||
for v in self.to_list(y.uselib): |
|
||||
if not env['STATICLIB_' + v]: |
|
||||
if not v in self.uselib: |
|
||||
self.uselib.insert(0, v) |
|
||||
|
|
||||
# if the library task generator provides 'export_incdirs', add to the include path |
|
||||
# the export_incdirs must be a list of paths relative to the other library |
|
||||
if getattr(y, 'export_incdirs', None): |
|
||||
for x in self.to_list(y.export_incdirs): |
|
||||
node = y.path.find_dir(x) |
|
||||
if not node: |
|
||||
raise Utils.WafError('object %r: invalid folder %r in export_incdirs' % (y.target, x)) |
|
||||
self.env.append_unique('INC_PATHS', node) |
|
||||
|
|
||||
# 2. the case of the libs defined outside |
|
||||
for x in self.uselib: |
|
||||
for v in self.p_flag_vars: |
|
||||
val = self.env[v + '_' + x] |
|
||||
if val: self.env.append_value(v, val) |
|
||||
|
|
||||
@feature('cprogram', 'cstaticlib', 'cshlib') |
|
||||
@after('init_cc', 'init_cxx', 'apply_link') |
|
||||
def apply_objdeps(self): |
|
||||
"add the .o files produced by some other object files in the same manner as uselib_local" |
|
||||
if not getattr(self, 'add_objects', None): return |
|
||||
|
|
||||
seen = [] |
|
||||
names = self.to_list(self.add_objects) |
|
||||
while names: |
|
||||
x = names[0] |
|
||||
|
|
||||
# visit dependencies only once |
|
||||
if x in seen: |
|
||||
names = names[1:] |
|
||||
continue |
|
||||
|
|
||||
# object does not exist ? |
|
||||
y = self.name_to_obj(x) |
|
||||
if not y: |
|
||||
raise Utils.WafError('object %r was not found in uselib_local (required by add_objects %r)' % (x, self.name)) |
|
||||
|
|
||||
# object has ancestors to process first ? update the list of names |
|
||||
if getattr(y, 'add_objects', None): |
|
||||
added = 0 |
|
||||
lst = y.to_list(y.add_objects) |
|
||||
lst.reverse() |
|
||||
for u in lst: |
|
||||
if u in seen: continue |
|
||||
added = 1 |
|
||||
names = [u]+names |
|
||||
if added: continue # list of names modified, loop |
|
||||
|
|
||||
# safe to process the current object |
|
||||
y.post() |
|
||||
seen.append(x) |
|
||||
|
|
||||
for t in y.compiled_tasks: |
|
||||
self.link_task.inputs.extend(t.outputs) |
|
||||
|
|
||||
@feature('cprogram', 'cshlib', 'cstaticlib') |
|
||||
@after('apply_lib_vars') |
|
||||
def apply_obj_vars(self): |
|
||||
"""after apply_lib_vars for uselib""" |
|
||||
v = self.env |
|
||||
lib_st = v['LIB_ST'] |
|
||||
staticlib_st = v['STATICLIB_ST'] |
|
||||
libpath_st = v['LIBPATH_ST'] |
|
||||
staticlibpath_st = v['STATICLIBPATH_ST'] |
|
||||
rpath_st = v['RPATH_ST'] |
|
||||
|
|
||||
app = v.append_unique |
|
||||
|
|
||||
if v['FULLSTATIC']: |
|
||||
v.append_value('LINKFLAGS', v['FULLSTATIC_MARKER']) |
|
||||
|
|
||||
for i in v['RPATH']: |
|
||||
if i and rpath_st: |
|
||||
app('LINKFLAGS', rpath_st % i) |
|
||||
|
|
||||
for i in v['LIBPATH']: |
|
||||
app('LINKFLAGS', libpath_st % i) |
|
||||
app('LINKFLAGS', staticlibpath_st % i) |
|
||||
|
|
||||
if v['STATICLIB']: |
|
||||
v.append_value('LINKFLAGS', v['STATICLIB_MARKER']) |
|
||||
k = [(staticlib_st % i) for i in v['STATICLIB']] |
|
||||
app('LINKFLAGS', k) |
|
||||
|
|
||||
# fully static binaries ? |
|
||||
if not v['FULLSTATIC']: |
|
||||
if v['STATICLIB'] or v['LIB']: |
|
||||
v.append_value('LINKFLAGS', v['SHLIB_MARKER']) |
|
||||
|
|
||||
app('LINKFLAGS', [lib_st % i for i in v['LIB']]) |
|
||||
|
|
||||
@after('apply_link') |
|
||||
def process_obj_files(self): |
|
||||
if not hasattr(self, 'obj_files'): return |
|
||||
for x in self.obj_files: |
|
||||
node = self.path.find_resource(x) |
|
||||
self.link_task.inputs.append(node) |
|
||||
|
|
||||
@taskgen |
|
||||
def add_obj_file(self, file): |
|
||||
"""Small example on how to link object files as if they were source |
|
||||
obj = bld.create_obj('cc') |
|
||||
obj.add_obj_file('foo.o')""" |
|
||||
if not hasattr(self, 'obj_files'): self.obj_files = [] |
|
||||
if not 'process_obj_files' in self.meths: self.meths.append('process_obj_files') |
|
||||
self.obj_files.append(file) |
|
||||
|
|
||||
c_attrs = { |
|
||||
'cxxflag' : 'CXXFLAGS', |
|
||||
'cflag' : 'CCFLAGS', |
|
||||
'ccflag' : 'CCFLAGS', |
|
||||
'linkflag' : 'LINKFLAGS', |
|
||||
'ldflag' : 'LINKFLAGS', |
|
||||
'lib' : 'LIB', |
|
||||
'libpath' : 'LIBPATH', |
|
||||
'staticlib': 'STATICLIB', |
|
||||
'staticlibpath': 'STATICLIBPATH', |
|
||||
'rpath' : 'RPATH', |
|
||||
'framework' : 'FRAMEWORK', |
|
||||
'frameworkpath' : 'FRAMEWORKPATH' |
|
||||
} |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@before('init_cxx', 'init_cc') |
|
||||
@before('apply_lib_vars', 'apply_obj_vars', 'apply_incpaths', 'init_cc') |
|
||||
def add_extra_flags(self): |
|
||||
"""case and plural insensitive |
|
||||
before apply_obj_vars for processing the library attributes |
|
||||
""" |
|
||||
for x in self.__dict__.keys(): |
|
||||
y = x.lower() |
|
||||
if y[-1] == 's': |
|
||||
y = y[:-1] |
|
||||
if c_attrs.get(y, None): |
|
||||
self.env.append_unique(c_attrs[y], getattr(self, x)) |
|
||||
|
|
||||
# ============ the code above must not know anything about import libs ========== |
|
||||
|
|
||||
@feature('cshlib') |
|
||||
@after('apply_link', 'default_cc') |
|
||||
@before('apply_lib_vars', 'apply_objdeps', 'default_link_install') |
|
||||
def apply_implib(self): |
|
||||
"""On mswindows, handle dlls and their import libs |
|
||||
the .dll.a is the import lib and it is required for linking so it is installed too |
|
||||
""" |
|
||||
if not self.env.DEST_BINFMT == 'pe': |
|
||||
return |
|
||||
|
|
||||
self.meths.remove('default_link_install') |
|
||||
|
|
||||
bindir = self.install_path |
|
||||
if not bindir: return |
|
||||
|
|
||||
# install the dll in the bin dir |
|
||||
dll = self.link_task.outputs[0] |
|
||||
self.bld.install_files(bindir, dll, self.env, self.chmod) |
|
||||
|
|
||||
# add linker flags to generate the import lib |
|
||||
implib = self.env['implib_PATTERN'] % os.path.split(self.target)[1] |
|
||||
|
|
||||
implib = dll.parent.find_or_declare(implib) |
|
||||
self.link_task.outputs.append(implib) |
|
||||
self.bld.install_as('${LIBDIR}/%s' % implib.name, implib, self.env) |
|
||||
|
|
||||
self.env.append_value('LINKFLAGS', (self.env['IMPLIB_ST'] % implib.bldpath(self.env)).split()) |
|
||||
|
|
||||
# ============ the code above must not know anything about vnum processing on unix platforms ========= |
|
||||
|
|
||||
@feature('cshlib') |
|
||||
@after('apply_link') |
|
||||
@before('apply_lib_vars', 'default_link_install') |
|
||||
def apply_vnum(self): |
|
||||
""" |
|
||||
libfoo.so is installed as libfoo.so.1.2.3 |
|
||||
""" |
|
||||
if not getattr(self, 'vnum', '') or not 'cshlib' in self.features or os.name != 'posix' or self.env.DEST_BINFMT not in ('elf', 'mac-o'): |
|
||||
return |
|
||||
|
|
||||
self.meths.remove('default_link_install') |
|
||||
|
|
||||
link = self.link_task |
|
||||
nums = self.vnum.split('.') |
|
||||
node = link.outputs[0] |
|
||||
|
|
||||
libname = node.name |
|
||||
if libname.endswith('.dylib'): |
|
||||
name3 = libname.replace('.dylib', '.%s.dylib' % self.vnum) |
|
||||
name2 = libname.replace('.dylib', '.%s.dylib' % nums[0]) |
|
||||
else: |
|
||||
name3 = libname + '.' + self.vnum |
|
||||
name2 = libname + '.' + nums[0] |
|
||||
|
|
||||
if self.env.SONAME_ST: |
|
||||
v = self.env.SONAME_ST % name2 |
|
||||
self.env.append_value('LINKFLAGS', v.split()) |
|
||||
|
|
||||
bld = self.bld |
|
||||
nums = self.vnum.split('.') |
|
||||
|
|
||||
path = self.install_path |
|
||||
if not path: return |
|
||||
|
|
||||
bld.install_as(path + os.sep + name3, node, env=self.env) |
|
||||
bld.symlink_as(path + os.sep + name2, name3) |
|
||||
bld.symlink_as(path + os.sep + libname, name3) |
|
||||
|
|
||||
# the following task is just to enable execution from the build dir :-/ |
|
||||
tsk = self.create_task('vnum') |
|
||||
tsk.set_inputs([node]) |
|
||||
tsk.set_outputs(node.parent.find_or_declare(name2)) |
|
||||
|
|
||||
def exec_vnum_link(self): |
|
||||
path = self.outputs[0].abspath(self.env) |
|
||||
try: |
|
||||
os.remove(path) |
|
||||
except OSError: |
|
||||
pass |
|
||||
|
|
||||
try: |
|
||||
os.symlink(self.inputs[0].name, path) |
|
||||
except OSError: |
|
||||
return 1 |
|
||||
|
|
||||
cls = Task.task_type_from_func('vnum', func=exec_vnum_link, ext_in='.bin', color='CYAN') |
|
||||
cls.quiet = 1 |
|
||||
|
|
||||
# ============ the --as-needed flag should added during the configuration, not at runtime ========= |
|
||||
|
|
||||
@conftest |
|
||||
def add_as_needed(conf): |
|
||||
if conf.env.DEST_BINFMT == 'elf' and 'gcc' in (conf.env.CXX_NAME, conf.env.CC_NAME): |
|
||||
conf.env.append_unique('LINKFLAGS', '--as-needed') |
|
||||
|
|
||||
@ -1,66 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Matthias Jahn jahn dôt matthias ât freenet dôt de, 2007 (pmarat) |
|
||||
|
|
||||
import os, sys, imp, types, ccroot |
|
||||
import optparse |
|
||||
import Utils, Configure, Options |
|
||||
from Logs import debug |
|
||||
|
|
||||
c_compiler = { |
|
||||
'win32': ['gcc'], |
|
||||
'cygwin': ['gcc'], |
|
||||
'darwin': ['gcc'], |
|
||||
'aix': ['xlc', 'gcc'], |
|
||||
'linux': ['gcc', 'icc', 'suncc'], |
|
||||
'sunos': ['gcc', 'suncc'], |
|
||||
'irix': ['gcc'], |
|
||||
'hpux': ['gcc'], |
|
||||
'default': ['gcc'] |
|
||||
} |
|
||||
|
|
||||
def __list_possible_compiler(platform): |
|
||||
try: |
|
||||
return c_compiler[platform] |
|
||||
except KeyError: |
|
||||
return c_compiler["default"] |
|
||||
|
|
||||
def detect(conf): |
|
||||
""" |
|
||||
for each compiler for the platform, try to configure the compiler |
|
||||
in theory the tools should raise a configuration error if the compiler |
|
||||
pretends to be something it is not (setting CC=icc and trying to configure gcc) |
|
||||
""" |
|
||||
try: test_for_compiler = Options.options.check_c_compiler |
|
||||
except AttributeError: conf.fatal("Add set_options(opt): opt.tool_options('compiler_cc')") |
|
||||
orig = conf.env |
|
||||
for compiler in test_for_compiler.split(): |
|
||||
conf.env = orig.copy() |
|
||||
try: |
|
||||
conf.check_tool(compiler) |
|
||||
except Configure.ConfigurationError, e: |
|
||||
debug('compiler_cc: %r' % e) |
|
||||
else: |
|
||||
if conf.env['CC']: |
|
||||
orig.table = conf.env.get_merged_dict() |
|
||||
conf.env = orig |
|
||||
conf.check_message(compiler, '', True) |
|
||||
conf.env['COMPILER_CC'] = compiler |
|
||||
break |
|
||||
conf.check_message(compiler, '', False) |
|
||||
break |
|
||||
else: |
|
||||
conf.fatal('could not configure a c compiler!') |
|
||||
|
|
||||
def set_options(opt): |
|
||||
build_platform = Utils.unversioned_sys_platform() |
|
||||
possible_compiler_list = __list_possible_compiler(build_platform) |
|
||||
test_for_compiler = ' '.join(possible_compiler_list) |
|
||||
cc_compiler_opts = opt.add_option_group("C Compiler Options") |
|
||||
cc_compiler_opts.add_option('--check-c-compiler', default="%s" % test_for_compiler, |
|
||||
help='On this platform (%s) the following C-Compiler will be checked by default: "%s"' % (build_platform, test_for_compiler), |
|
||||
dest="check_c_compiler") |
|
||||
|
|
||||
for c_compiler in test_for_compiler.split(): |
|
||||
opt.tool_options('%s' % c_compiler, option_group=cc_compiler_opts) |
|
||||
|
|
||||
@ -1,61 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Matthias Jahn jahn dôt matthias ât freenet dôt de 2007 (pmarat) |
|
||||
|
|
||||
import os, sys, imp, types, ccroot |
|
||||
import optparse |
|
||||
import Utils, Configure, Options |
|
||||
from Logs import debug |
|
||||
|
|
||||
cxx_compiler = { |
|
||||
'win32': ['g++'], |
|
||||
'cygwin': ['g++'], |
|
||||
'darwin': ['g++'], |
|
||||
'aix': ['xlc++', 'g++'], |
|
||||
'linux': ['g++', 'icpc', 'sunc++'], |
|
||||
'sunos': ['g++', 'sunc++'], |
|
||||
'irix': ['g++'], |
|
||||
'hpux': ['g++'], |
|
||||
'default': ['g++'] |
|
||||
} |
|
||||
|
|
||||
def __list_possible_compiler(platform): |
|
||||
try: |
|
||||
return cxx_compiler[platform] |
|
||||
except KeyError: |
|
||||
return cxx_compiler["default"] |
|
||||
|
|
||||
def detect(conf): |
|
||||
try: test_for_compiler = Options.options.check_cxx_compiler |
|
||||
except AttributeError: raise Configure.ConfigurationError("Add set_options(opt): opt.tool_options('compiler_cxx')") |
|
||||
orig = conf.env |
|
||||
for compiler in test_for_compiler.split(): |
|
||||
try: |
|
||||
conf.env = orig.copy() |
|
||||
conf.check_tool(compiler) |
|
||||
except Configure.ConfigurationError, e: |
|
||||
debug('compiler_cxx: %r' % e) |
|
||||
else: |
|
||||
if conf.env['CXX']: |
|
||||
orig.table = conf.env.get_merged_dict() |
|
||||
conf.env = orig |
|
||||
conf.check_message(compiler, '', True) |
|
||||
conf.env['COMPILER_CXX'] = compiler |
|
||||
break |
|
||||
conf.check_message(compiler, '', False) |
|
||||
break |
|
||||
else: |
|
||||
conf.fatal('could not configure a cxx compiler!') |
|
||||
|
|
||||
def set_options(opt): |
|
||||
build_platform = Utils.unversioned_sys_platform() |
|
||||
possible_compiler_list = __list_possible_compiler(build_platform) |
|
||||
test_for_compiler = ' '.join(possible_compiler_list) |
|
||||
cxx_compiler_opts = opt.add_option_group('C++ Compiler Options') |
|
||||
cxx_compiler_opts.add_option('--check-cxx-compiler', default="%s" % test_for_compiler, |
|
||||
help='On this platform (%s) the following C++ Compiler will be checked by default: "%s"' % (build_platform, test_for_compiler), |
|
||||
dest="check_cxx_compiler") |
|
||||
|
|
||||
for cxx_compiler in test_for_compiler.split(): |
|
||||
opt.tool_options('%s' % cxx_compiler, option_group=cxx_compiler_opts) |
|
||||
|
|
||||
@ -1,33 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Carlos Rafael Giani, 2007 (dv) |
|
||||
|
|
||||
import os, sys, imp, types |
|
||||
import Utils, Configure, Options |
|
||||
|
|
||||
def detect(conf): |
|
||||
if getattr(Options.options, 'check_dmd_first', None): |
|
||||
test_for_compiler = ['dmd', 'gdc'] |
|
||||
else: |
|
||||
test_for_compiler = ['gdc', 'dmd'] |
|
||||
|
|
||||
for d_compiler in test_for_compiler: |
|
||||
try: |
|
||||
conf.check_tool(d_compiler) |
|
||||
except: |
|
||||
pass |
|
||||
else: |
|
||||
break |
|
||||
else: |
|
||||
conf.fatal('no suitable d compiler was found') |
|
||||
|
|
||||
def set_options(opt): |
|
||||
d_compiler_opts = opt.add_option_group('D Compiler Options') |
|
||||
d_compiler_opts.add_option('--check-dmd-first', action='store_true', |
|
||||
help='checks for the gdc compiler before dmd (default is the other way round)', |
|
||||
dest='check_dmd_first', |
|
||||
default=False) |
|
||||
|
|
||||
for d_compiler in ['gdc', 'dmd']: |
|
||||
opt.tool_options('%s' % d_compiler, option_group=d_compiler_opts) |
|
||||
|
|
||||
@ -1,729 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005-2008 (ita) |
|
||||
|
|
||||
""" |
|
||||
c/c++ configuration routines |
|
||||
""" |
|
||||
|
|
||||
import os, imp, sys, shlex, shutil |
|
||||
from Utils import md5 |
|
||||
import Build, Utils, Configure, Task, Options, Logs, TaskGen |
|
||||
from Constants import * |
|
||||
from Configure import conf, conftest |
|
||||
|
|
||||
cfg_ver = { |
|
||||
'atleast-version': '>=', |
|
||||
'exact-version': '==', |
|
||||
'max-version': '<=', |
|
||||
} |
|
||||
|
|
||||
SNIP1 = ''' |
|
||||
int main() { |
|
||||
void *p; |
|
||||
p=(void*)(%s); |
|
||||
return 0; |
|
||||
} |
|
||||
''' |
|
||||
|
|
||||
SNIP2 = ''' |
|
||||
int main() { |
|
||||
if ((%(type_name)s *) 0) return 0; |
|
||||
if (sizeof (%(type_name)s)) return 0; |
|
||||
} |
|
||||
''' |
|
||||
|
|
||||
SNIP3 = ''' |
|
||||
int main() { |
|
||||
return 0; |
|
||||
} |
|
||||
''' |
|
||||
|
|
||||
def parse_flags(line, uselib, env): |
|
||||
"""pkg-config still has bugs on some platforms, and there are many -config programs, parsing flags is necessary :-/""" |
|
||||
|
|
||||
lst = shlex.split(line) |
|
||||
while lst: |
|
||||
x = lst.pop(0) |
|
||||
st = x[:2] |
|
||||
ot = x[2:] |
|
||||
|
|
||||
if st == '-I' or st == '/I': |
|
||||
if not ot: ot = lst.pop(0) |
|
||||
env.append_unique('CPPPATH_' + uselib, ot) |
|
||||
elif st == '-D': |
|
||||
if not ot: ot = lst.pop(0) |
|
||||
env.append_unique('CXXDEFINES_' + uselib, ot) |
|
||||
env.append_unique('CCDEFINES_' + uselib, ot) |
|
||||
elif st == '-l': |
|
||||
if not ot: ot = lst.pop(0) |
|
||||
env.append_unique('LIB_' + uselib, ot) |
|
||||
elif st == '-L': |
|
||||
if not ot: ot = lst.pop(0) |
|
||||
env.append_unique('LIBPATH_' + uselib, ot) |
|
||||
elif x == '-pthread' or x.startswith('+'): |
|
||||
env.append_unique('CCFLAGS_' + uselib, x) |
|
||||
env.append_unique('CXXFLAGS_' + uselib, x) |
|
||||
env.append_unique('LINKFLAGS_' + uselib, x) |
|
||||
elif x == '-framework': |
|
||||
env.append_unique('FRAMEWORK_' + uselib, lst.pop(0)) |
|
||||
elif x.startswith('-F'): |
|
||||
env.append_unique('FRAMEWORKPATH_' + uselib, x[2:]) |
|
||||
elif x.startswith('-std'): |
|
||||
env.append_unique('CCFLAGS_' + uselib, x) |
|
||||
env.append_unique('LINKFLAGS_' + uselib, x) |
|
||||
elif x.startswith('-Wl'): |
|
||||
env.append_unique('LINKFLAGS_' + uselib, x) |
|
||||
elif x.startswith('-m') or x.startswith('-f'): |
|
||||
env.append_unique('CCFLAGS_' + uselib, x) |
|
||||
env.append_unique('CXXFLAGS_' + uselib, x) |
|
||||
|
|
||||
@conf |
|
||||
def ret_msg(self, f, kw): |
|
||||
"""execute a function, when provided""" |
|
||||
if isinstance(f, str): |
|
||||
return f |
|
||||
return f(kw) |
|
||||
|
|
||||
@conf |
|
||||
def validate_cfg(self, kw): |
|
||||
if not 'path' in kw: |
|
||||
kw['path'] = 'pkg-config --errors-to-stdout --print-errors' |
|
||||
|
|
||||
# pkg-config version |
|
||||
if 'atleast_pkgconfig_version' in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for pkg-config version >= %s' % kw['atleast_pkgconfig_version'] |
|
||||
return |
|
||||
|
|
||||
# pkg-config --modversion |
|
||||
if 'modversion' in kw: |
|
||||
return |
|
||||
|
|
||||
if 'variables' in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for %s variables' % kw['package'] |
|
||||
return |
|
||||
|
|
||||
# checking for the version of a module, for the moment, one thing at a time |
|
||||
for x in cfg_ver.keys(): |
|
||||
y = x.replace('-', '_') |
|
||||
if y in kw: |
|
||||
if not 'package' in kw: |
|
||||
raise ValueError('%s requires a package' % x) |
|
||||
|
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for %s %s %s' % (kw['package'], cfg_ver[x], kw[y]) |
|
||||
return |
|
||||
|
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for %s' % (kw['package'] or kw['path']) |
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
if not 'errmsg' in kw: |
|
||||
kw['errmsg'] = 'not found' |
|
||||
|
|
||||
@conf |
|
||||
def cmd_and_log(self, cmd, kw): |
|
||||
Logs.debug('runner: %s\n' % cmd) |
|
||||
if self.log: |
|
||||
self.log.write('%s\n' % cmd) |
|
||||
|
|
||||
try: |
|
||||
p = Utils.pproc.Popen(cmd, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE, shell=True) |
|
||||
(out, err) = p.communicate() |
|
||||
except OSError, e: |
|
||||
self.log.write('error %r' % e) |
|
||||
self.fatal(str(e)) |
|
||||
|
|
||||
out = str(out) |
|
||||
err = str(err) |
|
||||
|
|
||||
if self.log: |
|
||||
self.log.write(out) |
|
||||
self.log.write(err) |
|
||||
|
|
||||
if p.returncode: |
|
||||
if not kw.get('errmsg', ''): |
|
||||
if kw.get('mandatory', False): |
|
||||
kw['errmsg'] = out.strip() |
|
||||
else: |
|
||||
kw['errmsg'] = 'no' |
|
||||
self.fatal('fail') |
|
||||
return out |
|
||||
|
|
||||
@conf |
|
||||
def exec_cfg(self, kw): |
|
||||
|
|
||||
# pkg-config version |
|
||||
if 'atleast_pkgconfig_version' in kw: |
|
||||
cmd = '%s --atleast-pkgconfig-version=%s' % (kw['path'], kw['atleast_pkgconfig_version']) |
|
||||
self.cmd_and_log(cmd, kw) |
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
return |
|
||||
|
|
||||
# checking for the version of a module |
|
||||
for x in cfg_ver: |
|
||||
y = x.replace('-', '_') |
|
||||
if y in kw: |
|
||||
self.cmd_and_log('%s --%s=%s %s' % (kw['path'], x, kw[y], kw['package']), kw) |
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0) |
|
||||
break |
|
||||
|
|
||||
# retrieving the version of a module |
|
||||
if 'modversion' in kw: |
|
||||
version = self.cmd_and_log('%s --modversion %s' % (kw['path'], kw['modversion']), kw).strip() |
|
||||
self.define('%s_VERSION' % Utils.quote_define_name(kw.get('uselib_store', kw['modversion'])), version) |
|
||||
return version |
|
||||
|
|
||||
# retrieving variables of a module |
|
||||
if 'variables' in kw: |
|
||||
env = kw.get('env', self.env) |
|
||||
uselib = kw.get('uselib_store', kw['package'].upper()) |
|
||||
vars = Utils.to_list(kw['variables']) |
|
||||
for v in vars: |
|
||||
val = self.cmd_and_log('%s --variable=%s %s' % (kw['path'], v, kw['package']), kw).strip() |
|
||||
var = '%s_%s' % (uselib, v) |
|
||||
env[var] = val |
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
return |
|
||||
|
|
||||
lst = [kw['path']] |
|
||||
for key, val in kw.get('define_variable', {}).iteritems(): |
|
||||
lst.append('--define-variable=%s=%s' % (key, val)) |
|
||||
|
|
||||
lst.append(kw.get('args', '')) |
|
||||
lst.append(kw['package']) |
|
||||
|
|
||||
# so we assume the command-line will output flags to be parsed afterwards |
|
||||
cmd = ' '.join(lst) |
|
||||
ret = self.cmd_and_log(cmd, kw) |
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
|
|
||||
self.define(self.have_define(kw.get('uselib_store', kw['package'])), 1, 0) |
|
||||
parse_flags(ret, kw.get('uselib_store', kw['package'].upper()), kw.get('env', self.env)) |
|
||||
return ret |
|
||||
|
|
||||
@conf |
|
||||
def check_cfg(self, *k, **kw): |
|
||||
""" |
|
||||
for pkg-config mostly, but also all the -config tools |
|
||||
conf.check_cfg(path='mpicc', args='--showme:compile --showme:link', package='', uselib_store='OPEN_MPI') |
|
||||
conf.check_cfg(package='dbus-1', variables='system_bus_default_address session_bus_services_dir') |
|
||||
""" |
|
||||
|
|
||||
self.validate_cfg(kw) |
|
||||
if 'msg' in kw: |
|
||||
self.check_message_1(kw['msg']) |
|
||||
ret = None |
|
||||
try: |
|
||||
ret = self.exec_cfg(kw) |
|
||||
except Configure.ConfigurationError, e: |
|
||||
if 'errmsg' in kw: |
|
||||
self.check_message_2(kw['errmsg'], 'YELLOW') |
|
||||
if 'mandatory' in kw and kw['mandatory']: |
|
||||
if Logs.verbose > 1: |
|
||||
raise |
|
||||
else: |
|
||||
self.fatal('the configuration failed (see %r)' % self.log.name) |
|
||||
else: |
|
||||
kw['success'] = ret |
|
||||
if 'okmsg' in kw: |
|
||||
self.check_message_2(self.ret_msg(kw['okmsg'], kw)) |
|
||||
|
|
||||
return ret |
|
||||
|
|
||||
# the idea is the following: now that we are certain |
|
||||
# that all the code here is only for c or c++, it is |
|
||||
# easy to put all the logic in one function |
|
||||
# |
|
||||
# this should prevent code duplication (ita) |
|
||||
|
|
||||
# env: an optional environment (modified -> provide a copy) |
|
||||
# compiler: cc or cxx - it tries to guess what is best |
|
||||
# type: cprogram, cshlib, cstaticlib |
|
||||
# code: a c code to execute |
|
||||
# uselib_store: where to add the variables |
|
||||
# uselib: parameters to use for building |
|
||||
# define: define to set, like FOO in #define FOO, if not set, add /* #undef FOO */ |
|
||||
# execute: True or False - will return the result of the execution |
|
||||
|
|
||||
@conf |
|
||||
def validate_c(self, kw): |
|
||||
"""validate the parameters for the test method""" |
|
||||
|
|
||||
if not 'env' in kw: |
|
||||
kw['env'] = self.env.copy() |
|
||||
|
|
||||
env = kw['env'] |
|
||||
if not 'compiler' in kw: |
|
||||
kw['compiler'] = 'cc' |
|
||||
if env['CXX_NAME'] and Task.TaskBase.classes.get('cxx', None): |
|
||||
kw['compiler'] = 'cxx' |
|
||||
if not self.env['CXX']: |
|
||||
self.fatal('a c++ compiler is required') |
|
||||
else: |
|
||||
if not self.env['CC']: |
|
||||
self.fatal('a c compiler is required') |
|
||||
|
|
||||
if not 'type' in kw: |
|
||||
kw['type'] = 'cprogram' |
|
||||
|
|
||||
assert not(kw['type'] != 'cprogram' and kw.get('execute', 0)), 'can only execute programs' |
|
||||
|
|
||||
|
|
||||
#if kw['type'] != 'program' and kw.get('execute', 0): |
|
||||
# raise ValueError, 'can only execute programs' |
|
||||
|
|
||||
def to_header(dct): |
|
||||
if 'header_name' in dct: |
|
||||
dct = Utils.to_list(dct['header_name']) |
|
||||
return ''.join(['#include <%s>\n' % x for x in dct]) |
|
||||
return '' |
|
||||
|
|
||||
# set the file name |
|
||||
if not 'compile_mode' in kw: |
|
||||
kw['compile_mode'] = (kw['compiler'] == 'cxx') and 'cxx' or 'cc' |
|
||||
|
|
||||
if not 'compile_filename' in kw: |
|
||||
kw['compile_filename'] = 'test.c' + ((kw['compile_mode'] == 'cxx') and 'pp' or '') |
|
||||
|
|
||||
#OSX |
|
||||
if 'framework_name' in kw: |
|
||||
try: TaskGen.task_gen.create_task_macapp |
|
||||
except AttributeError: self.fatal('frameworks require the osx tool') |
|
||||
|
|
||||
fwkname = kw['framework_name'] |
|
||||
if not 'uselib_store' in kw: |
|
||||
kw['uselib_store'] = fwkname.upper() |
|
||||
|
|
||||
if not kw.get('no_header', False): |
|
||||
if not 'header_name' in kw: |
|
||||
kw['header_name'] = [] |
|
||||
fwk = '%s/%s.h' % (fwkname, fwkname) |
|
||||
if kw.get('remove_dot_h', None): |
|
||||
fwk = fwk[:-2] |
|
||||
kw['header_name'] = Utils.to_list(kw['header_name']) + [fwk] |
|
||||
|
|
||||
kw['msg'] = 'Checking for framework %s' % fwkname |
|
||||
kw['framework'] = fwkname |
|
||||
#kw['frameworkpath'] = set it yourself |
|
||||
|
|
||||
if 'function_name' in kw: |
|
||||
fu = kw['function_name'] |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for function %s' % fu |
|
||||
kw['code'] = to_header(kw) + SNIP1 % fu |
|
||||
if not 'uselib_store' in kw: |
|
||||
kw['uselib_store'] = fu.upper() |
|
||||
if not 'define_name' in kw: |
|
||||
kw['define_name'] = self.have_define(fu) |
|
||||
|
|
||||
elif 'type_name' in kw: |
|
||||
tu = kw['type_name'] |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for type %s' % tu |
|
||||
if not 'header_name' in kw: |
|
||||
kw['header_name'] = 'stdint.h' |
|
||||
kw['code'] = to_header(kw) + SNIP2 % {'type_name' : tu} |
|
||||
if not 'define_name' in kw: |
|
||||
kw['define_name'] = self.have_define(tu.upper()) |
|
||||
|
|
||||
elif 'header_name' in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for header %s' % kw['header_name'] |
|
||||
|
|
||||
l = Utils.to_list(kw['header_name']) |
|
||||
assert len(l)>0, 'list of headers in header_name is empty' |
|
||||
|
|
||||
kw['code'] = to_header(kw) + SNIP3 |
|
||||
|
|
||||
if not 'uselib_store' in kw: |
|
||||
kw['uselib_store'] = l[0].upper() |
|
||||
|
|
||||
if not 'define_name' in kw: |
|
||||
kw['define_name'] = self.have_define(l[0]) |
|
||||
|
|
||||
if 'lib' in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for library %s' % kw['lib'] |
|
||||
if not 'uselib_store' in kw: |
|
||||
kw['uselib_store'] = kw['lib'].upper() |
|
||||
|
|
||||
if 'staticlib' in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for static library %s' % kw['staticlib'] |
|
||||
if not 'uselib_store' in kw: |
|
||||
kw['uselib_store'] = kw['staticlib'].upper() |
|
||||
|
|
||||
if 'fragment' in kw: |
|
||||
# an additional code fragment may be provided to replace the predefined code |
|
||||
# in custom headers |
|
||||
kw['code'] = kw['fragment'] |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for custom code' |
|
||||
if not 'errmsg' in kw: |
|
||||
kw['errmsg'] = 'no' |
|
||||
|
|
||||
for (flagsname,flagstype) in [('cxxflags','compiler'), ('cflags','compiler'), ('linkflags','linker')]: |
|
||||
if flagsname in kw: |
|
||||
if not 'msg' in kw: |
|
||||
kw['msg'] = 'Checking for %s flags %s' % (flagstype, kw[flagsname]) |
|
||||
if not 'errmsg' in kw: |
|
||||
kw['errmsg'] = 'no' |
|
||||
|
|
||||
if not 'execute' in kw: |
|
||||
kw['execute'] = False |
|
||||
|
|
||||
if not 'errmsg' in kw: |
|
||||
kw['errmsg'] = 'not found' |
|
||||
|
|
||||
if not 'okmsg' in kw: |
|
||||
kw['okmsg'] = 'yes' |
|
||||
|
|
||||
if not 'code' in kw: |
|
||||
kw['code'] = SNIP3 |
|
||||
|
|
||||
if not kw.get('success'): kw['success'] = None |
|
||||
|
|
||||
assert 'msg' in kw, 'invalid parameters, read http://freehackers.org/~tnagy/wafbook/single.html#config_helpers_c' |
|
||||
|
|
||||
@conf |
|
||||
def post_check(self, *k, **kw): |
|
||||
"set the variables after a test was run successfully" |
|
||||
|
|
||||
is_success = False |
|
||||
if kw['execute']: |
|
||||
if kw['success']: |
|
||||
is_success = True |
|
||||
else: |
|
||||
is_success = (kw['success'] == 0) |
|
||||
|
|
||||
if 'define_name' in kw: |
|
||||
if 'header_name' in kw or 'function_name' in kw or 'type_name' in kw or 'fragment' in kw: |
|
||||
if kw['execute']: |
|
||||
key = kw['success'] |
|
||||
if isinstance(key, str): |
|
||||
if key: |
|
||||
self.define(kw['define_name'], key, quote=kw.get('quote', 1)) |
|
||||
else: |
|
||||
self.define_cond(kw['define_name'], True) |
|
||||
else: |
|
||||
self.define_cond(kw['define_name'], False) |
|
||||
else: |
|
||||
self.define_cond(kw['define_name'], is_success) |
|
||||
|
|
||||
if is_success and 'uselib_store' in kw: |
|
||||
import cc, cxx |
|
||||
for k in set(cc.g_cc_flag_vars).union(cxx.g_cxx_flag_vars): |
|
||||
lk = k.lower() |
|
||||
# inconsistency: includes -> CPPPATH |
|
||||
if k == 'CPPPATH': lk = 'includes' |
|
||||
if k == 'CXXDEFINES': lk = 'defines' |
|
||||
if k == 'CCDEFINES': lk = 'defines' |
|
||||
if lk in kw: |
|
||||
val = kw[lk] |
|
||||
# remove trailing slash |
|
||||
if isinstance(val, str): |
|
||||
val = val.rstrip(os.path.sep) |
|
||||
self.env.append_unique(k + '_' + kw['uselib_store'], val) |
|
||||
|
|
||||
@conf |
|
||||
def check(self, *k, **kw): |
|
||||
# so this will be the generic function |
|
||||
# it will be safer to use check_cxx or check_cc |
|
||||
self.validate_c(kw) |
|
||||
self.check_message_1(kw['msg']) |
|
||||
ret = None |
|
||||
try: |
|
||||
ret = self.run_c_code(*k, **kw) |
|
||||
except Configure.ConfigurationError, e: |
|
||||
self.check_message_2(kw['errmsg'], 'YELLOW') |
|
||||
if 'mandatory' in kw and kw['mandatory']: |
|
||||
if Logs.verbose > 1: |
|
||||
raise |
|
||||
else: |
|
||||
self.fatal('the configuration failed (see %r)' % self.log.name) |
|
||||
else: |
|
||||
kw['success'] = ret |
|
||||
self.check_message_2(self.ret_msg(kw['okmsg'], kw)) |
|
||||
|
|
||||
self.post_check(*k, **kw) |
|
||||
if not kw.get('execute', False): |
|
||||
return ret == 0 |
|
||||
return ret |
|
||||
|
|
||||
@conf |
|
||||
def run_c_code(self, *k, **kw): |
|
||||
test_f_name = kw['compile_filename'] |
|
||||
|
|
||||
k = 0 |
|
||||
while k < 10000: |
|
||||
# make certain to use a fresh folder - necessary for win32 |
|
||||
dir = os.path.join(self.blddir, '.conf_check_%d' % k) |
|
||||
|
|
||||
# if the folder already exists, remove it |
|
||||
try: |
|
||||
shutil.rmtree(dir) |
|
||||
except OSError: |
|
||||
pass |
|
||||
|
|
||||
try: |
|
||||
os.stat(dir) |
|
||||
except OSError: |
|
||||
break |
|
||||
|
|
||||
k += 1 |
|
||||
|
|
||||
try: |
|
||||
os.makedirs(dir) |
|
||||
except: |
|
||||
self.fatal('cannot create a configuration test folder %r' % dir) |
|
||||
|
|
||||
try: |
|
||||
os.stat(dir) |
|
||||
except: |
|
||||
self.fatal('cannot use the configuration test folder %r' % dir) |
|
||||
|
|
||||
bdir = os.path.join(dir, 'testbuild') |
|
||||
|
|
||||
if not os.path.exists(bdir): |
|
||||
os.makedirs(bdir) |
|
||||
|
|
||||
env = kw['env'] |
|
||||
|
|
||||
dest = open(os.path.join(dir, test_f_name), 'w') |
|
||||
dest.write(kw['code']) |
|
||||
dest.close() |
|
||||
|
|
||||
back = os.path.abspath('.') |
|
||||
|
|
||||
bld = Build.BuildContext() |
|
||||
bld.log = self.log |
|
||||
bld.all_envs.update(self.all_envs) |
|
||||
bld.all_envs['Release'] = env |
|
||||
bld.lst_variants = bld.all_envs.keys() |
|
||||
bld.load_dirs(dir, bdir) |
|
||||
|
|
||||
os.chdir(dir) |
|
||||
|
|
||||
bld.rescan(bld.srcnode) |
|
||||
|
|
||||
if not 'features' in kw: |
|
||||
# conf.check(features='cc cprogram pyext', ...) |
|
||||
kw['features'] = [kw['compile_mode'], kw['type']] # "cprogram cc" |
|
||||
|
|
||||
o = bld(features=kw['features'], source=test_f_name, target='testprog') |
|
||||
|
|
||||
for k, v in kw.iteritems(): |
|
||||
setattr(o, k, v) |
|
||||
|
|
||||
self.log.write("==>\n%s\n<==\n" % kw['code']) |
|
||||
|
|
||||
# compile the program |
|
||||
try: |
|
||||
bld.compile() |
|
||||
except Utils.WafError: |
|
||||
ret = Utils.ex_stack() |
|
||||
else: |
|
||||
ret = 0 |
|
||||
|
|
||||
# chdir before returning |
|
||||
os.chdir(back) |
|
||||
|
|
||||
if ret: |
|
||||
self.log.write('command returned %r' % ret) |
|
||||
self.fatal(str(ret)) |
|
||||
|
|
||||
# if we need to run the program, try to get its result |
|
||||
# keep the name of the program to execute |
|
||||
if kw['execute']: |
|
||||
lastprog = o.link_task.outputs[0].abspath(env) |
|
||||
|
|
||||
args = Utils.to_list(kw.get('exec_args', [])) |
|
||||
proc = Utils.pproc.Popen([lastprog] + args, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE) |
|
||||
(out, err) = proc.communicate() |
|
||||
w = self.log.write |
|
||||
w(str(out)) |
|
||||
w('\n') |
|
||||
w(str(err)) |
|
||||
w('\n') |
|
||||
w('returncode %r' % proc.returncode) |
|
||||
w('\n') |
|
||||
if proc.returncode: |
|
||||
self.fatal(Utils.ex_stack()) |
|
||||
ret = out |
|
||||
|
|
||||
return ret |
|
||||
|
|
||||
@conf |
|
||||
def check_cxx(self, *k, **kw): |
|
||||
kw['compiler'] = 'cxx' |
|
||||
return self.check(*k, **kw) |
|
||||
|
|
||||
@conf |
|
||||
def check_cc(self, *k, **kw): |
|
||||
kw['compiler'] = 'cc' |
|
||||
return self.check(*k, **kw) |
|
||||
|
|
||||
@conf |
|
||||
def define(self, define, value, quote=1): |
|
||||
"""store a single define and its state into an internal list for later |
|
||||
writing to a config header file. Value can only be |
|
||||
a string or int; other types not supported. String |
|
||||
values will appear properly quoted in the generated |
|
||||
header file.""" |
|
||||
assert define and isinstance(define, str) |
|
||||
|
|
||||
# ordered_dict is for writing the configuration header in order |
|
||||
tbl = self.env[DEFINES] or Utils.ordered_dict() |
|
||||
|
|
||||
# the user forgot to tell if the value is quoted or not |
|
||||
if isinstance(value, str): |
|
||||
if quote: |
|
||||
tbl[define] = '"%s"' % repr('"'+value)[2:-1].replace('"', '\\"') |
|
||||
else: |
|
||||
tbl[define] = value |
|
||||
elif isinstance(value, int): |
|
||||
tbl[define] = value |
|
||||
else: |
|
||||
raise TypeError('define %r -> %r must be a string or an int' % (define, value)) |
|
||||
|
|
||||
# add later to make reconfiguring faster |
|
||||
self.env[DEFINES] = tbl |
|
||||
self.env[define] = value # <- not certain this is necessary |
|
||||
|
|
||||
@conf |
|
||||
def undefine(self, define): |
|
||||
"""store a single define and its state into an internal list |
|
||||
for later writing to a config header file""" |
|
||||
assert define and isinstance(define, str) |
|
||||
|
|
||||
tbl = self.env[DEFINES] or Utils.ordered_dict() |
|
||||
|
|
||||
value = UNDEFINED |
|
||||
tbl[define] = value |
|
||||
|
|
||||
# add later to make reconfiguring faster |
|
||||
self.env[DEFINES] = tbl |
|
||||
self.env[define] = value |
|
||||
|
|
||||
@conf |
|
||||
def define_cond(self, name, value): |
|
||||
"""Conditionally define a name. |
|
||||
Formally equivalent to: if value: define(name, 1) else: undefine(name)""" |
|
||||
if value: |
|
||||
self.define(name, 1) |
|
||||
else: |
|
||||
self.undefine(name) |
|
||||
|
|
||||
@conf |
|
||||
def is_defined(self, key): |
|
||||
defines = self.env[DEFINES] |
|
||||
if not defines: |
|
||||
return False |
|
||||
try: |
|
||||
value = defines[key] |
|
||||
except KeyError: |
|
||||
return False |
|
||||
else: |
|
||||
return value != UNDEFINED |
|
||||
|
|
||||
@conf |
|
||||
def get_define(self, define): |
|
||||
"get the value of a previously stored define" |
|
||||
try: return self.env[DEFINES][define] |
|
||||
except KeyError: return None |
|
||||
|
|
||||
@conf |
|
||||
def have_define(self, name): |
|
||||
"prefix the define with 'HAVE_' and make sure it has valid characters." |
|
||||
return self.__dict__.get('HAVE_PAT', 'HAVE_%s') % Utils.quote_define_name(name) |
|
||||
|
|
||||
@conf |
|
||||
def write_config_header(self, configfile='', env='', guard='', top=False): |
|
||||
"save the defines into a file" |
|
||||
if not configfile: configfile = WAF_CONFIG_H |
|
||||
waf_guard = guard or '_%s_WAF' % Utils.quote_define_name(configfile) |
|
||||
|
|
||||
# configfile -> absolute path |
|
||||
# there is a good reason to concatenate first and to split afterwards |
|
||||
if not env: env = self.env |
|
||||
if top: |
|
||||
diff = '' |
|
||||
else: |
|
||||
diff = Utils.diff_path(self.srcdir, self.curdir) |
|
||||
full = os.sep.join([self.blddir, env.variant(), diff, configfile]) |
|
||||
full = os.path.normpath(full) |
|
||||
(dir, base) = os.path.split(full) |
|
||||
|
|
||||
try: os.makedirs(dir) |
|
||||
except: pass |
|
||||
|
|
||||
dest = open(full, 'w') |
|
||||
dest.write('/* Configuration header created by Waf - do not edit */\n') |
|
||||
dest.write('#ifndef %s\n#define %s\n\n' % (waf_guard, waf_guard)) |
|
||||
|
|
||||
dest.write(self.get_config_header()) |
|
||||
|
|
||||
# config files are not removed on "waf clean" |
|
||||
env.append_unique(CFG_FILES, os.path.join(diff, configfile)) |
|
||||
|
|
||||
dest.write('\n#endif /* %s */\n' % waf_guard) |
|
||||
dest.close() |
|
||||
|
|
||||
@conf |
|
||||
def get_config_header(self): |
|
||||
"""Fill-in the contents of the config header. Override when you need to write your own config header.""" |
|
||||
config_header = [] |
|
||||
|
|
||||
tbl = self.env[DEFINES] or Utils.ordered_dict() |
|
||||
for key in tbl.allkeys: |
|
||||
value = tbl[key] |
|
||||
if value is None: |
|
||||
config_header.append('#define %s' % key) |
|
||||
elif value is UNDEFINED: |
|
||||
config_header.append('/* #undef %s */' % key) |
|
||||
else: |
|
||||
config_header.append('#define %s %s' % (key, value)) |
|
||||
return "\n".join(config_header) |
|
||||
|
|
||||
@conftest |
|
||||
def find_cpp(conf): |
|
||||
v = conf.env |
|
||||
cpp = None |
|
||||
if v['CPP']: cpp = v['CPP'] |
|
||||
elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] |
|
||||
if not cpp: cpp = conf.find_program('cpp', var='CPP') |
|
||||
if not cpp: cpp = v['CC'] |
|
||||
if not cpp: cpp = v['CXX'] |
|
||||
v['CPP'] = cpp |
|
||||
|
|
||||
@conftest |
|
||||
def cc_add_flags(conf): |
|
||||
conf.add_os_flags('CFLAGS', 'CCFLAGS') |
|
||||
conf.add_os_flags('CPPFLAGS') |
|
||||
|
|
||||
@conftest |
|
||||
def cxx_add_flags(conf): |
|
||||
conf.add_os_flags('CXXFLAGS') |
|
||||
conf.add_os_flags('CPPFLAGS') |
|
||||
|
|
||||
@conftest |
|
||||
def link_add_flags(conf): |
|
||||
conf.add_os_flags('LINKFLAGS') |
|
||||
conf.add_os_flags('LDFLAGS', 'LINKFLAGS') |
|
||||
|
|
||||
@conftest |
|
||||
def cc_load_tools(conf): |
|
||||
conf.check_tool('cc') |
|
||||
|
|
||||
@conftest |
|
||||
def cxx_load_tools(conf): |
|
||||
conf.check_tool('cxx') |
|
||||
|
|
||||
@ -1,104 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
"Base for c++ programs and libraries" |
|
||||
|
|
||||
import TaskGen, Task, Utils |
|
||||
from Logs import debug |
|
||||
import ccroot # <- do not remove |
|
||||
from TaskGen import feature, before, extension, after |
|
||||
|
|
||||
g_cxx_flag_vars = [ |
|
||||
'CXXDEPS', 'FRAMEWORK', 'FRAMEWORKPATH', |
|
||||
'STATICLIB', 'LIB', 'LIBPATH', 'LINKFLAGS', 'RPATH', |
|
||||
'CXXFLAGS', 'CCFLAGS', 'CPPPATH', 'CPPFLAGS', 'CXXDEFINES'] |
|
||||
"main cpp variables" |
|
||||
|
|
||||
EXT_CXX = ['.cpp', '.cc', '.cxx', '.C', '.c++'] |
|
||||
|
|
||||
g_cxx_type_vars=['CXXFLAGS', 'LINKFLAGS'] |
|
||||
|
|
||||
# TODO remove in waf 1.6 |
|
||||
class cxx_taskgen(ccroot.ccroot_abstract): |
|
||||
pass |
|
||||
|
|
||||
@feature('cxx') |
|
||||
@before('apply_type_vars') |
|
||||
@after('default_cc') |
|
||||
def init_cxx(self): |
|
||||
if not 'cc' in self.features: |
|
||||
self.mappings['.c'] = TaskGen.task_gen.mappings['.cxx'] |
|
||||
|
|
||||
self.p_flag_vars = set(self.p_flag_vars).union(g_cxx_flag_vars) |
|
||||
self.p_type_vars = set(self.p_type_vars).union(g_cxx_type_vars) |
|
||||
|
|
||||
if not self.env['CXX_NAME']: |
|
||||
raise Utils.WafError("At least one compiler (g++, ..) must be selected") |
|
||||
|
|
||||
@feature('cxx') |
|
||||
@after('apply_incpaths') |
|
||||
def apply_obj_vars_cxx(self): |
|
||||
"""after apply_incpaths for INC_PATHS""" |
|
||||
env = self.env |
|
||||
app = env.append_unique |
|
||||
cxxpath_st = env['CPPPATH_ST'] |
|
||||
|
|
||||
# local flags come first |
|
||||
# set the user-defined includes paths |
|
||||
for i in env['INC_PATHS']: |
|
||||
app('_CXXINCFLAGS', cxxpath_st % i.bldpath(env)) |
|
||||
app('_CXXINCFLAGS', cxxpath_st % i.srcpath(env)) |
|
||||
|
|
||||
# set the library include paths |
|
||||
for i in env['CPPPATH']: |
|
||||
app('_CXXINCFLAGS', cxxpath_st % i) |
|
||||
|
|
||||
@feature('cxx') |
|
||||
@after('apply_lib_vars') |
|
||||
def apply_defines_cxx(self): |
|
||||
"""after uselib is set for CXXDEFINES""" |
|
||||
self.defines = getattr(self, 'defines', []) |
|
||||
lst = self.to_list(self.defines) + self.to_list(self.env['CXXDEFINES']) |
|
||||
milst = [] |
|
||||
|
|
||||
# now process the local defines |
|
||||
for defi in lst: |
|
||||
if not defi in milst: |
|
||||
milst.append(defi) |
|
||||
|
|
||||
# CXXDEFINES_USELIB |
|
||||
libs = self.to_list(self.uselib) |
|
||||
for l in libs: |
|
||||
val = self.env['CXXDEFINES_'+l] |
|
||||
if val: milst += self.to_list(val) |
|
||||
|
|
||||
self.env['DEFLINES'] = ["%s %s" % (x[0], Utils.trimquotes('='.join(x[1:]))) for x in [y.split('=') for y in milst]] |
|
||||
y = self.env['CXXDEFINES_ST'] |
|
||||
self.env['_CXXDEFFLAGS'] = [y%x for x in milst] |
|
||||
|
|
||||
@extension(EXT_CXX) |
|
||||
def cxx_hook(self, node): |
|
||||
# create the compilation task: cpp or cc |
|
||||
if getattr(self, 'obj_ext', None): |
|
||||
obj_ext = self.obj_ext |
|
||||
else: |
|
||||
obj_ext = '_%d.o' % self.idx |
|
||||
|
|
||||
task = self.create_task('cxx', node, node.change_ext(obj_ext)) |
|
||||
try: |
|
||||
self.compiled_tasks.append(task) |
|
||||
except AttributeError: |
|
||||
raise Utils.WafError('Have you forgotten to set the feature "cxx" on %s?' % str(self)) |
|
||||
return task |
|
||||
|
|
||||
cxx_str = '${CXX} ${CXXFLAGS} ${CPPFLAGS} ${_CXXINCFLAGS} ${_CXXDEFFLAGS} ${CXX_SRC_F}${SRC} ${CXX_TGT_F}${TGT}' |
|
||||
cls = Task.simple_task_type('cxx', cxx_str, color='GREEN', ext_out='.o', ext_in='.cxx', shell=False) |
|
||||
cls.scan = ccroot.scan |
|
||||
cls.vars.append('CXXDEPS') |
|
||||
|
|
||||
link_str = '${LINK_CXX} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath(env)} ${LINKFLAGS}' |
|
||||
cls = Task.simple_task_type('cxx_link', link_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False) |
|
||||
cls.maxjobs = 1 |
|
||||
cls.install = Utils.nada |
|
||||
|
|
||||
@ -1,540 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Carlos Rafael Giani, 2007 (dv) |
|
||||
# Thomas Nagy, 2007-2008 (ita) |
|
||||
|
|
||||
import os, sys, re, optparse |
|
||||
import ccroot # <- leave this |
|
||||
import TaskGen, Utils, Task, Configure, Logs, Build |
|
||||
from Logs import debug, error |
|
||||
from TaskGen import taskgen, feature, after, before, extension |
|
||||
from Configure import conftest |
|
||||
|
|
||||
EXT_D = ['.d', '.di', '.D'] |
|
||||
D_METHS = ['apply_core', 'apply_vnum', 'apply_objdeps'] # additional d methods |
|
||||
|
|
||||
def filter_comments(filename): |
|
||||
txt = Utils.readf(filename) |
|
||||
buf = [] |
|
||||
|
|
||||
i = 0 |
|
||||
max = len(txt) |
|
||||
while i < max: |
|
||||
c = txt[i] |
|
||||
# skip a string |
|
||||
if c == '"': |
|
||||
i += 1 |
|
||||
c = '' |
|
||||
while i < max: |
|
||||
p = c |
|
||||
c = txt[i] |
|
||||
i += 1 |
|
||||
if i == max: return buf |
|
||||
if c == '"': |
|
||||
cnt = 0 |
|
||||
while i < cnt and i < max: |
|
||||
#print "cntcnt = ", str(cnt), self.txt[self.i-2-cnt] |
|
||||
if txt[i-2-cnt] == '\\': cnt+=1 |
|
||||
else: break |
|
||||
#print "cnt is ", str(cnt) |
|
||||
if (cnt%2)==0: break |
|
||||
i += 1 |
|
||||
# skip a char |
|
||||
elif c == "'": |
|
||||
i += 1 |
|
||||
if i == max: return buf |
|
||||
c = txt[i] |
|
||||
if c == '\\': |
|
||||
i += 1 |
|
||||
if i == max: return buf |
|
||||
c = txt[i] |
|
||||
if c == 'x': |
|
||||
i += 2 # skip two chars |
|
||||
elif c == 'u': |
|
||||
i += 4 # skip unicode chars |
|
||||
i += 1 |
|
||||
if i == max: return buf |
|
||||
c = txt[i] |
|
||||
if c != '\'': error("uh-oh, invalid character") |
|
||||
|
|
||||
# skip a comment |
|
||||
elif c == '/': |
|
||||
if i == max: break |
|
||||
c = txt[i+1] |
|
||||
# eat /+ +/ comments |
|
||||
if c == '+': |
|
||||
i += 1 |
|
||||
nesting = 1 |
|
||||
prev = 0 |
|
||||
while i < max: |
|
||||
c = txt[i] |
|
||||
if c == '+': |
|
||||
prev = 1 |
|
||||
elif c == '/': |
|
||||
if prev: |
|
||||
nesting -= 1 |
|
||||
if nesting == 0: break |
|
||||
else: |
|
||||
if i < max: |
|
||||
i += 1 |
|
||||
c = txt[i] |
|
||||
if c == '+': |
|
||||
nesting += 1 |
|
||||
else: |
|
||||
return buf |
|
||||
else: |
|
||||
prev = 0 |
|
||||
i += 1 |
|
||||
# eat /* */ comments |
|
||||
elif c == '*': |
|
||||
i += 1 |
|
||||
while i < max: |
|
||||
c = txt[i] |
|
||||
if c == '*': |
|
||||
prev = 1 |
|
||||
elif c == '/': |
|
||||
if prev: break |
|
||||
else: |
|
||||
prev = 0 |
|
||||
i += 1 |
|
||||
# eat // comments |
|
||||
elif c == '/': |
|
||||
i += 1 |
|
||||
c = txt[i] |
|
||||
while i < max and c != '\n': |
|
||||
i += 1 |
|
||||
c = txt[i] |
|
||||
# a valid char, add it to the buffer |
|
||||
else: |
|
||||
buf.append(c) |
|
||||
i += 1 |
|
||||
return buf |
|
||||
|
|
||||
class d_parser(object): |
|
||||
def __init__(self, env, incpaths): |
|
||||
#self.code = '' |
|
||||
#self.module = '' |
|
||||
#self.imports = [] |
|
||||
|
|
||||
self.allnames = [] |
|
||||
|
|
||||
self.re_module = re.compile("module\s+([^;]+)") |
|
||||
self.re_import = re.compile("import\s+([^;]+)") |
|
||||
self.re_import_bindings = re.compile("([^:]+):(.*)") |
|
||||
self.re_import_alias = re.compile("[^=]+=(.+)") |
|
||||
|
|
||||
self.env = env |
|
||||
|
|
||||
self.nodes = [] |
|
||||
self.names = [] |
|
||||
|
|
||||
self.incpaths = incpaths |
|
||||
|
|
||||
def tryfind(self, filename): |
|
||||
found = 0 |
|
||||
for n in self.incpaths: |
|
||||
found = n.find_resource(filename.replace('.', '/') + '.d') |
|
||||
if found: |
|
||||
self.nodes.append(found) |
|
||||
self.waiting.append(found) |
|
||||
break |
|
||||
if not found: |
|
||||
if not filename in self.names: |
|
||||
self.names.append(filename) |
|
||||
|
|
||||
def get_strings(self, code): |
|
||||
#self.imports = [] |
|
||||
self.module = '' |
|
||||
lst = [] |
|
||||
|
|
||||
# get the module name (if present) |
|
||||
|
|
||||
mod_name = self.re_module.search(code) |
|
||||
if mod_name: |
|
||||
self.module = re.sub('\s+', '', mod_name.group(1)) # strip all whitespaces |
|
||||
|
|
||||
# go through the code, have a look at all import occurrences |
|
||||
|
|
||||
# first, lets look at anything beginning with "import" and ending with ";" |
|
||||
import_iterator = self.re_import.finditer(code) |
|
||||
if import_iterator: |
|
||||
for import_match in import_iterator: |
|
||||
import_match_str = re.sub('\s+', '', import_match.group(1)) # strip all whitespaces |
|
||||
|
|
||||
# does this end with an import bindings declaration? |
|
||||
# (import bindings always terminate the list of imports) |
|
||||
bindings_match = self.re_import_bindings.match(import_match_str) |
|
||||
if bindings_match: |
|
||||
import_match_str = bindings_match.group(1) |
|
||||
# if so, extract the part before the ":" (since the module declaration(s) is/are located there) |
|
||||
|
|
||||
# split the matching string into a bunch of strings, separated by a comma |
|
||||
matches = import_match_str.split(',') |
|
||||
|
|
||||
for match in matches: |
|
||||
alias_match = self.re_import_alias.match(match) |
|
||||
if alias_match: |
|
||||
# is this an alias declaration? (alias = module name) if so, extract the module name |
|
||||
match = alias_match.group(1) |
|
||||
|
|
||||
lst.append(match) |
|
||||
return lst |
|
||||
|
|
||||
def start(self, node): |
|
||||
self.waiting = [node] |
|
||||
# while the stack is not empty, add the dependencies |
|
||||
while self.waiting: |
|
||||
nd = self.waiting.pop(0) |
|
||||
self.iter(nd) |
|
||||
|
|
||||
def iter(self, node): |
|
||||
path = node.abspath(self.env) # obtain the absolute path |
|
||||
code = "".join(filter_comments(path)) # read the file and filter the comments |
|
||||
names = self.get_strings(code) # obtain the import strings |
|
||||
for x in names: |
|
||||
# optimization |
|
||||
if x in self.allnames: continue |
|
||||
self.allnames.append(x) |
|
||||
|
|
||||
# for each name, see if it is like a node or not |
|
||||
self.tryfind(x) |
|
||||
|
|
||||
def scan(self): |
|
||||
"look for .d/.di the .d source need" |
|
||||
env = self.env |
|
||||
gruik = d_parser(env, env['INC_PATHS']) |
|
||||
gruik.start(self.inputs[0]) |
|
||||
|
|
||||
if Logs.verbose: |
|
||||
debug('deps: nodes found for %s: %s %s' % (str(self.inputs[0]), str(gruik.nodes), str(gruik.names))) |
|
||||
#debug("deps found for %s: %s" % (str(node), str(gruik.deps)), 'deps') |
|
||||
return (gruik.nodes, gruik.names) |
|
||||
|
|
||||
def get_target_name(self): |
|
||||
"for d programs and libs" |
|
||||
v = self.env |
|
||||
tp = 'program' |
|
||||
for x in self.features: |
|
||||
if x in ['dshlib', 'dstaticlib']: |
|
||||
tp = x.lstrip('d') |
|
||||
return v['D_%s_PATTERN' % tp] % self.target |
|
||||
|
|
||||
d_params = { |
|
||||
'dflags': '', |
|
||||
'importpaths':'', |
|
||||
'libs':'', |
|
||||
'libpaths':'', |
|
||||
'generate_headers':False, |
|
||||
} |
|
||||
|
|
||||
@feature('d') |
|
||||
@before('apply_type_vars') |
|
||||
def init_d(self): |
|
||||
for x in d_params: |
|
||||
setattr(self, x, getattr(self, x, d_params[x])) |
|
||||
|
|
||||
class d_taskgen(TaskGen.task_gen): |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
# COMPAT |
|
||||
if len(k) > 1: |
|
||||
self.features.append('d' + k[1]) |
|
||||
|
|
||||
# okay, we borrow a few methods from ccroot |
|
||||
TaskGen.bind_feature('d', D_METHS) |
|
||||
|
|
||||
@feature('d') |
|
||||
@before('apply_d_libs') |
|
||||
def init_d(self): |
|
||||
Utils.def_attrs(self, |
|
||||
dflags='', |
|
||||
importpaths='', |
|
||||
libs='', |
|
||||
libpaths='', |
|
||||
uselib='', |
|
||||
uselib_local='', |
|
||||
generate_headers=False, # set to true if you want .di files as well as .o |
|
||||
compiled_tasks=[], |
|
||||
add_objects=[], |
|
||||
link_task=None) |
|
||||
|
|
||||
@feature('d') |
|
||||
@after('apply_d_link', 'init_d') |
|
||||
@before('apply_vnum') |
|
||||
def apply_d_libs(self): |
|
||||
"""after apply_link because of 'link_task' |
|
||||
after default_cc because of the attribute 'uselib'""" |
|
||||
env = self.env |
|
||||
|
|
||||
# 1. the case of the libs defined in the project (visit ancestors first) |
|
||||
# the ancestors external libraries (uselib) will be prepended |
|
||||
self.uselib = self.to_list(self.uselib) |
|
||||
names = self.to_list(self.uselib_local) |
|
||||
|
|
||||
seen = set([]) |
|
||||
tmp = Utils.deque(names) # consume a copy of the list of names |
|
||||
while tmp: |
|
||||
lib_name = tmp.popleft() |
|
||||
# visit dependencies only once |
|
||||
if lib_name in seen: |
|
||||
continue |
|
||||
|
|
||||
y = self.name_to_obj(lib_name) |
|
||||
if not y: |
|
||||
raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name)) |
|
||||
y.post() |
|
||||
seen.add(lib_name) |
|
||||
|
|
||||
# object has ancestors to process (shared libraries): add them to the end of the list |
|
||||
if getattr(y, 'uselib_local', None): |
|
||||
lst = y.to_list(y.uselib_local) |
|
||||
if 'dshlib' in y.features or 'dprogram' in y.features: |
|
||||
lst = [x for x in lst if not 'dstaticlib' in self.name_to_obj(x).features] |
|
||||
tmp.extend(lst) |
|
||||
|
|
||||
# link task and flags |
|
||||
if getattr(y, 'link_task', None): |
|
||||
|
|
||||
link_name = y.target[y.target.rfind(os.sep) + 1:] |
|
||||
if 'dstaticlib' in y.features or 'dshlib' in y.features: |
|
||||
env.append_unique('DLINKFLAGS', env.DLIB_ST % link_name) |
|
||||
env.append_unique('DLINKFLAGS', env.DLIBPATH_ST % y.link_task.outputs[0].parent.bldpath(env)) |
|
||||
|
|
||||
# the order |
|
||||
self.link_task.set_run_after(y.link_task) |
|
||||
|
|
||||
# for the recompilation |
|
||||
dep_nodes = getattr(self.link_task, 'dep_nodes', []) |
|
||||
self.link_task.dep_nodes = dep_nodes + y.link_task.outputs |
|
||||
|
|
||||
# add ancestors uselib too - but only propagate those that have no staticlib |
|
||||
for v in self.to_list(y.uselib): |
|
||||
if not v in self.uselib: |
|
||||
self.uselib.insert(0, v) |
|
||||
|
|
||||
# if the library task generator provides 'export_incdirs', add to the include path |
|
||||
# the export_incdirs must be a list of paths relative to the other library |
|
||||
if getattr(y, 'export_incdirs', None): |
|
||||
for x in self.to_list(y.export_incdirs): |
|
||||
node = y.path.find_dir(x) |
|
||||
if not node: |
|
||||
raise Utils.WafError('object %r: invalid folder %r in export_incdirs' % (y.target, x)) |
|
||||
self.env.append_unique('INC_PATHS', node) |
|
||||
|
|
||||
@feature('dprogram', 'dshlib', 'dstaticlib') |
|
||||
@after('apply_core') |
|
||||
def apply_d_link(self): |
|
||||
link = getattr(self, 'link', None) |
|
||||
if not link: |
|
||||
if 'dstaticlib' in self.features: link = 'static_link' |
|
||||
else: link = 'd_link' |
|
||||
|
|
||||
outputs = [t.outputs[0] for t in self.compiled_tasks] |
|
||||
self.link_task = self.create_task(link, outputs, self.path.find_or_declare(get_target_name(self))) |
|
||||
|
|
||||
@feature('d') |
|
||||
@after('apply_core') |
|
||||
def apply_d_vars(self): |
|
||||
env = self.env |
|
||||
dpath_st = env['DPATH_ST'] |
|
||||
lib_st = env['DLIB_ST'] |
|
||||
libpath_st = env['DLIBPATH_ST'] |
|
||||
|
|
||||
importpaths = self.to_list(self.importpaths) |
|
||||
libpaths = [] |
|
||||
libs = [] |
|
||||
uselib = self.to_list(self.uselib) |
|
||||
|
|
||||
for i in uselib: |
|
||||
if env['DFLAGS_' + i]: |
|
||||
env.append_unique('DFLAGS', env['DFLAGS_' + i]) |
|
||||
|
|
||||
for x in self.features: |
|
||||
if not x in ['dprogram', 'dstaticlib', 'dshlib']: |
|
||||
continue |
|
||||
x.lstrip('d') |
|
||||
d_shlib_dflags = env['D_' + x + '_DFLAGS'] |
|
||||
if d_shlib_dflags: |
|
||||
env.append_unique('DFLAGS', d_shlib_dflags) |
|
||||
|
|
||||
# add import paths |
|
||||
for i in uselib: |
|
||||
if env['DPATH_' + i]: |
|
||||
for entry in self.to_list(env['DPATH_' + i]): |
|
||||
if not entry in importpaths: |
|
||||
importpaths.append(entry) |
|
||||
|
|
||||
# now process the import paths |
|
||||
for path in importpaths: |
|
||||
if os.path.isabs(path): |
|
||||
env.append_unique('_DIMPORTFLAGS', dpath_st % path) |
|
||||
else: |
|
||||
node = self.path.find_dir(path) |
|
||||
self.env.append_unique('INC_PATHS', node) |
|
||||
env.append_unique('_DIMPORTFLAGS', dpath_st % node.srcpath(env)) |
|
||||
env.append_unique('_DIMPORTFLAGS', dpath_st % node.bldpath(env)) |
|
||||
|
|
||||
# add library paths |
|
||||
for i in uselib: |
|
||||
if env['LIBPATH_' + i]: |
|
||||
for entry in self.to_list(env['LIBPATH_' + i]): |
|
||||
if not entry in libpaths: |
|
||||
libpaths.append(entry) |
|
||||
libpaths = self.to_list(self.libpaths) + libpaths |
|
||||
|
|
||||
# now process the library paths |
|
||||
# apply same path manipulation as used with import paths |
|
||||
for path in libpaths: |
|
||||
if not os.path.isabs(path): |
|
||||
node = self.path.find_resource(path) |
|
||||
if not node: |
|
||||
raise Utils.WafError('could not find libpath %r from %r' % (path, self)) |
|
||||
path = node.abspath(self.env) |
|
||||
|
|
||||
env.append_unique('DLINKFLAGS', libpath_st % path) |
|
||||
|
|
||||
# add libraries |
|
||||
for i in uselib: |
|
||||
if env['LIB_' + i]: |
|
||||
for entry in self.to_list(env['LIB_' + i]): |
|
||||
if not entry in libs: |
|
||||
libs.append(entry) |
|
||||
libs.extend(self.to_list(self.libs)) |
|
||||
|
|
||||
# process user flags |
|
||||
for flag in self.to_list(self.dflags): |
|
||||
env.append_unique('DFLAGS', flag) |
|
||||
|
|
||||
# now process the libraries |
|
||||
for lib in libs: |
|
||||
env.append_unique('DLINKFLAGS', lib_st % lib) |
|
||||
|
|
||||
# add linker flags |
|
||||
for i in uselib: |
|
||||
dlinkflags = env['DLINKFLAGS_' + i] |
|
||||
if dlinkflags: |
|
||||
for linkflag in dlinkflags: |
|
||||
env.append_unique('DLINKFLAGS', linkflag) |
|
||||
|
|
||||
@feature('dshlib') |
|
||||
@after('apply_d_vars') |
|
||||
def add_shlib_d_flags(self): |
|
||||
for linkflag in self.env['D_shlib_LINKFLAGS']: |
|
||||
self.env.append_unique('DLINKFLAGS', linkflag) |
|
||||
|
|
||||
@extension(EXT_D) |
|
||||
def d_hook(self, node): |
|
||||
# create the compilation task: cpp or cc |
|
||||
task = self.create_task(self.generate_headers and 'd_with_header' or 'd') |
|
||||
try: obj_ext = self.obj_ext |
|
||||
except AttributeError: obj_ext = '_%d.o' % self.idx |
|
||||
|
|
||||
task.inputs = [node] |
|
||||
task.outputs = [node.change_ext(obj_ext)] |
|
||||
self.compiled_tasks.append(task) |
|
||||
|
|
||||
if self.generate_headers: |
|
||||
header_node = node.change_ext(self.env['DHEADER_ext']) |
|
||||
task.outputs += [header_node] |
|
||||
|
|
||||
d_str = '${D_COMPILER} ${DFLAGS} ${_DIMPORTFLAGS} ${D_SRC_F}${SRC} ${D_TGT_F}${TGT}' |
|
||||
d_with_header_str = '${D_COMPILER} ${DFLAGS} ${_DIMPORTFLAGS} \ |
|
||||
${D_HDR_F}${TGT[1].bldpath(env)} \ |
|
||||
${D_SRC_F}${SRC} \ |
|
||||
${D_TGT_F}${TGT[0].bldpath(env)}' |
|
||||
link_str = '${D_LINKER} ${DLNK_SRC_F}${SRC} ${DLNK_TGT_F}${TGT} ${DLINKFLAGS}' |
|
||||
|
|
||||
def override_exec(cls): |
|
||||
"""stupid dmd wants -of stuck to the file name""" |
|
||||
old_exec = cls.exec_command |
|
||||
def exec_command(self, *k, **kw): |
|
||||
if isinstance(k[0], list): |
|
||||
lst = k[0] |
|
||||
for i in xrange(len(lst)): |
|
||||
if lst[i] == '-of': |
|
||||
del lst[i] |
|
||||
lst[i] = '-of' + lst[i] |
|
||||
break |
|
||||
return old_exec(self, *k, **kw) |
|
||||
cls.exec_command = exec_command |
|
||||
|
|
||||
cls = Task.simple_task_type('d', d_str, 'GREEN', before='static_link d_link', shell=False) |
|
||||
cls.scan = scan |
|
||||
override_exec(cls) |
|
||||
|
|
||||
cls = Task.simple_task_type('d_with_header', d_with_header_str, 'GREEN', before='static_link d_link', shell=False) |
|
||||
override_exec(cls) |
|
||||
|
|
||||
cls = Task.simple_task_type('d_link', link_str, color='YELLOW', shell=False) |
|
||||
override_exec(cls) |
|
||||
|
|
||||
# for feature request #104 |
|
||||
@taskgen |
|
||||
def generate_header(self, filename, install_path): |
|
||||
if not hasattr(self, 'header_lst'): self.header_lst = [] |
|
||||
self.meths.append('process_header') |
|
||||
self.header_lst.append([filename, install_path]) |
|
||||
|
|
||||
@before('apply_core') |
|
||||
def process_header(self): |
|
||||
env = self.env |
|
||||
for i in getattr(self, 'header_lst', []): |
|
||||
node = self.path.find_resource(i[0]) |
|
||||
|
|
||||
if not node: |
|
||||
raise Utils.WafError('file not found on d obj '+i[0]) |
|
||||
|
|
||||
task = self.create_task('d_header') |
|
||||
task.set_inputs(node) |
|
||||
task.set_outputs(node.change_ext('.di')) |
|
||||
|
|
||||
d_header_str = '${D_COMPILER} ${D_HEADER} ${SRC}' |
|
||||
Task.simple_task_type('d_header', d_header_str, color='BLUE', shell=False) |
|
||||
|
|
||||
@conftest |
|
||||
def d_platform_flags(conf): |
|
||||
v = conf.env |
|
||||
binfmt = v.DEST_BINFMT or Utils.unversioned_sys_platform_to_binary_format( |
|
||||
v.DEST_OS or Utils.unversioned_sys_platform()) |
|
||||
if binfmt == 'pe': |
|
||||
v['D_program_PATTERN'] = '%s.exe' |
|
||||
v['D_shlib_PATTERN'] = 'lib%s.dll' |
|
||||
v['D_staticlib_PATTERN'] = 'lib%s.a' |
|
||||
else: |
|
||||
v['D_program_PATTERN'] = '%s' |
|
||||
v['D_shlib_PATTERN'] = 'lib%s.so' |
|
||||
v['D_staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
# quick test # |
|
||||
if __name__ == "__main__": |
|
||||
#Logs.verbose = 2 |
|
||||
|
|
||||
try: arg = sys.argv[1] |
|
||||
except IndexError: arg = "file.d" |
|
||||
|
|
||||
print("".join(filter_comments(arg))) |
|
||||
# TODO |
|
||||
paths = ['.'] |
|
||||
|
|
||||
#gruik = filter() |
|
||||
#gruik.start(arg) |
|
||||
|
|
||||
#code = "".join(gruik.buf) |
|
||||
|
|
||||
#print "we have found the following code" |
|
||||
#print code |
|
||||
|
|
||||
#print "now parsing" |
|
||||
#print "-------------------------------------------" |
|
||||
""" |
|
||||
parser_ = d_parser() |
|
||||
parser_.start(arg) |
|
||||
|
|
||||
print "module: %s" % parser_.module |
|
||||
print "imports: ", |
|
||||
for imp in parser_.imports: |
|
||||
print imp + " ", |
|
||||
print |
|
||||
""" |
|
||||
|
|
||||
@ -1,64 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Carlos Rafael Giani, 2007 (dv) |
|
||||
# Thomas Nagy, 2008 (ita) |
|
||||
|
|
||||
import sys |
|
||||
import Utils, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_dmd(conf): |
|
||||
conf.find_program(['dmd', 'ldc'], var='D_COMPILER', mandatory=True) |
|
||||
|
|
||||
@conftest |
|
||||
def common_flags_ldc(conf): |
|
||||
v = conf.env |
|
||||
v['DFLAGS'] = ['-d-version=Posix'] |
|
||||
v['DLINKFLAGS'] = [] |
|
||||
v['D_shlib_DFLAGS'] = ['-relocation-model=pic'] |
|
||||
|
|
||||
@conftest |
|
||||
def common_flags_dmd(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# _DFLAGS _DIMPORTFLAGS |
|
||||
|
|
||||
# Compiler is dmd so 'gdc' part will be ignored, just |
|
||||
# ensure key is there, so wscript can append flags to it |
|
||||
v['DFLAGS'] = ['-version=Posix'] |
|
||||
|
|
||||
v['D_SRC_F'] = '' |
|
||||
v['D_TGT_F'] = ['-c', '-of'] |
|
||||
v['DPATH_ST'] = '-I%s' # template for adding import paths |
|
||||
|
|
||||
# linker |
|
||||
v['D_LINKER'] = v['D_COMPILER'] |
|
||||
v['DLNK_SRC_F'] = '' |
|
||||
v['DLNK_TGT_F'] = '-of' |
|
||||
|
|
||||
v['DLIB_ST'] = '-L-l%s' # template for adding libs |
|
||||
v['DLIBPATH_ST'] = '-L-L%s' # template for adding libpaths |
|
||||
|
|
||||
# linker debug levels |
|
||||
v['DFLAGS_OPTIMIZED'] = ['-O'] |
|
||||
v['DFLAGS_DEBUG'] = ['-g', '-debug'] |
|
||||
v['DFLAGS_ULTRADEBUG'] = ['-g', '-debug'] |
|
||||
v['DLINKFLAGS'] = ['-quiet'] |
|
||||
|
|
||||
v['D_shlib_DFLAGS'] = ['-fPIC'] |
|
||||
v['D_shlib_LINKFLAGS'] = ['-L-shared'] |
|
||||
|
|
||||
v['DHEADER_ext'] = '.di' |
|
||||
v['D_HDR_F'] = ['-H', '-Hf'] |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_dmd() |
|
||||
conf.check_tool('ar') |
|
||||
conf.check_tool('d') |
|
||||
conf.common_flags_dmd() |
|
||||
conf.d_platform_flags() |
|
||||
|
|
||||
if conf.env.D_COMPILER.find('ldc') > -1: |
|
||||
conf.common_flags_ldc() |
|
||||
|
|
||||
@ -1,38 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2008 (ita) |
|
||||
|
|
||||
"as and gas" |
|
||||
|
|
||||
import os, sys |
|
||||
import Task |
|
||||
from TaskGen import extension, taskgen, after, before |
|
||||
|
|
||||
EXT_ASM = ['.s', '.S', '.asm', '.ASM', '.spp', '.SPP'] |
|
||||
|
|
||||
as_str = '${AS} ${ASFLAGS} ${_ASINCFLAGS} ${SRC} -o ${TGT}' |
|
||||
Task.simple_task_type('asm', as_str, 'PINK', ext_out='.o', shell=False) |
|
||||
|
|
||||
@extension(EXT_ASM) |
|
||||
def asm_hook(self, node): |
|
||||
# create the compilation task: cpp or cc |
|
||||
try: obj_ext = self.obj_ext |
|
||||
except AttributeError: obj_ext = '_%d.o' % self.idx |
|
||||
|
|
||||
task = self.create_task('asm', node, node.change_ext(obj_ext)) |
|
||||
self.compiled_tasks.append(task) |
|
||||
self.meths.append('asm_incflags') |
|
||||
|
|
||||
@after('apply_obj_vars_cc') |
|
||||
@after('apply_obj_vars_cxx') |
|
||||
@before('apply_link') |
|
||||
def asm_incflags(self): |
|
||||
self.env.append_value('_ASINCFLAGS', self.env.ASINCFLAGS) |
|
||||
var = ('cxx' in self.features) and 'CXX' or 'CC' |
|
||||
self.env.append_value('_ASINCFLAGS', self.env['_%sINCFLAGS' % var]) |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_program(['gas', 'as'], var='AS') |
|
||||
if not conf.env.AS: conf.env.AS = conf.env.CC |
|
||||
#conf.env.ASFLAGS = ['-c'] <- may be necesary for .S files |
|
||||
|
|
||||
@ -1,137 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006-2008 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
# Yinon Ehrlich, 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_gcc(conf): |
|
||||
cc = conf.find_program(['gcc', 'cc'], var='CC', mandatory=True) |
|
||||
cc = conf.cmd_to_list(cc) |
|
||||
ccroot.get_cc_version(conf, cc, gcc=True) |
|
||||
conf.env.CC_NAME = 'gcc' |
|
||||
conf.env.CC = cc |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS |
|
||||
|
|
||||
v['CCFLAGS_DEBUG'] = ['-g'] |
|
||||
|
|
||||
v['CCFLAGS_RELEASE'] = ['-O2'] |
|
||||
|
|
||||
v['CC_SRC_F'] = '' |
|
||||
v['CC_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CC']: v['LINK_CC'] = v['CC'] |
|
||||
v['CCLNK_SRC_F'] = '' |
|
||||
v['CCLNK_TGT_F'] = ['-o', ''] # shell hack for -MD |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['RPATH_ST'] = '-Wl,-rpath,%s' |
|
||||
v['CCDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '-Wl,-h,%s' |
|
||||
v['SHLIB_MARKER'] = '-Wl,-Bdynamic' |
|
||||
v['STATICLIB_MARKER'] = '-Wl,-Bstatic' |
|
||||
v['FULLSTATIC_MARKER'] = '-static' |
|
||||
|
|
||||
# program |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CCFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro |
|
||||
v['shlib_LINKFLAGS'] = ['-shared'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = ['-Wl,-Bstatic'] |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
# osx stuff |
|
||||
v['LINKFLAGS_MACBUNDLE'] = ['-bundle', '-undefined', 'dynamic_lookup'] |
|
||||
v['CCFLAGS_MACBUNDLE'] = ['-fPIC'] |
|
||||
v['macbundle_PATTERN'] = '%s.bundle' |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_modifier_win32(conf): |
|
||||
v = conf.env |
|
||||
v['program_PATTERN'] = '%s.exe' |
|
||||
|
|
||||
v['shlib_PATTERN'] = '%s.dll' |
|
||||
v['implib_PATTERN'] = 'lib%s.dll.a' |
|
||||
v['IMPLIB_ST'] = '-Wl,--out-implib,%s' |
|
||||
|
|
||||
dest_arch = v['DEST_CPU'] |
|
||||
if dest_arch == 'x86': |
|
||||
# On 32-bit x86, gcc emits a message telling the -fPIC option is ignored on this arch, so we remove that flag. |
|
||||
v['shlib_CCFLAGS'] = ['-DPIC'] # TODO this is a wrong define, we don't use -fPIC! |
|
||||
|
|
||||
v.append_value('shlib_CCFLAGS', '-DDLL_EXPORT') # TODO adding nonstandard defines like this DLL_EXPORT is not a good idea |
|
||||
|
|
||||
# Auto-import is enabled by default even without this option, |
|
||||
# but enabling it explicitly has the nice effect of suppressing the rather boring, debug-level messages |
|
||||
# that the linker emits otherwise. |
|
||||
v.append_value('LINKFLAGS', '-Wl,--enable-auto-import') |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_modifier_cygwin(conf): |
|
||||
gcc_modifier_win32(conf) |
|
||||
v = conf.env |
|
||||
v['shlib_PATTERN'] = 'cyg%s.dll' |
|
||||
v.append_value('shlib_LINKFLAGS', '-Wl,--enable-auto-image-base') |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_modifier_darwin(conf): |
|
||||
v = conf.env |
|
||||
v['shlib_CCFLAGS'] = ['-fPIC', '-compatibility_version', '1', '-current_version', '1'] |
|
||||
v['shlib_LINKFLAGS'] = ['-dynamiclib'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.dylib' |
|
||||
|
|
||||
v['staticlib_LINKFLAGS'] = [] |
|
||||
|
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
v['STATICLIB_MARKER'] = '' |
|
||||
v['SONAME_ST'] = '' |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_modifier_aix(conf): |
|
||||
v = conf.env |
|
||||
v['program_LINKFLAGS'] = ['-Wl,-brtl'] |
|
||||
|
|
||||
v['shlib_LINKFLAGS'] = ['-shared','-Wl,-brtl,-bexpfull'] |
|
||||
|
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
|
|
||||
@conftest |
|
||||
def gcc_modifier_platform(conf): |
|
||||
# * set configurations specific for a platform. |
|
||||
# * the destination platform is detected automatically by looking at the macros the compiler predefines, |
|
||||
# and if it's not recognised, it fallbacks to sys.platform. |
|
||||
dest_os = conf.env['DEST_OS'] or Utils.unversioned_sys_platform() |
|
||||
gcc_modifier_func = globals().get('gcc_modifier_' + dest_os) |
|
||||
if gcc_modifier_func: |
|
||||
gcc_modifier_func(conf) |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_gcc() |
|
||||
conf.find_cpp() |
|
||||
conf.find_ar() |
|
||||
conf.gcc_common_flags() |
|
||||
conf.gcc_modifier_platform() |
|
||||
conf.cc_load_tools() |
|
||||
conf.cc_add_flags() |
|
||||
conf.link_add_flags() |
|
||||
|
|
||||
@ -1,52 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Carlos Rafael Giani, 2007 (dv) |
|
||||
|
|
||||
import sys |
|
||||
import Utils, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_gdc(conf): |
|
||||
conf.find_program('gdc', var='D_COMPILER', mandatory=True) |
|
||||
|
|
||||
@conftest |
|
||||
def common_flags_gdc(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# _DFLAGS _DIMPORTFLAGS |
|
||||
|
|
||||
# for mory info about the meaning of this dict see dmd.py |
|
||||
v['DFLAGS'] = [] |
|
||||
|
|
||||
v['D_SRC_F'] = '' |
|
||||
v['D_TGT_F'] = ['-c', '-o', ''] |
|
||||
v['DPATH_ST'] = '-I%s' # template for adding import paths |
|
||||
|
|
||||
# linker |
|
||||
v['D_LINKER'] = v['D_COMPILER'] |
|
||||
v['DLNK_SRC_F'] = '' |
|
||||
v['DLNK_TGT_F'] = ['-o', ''] |
|
||||
|
|
||||
v['DLIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['DLIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
|
|
||||
# debug levels |
|
||||
v['DLINKFLAGS'] = [] |
|
||||
v['DFLAGS_OPTIMIZED'] = ['-O3'] |
|
||||
v['DFLAGS_DEBUG'] = ['-O0'] |
|
||||
v['DFLAGS_ULTRADEBUG'] = ['-O0'] |
|
||||
|
|
||||
v['D_shlib_DFLAGS'] = [] |
|
||||
v['D_shlib_LINKFLAGS'] = ['-shared'] |
|
||||
|
|
||||
v['DHEADER_ext'] = '.di' |
|
||||
v['D_HDR_F'] = '-fintfc -fintfc-file=' |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_gdc() |
|
||||
conf.check_tool('ar') |
|
||||
conf.check_tool('d') |
|
||||
conf.common_flags_gdc() |
|
||||
conf.d_platform_flags() |
|
||||
|
|
||||
@ -1,111 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Ali Sabil, 2007 |
|
||||
|
|
||||
""" |
|
||||
To use this module do not forget to call |
|
||||
opt.tool_options('gnu_dirs') |
|
||||
AND |
|
||||
conf.check_tool('gnu_dirs') |
|
||||
|
|
||||
Add options for the standard GNU directories, this tool will add the options |
|
||||
found in autotools, and will update the environment with the following |
|
||||
installation variables: |
|
||||
|
|
||||
* PREFIX : architecture-independent files [/usr/local] |
|
||||
* EXEC_PREFIX : architecture-dependent files [PREFIX] |
|
||||
* BINDIR : user executables [EXEC_PREFIX/bin] |
|
||||
* SBINDIR : user executables [EXEC_PREFIX/sbin] |
|
||||
* LIBEXECDIR : program executables [EXEC_PREFIX/libexec] |
|
||||
* SYSCONFDIR : read-only single-machine data [PREFIX/etc] |
|
||||
* SHAREDSTATEDIR : modifiable architecture-independent data [PREFIX/com] |
|
||||
* LOCALSTATEDIR : modifiable single-machine data [PREFIX/var] |
|
||||
* LIBDIR : object code libraries [EXEC_PREFIX/lib] |
|
||||
* INCLUDEDIR : C header files [PREFIX/include] |
|
||||
* OLDINCLUDEDIR : C header files for non-gcc [/usr/include] |
|
||||
* DATAROOTDIR : read-only arch.-independent data root [PREFIX/share] |
|
||||
* DATADIR : read-only architecture-independent data [DATAROOTDIR] |
|
||||
* INFODIR : info documentation [DATAROOTDIR/info] |
|
||||
* LOCALEDIR : locale-dependent data [DATAROOTDIR/locale] |
|
||||
* MANDIR : man documentation [DATAROOTDIR/man] |
|
||||
* DOCDIR : documentation root [DATAROOTDIR/doc/telepathy-glib] |
|
||||
* HTMLDIR : html documentation [DOCDIR] |
|
||||
* DVIDIR : dvi documentation [DOCDIR] |
|
||||
* PDFDIR : pdf documentation [DOCDIR] |
|
||||
* PSDIR : ps documentation [DOCDIR] |
|
||||
""" |
|
||||
|
|
||||
import Utils, Options |
|
||||
|
|
||||
_options = [x.split(', ') for x in ''' |
|
||||
bindir, user executables, ${EXEC_PREFIX}/bin |
|
||||
sbindir, system admin executables, ${EXEC_PREFIX}/sbin |
|
||||
libexecdir, program executables, ${EXEC_PREFIX}/libexec |
|
||||
sysconfdir, read-only single-machine data, ${PREFIX}/etc |
|
||||
sharedstatedir, modifiable architecture-independent data, ${PREFIX}/com |
|
||||
localstatedir, modifiable single-machine data, ${PREFIX}/var |
|
||||
libdir, object code libraries, ${EXEC_PREFIX}/lib |
|
||||
includedir, C header files, ${PREFIX}/include |
|
||||
oldincludedir, C header files for non-gcc, /usr/include |
|
||||
datarootdir, read-only arch.-independent data root, ${PREFIX}/share |
|
||||
datadir, read-only architecture-independent data, ${DATAROOTDIR} |
|
||||
infodir, info documentation, ${DATAROOTDIR}/info |
|
||||
localedir, locale-dependent data, ${DATAROOTDIR}/locale |
|
||||
mandir, man documentation, ${DATAROOTDIR}/man |
|
||||
docdir, documentation root, ${DATAROOTDIR}/doc/${PACKAGE} |
|
||||
htmldir, html documentation, ${DOCDIR} |
|
||||
dvidir, dvi documentation, ${DOCDIR} |
|
||||
pdfdir, pdf documentation, ${DOCDIR} |
|
||||
psdir, ps documentation, ${DOCDIR} |
|
||||
'''.split('\n') if x] |
|
||||
|
|
||||
def detect(conf): |
|
||||
def get_param(varname, default): |
|
||||
return getattr(Options.options, varname, '') or default |
|
||||
|
|
||||
env = conf.env |
|
||||
env['EXEC_PREFIX'] = get_param('EXEC_PREFIX', env['PREFIX']) |
|
||||
env['PACKAGE'] = Utils.g_module.APPNAME |
|
||||
|
|
||||
complete = False |
|
||||
iter = 0 |
|
||||
while not complete and iter < len(_options) + 1: |
|
||||
iter += 1 |
|
||||
complete = True |
|
||||
for name, help, default in _options: |
|
||||
name = name.upper() |
|
||||
if not env[name]: |
|
||||
try: |
|
||||
env[name] = Utils.subst_vars(get_param(name, default), env) |
|
||||
except TypeError: |
|
||||
complete = False |
|
||||
if not complete: |
|
||||
lst = [name for name, _, _ in _options if not env[name.upper()]] |
|
||||
raise Utils.WafError('Variable substitution failure %r' % lst) |
|
||||
|
|
||||
def set_options(opt): |
|
||||
|
|
||||
inst_dir = opt.add_option_group('Installation directories', |
|
||||
'By default, "waf install" will put the files in\ |
|
||||
"/usr/local/bin", "/usr/local/lib" etc. An installation prefix other\ |
|
||||
than "/usr/local" can be given using "--prefix", for example "--prefix=$HOME"') |
|
||||
|
|
||||
for k in ('--prefix', '--destdir'): |
|
||||
option = opt.parser.get_option(k) |
|
||||
if option: |
|
||||
opt.parser.remove_option(k) |
|
||||
inst_dir.add_option(option) |
|
||||
|
|
||||
inst_dir.add_option('--exec-prefix', |
|
||||
help = 'installation prefix [Default: ${PREFIX}]', |
|
||||
default = '', |
|
||||
dest = 'EXEC_PREFIX') |
|
||||
|
|
||||
dirs_options = opt.add_option_group('Pre-defined installation directories', '') |
|
||||
|
|
||||
for name, help, default in _options: |
|
||||
option_name = '--' + name |
|
||||
str_default = default |
|
||||
str_help = '%s [Default: %s]' % (help, str_default) |
|
||||
dirs_options.add_option(option_name, help=str_help, default='', dest=name.upper()) |
|
||||
|
|
||||
@ -1,18 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Ali Sabil, 2007 |
|
||||
|
|
||||
import TaskGen |
|
||||
|
|
||||
TaskGen.declare_chain( |
|
||||
name = 'gob2', |
|
||||
rule = '${GOB2} -o ${TGT[0].bld_dir(env)} ${GOB2FLAGS} ${SRC}', |
|
||||
ext_in = '.gob', |
|
||||
ext_out = '.c' |
|
||||
) |
|
||||
|
|
||||
def detect(conf): |
|
||||
gob2 = conf.find_program('gob2', var='GOB2', mandatory=True) |
|
||||
conf.env['GOB2'] = gob2 |
|
||||
conf.env['GOB2FLAGS'] = '' |
|
||||
|
|
||||
@ -1,134 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
# Yinon Ehrlich, 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_gxx(conf): |
|
||||
cxx = conf.find_program(['g++', 'c++'], var='CXX', mandatory=True) |
|
||||
cxx = conf.cmd_to_list(cxx) |
|
||||
ccroot.get_cc_version(conf, cxx, gcc=True) |
|
||||
conf.env.CXX_NAME = 'gcc' |
|
||||
conf.env.CXX = cxx |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS |
|
||||
v['CXXFLAGS_DEBUG'] = ['-g'] |
|
||||
v['CXXFLAGS_RELEASE'] = ['-O2'] |
|
||||
|
|
||||
v['CXX_SRC_F'] = '' |
|
||||
v['CXX_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] |
|
||||
v['CXXLNK_SRC_F'] = '' |
|
||||
v['CXXLNK_TGT_F'] = ['-o', ''] # shell hack for -MD |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['RPATH_ST'] = '-Wl,-rpath,%s' |
|
||||
v['CXXDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '-Wl,-h,%s' |
|
||||
v['SHLIB_MARKER'] = '-Wl,-Bdynamic' |
|
||||
v['STATICLIB_MARKER'] = '-Wl,-Bstatic' |
|
||||
v['FULLSTATIC_MARKER'] = '-static' |
|
||||
|
|
||||
# program |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CXXFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro |
|
||||
v['shlib_LINKFLAGS'] = ['-shared'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = ['-Wl,-Bstatic'] |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
# osx stuff |
|
||||
v['LINKFLAGS_MACBUNDLE'] = ['-bundle', '-undefined', 'dynamic_lookup'] |
|
||||
v['CCFLAGS_MACBUNDLE'] = ['-fPIC'] |
|
||||
v['macbundle_PATTERN'] = '%s.bundle' |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_modifier_win32(conf): |
|
||||
v = conf.env |
|
||||
v['program_PATTERN'] = '%s.exe' |
|
||||
|
|
||||
v['shlib_PATTERN'] = '%s.dll' |
|
||||
v['implib_PATTERN'] = 'lib%s.dll.a' |
|
||||
v['IMPLIB_ST'] = '-Wl,--out-implib,%s' |
|
||||
|
|
||||
dest_arch = v['DEST_CPU'] |
|
||||
if dest_arch == 'x86': |
|
||||
# On 32-bit x86, gcc emits a message telling the -fPIC option is ignored on this arch, so we remove that flag. |
|
||||
v['shlib_CXXFLAGS'] = ['-DPIC'] # TODO this is a wrong define, we don't use -fPIC! |
|
||||
|
|
||||
v.append_value('shlib_CXXFLAGS', '-DDLL_EXPORT') # TODO adding nonstandard defines like this DLL_EXPORT is not a good idea |
|
||||
|
|
||||
# Auto-import is enabled by default even without this option, |
|
||||
# but enabling it explicitly has the nice effect of suppressing the rather boring, debug-level messages |
|
||||
# that the linker emits otherwise. |
|
||||
v.append_value('LINKFLAGS', '-Wl,--enable-auto-import') |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_modifier_cygwin(conf): |
|
||||
gxx_modifier_win32(conf) |
|
||||
v = conf.env |
|
||||
v['shlib_PATTERN'] = 'cyg%s.dll' |
|
||||
v.append_value('shlib_LINKFLAGS', '-Wl,--enable-auto-image-base') |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_modifier_darwin(conf): |
|
||||
v = conf.env |
|
||||
v['shlib_CXXFLAGS'] = ['-fPIC', '-compatibility_version', '1', '-current_version', '1'] |
|
||||
v['shlib_LINKFLAGS'] = ['-dynamiclib'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.dylib' |
|
||||
|
|
||||
v['staticlib_LINKFLAGS'] = [] |
|
||||
|
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
v['STATICLIB_MARKER'] = '' |
|
||||
v['SONAME_ST'] = '' |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_modifier_aix(conf): |
|
||||
v = conf.env |
|
||||
v['program_LINKFLAGS'] = ['-Wl,-brtl'] |
|
||||
|
|
||||
v['shlib_LINKFLAGS'] = ['-shared', '-Wl,-brtl,-bexpfull'] |
|
||||
|
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
|
|
||||
@conftest |
|
||||
def gxx_modifier_platform(conf): |
|
||||
# * set configurations specific for a platform. |
|
||||
# * the destination platform is detected automatically by looking at the macros the compiler predefines, |
|
||||
# and if it's not recognised, it fallbacks to sys.platform. |
|
||||
dest_os = conf.env['DEST_OS'] or Utils.unversioned_sys_platform() |
|
||||
gxx_modifier_func = globals().get('gxx_modifier_' + dest_os) |
|
||||
if gxx_modifier_func: |
|
||||
gxx_modifier_func(conf) |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_gxx() |
|
||||
conf.find_cpp() |
|
||||
conf.find_ar() |
|
||||
conf.gxx_common_flags() |
|
||||
conf.gxx_modifier_platform() |
|
||||
conf.cxx_load_tools() |
|
||||
conf.cxx_add_flags() |
|
||||
|
|
||||
@ -1,37 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Stian Selnes, 2008 |
|
||||
# Thomas Nagy 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar, gcc |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_icc(conf): |
|
||||
if sys.platform == 'cygwin': |
|
||||
conf.fatal('The Intel compiler does not work on Cygwin') |
|
||||
|
|
||||
v = conf.env |
|
||||
cc = None |
|
||||
if v['CC']: cc = v['CC'] |
|
||||
elif 'CC' in conf.environ: cc = conf.environ['CC'] |
|
||||
if not cc: cc = conf.find_program('icc', var='CC') |
|
||||
if not cc: cc = conf.find_program('ICL', var='CC') |
|
||||
if not cc: conf.fatal('Intel C Compiler (icc) was not found') |
|
||||
cc = conf.cmd_to_list(cc) |
|
||||
|
|
||||
ccroot.get_cc_version(conf, cc, icc=True) |
|
||||
v['CC'] = cc |
|
||||
v['CC_NAME'] = 'icc' |
|
||||
|
|
||||
detect = ''' |
|
||||
find_icc |
|
||||
find_ar |
|
||||
gcc_common_flags |
|
||||
gcc_modifier_platform |
|
||||
cc_load_tools |
|
||||
cc_add_flags |
|
||||
link_add_flags |
|
||||
''' |
|
||||
@ -1,34 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar, gxx |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_icpc(conf): |
|
||||
if sys.platform == 'cygwin': |
|
||||
conf.fatal('The Intel compiler does not work on Cygwin') |
|
||||
|
|
||||
v = conf.env |
|
||||
cxx = None |
|
||||
if v['CXX']: cxx = v['CXX'] |
|
||||
elif 'CXX' in conf.environ: cxx = conf.environ['CXX'] |
|
||||
if not cxx: cxx = conf.find_program('icpc', var='CXX') |
|
||||
if not cxx: conf.fatal('Intel C++ Compiler (icpc) was not found') |
|
||||
cxx = conf.cmd_to_list(cxx) |
|
||||
|
|
||||
ccroot.get_cc_version(conf, cxx, icc=True) |
|
||||
v['CXX'] = cxx |
|
||||
v['CXX_NAME'] = 'icc' |
|
||||
|
|
||||
detect = ''' |
|
||||
find_icpc |
|
||||
find_ar |
|
||||
gxx_common_flags |
|
||||
gxx_modifier_platform |
|
||||
cxx_load_tools |
|
||||
cxx_add_flags |
|
||||
''' |
|
||||
@ -1,139 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
|
|
||||
"intltool support" |
|
||||
|
|
||||
import os, re |
|
||||
import Configure, TaskGen, Task, Utils, Runner, Options, Build, config_c |
|
||||
from TaskGen import feature, before, taskgen |
|
||||
from Logs import error |
|
||||
|
|
||||
""" |
|
||||
Usage: |
|
||||
|
|
||||
bld(features='intltool_in', source='a.po b.po', podir='po', cache='.intlcache', flags='') |
|
||||
|
|
||||
""" |
|
||||
|
|
||||
class intltool_in_taskgen(TaskGen.task_gen): |
|
||||
"""deprecated""" |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@before('apply_core') |
|
||||
@feature('intltool_in') |
|
||||
def iapply_intltool_in_f(self): |
|
||||
try: self.meths.remove('apply_core') |
|
||||
except ValueError: pass |
|
||||
|
|
||||
for i in self.to_list(self.source): |
|
||||
node = self.path.find_resource(i) |
|
||||
|
|
||||
podir = getattr(self, 'podir', 'po') |
|
||||
podirnode = self.path.find_dir(podir) |
|
||||
if not podirnode: |
|
||||
error("could not find the podir %r" % podir) |
|
||||
continue |
|
||||
|
|
||||
cache = getattr(self, 'intlcache', '.intlcache') |
|
||||
self.env['INTLCACHE'] = os.path.join(self.path.bldpath(self.env), podir, cache) |
|
||||
self.env['INTLPODIR'] = podirnode.srcpath(self.env) |
|
||||
self.env['INTLFLAGS'] = getattr(self, 'flags', ['-q', '-u', '-c']) |
|
||||
|
|
||||
task = self.create_task('intltool', node, node.change_ext('')) |
|
||||
task.install_path = self.install_path |
|
||||
|
|
||||
class intltool_po_taskgen(TaskGen.task_gen): |
|
||||
"""deprecated""" |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
|
|
||||
@feature('intltool_po') |
|
||||
def apply_intltool_po(self): |
|
||||
try: self.meths.remove('apply_core') |
|
||||
except ValueError: pass |
|
||||
|
|
||||
self.default_install_path = '${LOCALEDIR}' |
|
||||
appname = getattr(self, 'appname', 'set_your_app_name') |
|
||||
podir = getattr(self, 'podir', '') |
|
||||
|
|
||||
def install_translation(task): |
|
||||
out = task.outputs[0] |
|
||||
filename = out.name |
|
||||
(langname, ext) = os.path.splitext(filename) |
|
||||
inst_file = langname + os.sep + 'LC_MESSAGES' + os.sep + appname + '.mo' |
|
||||
self.bld.install_as(os.path.join(self.install_path, inst_file), out, self.env, self.chmod) |
|
||||
|
|
||||
linguas = self.path.find_resource(os.path.join(podir, 'LINGUAS')) |
|
||||
if linguas: |
|
||||
# scan LINGUAS file for locales to process |
|
||||
file = open(linguas.abspath()) |
|
||||
langs = [] |
|
||||
for line in file.readlines(): |
|
||||
# ignore lines containing comments |
|
||||
if not line.startswith('#'): |
|
||||
langs += line.split() |
|
||||
file.close() |
|
||||
re_linguas = re.compile('[-a-zA-Z_@.]+') |
|
||||
for lang in langs: |
|
||||
# Make sure that we only process lines which contain locales |
|
||||
if re_linguas.match(lang): |
|
||||
node = self.path.find_resource(os.path.join(podir, re_linguas.match(lang).group() + '.po')) |
|
||||
task = self.create_task('po') |
|
||||
task.set_inputs(node) |
|
||||
task.set_outputs(node.change_ext('.mo')) |
|
||||
if self.bld.is_install: task.install = install_translation |
|
||||
else: |
|
||||
Utils.pprint('RED', "Error no LINGUAS file found in po directory") |
|
||||
|
|
||||
Task.simple_task_type('po', '${POCOM} -o ${TGT} ${SRC}', color='BLUE', shell=False) |
|
||||
Task.simple_task_type('intltool', |
|
||||
'${INTLTOOL} ${INTLFLAGS} ${INTLCACHE} ${INTLPODIR} ${SRC} ${TGT}', |
|
||||
color='BLUE', after="cc_link cxx_link", shell=False) |
|
||||
|
|
||||
def detect(conf): |
|
||||
pocom = conf.find_program('msgfmt') |
|
||||
if not pocom: |
|
||||
# if msgfmt should not be mandatory, catch the thrown exception in your wscript |
|
||||
conf.fatal('The program msgfmt (gettext) is mandatory!') |
|
||||
conf.env['POCOM'] = pocom |
|
||||
|
|
||||
# NOTE: it is possible to set INTLTOOL in the environment, but it must not have spaces in it |
|
||||
|
|
||||
intltool = conf.find_program('intltool-merge', var='INTLTOOL') |
|
||||
if not intltool: |
|
||||
# if intltool-merge should not be mandatory, catch the thrown exception in your wscript |
|
||||
if Options.platform == 'win32': |
|
||||
perl = conf.find_program('perl', var='PERL') |
|
||||
if not perl: |
|
||||
conf.fatal('The program perl (required by intltool) could not be found') |
|
||||
|
|
||||
intltooldir = Configure.find_file('intltool-merge', os.environ['PATH'].split(os.pathsep)) |
|
||||
if not intltooldir: |
|
||||
conf.fatal('The program intltool-merge (intltool, gettext-devel) is mandatory!') |
|
||||
|
|
||||
conf.env['INTLTOOL'] = Utils.to_list(conf.env['PERL']) + [intltooldir + os.sep + 'intltool-merge'] |
|
||||
conf.check_message('intltool', '', True, ' '.join(conf.env['INTLTOOL'])) |
|
||||
else: |
|
||||
conf.fatal('The program intltool-merge (intltool, gettext-devel) is mandatory!') |
|
||||
|
|
||||
def getstr(varname): |
|
||||
return getattr(Options.options, varname, '') |
|
||||
|
|
||||
prefix = conf.env['PREFIX'] |
|
||||
datadir = getstr('datadir') |
|
||||
if not datadir: datadir = os.path.join(prefix,'share') |
|
||||
|
|
||||
conf.define('LOCALEDIR', os.path.join(datadir, 'locale')) |
|
||||
conf.define('DATADIR', datadir) |
|
||||
|
|
||||
if conf.env['CC'] or conf.env['CXX']: |
|
||||
# Define to 1 if <locale.h> is present |
|
||||
conf.check(header_name='locale.h') |
|
||||
|
|
||||
def set_options(opt): |
|
||||
opt.add_option('--want-rpath', type='int', default=1, dest='want_rpath', help='set rpath to 1 or 0 [Default 1]') |
|
||||
opt.add_option('--datadir', type='string', default='', dest='datadir', help='read-only application data') |
|
||||
|
|
||||
@ -1,330 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Matthias Jahn, 2008, jahn matthias ath freenet punto de |
|
||||
# Thomas Nagy, 2008 (ita) |
|
||||
|
|
||||
import sys, re, os, optparse |
|
||||
|
|
||||
import TaskGen, Task, Utils, preproc |
|
||||
from Logs import error, debug, warn |
|
||||
from TaskGen import taskgen, after, before, feature |
|
||||
|
|
||||
REVISION="0.1.3" |
|
||||
|
|
||||
""" |
|
||||
if you want to use the code here, you must use something like this: |
|
||||
obj = obj.create(...) |
|
||||
obj.features.append("libtool") |
|
||||
obj.vnum = "1.2.3" # optional, but versioned libraries are common |
|
||||
""" |
|
||||
|
|
||||
# fake libtool files |
|
||||
fakelibtool_vardeps = ['CXX', 'PREFIX'] |
|
||||
def fakelibtool_build(task): |
|
||||
# Writes a .la file, used by libtool |
|
||||
env = task.env |
|
||||
dest = open(task.outputs[0].abspath(env), 'w') |
|
||||
sname = task.inputs[0].name |
|
||||
fu = dest.write |
|
||||
fu("# Generated by ltmain.sh - GNU libtool 1.5.18 - (pwn3d by BKsys II code name WAF)\n") |
|
||||
if env['vnum']: |
|
||||
nums = env['vnum'].split('.') |
|
||||
libname = task.inputs[0].name |
|
||||
name3 = libname+'.'+env['vnum'] |
|
||||
name2 = libname+'.'+nums[0] |
|
||||
name1 = libname |
|
||||
fu("dlname='%s'\n" % name2) |
|
||||
strn = " ".join([name3, name2, name1]) |
|
||||
fu("library_names='%s'\n" % (strn) ) |
|
||||
else: |
|
||||
fu("dlname='%s'\n" % sname) |
|
||||
fu("library_names='%s %s %s'\n" % (sname, sname, sname) ) |
|
||||
fu("old_library=''\n") |
|
||||
vars = ' '.join(env['libtoolvars']+env['LINKFLAGS']) |
|
||||
fu("dependency_libs='%s'\n" % vars) |
|
||||
fu("current=0\n") |
|
||||
fu("age=0\nrevision=0\ninstalled=yes\nshouldnotlink=no\n") |
|
||||
fu("dlopen=''\ndlpreopen=''\n") |
|
||||
fu("libdir='%s/lib'\n" % env['PREFIX']) |
|
||||
dest.close() |
|
||||
return 0 |
|
||||
|
|
||||
def read_la_file(path): |
|
||||
sp = re.compile(r'^([^=]+)=\'(.*)\'$') |
|
||||
dc={} |
|
||||
file = open(path, "r") |
|
||||
for line in file.readlines(): |
|
||||
try: |
|
||||
#print sp.split(line.strip()) |
|
||||
_, left, right, _ = sp.split(line.strip()) |
|
||||
dc[left]=right |
|
||||
except ValueError: |
|
||||
pass |
|
||||
file.close() |
|
||||
return dc |
|
||||
|
|
||||
@feature("libtool") |
|
||||
@after('apply_link') |
|
||||
def apply_link_libtool(self): |
|
||||
if self.type != 'program': |
|
||||
linktask = self.link_task |
|
||||
self.latask = self.create_task('fakelibtool', linktask.outputs, linktask.outputs[0].change_ext('.la')) |
|
||||
|
|
||||
if self.bld.is_install: |
|
||||
self.bld.install_files('${PREFIX}/lib', linktask.outputs[0], self.env) |
|
||||
|
|
||||
@feature("libtool") |
|
||||
@before('apply_core') |
|
||||
def apply_libtool(self): |
|
||||
self.env['vnum']=self.vnum |
|
||||
|
|
||||
paths=[] |
|
||||
libs=[] |
|
||||
libtool_files=[] |
|
||||
libtool_vars=[] |
|
||||
|
|
||||
for l in self.env['LINKFLAGS']: |
|
||||
if l[:2]=='-L': |
|
||||
paths.append(l[2:]) |
|
||||
elif l[:2]=='-l': |
|
||||
libs.append(l[2:]) |
|
||||
|
|
||||
for l in libs: |
|
||||
for p in paths: |
|
||||
dict = read_la_file(p+'/lib'+l+'.la') |
|
||||
linkflags2 = dict.get('dependency_libs', '') |
|
||||
for v in linkflags2.split(): |
|
||||
if v.endswith('.la'): |
|
||||
libtool_files.append(v) |
|
||||
libtool_vars.append(v) |
|
||||
continue |
|
||||
self.env.append_unique('LINKFLAGS', v) |
|
||||
break |
|
||||
|
|
||||
self.env['libtoolvars']=libtool_vars |
|
||||
|
|
||||
while libtool_files: |
|
||||
file = libtool_files.pop() |
|
||||
dict = read_la_file(file) |
|
||||
for v in dict['dependency_libs'].split(): |
|
||||
if v[-3:] == '.la': |
|
||||
libtool_files.append(v) |
|
||||
continue |
|
||||
self.env.append_unique('LINKFLAGS', v) |
|
||||
|
|
||||
Task.task_type_from_func('fakelibtool', vars=fakelibtool_vardeps, func=fakelibtool_build, color='BLUE', after="cc_link cxx_link static_link") |
|
||||
|
|
||||
class libtool_la_file: |
|
||||
def __init__ (self, la_filename): |
|
||||
self.__la_filename = la_filename |
|
||||
#remove path and .la suffix |
|
||||
self.linkname = str(os.path.split(la_filename)[-1])[:-3] |
|
||||
if self.linkname.startswith("lib"): |
|
||||
self.linkname = self.linkname[3:] |
|
||||
# The name that we can dlopen(3). |
|
||||
self.dlname = None |
|
||||
# Names of this library |
|
||||
self.library_names = None |
|
||||
# The name of the static archive. |
|
||||
self.old_library = None |
|
||||
# Libraries that this one depends upon. |
|
||||
self.dependency_libs = None |
|
||||
# Version information for libIlmImf. |
|
||||
self.current = None |
|
||||
self.age = None |
|
||||
self.revision = None |
|
||||
# Is this an already installed library? |
|
||||
self.installed = None |
|
||||
# Should we warn about portability when linking against -modules? |
|
||||
self.shouldnotlink = None |
|
||||
# Files to dlopen/dlpreopen |
|
||||
self.dlopen = None |
|
||||
self.dlpreopen = None |
|
||||
# Directory that this library needs to be installed in: |
|
||||
self.libdir = '/usr/lib' |
|
||||
if not self.__parse(): |
|
||||
raise "file %s not found!!" %(la_filename) |
|
||||
|
|
||||
def __parse(self): |
|
||||
"Retrieve the variables from a file" |
|
||||
if not os.path.isfile(self.__la_filename): return 0 |
|
||||
la_file=open(self.__la_filename, 'r') |
|
||||
for line in la_file: |
|
||||
ln = line.strip() |
|
||||
if not ln: continue |
|
||||
if ln[0]=='#': continue |
|
||||
(key, value) = str(ln).split('=', 1) |
|
||||
key = key.strip() |
|
||||
value = value.strip() |
|
||||
if value == "no": value = False |
|
||||
elif value == "yes": value = True |
|
||||
else: |
|
||||
try: value = int(value) |
|
||||
except ValueError: value = value.strip("'") |
|
||||
setattr(self, key, value) |
|
||||
la_file.close() |
|
||||
return 1 |
|
||||
|
|
||||
def get_libs(self): |
|
||||
"""return linkflags for this lib""" |
|
||||
libs = [] |
|
||||
if self.dependency_libs: |
|
||||
libs = str(self.dependency_libs).strip().split() |
|
||||
if libs == None: |
|
||||
libs = [] |
|
||||
# add la lib and libdir |
|
||||
libs.insert(0, "-l%s" % self.linkname.strip()) |
|
||||
libs.insert(0, "-L%s" % self.libdir.strip()) |
|
||||
return libs |
|
||||
|
|
||||
def __str__(self): |
|
||||
return '''\ |
|
||||
dlname = "%(dlname)s" |
|
||||
library_names = "%(library_names)s" |
|
||||
old_library = "%(old_library)s" |
|
||||
dependency_libs = "%(dependency_libs)s" |
|
||||
version = %(current)s.%(age)s.%(revision)s |
|
||||
installed = "%(installed)s" |
|
||||
shouldnotlink = "%(shouldnotlink)s" |
|
||||
dlopen = "%(dlopen)s" |
|
||||
dlpreopen = "%(dlpreopen)s" |
|
||||
libdir = "%(libdir)s"''' % self.__dict__ |
|
||||
|
|
||||
class libtool_config: |
|
||||
def __init__ (self, la_filename): |
|
||||
self.__libtool_la_file = libtool_la_file(la_filename) |
|
||||
tmp = self.__libtool_la_file |
|
||||
self.__version = [int(tmp.current), int(tmp.age), int(tmp.revision)] |
|
||||
self.__sub_la_files = [] |
|
||||
self.__sub_la_files.append(la_filename) |
|
||||
self.__libs = None |
|
||||
|
|
||||
def __cmp__(self, other): |
|
||||
"""make it compareable with X.Y.Z versions (Y and Z are optional)""" |
|
||||
if not other: |
|
||||
return 1 |
|
||||
othervers = [int(s) for s in str(other).split(".")] |
|
||||
selfvers = self.__version |
|
||||
return cmp(selfvers, othervers) |
|
||||
|
|
||||
def __str__(self): |
|
||||
return "\n".join([ |
|
||||
str(self.__libtool_la_file), |
|
||||
' '.join(self.__libtool_la_file.get_libs()), |
|
||||
'* New getlibs:', |
|
||||
' '.join(self.get_libs()) |
|
||||
]) |
|
||||
|
|
||||
def __get_la_libs(self, la_filename): |
|
||||
return libtool_la_file(la_filename).get_libs() |
|
||||
|
|
||||
def get_libs(self): |
|
||||
"""return the complete uniqe linkflags that do not |
|
||||
contain .la files anymore""" |
|
||||
libs_list = list(self.__libtool_la_file.get_libs()) |
|
||||
libs_map = {} |
|
||||
while len(libs_list) > 0: |
|
||||
entry = libs_list.pop(0) |
|
||||
if entry: |
|
||||
if str(entry).endswith(".la"): |
|
||||
## prevents duplicate .la checks |
|
||||
if entry not in self.__sub_la_files: |
|
||||
self.__sub_la_files.append(entry) |
|
||||
libs_list.extend(self.__get_la_libs(entry)) |
|
||||
else: |
|
||||
libs_map[entry]=1 |
|
||||
self.__libs = libs_map.keys() |
|
||||
return self.__libs |
|
||||
|
|
||||
def get_libs_only_L(self): |
|
||||
if not self.__libs: self.get_libs() |
|
||||
libs = self.__libs |
|
||||
libs = [s for s in libs if str(s).startswith('-L')] |
|
||||
return libs |
|
||||
|
|
||||
def get_libs_only_l(self): |
|
||||
if not self.__libs: self.get_libs() |
|
||||
libs = self.__libs |
|
||||
libs = [s for s in libs if str(s).startswith('-l')] |
|
||||
return libs |
|
||||
|
|
||||
def get_libs_only_other(self): |
|
||||
if not self.__libs: self.get_libs() |
|
||||
libs = self.__libs |
|
||||
libs = [s for s in libs if not(str(s).startswith('-L')or str(s).startswith('-l'))] |
|
||||
return libs |
|
||||
|
|
||||
def useCmdLine(): |
|
||||
"""parse cmdline args and control build""" |
|
||||
usage = '''Usage: %prog [options] PathToFile.la |
|
||||
example: %prog --atleast-version=2.0.0 /usr/lib/libIlmImf.la |
|
||||
nor: %prog --libs /usr/lib/libamarok.la''' |
|
||||
parser = optparse.OptionParser(usage) |
|
||||
a = parser.add_option |
|
||||
a("--version", dest = "versionNumber", |
|
||||
action = "store_true", default = False, |
|
||||
help = "output version of libtool-config" |
|
||||
) |
|
||||
a("--debug", dest = "debug", |
|
||||
action = "store_true", default = False, |
|
||||
help = "enable debug" |
|
||||
) |
|
||||
a("--libs", dest = "libs", |
|
||||
action = "store_true", default = False, |
|
||||
help = "output all linker flags" |
|
||||
) |
|
||||
a("--libs-only-l", dest = "libs_only_l", |
|
||||
action = "store_true", default = False, |
|
||||
help = "output -l flags" |
|
||||
) |
|
||||
a("--libs-only-L", dest = "libs_only_L", |
|
||||
action = "store_true", default = False, |
|
||||
help = "output -L flags" |
|
||||
) |
|
||||
a("--libs-only-other", dest = "libs_only_other", |
|
||||
action = "store_true", default = False, |
|
||||
help = "output other libs (e.g. -pthread)" |
|
||||
) |
|
||||
a("--atleast-version", dest = "atleast_version", |
|
||||
default=None, |
|
||||
help = "return 0 if the module is at least version ATLEAST_VERSION" |
|
||||
) |
|
||||
a("--exact-version", dest = "exact_version", |
|
||||
default=None, |
|
||||
help = "return 0 if the module is exactly version EXACT_VERSION" |
|
||||
) |
|
||||
a("--max-version", dest = "max_version", |
|
||||
default=None, |
|
||||
help = "return 0 if the module is at no newer than version MAX_VERSION" |
|
||||
) |
|
||||
|
|
||||
(options, args) = parser.parse_args() |
|
||||
if len(args) != 1 and not options.versionNumber: |
|
||||
parser.error("incorrect number of arguments") |
|
||||
if options.versionNumber: |
|
||||
print("libtool-config version %s" % REVISION) |
|
||||
return 0 |
|
||||
ltf = libtool_config(args[0]) |
|
||||
if options.debug: |
|
||||
print(ltf) |
|
||||
if options.atleast_version: |
|
||||
if ltf >= options.atleast_version: return 0 |
|
||||
sys.exit(1) |
|
||||
if options.exact_version: |
|
||||
if ltf == options.exact_version: return 0 |
|
||||
sys.exit(1) |
|
||||
if options.max_version: |
|
||||
if ltf <= options.max_version: return 0 |
|
||||
sys.exit(1) |
|
||||
|
|
||||
def p(x): |
|
||||
print(" ".join(x)) |
|
||||
if options.libs: p(ltf.get_libs()) |
|
||||
elif options.libs_only_l: p(ltf.get_libs_only_l()) |
|
||||
elif options.libs_only_L: p(ltf.get_libs_only_L()) |
|
||||
elif options.libs_only_other: p(ltf.get_libs_only_other()) |
|
||||
return 0 |
|
||||
|
|
||||
if __name__ == '__main__': |
|
||||
useCmdLine() |
|
||||
|
|
||||
@ -1,430 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
|
|
||||
""" |
|
||||
Custom objects: |
|
||||
- execute a function everytime |
|
||||
- copy a file somewhere else |
|
||||
""" |
|
||||
|
|
||||
import shutil, re, os |
|
||||
import TaskGen, Node, Task, Utils, Build, Constants |
|
||||
from TaskGen import feature, taskgen, after, before |
|
||||
from Logs import debug |
|
||||
|
|
||||
def copy_func(tsk): |
|
||||
"Make a file copy. This might be used to make other kinds of file processing (even calling a compiler is possible)" |
|
||||
env = tsk.env |
|
||||
infile = tsk.inputs[0].abspath(env) |
|
||||
outfile = tsk.outputs[0].abspath(env) |
|
||||
try: |
|
||||
shutil.copy2(infile, outfile) |
|
||||
except (OSError, IOError): |
|
||||
return 1 |
|
||||
else: |
|
||||
if tsk.chmod: os.chmod(outfile, tsk.chmod) |
|
||||
return 0 |
|
||||
|
|
||||
def action_process_file_func(tsk): |
|
||||
"Ask the function attached to the task to process it" |
|
||||
if not tsk.fun: raise Utils.WafError('task must have a function attached to it for copy_func to work!') |
|
||||
return tsk.fun(tsk) |
|
||||
|
|
||||
class cmd_taskgen(TaskGen.task_gen): |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@feature('cmd') |
|
||||
def apply_cmd(self): |
|
||||
"call a command everytime" |
|
||||
if not self.fun: raise Utils.WafError('cmdobj needs a function!') |
|
||||
tsk = Task.TaskBase() |
|
||||
tsk.fun = self.fun |
|
||||
tsk.env = self.env |
|
||||
self.tasks.append(tsk) |
|
||||
tsk.install_path = self.install_path |
|
||||
|
|
||||
class copy_taskgen(TaskGen.task_gen): |
|
||||
"By default, make a file copy, if fun is provided, fun will make the copy (or call a compiler, etc)" |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@feature('copy') |
|
||||
@before('apply_core') |
|
||||
def apply_copy(self): |
|
||||
Utils.def_attrs(self, fun=copy_func) |
|
||||
self.default_install_path = 0 |
|
||||
|
|
||||
lst = self.to_list(self.source) |
|
||||
self.meths.remove('apply_core') |
|
||||
|
|
||||
for filename in lst: |
|
||||
node = self.path.find_resource(filename) |
|
||||
if not node: raise Utils.WafError('cannot find input file %s for processing' % filename) |
|
||||
|
|
||||
target = self.target |
|
||||
if not target or len(lst)>1: target = node.name |
|
||||
|
|
||||
# TODO the file path may be incorrect |
|
||||
newnode = self.path.find_or_declare(target) |
|
||||
|
|
||||
tsk = self.create_task('copy', node, newnode) |
|
||||
tsk.fun = self.fun |
|
||||
tsk.chmod = self.chmod |
|
||||
tsk.install_path = self.install_path |
|
||||
|
|
||||
if not tsk.env: |
|
||||
tsk.debug() |
|
||||
raise Utils.WafError('task without an environment') |
|
||||
|
|
||||
def subst_func(tsk): |
|
||||
"Substitutes variables in a .in file" |
|
||||
|
|
||||
m4_re = re.compile('@(\w+)@', re.M) |
|
||||
|
|
||||
env = tsk.env |
|
||||
infile = tsk.inputs[0].abspath(env) |
|
||||
outfile = tsk.outputs[0].abspath(env) |
|
||||
|
|
||||
code = Utils.readf(infile) |
|
||||
|
|
||||
# replace all % by %% to prevent errors by % signs in the input file while string formatting |
|
||||
code = code.replace('%', '%%') |
|
||||
|
|
||||
s = m4_re.sub(r'%(\1)s', code) |
|
||||
|
|
||||
di = tsk.dict or {} |
|
||||
if not di: |
|
||||
names = m4_re.findall(code) |
|
||||
for i in names: |
|
||||
di[i] = env.get_flat(i) or env.get_flat(i.upper()) |
|
||||
|
|
||||
file = open(outfile, 'w') |
|
||||
file.write(s % di) |
|
||||
file.close() |
|
||||
if tsk.chmod: os.chmod(outfile, tsk.chmod) |
|
||||
|
|
||||
class subst_taskgen(TaskGen.task_gen): |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@feature('subst') |
|
||||
@before('apply_core') |
|
||||
def apply_subst(self): |
|
||||
Utils.def_attrs(self, fun=subst_func) |
|
||||
self.default_install_path = 0 |
|
||||
lst = self.to_list(self.source) |
|
||||
self.meths.remove('apply_core') |
|
||||
|
|
||||
self.dict = getattr(self, 'dict', {}) |
|
||||
|
|
||||
for filename in lst: |
|
||||
node = self.path.find_resource(filename) |
|
||||
if not node: raise Utils.WafError('cannot find input file %s for processing' % filename) |
|
||||
|
|
||||
if self.target: |
|
||||
newnode = self.path.find_or_declare(self.target) |
|
||||
else: |
|
||||
newnode = node.change_ext('') |
|
||||
|
|
||||
try: |
|
||||
self.dict = self.dict.get_merged_dict() |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
|
|
||||
if self.dict and not self.env['DICT_HASH']: |
|
||||
self.env = self.env.copy() |
|
||||
keys = list(self.dict.keys()) |
|
||||
keys.sort() |
|
||||
lst = [self.dict[x] for x in keys] |
|
||||
self.env['DICT_HASH'] = str(Utils.h_list(lst)) |
|
||||
|
|
||||
tsk = self.create_task('copy', node, newnode) |
|
||||
tsk.fun = self.fun |
|
||||
tsk.dict = self.dict |
|
||||
tsk.dep_vars = ['DICT_HASH'] |
|
||||
tsk.install_path = self.install_path |
|
||||
tsk.chmod = self.chmod |
|
||||
|
|
||||
if not tsk.env: |
|
||||
tsk.debug() |
|
||||
raise Utils.WafError('task without an environment') |
|
||||
|
|
||||
#################### |
|
||||
## command-output #### |
|
||||
#################### |
|
||||
|
|
||||
class cmd_arg(object): |
|
||||
"""command-output arguments for representing files or folders""" |
|
||||
def __init__(self, name, template='%s'): |
|
||||
self.name = name |
|
||||
self.template = template |
|
||||
self.node = None |
|
||||
|
|
||||
class input_file(cmd_arg): |
|
||||
def find_node(self, base_path): |
|
||||
assert isinstance(base_path, Node.Node) |
|
||||
self.node = base_path.find_resource(self.name) |
|
||||
if self.node is None: |
|
||||
raise Utils.WafError("Input file %s not found in " % (self.name, base_path)) |
|
||||
|
|
||||
def get_path(self, env, absolute): |
|
||||
if absolute: |
|
||||
return self.template % self.node.abspath(env) |
|
||||
else: |
|
||||
return self.template % self.node.srcpath(env) |
|
||||
|
|
||||
class output_file(cmd_arg): |
|
||||
def find_node(self, base_path): |
|
||||
assert isinstance(base_path, Node.Node) |
|
||||
self.node = base_path.find_or_declare(self.name) |
|
||||
if self.node is None: |
|
||||
raise Utils.WafError("Output file %s not found in " % (self.name, base_path)) |
|
||||
|
|
||||
def get_path(self, env, absolute): |
|
||||
if absolute: |
|
||||
return self.template % self.node.abspath(env) |
|
||||
else: |
|
||||
return self.template % self.node.bldpath(env) |
|
||||
|
|
||||
class cmd_dir_arg(cmd_arg): |
|
||||
def find_node(self, base_path): |
|
||||
assert isinstance(base_path, Node.Node) |
|
||||
self.node = base_path.find_dir(self.name) |
|
||||
if self.node is None: |
|
||||
raise Utils.WafError("Directory %s not found in " % (self.name, base_path)) |
|
||||
|
|
||||
class input_dir(cmd_dir_arg): |
|
||||
def get_path(self, dummy_env, dummy_absolute): |
|
||||
return self.template % self.node.abspath() |
|
||||
|
|
||||
class output_dir(cmd_dir_arg): |
|
||||
def get_path(self, env, dummy_absolute): |
|
||||
return self.template % self.node.abspath(env) |
|
||||
|
|
||||
|
|
||||
class command_output(Task.Task): |
|
||||
color = "BLUE" |
|
||||
def __init__(self, env, command, command_node, command_args, stdin, stdout, cwd, os_env, stderr): |
|
||||
Task.Task.__init__(self, env, normal=1) |
|
||||
assert isinstance(command, (str, Node.Node)) |
|
||||
self.command = command |
|
||||
self.command_args = command_args |
|
||||
self.stdin = stdin |
|
||||
self.stdout = stdout |
|
||||
self.cwd = cwd |
|
||||
self.os_env = os_env |
|
||||
self.stderr = stderr |
|
||||
|
|
||||
if command_node is not None: self.dep_nodes = [command_node] |
|
||||
self.dep_vars = [] # additional environment variables to look |
|
||||
|
|
||||
def run(self): |
|
||||
task = self |
|
||||
#assert len(task.inputs) > 0 |
|
||||
|
|
||||
def input_path(node, template): |
|
||||
if task.cwd is None: |
|
||||
return template % node.bldpath(task.env) |
|
||||
else: |
|
||||
return template % node.abspath() |
|
||||
def output_path(node, template): |
|
||||
fun = node.abspath |
|
||||
if task.cwd is None: fun = node.bldpath |
|
||||
return template % fun(task.env) |
|
||||
|
|
||||
if isinstance(task.command, Node.Node): |
|
||||
argv = [input_path(task.command, '%s')] |
|
||||
else: |
|
||||
argv = [task.command] |
|
||||
|
|
||||
for arg in task.command_args: |
|
||||
if isinstance(arg, str): |
|
||||
argv.append(arg) |
|
||||
else: |
|
||||
assert isinstance(arg, cmd_arg) |
|
||||
argv.append(arg.get_path(task.env, (task.cwd is not None))) |
|
||||
|
|
||||
if task.stdin: |
|
||||
stdin = open(input_path(task.stdin, '%s')) |
|
||||
else: |
|
||||
stdin = None |
|
||||
|
|
||||
if task.stdout: |
|
||||
stdout = open(output_path(task.stdout, '%s'), "w") |
|
||||
else: |
|
||||
stdout = None |
|
||||
|
|
||||
if task.stderr: |
|
||||
stderr = open(output_path(task.stderr, '%s'), "w") |
|
||||
else: |
|
||||
stderr = None |
|
||||
|
|
||||
if task.cwd is None: |
|
||||
cwd = ('None (actually %r)' % os.getcwd()) |
|
||||
else: |
|
||||
cwd = repr(task.cwd) |
|
||||
debug("command-output: cwd=%s, stdin=%r, stdout=%r, argv=%r" % |
|
||||
(cwd, stdin, stdout, argv)) |
|
||||
|
|
||||
if task.os_env is None: |
|
||||
os_env = os.environ |
|
||||
else: |
|
||||
os_env = task.os_env |
|
||||
command = Utils.pproc.Popen(argv, stdin=stdin, stdout=stdout, stderr=stderr, cwd=task.cwd, env=os_env) |
|
||||
return command.wait() |
|
||||
|
|
||||
class cmd_output_taskgen(TaskGen.task_gen): |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@feature('command-output') |
|
||||
def init_cmd_output(self): |
|
||||
Utils.def_attrs(self, |
|
||||
stdin = None, |
|
||||
stdout = None, |
|
||||
stderr = None, |
|
||||
# the command to execute |
|
||||
command = None, |
|
||||
|
|
||||
# whether it is an external command; otherwise it is assumed |
|
||||
# to be an executable binary or script that lives in the |
|
||||
# source or build tree. |
|
||||
command_is_external = False, |
|
||||
|
|
||||
# extra parameters (argv) to pass to the command (excluding |
|
||||
# the command itself) |
|
||||
argv = [], |
|
||||
|
|
||||
# dependencies to other objects -> this is probably not what you want (ita) |
|
||||
# values must be 'task_gen' instances (not names!) |
|
||||
dependencies = [], |
|
||||
|
|
||||
# dependencies on env variable contents |
|
||||
dep_vars = [], |
|
||||
|
|
||||
# input files that are implicit, i.e. they are not |
|
||||
# stdin, nor are they mentioned explicitly in argv |
|
||||
hidden_inputs = [], |
|
||||
|
|
||||
# output files that are implicit, i.e. they are not |
|
||||
# stdout, nor are they mentioned explicitly in argv |
|
||||
hidden_outputs = [], |
|
||||
|
|
||||
# change the subprocess to this cwd (must use obj.input_dir() or output_dir() here) |
|
||||
cwd = None, |
|
||||
|
|
||||
# OS environment variables to pass to the subprocess |
|
||||
# if None, use the default environment variables unchanged |
|
||||
os_env = None) |
|
||||
|
|
||||
@feature('command-output') |
|
||||
@after('init_cmd_output') |
|
||||
def apply_cmd_output(self): |
|
||||
if self.command is None: |
|
||||
raise Utils.WafError("command-output missing command") |
|
||||
if self.command_is_external: |
|
||||
cmd = self.command |
|
||||
cmd_node = None |
|
||||
else: |
|
||||
cmd_node = self.path.find_resource(self.command) |
|
||||
assert cmd_node is not None, ('''Could not find command '%s' in source tree. |
|
||||
Hint: if this is an external command, |
|
||||
use command_is_external=True''') % (self.command,) |
|
||||
cmd = cmd_node |
|
||||
|
|
||||
if self.cwd is None: |
|
||||
cwd = None |
|
||||
else: |
|
||||
assert isinstance(cwd, CmdDirArg) |
|
||||
self.cwd.find_node(self.path) |
|
||||
|
|
||||
args = [] |
|
||||
inputs = [] |
|
||||
outputs = [] |
|
||||
|
|
||||
for arg in self.argv: |
|
||||
if isinstance(arg, cmd_arg): |
|
||||
arg.find_node(self.path) |
|
||||
if isinstance(arg, input_file): |
|
||||
inputs.append(arg.node) |
|
||||
if isinstance(arg, output_file): |
|
||||
outputs.append(arg.node) |
|
||||
|
|
||||
if self.stdout is None: |
|
||||
stdout = None |
|
||||
else: |
|
||||
assert isinstance(self.stdout, str) |
|
||||
stdout = self.path.find_or_declare(self.stdout) |
|
||||
if stdout is None: |
|
||||
raise Utils.WafError("File %s not found" % (self.stdout,)) |
|
||||
outputs.append(stdout) |
|
||||
|
|
||||
if self.stderr is None: |
|
||||
stderr = None |
|
||||
else: |
|
||||
assert isinstance(self.stderr, str) |
|
||||
stderr = self.path.find_or_declare(self.stderr) |
|
||||
if stderr is None: |
|
||||
raise Utils.WafError("File %s not found" % (self.stderr,)) |
|
||||
outputs.append(stderr) |
|
||||
|
|
||||
if self.stdin is None: |
|
||||
stdin = None |
|
||||
else: |
|
||||
assert isinstance(self.stdin, str) |
|
||||
stdin = self.path.find_resource(self.stdin) |
|
||||
if stdin is None: |
|
||||
raise Utils.WafError("File %s not found" % (self.stdin,)) |
|
||||
inputs.append(stdin) |
|
||||
|
|
||||
for hidden_input in self.to_list(self.hidden_inputs): |
|
||||
node = self.path.find_resource(hidden_input) |
|
||||
if node is None: |
|
||||
raise Utils.WafError("File %s not found in dir %s" % (hidden_input, self.path)) |
|
||||
inputs.append(node) |
|
||||
|
|
||||
for hidden_output in self.to_list(self.hidden_outputs): |
|
||||
node = self.path.find_or_declare(hidden_output) |
|
||||
if node is None: |
|
||||
raise Utils.WafError("File %s not found in dir %s" % (hidden_output, self.path)) |
|
||||
outputs.append(node) |
|
||||
|
|
||||
if not (inputs or getattr(self, 'no_inputs', None)): |
|
||||
raise Utils.WafError('command-output objects must have at least one input file or give self.no_inputs') |
|
||||
if not (outputs or getattr(self, 'no_outputs', None)): |
|
||||
raise Utils.WafError('command-output objects must have at least one output file or give self.no_outputs') |
|
||||
|
|
||||
task = command_output(self.env, cmd, cmd_node, self.argv, stdin, stdout, cwd, self.os_env, stderr) |
|
||||
Utils.copy_attrs(self, task, 'before after ext_in ext_out', only_if_set=True) |
|
||||
self.tasks.append(task) |
|
||||
|
|
||||
task.inputs = inputs |
|
||||
task.outputs = outputs |
|
||||
task.dep_vars = self.to_list(self.dep_vars) |
|
||||
|
|
||||
for dep in self.dependencies: |
|
||||
assert dep is not self |
|
||||
dep.post() |
|
||||
for dep_task in dep.tasks: |
|
||||
task.set_run_after(dep_task) |
|
||||
|
|
||||
if not task.inputs: |
|
||||
# the case for svnversion, always run, and update the output nodes |
|
||||
task.runnable_status = type(Task.TaskBase.run)(runnable_status, task, task.__class__) # always run |
|
||||
task.post_run = type(Task.TaskBase.run)(post_run, task, task.__class__) |
|
||||
|
|
||||
# TODO the case with no outputs? |
|
||||
|
|
||||
def post_run(self): |
|
||||
for x in self.outputs: |
|
||||
h = Utils.h_file(x.abspath(self.env)) |
|
||||
self.generator.bld.node_sigs[self.env.variant()][x.id] = h |
|
||||
|
|
||||
def runnable_status(self): |
|
||||
return Constants.RUN_ME |
|
||||
|
|
||||
Task.task_type_from_func('copy', vars=[], func=action_process_file_func) |
|
||||
TaskGen.task_gen.classes['command-output'] = cmd_output_taskgen |
|
||||
|
|
||||
@ -1,49 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2008 |
|
||||
|
|
||||
""" |
|
||||
Nasm processing |
|
||||
""" |
|
||||
|
|
||||
import os |
|
||||
import TaskGen, Task, Utils |
|
||||
from TaskGen import taskgen, before, extension |
|
||||
|
|
||||
nasm_str = '${NASM} ${NASM_FLAGS} ${NASM_INCLUDES} ${SRC} -o ${TGT}' |
|
||||
|
|
||||
EXT_NASM = ['.s', '.S', '.asm', '.ASM', '.spp', '.SPP'] |
|
||||
|
|
||||
@before('apply_link') |
|
||||
def apply_nasm_vars(self): |
|
||||
|
|
||||
# flags |
|
||||
if hasattr(self, 'nasm_flags'): |
|
||||
for flag in self.to_list(self.nasm_flags): |
|
||||
self.env.append_value('NASM_FLAGS', flag) |
|
||||
|
|
||||
# includes - well, if we suppose it works with c processing |
|
||||
if hasattr(self, 'includes'): |
|
||||
for inc in self.to_list(self.includes): |
|
||||
node = self.path.find_dir(inc) |
|
||||
if not node: |
|
||||
raise Utils.WafError('cannot find the dir' + inc) |
|
||||
self.env.append_value('NASM_INCLUDES', '-I%s' % node.srcpath(self.env)) |
|
||||
self.env.append_value('NASM_INCLUDES', '-I%s' % node.bldpath(self.env)) |
|
||||
|
|
||||
@extension(EXT_NASM) |
|
||||
def nasm_file(self, node): |
|
||||
try: obj_ext = self.obj_ext |
|
||||
except AttributeError: obj_ext = '_%d.o' % self.idx |
|
||||
|
|
||||
task = self.create_task('nasm', node, node.change_ext(obj_ext)) |
|
||||
self.compiled_tasks.append(task) |
|
||||
|
|
||||
self.meths.append('apply_nasm_vars') |
|
||||
|
|
||||
# create our action here |
|
||||
Task.simple_task_type('nasm', nasm_str, color='BLUE', ext_out='.o', shell=False) |
|
||||
|
|
||||
def detect(conf): |
|
||||
nasm = conf.find_program(['nasm', 'yasm'], var='NASM', mandatory=True) |
|
||||
|
|
||||
@ -1,86 +0,0 @@ |
|||||
import os |
|
||||
import TaskGen, Utils, Runner, Options, Build |
|
||||
from TaskGen import extension, taskgen, before, after, feature |
|
||||
from Configure import conf, conftest |
|
||||
|
|
||||
@taskgen |
|
||||
@before('apply_incpaths', 'apply_lib_vars', 'apply_type_vars') |
|
||||
@feature('node_addon') |
|
||||
@before('apply_bundle') |
|
||||
def init_node_addon(self): |
|
||||
self.default_install_path = self.env['NODE_PATH'] |
|
||||
self.uselib = self.to_list(getattr(self, 'uselib', '')) |
|
||||
if not 'NODE' in self.uselib: self.uselib.append('NODE') |
|
||||
self.env['MACBUNDLE'] = True |
|
||||
|
|
||||
@taskgen |
|
||||
@before('apply_link', 'apply_lib_vars', 'apply_type_vars') |
|
||||
@after('apply_bundle') |
|
||||
@feature('node_addon') |
|
||||
def node_addon_shlib_ext(self): |
|
||||
self.env['shlib_PATTERN'] = "%s.node" |
|
||||
|
|
||||
def detect(conf): |
|
||||
join = os.path.join |
|
||||
|
|
||||
conf.env['PREFIX_NODE'] = get_prefix() |
|
||||
prefix = conf.env['PREFIX_NODE'] |
|
||||
lib = join(prefix, 'lib') |
|
||||
nodebin = join(prefix, 'bin', 'node') |
|
||||
|
|
||||
conf.env['LIBPATH_NODE'] = lib |
|
||||
conf.env['CPPPATH_NODE'] = join(prefix, 'include', 'node') |
|
||||
|
|
||||
conf.env.append_value('CPPFLAGS_NODE', '-D_GNU_SOURCE') |
|
||||
|
|
||||
conf.env.append_value('CCFLAGS_NODE', '-D_LARGEFILE_SOURCE') |
|
||||
conf.env.append_value('CCFLAGS_NODE', '-D_FILE_OFFSET_BITS=64') |
|
||||
|
|
||||
conf.env.append_value('CXXFLAGS_NODE', '-D_LARGEFILE_SOURCE') |
|
||||
conf.env.append_value('CXXFLAGS_NODE', '-D_FILE_OFFSET_BITS=64') |
|
||||
|
|
||||
# with symbols |
|
||||
conf.env.append_value('CCFLAGS', ['-g']) |
|
||||
conf.env.append_value('CXXFLAGS', ['-g']) |
|
||||
# install path |
|
||||
conf.env['NODE_PATH'] = get_node_path() |
|
||||
# this changes the install path of cxx task_gen |
|
||||
conf.env['LIBDIR'] = conf.env['NODE_PATH'] |
|
||||
|
|
||||
found = os.path.exists(conf.env['NODE_PATH']) |
|
||||
conf.check_message('node path', '', found, conf.env['NODE_PATH']) |
|
||||
|
|
||||
found = os.path.exists(nodebin) |
|
||||
conf.check_message('node prefix', '', found, prefix) |
|
||||
|
|
||||
## On Cygwin we need to link to the generated symbol definitions |
|
||||
if Options.platform.startswith('cygwin'): conf.env['LIB_NODE'] = 'node' |
|
||||
|
|
||||
## On Mac OSX we need to use mac bundles |
|
||||
if Options.platform == 'darwin': |
|
||||
if 'i386' in Utils.cmd_output(['file', nodebin]): |
|
||||
conf.env.append_value('CPPFLAGS_NODE', ['-arch', 'i386']) |
|
||||
conf.env.append_value('CXXFLAGS_NODE', ['-arch', 'i386']) |
|
||||
conf.env.append_value('LINKFLAGS', ['-arch', 'i386']) |
|
||||
conf.env['DEST_CPU'] = 'i386' |
|
||||
conf.check_tool('osx') |
|
||||
|
|
||||
def get_node_path(): |
|
||||
join = os.path.join |
|
||||
nodePath = None |
|
||||
if not os.environ.has_key('NODE_PATH'): |
|
||||
if not os.environ.has_key('HOME'): |
|
||||
nodePath = join(get_prefix(), 'lib', 'node') |
|
||||
else: |
|
||||
nodePath = join(os.environ['HOME'], '.node_libraries') |
|
||||
else: |
|
||||
nodePath = os.environ['NODE_PATH'] |
|
||||
return nodePath |
|
||||
|
|
||||
def get_prefix(): |
|
||||
prefix = None |
|
||||
if not os.environ.has_key('PREFIX_NODE'): |
|
||||
prefix = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..')) |
|
||||
else: |
|
||||
prefix = os.environ['PREFIX_NODE'] |
|
||||
return prefix |
|
||||
@ -1,187 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy 2008 |
|
||||
|
|
||||
"""MacOSX related tools |
|
||||
|
|
||||
To compile an executable into a Mac application bundle (a .app), set its 'mac_app' attribute |
|
||||
obj.mac_app = True |
|
||||
|
|
||||
To make a bundled shared library (a .bundle), set the 'mac_bundle' attribute: |
|
||||
obj.mac_bundle = True |
|
||||
""" |
|
||||
|
|
||||
import os, shutil, sys, platform |
|
||||
import TaskGen, Task, Build, Options, Utils |
|
||||
from TaskGen import taskgen, feature, after, before |
|
||||
from Logs import error, debug |
|
||||
|
|
||||
# plist template |
|
||||
app_info = ''' |
|
||||
<?xml version="1.0" encoding="UTF-8"?> |
|
||||
<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd"> |
|
||||
<plist version="0.9"> |
|
||||
<dict> |
|
||||
<key>CFBundlePackageType</key> |
|
||||
<string>APPL</string> |
|
||||
<key>CFBundleGetInfoString</key> |
|
||||
<string>Created by Waf</string> |
|
||||
<key>CFBundleSignature</key> |
|
||||
<string>????</string> |
|
||||
<key>NOTE</key> |
|
||||
<string>THIS IS A GENERATED FILE, DO NOT MODIFY</string> |
|
||||
<key>CFBundleExecutable</key> |
|
||||
<string>%s</string> |
|
||||
</dict> |
|
||||
</plist> |
|
||||
''' |
|
||||
|
|
||||
# see WAF issue 285 |
|
||||
# and also http://trac.macports.org/ticket/17059 |
|
||||
@feature('cc', 'cxx') |
|
||||
@before('apply_lib_vars') |
|
||||
def set_macosx_deployment_target(self): |
|
||||
if self.env['MACOSX_DEPLOYMENT_TARGET']: |
|
||||
os.environ['MACOSX_DEPLOYMENT_TARGET'] = self.env['MACOSX_DEPLOYMENT_TARGET'] |
|
||||
elif 'MACOSX_DEPLOYMENT_TARGET' not in os.environ: |
|
||||
if sys.platform == 'darwin': |
|
||||
os.environ['MACOSX_DEPLOYMENT_TARGET'] = '.'.join(platform.mac_ver()[0].split('.')[:2]) |
|
||||
|
|
||||
@feature('cc', 'cxx') |
|
||||
@after('apply_lib_vars') |
|
||||
def apply_framework(self): |
|
||||
for x in self.to_list(self.env['FRAMEWORKPATH']): |
|
||||
frameworkpath_st = '-F%s' |
|
||||
self.env.append_unique('CXXFLAGS', frameworkpath_st % x) |
|
||||
self.env.append_unique('CCFLAGS', frameworkpath_st % x) |
|
||||
self.env.append_unique('LINKFLAGS', frameworkpath_st % x) |
|
||||
|
|
||||
for x in self.to_list(self.env['FRAMEWORK']): |
|
||||
self.env.append_value('LINKFLAGS', ['-framework', x]) |
|
||||
|
|
||||
@taskgen |
|
||||
def create_bundle_dirs(self, name, out): |
|
||||
bld = self.bld |
|
||||
dir = out.parent.get_dir(name) |
|
||||
|
|
||||
if not dir: |
|
||||
dir = out.__class__(name, out.parent, 1) |
|
||||
bld.rescan(dir) |
|
||||
contents = out.__class__('Contents', dir, 1) |
|
||||
bld.rescan(contents) |
|
||||
macos = out.__class__('MacOS', contents, 1) |
|
||||
bld.rescan(macos) |
|
||||
return dir |
|
||||
|
|
||||
def bundle_name_for_output(out): |
|
||||
name = out.name |
|
||||
k = name.rfind('.') |
|
||||
if k >= 0: |
|
||||
name = name[:k] + '.app' |
|
||||
else: |
|
||||
name = name + '.app' |
|
||||
return name |
|
||||
|
|
||||
@taskgen |
|
||||
@after('apply_link') |
|
||||
@feature('cprogram') |
|
||||
def create_task_macapp(self): |
|
||||
"""Use env['MACAPP'] to force *all* executables to be transformed into Mac applications |
|
||||
or use obj.mac_app = True to build specific targets as Mac apps""" |
|
||||
if self.env['MACAPP'] or getattr(self, 'mac_app', False): |
|
||||
apptask = self.create_task('macapp') |
|
||||
apptask.set_inputs(self.link_task.outputs) |
|
||||
|
|
||||
out = self.link_task.outputs[0] |
|
||||
|
|
||||
name = bundle_name_for_output(out) |
|
||||
dir = self.create_bundle_dirs(name, out) |
|
||||
|
|
||||
n1 = dir.find_or_declare(['Contents', 'MacOS', out.name]) |
|
||||
|
|
||||
apptask.set_outputs([n1]) |
|
||||
apptask.chmod = 0755 |
|
||||
apptask.install_path = os.path.join(self.install_path, name, 'Contents', 'MacOS') |
|
||||
self.apptask = apptask |
|
||||
|
|
||||
@after('apply_link') |
|
||||
@feature('cprogram') |
|
||||
def create_task_macplist(self): |
|
||||
"""Use env['MACAPP'] to force *all* executables to be transformed into Mac applications |
|
||||
or use obj.mac_app = True to build specific targets as Mac apps""" |
|
||||
if self.env['MACAPP'] or getattr(self, 'mac_app', False): |
|
||||
# check if the user specified a plist before using our template |
|
||||
if not getattr(self, 'mac_plist', False): |
|
||||
self.mac_plist = app_info |
|
||||
|
|
||||
plisttask = self.create_task('macplist') |
|
||||
plisttask.set_inputs(self.link_task.outputs) |
|
||||
|
|
||||
out = self.link_task.outputs[0] |
|
||||
self.mac_plist = self.mac_plist % (out.name) |
|
||||
|
|
||||
name = bundle_name_for_output(out) |
|
||||
dir = self.create_bundle_dirs(name, out) |
|
||||
|
|
||||
n1 = dir.find_or_declare(['Contents', 'Info.plist']) |
|
||||
|
|
||||
plisttask.set_outputs([n1]) |
|
||||
plisttask.mac_plist = self.mac_plist |
|
||||
plisttask.install_path = os.path.join(self.install_path, name, 'Contents') |
|
||||
self.plisttask = plisttask |
|
||||
|
|
||||
@after('apply_link') |
|
||||
@feature('cshlib') |
|
||||
def apply_link_osx(self): |
|
||||
name = self.link_task.outputs[0].name |
|
||||
if not self.install_path: |
|
||||
return |
|
||||
if getattr(self, 'vnum', None): |
|
||||
name = name.replace('.dylib', '.%s.dylib' % self.vnum) |
|
||||
|
|
||||
path = os.path.join(Utils.subst_vars(self.install_path, self.env), name) |
|
||||
if '-dynamiclib' in self.env['LINKFLAGS']: |
|
||||
self.env.append_value('LINKFLAGS', '-install_name') |
|
||||
self.env.append_value('LINKFLAGS', path) |
|
||||
|
|
||||
@before('apply_link', 'apply_lib_vars') |
|
||||
@feature('cc', 'cxx') |
|
||||
def apply_bundle(self): |
|
||||
"""use env['MACBUNDLE'] to force all shlibs into mac bundles |
|
||||
or use obj.mac_bundle = True for specific targets only""" |
|
||||
if not ('cshlib' in self.features or 'shlib' in self.features): return |
|
||||
if self.env['MACBUNDLE'] or getattr(self, 'mac_bundle', False): |
|
||||
self.env['shlib_PATTERN'] = self.env['macbundle_PATTERN'] |
|
||||
uselib = self.uselib = self.to_list(self.uselib) |
|
||||
if not 'MACBUNDLE' in uselib: uselib.append('MACBUNDLE') |
|
||||
|
|
||||
@after('apply_link') |
|
||||
@feature('cshlib') |
|
||||
def apply_bundle_remove_dynamiclib(self): |
|
||||
if self.env['MACBUNDLE'] or getattr(self, 'mac_bundle', False): |
|
||||
if not getattr(self, 'vnum', None): |
|
||||
try: |
|
||||
self.env['LINKFLAGS'].remove('-dynamiclib') |
|
||||
except ValueError: |
|
||||
pass |
|
||||
|
|
||||
# TODO REMOVE IN 1.6 (global variable) |
|
||||
app_dirs = ['Contents', 'Contents/MacOS', 'Contents/Resources'] |
|
||||
|
|
||||
def app_build(task): |
|
||||
env = task.env |
|
||||
shutil.copy2(task.inputs[0].srcpath(env), task.outputs[0].abspath(env)) |
|
||||
|
|
||||
return 0 |
|
||||
|
|
||||
def plist_build(task): |
|
||||
env = task.env |
|
||||
f = open(task.outputs[0].abspath(env), "w") |
|
||||
f.write(task.mac_plist) |
|
||||
f.close() |
|
||||
|
|
||||
return 0 |
|
||||
|
|
||||
Task.task_type_from_func('macapp', vars=[], func=app_build, after="cxx_link cc_link static_link") |
|
||||
Task.task_type_from_func('macplist', vars=[], func=plist_build, after="cxx_link cc_link static_link") |
|
||||
|
|
||||
@ -1,813 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006-2009 (ita) |
|
||||
|
|
||||
""" |
|
||||
C/C++ preprocessor for finding dependencies |
|
||||
|
|
||||
Reasons for using the Waf preprocessor by default |
|
||||
1. Some c/c++ extensions (Qt) require a custom preprocessor for obtaining the dependencies (.moc files) |
|
||||
2. Not all compilers provide .d files for obtaining the dependencies (portability) |
|
||||
3. A naive file scanner will not catch the constructs such as "#include foo()" |
|
||||
4. A naive file scanner will catch unnecessary dependencies (change an unused header -> recompile everything) |
|
||||
|
|
||||
Regarding the speed concerns: |
|
||||
a. the preprocessing is performed only when files must be compiled |
|
||||
b. the macros are evaluated only for #if/#elif/#include |
|
||||
c. the time penalty is about 10% |
|
||||
d. system headers are not scanned |
|
||||
|
|
||||
Now if you do not want the Waf preprocessor, the tool "gccdeps" uses the .d files produced |
|
||||
during the compilation to track the dependencies (useful when used with the boost libraries). |
|
||||
It only works with gcc though, and it cannot be used with Qt builds. A dumb |
|
||||
file scanner will be added in the future, so we will have most bahaviours. |
|
||||
""" |
|
||||
# TODO: more varargs, pragma once |
|
||||
# TODO: dumb file scanner tracking all includes |
|
||||
|
|
||||
import re, sys, os, string |
|
||||
import Logs, Build, Utils |
|
||||
from Logs import debug, error |
|
||||
import traceback |
|
||||
|
|
||||
class PreprocError(Utils.WafError): |
|
||||
pass |
|
||||
|
|
||||
POPFILE = '-' |
|
||||
|
|
||||
|
|
||||
recursion_limit = 100 |
|
||||
"do not loop too much on header inclusion" |
|
||||
|
|
||||
go_absolute = 0 |
|
||||
"set to 1 to track headers on files in /usr/include - else absolute paths are ignored" |
|
||||
|
|
||||
standard_includes = ['/usr/include'] |
|
||||
if sys.platform == "win32": |
|
||||
standard_includes = [] |
|
||||
|
|
||||
use_trigraphs = 0 |
|
||||
'apply the trigraph rules first' |
|
||||
|
|
||||
strict_quotes = 0 |
|
||||
"Keep <> for system includes (do not search for those includes)" |
|
||||
|
|
||||
g_optrans = { |
|
||||
'not':'!', |
|
||||
'and':'&&', |
|
||||
'bitand':'&', |
|
||||
'and_eq':'&=', |
|
||||
'or':'||', |
|
||||
'bitor':'|', |
|
||||
'or_eq':'|=', |
|
||||
'xor':'^', |
|
||||
'xor_eq':'^=', |
|
||||
'compl':'~', |
|
||||
} |
|
||||
"these ops are for c++, to reset, set an empty dict" |
|
||||
|
|
||||
# ignore #warning and #error |
|
||||
re_lines = re.compile(\ |
|
||||
'^[ \t]*(#|%:)[ \t]*(ifdef|ifndef|if|else|elif|endif|include|import|define|undef|pragma)[ \t]*(.*)\r*$', |
|
||||
re.IGNORECASE | re.MULTILINE) |
|
||||
|
|
||||
re_mac = re.compile("^[a-zA-Z_]\w*") |
|
||||
re_fun = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*[(]') |
|
||||
re_pragma_once = re.compile('^\s*once\s*', re.IGNORECASE) |
|
||||
re_nl = re.compile('\\\\\r*\n', re.MULTILINE) |
|
||||
re_cpp = re.compile(\ |
|
||||
r"""(/\*[^*]*\*+([^/*][^*]*\*+)*/)|//[^\n]*|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)""", |
|
||||
re.MULTILINE) |
|
||||
trig_def = [('??'+a, b) for a, b in zip("=-/!'()<>", r'#~\|^[]{}')] |
|
||||
chr_esc = {'0':0, 'a':7, 'b':8, 't':9, 'n':10, 'f':11, 'v':12, 'r':13, '\\':92, "'":39} |
|
||||
|
|
||||
NUM = 'i' |
|
||||
OP = 'O' |
|
||||
IDENT = 'T' |
|
||||
STR = 's' |
|
||||
CHAR = 'c' |
|
||||
|
|
||||
tok_types = [NUM, STR, IDENT, OP] |
|
||||
exp_types = [ |
|
||||
r"""0[xX](?P<hex>[a-fA-F0-9]+)(?P<qual1>[uUlL]*)|L*?'(?P<char>(\\.|[^\\'])+)'|(?P<n1>\d+)[Ee](?P<exp0>[+-]*?\d+)(?P<float0>[fFlL]*)|(?P<n2>\d*\.\d+)([Ee](?P<exp1>[+-]*?\d+))?(?P<float1>[fFlL]*)|(?P<n4>\d+\.\d*)([Ee](?P<exp2>[+-]*?\d+))?(?P<float2>[fFlL]*)|(?P<oct>0*)(?P<n0>\d+)(?P<qual2>[uUlL]*)""", |
|
||||
r'L?"([^"\\]|\\.)*"', |
|
||||
r'[a-zA-Z_]\w*', |
|
||||
r'%:%:|<<=|>>=|\.\.\.|<<|<%|<:|<=|>>|>=|\+\+|\+=|--|->|-=|\*=|/=|%:|%=|%>|==|&&|&=|\|\||\|=|\^=|:>|!=|##|[\(\)\{\}\[\]<>\?\|\^\*\+&=:!#;,%/\-\?\~\.]', |
|
||||
] |
|
||||
re_clexer = re.compile('|'.join(["(?P<%s>%s)" % (name, part) for name, part in zip(tok_types, exp_types)]), re.M) |
|
||||
|
|
||||
accepted = 'a' |
|
||||
ignored = 'i' |
|
||||
undefined = 'u' |
|
||||
skipped = 's' |
|
||||
|
|
||||
def repl(m): |
|
||||
s = m.group(1) |
|
||||
if s is not None: return ' ' |
|
||||
s = m.group(3) |
|
||||
if s is None: return '' |
|
||||
return s |
|
||||
|
|
||||
def filter_comments(filename): |
|
||||
# return a list of tuples : keyword, line |
|
||||
code = Utils.readf(filename) |
|
||||
if use_trigraphs: |
|
||||
for (a, b) in trig_def: code = code.split(a).join(b) |
|
||||
code = re_nl.sub('', code) |
|
||||
code = re_cpp.sub(repl, code) |
|
||||
return [(m.group(2), m.group(3)) for m in re.finditer(re_lines, code)] |
|
||||
|
|
||||
prec = {} |
|
||||
# op -> number, needed for such expressions: #if 1 && 2 != 0 |
|
||||
ops = ['* / %', '+ -', '<< >>', '< <= >= >', '== !=', '& | ^', '&& ||', ','] |
|
||||
for x in range(len(ops)): |
|
||||
syms = ops[x] |
|
||||
for u in syms.split(): |
|
||||
prec[u] = x |
|
||||
|
|
||||
def reduce_nums(val_1, val_2, val_op): |
|
||||
"""apply arithmetic rules and try to return an integer result""" |
|
||||
#print val_1, val_2, val_op |
|
||||
|
|
||||
# now perform the operation, make certain a and b are numeric |
|
||||
try: a = 0 + val_1 |
|
||||
except TypeError: a = int(val_1) |
|
||||
try: b = 0 + val_2 |
|
||||
except TypeError: b = int(val_2) |
|
||||
|
|
||||
d = val_op |
|
||||
if d == '%': c = a%b |
|
||||
elif d=='+': c = a+b |
|
||||
elif d=='-': c = a-b |
|
||||
elif d=='*': c = a*b |
|
||||
elif d=='/': c = a/b |
|
||||
elif d=='^': c = a^b |
|
||||
elif d=='|': c = a|b |
|
||||
elif d=='||': c = int(a or b) |
|
||||
elif d=='&': c = a&b |
|
||||
elif d=='&&': c = int(a and b) |
|
||||
elif d=='==': c = int(a == b) |
|
||||
elif d=='!=': c = int(a != b) |
|
||||
elif d=='<=': c = int(a <= b) |
|
||||
elif d=='<': c = int(a < b) |
|
||||
elif d=='>': c = int(a > b) |
|
||||
elif d=='>=': c = int(a >= b) |
|
||||
elif d=='^': c = int(a^b) |
|
||||
elif d=='<<': c = a<<b |
|
||||
elif d=='>>': c = a>>b |
|
||||
else: c = 0 |
|
||||
return c |
|
||||
|
|
||||
def get_num(lst): |
|
||||
if not lst: raise PreprocError("empty list for get_num") |
|
||||
(p, v) = lst[0] |
|
||||
if p == OP: |
|
||||
if v == '(': |
|
||||
count_par = 1 |
|
||||
i = 1 |
|
||||
while i < len(lst): |
|
||||
(p, v) = lst[i] |
|
||||
|
|
||||
if p == OP: |
|
||||
if v == ')': |
|
||||
count_par -= 1 |
|
||||
if count_par == 0: |
|
||||
break |
|
||||
elif v == '(': |
|
||||
count_par += 1 |
|
||||
i += 1 |
|
||||
else: |
|
||||
raise PreprocError("rparen expected %r" % lst) |
|
||||
|
|
||||
(num, _) = get_term(lst[1:i]) |
|
||||
return (num, lst[i+1:]) |
|
||||
|
|
||||
elif v == '+': |
|
||||
return get_num(lst[1:]) |
|
||||
elif v == '-': |
|
||||
num, lst = get_num(lst[1:]) |
|
||||
return (reduce_nums('-1', num, '*'), lst) |
|
||||
elif v == '!': |
|
||||
num, lst = get_num(lst[1:]) |
|
||||
return (int(not int(num)), lst) |
|
||||
elif v == '~': |
|
||||
return (~ int(num), lst) |
|
||||
else: |
|
||||
raise PreprocError("invalid op token %r for get_num" % lst) |
|
||||
elif p == NUM: |
|
||||
return v, lst[1:] |
|
||||
elif p == IDENT: |
|
||||
# all macros should have been replaced, remaining identifiers eval to 0 |
|
||||
return 0, lst[1:] |
|
||||
else: |
|
||||
raise PreprocError("invalid token %r for get_num" % lst) |
|
||||
|
|
||||
def get_term(lst): |
|
||||
if not lst: raise PreprocError("empty list for get_term") |
|
||||
num, lst = get_num(lst) |
|
||||
if not lst: |
|
||||
return (num, []) |
|
||||
(p, v) = lst[0] |
|
||||
if p == OP: |
|
||||
if v == '&&' and not num: |
|
||||
return (num, []) |
|
||||
elif v == '||' and num: |
|
||||
return (num, []) |
|
||||
elif v == ',': |
|
||||
# skip |
|
||||
return get_term(lst[1:]) |
|
||||
elif v == '?': |
|
||||
count_par = 0 |
|
||||
i = 1 |
|
||||
while i < len(lst): |
|
||||
(p, v) = lst[i] |
|
||||
|
|
||||
if p == OP: |
|
||||
if v == ')': |
|
||||
count_par -= 1 |
|
||||
elif v == '(': |
|
||||
count_par += 1 |
|
||||
elif v == ':': |
|
||||
if count_par == 0: |
|
||||
break |
|
||||
i += 1 |
|
||||
else: |
|
||||
raise PreprocError("rparen expected %r" % lst) |
|
||||
|
|
||||
if int(num): |
|
||||
return get_term(lst[1:i]) |
|
||||
else: |
|
||||
return get_term(lst[i+1:]) |
|
||||
|
|
||||
else: |
|
||||
num2, lst = get_num(lst[1:]) |
|
||||
|
|
||||
if not lst: |
|
||||
# no more tokens to process |
|
||||
num2 = reduce_nums(num, num2, v) |
|
||||
return get_term([(NUM, num2)] + lst) |
|
||||
|
|
||||
# operator precedence |
|
||||
p2, v2 = lst[0] |
|
||||
if p2 != OP: |
|
||||
raise PreprocError("op expected %r" % lst) |
|
||||
|
|
||||
if prec[v2] >= prec[v]: |
|
||||
num2 = reduce_nums(num, num2, v) |
|
||||
return get_term([(NUM, num2)] + lst) |
|
||||
else: |
|
||||
num3, lst = get_num(lst[1:]) |
|
||||
num3 = reduce_nums(num2, num3, v2) |
|
||||
return get_term([(NUM, num), (p, v), (NUM, num3)] + lst) |
|
||||
|
|
||||
|
|
||||
raise PreprocError("cannot reduce %r" % lst) |
|
||||
|
|
||||
def reduce_eval(lst): |
|
||||
"""take a list of tokens and output true or false (#if/#elif conditions)""" |
|
||||
num, lst = get_term(lst) |
|
||||
return (NUM, num) |
|
||||
|
|
||||
def stringize(lst): |
|
||||
"""use for converting a list of tokens to a string""" |
|
||||
lst = [str(v2) for (p2, v2) in lst] |
|
||||
return "".join(lst) |
|
||||
|
|
||||
def paste_tokens(t1, t2): |
|
||||
""" |
|
||||
here is what we can paste: |
|
||||
a ## b -> ab |
|
||||
> ## = -> >= |
|
||||
a ## 2 -> a2 |
|
||||
""" |
|
||||
p1 = None |
|
||||
if t1[0] == OP and t2[0] == OP: |
|
||||
p1 = OP |
|
||||
elif t1[0] == IDENT and (t2[0] == IDENT or t2[0] == NUM): |
|
||||
p1 = IDENT |
|
||||
elif t1[0] == NUM and t2[0] == NUM: |
|
||||
p1 = NUM |
|
||||
if not p1: |
|
||||
raise PreprocError('tokens do not make a valid paste %r and %r' % (t1, t2)) |
|
||||
return (p1, t1[1] + t2[1]) |
|
||||
|
|
||||
def reduce_tokens(lst, defs, ban=[]): |
|
||||
"""replace the tokens in lst, using the macros provided in defs, and a list of macros that cannot be re-applied""" |
|
||||
i = 0 |
|
||||
|
|
||||
while i < len(lst): |
|
||||
(p, v) = lst[i] |
|
||||
|
|
||||
if p == IDENT and v == "defined": |
|
||||
del lst[i] |
|
||||
if i < len(lst): |
|
||||
(p2, v2) = lst[i] |
|
||||
if p2 == IDENT: |
|
||||
if v2 in defs: |
|
||||
lst[i] = (NUM, 1) |
|
||||
else: |
|
||||
lst[i] = (NUM, 0) |
|
||||
elif p2 == OP and v2 == '(': |
|
||||
del lst[i] |
|
||||
(p2, v2) = lst[i] |
|
||||
del lst[i] # remove the ident, and change the ) for the value |
|
||||
if v2 in defs: |
|
||||
lst[i] = (NUM, 1) |
|
||||
else: |
|
||||
lst[i] = (NUM, 0) |
|
||||
else: |
|
||||
raise PreprocError("invalid define expression %r" % lst) |
|
||||
|
|
||||
elif p == IDENT and v in defs: |
|
||||
|
|
||||
if isinstance(defs[v], str): |
|
||||
a, b = extract_macro(defs[v]) |
|
||||
defs[v] = b |
|
||||
macro_def = defs[v] |
|
||||
to_add = macro_def[1] |
|
||||
|
|
||||
if isinstance(macro_def[0], list): |
|
||||
# macro without arguments |
|
||||
del lst[i] |
|
||||
for x in xrange(len(to_add)): |
|
||||
lst.insert(i, to_add[x]) |
|
||||
i += 1 |
|
||||
else: |
|
||||
# collect the arguments for the funcall |
|
||||
|
|
||||
args = [] |
|
||||
del lst[i] |
|
||||
|
|
||||
if i >= len(lst): |
|
||||
raise PreprocError("expected '(' after %r (got nothing)" % v) |
|
||||
|
|
||||
(p2, v2) = lst[i] |
|
||||
if p2 != OP or v2 != '(': |
|
||||
raise PreprocError("expected '(' after %r" % v) |
|
||||
|
|
||||
del lst[i] |
|
||||
|
|
||||
one_param = [] |
|
||||
count_paren = 0 |
|
||||
while i < len(lst): |
|
||||
p2, v2 = lst[i] |
|
||||
|
|
||||
del lst[i] |
|
||||
if p2 == OP and count_paren == 0: |
|
||||
if v2 == '(': |
|
||||
one_param.append((p2, v2)) |
|
||||
count_paren += 1 |
|
||||
elif v2 == ')': |
|
||||
if one_param: args.append(one_param) |
|
||||
break |
|
||||
elif v2 == ',': |
|
||||
if not one_param: raise PreprocError("empty param in funcall %s" % p) |
|
||||
args.append(one_param) |
|
||||
one_param = [] |
|
||||
else: |
|
||||
one_param.append((p2, v2)) |
|
||||
else: |
|
||||
one_param.append((p2, v2)) |
|
||||
if v2 == '(': count_paren += 1 |
|
||||
elif v2 == ')': count_paren -= 1 |
|
||||
else: |
|
||||
raise PreprocError('malformed macro') |
|
||||
|
|
||||
# substitute the arguments within the define expression |
|
||||
accu = [] |
|
||||
arg_table = macro_def[0] |
|
||||
j = 0 |
|
||||
while j < len(to_add): |
|
||||
(p2, v2) = to_add[j] |
|
||||
|
|
||||
if p2 == OP and v2 == '#': |
|
||||
# stringize is for arguments only |
|
||||
if j+1 < len(to_add) and to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table: |
|
||||
toks = args[arg_table[to_add[j+1][1]]] |
|
||||
accu.append((STR, stringize(toks))) |
|
||||
j += 1 |
|
||||
else: |
|
||||
accu.append((p2, v2)) |
|
||||
elif p2 == OP and v2 == '##': |
|
||||
# token pasting, how can man invent such a complicated system? |
|
||||
if accu and j+1 < len(to_add): |
|
||||
# we have at least two tokens |
|
||||
|
|
||||
t1 = accu[-1] |
|
||||
|
|
||||
if to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table: |
|
||||
toks = args[arg_table[to_add[j+1][1]]] |
|
||||
|
|
||||
if toks: |
|
||||
accu[-1] = paste_tokens(t1, toks[0]) #(IDENT, accu[-1][1] + toks[0][1]) |
|
||||
accu.extend(toks[1:]) |
|
||||
else: |
|
||||
# error, case "a##" |
|
||||
accu.append((p2, v2)) |
|
||||
accu.extend(toks) |
|
||||
elif to_add[j+1][0] == IDENT and to_add[j+1][1] == '__VA_ARGS__': |
|
||||
# TODO not sure |
|
||||
# first collect the tokens |
|
||||
va_toks = [] |
|
||||
st = len(macro_def[0]) |
|
||||
pt = len(args) |
|
||||
for x in args[pt-st+1:]: |
|
||||
va_toks.extend(x) |
|
||||
va_toks.append((OP, ',')) |
|
||||
if va_toks: va_toks.pop() # extra comma |
|
||||
if len(accu)>1: |
|
||||
(p3, v3) = accu[-1] |
|
||||
(p4, v4) = accu[-2] |
|
||||
if v3 == '##': |
|
||||
# remove the token paste |
|
||||
accu.pop() |
|
||||
if v4 == ',' and pt < st: |
|
||||
# remove the comma |
|
||||
accu.pop() |
|
||||
accu += va_toks |
|
||||
else: |
|
||||
accu[-1] = paste_tokens(t1, to_add[j+1]) |
|
||||
|
|
||||
j += 1 |
|
||||
else: |
|
||||
# invalid paste, case "##a" or "b##" |
|
||||
accu.append((p2, v2)) |
|
||||
|
|
||||
elif p2 == IDENT and v2 in arg_table: |
|
||||
toks = args[arg_table[v2]] |
|
||||
reduce_tokens(toks, defs, ban+[v]) |
|
||||
accu.extend(toks) |
|
||||
else: |
|
||||
accu.append((p2, v2)) |
|
||||
|
|
||||
j += 1 |
|
||||
|
|
||||
|
|
||||
reduce_tokens(accu, defs, ban+[v]) |
|
||||
|
|
||||
for x in xrange(len(accu)-1, -1, -1): |
|
||||
lst.insert(i, accu[x]) |
|
||||
|
|
||||
i += 1 |
|
||||
|
|
||||
|
|
||||
def eval_macro(lst, adefs): |
|
||||
"""reduce the tokens from the list lst, and try to return a 0/1 result""" |
|
||||
reduce_tokens(lst, adefs, []) |
|
||||
if not lst: raise PreprocError("missing tokens to evaluate") |
|
||||
(p, v) = reduce_eval(lst) |
|
||||
return int(v) != 0 |
|
||||
|
|
||||
def extract_macro(txt): |
|
||||
"""process a macro definition from "#define f(x, y) x * y" into a function or a simple macro without arguments""" |
|
||||
t = tokenize(txt) |
|
||||
if re_fun.search(txt): |
|
||||
p, name = t[0] |
|
||||
|
|
||||
p, v = t[1] |
|
||||
if p != OP: raise PreprocError("expected open parenthesis") |
|
||||
|
|
||||
i = 1 |
|
||||
pindex = 0 |
|
||||
params = {} |
|
||||
prev = '(' |
|
||||
|
|
||||
while 1: |
|
||||
i += 1 |
|
||||
p, v = t[i] |
|
||||
|
|
||||
if prev == '(': |
|
||||
if p == IDENT: |
|
||||
params[v] = pindex |
|
||||
pindex += 1 |
|
||||
prev = p |
|
||||
elif p == OP and v == ')': |
|
||||
break |
|
||||
else: |
|
||||
raise PreprocError("unexpected token (3)") |
|
||||
elif prev == IDENT: |
|
||||
if p == OP and v == ',': |
|
||||
prev = v |
|
||||
elif p == OP and v == ')': |
|
||||
break |
|
||||
else: |
|
||||
raise PreprocError("comma or ... expected") |
|
||||
elif prev == ',': |
|
||||
if p == IDENT: |
|
||||
params[v] = pindex |
|
||||
pindex += 1 |
|
||||
prev = p |
|
||||
elif p == OP and v == '...': |
|
||||
raise PreprocError("not implemented (1)") |
|
||||
else: |
|
||||
raise PreprocError("comma or ... expected (2)") |
|
||||
elif prev == '...': |
|
||||
raise PreprocError("not implemented (2)") |
|
||||
else: |
|
||||
raise PreprocError("unexpected else") |
|
||||
|
|
||||
#~ print (name, [params, t[i+1:]]) |
|
||||
return (name, [params, t[i+1:]]) |
|
||||
else: |
|
||||
(p, v) = t[0] |
|
||||
return (v, [[], t[1:]]) |
|
||||
|
|
||||
re_include = re.compile('^\s*(<(?P<a>.*)>|"(?P<b>.*)")') |
|
||||
def extract_include(txt, defs): |
|
||||
"""process a line in the form "#include foo" to return a string representing the file""" |
|
||||
m = re_include.search(txt) |
|
||||
if m: |
|
||||
if m.group('a'): return '<', m.group('a') |
|
||||
if m.group('b'): return '"', m.group('b') |
|
||||
|
|
||||
# perform preprocessing and look at the result, it must match an include |
|
||||
toks = tokenize(txt) |
|
||||
reduce_tokens(toks, defs, ['waf_include']) |
|
||||
|
|
||||
if not toks: |
|
||||
raise PreprocError("could not parse include %s" % txt) |
|
||||
|
|
||||
if len(toks) == 1: |
|
||||
if toks[0][0] == STR: |
|
||||
return '"', toks[0][1] |
|
||||
else: |
|
||||
if toks[0][1] == '<' and toks[-1][1] == '>': |
|
||||
return stringize(toks).lstrip('<').rstrip('>') |
|
||||
|
|
||||
raise PreprocError("could not parse include %s." % txt) |
|
||||
|
|
||||
def parse_char(txt): |
|
||||
if not txt: raise PreprocError("attempted to parse a null char") |
|
||||
if txt[0] != '\\': |
|
||||
return ord(txt) |
|
||||
c = txt[1] |
|
||||
if c == 'x': |
|
||||
if len(txt) == 4 and txt[3] in string.hexdigits: return int(txt[2:], 16) |
|
||||
return int(txt[2:], 16) |
|
||||
elif c.isdigit(): |
|
||||
if c == '0' and len(txt)==2: return 0 |
|
||||
for i in 3, 2, 1: |
|
||||
if len(txt) > i and txt[1:1+i].isdigit(): |
|
||||
return (1+i, int(txt[1:1+i], 8)) |
|
||||
else: |
|
||||
try: return chr_esc[c] |
|
||||
except KeyError: raise PreprocError("could not parse char literal '%s'" % txt) |
|
||||
|
|
||||
def tokenize(s): |
|
||||
"""convert a string into a list of tokens (shlex.split does not apply to c/c++/d)""" |
|
||||
ret = [] |
|
||||
for match in re_clexer.finditer(s): |
|
||||
m = match.group |
|
||||
for name in tok_types: |
|
||||
v = m(name) |
|
||||
if v: |
|
||||
if name == IDENT: |
|
||||
try: v = g_optrans[v]; name = OP |
|
||||
except KeyError: |
|
||||
# c++ specific |
|
||||
if v.lower() == "true": |
|
||||
v = 1 |
|
||||
name = NUM |
|
||||
elif v.lower() == "false": |
|
||||
v = 0 |
|
||||
name = NUM |
|
||||
elif name == NUM: |
|
||||
if m('oct'): v = int(v, 8) |
|
||||
elif m('hex'): v = int(m('hex'), 16) |
|
||||
elif m('n0'): v = m('n0') |
|
||||
else: |
|
||||
v = m('char') |
|
||||
if v: v = parse_char(v) |
|
||||
else: v = m('n2') or m('n4') |
|
||||
elif name == OP: |
|
||||
if v == '%:': v = '#' |
|
||||
elif v == '%:%:': v = '##' |
|
||||
elif name == STR: |
|
||||
# remove the quotes around the string |
|
||||
v = v[1:-1] |
|
||||
ret.append((name, v)) |
|
||||
break |
|
||||
return ret |
|
||||
|
|
||||
class c_parser(object): |
|
||||
def __init__(self, nodepaths=None, defines=None): |
|
||||
#self.lines = txt.split('\n') |
|
||||
self.lines = [] |
|
||||
|
|
||||
if defines is None: |
|
||||
self.defs = {} |
|
||||
else: |
|
||||
self.defs = dict(defines) # make a copy |
|
||||
self.state = [] |
|
||||
|
|
||||
self.env = None # needed for the variant when searching for files |
|
||||
|
|
||||
self.count_files = 0 |
|
||||
self.currentnode_stack = [] |
|
||||
|
|
||||
self.nodepaths = nodepaths or [] |
|
||||
|
|
||||
self.nodes = [] |
|
||||
self.names = [] |
|
||||
|
|
||||
# file added |
|
||||
self.curfile = '' |
|
||||
self.ban_includes = [] |
|
||||
|
|
||||
def tryfind(self, filename): |
|
||||
self.curfile = filename |
|
||||
|
|
||||
# for msvc it should be a for loop on the whole stack |
|
||||
found = self.currentnode_stack[-1].find_resource(filename) |
|
||||
|
|
||||
for n in self.nodepaths: |
|
||||
if found: |
|
||||
break |
|
||||
found = n.find_resource(filename) |
|
||||
|
|
||||
if not found: |
|
||||
if not filename in self.names: |
|
||||
self.names.append(filename) |
|
||||
else: |
|
||||
self.nodes.append(found) |
|
||||
if filename[-4:] != '.moc': |
|
||||
self.addlines(found) |
|
||||
return found |
|
||||
|
|
||||
def addlines(self, node): |
|
||||
|
|
||||
self.currentnode_stack.append(node.parent) |
|
||||
filepath = node.abspath(self.env) |
|
||||
|
|
||||
self.count_files += 1 |
|
||||
if self.count_files > recursion_limit: raise PreprocError("recursion limit exceeded") |
|
||||
pc = self.parse_cache |
|
||||
debug('preproc: reading file %r', filepath) |
|
||||
try: |
|
||||
lns = pc[filepath] |
|
||||
except KeyError: |
|
||||
pass |
|
||||
else: |
|
||||
self.lines = lns + self.lines |
|
||||
return |
|
||||
|
|
||||
try: |
|
||||
lines = filter_comments(filepath) |
|
||||
lines.append((POPFILE, '')) |
|
||||
pc[filepath] = lines # cache the lines filtered |
|
||||
self.lines = lines + self.lines |
|
||||
except IOError: |
|
||||
raise PreprocError("could not read the file %s" % filepath) |
|
||||
except Exception: |
|
||||
if Logs.verbose > 0: |
|
||||
error("parsing %s failed" % filepath) |
|
||||
traceback.print_exc() |
|
||||
|
|
||||
def start(self, node, env): |
|
||||
debug('preproc: scanning %s (in %s)', node.name, node.parent.name) |
|
||||
|
|
||||
self.env = env |
|
||||
variant = node.variant(env) |
|
||||
bld = node.__class__.bld |
|
||||
try: |
|
||||
self.parse_cache = bld.parse_cache |
|
||||
except AttributeError: |
|
||||
bld.parse_cache = {} |
|
||||
self.parse_cache = bld.parse_cache |
|
||||
|
|
||||
self.addlines(node) |
|
||||
if env['DEFLINES']: |
|
||||
self.lines = [('define', x) for x in env['DEFLINES']] + self.lines |
|
||||
|
|
||||
while self.lines: |
|
||||
(kind, line) = self.lines.pop(0) |
|
||||
if kind == POPFILE: |
|
||||
self.currentnode_stack.pop() |
|
||||
continue |
|
||||
try: |
|
||||
self.process_line(kind, line) |
|
||||
except Exception, e: |
|
||||
if Logs.verbose: |
|
||||
debug('preproc: line parsing failed (%s): %s %s', e, line, Utils.ex_stack()) |
|
||||
|
|
||||
def process_line(self, token, line): |
|
||||
ve = Logs.verbose |
|
||||
if ve: debug('preproc: line is %s - %s state is %s', token, line, self.state) |
|
||||
state = self.state |
|
||||
|
|
||||
# make certain we define the state if we are about to enter in an if block |
|
||||
if token in ['ifdef', 'ifndef', 'if']: |
|
||||
state.append(undefined) |
|
||||
elif token == 'endif': |
|
||||
state.pop() |
|
||||
|
|
||||
# skip lines when in a dead 'if' branch, wait for the endif |
|
||||
if not token in ['else', 'elif', 'endif']: |
|
||||
if skipped in self.state or ignored in self.state: |
|
||||
return |
|
||||
|
|
||||
if token == 'if': |
|
||||
ret = eval_macro(tokenize(line), self.defs) |
|
||||
if ret: state[-1] = accepted |
|
||||
else: state[-1] = ignored |
|
||||
elif token == 'ifdef': |
|
||||
m = re_mac.search(line) |
|
||||
if m and m.group(0) in self.defs: state[-1] = accepted |
|
||||
else: state[-1] = ignored |
|
||||
elif token == 'ifndef': |
|
||||
m = re_mac.search(line) |
|
||||
if m and m.group(0) in self.defs: state[-1] = ignored |
|
||||
else: state[-1] = accepted |
|
||||
elif token == 'include' or token == 'import': |
|
||||
(kind, inc) = extract_include(line, self.defs) |
|
||||
if inc in self.ban_includes: return |
|
||||
if token == 'import': self.ban_includes.append(inc) |
|
||||
if ve: debug('preproc: include found %s (%s) ', inc, kind) |
|
||||
if kind == '"' or not strict_quotes: |
|
||||
self.tryfind(inc) |
|
||||
elif token == 'elif': |
|
||||
if state[-1] == accepted: |
|
||||
state[-1] = skipped |
|
||||
elif state[-1] == ignored: |
|
||||
if eval_macro(tokenize(line), self.defs): |
|
||||
state[-1] = accepted |
|
||||
elif token == 'else': |
|
||||
if state[-1] == accepted: state[-1] = skipped |
|
||||
elif state[-1] == ignored: state[-1] = accepted |
|
||||
elif token == 'define': |
|
||||
m = re_mac.search(line) |
|
||||
if m: |
|
||||
name = m.group(0) |
|
||||
if ve: debug('preproc: define %s %s', name, line) |
|
||||
self.defs[name] = line |
|
||||
else: |
|
||||
raise PreprocError("invalid define line %s" % line) |
|
||||
elif token == 'undef': |
|
||||
m = re_mac.search(line) |
|
||||
if m and m.group(0) in self.defs: |
|
||||
self.defs.__delitem__(m.group(0)) |
|
||||
#print "undef %s" % name |
|
||||
elif token == 'pragma': |
|
||||
if re_pragma_once.search(line.lower()): |
|
||||
self.ban_includes.append(self.curfile) |
|
||||
|
|
||||
def get_deps(node, env, nodepaths=[]): |
|
||||
""" |
|
||||
Get the dependencies using a c/c++ preprocessor, this is required for finding dependencies of the kind |
|
||||
#include some_macro() |
|
||||
""" |
|
||||
|
|
||||
gruik = c_parser(nodepaths) |
|
||||
gruik.start(node, env) |
|
||||
return (gruik.nodes, gruik.names) |
|
||||
|
|
||||
#################### dumb dependency scanner |
|
||||
|
|
||||
re_inc = re.compile(\ |
|
||||
'^[ \t]*(#|%:)[ \t]*(include)[ \t]*(.*)\r*$', |
|
||||
re.IGNORECASE | re.MULTILINE) |
|
||||
|
|
||||
def lines_includes(filename): |
|
||||
code = Utils.readf(filename) |
|
||||
if use_trigraphs: |
|
||||
for (a, b) in trig_def: code = code.split(a).join(b) |
|
||||
code = re_nl.sub('', code) |
|
||||
code = re_cpp.sub(repl, code) |
|
||||
return [(m.group(2), m.group(3)) for m in re.finditer(re_inc, code)] |
|
||||
|
|
||||
def get_deps_simple(node, env, nodepaths=[], defines={}): |
|
||||
""" |
|
||||
Get the dependencies by just looking recursively at the #include statements |
|
||||
""" |
|
||||
|
|
||||
nodes = [] |
|
||||
names = [] |
|
||||
|
|
||||
def find_deps(node): |
|
||||
lst = lines_includes(node.abspath(env)) |
|
||||
|
|
||||
for (_, line) in lst: |
|
||||
(t, filename) = extract_include(line, defines) |
|
||||
if filename in names: |
|
||||
continue |
|
||||
|
|
||||
if filename.endswith('.moc'): |
|
||||
names.append(filename) |
|
||||
|
|
||||
found = None |
|
||||
for n in nodepaths: |
|
||||
if found: |
|
||||
break |
|
||||
found = n.find_resource(filename) |
|
||||
|
|
||||
if not found: |
|
||||
if not filename in names: |
|
||||
names.append(filename) |
|
||||
elif not found in nodes: |
|
||||
nodes.append(found) |
|
||||
find_deps(node) |
|
||||
|
|
||||
find_deps(node) |
|
||||
return (nodes, names) |
|
||||
|
|
||||
|
|
||||
@ -1,401 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2007 (ita) |
|
||||
# Gustavo Carneiro (gjc), 2007 |
|
||||
|
|
||||
"Python support" |
|
||||
|
|
||||
import os, sys |
|
||||
import TaskGen, Utils, Utils, Runner, Options, Build |
|
||||
from Logs import debug, warn, info |
|
||||
from TaskGen import extension, taskgen, before, after, feature |
|
||||
from Configure import conf |
|
||||
|
|
||||
EXT_PY = ['.py'] |
|
||||
FRAG_2 = ''' |
|
||||
#ifdef __cplusplus |
|
||||
extern "C" { |
|
||||
#endif |
|
||||
void Py_Initialize(void); |
|
||||
void Py_Finalize(void); |
|
||||
#ifdef __cplusplus |
|
||||
} |
|
||||
#endif |
|
||||
int main() |
|
||||
{ |
|
||||
Py_Initialize(); |
|
||||
Py_Finalize(); |
|
||||
return 0; |
|
||||
} |
|
||||
''' |
|
||||
|
|
||||
@before('apply_incpaths', 'apply_lib_vars', 'apply_type_vars') |
|
||||
@feature('pyext') |
|
||||
@before('apply_bundle') |
|
||||
def init_pyext(self): |
|
||||
self.default_install_path = '${PYTHONDIR}' |
|
||||
self.uselib = self.to_list(getattr(self, 'uselib', '')) |
|
||||
if not 'PYEXT' in self.uselib: |
|
||||
self.uselib.append('PYEXT') |
|
||||
self.env['MACBUNDLE'] = True |
|
||||
|
|
||||
@before('apply_link', 'apply_lib_vars', 'apply_type_vars') |
|
||||
@after('apply_bundle') |
|
||||
@feature('pyext') |
|
||||
def pyext_shlib_ext(self): |
|
||||
# override shlib_PATTERN set by the osx module |
|
||||
self.env['shlib_PATTERN'] = self.env['pyext_PATTERN'] |
|
||||
|
|
||||
@before('apply_incpaths', 'apply_lib_vars', 'apply_type_vars') |
|
||||
@feature('pyembed') |
|
||||
def init_pyembed(self): |
|
||||
self.uselib = self.to_list(getattr(self, 'uselib', '')) |
|
||||
if not 'PYEMBED' in self.uselib: |
|
||||
self.uselib.append('PYEMBED') |
|
||||
|
|
||||
@extension(EXT_PY) |
|
||||
def process_py(self, node): |
|
||||
if not (self.bld.is_install and self.install_path): |
|
||||
return |
|
||||
def inst_py(ctx): |
|
||||
install_pyfile(self, node) |
|
||||
self.bld.add_post_fun(inst_py) |
|
||||
|
|
||||
def install_pyfile(self, node): |
|
||||
path = self.bld.get_install_path(self.install_path + os.sep + node.name, self.env) |
|
||||
|
|
||||
self.bld.install_files(self.install_path, [node], self.env, self.chmod, postpone=False) |
|
||||
if self.bld.is_install < 0: |
|
||||
info("* removing byte compiled python files") |
|
||||
for x in 'co': |
|
||||
try: |
|
||||
os.remove(path + x) |
|
||||
except OSError: |
|
||||
pass |
|
||||
|
|
||||
if self.bld.is_install > 0: |
|
||||
if self.env['PYC'] or self.env['PYO']: |
|
||||
info("* byte compiling %r" % path) |
|
||||
|
|
||||
if self.env['PYC']: |
|
||||
program = (""" |
|
||||
import sys, py_compile |
|
||||
for pyfile in sys.argv[1:]: |
|
||||
py_compile.compile(pyfile, pyfile + 'c') |
|
||||
""") |
|
||||
argv = [self.env['PYTHON'], '-c', program, path] |
|
||||
ret = Utils.pproc.Popen(argv).wait() |
|
||||
if ret: |
|
||||
raise Utils.WafError('bytecode compilation failed %r' % path) |
|
||||
|
|
||||
if self.env['PYO']: |
|
||||
program = (""" |
|
||||
import sys, py_compile |
|
||||
for pyfile in sys.argv[1:]: |
|
||||
py_compile.compile(pyfile, pyfile + 'o') |
|
||||
""") |
|
||||
argv = [self.env['PYTHON'], self.env['PYFLAGS_OPT'], '-c', program, path] |
|
||||
ret = Utils.pproc.Popen(argv).wait() |
|
||||
if ret: |
|
||||
raise Utils.WafError('bytecode compilation failed %r' % path) |
|
||||
|
|
||||
# COMPAT |
|
||||
class py_taskgen(TaskGen.task_gen): |
|
||||
def __init__(self, *k, **kw): |
|
||||
TaskGen.task_gen.__init__(self, *k, **kw) |
|
||||
|
|
||||
@before('apply_core') |
|
||||
@after('vars_target_cprogram', 'vars_target_cstaticlib') |
|
||||
@feature('py') |
|
||||
def init_py(self): |
|
||||
self.default_install_path = '${PYTHONDIR}' |
|
||||
|
|
||||
def _get_python_variables(python_exe, variables, imports=['import sys']): |
|
||||
"""Run a python interpreter and print some variables""" |
|
||||
program = list(imports) |
|
||||
program.append('') |
|
||||
for v in variables: |
|
||||
program.append("print(repr(%s))" % v) |
|
||||
os_env = dict(os.environ) |
|
||||
try: |
|
||||
del os_env['MACOSX_DEPLOYMENT_TARGET'] # see comments in the OSX tool |
|
||||
except KeyError: |
|
||||
pass |
|
||||
proc = Utils.pproc.Popen([python_exe, "-c", '\n'.join(program)], stdout=Utils.pproc.PIPE, env=os_env) |
|
||||
output = proc.communicate()[0].split("\n") # do not touch, python3 |
|
||||
if proc.returncode: |
|
||||
if Options.options.verbose: |
|
||||
warn("Python program to extract python configuration variables failed:\n%s" |
|
||||
% '\n'.join(["line %03i: %s" % (lineno+1, line) for lineno, line in enumerate(program)])) |
|
||||
raise RuntimeError |
|
||||
return_values = [] |
|
||||
for s in output: |
|
||||
s = s.strip() |
|
||||
if not s: |
|
||||
continue |
|
||||
if s == 'None': |
|
||||
return_values.append(None) |
|
||||
elif s[0] == "'" and s[-1] == "'": |
|
||||
return_values.append(s[1:-1]) |
|
||||
elif s[0].isdigit(): |
|
||||
return_values.append(int(s)) |
|
||||
else: break |
|
||||
return return_values |
|
||||
|
|
||||
@conf |
|
||||
def check_python_headers(conf): |
|
||||
"""Check for headers and libraries necessary to extend or embed python. |
|
||||
|
|
||||
On success the environment variables xxx_PYEXT and xxx_PYEMBED are added for uselib |
|
||||
|
|
||||
PYEXT: for compiling python extensions |
|
||||
PYEMBED: for embedding a python interpreter""" |
|
||||
|
|
||||
if not conf.env['CC_NAME'] and not conf.env['CXX_NAME']: |
|
||||
conf.fatal('load a compiler first (gcc, g++, ..)') |
|
||||
|
|
||||
if not conf.env['PYTHON_VERSION']: |
|
||||
conf.check_python_version() |
|
||||
|
|
||||
env = conf.env |
|
||||
python = env['PYTHON'] |
|
||||
if not python: |
|
||||
conf.fatal('could not find the python executable') |
|
||||
|
|
||||
## On Mac OSX we need to use mac bundles for python plugins |
|
||||
if Options.platform == 'darwin': |
|
||||
conf.check_tool('osx') |
|
||||
|
|
||||
try: |
|
||||
# Get some python configuration variables using distutils |
|
||||
v = 'prefix SO SYSLIBS LDFLAGS SHLIBS LIBDIR LIBPL INCLUDEPY Py_ENABLE_SHARED MACOSX_DEPLOYMENT_TARGET'.split() |
|
||||
(python_prefix, python_SO, python_SYSLIBS, python_LDFLAGS, python_SHLIBS, |
|
||||
python_LIBDIR, python_LIBPL, INCLUDEPY, Py_ENABLE_SHARED, |
|
||||
python_MACOSX_DEPLOYMENT_TARGET) = \ |
|
||||
_get_python_variables(python, ["get_config_var('%s')" % x for x in v], |
|
||||
['from distutils.sysconfig import get_config_var']) |
|
||||
except RuntimeError: |
|
||||
conf.fatal("Python development headers not found (-v for details).") |
|
||||
|
|
||||
conf.log.write("""Configuration returned from %r: |
|
||||
python_prefix = %r |
|
||||
python_SO = %r |
|
||||
python_SYSLIBS = %r |
|
||||
python_LDFLAGS = %r |
|
||||
python_SHLIBS = %r |
|
||||
python_LIBDIR = %r |
|
||||
python_LIBPL = %r |
|
||||
INCLUDEPY = %r |
|
||||
Py_ENABLE_SHARED = %r |
|
||||
MACOSX_DEPLOYMENT_TARGET = %r |
|
||||
""" % (python, python_prefix, python_SO, python_SYSLIBS, python_LDFLAGS, python_SHLIBS, |
|
||||
python_LIBDIR, python_LIBPL, INCLUDEPY, Py_ENABLE_SHARED, python_MACOSX_DEPLOYMENT_TARGET)) |
|
||||
|
|
||||
if python_MACOSX_DEPLOYMENT_TARGET: |
|
||||
conf.env['MACOSX_DEPLOYMENT_TARGET'] = python_MACOSX_DEPLOYMENT_TARGET |
|
||||
conf.environ['MACOSX_DEPLOYMENT_TARGET'] = python_MACOSX_DEPLOYMENT_TARGET |
|
||||
|
|
||||
env['pyext_PATTERN'] = '%s'+python_SO |
|
||||
|
|
||||
# Check for python libraries for embedding |
|
||||
if python_SYSLIBS is not None: |
|
||||
for lib in python_SYSLIBS.split(): |
|
||||
if lib.startswith('-l'): |
|
||||
lib = lib[2:] # strip '-l' |
|
||||
env.append_value('LIB_PYEMBED', lib) |
|
||||
|
|
||||
if python_SHLIBS is not None: |
|
||||
for lib in python_SHLIBS.split(): |
|
||||
if lib.startswith('-l'): |
|
||||
env.append_value('LIB_PYEMBED', lib[2:]) # strip '-l' |
|
||||
else: |
|
||||
env.append_value('LINKFLAGS_PYEMBED', lib) |
|
||||
|
|
||||
if Options.platform != 'darwin' and python_LDFLAGS: |
|
||||
env.append_value('LINKFLAGS_PYEMBED', python_LDFLAGS.split()) |
|
||||
|
|
||||
result = False |
|
||||
name = 'python' + env['PYTHON_VERSION'] |
|
||||
|
|
||||
if python_LIBDIR is not None: |
|
||||
path = [python_LIBDIR] |
|
||||
conf.log.write("\n\n# Trying LIBDIR: %r\n" % path) |
|
||||
result = conf.check(lib=name, uselib='PYEMBED', libpath=path) |
|
||||
|
|
||||
if not result and python_LIBPL is not None: |
|
||||
conf.log.write("\n\n# try again with -L$python_LIBPL (some systems don't install the python library in $prefix/lib)\n") |
|
||||
path = [python_LIBPL] |
|
||||
result = conf.check(lib=name, uselib='PYEMBED', libpath=path) |
|
||||
|
|
||||
if not result: |
|
||||
conf.log.write("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n") |
|
||||
path = [os.path.join(python_prefix, "libs")] |
|
||||
name = 'python' + env['PYTHON_VERSION'].replace('.', '') |
|
||||
result = conf.check(lib=name, uselib='PYEMBED', libpath=path) |
|
||||
|
|
||||
if result: |
|
||||
env['LIBPATH_PYEMBED'] = path |
|
||||
env.append_value('LIB_PYEMBED', name) |
|
||||
else: |
|
||||
conf.log.write("\n\n### LIB NOT FOUND\n") |
|
||||
|
|
||||
# under certain conditions, python extensions must link to |
|
||||
# python libraries, not just python embedding programs. |
|
||||
if (sys.platform == 'win32' or sys.platform.startswith('os2') |
|
||||
or sys.platform == 'darwin' or Py_ENABLE_SHARED): |
|
||||
env['LIBPATH_PYEXT'] = env['LIBPATH_PYEMBED'] |
|
||||
env['LIB_PYEXT'] = env['LIB_PYEMBED'] |
|
||||
|
|
||||
# We check that pythonX.Y-config exists, and if it exists we |
|
||||
# use it to get only the includes, else fall back to distutils. |
|
||||
python_config = conf.find_program( |
|
||||
'python%s-config' % ('.'.join(env['PYTHON_VERSION'].split('.')[:2])), |
|
||||
var='PYTHON_CONFIG') |
|
||||
if not python_config: |
|
||||
python_config = conf.find_program( |
|
||||
'python-config-%s' % ('.'.join(env['PYTHON_VERSION'].split('.')[:2])), |
|
||||
var='PYTHON_CONFIG') |
|
||||
|
|
||||
includes = [] |
|
||||
if python_config: |
|
||||
for incstr in Utils.cmd_output("%s %s --includes" % (python, python_config)).strip().split(): |
|
||||
# strip the -I or /I |
|
||||
if (incstr.startswith('-I') |
|
||||
or incstr.startswith('/I')): |
|
||||
incstr = incstr[2:] |
|
||||
# append include path, unless already given |
|
||||
if incstr not in includes: |
|
||||
includes.append(incstr) |
|
||||
conf.log.write("Include path for Python extensions " |
|
||||
"(found via python-config --includes): %r\n" % (includes,)) |
|
||||
env['CPPPATH_PYEXT'] = includes |
|
||||
env['CPPPATH_PYEMBED'] = includes |
|
||||
else: |
|
||||
conf.log.write("Include path for Python extensions " |
|
||||
"(found via distutils module): %r\n" % (INCLUDEPY,)) |
|
||||
env['CPPPATH_PYEXT'] = [INCLUDEPY] |
|
||||
env['CPPPATH_PYEMBED'] = [INCLUDEPY] |
|
||||
|
|
||||
# Code using the Python API needs to be compiled with -fno-strict-aliasing |
|
||||
if env['CC_NAME'] == 'gcc': |
|
||||
env.append_value('CCFLAGS_PYEMBED', '-fno-strict-aliasing') |
|
||||
env.append_value('CCFLAGS_PYEXT', '-fno-strict-aliasing') |
|
||||
if env['CXX_NAME'] == 'gcc': |
|
||||
env.append_value('CXXFLAGS_PYEMBED', '-fno-strict-aliasing') |
|
||||
env.append_value('CXXFLAGS_PYEXT', '-fno-strict-aliasing') |
|
||||
|
|
||||
# See if it compiles |
|
||||
conf.check(header_name='Python.h', define_name='HAVE_PYTHON_H', |
|
||||
uselib='PYEMBED', fragment=FRAG_2, |
|
||||
errmsg='Could not find the python development headers', mandatory=1) |
|
||||
|
|
||||
@conf |
|
||||
def check_python_version(conf, minver=None): |
|
||||
""" |
|
||||
Check if the python interpreter is found matching a given minimum version. |
|
||||
minver should be a tuple, eg. to check for python >= 2.4.2 pass (2,4,2) as minver. |
|
||||
|
|
||||
If successful, PYTHON_VERSION is defined as 'MAJOR.MINOR' |
|
||||
(eg. '2.4') of the actual python version found, and PYTHONDIR is |
|
||||
defined, pointing to the site-packages directory appropriate for |
|
||||
this python version, where modules/packages/extensions should be |
|
||||
installed. |
|
||||
""" |
|
||||
assert minver is None or isinstance(minver, tuple) |
|
||||
python = conf.env['PYTHON'] |
|
||||
if not python: |
|
||||
conf.fatal('could not find the python executable') |
|
||||
|
|
||||
# Get python version string |
|
||||
cmd = [python, "-c", "import sys\nfor x in sys.version_info: print(str(x))"] |
|
||||
debug('python: Running python command %r' % cmd) |
|
||||
proc = Utils.pproc.Popen(cmd, stdout=Utils.pproc.PIPE) |
|
||||
lines = proc.communicate()[0].split() |
|
||||
assert len(lines) == 5, "found %i lines, expected 5: %r" % (len(lines), lines) |
|
||||
pyver_tuple = (int(lines[0]), int(lines[1]), int(lines[2]), lines[3], int(lines[4])) |
|
||||
|
|
||||
# compare python version with the minimum required |
|
||||
result = (minver is None) or (pyver_tuple >= minver) |
|
||||
|
|
||||
if result: |
|
||||
# define useful environment variables |
|
||||
pyver = '.'.join([str(x) for x in pyver_tuple[:2]]) |
|
||||
conf.env['PYTHON_VERSION'] = pyver |
|
||||
|
|
||||
if 'PYTHONDIR' in conf.environ: |
|
||||
pydir = conf.environ['PYTHONDIR'] |
|
||||
else: |
|
||||
if sys.platform == 'win32': |
|
||||
(python_LIBDEST, pydir) = \ |
|
||||
_get_python_variables(python, |
|
||||
["get_config_var('LIBDEST')", |
|
||||
"get_python_lib(standard_lib=0, prefix=%r)" % conf.env['PREFIX']], |
|
||||
['from distutils.sysconfig import get_config_var, get_python_lib']) |
|
||||
else: |
|
||||
python_LIBDEST = None |
|
||||
(pydir,) = \ |
|
||||
_get_python_variables(python, |
|
||||
["get_python_lib(standard_lib=0, prefix=%r)" % conf.env['PREFIX']], |
|
||||
['from distutils.sysconfig import get_config_var, get_python_lib']) |
|
||||
if python_LIBDEST is None: |
|
||||
if conf.env['LIBDIR']: |
|
||||
python_LIBDEST = os.path.join(conf.env['LIBDIR'], "python" + pyver) |
|
||||
else: |
|
||||
python_LIBDEST = os.path.join(conf.env['PREFIX'], "lib", "python" + pyver) |
|
||||
|
|
||||
if hasattr(conf, 'define'): # conf.define is added by the C tool, so may not exist |
|
||||
conf.define('PYTHONDIR', pydir) |
|
||||
conf.env['PYTHONDIR'] = pydir |
|
||||
|
|
||||
# Feedback |
|
||||
pyver_full = '.'.join(map(str, pyver_tuple[:3])) |
|
||||
if minver is None: |
|
||||
conf.check_message_custom('Python version', '', pyver_full) |
|
||||
else: |
|
||||
minver_str = '.'.join(map(str, minver)) |
|
||||
conf.check_message('Python version', ">= %s" % minver_str, result, option=pyver_full) |
|
||||
|
|
||||
if not result: |
|
||||
conf.fatal('The python version is too old (%r)' % pyver_full) |
|
||||
|
|
||||
@conf |
|
||||
def check_python_module(conf, module_name): |
|
||||
""" |
|
||||
Check if the selected python interpreter can import the given python module. |
|
||||
""" |
|
||||
result = not Utils.pproc.Popen([conf.env['PYTHON'], "-c", "import %s" % module_name], |
|
||||
stderr=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE).wait() |
|
||||
conf.check_message('Python module', module_name, result) |
|
||||
if not result: |
|
||||
conf.fatal('Could not find the python module %r' % module_name) |
|
||||
|
|
||||
def detect(conf): |
|
||||
|
|
||||
if not conf.env.PYTHON: |
|
||||
conf.env.PYTHON = sys.executable |
|
||||
|
|
||||
python = conf.find_program('python', var='PYTHON') |
|
||||
if not python: |
|
||||
conf.fatal('Could not find the path of the python executable') |
|
||||
|
|
||||
v = conf.env |
|
||||
|
|
||||
v['PYCMD'] = '"import sys, py_compile;py_compile.compile(sys.argv[1], sys.argv[2])"' |
|
||||
v['PYFLAGS'] = '' |
|
||||
v['PYFLAGS_OPT'] = '-O' |
|
||||
|
|
||||
v['PYC'] = getattr(Options.options, 'pyc', 1) |
|
||||
v['PYO'] = getattr(Options.options, 'pyo', 1) |
|
||||
|
|
||||
def set_options(opt): |
|
||||
opt.add_option('--nopyc', |
|
||||
action='store_false', |
|
||||
default=1, |
|
||||
help = 'Do not install bytecode compiled .pyc files (configuration) [Default:install]', |
|
||||
dest = 'pyc') |
|
||||
opt.add_option('--nopyo', |
|
||||
action='store_false', |
|
||||
default=1, |
|
||||
help='Do not install optimised compiled .pyo files (configuration) [Default:install]', |
|
||||
dest='pyo') |
|
||||
|
|
||||
@ -1,77 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
|
|
||||
import os, optparse |
|
||||
import Utils, Options, Configure |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_scc(conf): |
|
||||
v = conf.env |
|
||||
cc = None |
|
||||
if v['CC']: cc = v['CC'] |
|
||||
elif 'CC' in conf.environ: cc = conf.environ['CC'] |
|
||||
#if not cc: cc = conf.find_program('gcc', var='CC') |
|
||||
if not cc: cc = conf.find_program('cc', var='CC') |
|
||||
if not cc: conf.fatal('suncc was not found') |
|
||||
cc = conf.cmd_to_list(cc) |
|
||||
|
|
||||
try: |
|
||||
if not Utils.cmd_output(cc + ['-flags']): |
|
||||
conf.fatal('suncc %r was not found' % cc) |
|
||||
except ValueError: |
|
||||
conf.fatal('suncc -flags could not be executed') |
|
||||
|
|
||||
v['CC'] = cc |
|
||||
v['CC_NAME'] = 'sun' |
|
||||
|
|
||||
@conftest |
|
||||
def scc_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS |
|
||||
|
|
||||
v['CC_SRC_F'] = '' |
|
||||
v['CC_TGT_F'] = ['-c', '-o', ''] |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CC']: v['LINK_CC'] = v['CC'] |
|
||||
v['CCLNK_SRC_F'] = '' |
|
||||
v['CCLNK_TGT_F'] = ['-o', ''] # solaris hack, separate the -o from the target |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['CCDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '-Wl,-h -Wl,%s' |
|
||||
v['SHLIB_MARKER'] = '-Bdynamic' |
|
||||
v['STATICLIB_MARKER'] = '-Bstatic' |
|
||||
|
|
||||
# program |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CCFLAGS'] = ['-Kpic', '-DPIC'] |
|
||||
v['shlib_LINKFLAGS'] = ['-G'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = ['-Bstatic'] |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
detect = ''' |
|
||||
find_scc |
|
||||
find_cpp |
|
||||
find_ar |
|
||||
scc_common_flags |
|
||||
cc_load_tools |
|
||||
cc_add_flags |
|
||||
link_add_flags |
|
||||
''' |
|
||||
|
|
||||
@ -1,75 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
|
|
||||
import os, optparse |
|
||||
import Utils, Options, Configure |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_sxx(conf): |
|
||||
v = conf.env |
|
||||
cc = None |
|
||||
if v['CXX']: cc = v['CXX'] |
|
||||
elif 'CXX' in conf.environ: cc = conf.environ['CXX'] |
|
||||
if not cc: cc = conf.find_program('c++', var='CXX') |
|
||||
if not cc: conf.fatal('sunc++ was not found') |
|
||||
cc = conf.cmd_to_list(cc) |
|
||||
|
|
||||
try: |
|
||||
if not Utils.cmd_output(cc + ['-flags']): |
|
||||
conf.fatal('sunc++ %r was not found' % cc) |
|
||||
except ValueError: |
|
||||
conf.fatal('sunc++ -flags could not be executed') |
|
||||
|
|
||||
v['CXX'] = cc |
|
||||
v['CXX_NAME'] = 'sun' |
|
||||
|
|
||||
@conftest |
|
||||
def sxx_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS |
|
||||
|
|
||||
v['CXX_SRC_F'] = '' |
|
||||
v['CXX_TGT_F'] = ['-c', '-o', ''] |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] |
|
||||
v['CXXLNK_SRC_F'] = '' |
|
||||
v['CXXLNK_TGT_F'] = ['-o', ''] # solaris hack, separate the -o from the target |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['CXXDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '-Wl,-h -Wl,%s' |
|
||||
v['SHLIB_MARKER'] = '-Bdynamic' |
|
||||
v['STATICLIB_MARKER'] = '-Bstatic' |
|
||||
|
|
||||
# program |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CXXFLAGS'] = ['-Kpic', '-DPIC'] |
|
||||
v['shlib_LINKFLAGS'] = ['-G'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = ['-Bstatic'] |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
detect = ''' |
|
||||
find_sxx |
|
||||
find_cpp |
|
||||
find_ar |
|
||||
sxx_common_flags |
|
||||
cxx_load_tools |
|
||||
cxx_add_flags |
|
||||
''' |
|
||||
|
|
||||
@ -1,305 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Carlos Rafael Giani, 2006 |
|
||||
|
|
||||
""" |
|
||||
Unit tests run in the shutdown() method, and for c/c++ programs |
|
||||
|
|
||||
One should NOT have to give parameters to programs to execute |
|
||||
|
|
||||
In the shutdown method, add the following code: |
|
||||
|
|
||||
>>> def shutdown(): |
|
||||
... ut = UnitTest.unit_test() |
|
||||
... ut.run() |
|
||||
... ut.print_results() |
|
||||
|
|
||||
|
|
||||
Each object to use as a unit test must be a program and must have X{obj.unit_test=1} |
|
||||
""" |
|
||||
import os, sys |
|
||||
import Build, TaskGen, Utils, Options, Logs, Task |
|
||||
from TaskGen import before, after, feature |
|
||||
from Constants import * |
|
||||
|
|
||||
class unit_test(object): |
|
||||
"Unit test representation" |
|
||||
def __init__(self): |
|
||||
self.returncode_ok = 0 # Unit test returncode considered OK. All returncodes differing from this one |
|
||||
# will cause the unit test to be marked as "FAILED". |
|
||||
|
|
||||
# The following variables are filled with data by run(). |
|
||||
|
|
||||
# print_results() uses these for printing the unit test summary, |
|
||||
# but if there is need for direct access to the results, |
|
||||
# they can be retrieved here, after calling run(). |
|
||||
|
|
||||
self.num_tests_ok = 0 # Number of successful unit tests |
|
||||
self.num_tests_failed = 0 # Number of failed unit tests |
|
||||
self.num_tests_err = 0 # Tests that have not even run |
|
||||
self.total_num_tests = 0 # Total amount of unit tests |
|
||||
self.max_label_length = 0 # Maximum label length (pretty-print the output) |
|
||||
|
|
||||
self.unit_tests = Utils.ordered_dict() # Unit test dictionary. Key: the label (unit test filename relative |
|
||||
# to the build dir), value: unit test filename with absolute path |
|
||||
self.unit_test_results = {} # Dictionary containing the unit test results. |
|
||||
# Key: the label, value: result (true = success false = failure) |
|
||||
self.unit_test_erroneous = {} # Dictionary indicating erroneous unit tests. |
|
||||
# Key: the label, value: true = unit test has an error false = unit test is ok |
|
||||
self.change_to_testfile_dir = False #True if the test file needs to be executed from the same dir |
|
||||
self.want_to_see_test_output = False #True to see the stdout from the testfile (for example check suites) |
|
||||
self.want_to_see_test_error = False #True to see the stderr from the testfile (for example check suites) |
|
||||
self.run_if_waf_does = 'check' #build was the old default |
|
||||
|
|
||||
def run(self): |
|
||||
"Run the unit tests and gather results (note: no output here)" |
|
||||
|
|
||||
self.num_tests_ok = 0 |
|
||||
self.num_tests_failed = 0 |
|
||||
self.num_tests_err = 0 |
|
||||
self.total_num_tests = 0 |
|
||||
self.max_label_length = 0 |
|
||||
|
|
||||
self.unit_tests = Utils.ordered_dict() |
|
||||
self.unit_test_results = {} |
|
||||
self.unit_test_erroneous = {} |
|
||||
|
|
||||
ld_library_path = [] |
|
||||
|
|
||||
# If waf is not building, don't run anything |
|
||||
if not Options.commands[self.run_if_waf_does]: return |
|
||||
|
|
||||
# Get the paths for the shared libraries, and obtain the unit tests to execute |
|
||||
for obj in Build.bld.all_task_gen: |
|
||||
try: |
|
||||
link_task = obj.link_task |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
else: |
|
||||
lib_path = link_task.outputs[0].parent.abspath(obj.env) |
|
||||
if lib_path not in ld_library_path: |
|
||||
ld_library_path.append(lib_path) |
|
||||
|
|
||||
unit_test = getattr(obj, 'unit_test', '') |
|
||||
if unit_test and 'cprogram' in obj.features: |
|
||||
try: |
|
||||
output = obj.path |
|
||||
filename = os.path.join(output.abspath(obj.env), obj.target) |
|
||||
srcdir = output.abspath() |
|
||||
label = os.path.join(output.bldpath(obj.env), obj.target) |
|
||||
self.max_label_length = max(self.max_label_length, len(label)) |
|
||||
self.unit_tests[label] = (filename, srcdir) |
|
||||
except KeyError: |
|
||||
pass |
|
||||
self.total_num_tests = len(self.unit_tests) |
|
||||
# Now run the unit tests |
|
||||
Utils.pprint('GREEN', 'Running the unit tests') |
|
||||
count = 0 |
|
||||
result = 1 |
|
||||
|
|
||||
for label in self.unit_tests.allkeys: |
|
||||
file_and_src = self.unit_tests[label] |
|
||||
filename = file_and_src[0] |
|
||||
srcdir = file_and_src[1] |
|
||||
count += 1 |
|
||||
line = Build.bld.progress_line(count, self.total_num_tests, Logs.colors.GREEN, Logs.colors.NORMAL) |
|
||||
if Options.options.progress_bar and line: |
|
||||
sys.stderr.write(line) |
|
||||
sys.stderr.flush() |
|
||||
try: |
|
||||
kwargs = {} |
|
||||
kwargs['env'] = os.environ.copy() |
|
||||
if self.change_to_testfile_dir: |
|
||||
kwargs['cwd'] = srcdir |
|
||||
if not self.want_to_see_test_output: |
|
||||
kwargs['stdout'] = Utils.pproc.PIPE # PIPE for ignoring output |
|
||||
if not self.want_to_see_test_error: |
|
||||
kwargs['stderr'] = Utils.pproc.PIPE # PIPE for ignoring output |
|
||||
if ld_library_path: |
|
||||
v = kwargs['env'] |
|
||||
def add_path(dct, path, var): |
|
||||
dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, '')]) |
|
||||
if sys.platform == 'win32': |
|
||||
add_path(v, ld_library_path, 'PATH') |
|
||||
elif sys.platform == 'darwin': |
|
||||
add_path(v, ld_library_path, 'DYLD_LIBRARY_PATH') |
|
||||
add_path(v, ld_library_path, 'LD_LIBRARY_PATH') |
|
||||
else: |
|
||||
add_path(v, ld_library_path, 'LD_LIBRARY_PATH') |
|
||||
|
|
||||
pp = Utils.pproc.Popen(filename, **kwargs) |
|
||||
pp.wait() |
|
||||
|
|
||||
result = int(pp.returncode == self.returncode_ok) |
|
||||
|
|
||||
if result: |
|
||||
self.num_tests_ok += 1 |
|
||||
else: |
|
||||
self.num_tests_failed += 1 |
|
||||
|
|
||||
self.unit_test_results[label] = result |
|
||||
self.unit_test_erroneous[label] = 0 |
|
||||
except OSError: |
|
||||
self.unit_test_erroneous[label] = 1 |
|
||||
self.num_tests_err += 1 |
|
||||
except KeyboardInterrupt: |
|
||||
pass |
|
||||
if Options.options.progress_bar: sys.stdout.write(Logs.colors.cursor_on) |
|
||||
|
|
||||
def print_results(self): |
|
||||
"Pretty-prints a summary of all unit tests, along with some statistics" |
|
||||
|
|
||||
# If waf is not building, don't output anything |
|
||||
if not Options.commands[self.run_if_waf_does]: return |
|
||||
|
|
||||
p = Utils.pprint |
|
||||
# Early quit if no tests were performed |
|
||||
if self.total_num_tests == 0: |
|
||||
p('YELLOW', 'No unit tests present') |
|
||||
return |
|
||||
|
|
||||
for label in self.unit_tests.allkeys: |
|
||||
filename = self.unit_tests[label] |
|
||||
err = 0 |
|
||||
result = 0 |
|
||||
|
|
||||
try: err = self.unit_test_erroneous[label] |
|
||||
except KeyError: pass |
|
||||
|
|
||||
try: result = self.unit_test_results[label] |
|
||||
except KeyError: pass |
|
||||
|
|
||||
n = self.max_label_length - len(label) |
|
||||
if err: n += 4 |
|
||||
elif result: n += 7 |
|
||||
else: n += 3 |
|
||||
|
|
||||
line = '%s %s' % (label, '.' * n) |
|
||||
|
|
||||
if err: p('RED', '%sERROR' % line) |
|
||||
elif result: p('GREEN', '%sOK' % line) |
|
||||
else: p('YELLOW', '%sFAILED' % line) |
|
||||
|
|
||||
percentage_ok = float(self.num_tests_ok) / float(self.total_num_tests) * 100.0 |
|
||||
percentage_failed = float(self.num_tests_failed) / float(self.total_num_tests) * 100.0 |
|
||||
percentage_erroneous = float(self.num_tests_err) / float(self.total_num_tests) * 100.0 |
|
||||
|
|
||||
p('NORMAL', ''' |
|
||||
Successful tests: %i (%.1f%%) |
|
||||
Failed tests: %i (%.1f%%) |
|
||||
Erroneous tests: %i (%.1f%%) |
|
||||
|
|
||||
Total number of tests: %i |
|
||||
''' % (self.num_tests_ok, percentage_ok, self.num_tests_failed, percentage_failed, |
|
||||
self.num_tests_err, percentage_erroneous, self.total_num_tests)) |
|
||||
p('GREEN', 'Unit tests finished') |
|
||||
|
|
||||
|
|
||||
############################################################################################ |
|
||||
|
|
||||
""" |
|
||||
New unit test system |
|
||||
|
|
||||
The targets with feature 'test' are executed after they are built |
|
||||
bld(features='cprogram cc test', ...) |
|
||||
|
|
||||
To display the results: |
|
||||
import UnitTest |
|
||||
bld.add_post_fun(UnitTest.summary) |
|
||||
""" |
|
||||
|
|
||||
import threading |
|
||||
testlock = threading.Lock() |
|
||||
|
|
||||
def set_options(opt): |
|
||||
opt.add_option('--alltests', action='store_true', default=True, help='Exec all unit tests', dest='all_tests') |
|
||||
|
|
||||
@feature('test') |
|
||||
@after('apply_link', 'vars_target_cprogram') |
|
||||
def make_test(self): |
|
||||
if not 'cprogram' in self.features: |
|
||||
Logs.error('test cannot be executed %s' % self) |
|
||||
return |
|
||||
|
|
||||
self.default_install_path = None |
|
||||
self.create_task('utest', self.link_task.outputs) |
|
||||
|
|
||||
def exec_test(self): |
|
||||
|
|
||||
status = 0 |
|
||||
|
|
||||
variant = self.env.variant() |
|
||||
filename = self.inputs[0].abspath(self.env) |
|
||||
|
|
||||
try: |
|
||||
fu = getattr(self.generator.bld, 'all_test_paths') |
|
||||
except AttributeError: |
|
||||
fu = os.environ.copy() |
|
||||
self.generator.bld.all_test_paths = fu |
|
||||
|
|
||||
lst = [] |
|
||||
for obj in self.generator.bld.all_task_gen: |
|
||||
link_task = getattr(obj, 'link_task', None) |
|
||||
if link_task and link_task.env.variant() == variant: |
|
||||
lst.append(link_task.outputs[0].parent.abspath(obj.env)) |
|
||||
|
|
||||
def add_path(dct, path, var): |
|
||||
dct[var] = os.pathsep.join(Utils.to_list(path) + [os.environ.get(var, '')]) |
|
||||
|
|
||||
if sys.platform == 'win32': |
|
||||
add_path(fu, lst, 'PATH') |
|
||||
elif sys.platform == 'darwin': |
|
||||
add_path(fu, lst, 'DYLD_LIBRARY_PATH') |
|
||||
add_path(fu, lst, 'LD_LIBRARY_PATH') |
|
||||
else: |
|
||||
add_path(fu, lst, 'LD_LIBRARY_PATH') |
|
||||
|
|
||||
|
|
||||
cwd = getattr(self.generator, 'ut_cwd', '') or self.inputs[0].parent.abspath(self.env) |
|
||||
proc = Utils.pproc.Popen(filename, cwd=cwd, env=fu, stderr=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE) |
|
||||
(stdout, stderr) = proc.communicate() |
|
||||
|
|
||||
tup = (filename, proc.returncode, stdout, stderr) |
|
||||
self.generator.utest_result = tup |
|
||||
|
|
||||
testlock.acquire() |
|
||||
try: |
|
||||
bld = self.generator.bld |
|
||||
Logs.debug("ut: %r", tup) |
|
||||
try: |
|
||||
bld.utest_results.append(tup) |
|
||||
except AttributeError: |
|
||||
bld.utest_results = [tup] |
|
||||
finally: |
|
||||
testlock.release() |
|
||||
|
|
||||
cls = Task.task_type_from_func('utest', func=exec_test, color='PINK', ext_in='.bin') |
|
||||
|
|
||||
old = cls.runnable_status |
|
||||
def test_status(self): |
|
||||
if getattr(Options.options, 'all_tests', False): |
|
||||
return RUN_ME |
|
||||
return old(self) |
|
||||
|
|
||||
cls.runnable_status = test_status |
|
||||
cls.quiet = 1 |
|
||||
|
|
||||
def summary(bld): |
|
||||
lst = getattr(bld, 'utest_results', []) |
|
||||
if lst: |
|
||||
Utils.pprint('CYAN', 'execution summary') |
|
||||
|
|
||||
total = len(lst) |
|
||||
tfail = len([x for x in lst if x[1]]) |
|
||||
|
|
||||
Utils.pprint('CYAN', ' tests that pass %d/%d' % (total-tfail, total)) |
|
||||
for (f, code, out, err) in lst: |
|
||||
if not code: |
|
||||
Utils.pprint('CYAN', ' %s' % f) |
|
||||
|
|
||||
Utils.pprint('CYAN', ' tests that fail %d/%d' % (tfail, total)) |
|
||||
for (f, code, out, err) in lst: |
|
||||
if code: |
|
||||
Utils.pprint('CYAN', ' %s' % f) |
|
||||
|
|
||||
|
|
||||
@ -1,45 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Brant Young, 2007 |
|
||||
|
|
||||
"This hook is called when the class cpp/cc task generator encounters a '.rc' file: X{.rc -> [.res|.rc.o]}" |
|
||||
|
|
||||
import os, sys, re |
|
||||
import TaskGen, Task |
|
||||
from Utils import quote_whitespace |
|
||||
from TaskGen import extension |
|
||||
|
|
||||
EXT_WINRC = ['.rc'] |
|
||||
|
|
||||
winrc_str = '${WINRC} ${_CPPDEFFLAGS} ${_CCDEFFLAGS} ${WINRCFLAGS} ${_CPPINCFLAGS} ${_CCINCFLAGS} ${WINRC_TGT_F} ${TGT} ${WINRC_SRC_F} ${SRC}' |
|
||||
|
|
||||
@extension(EXT_WINRC) |
|
||||
def rc_file(self, node): |
|
||||
obj_ext = '.rc.o' |
|
||||
if self.env['WINRC_TGT_F'] == '/fo': obj_ext = '.res' |
|
||||
|
|
||||
rctask = self.create_task('winrc', node, node.change_ext(obj_ext)) |
|
||||
self.compiled_tasks.append(rctask) |
|
||||
|
|
||||
# create our action, for use with rc file |
|
||||
Task.simple_task_type('winrc', winrc_str, color='BLUE', before='cc cxx', shell=False) |
|
||||
|
|
||||
def detect(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
winrc = v['WINRC'] |
|
||||
v['WINRC_TGT_F'] = '-o' |
|
||||
v['WINRC_SRC_F'] = '-i' |
|
||||
# find rc.exe |
|
||||
if not winrc: |
|
||||
if v['CC_NAME'] in ['gcc', 'cc', 'g++', 'c++']: |
|
||||
winrc = conf.find_program('windres', var='WINRC', path_list = v['PATH']) |
|
||||
elif v['CC_NAME'] == 'msvc': |
|
||||
winrc = conf.find_program('RC', var='WINRC', path_list = v['PATH']) |
|
||||
v['WINRC_TGT_F'] = '/fo' |
|
||||
v['WINRC_SRC_F'] = '' |
|
||||
if not winrc: |
|
||||
conf.fatal('winrc was not found!') |
|
||||
|
|
||||
v['WINRCFLAGS'] = '' |
|
||||
|
|
||||
@ -1,77 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006-2008 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
# Yinon Ehrlich, 2009 |
|
||||
# Michael Kuhn, 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_xlc(conf): |
|
||||
cc = conf.find_program(['xlc_r', 'xlc'], var='CC', mandatory=True) |
|
||||
cc = conf.cmd_to_list(cc) |
|
||||
conf.env.CC_NAME = 'xlc' |
|
||||
conf.env.CC = cc |
|
||||
|
|
||||
@conftest |
|
||||
def find_cpp(conf): |
|
||||
v = conf.env |
|
||||
cpp = None |
|
||||
if v['CPP']: cpp = v['CPP'] |
|
||||
elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] |
|
||||
if not cpp: cpp = v['CC'] |
|
||||
v['CPP'] = cpp |
|
||||
|
|
||||
@conftest |
|
||||
def xlc_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CCDEFINES _CCINCFLAGS _CCDEFFLAGS |
|
||||
v['CCFLAGS_DEBUG'] = ['-g'] |
|
||||
v['CCFLAGS_RELEASE'] = ['-O2'] |
|
||||
|
|
||||
v['CC_SRC_F'] = '' |
|
||||
v['CC_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CC']: v['LINK_CC'] = v['CC'] |
|
||||
v['CCLNK_SRC_F'] = '' |
|
||||
v['CCLNK_TGT_F'] = ['-o', ''] # shell hack for -MD |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['RPATH_ST'] = '-Wl,-rpath,%s' |
|
||||
v['CCDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '' |
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
v['STATICLIB_MARKER'] = '' |
|
||||
v['FULLSTATIC_MARKER'] = '-static' |
|
||||
|
|
||||
# program |
|
||||
v['program_LINKFLAGS'] = ['-Wl,-brtl'] |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CCFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro |
|
||||
v['shlib_LINKFLAGS'] = ['-G', '-Wl,-brtl,-bexpfull'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = '' |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_xlc() |
|
||||
conf.find_cpp() |
|
||||
conf.find_ar() |
|
||||
conf.xlc_common_flags() |
|
||||
conf.cc_load_tools() |
|
||||
conf.cc_add_flags() |
|
||||
@ -1,77 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2006 (ita) |
|
||||
# Ralf Habacker, 2006 (rh) |
|
||||
# Yinon Ehrlich, 2009 |
|
||||
# Michael Kuhn, 2009 |
|
||||
|
|
||||
import os, sys |
|
||||
import Configure, Options, Utils |
|
||||
import ccroot, ar |
|
||||
from Configure import conftest |
|
||||
|
|
||||
@conftest |
|
||||
def find_xlcxx(conf): |
|
||||
cxx = conf.find_program(['xlc++_r', 'xlc++'], var='CXX', mandatory=True) |
|
||||
cxx = conf.cmd_to_list(cxx) |
|
||||
conf.env.CXX_NAME = 'xlc++' |
|
||||
conf.env.CXX = cxx |
|
||||
|
|
||||
@conftest |
|
||||
def find_cpp(conf): |
|
||||
v = conf.env |
|
||||
cpp = None |
|
||||
if v['CPP']: cpp = v['CPP'] |
|
||||
elif 'CPP' in conf.environ: cpp = conf.environ['CPP'] |
|
||||
if not cpp: cpp = v['CXX'] |
|
||||
v['CPP'] = cpp |
|
||||
|
|
||||
@conftest |
|
||||
def xlcxx_common_flags(conf): |
|
||||
v = conf.env |
|
||||
|
|
||||
# CPPFLAGS CXXDEFINES _CXXINCFLAGS _CXXDEFFLAGS |
|
||||
v['CXXFLAGS_DEBUG'] = ['-g'] |
|
||||
v['CXXFLAGS_RELEASE'] = ['-O2'] |
|
||||
|
|
||||
v['CXX_SRC_F'] = '' |
|
||||
v['CXX_TGT_F'] = ['-c', '-o', ''] # shell hack for -MD |
|
||||
v['CPPPATH_ST'] = '-I%s' # template for adding include paths |
|
||||
|
|
||||
# linker |
|
||||
if not v['LINK_CXX']: v['LINK_CXX'] = v['CXX'] |
|
||||
v['CXXLNK_SRC_F'] = '' |
|
||||
v['CXXLNK_TGT_F'] = ['-o', ''] # shell hack for -MD |
|
||||
|
|
||||
v['LIB_ST'] = '-l%s' # template for adding libs |
|
||||
v['LIBPATH_ST'] = '-L%s' # template for adding libpaths |
|
||||
v['STATICLIB_ST'] = '-l%s' |
|
||||
v['STATICLIBPATH_ST'] = '-L%s' |
|
||||
v['RPATH_ST'] = '-Wl,-rpath,%s' |
|
||||
v['CXXDEFINES_ST'] = '-D%s' |
|
||||
|
|
||||
v['SONAME_ST'] = '' |
|
||||
v['SHLIB_MARKER'] = '' |
|
||||
v['STATICLIB_MARKER'] = '' |
|
||||
v['FULLSTATIC_MARKER'] = '-static' |
|
||||
|
|
||||
# program |
|
||||
v['program_LINKFLAGS'] = ['-Wl,-brtl'] |
|
||||
v['program_PATTERN'] = '%s' |
|
||||
|
|
||||
# shared library |
|
||||
v['shlib_CXXFLAGS'] = ['-fPIC', '-DPIC'] # avoid using -DPIC, -fPIC aleady defines the __PIC__ macro |
|
||||
v['shlib_LINKFLAGS'] = ['-G', '-Wl,-brtl,-bexpfull'] |
|
||||
v['shlib_PATTERN'] = 'lib%s.so' |
|
||||
|
|
||||
# static lib |
|
||||
v['staticlib_LINKFLAGS'] = '' |
|
||||
v['staticlib_PATTERN'] = 'lib%s.a' |
|
||||
|
|
||||
def detect(conf): |
|
||||
conf.find_xlcxx() |
|
||||
conf.find_cpp() |
|
||||
conf.find_ar() |
|
||||
conf.xlcxx_common_flags() |
|
||||
conf.cxx_load_tools() |
|
||||
conf.cxx_add_flags() |
|
||||
@ -1,707 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
|
|
||||
""" |
|
||||
Utilities, the stable ones are the following: |
|
||||
|
|
||||
* h_file: compute a unique value for a file (hash), it uses |
|
||||
the module fnv if it is installed (see waf/utils/fnv & http://code.google.com/p/waf/wiki/FAQ) |
|
||||
else, md5 (see the python docs) |
|
||||
|
|
||||
For large projects (projects with more than 15000 files) or slow hard disks and filesystems (HFS) |
|
||||
it is possible to use a hashing based on the path and the size (may give broken cache results) |
|
||||
The method h_file MUST raise an OSError if the file is a folder |
|
||||
|
|
||||
import stat |
|
||||
def h_file(filename): |
|
||||
st = os.stat(filename) |
|
||||
if stat.S_ISDIR(st[stat.ST_MODE]): raise IOError('not a file') |
|
||||
m = Utils.md5() |
|
||||
m.update(str(st.st_mtime)) |
|
||||
m.update(str(st.st_size)) |
|
||||
m.update(filename) |
|
||||
return m.digest() |
|
||||
|
|
||||
To replace the function in your project, use something like this: |
|
||||
import Utils |
|
||||
Utils.h_file = h_file |
|
||||
|
|
||||
* h_list |
|
||||
* h_fun |
|
||||
* get_term_cols |
|
||||
* ordered_dict |
|
||||
|
|
||||
""" |
|
||||
|
|
||||
import os, sys, imp, string, errno, traceback, inspect, re, shutil, datetime, gc |
|
||||
|
|
||||
# In python 3.0 we can get rid of all this |
|
||||
try: from UserDict import UserDict |
|
||||
except ImportError: from collections import UserDict |
|
||||
if sys.hexversion >= 0x2060000 or os.name == 'java': |
|
||||
import subprocess as pproc |
|
||||
else: |
|
||||
import pproc |
|
||||
import Logs |
|
||||
from Constants import * |
|
||||
|
|
||||
try: |
|
||||
from collections import deque |
|
||||
except ImportError: |
|
||||
class deque(list): |
|
||||
def popleft(self): |
|
||||
return self.pop(0) |
|
||||
|
|
||||
is_win32 = sys.platform == 'win32' |
|
||||
|
|
||||
try: |
|
||||
# defaultdict in python 2.5 |
|
||||
from collections import defaultdict as 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 |
|
||||
|
|
||||
class WafError(Exception): |
|
||||
def __init__(self, *args): |
|
||||
self.args = args |
|
||||
try: |
|
||||
self.stack = traceback.extract_stack() |
|
||||
except: |
|
||||
pass |
|
||||
Exception.__init__(self, *args) |
|
||||
def __str__(self): |
|
||||
return str(len(self.args) == 1 and self.args[0] or self.args) |
|
||||
|
|
||||
class WscriptError(WafError): |
|
||||
def __init__(self, message, wscript_file=None): |
|
||||
if wscript_file: |
|
||||
self.wscript_file = wscript_file |
|
||||
self.wscript_line = None |
|
||||
else: |
|
||||
try: |
|
||||
(self.wscript_file, self.wscript_line) = self.locate_error() |
|
||||
except: |
|
||||
(self.wscript_file, self.wscript_line) = (None, None) |
|
||||
|
|
||||
msg_file_line = '' |
|
||||
if self.wscript_file: |
|
||||
msg_file_line = "%s:" % self.wscript_file |
|
||||
if self.wscript_line: |
|
||||
msg_file_line += "%s:" % self.wscript_line |
|
||||
err_message = "%s error: %s" % (msg_file_line, message) |
|
||||
WafError.__init__(self, err_message) |
|
||||
|
|
||||
def locate_error(self): |
|
||||
stack = traceback.extract_stack() |
|
||||
stack.reverse() |
|
||||
for frame in stack: |
|
||||
file_name = os.path.basename(frame[0]) |
|
||||
is_wscript = (file_name == WSCRIPT_FILE or file_name == WSCRIPT_BUILD_FILE) |
|
||||
if is_wscript: |
|
||||
return (frame[0], frame[1]) |
|
||||
return (None, None) |
|
||||
|
|
||||
indicator = is_win32 and '\x1b[A\x1b[K%s%s%s\r' or '\x1b[K%s%s%s\r' |
|
||||
|
|
||||
try: |
|
||||
from fnv import new as md5 |
|
||||
import Constants |
|
||||
Constants.SIG_NIL = 'signofnv' |
|
||||
|
|
||||
def h_file(filename): |
|
||||
m = md5() |
|
||||
try: |
|
||||
m.hfile(filename) |
|
||||
x = m.digest() |
|
||||
if x is None: raise OSError("not a file") |
|
||||
return x |
|
||||
except SystemError: |
|
||||
raise OSError("not a file" + filename) |
|
||||
|
|
||||
except ImportError: |
|
||||
try: |
|
||||
try: |
|
||||
from hashlib import md5 |
|
||||
except ImportError: |
|
||||
from md5 import md5 |
|
||||
|
|
||||
def h_file(filename): |
|
||||
f = open(filename, 'rb') |
|
||||
m = md5() |
|
||||
while (filename): |
|
||||
filename = f.read(100000) |
|
||||
m.update(filename) |
|
||||
f.close() |
|
||||
return m.digest() |
|
||||
except ImportError: |
|
||||
# portability fixes may be added elsewhere (although, md5 should be everywhere by now) |
|
||||
md5 = None |
|
||||
|
|
||||
class ordered_dict(UserDict): |
|
||||
def __init__(self, dict = None): |
|
||||
self.allkeys = [] |
|
||||
UserDict.__init__(self, dict) |
|
||||
|
|
||||
def __delitem__(self, key): |
|
||||
self.allkeys.remove(key) |
|
||||
UserDict.__delitem__(self, key) |
|
||||
|
|
||||
def __setitem__(self, key, item): |
|
||||
if key not in self.allkeys: self.allkeys.append(key) |
|
||||
UserDict.__setitem__(self, key, item) |
|
||||
|
|
||||
def exec_command(s, **kw): |
|
||||
if 'log' in kw: |
|
||||
kw['stdout'] = kw['stderr'] = kw['log'] |
|
||||
del(kw['log']) |
|
||||
kw['shell'] = isinstance(s, str) |
|
||||
|
|
||||
try: |
|
||||
proc = pproc.Popen(s, **kw) |
|
||||
return proc.wait() |
|
||||
except OSError: |
|
||||
return -1 |
|
||||
|
|
||||
if is_win32: |
|
||||
def exec_command(s, **kw): |
|
||||
if 'log' in kw: |
|
||||
kw['stdout'] = kw['stderr'] = kw['log'] |
|
||||
del(kw['log']) |
|
||||
kw['shell'] = isinstance(s, str) |
|
||||
|
|
||||
if len(s) > 2000: |
|
||||
startupinfo = pproc.STARTUPINFO() |
|
||||
startupinfo.dwFlags |= pproc.STARTF_USESHOWWINDOW |
|
||||
kw['startupinfo'] = startupinfo |
|
||||
|
|
||||
try: |
|
||||
if 'stdout' not in kw: |
|
||||
kw['stdout'] = pproc.PIPE |
|
||||
kw['stderr'] = pproc.PIPE |
|
||||
proc = pproc.Popen(s,**kw) |
|
||||
(stdout, stderr) = proc.communicate() |
|
||||
Logs.info(stdout) |
|
||||
if stderr: |
|
||||
Logs.error(stderr) |
|
||||
return proc.returncode |
|
||||
else: |
|
||||
proc = pproc.Popen(s,**kw) |
|
||||
return proc.wait() |
|
||||
except OSError: |
|
||||
return -1 |
|
||||
|
|
||||
listdir = os.listdir |
|
||||
if is_win32: |
|
||||
def listdir_win32(s): |
|
||||
if re.match('^[A-Za-z]:$', s): |
|
||||
# os.path.isdir fails if s contains only the drive name... (x:) |
|
||||
s += os.sep |
|
||||
if not os.path.isdir(s): |
|
||||
e = OSError() |
|
||||
e.errno = errno.ENOENT |
|
||||
raise e |
|
||||
return os.listdir(s) |
|
||||
listdir = listdir_win32 |
|
||||
|
|
||||
def waf_version(mini = 0x010000, maxi = 0x100000): |
|
||||
"Halts if the waf version is wrong" |
|
||||
ver = HEXVERSION |
|
||||
try: min_val = mini + 0 |
|
||||
except TypeError: min_val = int(mini.replace('.', '0'), 16) |
|
||||
|
|
||||
if min_val > ver: |
|
||||
Logs.error("waf version should be at least %s (%s found)" % (mini, ver)) |
|
||||
sys.exit(0) |
|
||||
|
|
||||
try: max_val = maxi + 0 |
|
||||
except TypeError: max_val = int(maxi.replace('.', '0'), 16) |
|
||||
|
|
||||
if max_val < ver: |
|
||||
Logs.error("waf version should be at most %s (%s found)" % (maxi, ver)) |
|
||||
sys.exit(0) |
|
||||
|
|
||||
def python_24_guard(): |
|
||||
if sys.hexversion < 0x20400f0 or sys.hexversion >= 0x3000000: |
|
||||
raise ImportError("Waf requires Python >= 2.3 but the raw source requires Python 2.4, 2.5 or 2.6") |
|
||||
|
|
||||
def ex_stack(): |
|
||||
exc_type, exc_value, tb = sys.exc_info() |
|
||||
if Logs.verbose > 1: |
|
||||
exc_lines = traceback.format_exception(exc_type, exc_value, tb) |
|
||||
return ''.join(exc_lines) |
|
||||
return str(exc_value) |
|
||||
|
|
||||
def to_list(sth): |
|
||||
if isinstance(sth, str): |
|
||||
return sth.split() |
|
||||
else: |
|
||||
return sth |
|
||||
|
|
||||
g_loaded_modules = {} |
|
||||
"index modules by absolute path" |
|
||||
|
|
||||
g_module=None |
|
||||
"the main module is special" |
|
||||
|
|
||||
def load_module(file_path, name=WSCRIPT_FILE): |
|
||||
"this function requires an absolute path" |
|
||||
try: |
|
||||
return g_loaded_modules[file_path] |
|
||||
except KeyError: |
|
||||
pass |
|
||||
|
|
||||
module = imp.new_module(name) |
|
||||
|
|
||||
try: |
|
||||
code = readf(file_path, m='rU') |
|
||||
except (IOError, OSError): |
|
||||
raise WscriptError('Could not read the file %r' % file_path) |
|
||||
|
|
||||
module.waf_hash_val = code |
|
||||
|
|
||||
sys.path.insert(0, os.path.dirname(file_path)) |
|
||||
try: |
|
||||
exec(compile(code, file_path, 'exec'), module.__dict__) |
|
||||
except Exception: |
|
||||
exc_type, exc_value, tb = sys.exc_info() |
|
||||
raise WscriptError("".join(traceback.format_exception(exc_type, exc_value, tb)), file_path) |
|
||||
sys.path.pop(0) |
|
||||
|
|
||||
g_loaded_modules[file_path] = module |
|
||||
|
|
||||
return module |
|
||||
|
|
||||
def set_main_module(file_path): |
|
||||
"Load custom options, if defined" |
|
||||
global g_module |
|
||||
g_module = load_module(file_path, 'wscript_main') |
|
||||
g_module.root_path = file_path |
|
||||
|
|
||||
try: |
|
||||
g_module.APPNAME |
|
||||
except: |
|
||||
g_module.APPNAME = 'noname' |
|
||||
try: |
|
||||
g_module.VERSION |
|
||||
except: |
|
||||
g_module.VERSION = '1.0' |
|
||||
|
|
||||
# note: to register the module globally, use the following: |
|
||||
# sys.modules['wscript_main'] = g_module |
|
||||
|
|
||||
def to_hashtable(s): |
|
||||
"used for importing env files" |
|
||||
tbl = {} |
|
||||
lst = s.split('\n') |
|
||||
for line in lst: |
|
||||
if not line: continue |
|
||||
mems = line.split('=') |
|
||||
tbl[mems[0]] = mems[1] |
|
||||
return tbl |
|
||||
|
|
||||
def get_term_cols(): |
|
||||
"console width" |
|
||||
return 80 |
|
||||
try: |
|
||||
import struct, fcntl, termios |
|
||||
except ImportError: |
|
||||
pass |
|
||||
else: |
|
||||
if Logs.got_tty: |
|
||||
def myfun(): |
|
||||
dummy_lines, cols = struct.unpack("HHHH", \ |
|
||||
fcntl.ioctl(sys.stderr.fileno(),termios.TIOCGWINSZ , \ |
|
||||
struct.pack("HHHH", 0, 0, 0, 0)))[:2] |
|
||||
return cols |
|
||||
# we actually try the function once to see if it is suitable |
|
||||
try: |
|
||||
myfun() |
|
||||
except: |
|
||||
pass |
|
||||
else: |
|
||||
get_term_cols = myfun |
|
||||
|
|
||||
rot_idx = 0 |
|
||||
rot_chr = ['\\', '|', '/', '-'] |
|
||||
"the rotation character in the progress bar" |
|
||||
|
|
||||
|
|
||||
def split_path(path): |
|
||||
return path.split('/') |
|
||||
|
|
||||
def split_path_cygwin(path): |
|
||||
if path.startswith('//'): |
|
||||
ret = path.split('/')[2:] |
|
||||
ret[0] = '/' + ret[0] |
|
||||
return ret |
|
||||
return path.split('/') |
|
||||
|
|
||||
re_sp = re.compile('[/\\\\]') |
|
||||
def split_path_win32(path): |
|
||||
if path.startswith('\\\\'): |
|
||||
ret = re.split(re_sp, path)[2:] |
|
||||
ret[0] = '\\' + ret[0] |
|
||||
return ret |
|
||||
return re.split(re_sp, path) |
|
||||
|
|
||||
if sys.platform == 'cygwin': |
|
||||
split_path = split_path_cygwin |
|
||||
elif is_win32: |
|
||||
split_path = split_path_win32 |
|
||||
|
|
||||
def copy_attrs(orig, dest, names, only_if_set=False): |
|
||||
for a in to_list(names): |
|
||||
u = getattr(orig, a, ()) |
|
||||
if u or not only_if_set: |
|
||||
setattr(dest, a, u) |
|
||||
|
|
||||
def def_attrs(cls, **kw): |
|
||||
''' |
|
||||
set attributes for class. |
|
||||
@param cls [any class]: the class to update the given attributes in. |
|
||||
@param kw [dictionary]: dictionary of attributes names and values. |
|
||||
|
|
||||
if the given class hasn't one (or more) of these attributes, add the attribute with its value to the class. |
|
||||
''' |
|
||||
for k, v in kw.iteritems(): |
|
||||
if not hasattr(cls, k): |
|
||||
setattr(cls, k, v) |
|
||||
|
|
||||
def quote_define_name(path): |
|
||||
fu = re.compile("[^a-zA-Z0-9]").sub("_", path) |
|
||||
fu = fu.upper() |
|
||||
return fu |
|
||||
|
|
||||
def quote_whitespace(path): |
|
||||
return (path.strip().find(' ') > 0 and '"%s"' % path or path).replace('""', '"') |
|
||||
|
|
||||
def trimquotes(s): |
|
||||
if not s: return '' |
|
||||
s = s.rstrip() |
|
||||
if s[0] == "'" and s[-1] == "'": return s[1:-1] |
|
||||
return s |
|
||||
|
|
||||
def h_list(lst): |
|
||||
m = md5() |
|
||||
m.update(str(lst)) |
|
||||
return m.digest() |
|
||||
|
|
||||
def h_fun(fun): |
|
||||
try: |
|
||||
return fun.code |
|
||||
except AttributeError: |
|
||||
try: |
|
||||
h = inspect.getsource(fun) |
|
||||
except IOError: |
|
||||
h = "nocode" |
|
||||
try: |
|
||||
fun.code = h |
|
||||
except AttributeError: |
|
||||
pass |
|
||||
return h |
|
||||
|
|
||||
def pprint(col, str, label='', sep=os.linesep): |
|
||||
"print messages in color" |
|
||||
sys.stderr.write("%s%s%s %s%s" % (Logs.colors(col), str, Logs.colors.NORMAL, label, sep)) |
|
||||
|
|
||||
def check_dir(dir): |
|
||||
"""If a folder doesn't exists, create it.""" |
|
||||
try: |
|
||||
os.stat(dir) |
|
||||
except OSError: |
|
||||
try: |
|
||||
os.makedirs(dir) |
|
||||
except OSError, e: |
|
||||
raise WafError("Cannot create folder '%s' (original error: %s)" % (dir, e)) |
|
||||
|
|
||||
def cmd_output(cmd, **kw): |
|
||||
|
|
||||
silent = False |
|
||||
if 'silent' in kw: |
|
||||
silent = kw['silent'] |
|
||||
del(kw['silent']) |
|
||||
|
|
||||
if 'e' in kw: |
|
||||
tmp = kw['e'] |
|
||||
del(kw['e']) |
|
||||
kw['env'] = tmp |
|
||||
|
|
||||
kw['shell'] = isinstance(cmd, str) |
|
||||
kw['stdout'] = pproc.PIPE |
|
||||
if silent: |
|
||||
kw['stderr'] = pproc.PIPE |
|
||||
|
|
||||
try: |
|
||||
p = pproc.Popen(cmd, **kw) |
|
||||
output = p.communicate()[0] |
|
||||
except OSError, e: |
|
||||
raise ValueError(str(e)) |
|
||||
|
|
||||
if p.returncode: |
|
||||
if not silent: |
|
||||
msg = "command execution failed: %s -> %r" % (cmd, str(output)) |
|
||||
raise ValueError(msg) |
|
||||
output = '' |
|
||||
return output |
|
||||
|
|
||||
reg_subst = re.compile(r"(\\\\)|(\$\$)|\$\{([^}]+)\}") |
|
||||
def subst_vars(expr, params): |
|
||||
"substitute ${PREFIX}/bin in /usr/local/bin" |
|
||||
def repl_var(m): |
|
||||
if m.group(1): |
|
||||
return '\\' |
|
||||
if m.group(2): |
|
||||
return '$' |
|
||||
try: |
|
||||
# environments may contain lists |
|
||||
return params.get_flat(m.group(3)) |
|
||||
except AttributeError: |
|
||||
return params[m.group(3)] |
|
||||
return reg_subst.sub(repl_var, expr) |
|
||||
|
|
||||
def unversioned_sys_platform_to_binary_format(unversioned_sys_platform): |
|
||||
"infers the binary format from the unversioned_sys_platform name." |
|
||||
|
|
||||
if unversioned_sys_platform in ('linux', 'freebsd', 'netbsd', 'openbsd', 'sunos'): |
|
||||
return 'elf' |
|
||||
elif unversioned_sys_platform == 'darwin': |
|
||||
return 'mac-o' |
|
||||
elif unversioned_sys_platform in ('win32', 'cygwin', 'uwin', 'msys'): |
|
||||
return 'pe' |
|
||||
# TODO we assume all other operating systems are elf, which is not true. |
|
||||
# we may set this to 'unknown' and have ccroot and other tools handle the case "gracefully" (whatever that means). |
|
||||
return 'elf' |
|
||||
|
|
||||
def unversioned_sys_platform(): |
|
||||
"""returns an unversioned name from sys.platform. |
|
||||
sys.plaform is not very well defined and depends directly on the python source tree. |
|
||||
The version appended to the names is unreliable as it's taken from the build environment at the time python was built, |
|
||||
i.e., it's possible to get freebsd7 on a freebsd8 system. |
|
||||
So we remove the version from the name, except for special cases where the os has a stupid name like os2 or win32. |
|
||||
Some possible values of sys.platform are, amongst others: |
|
||||
aix3 aix4 atheos beos5 darwin freebsd2 freebsd3 freebsd4 freebsd5 freebsd6 freebsd7 |
|
||||
generic irix5 irix6 linux2 mac netbsd1 next3 os2emx riscos sunos5 unixware7 |
|
||||
Investigating the python source tree may reveal more values. |
|
||||
""" |
|
||||
s = sys.platform |
|
||||
if s == 'java': |
|
||||
# The real OS is hidden under the JVM. |
|
||||
from java.lang import System |
|
||||
s = System.getProperty('os.name') |
|
||||
# see http://lopica.sourceforge.net/os.html for a list of possible values |
|
||||
if s == 'Mac OS X': |
|
||||
return 'darwin' |
|
||||
elif s.startswith('Windows '): |
|
||||
return 'win32' |
|
||||
elif s == 'OS/2': |
|
||||
return 'os2' |
|
||||
elif s == 'HP-UX': |
|
||||
return 'hpux' |
|
||||
elif s in ('SunOS', 'Solaris'): |
|
||||
return 'sunos' |
|
||||
else: s = s.lower() |
|
||||
if s == 'win32' or s.endswith('os2') and s != 'sunos2': return s |
|
||||
return re.split('\d+$', s)[0] |
|
||||
|
|
||||
#@deprecated('use unversioned_sys_platform instead') |
|
||||
def detect_platform(): |
|
||||
"""this function has been in the Utils module for some time. |
|
||||
It's hard to guess what people have used it for. |
|
||||
It seems its goal is to return an unversionned sys.platform, but it's not handling all platforms. |
|
||||
For example, the version is not removed on freebsd and netbsd, amongst others. |
|
||||
""" |
|
||||
s = sys.platform |
|
||||
|
|
||||
# known POSIX |
|
||||
for x in 'cygwin linux irix sunos hpux aix darwin'.split(): |
|
||||
# sys.platform may be linux2 |
|
||||
if s.find(x) >= 0: |
|
||||
return x |
|
||||
|
|
||||
# unknown POSIX |
|
||||
if os.name in 'posix java os2'.split(): |
|
||||
return os.name |
|
||||
|
|
||||
return s |
|
||||
|
|
||||
def load_tool(tool, tooldir=None): |
|
||||
''' |
|
||||
load_tool: import a Python module, optionally using several directories. |
|
||||
@param tool [string]: name of tool to import. |
|
||||
@param tooldir [list]: directories to look for the tool. |
|
||||
@return: the loaded module. |
|
||||
|
|
||||
Warning: this function is not thread-safe: plays with sys.path, |
|
||||
so must run in sequence. |
|
||||
''' |
|
||||
if tooldir: |
|
||||
assert isinstance(tooldir, list) |
|
||||
sys.path = tooldir + sys.path |
|
||||
try: |
|
||||
try: |
|
||||
return __import__(tool) |
|
||||
except ImportError, e: |
|
||||
Logs.error('Could not load the tool %r in %r:\n%s' % (tool, sys.path, e)) |
|
||||
raise |
|
||||
finally: |
|
||||
if tooldir: |
|
||||
sys.path = sys.path[len(tooldir):] |
|
||||
|
|
||||
def readf(fname, m='r'): |
|
||||
"get the contents of a file, it is not used anywhere for the moment" |
|
||||
f = open(fname, m) |
|
||||
try: |
|
||||
txt = f.read() |
|
||||
finally: |
|
||||
f.close() |
|
||||
return txt |
|
||||
|
|
||||
def nada(*k, **kw): |
|
||||
"""A function that does nothing""" |
|
||||
pass |
|
||||
|
|
||||
def diff_path(top, subdir): |
|
||||
"""difference between two absolute paths""" |
|
||||
top = os.path.normpath(top).replace('\\', '/').split('/') |
|
||||
subdir = os.path.normpath(subdir).replace('\\', '/').split('/') |
|
||||
if len(top) == len(subdir): return '' |
|
||||
diff = subdir[len(top) - len(subdir):] |
|
||||
return os.path.join(*diff) |
|
||||
|
|
||||
class Context(object): |
|
||||
"""A base class for commands to be executed from Waf scripts""" |
|
||||
|
|
||||
def set_curdir(self, dir): |
|
||||
self.curdir_ = dir |
|
||||
|
|
||||
def get_curdir(self): |
|
||||
try: |
|
||||
return self.curdir_ |
|
||||
except AttributeError: |
|
||||
self.curdir_ = os.getcwd() |
|
||||
return self.get_curdir() |
|
||||
|
|
||||
curdir = property(get_curdir, set_curdir) |
|
||||
|
|
||||
def recurse(self, dirs, name=''): |
|
||||
"""The function for calling scripts from folders, it tries to call wscript + function_name |
|
||||
and if that file does not exist, it will call the method 'function_name' from a file named wscript |
|
||||
the dirs can be a list of folders or a string containing space-separated folder paths |
|
||||
""" |
|
||||
if not name: |
|
||||
name = inspect.stack()[1][3] |
|
||||
|
|
||||
if isinstance(dirs, str): |
|
||||
dirs = to_list(dirs) |
|
||||
|
|
||||
for x in dirs: |
|
||||
if os.path.isabs(x): |
|
||||
nexdir = x |
|
||||
else: |
|
||||
nexdir = os.path.join(self.curdir, x) |
|
||||
|
|
||||
base = os.path.join(nexdir, WSCRIPT_FILE) |
|
||||
file_path = base + '_' + name |
|
||||
|
|
||||
try: |
|
||||
txt = readf(file_path, m='rU') |
|
||||
except (OSError, IOError): |
|
||||
try: |
|
||||
module = load_module(base) |
|
||||
except OSError: |
|
||||
raise WscriptError('No such script %s' % base) |
|
||||
|
|
||||
try: |
|
||||
f = module.__dict__[name] |
|
||||
except KeyError: |
|
||||
raise WscriptError('No function %s defined in %s' % (name, base)) |
|
||||
|
|
||||
if getattr(self.__class__, 'pre_recurse', None): |
|
||||
self.pre_recurse(f, base, nexdir) |
|
||||
old = self.curdir |
|
||||
self.curdir = nexdir |
|
||||
try: |
|
||||
f(self) |
|
||||
finally: |
|
||||
self.curdir = old |
|
||||
if getattr(self.__class__, 'post_recurse', None): |
|
||||
self.post_recurse(module, base, nexdir) |
|
||||
else: |
|
||||
dc = {'ctx': self} |
|
||||
if getattr(self.__class__, 'pre_recurse', None): |
|
||||
dc = self.pre_recurse(txt, file_path, nexdir) |
|
||||
old = self.curdir |
|
||||
self.curdir = nexdir |
|
||||
try: |
|
||||
try: |
|
||||
exec(compile(txt, file_path, 'exec'), dc) |
|
||||
except Exception: |
|
||||
exc_type, exc_value, tb = sys.exc_info() |
|
||||
raise WscriptError("".join(traceback.format_exception(exc_type, exc_value, tb)), base) |
|
||||
finally: |
|
||||
self.curdir = old |
|
||||
if getattr(self.__class__, 'post_recurse', None): |
|
||||
self.post_recurse(txt, file_path, nexdir) |
|
||||
|
|
||||
if is_win32: |
|
||||
old = shutil.copy2 |
|
||||
def copy2(src, dst): |
|
||||
old(src, dst) |
|
||||
shutil.copystat(src, src) |
|
||||
setattr(shutil, 'copy2', copy2) |
|
||||
|
|
||||
def zip_folder(dir, zip_file_name, prefix): |
|
||||
""" |
|
||||
prefix represents the app to add in the archive |
|
||||
""" |
|
||||
import zipfile |
|
||||
zip = zipfile.ZipFile(zip_file_name, 'w', compression=zipfile.ZIP_DEFLATED) |
|
||||
base = os.path.abspath(dir) |
|
||||
|
|
||||
if prefix: |
|
||||
if prefix[-1] != os.sep: |
|
||||
prefix += os.sep |
|
||||
|
|
||||
n = len(base) |
|
||||
for root, dirs, files in os.walk(base): |
|
||||
for f in files: |
|
||||
archive_name = prefix + root[n:] + os.sep + f |
|
||||
zip.write(root + os.sep + f, archive_name, zipfile.ZIP_DEFLATED) |
|
||||
zip.close() |
|
||||
|
|
||||
def get_elapsed_time(start): |
|
||||
"Format a time delta (datetime.timedelta) using the format DdHhMmS.MSs" |
|
||||
delta = datetime.datetime.now() - start |
|
||||
# cast to int necessary for python 3.0 |
|
||||
days = int(delta.days) |
|
||||
hours = int(delta.seconds / 3600) |
|
||||
minutes = int((delta.seconds - hours * 3600) / 60) |
|
||||
seconds = delta.seconds - hours * 3600 - minutes * 60 \ |
|
||||
+ float(delta.microseconds) / 1000 / 1000 |
|
||||
result = '' |
|
||||
if days: |
|
||||
result += '%dd' % days |
|
||||
if days or hours: |
|
||||
result += '%dh' % hours |
|
||||
if days or hours or minutes: |
|
||||
result += '%dm' % minutes |
|
||||
return '%s%.3fs' % (result, seconds) |
|
||||
|
|
||||
if os.name == 'java': |
|
||||
# For Jython (they should really fix the inconsistency) |
|
||||
try: |
|
||||
gc.disable() |
|
||||
gc.enable() |
|
||||
except NotImplementedError: |
|
||||
gc.disable = gc.enable |
|
||||
|
|
||||
@ -1,3 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2005 (ita) |
|
||||
@ -1,221 +0,0 @@ |
|||||
import sys, os |
|
||||
try: |
|
||||
if (not sys.stderr.isatty()) or (not sys.stdout.isatty()): |
|
||||
raise ValueError('not a tty') |
|
||||
|
|
||||
from ctypes import * |
|
||||
|
|
||||
class COORD(Structure): |
|
||||
_fields_ = [("X", c_short), ("Y", c_short)] |
|
||||
|
|
||||
class SMALL_RECT(Structure): |
|
||||
_fields_ = [("Left", c_short), ("Top", c_short), ("Right", c_short), ("Bottom", c_short)] |
|
||||
|
|
||||
class CONSOLE_SCREEN_BUFFER_INFO(Structure): |
|
||||
_fields_ = [("Size", COORD), ("CursorPosition", COORD), ("Attributes", c_short), ("Window", SMALL_RECT), ("MaximumWindowSize", COORD)] |
|
||||
|
|
||||
class CONSOLE_CURSOR_INFO(Structure): |
|
||||
_fields_ = [('dwSize',c_ulong), ('bVisible', c_int)] |
|
||||
|
|
||||
sbinfo = CONSOLE_SCREEN_BUFFER_INFO() |
|
||||
csinfo = CONSOLE_CURSOR_INFO() |
|
||||
hconsole = windll.kernel32.GetStdHandle(-11) |
|
||||
windll.kernel32.GetConsoleScreenBufferInfo(hconsole, byref(sbinfo)) |
|
||||
if sbinfo.Size.X < 10 or sbinfo.Size.Y < 10: raise Exception('small console') |
|
||||
windll.kernel32.GetConsoleCursorInfo(hconsole, byref(csinfo)) |
|
||||
except Exception: |
|
||||
pass |
|
||||
else: |
|
||||
import re, threading |
|
||||
|
|
||||
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.hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE) |
|
||||
self.cursor_history = [] |
|
||||
|
|
||||
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: # Clear from begining of line to cursor position |
|
||||
line_start = COORD(0, sbinfo.CursorPosition.Y) |
|
||||
line_length = sbinfo.Size.X |
|
||||
elif mode == 2: # Clear entire line |
|
||||
line_start = COORD(sbinfo.CursorPosition.X, sbinfo.CursorPosition.Y) |
|
||||
line_length = sbinfo.Size.X - sbinfo.CursorPosition.X |
|
||||
else: # Clear from cursor position to end of line |
|
||||
line_start = sbinfo.CursorPosition |
|
||||
line_length = sbinfo.Size.X - sbinfo.CursorPosition.X |
|
||||
chars_written = c_int() |
|
||||
windll.kernel32.FillConsoleOutputCharacterA(self.hconsole, c_char(' '), 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 from begining of screen to cursor position |
|
||||
clear_start = COORD(0, 0) |
|
||||
clear_length = sbinfo.CursorPosition.X * sbinfo.CursorPosition.Y |
|
||||
elif mode == 2: # Clear entire screen and return cursor to home |
|
||||
clear_start = COORD(0, 0) |
|
||||
clear_length = sbinfo.Size.X * sbinfo.Size.Y |
|
||||
windll.kernel32.SetConsoleCursorPosition(self.hconsole, clear_start) |
|
||||
else: # Clear from cursor position to end of screen |
|
||||
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_char(' '), 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.push(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): |
|
||||
x, sep, y = 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) |
|
||||
) |
|
||||
|
|
||||
escape_to_color = { (0, 30): 0x0, #black |
|
||||
(0, 31): 0x4, #red |
|
||||
(0, 32): 0x2, #green |
|
||||
(0, 33): 0x4+0x2, #dark yellow |
|
||||
(0, 34): 0x1, #blue |
|
||||
(0, 35): 0x1+0x4, #purple |
|
||||
(0, 36): 0x2+0x4, #cyan |
|
||||
(0, 37): 0x1+0x2+0x4, #grey |
|
||||
(1, 30): 0x1+0x2+0x4, #dark gray |
|
||||
(1, 31): 0x4+0x8, #red |
|
||||
(1, 32): 0x2+0x8, #light green |
|
||||
(1, 33): 0x4+0x2+0x8, #yellow |
|
||||
(1, 34): 0x1+0x8, #light blue |
|
||||
(1, 35): 0x1+0x4+0x8, #light purple |
|
||||
(1, 36): 0x1+0x2+0x8, #light cyan |
|
||||
(1, 37): 0x1+0x2+0x4+0x8, #white |
|
||||
} |
|
||||
|
|
||||
def set_color(self, param): |
|
||||
intensity, sep, color = param.partition(';') |
|
||||
intensity = to_int(intensity, 0) |
|
||||
color = to_int(color, 0) |
|
||||
if intensity and not color: |
|
||||
color, intensity = intensity, color |
|
||||
attrib = self.escape_to_color.get((intensity, color), 0x7) |
|
||||
windll.kernel32.SetConsoleTextAttribute(self.hconsole, attrib) |
|
||||
|
|
||||
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, |
|
||||
} |
|
||||
# Match either the escape sequence or text not containing escape sequence |
|
||||
ansi_tokans = re.compile('(?:\x1b\[([0-9?;]*)([a-zA-Z])|([^\x1b]+))') |
|
||||
def write(self, text): |
|
||||
wlock.acquire() |
|
||||
for param, cmd, txt in self.ansi_tokans.findall(text): |
|
||||
if cmd: |
|
||||
cmd_func = self.ansi_command_table.get(cmd) |
|
||||
if cmd_func: |
|
||||
cmd_func(self, param) |
|
||||
else: |
|
||||
chars_written = c_int() |
|
||||
if isinstance(txt, unicode): |
|
||||
windll.kernel32.WriteConsoleW(self.hconsole, txt, len(txt), byref(chars_written), None) |
|
||||
else: |
|
||||
windll.kernel32.WriteConsoleA(self.hconsole, txt, len(txt), byref(chars_written), None) |
|
||||
wlock.release() |
|
||||
|
|
||||
def flush(self): |
|
||||
pass |
|
||||
|
|
||||
def isatty(self): |
|
||||
return True |
|
||||
|
|
||||
sys.stderr = sys.stdout = AnsiTerm() |
|
||||
os.environ['TERM'] = 'vt100' |
|
||||
|
|
||||
@ -1,620 +0,0 @@ |
|||||
# borrowed from python 2.5.2c1 |
|
||||
# Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se> |
|
||||
# Licensed to PSF under a Contributor Agreement. |
|
||||
|
|
||||
import sys |
|
||||
mswindows = (sys.platform == "win32") |
|
||||
|
|
||||
import os |
|
||||
import types |
|
||||
import traceback |
|
||||
import gc |
|
||||
|
|
||||
class CalledProcessError(Exception): |
|
||||
def __init__(self, returncode, cmd): |
|
||||
self.returncode = returncode |
|
||||
self.cmd = cmd |
|
||||
def __str__(self): |
|
||||
return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode) |
|
||||
|
|
||||
if mswindows: |
|
||||
import threading |
|
||||
import msvcrt |
|
||||
if 0: |
|
||||
import pywintypes |
|
||||
from win32api import GetStdHandle, STD_INPUT_HANDLE, \ |
|
||||
STD_OUTPUT_HANDLE, STD_ERROR_HANDLE |
|
||||
from win32api import GetCurrentProcess, DuplicateHandle, \ |
|
||||
GetModuleFileName, GetVersion |
|
||||
from win32con import DUPLICATE_SAME_ACCESS, SW_HIDE |
|
||||
from win32pipe import CreatePipe |
|
||||
from win32process import CreateProcess, STARTUPINFO, \ |
|
||||
GetExitCodeProcess, STARTF_USESTDHANDLES, \ |
|
||||
STARTF_USESHOWWINDOW, CREATE_NEW_CONSOLE |
|
||||
from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0 |
|
||||
else: |
|
||||
from _subprocess import * |
|
||||
class STARTUPINFO: |
|
||||
dwFlags = 0 |
|
||||
hStdInput = None |
|
||||
hStdOutput = None |
|
||||
hStdError = None |
|
||||
wShowWindow = 0 |
|
||||
class pywintypes: |
|
||||
error = IOError |
|
||||
else: |
|
||||
import select |
|
||||
import errno |
|
||||
import fcntl |
|
||||
import pickle |
|
||||
|
|
||||
__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "CalledProcessError"] |
|
||||
|
|
||||
try: |
|
||||
MAXFD = os.sysconf("SC_OPEN_MAX") |
|
||||
except: |
|
||||
MAXFD = 256 |
|
||||
|
|
||||
try: |
|
||||
False |
|
||||
except NameError: |
|
||||
False = 0 |
|
||||
True = 1 |
|
||||
|
|
||||
_active = [] |
|
||||
|
|
||||
def _cleanup(): |
|
||||
for inst in _active[:]: |
|
||||
if inst.poll(_deadstate=sys.maxint) >= 0: |
|
||||
try: |
|
||||
_active.remove(inst) |
|
||||
except ValueError: |
|
||||
pass |
|
||||
|
|
||||
PIPE = -1 |
|
||||
STDOUT = -2 |
|
||||
|
|
||||
|
|
||||
def call(*popenargs, **kwargs): |
|
||||
return Popen(*popenargs, **kwargs).wait() |
|
||||
|
|
||||
def check_call(*popenargs, **kwargs): |
|
||||
retcode = call(*popenargs, **kwargs) |
|
||||
cmd = kwargs.get("args") |
|
||||
if cmd is None: |
|
||||
cmd = popenargs[0] |
|
||||
if retcode: |
|
||||
raise CalledProcessError(retcode, cmd) |
|
||||
return retcode |
|
||||
|
|
||||
|
|
||||
def list2cmdline(seq): |
|
||||
result = [] |
|
||||
needquote = False |
|
||||
for arg in seq: |
|
||||
bs_buf = [] |
|
||||
|
|
||||
if result: |
|
||||
result.append(' ') |
|
||||
|
|
||||
needquote = (" " in arg) or ("\t" in arg) or arg == "" |
|
||||
if needquote: |
|
||||
result.append('"') |
|
||||
|
|
||||
for c in arg: |
|
||||
if c == '\\': |
|
||||
bs_buf.append(c) |
|
||||
elif c == '"': |
|
||||
result.append('\\' * len(bs_buf)*2) |
|
||||
bs_buf = [] |
|
||||
result.append('\\"') |
|
||||
else: |
|
||||
if bs_buf: |
|
||||
result.extend(bs_buf) |
|
||||
bs_buf = [] |
|
||||
result.append(c) |
|
||||
|
|
||||
if bs_buf: |
|
||||
result.extend(bs_buf) |
|
||||
|
|
||||
if needquote: |
|
||||
result.extend(bs_buf) |
|
||||
result.append('"') |
|
||||
|
|
||||
return ''.join(result) |
|
||||
|
|
||||
class Popen(object): |
|
||||
def __init__(self, args, bufsize=0, executable=None, |
|
||||
stdin=None, stdout=None, stderr=None, |
|
||||
preexec_fn=None, close_fds=False, shell=False, |
|
||||
cwd=None, env=None, universal_newlines=False, |
|
||||
startupinfo=None, creationflags=0): |
|
||||
_cleanup() |
|
||||
|
|
||||
self._child_created = False |
|
||||
if not isinstance(bufsize, (int, long)): |
|
||||
raise TypeError("bufsize must be an integer") |
|
||||
|
|
||||
if mswindows: |
|
||||
if preexec_fn is not None: |
|
||||
raise ValueError("preexec_fn is not supported on Windows platforms") |
|
||||
if close_fds: |
|
||||
raise ValueError("close_fds is not supported on Windows platforms") |
|
||||
else: |
|
||||
if startupinfo is not None: |
|
||||
raise ValueError("startupinfo is only supported on Windows platforms") |
|
||||
if creationflags != 0: |
|
||||
raise ValueError("creationflags is only supported on Windows platforms") |
|
||||
|
|
||||
self.stdin = None |
|
||||
self.stdout = None |
|
||||
self.stderr = None |
|
||||
self.pid = None |
|
||||
self.returncode = None |
|
||||
self.universal_newlines = universal_newlines |
|
||||
|
|
||||
(p2cread, p2cwrite, |
|
||||
c2pread, c2pwrite, |
|
||||
errread, errwrite) = self._get_handles(stdin, stdout, stderr) |
|
||||
|
|
||||
self._execute_child(args, executable, preexec_fn, close_fds, |
|
||||
cwd, env, universal_newlines, |
|
||||
startupinfo, creationflags, shell, |
|
||||
p2cread, p2cwrite, |
|
||||
c2pread, c2pwrite, |
|
||||
errread, errwrite) |
|
||||
|
|
||||
if mswindows: |
|
||||
if stdin is None and p2cwrite is not None: |
|
||||
os.close(p2cwrite) |
|
||||
p2cwrite = None |
|
||||
if stdout is None and c2pread is not None: |
|
||||
os.close(c2pread) |
|
||||
c2pread = None |
|
||||
if stderr is None and errread is not None: |
|
||||
os.close(errread) |
|
||||
errread = None |
|
||||
|
|
||||
if p2cwrite: |
|
||||
self.stdin = os.fdopen(p2cwrite, 'wb', bufsize) |
|
||||
if c2pread: |
|
||||
if universal_newlines: |
|
||||
self.stdout = os.fdopen(c2pread, 'rU', bufsize) |
|
||||
else: |
|
||||
self.stdout = os.fdopen(c2pread, 'rb', bufsize) |
|
||||
if errread: |
|
||||
if universal_newlines: |
|
||||
self.stderr = os.fdopen(errread, 'rU', bufsize) |
|
||||
else: |
|
||||
self.stderr = os.fdopen(errread, 'rb', bufsize) |
|
||||
|
|
||||
|
|
||||
def _translate_newlines(self, data): |
|
||||
data = data.replace("\r\n", "\n") |
|
||||
data = data.replace("\r", "\n") |
|
||||
return data |
|
||||
|
|
||||
|
|
||||
def __del__(self, sys=sys): |
|
||||
if not self._child_created: |
|
||||
return |
|
||||
self.poll(_deadstate=sys.maxint) |
|
||||
if self.returncode is None and _active is not None: |
|
||||
_active.append(self) |
|
||||
|
|
||||
|
|
||||
def communicate(self, input=None): |
|
||||
if [self.stdin, self.stdout, self.stderr].count(None) >= 2: |
|
||||
stdout = None |
|
||||
stderr = None |
|
||||
if self.stdin: |
|
||||
if input: |
|
||||
self.stdin.write(input) |
|
||||
self.stdin.close() |
|
||||
elif self.stdout: |
|
||||
stdout = self.stdout.read() |
|
||||
elif self.stderr: |
|
||||
stderr = self.stderr.read() |
|
||||
self.wait() |
|
||||
return (stdout, stderr) |
|
||||
|
|
||||
return self._communicate(input) |
|
||||
|
|
||||
|
|
||||
if mswindows: |
|
||||
def _get_handles(self, stdin, stdout, stderr): |
|
||||
if stdin is None and stdout is None and stderr is None: |
|
||||
return (None, None, None, None, None, None) |
|
||||
|
|
||||
p2cread, p2cwrite = None, None |
|
||||
c2pread, c2pwrite = None, None |
|
||||
errread, errwrite = None, None |
|
||||
|
|
||||
if stdin is None: |
|
||||
p2cread = GetStdHandle(STD_INPUT_HANDLE) |
|
||||
if p2cread is not None: |
|
||||
pass |
|
||||
elif stdin is None or stdin == PIPE: |
|
||||
p2cread, p2cwrite = CreatePipe(None, 0) |
|
||||
p2cwrite = p2cwrite.Detach() |
|
||||
p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0) |
|
||||
elif isinstance(stdin, int): |
|
||||
p2cread = msvcrt.get_osfhandle(stdin) |
|
||||
else: |
|
||||
p2cread = msvcrt.get_osfhandle(stdin.fileno()) |
|
||||
p2cread = self._make_inheritable(p2cread) |
|
||||
|
|
||||
if stdout is None: |
|
||||
c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE) |
|
||||
if c2pwrite is not None: |
|
||||
pass |
|
||||
elif stdout is None or stdout == PIPE: |
|
||||
c2pread, c2pwrite = CreatePipe(None, 0) |
|
||||
c2pread = c2pread.Detach() |
|
||||
c2pread = msvcrt.open_osfhandle(c2pread, 0) |
|
||||
elif isinstance(stdout, int): |
|
||||
c2pwrite = msvcrt.get_osfhandle(stdout) |
|
||||
else: |
|
||||
c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) |
|
||||
c2pwrite = self._make_inheritable(c2pwrite) |
|
||||
|
|
||||
if stderr is None: |
|
||||
errwrite = GetStdHandle(STD_ERROR_HANDLE) |
|
||||
if errwrite is not None: |
|
||||
pass |
|
||||
elif stderr is None or stderr == PIPE: |
|
||||
errread, errwrite = CreatePipe(None, 0) |
|
||||
errread = errread.Detach() |
|
||||
errread = msvcrt.open_osfhandle(errread, 0) |
|
||||
elif stderr == STDOUT: |
|
||||
errwrite = c2pwrite |
|
||||
elif isinstance(stderr, int): |
|
||||
errwrite = msvcrt.get_osfhandle(stderr) |
|
||||
else: |
|
||||
errwrite = msvcrt.get_osfhandle(stderr.fileno()) |
|
||||
errwrite = self._make_inheritable(errwrite) |
|
||||
|
|
||||
return (p2cread, p2cwrite, |
|
||||
c2pread, c2pwrite, |
|
||||
errread, errwrite) |
|
||||
def _make_inheritable(self, handle): |
|
||||
return DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(), 0, 1, DUPLICATE_SAME_ACCESS) |
|
||||
|
|
||||
def _find_w9xpopen(self): |
|
||||
w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)), "w9xpopen.exe") |
|
||||
if not os.path.exists(w9xpopen): |
|
||||
w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), "w9xpopen.exe") |
|
||||
if not os.path.exists(w9xpopen): |
|
||||
raise RuntimeError("Cannot locate w9xpopen.exe, which is needed for Popen to work with your shell or platform.") |
|
||||
return w9xpopen |
|
||||
|
|
||||
def _execute_child(self, args, executable, preexec_fn, close_fds, |
|
||||
cwd, env, universal_newlines, |
|
||||
startupinfo, creationflags, shell, |
|
||||
p2cread, p2cwrite, |
|
||||
c2pread, c2pwrite, |
|
||||
errread, errwrite): |
|
||||
|
|
||||
if not isinstance(args, types.StringTypes): |
|
||||
args = list2cmdline(args) |
|
||||
|
|
||||
if startupinfo is None: |
|
||||
startupinfo = STARTUPINFO() |
|
||||
if None not in (p2cread, c2pwrite, errwrite): |
|
||||
startupinfo.dwFlags |= STARTF_USESTDHANDLES |
|
||||
startupinfo.hStdInput = p2cread |
|
||||
startupinfo.hStdOutput = c2pwrite |
|
||||
startupinfo.hStdError = errwrite |
|
||||
|
|
||||
if shell: |
|
||||
startupinfo.dwFlags |= STARTF_USESHOWWINDOW |
|
||||
startupinfo.wShowWindow = SW_HIDE |
|
||||
comspec = os.environ.get("COMSPEC", "cmd.exe") |
|
||||
args = comspec + " /c " + args |
|
||||
if (GetVersion() >= 0x80000000L or |
|
||||
os.path.basename(comspec).lower() == "command.com"): |
|
||||
w9xpopen = self._find_w9xpopen() |
|
||||
args = '"%s" %s' % (w9xpopen, args) |
|
||||
creationflags |= CREATE_NEW_CONSOLE |
|
||||
|
|
||||
try: |
|
||||
hp, ht, pid, tid = CreateProcess(executable, args, None, None, 1, creationflags, env, cwd, startupinfo) |
|
||||
except pywintypes.error, e: |
|
||||
raise WindowsError(*e.args) |
|
||||
|
|
||||
self._child_created = True |
|
||||
self._handle = hp |
|
||||
self.pid = pid |
|
||||
ht.Close() |
|
||||
|
|
||||
if p2cread is not None: |
|
||||
p2cread.Close() |
|
||||
if c2pwrite is not None: |
|
||||
c2pwrite.Close() |
|
||||
if errwrite is not None: |
|
||||
errwrite.Close() |
|
||||
|
|
||||
|
|
||||
def poll(self, _deadstate=None): |
|
||||
if self.returncode is None: |
|
||||
if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0: |
|
||||
self.returncode = GetExitCodeProcess(self._handle) |
|
||||
return self.returncode |
|
||||
|
|
||||
|
|
||||
def wait(self): |
|
||||
if self.returncode is None: |
|
||||
obj = WaitForSingleObject(self._handle, INFINITE) |
|
||||
self.returncode = GetExitCodeProcess(self._handle) |
|
||||
return self.returncode |
|
||||
|
|
||||
def _readerthread(self, fh, buffer): |
|
||||
buffer.append(fh.read()) |
|
||||
|
|
||||
def _communicate(self, input): |
|
||||
stdout = None |
|
||||
stderr = None |
|
||||
|
|
||||
if self.stdout: |
|
||||
stdout = [] |
|
||||
stdout_thread = threading.Thread(target=self._readerthread, args=(self.stdout, stdout)) |
|
||||
stdout_thread.setDaemon(True) |
|
||||
stdout_thread.start() |
|
||||
if self.stderr: |
|
||||
stderr = [] |
|
||||
stderr_thread = threading.Thread(target=self._readerthread, args=(self.stderr, stderr)) |
|
||||
stderr_thread.setDaemon(True) |
|
||||
stderr_thread.start() |
|
||||
|
|
||||
if self.stdin: |
|
||||
if input is not None: |
|
||||
self.stdin.write(input) |
|
||||
self.stdin.close() |
|
||||
|
|
||||
if self.stdout: |
|
||||
stdout_thread.join() |
|
||||
if self.stderr: |
|
||||
stderr_thread.join() |
|
||||
|
|
||||
if stdout is not None: |
|
||||
stdout = stdout[0] |
|
||||
if stderr is not None: |
|
||||
stderr = stderr[0] |
|
||||
|
|
||||
if self.universal_newlines and hasattr(file, 'newlines'): |
|
||||
if stdout: |
|
||||
stdout = self._translate_newlines(stdout) |
|
||||
if stderr: |
|
||||
stderr = self._translate_newlines(stderr) |
|
||||
|
|
||||
self.wait() |
|
||||
return (stdout, stderr) |
|
||||
|
|
||||
else: |
|
||||
def _get_handles(self, stdin, stdout, stderr): |
|
||||
p2cread, p2cwrite = None, None |
|
||||
c2pread, c2pwrite = None, None |
|
||||
errread, errwrite = None, None |
|
||||
|
|
||||
if stdin is None: |
|
||||
pass |
|
||||
elif stdin == PIPE: |
|
||||
p2cread, p2cwrite = os.pipe() |
|
||||
elif isinstance(stdin, int): |
|
||||
p2cread = stdin |
|
||||
else: |
|
||||
p2cread = stdin.fileno() |
|
||||
|
|
||||
if stdout is None: |
|
||||
pass |
|
||||
elif stdout == PIPE: |
|
||||
c2pread, c2pwrite = os.pipe() |
|
||||
elif isinstance(stdout, int): |
|
||||
c2pwrite = stdout |
|
||||
else: |
|
||||
c2pwrite = stdout.fileno() |
|
||||
|
|
||||
if stderr is None: |
|
||||
pass |
|
||||
elif stderr == PIPE: |
|
||||
errread, errwrite = os.pipe() |
|
||||
elif stderr == STDOUT: |
|
||||
errwrite = c2pwrite |
|
||||
elif isinstance(stderr, int): |
|
||||
errwrite = stderr |
|
||||
else: |
|
||||
errwrite = stderr.fileno() |
|
||||
|
|
||||
return (p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite) |
|
||||
|
|
||||
def _set_cloexec_flag(self, fd): |
|
||||
try: |
|
||||
cloexec_flag = fcntl.FD_CLOEXEC |
|
||||
except AttributeError: |
|
||||
cloexec_flag = 1 |
|
||||
|
|
||||
old = fcntl.fcntl(fd, fcntl.F_GETFD) |
|
||||
fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag) |
|
||||
|
|
||||
def _close_fds(self, but): |
|
||||
for i in xrange(3, MAXFD): |
|
||||
if i == but: |
|
||||
continue |
|
||||
try: |
|
||||
os.close(i) |
|
||||
except: |
|
||||
pass |
|
||||
|
|
||||
def _execute_child(self, args, executable, preexec_fn, close_fds, |
|
||||
cwd, env, universal_newlines, startupinfo, creationflags, shell, |
|
||||
p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite): |
|
||||
|
|
||||
if isinstance(args, types.StringTypes): |
|
||||
args = [args] |
|
||||
else: |
|
||||
args = list(args) |
|
||||
|
|
||||
if shell: |
|
||||
args = ["/bin/sh", "-c"] + args |
|
||||
|
|
||||
if executable is None: |
|
||||
executable = args[0] |
|
||||
|
|
||||
errpipe_read, errpipe_write = os.pipe() |
|
||||
self._set_cloexec_flag(errpipe_write) |
|
||||
|
|
||||
gc_was_enabled = gc.isenabled() |
|
||||
gc.disable() |
|
||||
try: |
|
||||
self.pid = os.fork() |
|
||||
except: |
|
||||
if gc_was_enabled: |
|
||||
gc.enable() |
|
||||
raise |
|
||||
self._child_created = True |
|
||||
if self.pid == 0: |
|
||||
try: |
|
||||
if p2cwrite: |
|
||||
os.close(p2cwrite) |
|
||||
if c2pread: |
|
||||
os.close(c2pread) |
|
||||
if errread: |
|
||||
os.close(errread) |
|
||||
os.close(errpipe_read) |
|
||||
|
|
||||
if p2cread: |
|
||||
os.dup2(p2cread, 0) |
|
||||
if c2pwrite: |
|
||||
os.dup2(c2pwrite, 1) |
|
||||
if errwrite: |
|
||||
os.dup2(errwrite, 2) |
|
||||
|
|
||||
if p2cread and p2cread not in (0,): |
|
||||
os.close(p2cread) |
|
||||
if c2pwrite and c2pwrite not in (p2cread, 1): |
|
||||
os.close(c2pwrite) |
|
||||
if errwrite and errwrite not in (p2cread, c2pwrite, 2): |
|
||||
os.close(errwrite) |
|
||||
|
|
||||
if close_fds: |
|
||||
self._close_fds(but=errpipe_write) |
|
||||
|
|
||||
if cwd is not None: |
|
||||
os.chdir(cwd) |
|
||||
|
|
||||
if preexec_fn: |
|
||||
apply(preexec_fn) |
|
||||
|
|
||||
if env is None: |
|
||||
os.execvp(executable, args) |
|
||||
else: |
|
||||
os.execvpe(executable, args, env) |
|
||||
|
|
||||
except: |
|
||||
exc_type, exc_value, tb = sys.exc_info() |
|
||||
exc_lines = traceback.format_exception(exc_type, exc_value, tb) |
|
||||
exc_value.child_traceback = ''.join(exc_lines) |
|
||||
os.write(errpipe_write, pickle.dumps(exc_value)) |
|
||||
|
|
||||
os._exit(255) |
|
||||
|
|
||||
if gc_was_enabled: |
|
||||
gc.enable() |
|
||||
os.close(errpipe_write) |
|
||||
if p2cread and p2cwrite: |
|
||||
os.close(p2cread) |
|
||||
if c2pwrite and c2pread: |
|
||||
os.close(c2pwrite) |
|
||||
if errwrite and errread: |
|
||||
os.close(errwrite) |
|
||||
|
|
||||
data = os.read(errpipe_read, 1048576) |
|
||||
os.close(errpipe_read) |
|
||||
if data != "": |
|
||||
os.waitpid(self.pid, 0) |
|
||||
child_exception = pickle.loads(data) |
|
||||
raise child_exception |
|
||||
|
|
||||
def _handle_exitstatus(self, sts): |
|
||||
if os.WIFSIGNALED(sts): |
|
||||
self.returncode = -os.WTERMSIG(sts) |
|
||||
elif os.WIFEXITED(sts): |
|
||||
self.returncode = os.WEXITSTATUS(sts) |
|
||||
else: |
|
||||
raise RuntimeError("Unknown child exit status!") |
|
||||
|
|
||||
def poll(self, _deadstate=None): |
|
||||
if self.returncode is None: |
|
||||
try: |
|
||||
pid, sts = os.waitpid(self.pid, os.WNOHANG) |
|
||||
if pid == self.pid: |
|
||||
self._handle_exitstatus(sts) |
|
||||
except os.error: |
|
||||
if _deadstate is not None: |
|
||||
self.returncode = _deadstate |
|
||||
return self.returncode |
|
||||
|
|
||||
def wait(self): |
|
||||
if self.returncode is None: |
|
||||
pid, sts = os.waitpid(self.pid, 0) |
|
||||
self._handle_exitstatus(sts) |
|
||||
return self.returncode |
|
||||
|
|
||||
def _communicate(self, input): |
|
||||
read_set = [] |
|
||||
write_set = [] |
|
||||
stdout = None |
|
||||
stderr = None |
|
||||
|
|
||||
if self.stdin: |
|
||||
self.stdin.flush() |
|
||||
if input: |
|
||||
write_set.append(self.stdin) |
|
||||
else: |
|
||||
self.stdin.close() |
|
||||
if self.stdout: |
|
||||
read_set.append(self.stdout) |
|
||||
stdout = [] |
|
||||
if self.stderr: |
|
||||
read_set.append(self.stderr) |
|
||||
stderr = [] |
|
||||
|
|
||||
input_offset = 0 |
|
||||
while read_set or write_set: |
|
||||
rlist, wlist, xlist = select.select(read_set, write_set, []) |
|
||||
|
|
||||
if self.stdin in wlist: |
|
||||
bytes_written = os.write(self.stdin.fileno(), buffer(input, input_offset, 512)) |
|
||||
input_offset += bytes_written |
|
||||
if input_offset >= len(input): |
|
||||
self.stdin.close() |
|
||||
write_set.remove(self.stdin) |
|
||||
|
|
||||
if self.stdout in rlist: |
|
||||
data = os.read(self.stdout.fileno(), 1024) |
|
||||
if data == "": |
|
||||
self.stdout.close() |
|
||||
read_set.remove(self.stdout) |
|
||||
stdout.append(data) |
|
||||
|
|
||||
if self.stderr in rlist: |
|
||||
data = os.read(self.stderr.fileno(), 1024) |
|
||||
if data == "": |
|
||||
self.stderr.close() |
|
||||
read_set.remove(self.stderr) |
|
||||
stderr.append(data) |
|
||||
|
|
||||
if stdout is not None: |
|
||||
stdout = ''.join(stdout) |
|
||||
if stderr is not None: |
|
||||
stderr = ''.join(stderr) |
|
||||
|
|
||||
if self.universal_newlines and hasattr(file, 'newlines'): |
|
||||
if stdout: |
|
||||
stdout = self._translate_newlines(stdout) |
|
||||
if stderr: |
|
||||
stderr = self._translate_newlines(stderr) |
|
||||
|
|
||||
self.wait() |
|
||||
return (stdout, stderr) |
|
||||
|
|
||||
@ -1,122 +0,0 @@ |
|||||
#!/usr/bin/env python |
|
||||
# encoding: utf-8 |
|
||||
# Thomas Nagy, 2009 (ita) |
|
||||
|
|
||||
""" |
|
||||
Fixes for py3k go here |
|
||||
""" |
|
||||
|
|
||||
import os |
|
||||
|
|
||||
all_modifs = {} |
|
||||
|
|
||||
def modif(dir, name, fun): |
|
||||
if name == '*': |
|
||||
lst = [] |
|
||||
for y in '. Tools 3rdparty'.split(): |
|
||||
for x in os.listdir(os.path.join(dir, y)): |
|
||||
if x.endswith('.py'): |
|
||||
lst.append(y + os.sep + x) |
|
||||
#lst = [y + os.sep + x for x in os.listdir(os.path.join(dir, y)) for y in '. Tools 3rdparty'.split() if x.endswith('.py')] |
|
||||
for x in lst: |
|
||||
modif(dir, x, fun) |
|
||||
return |
|
||||
|
|
||||
filename = os.path.join(dir, name) |
|
||||
f = open(filename, 'r') |
|
||||
txt = f.read() |
|
||||
f.close() |
|
||||
|
|
||||
txt = fun(txt) |
|
||||
|
|
||||
f = open(filename, 'w') |
|
||||
f.write(txt) |
|
||||
f.close() |
|
||||
|
|
||||
def subst(filename): |
|
||||
def do_subst(fun): |
|
||||
global all_modifs |
|
||||
try: |
|
||||
all_modifs[filename] += fun |
|
||||
except KeyError: |
|
||||
all_modifs[filename] = [fun] |
|
||||
return fun |
|
||||
return do_subst |
|
||||
|
|
||||
@subst('Constants.py') |
|
||||
def r1(code): |
|
||||
code = code.replace("'iluvcuteoverload'", "b'iluvcuteoverload'") |
|
||||
code = code.replace("ABI=7", "ABI=37") |
|
||||
return code |
|
||||
|
|
||||
@subst('Tools/ccroot.py') |
|
||||
def r2(code): |
|
||||
code = code.replace("p.stdin.write('\\n')", "p.stdin.write(b'\\n')") |
|
||||
code = code.replace('p.communicate()[0]', 'p.communicate()[0].decode("utf-8")') |
|
||||
return code |
|
||||
|
|
||||
@subst('Utils.py') |
|
||||
def r3(code): |
|
||||
code = code.replace("m.update(str(lst))", "m.update(str(lst).encode())") |
|
||||
code = code.replace('p.communicate()[0]', 'p.communicate()[0].decode("utf-8")') |
|
||||
return code |
|
||||
|
|
||||
@subst('ansiterm.py') |
|
||||
def r33(code): |
|
||||
code = code.replace('unicode', 'str') |
|
||||
return code |
|
||||
|
|
||||
@subst('Task.py') |
|
||||
def r4(code): |
|
||||
code = code.replace("up(self.__class__.__name__)", "up(self.__class__.__name__.encode())") |
|
||||
code = code.replace("up(self.env.variant())", "up(self.env.variant().encode())") |
|
||||
code = code.replace("up(x.parent.abspath())", "up(x.parent.abspath().encode())") |
|
||||
code = code.replace("up(x.name)", "up(x.name.encode())") |
|
||||
code = code.replace('class TaskBase(object):\n\t__metaclass__=store_task_type', 'import binascii\n\nclass TaskBase(object, metaclass=store_task_type):') |
|
||||
code = code.replace('keys=self.cstr_groups.keys()', 'keys=list(self.cstr_groups.keys())') |
|
||||
code = code.replace("sig.encode('hex')", 'binascii.hexlify(sig)') |
|
||||
return code |
|
||||
|
|
||||
@subst('Build.py') |
|
||||
def r5(code): |
|
||||
code = code.replace("cPickle.dump(data,file,-1)", "cPickle.dump(data,file)") |
|
||||
code = code.replace('for node in src_dir_node.childs.values():', 'for node in list(src_dir_node.childs.values()):') |
|
||||
return code |
|
||||
|
|
||||
@subst('*') |
|
||||
def r6(code): |
|
||||
code = code.replace('xrange', 'range') |
|
||||
code = code.replace('iteritems', 'items') |
|
||||
code = code.replace('maxint', 'maxsize') |
|
||||
code = code.replace('iterkeys', 'keys') |
|
||||
code = code.replace('Error,e:', 'Error as e:') |
|
||||
code = code.replace('Exception,e:', 'Exception as e:') |
|
||||
return code |
|
||||
|
|
||||
@subst('TaskGen.py') |
|
||||
def r7(code): |
|
||||
code = code.replace('class task_gen(object):\n\t__metaclass__=register_obj', 'class task_gen(object, metaclass=register_obj):') |
|
||||
return code |
|
||||
|
|
||||
@subst('Tools/python.py') |
|
||||
def r8(code): |
|
||||
code = code.replace('proc.communicate()[0]', 'proc.communicate()[0].decode("utf-8")') |
|
||||
return code |
|
||||
|
|
||||
@subst('Tools/glib2.py') |
|
||||
def r9(code): |
|
||||
code = code.replace('f.write(c)', 'f.write(c.encode("utf-8"))') |
|
||||
return code |
|
||||
|
|
||||
@subst('Tools/config_c.py') |
|
||||
def r10(code): |
|
||||
code = code.replace("key=kw['success']", "key=kw['success']\n\t\t\t\ttry:\n\t\t\t\t\tkey=key.decode('utf-8')\n\t\t\t\texcept:\n\t\t\t\t\tpass") |
|
||||
return code |
|
||||
|
|
||||
def fixdir(dir): |
|
||||
global all_modifs |
|
||||
for k in all_modifs: |
|
||||
for v in all_modifs[k]: |
|
||||
modif(os.path.join(dir, 'wafadmin'), k, v) |
|
||||
#print('substitutions finished') |
|
||||
|
|
||||
Loading…
Reference in new issue