#!/usr/bin/env python
-# encoding: ISO-8859-1
-# Thomas Nagy, 2005-2010
+# encoding: ISO8859-1
+# Thomas Nagy, 2005-2015
"""
Redistribution and use in source and binary forms, with or without
POSSIBILITY OF SUCH DAMAGE.
"""
-import os, sys
-if sys.hexversion<0x203000f: raise ImportError("Waf requires Python >= 2.3")
+import os, sys, inspect
-if 'PSYCOWAF' in os.environ:
- try:import psyco;psyco.full()
- except:pass
-
-VERSION="1.5.19"
+VERSION="1.9.10"
REVISION="x"
-INSTALL="x"
-C1='x'
-C2='x'
+GIT="x"
+INSTALL=''
+C1='#>'
+C2='#6'
+C3='#4'
cwd = os.getcwd()
join = os.path.join
+
WAF='waf'
def b(x):
return x
-
if sys.hexversion>0x300000f:
WAF='waf3'
def b(x):
print(('\033[91mError: %s\033[0m' % m))
sys.exit(1)
-def test(dir):
- try: os.stat(join(dir, 'wafadmin')); return os.path.abspath(dir)
+def unpack_wafdir(dir, src):
+ f = open(src,'rb')
+ c = 'corrupt archive (%d)'
+ while 1:
+ line = f.readline()
+ if not line: err('run waf-light from a folder containing waflib')
+ if line == b('#==>\n'):
+ txt = f.readline()
+ if not txt: err(c % 1)
+ if f.readline() != b('#<==\n'): err(c % 2)
+ break
+ if not txt: err(c % 3)
+ txt = txt[1:-1].replace(b(C1), b('\n')).replace(b(C2), b('\r')).replace(b(C3), b('\x00'))
+
+ import shutil, tarfile
+ try: shutil.rmtree(dir)
except OSError: pass
+ try:
+ for x in ('Tools', 'extras'):
+ os.makedirs(join(dir, 'waflib', x))
+ except OSError:
+ err("Cannot unpack waf lib into %s\nMove waf in a writable directory" % dir)
+
+ os.chdir(dir)
+ tmp = 't.bz2'
+ t = open(tmp,'wb')
+ try: t.write(txt)
+ finally: t.close()
+
+ try:
+ t = tarfile.open(tmp)
+ except:
+ try:
+ os.system('bunzip2 t.bz2')
+ t = tarfile.open('t')
+ tmp = 't'
+ except:
+ os.chdir(cwd)
+ try: shutil.rmtree(dir)
+ except OSError: pass
+ err("Waf cannot be unpacked, check that bzip2 support is present")
+
+ try:
+ for x in t: t.extract(x)
+ finally:
+ t.close()
+
+ for x in ('Tools', 'extras'):
+ os.chmod(join('waflib',x), 493)
+
+ if sys.hexversion<0x300000f:
+ sys.path = [join(dir, 'waflib')] + sys.path
+ import fixpy2
+ fixpy2.fixdir(dir)
+
+ os.remove(tmp)
+ os.chdir(cwd)
+
+ try: dir = unicode(dir, 'mbcs')
+ except: pass
+ try:
+ from ctypes import windll
+ windll.kernel32.SetFileAttributesW(dir, 2)
+ except:
+ pass
+
+def test(dir):
+ try:
+ os.stat(join(dir, 'waflib'))
+ return os.path.abspath(dir)
+ except OSError:
+ pass
def find_lib():
return os.path.abspath(os.path.join(os.path.dirname(__file__), '../../third_party/waf'))
wafdir = find_lib()
-w = join(wafdir, 'wafadmin')
-t = join(w, 'Tools')
-f = join(w, '3rdparty')
-sys.path = [w, t, f] + sys.path
+sys.path.insert(0, wafdir)
if __name__ == '__main__':
- import Scripting
- Scripting.prepare(t, cwd, VERSION, wafdir)
+
+ # TODO: remove these when possible
+ from waflib.extras import compat15
+ import sys
+
+ from waflib.Tools import ccroot, c, ar, compiler_c, gcc
+ sys.modules['cc'] = c
+ sys.modules['ccroot'] = ccroot
+ sys.modules['ar'] = ar
+ sys.modules['compiler_cc'] = compiler_c
+ sys.modules['gcc'] = gcc
+
+ from waflib import Options
+ Options.lockfile = os.environ.get('WAFLOCK', '.lock-wscript')
+ if os.path.isfile(Options.lockfile) and os.stat(Options.lockfile).st_size == 0:
+ os.environ['NOCLIMB'] = "1"
+ # there is a single top-level, but libraries must build independently
+ os.environ['NO_LOCK_IN_TOP'] = "1"
+
+ from waflib import Task
+ class o(object):
+ display = None
+ Task.classes['cc_link'] = o
+
+ from waflib import Scripting
+ Scripting.waf_entry_point(cwd, VERSION, wafdir)
'''define a config option'''
conf.define(d, v, quote=quote)
if add_to_cflags:
- conf.env.append_value('CCDEFINES', d + '=' + str(v))
+ conf.env.append_value('CFLAGS', '-D%s=%s' % (d, str(v)))
def hlist_to_string(conf, headers=None):
'''convert a headers list to a set of #include lines'''
ret = conf.check(fragment='%s\nint main(void) { return 0; }' % hdrs,
type='nolink',
execute=0,
- ccflags=ccflags,
+ cflags=ccflags,
mandatory=False,
includes=cpppath,
uselib=lib.upper(),
else:
execute = 0
- defs = conf.get_config_header()
-
if addmain:
- fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
+ fragment='%s\n int main(void) { %s; return 0; }\n' % (hdrs, code)
else:
- fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
+ fragment='%s\n%s\n' % (hdrs, code)
if msg is None:
msg="Checking for %s" % define
conf.COMPOUND_START(msg)
- ret = conf.check(fragment=fragment,
+ try:
+ ret = conf.check(fragment=fragment,
execute=execute,
define_name = define,
- mandatory = mandatory,
- ccflags=cflags,
+ cflags=cflags,
ldflags=ldflags,
includes=includes,
uselib=uselib,
quote=quote,
exec_args=exec_args,
define_ret=define_ret)
- if not ret and CONFIG_SET(conf, define):
- # sometimes conf.check() returns false, but it
- # sets the define. Maybe a waf bug?
- ret = True
- if ret:
+ except Exception:
+ if always:
+ conf.DEFINE(define, 0)
+ conf.COMPOUND_END(False)
+ if mandatory:
+ raise
+ return False
+ else:
+ # success
if not define_ret:
conf.DEFINE(define, 1)
conf.COMPOUND_END(True)
else:
- conf.COMPOUND_END(conf.env[define])
+ conf.DEFINE(define, ret, quote=quote)
+ conf.COMPOUND_END(ret)
return True
- if always:
- conf.DEFINE(define, 0)
- conf.COMPOUND_END(False)
- return False
-
@conf
check_cflags.extend(conf.env['WERROR_CFLAGS'])
return conf.check(fragment=fragment,
execute=0,
+ mandatory=False,
type='nolink',
ccflags=check_cflags,
msg="Checking compiler accepts %s" % cflags)
# note that we do not add the -I and -L in here, as that is added by the waf
# core. Adding it here would just change the order that it is put on the link line
# which can cause system paths to be added before internal libraries
- extra_ccflags = TO_LIST(getattr(self.env, 'CCFLAGS_%s' % lib.upper(), []))
+ extra_ccflags = TO_LIST(getattr(self.env, 'CFLAGS_%s' % lib.upper(), []))
extra_ldflags = TO_LIST(getattr(self.env, 'LDFLAGS_%s' % lib.upper(), []))
extra_cpppath = TO_LIST(getattr(self.env, 'CPPPATH_%s' % lib.upper(), []))
ccflags.extend(extra_ccflags)
ldflags.extend(extra_ldflags)
cpppath.extend(extra_cpppath)
+
+ extra_cpppath = TO_LIST(getattr(self.env, 'INCLUDES_%s' % lib.upper(), []))
+ cpppath.extend(extra_cpppath)
if 'EXTRA_LDFLAGS' in self.env:
ldflags.extend(self.env['EXTRA_LDFLAGS'])
(ccflags, ldflags, cpppath) = library_flags(conf, lib)
if shlib:
- res = conf.check(features='c cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper(), mandatory=False)
+ res = conf.check(features='c cshlib', fragment=fragment, lib=lib, uselib_store=lib, cflags=ccflags, ldflags=ldflags, uselib=lib.upper(), mandatory=False)
else:
- res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper(), mandatory=False)
+ res = conf.check(lib=lib, uselib_store=lib, cflags=ccflags, ldflags=ldflags, uselib=lib.upper(), mandatory=False)
if not res:
if mandatory:
conf.env['EXTRA_LDFLAGS'].extend(conf.env['ADDITIONAL_LDFLAGS'])
if path is None:
- conf.write_config_header('config.h', top=True)
+ conf.write_config_header('default/config.h', top=True, remove=False)
else:
- conf.write_config_header(path)
+ conf.write_config_header(os.path.join(conf.variant, path), remove=False)
+ for key in conf.env.define_key:
+ conf.undefine(key, from_env=False)
+ conf.env.define_key = []
conf.SAMBA_CROSS_CHECK_COMPLETE()
if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']
-@conf
-def CHECK_CFG(self, *k, **kw):
- return self.check_cfg(*k, **kw)
target = header,
update_outputs=True,
ext_out='.c',
- before ='cc',
+ before ='c',
rule = '${PERL} "${SCRIPT}/mkproto.pl" --srcdir=.. --builddir=. --public=/dev/null --private="${TGT}" ${SRC}'
)
t.env.SCRIPT = os.path.join(bld.srcnode.abspath(), 'source4/script')
def add_option(self, *k, **kw):
'''syntax help: provide the "match" attribute to opt.add_option() so that folders can be added to specific config tests'''
+ Options.parser = self
match = kw.get('match', [])
if match:
del kw['match']
return False
s='http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
- conf.CHECK_COMMAND('%s --nonet %s 2> /dev/null' % (conf.env.XSLTPROC, s),
+ conf.CHECK_COMMAND('%s --nonet %s 2> /dev/null' % (conf.env.get_flat('XSLTPROC'), s),
msg='Checking for stylesheet %s' % s,
define='XSLTPROC_MANPAGES', on_target=False,
boolean=True)
# extra link flags from pkg_config
libs = self.final_syslibs.copy()
- (ccflags, ldflags, cpppath) = library_flags(self, list(libs))
+ (cflags, ldflags, cpppath) = library_flags(self, list(libs))
new_ldflags = getattr(self, 'samba_ldflags', [])[:]
new_ldflags.extend(ldflags)
self.ldflags = new_ldflags
self.sname, self.uselib, self.uselib_local, self.add_objects)
if self.samba_type in ['SUBSYSTEM']:
- # this is needed for the ccflags of libs that come from pkg_config
+ # this is needed for the cflags of libs that come from pkg_config
self.uselib = list(self.final_syslibs)
self.uselib.extend(list(self.direct_syslibs))
for lib in self.final_libs:
if sentinel == 'NULL':
proto = "extern void __%s_dummy_module_proto(void)" % (sname)
cflags.append('-DSTATIC_%s_MODULES_PROTO=%s' % (sname, proto))
- self.ccflags = cflags
+ self.cflags = cflags
return
for m in modules:
proto += '_MODULE_PROTO(%s)' % f
proto += "extern void __%s_dummy_module_proto(void)" % (m)
cflags.append('-DSTATIC_%s_MODULES_PROTO=%s' % (m, proto))
- self.ccflags = cflags
+ self.cflags = cflags
def check_duplicate_sources(bld, tgt_list):
tpath = os.path.normpath(os_path_relpath(t.path.abspath(bld.env), t.env.BUILD_DIRECTORY + '/default'))
obj_sources = set()
for s in source_list:
+ if not isinstance(s, str):
+ print('strange path in check_duplicate_sources %r' % s)
+ s = s.abspath()
p = os.path.normpath(os.path.join(tpath, s))
if p in obj_sources:
Logs.error("ERROR: source %s appears twice in target '%s'" % (p, t.sname))
t.samba_abspath = t.path.abspath(bld.env)
t.samba_deps_extended = t.samba_deps[:]
t.samba_includes_extended = TO_LIST(t.samba_includes)[:]
- t.ccflags = getattr(t, 'samba_cflags', '')
+ t.cflags = getattr(t, 'samba_cflags', '')
def replace_grouping_libraries(bld, tgt_list):
'''replace dependencies based on grouping libraries
'source', 'grouping_library', 'samba_ldflags', 'allow_undefined_symbols',
'use_global_deps', 'global_include' ]
savedeps_outputs = ['uselib', 'uselib_local', 'add_objects', 'includes',
- 'ccflags', 'ldflags', 'samba_deps_extended', 'final_libs']
+ 'cflags', 'ldflags', 'samba_deps_extended', 'final_libs']
savedeps_outenv = ['INC_PATHS']
savedeps_envvars = ['NONSHARED_BINARIES', 'GLOBAL_DEPENDENCIES', 'EXTRA_CFLAGS', 'EXTRA_LDFLAGS', 'EXTRA_INCLUDES' ]
savedeps_caches = ['GLOBAL_DEPENDENCIES', 'TARGET_TYPE', 'INIT_FUNCTIONS', 'SYSLIB_DEPS']
def find_git(env=None):
"""Find the git binary."""
if env is not None and 'GIT' in env:
- return env['GIT']
+ return env.get_flat('GIT')
# Get version from GIT
if os.path.exists("/usr/bin/git"):
# tell waf to install the right binary
bld.install_as(os.path.join(install_path, orig_target),
- os.path.join(self.path.abspath(bld.env), self.target),
+ self.path.find_or_declare(self.target),
chmod=MODE_755)
# tell waf to install the library
bld.install_as(os.path.join(install_path, install_name),
- os.path.join(self.path.abspath(bld.env), inst_name),
+ self.path.find_or_declare(inst_name),
chmod=MODE_755)
+
if install_link and install_link != install_name:
# and the symlink if needed
bld.symlink_as(os.path.join(install_path, install_link), os.path.basename(install_name))
+++ /dev/null
-# This file contains waf optimisations for Samba
-
-# most of these optimisations are possible because of the restricted build environment
-# that Samba has. For example, Samba doesn't attempt to cope with Win32 paths during the
-# build, and Samba doesn't need build varients
-
-# overall this makes some build tasks quite a bit faster
-
-import os
-import Build, Utils, Node
-from TaskGen import feature, after, before
-import preproc
-
-@feature('c', 'cc', 'cxx')
-@after('apply_type_vars', 'apply_lib_vars', 'apply_core')
-def apply_incpaths(self):
- lst = []
-
- try:
- kak = self.bld.kak
- except AttributeError:
- kak = self.bld.kak = {}
-
- # 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 path[0] != '/': # os.path.isabs(path):
- lst.append(path)
- else:
- self.env.prepend_value('CPPPATH', path)
-
- for path in lst:
- node = None
- if path[0] == '/': # 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:
- try:
- node = kak[path]
- except KeyError:
- kak[path] = node = node.find_dir(path[1:])
- else:
- try:
- node = kak[(self.path.id, path)]
- except KeyError:
- kak[(self.path.id, path)] = node = self.path.find_dir(path)
-
- if node:
- self.env.append_value('INC_PATHS', node)
-
-@feature('c', 'cc')
-@after('apply_incpaths')
-def apply_obj_vars_cc(self):
- """after apply_incpaths for INC_PATHS"""
- env = self.env
- app = env.append_unique
- cpppath_st = env['CPPPATH_ST']
-
- lss = env['_CCINCFLAGS']
-
- try:
- cac = self.bld.cac
- except AttributeError:
- cac = self.bld.cac = {}
-
- # local flags come first
- # set the user-defined includes paths
- for i in env['INC_PATHS']:
-
- try:
- lss.extend(cac[i.id])
- except KeyError:
-
- cac[i.id] = [cpppath_st % i.bldpath(env), cpppath_st % i.srcpath(env)]
- lss.extend(cac[i.id])
-
- env['_CCINCFLAGS'] = lss
- # set the library include paths
- for i in env['CPPPATH']:
- app('_CCINCFLAGS', cpppath_st % i)
-
-import Node, Environment
-
-def vari(self):
- return "default"
-Environment.Environment.variant = vari
-
-def variant(self, env):
- if not env: return 0
- elif self.id & 3 == Node.FILE: return 0
- else: return "default"
-Node.Node.variant = variant
-
-
-import TaskGen, Task
-
-def create_task(self, name, src=None, tgt=None):
- task = Task.TaskBase.classes[name](self.env, generator=self)
- if src:
- task.set_inputs(src)
- if tgt:
- task.set_outputs(tgt)
- return task
-TaskGen.task_gen.create_task = create_task
-
-def hash_constraints(self):
- a = self.attr
- sum = hash((str(a('before', '')),
- str(a('after', '')),
- str(a('ext_in', '')),
- str(a('ext_out', '')),
- self.__class__.maxjobs))
- return sum
-Task.TaskBase.hash_constraints = hash_constraints
-
-def hash_env_vars(self, env, vars_lst):
- idx = str(id(env)) + str(vars_lst)
- try:
- return self.cache_sig_vars[idx]
- except KeyError:
- pass
-
- m = Utils.md5()
- m.update(''.join([str(env[a]) for a in vars_lst]))
-
- ret = self.cache_sig_vars[idx] = m.digest()
- return ret
-Build.BuildContext.hash_env_vars = hash_env_vars
-
-
-def store_fast(self, filename):
- file = open(filename, 'wb')
- data = self.get_merged_dict()
- try:
- Build.cPickle.dump(data, file, -1)
- finally:
- file.close()
-Environment.Environment.store_fast = store_fast
-
-def load_fast(self, filename):
- file = open(filename, 'rb')
- try:
- data = Build.cPickle.load(file)
- finally:
- file.close()
- self.table.update(data)
-Environment.Environment.load_fast = load_fast
-
-def is_this_a_static_lib(self, name):
- try:
- cache = self.cache_is_this_a_static_lib
- except AttributeError:
- cache = self.cache_is_this_a_static_lib = {}
- try:
- return cache[name]
- except KeyError:
- ret = cache[name] = 'cstaticlib' in self.bld.get_tgen_by_name(name).features
- return ret
-TaskGen.task_gen.is_this_a_static_lib = is_this_a_static_lib
-
-def shared_ancestors(self):
- try:
- cache = self.cache_is_this_a_static_lib
- except AttributeError:
- cache = self.cache_is_this_a_static_lib = {}
- try:
- return cache[id(self)]
- except KeyError:
-
- ret = []
- if 'cshlib' in self.features: # or 'cprogram' in self.features:
- if getattr(self, 'uselib_local', None):
- lst = self.to_list(self.uselib_local)
- ret = [x for x in lst if not self.is_this_a_static_lib(x)]
- cache[id(self)] = ret
- return ret
-TaskGen.task_gen.shared_ancestors = shared_ancestors
-
-@feature('c', 'cc', 'cxx')
-@after('apply_link', 'init_cc', 'init_cxx', 'apply_core')
-def apply_lib_vars(self):
- """after apply_link because of 'link_task'
- after default_cc because of the attribute 'uselib'"""
-
- # after 'apply_core' in case if 'cc' if there is no link
-
- env = self.env
- app = env.append_value
- seen_libpaths = set([])
-
- # OPTIMIZATION 1: skip uselib variables already added (700ms)
- seen_uselib = set([])
-
- # 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.get_tgen_by_name(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)
-
- # OPTIMIZATION 2: pre-compute ancestors shared libraries (100ms)
- tmp.extend(y.shared_ancestors())
-
- # link task and flags
- if getattr(y, 'link_task', None):
-
- link_name = y.target[y.target.rfind('/') + 1:]
- if 'cstaticlib' in y.features:
- app('STATICLIB', link_name)
- elif 'cshlib' in y.features or 'cprogram' in y.features:
- # WARNING some linkers can link against programs
- app('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
-
- # OPTIMIZATION 3: reduce the amount of function calls
- # add the link path too
- par = y.link_task.outputs[0].parent
- if id(par) not in seen_libpaths:
- seen_libpaths.add(id(par))
- tmp_path = par.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 v not in seen_uselib:
- seen_uselib.add(v)
- if not env['STATICLIB_' + v]:
- if not v in self.uselib:
- self.uselib.insert(0, v)
-
- # 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)
-
-
conf.check_perl_version(version)
def read_perl_config_var(cmd):
- return Utils.to_list(Utils.cmd_output([conf.env.PERL, '-MConfig', '-e', cmd]))
+ return Utils.to_list(Utils.cmd_output([conf.env.get_flat('PERL'), '-MConfig', '-e', cmd]))
def check_perl_config_var(var):
conf.start_msg("Checking for perl $Config{%s}:" % var)
# waf build tool for building IDL files with pidl
import os
-import Build
+import Build, Utils
from TaskGen import feature, before
from samba_utils import SET_TARGET_TYPE, TO_LIST, LOCAL_CACHE
t = bld(rule='cd .. && %s %s ${PERL} "${PIDL}" --quiet ${OPTIONS} --outputdir ${OUTPUTDIR} -- "${SRC[0].abspath(env)}"' % (cpp, cc),
ext_out = '.c',
- before = 'cc',
+ before = 'c',
update_outputs = True,
shell = True,
source = source,
t.env.PIDL = os.path.join(bld.srcnode.abspath(), 'pidl/pidl')
t.env.OPTIONS = TO_LIST(options)
- t.env.OUTPUTDIR = bld.bldnode.name + '/' + bld.path.find_dir(output_dir).bldpath(t.env)
+ t.env.OUTPUTDIR = bld.bldnode.parent.name + '/default/' + bld.path.find_dir(output_dir).path_from(bld.srcnode)
if generate_tables and table_header_idx is not None:
pidl_headers = LOCAL_CACHE(bld, 'PIDL_HEADERS')
@before('exec_rule')
def collect(self):
pidl_headers = LOCAL_CACHE(self.bld, 'PIDL_HEADERS')
+ self.source = Utils.to_list(self.source)
for (name, hd) in pidl_headers.items():
y = self.bld.get_tgen_by_name(name)
self.bld.ASSERT(y is not None, 'Failed to find PIDL header %s' % name)
y.post()
for node in hd:
self.bld.ASSERT(node is not None, 'Got None as build node generating PIDL table for %s' % name)
- self.source += " " + node.relpath_gen(self.path)
+ self.source.append(node)
def SAMBA_PIDL_TABLES(bld, name, target):
features = 'collect',
rule = '${PERL} ${SRC} --output ${TGT} | sed "s|default/||" > ${TGT}',
ext_out = '.c',
- before = 'cc',
+ before = 'c',
update_outputs = True,
shell = True,
source = '../../librpc/tables.pl',
conf.msg("python headers", "Check disabled due to --disable-python")
# we don't want PYTHONDIR in config.h, as otherwise changing
# --prefix causes a complete rebuild
- del(conf.env.defines['PYTHONDIR'])
- del(conf.env.defines['PYTHONARCHDIR'])
+ conf.env.DEFINES = [x for x in conf.env.DEFINES
+ if not x.startswith('PYTHONDIR=')
+ and not x.startswith('PYTHONARCHDIR=')]
+
return
if conf.env["python_headers_checked"] == []:
# we don't want PYTHONDIR in config.h, as otherwise changing
# --prefix causes a complete rebuild
- del(conf.env.defines['PYTHONDIR'])
- del(conf.env.defines['PYTHONARCHDIR'])
+ conf.env.DEFINES = [x for x in conf.env.DEFINES
+ if not x.startswith('PYTHONDIR=')
+ and not x.startswith('PYTHONARCHDIR=')]
def _check_python_headers(conf, mandatory):
try:
Configure.ConfigurationError
- conf.check_python_headers(mandatory=mandatory)
+ conf.check_python_headers()
except Configure.ConfigurationError:
if mandatory:
raise
conf.env.append_unique('LIBPATH_PYEMBED', lib[2:]) # strip '-L'
conf.env['LINKFLAGS_PYEMBED'].remove(lib)
+ # same as in waf 1.5, keep only '-fno-strict-aliasing'
+ # and ignore defines such as NDEBUG _FORTIFY_SOURCE=2
+ conf.env.DEFINES_PYEXT = []
+ conf.env.CFLAGS_PYEXT = ['-fno-strict-aliasing']
+
return
def PYTHON_BUILD_IS_ENABLED(self):
# a waf tool to add autoconf-like macros to the configure section
# and for SAMBA_ macros for building libraries, binaries etc
-import os, sys, re, fnmatch, shlex
+import os, sys, re, fnmatch, shlex, inspect
from optparse import SUPPRESS_HELP
-import Build, Options, Utils, Task, Logs, Configure
+from waflib import Build, Options, Utils, Task, Logs, Configure, Errors
from TaskGen import feature, before, after
-from Configure import conf, ConfigurationContext
+from Configure import ConfigurationContext
from Logs import debug
# TODO: make this a --option
MODE_644 = int('644', 8)
MODE_755 = int('755', 8)
+def conf(f):
+ # override in order to propagate the argument "mandatory"
+ def fun(*k, **kw):
+ mandatory = True
+ if 'mandatory' in kw:
+ mandatory = kw['mandatory']
+ del kw['mandatory']
+
+ try:
+ return f(*k, **kw)
+ except Errors.ConfigurationError:
+ if mandatory:
+ raise
+
+ fun.__name__ = f.__name__
+ if 'mandatory' in inspect.getsource(f):
+ fun = f
+
+ setattr(Configure.ConfigurationContext, f.__name__, fun)
+ setattr(Build.BuildContext, f.__name__, fun)
+ return f
+Configure.conf = conf
+Configure.conftest = conf
+
@conf
def SET_TARGET_TYPE(ctx, target, value):
'''set the target type of a target'''
if not vname in env:
raise KeyError("Failed to find variable %s in %s" % (vname, string))
v = env[vname]
+ if isinstance(v, list):
+ v = ' '.join(v)
out.append(v)
return ''.join(out)
pythonpath = os.path.join(Utils.g_module.blddir, 'python')
result = 0
for interp in env.python_interpreters:
+ if not isinstance(interp, str):
+ interp = ' '.join(interp)
for testfile in testfiles:
cmd = "PYTHONPATH=%s %s %s" % (pythonpath, interp, testfile)
if extra_env:
import Environment
env = Environment.Environment()
try:
- env.load('.lock-wscript')
- env.load(env.blddir + '/c4che/default.cache.py')
- except:
+ env.load('bin/c4che/default_cache.py')
+ except (OSError, IOError):
pass
return env
return
visited_dirs.add(key)
relpath = os_path_relpath(abspath, ctx.curdir)
+ if 'waflib.extras.compat15' in sys.modules:
+ return ctx.recurse(relpath)
if ctxclass == 'Handler':
return ctx.sub_options(relpath)
if ctxclass == 'ConfigurationContext':
if python:
return ctx.env.pyext_PATTERN % root1
else:
- (root2, ext2) = os.path.splitext(ctx.env.shlib_PATTERN)
+ (root2, ext2) = os.path.splitext(ctx.env.cshlib_PATTERN)
return root1+ext2
Build.BuildContext.map_shlib_extension = map_shlib_extension
if python:
libname = apply_pattern(name, ctx.env.pyext_PATTERN)
else:
- libname = apply_pattern(name, ctx.env.shlib_PATTERN)
+ libname = apply_pattern(name, ctx.env.cshlib_PATTERN)
if nolibprefix and libname[0:3] == 'lib':
libname = libname[3:]
if version:
--- /dev/null
+# compatibility layer for building with more recent waf versions
+
+import os, shlex, sys
+import Build, Configure, Node, Utils, Options, Logs
+from waflib import ConfigSet
+from TaskGen import feature, after
+from Configure import conf, ConfigurationContext
+
+from waflib.Tools import bison, flex
+sys.modules['bison'] = bison
+sys.modules['flex'] = flex
+
+for y in (Build.BuildContext, Build.CleanContext, Build.InstallContext, Build.UninstallContext, Build.ListContext):
+ class tmp(y):
+ variant = 'default'
+
+def pre_build(self):
+ self.cwdx = self.bldnode.parent
+ self.cwd = self.cwdx.abspath()
+ self.bdir = self.bldnode.abspath()
+ return Build.BuildContext.old_pre_build(self)
+Build.BuildContext.old_pre_build = Build.BuildContext.pre_build
+Build.BuildContext.pre_build = pre_build
+
+def abspath(self, env=None):
+ if env and hasattr(self, 'children'):
+ return self.get_bld().abspath()
+ return self.old_abspath()
+Node.Node.old_abspath = Node.Node.abspath
+Node.Node.abspath = abspath
+
+def bldpath(self, env=None):
+ return self.abspath()
+ #return self.path_from(self.ctx.bldnode.parent)
+Node.Node.bldpath = bldpath
+
+def srcpath(self, env=None):
+ return self.abspath()
+ #return self.path_from(self.ctx.bldnode.parent)
+Node.Node.srcpath = srcpath
+
+def store_fast(self, filename):
+ file = open(filename, 'wb')
+ data = self.get_merged_dict()
+ try:
+ Build.cPickle.dump(data, file, -1)
+ finally:
+ file.close()
+ConfigSet.ConfigSet.store_fast = store_fast
+
+def load_fast(self, filename):
+ file = open(filename, 'rb')
+ try:
+ data = Build.cPickle.load(file)
+ finally:
+ file.close()
+ self.table.update(data)
+ConfigSet.ConfigSet.load_fast = load_fast
+
+@feature('c', 'cxx', 'd', 'asm', 'fc', 'includes')
+@after('propagate_uselib_vars', 'process_source')
+def apply_incpaths(self):
+ lst = self.to_incnodes(self.to_list(getattr(self, 'includes', [])) + self.env['INCLUDES'])
+ self.includes_nodes = lst
+ cwdx = getattr(self.bld, 'cwdx', self.bld.bldnode)
+ self.env['INCPATHS'] = [x.path_from(cwdx) for x in lst]
+
+@conf
+def define(self, key, val, quote=True, comment=None):
+ assert key and isinstance(key, str)
+
+ if val is True:
+ val = 1
+ elif val in (False, None):
+ val = 0
+
+ # waf 1.5
+ self.env[key] = val
+
+ if isinstance(val, int) or isinstance(val, float):
+ s = '%s=%s'
+ else:
+ s = quote and '%s="%s"' or '%s=%s'
+ app = s % (key, str(val))
+
+ ban = key + '='
+ lst = self.env.DEFINES
+ for x in lst:
+ if x.startswith(ban):
+ lst[lst.index(x)] = app
+ break
+ else:
+ self.env.append_value('DEFINES', app)
+
+ self.env.append_unique('define_key', key)
+
+# compat15 removes this but we want to keep it
+@conf
+def undefine(self, key, from_env=True, comment=None):
+ assert key and isinstance(key, str)
+
+ ban = key + '='
+ self.env.DEFINES = [x for x in self.env.DEFINES if not x.startswith(ban)]
+ self.env.append_unique('define_key', key)
+ # waf 1.5
+ if from_env:
+ self.env[key] = ()
+
+class ConfigurationContext(Configure.ConfigurationContext):
+ def init_dirs(self):
+ self.setenv('default')
+ self.env.merge_config_header = True
+ return super(ConfigurationContext, self).init_dirs()
+
+def find_program_samba(self, *k, **kw):
+ kw['mandatory'] = False
+ ret = self.find_program_old(*k, **kw)
+ return ret
+Configure.ConfigurationContext.find_program_old = Configure.ConfigurationContext.find_program
+Configure.ConfigurationContext.find_program = find_program_samba
+
+def PROCESS_SEPARATE_RULE(self, rule):
+ ''' cause waf to process additional script based on `rule'.
+ You should have file named wscript_<stage>_rule in the current directory
+ where stage is either 'configure' or 'build'
+ '''
+ stage = ''
+ if isinstance(self, Configure.ConfigurationContext):
+ stage = 'configure'
+ elif isinstance(self, Build.BuildContext):
+ stage = 'build'
+ script = self.path.find_node('wscript_'+stage+'_'+rule)
+ if script:
+ txt = script.read()
+ bld = self
+ conf = self
+ ctx = self
+ dc = {'ctx': self, 'conf': self, 'bld': self}
+ if getattr(self.__class__, 'pre_recurse', None):
+ dc = self.pre_recurse(script)
+ exec(compile(txt, script.abspath(), 'exec'), dc)
+ if getattr(self.__class__, 'post_recurse', None):
+ dc = self.post_recurse(script)
+
+Build.BuildContext.PROCESS_SEPARATE_RULE = PROCESS_SEPARATE_RULE
+ConfigurationContext.PROCESS_SEPARATE_RULE = PROCESS_SEPARATE_RULE
+
+Build.BuildContext.ENFORCE_GROUP_ORDERING = Utils.nada
+Build.BuildContext.AUTOCLEANUP_STALE_FILES = Utils.nada
+
+@conf
+def check(self, *k, **kw):
+ '''Override the waf defaults to inject --with-directory options'''
+
+ # match the configuration test with speficic options, for example:
+ # --with-libiconv -> Options.options.iconv_open -> "Checking for library iconv"
+ self.validate_c(kw)
+
+ additional_dirs = []
+ if 'msg' in kw:
+ msg = kw['msg']
+ for x in Options.parser.parser.option_list:
+ if getattr(x, 'match', None) and msg in x.match:
+ d = getattr(Options.options, x.dest, '')
+ if d:
+ additional_dirs.append(d)
+
+ # we add the additional dirs twice: once for the test data, and again if the compilation test suceeds below
+ def add_options_dir(dirs, env):
+ for x in dirs:
+ if not x in env.CPPPATH:
+ env.CPPPATH = [os.path.join(x, 'include')] + env.CPPPATH
+ if not x in env.LIBPATH:
+ env.LIBPATH = [os.path.join(x, 'lib')] + env.LIBPATH
+
+ add_options_dir(additional_dirs, kw['env'])
+
+ self.start_msg(kw['msg'], **kw)
+ ret = None
+ try:
+ ret = self.run_build(*k, **kw)
+ except self.errors.ConfigurationError:
+ self.end_msg(kw['errmsg'], 'YELLOW', **kw)
+ if Logs.verbose > 1:
+ raise
+ else:
+ self.fatal('The configuration failed')
+ else:
+ kw['success'] = ret
+ # success! time for brandy
+ add_options_dir(additional_dirs, self.env)
+
+ ret = self.post_check(*k, **kw)
+ if not ret:
+ self.end_msg(kw['errmsg'], 'YELLOW', **kw)
+ self.fatal('The configuration failed %r' % ret)
+ else:
+ self.end_msg(self.ret_msg(kw['okmsg'], kw), **kw)
+ return ret
+
+@conf
+def CHECK_LIBRARY_SUPPORT(conf, rpath=False, version_script=False, msg=None):
+ '''see if the platform supports building libraries'''
+
+ if msg is None:
+ if rpath:
+ msg = "rpath library support"
+ else:
+ msg = "building library support"
+
+ def build(bld):
+ lib_node = bld.srcnode.make_node('libdir/liblc1.c')
+ lib_node.parent.mkdir()
+ lib_node.write('int lib_func(void) { return 42; }\n', 'w')
+ main_node = bld.srcnode.make_node('main.c')
+ main_node.write('int main(void) {return !(lib_func() == 42);}', 'w')
+ linkflags = []
+ if version_script:
+ script = bld.srcnode.make_node('ldscript')
+ script.write('TEST_1.0A2 { global: *; };\n', 'w')
+ linkflags.append('-Wl,--version-script=%s' % script.abspath())
+ bld(features='c cshlib', source=lib_node, target='lib1', linkflags=linkflags, name='lib1')
+ o = bld(features='c cprogram', source=main_node, target='prog1', uselib_local='lib1')
+ if rpath:
+ o.rpath = [lib_node.parent.abspath()]
+ def run_app(self):
+ args = conf.SAMBA_CROSS_ARGS(msg=msg)
+ env = dict(os.environ)
+ env['LD_LIBRARY_PATH'] = self.inputs[0].parent.abspath() + os.pathsep + env.get('LD_LIBRARY_PATH', '')
+ self.generator.bld.cmd_and_log([self.inputs[0].abspath()] + args, env=env)
+ o.post()
+ bld(rule=run_app, source=o.link_task.outputs[0])
+
+ # ok, so it builds
+ try:
+ conf.check(build_fun=build, msg='Checking for %s' % msg)
+ except conf.errors.ConfigurationError:
+ return False
+ return True
+
+@conf
+def CHECK_NEED_LC(conf, msg):
+ '''check if we need -lc'''
+ def build(bld):
+ lib_node = bld.srcnode.make_node('libdir/liblc1.c')
+ lib_node.parent.mkdir()
+ lib_node.write('#include <stdio.h>\nint lib_func(void) { FILE *f = fopen("foo", "r");}\n', 'w')
+ bld(features='c cshlib', source=[lib_node], linkflags=conf.env.EXTRA_LDFLAGS, target='liblc')
+ try:
+ conf.check(build_fun=build, msg=msg, okmsg='-lc is unnecessary', errmsg='-lc is necessary')
+ except conf.errors.ConfigurationError:
+ return False
+ return True
+
+# already implemented on "waf -v"
+def order(bld, tgt_list):
+ return True
+Build.BuildContext.check_group_ordering = order
+
+@conf
+def CHECK_CFG(self, *k, **kw):
+ if 'args' in kw:
+ kw['args'] = shlex.split(kw['args'])
+ if not 'mandatory' in kw:
+ kw['mandatory'] = False
+ kw['global_define'] = True
+ return self.check_cfg(*k, **kw)
TaskGen.task_gen.apply_verif = Utils.nada
# bring in the other samba modules
-from samba_optimisation import *
from samba_utils import *
from samba_version import *
from samba_autoconf import *
import generic_cc
import samba_dist
import samba_wildcard
-import stale_files
import symbols
import pkgconfig
import configure_file
+import samba_waf18
# some systems have broken threading in python
if os.environ.get('WAF_NOTHREADS') == '1':
os.environ['PYTHONUNBUFFERED'] = '1'
-
-if Constants.HEXVERSION < 0x105019:
+if Constants.HEXVERSION not in (0x105019, 0x1090a00):
Logs.error('''
Please use the version of waf that comes with Samba, not
a system installed version. See http://wiki.samba.org/index.php/Waf
vscript = "%s.vscript" % libname
bld.ABI_VSCRIPT(version_libname, abi_directory, version, vscript,
abi_match)
- fullname = apply_pattern(bundled_name, bld.env.shlib_PATTERN)
+ fullname = apply_pattern(bundled_name, bld.env.cshlib_PATTERN)
fullpath = bld.path.find_or_declare(fullname)
vscriptpath = bld.path.find_or_declare(vscript)
if not fullpath:
bld.add_manual_dependency(fullpath, vscriptpath)
if bld.is_install:
# also make the .inst file depend on the vscript
- instname = apply_pattern(bundled_name + '.inst', bld.env.shlib_PATTERN)
+ instname = apply_pattern(bundled_name + '.inst', bld.env.cshlib_PATTERN)
bld.add_manual_dependency(bld.path.find_or_declare(instname), bld.path.find_or_declare(vscript))
vscript = os.path.join(bld.path.abspath(bld.env), vscript)
link_name = 'shared/%s' % realname
if link_name:
+ if 'waflib.extras.compat15' in sys.modules:
+ link_name = 'default/' + link_name
t.link_name = link_name
if pc_files is not None and not private_library:
target=target,
shell=isinstance(rule, str),
update_outputs=True,
- before='cc',
+ before='c',
ext_out='.c',
samba_type='GENERATOR',
dep_vars = dep_vars,
python_fixup=False, perl_fixup=False,
destname=None, base_name=None):
'''install a file'''
+ if not isinstance(file, str):
+ file = file.abspath()
destdir = bld.EXPAND_VARIABLES(destdir)
if not destname:
destname = file
bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m, flat=True)
Build.BuildContext.SAMBAMANPAGES = SAMBAMANPAGES
-#############################################################
-# give a nicer display when building different types of files
-def progress_display(self, msg, fname):
- col1 = Logs.colors(self.color)
- col2 = Logs.colors.NORMAL
- total = self.position[1]
- n = len(str(total))
- fs = '[%%%dd/%%%dd] %s %%s%%s%%s\n' % (n, n, msg)
- return fs % (self.position[0], self.position[1], col1, fname, col2)
-
-def link_display(self):
- if Options.options.progress_bar != 0:
- return Task.Task.old_display(self)
- fname = self.outputs[0].bldpath(self.env)
- return progress_display(self, 'Linking', fname)
-Task.TaskBase.classes['cc_link'].display = link_display
-
-def samba_display(self):
- if Options.options.progress_bar != 0:
- return Task.Task.old_display(self)
-
- targets = LOCAL_CACHE(self, 'TARGET_TYPE')
- if self.name in targets:
- target_type = targets[self.name]
- type_map = { 'GENERATOR' : 'Generating',
- 'PROTOTYPE' : 'Generating'
- }
- if target_type in type_map:
- return progress_display(self, type_map[target_type], self.name)
-
- if len(self.inputs) == 0:
- return Task.Task.old_display(self)
-
- fname = self.inputs[0].bldpath(self.env)
- if fname[0:3] == '../':
- fname = fname[3:]
- ext_loc = fname.rfind('.')
- if ext_loc == -1:
- return Task.Task.old_display(self)
- ext = fname[ext_loc:]
-
- ext_map = { '.idl' : 'Compiling IDL',
- '.et' : 'Compiling ERRTABLE',
- '.asn1': 'Compiling ASN1',
- '.c' : 'Compiling' }
- if ext in ext_map:
- return progress_display(self, ext_map[ext], fname)
- return Task.Task.old_display(self)
-
-Task.TaskBase.classes['Task'].old_display = Task.TaskBase.classes['Task'].display
-Task.TaskBase.classes['Task'].display = samba_display
-
-
@after('apply_link')
@feature('cshlib')
def apply_bundle_remove_dynamiclib_patch(self):
# are resolved related to WAFCACHE. It will need a lot of testing
# before it is enabled by default.
if '--enable-auto-reconfigure' in sys.argv:
- Configure.autoconfig = True
+ Configure.autoconfig = 'clobber'
def set_options(opt):
opt.tool_options('compiler_cc')
p = os.path.join(conf.srcdir, 'buildtools/wafsamba/gccdeps.pyc')
if os.path.exists(p):
os.remove(p)
-
- from TaskGen import feature, after
- @feature('testd')
- @after('apply_core')
- def check_d(self):
- tsk = self.compiled_tasks[0]
- tsk.outputs.append(tsk.outputs[0].change_ext('.d'))
-
- import Task
- cc = Task.TaskBase.classes['cc']
- oldmeth = cc.run
-
- cc.run = Task.compile_fun_noshell('cc', '${CC} ${CCFLAGS} ${CPPFLAGS} ${_CCINCFLAGS} ${_CCDEFFLAGS} ${CC_SRC_F}${SRC} ${CC_TGT_F}${TGT[0].abspath(env)}')[0]
- try:
- try:
- conf.check(features='c testd', fragment='int main() {return 0;}\n', ccflags=['-MD'], mandatory=True, msg='Check for -MD')
- except:
- pass
- else:
- conf.check_tool('gccdeps', tooldir=conf.srcdir + "/buildtools/wafsamba")
- finally:
- cc.run = oldmeth
+ conf.load('gccdeps')
# make the install paths available in environment
conf.env.LIBDIR = Options.options.LIBDIR or '${PREFIX}/lib'
conf.DEFINE('TIME_WITH_SYS_TIME', 1)
# cope with different extensions for libraries
- (root, ext) = os.path.splitext(conf.env.shlib_PATTERN)
+ (root, ext) = os.path.splitext(conf.env.cshlib_PATTERN)
if ext[0] == '.':
conf.define('SHLIBEXT', ext[1:], quote=True)
else:
# Symlink back to source dir so it can find tests in test/
link = os.path.join(testdir, 'test')
if not os.path.exists(link):
- os.symlink(os.path.abspath(os.path.join(env.cwd, 'test')), link)
+ os.symlink(ctx.path.make_node('test').abspath(), link)
sh_tests = ["test/test_tdbbackup.sh test/jenkins-be-hash.tdb"]
# WAF doesn't build the unit tests for this, maybe because they don't link with tdb?
# This forces it
def test(ctx):
- import Scripting
- Scripting.commands.append('build')
- Scripting.commands.append('testonly')
+ import Options
+ Options.commands.append('build')
+ Options.commands.append('testonly')
def dist():
'''makes a tarball for distribution'''
return False
# Check for system perl module
- if not conf.check_perl_module(module_check):
+ if conf.check_perl_module(module_check) is None:
return False
conf.define('USING_SYSTEM_%s' % bundle_name.upper(), 1)
# if running all tests, then force a symbol check
env = LOAD_ENVIRONMENT()
CHECK_MAKEFLAGS(env)
- Scripting.commands.append('build')
- Scripting.commands.append('testonly')
+ Options.commands.append('build')
+ Options.commands.append('testonly')
init_function='',
internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_ceph'),
enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_ceph'),
- cflags=bld.CONFIG_GET('CCFLAGS_CEPHFS'))
+ cflags=bld.CONFIG_GET('CFLAGS_CEPHFS'))
bld.SAMBA3_MODULE('vfs_glusterfs',
subsystem='vfs',
conf.CHECK_DECLS('FS_IOC_GETFLAGS FS_COMPR_FL', headers='linux/fs.h')):
conf.DEFINE('HAVE_LINUX_IOCTL', '1')
- conf.env['CCFLAGS_CEPHFS'] = "-D_FILE_OFFSET_BITS=64"
+ conf.env['CFLAGS_CEPHFS'] = "-D_FILE_OFFSET_BITS=64"
if Options.options.libcephfs_dir:
conf.env['CPPPATH_CEPHFS'] = Options.options.libcephfs_dir + '/include'
conf.env['LIBPATH_CEPHFS'] = Options.options.libcephfs_dir + '/lib'
t = bld(rule='"${SRC[1].abspath(env)}" "${TGT[0].parent.abspath(env)}" "${COMPILE_ET}" "${SRC[0].abspath(env)}" ${TGT[0].bldpath(env)}',
ext_out = '.c',
- before = 'cc',
+ before = 'c',
update_outputs = True,
shell = True,
source = sources,
target=header,
update_outputs=True,
ext_out='.c',
- before='cc')
+ before='c')
t.env.HEIMDAL = os.path.join(bld.srcnode.abspath(), 'source4/heimdal')
t.env.OPTIONS = options
krb5_config = conf.find_program("krb5-config", var="HEIMDAL_KRB5_CONFIG")
if krb5_config:
# Not ideal, but seems like the best way to get at these paths:
- f = open(krb5_config, 'r')
+ f = open(krb5_config[0], 'r')
try:
for l in f:
if l.startswith("libdir="):
# and include config.h if it is set, resulting in failure (since config.h
# doesn't yet exist)
-CCDEFINES = list(conf.env.CCDEFINES)
+DEFINES = list(conf.env.DEFINES)
conf.undefine("HAVE_CONFIG_H")
-while "HAVE_CONFIG_H=1" in conf.env.CCDEFINES:
- conf.env.CCDEFINES.remove("HAVE_CONFIG_H=1")
+while "HAVE_CONFIG_H=1" in conf.env.DEFINES:
+ conf.env.DEFINES.remove("HAVE_CONFIG_H=1")
try:
check_system_heimdal_lib("wind", "wind_stringprep", "wind.h", onlyif="roken")
check_system_heimdal_lib("hx509", "hx509_bitstring_print", "hx509.h", onlyif="roken wind")
check_system_heimdal_lib("kdc", "kdc_log", "kdc.h",
onlyif="roken krb5 hdb asn1 heimntlm hcrypto com_err wind heimbase")
finally:
- conf.env.CCDEFINES = CCDEFINES
+ conf.env.DEFINES = DEFINES
# With the proper checks in place we should be able to build against the system libtommath.
#if conf.CHECK_BUNDLED_SYSTEM('tommath', checkfunctions='mp_init', headers='tommath.h'):
if not conf.CHECK_SHLIB_W_PYTHON("Checking if -fno-common is needed"):
conf.ADD_CFLAGS('-fno-common')
if not conf.CHECK_SHLIB_W_PYTHON("Checking if -undefined dynamic_lookup is not need"):
- conf.env.append_value('shlib_LINKFLAGS', ['-undefined', 'dynamic_lookup'])
+ conf.env.append_value('cshlib_LINKFLAGS', ['-undefined', 'dynamic_lookup'])
if sys.platform == 'darwin':
conf.ADD_LDFLAGS('-framework CoreFoundation')
git.samba.org / nivanova / samba-autobuild / .git / commitdiff