diff options
Diffstat (limited to 'lib/replace')
| -rw-r--r-- | lib/replace/wafsamba.py | 852 |
1 files changed, 0 insertions, 852 deletions
diff --git a/lib/replace/wafsamba.py b/lib/replace/wafsamba.py deleted file mode 100644 index 54c1235ef3..0000000000 --- a/lib/replace/wafsamba.py +++ /dev/null @@ -1,852 +0,0 @@ -# a waf tool to add autoconf-like macros to the configure section -# and for SAMBA_ macros for building libraries, binaries etc - -import Build, os, Logs, sys, Configure, Options, string, Task, Utils, optparse -from Configure import conf -from Logs import debug -from TaskGen import extension - -LIB_PATH="shared" - -###################################################### -# this is used as a decorator to make functions only -# run once. Based on the idea from -# http://stackoverflow.com/questions/815110/is-there-a-decorator-to-simply-cache-function-return-values -runonce_ret = {} -def runonce(function): - def wrapper(*args): - if args in runonce_ret: - return runonce_ret[args] - else: - ret = function(*args) - runonce_ret[args] = ret - return ret - return wrapper - - -#################################################### -# some autoconf like helpers, to make the transition -# to waf a bit easier for those used to autoconf -# m4 files -@runonce -@conf -def DEFINE(conf, d, v): - conf.define(d, v, quote=False) - conf.env.append_value('CCDEFINES', d + '=' + str(v)) - -@runonce -def CHECK_HEADER(conf, h): - if conf.check(header_name=h): - conf.env.hlist.append(h) - -@conf -def CHECK_HEADERS(conf, list): - for hdr in list.split(): - CHECK_HEADER(conf, hdr) - -@conf -def CHECK_TYPES(conf, list): - for t in list.split(): - conf.check(type_name=t, header_name=conf.env.hlist) - -@conf -def CHECK_TYPE_IN(conf, t, hdr): - if conf.check(header_name=hdr): - conf.check(type_name=t, header_name=hdr) - -@conf -def CHECK_TYPE(conf, t, alternate): - if not conf.check(type_name=t, header_name=conf.env.hlist): - conf.DEFINE(t, alternate) - -@conf -def CHECK_VARIABLE(conf, v): - hdrs='' - for h in conf.env.hlist: - hdrs += '#include <%s>\n' % h - if conf.check(fragment= - '%s\nint main(void) {void *_x; _x=(void *)&%s; return 0;}\n' % (hdrs, v), - execute=0, - msg="Checking for variable %s" % v): - conf.DEFINE('HAVE_%s' % v.upper(), 1) - -@runonce -def CHECK_FUNC(conf, f): - conf.check(function_name=f, header_name=conf.env.hlist) - - -@conf -def CHECK_FUNCS(conf, list): - for f in list.split(): - CHECK_FUNC(conf, f) - - -################################################# -# return True if a configuration option was found -@conf -def CONFIG_SET(conf, option): - return (option in conf.env) and (conf.env[option] != ()) -Build.BuildContext.CONFIG_SET = CONFIG_SET - - -########################################################### -# check that the functions in 'list' are available in 'library' -# if they are, then make that library available as a dependency -# -# if the library is not available and mandatory==True, then -# raise an error. -# -# If the library is not available and mandatory==False, then -# add the library to the list of dependencies to remove from -# build rules -@conf -def CHECK_FUNCS_IN(conf, list, library, mandatory=False): - if not conf.check(lib=library, uselib_store=library): - conf.ASSERT(not mandatory, - "Mandatory library '%s' not found for functions '%s'" % (library, list)) - # if it isn't a mandatory library, then remove it from dependency lists - LOCAL_CACHE_SET(conf, 'EMPTY_TARGETS', library.upper(), True) - return - for f in list.split(): - conf.check(function_name=f, lib=library, header_name=conf.env.hlist) - conf.env['LIB_' + library.upper()] = library - LOCAL_CACHE_SET(conf, 'TARGET_TYPE', library, 'SYSLIB') - - -################################################# -# write out config.h in the right directory -@conf -def SAMBA_CONFIG_H(conf, path=None): - if os.path.normpath(conf.curdir) != os.path.normpath(os.environ.get('PWD')): - return - if path is None: - conf.write_config_header('config.h', top=True) - else: - conf.write_config_header(path) - - -############################################################## -# setup a configurable path -@conf -def CONFIG_PATH(conf, name, default): - if not name in conf.env: - conf.env[name] = conf.env['PREFIX'] + default - conf.define(name, conf.env[name], quote=True) - -############################################################## -# add some CFLAGS to the command line -@conf -def ADD_CFLAGS(conf, flags): - if not 'EXTRA_CFLAGS' in conf.env: - conf.env['EXTRA_CFLAGS'] = [] - conf.env['EXTRA_CFLAGS'].extend(flags.split()) - - -############################################################## -# work out the current flags. local flags are added first -def CURRENT_CFLAGS(bld, cflags): - if not 'EXTRA_CFLAGS' in bld.env: - list = [] - else: - list = bld.env['EXTRA_CFLAGS']; - ret = cflags.split() - ret.extend(list) - return ret - - -################################################################ -# magic rpath handling -# -# we want a different rpath when installing and when building -# Note that this should really check if rpath is available on this platform -# and it should also honor an --enable-rpath option -def set_rpath(bld): - if Options.is_install: - if bld.env['RPATH_ON_INSTALL']: - bld.env['RPATH'] = ['-Wl,-rpath=%s/lib' % bld.env.PREFIX] - else: - bld.env['RPATH'] = [] - else: - rpath = os.path.normpath('%s/%s' % (bld.env['BUILD_DIRECTORY'], LIB_PATH)) - bld.env.append_value('RPATH', '-Wl,-rpath=%s' % rpath) -Build.BuildContext.set_rpath = set_rpath - - -############################################################# -# return a named build cache dictionary, used to store -# state inside the following functions -@conf -def LOCAL_CACHE(ctx, name): - if name in ctx.env: - return ctx.env[name] - ctx.env[name] = {} - return ctx.env[name] - - -############################################################# -# set a value in a local cache -@conf -def LOCAL_CACHE_SET(ctx, cachename, key, value): - cache = LOCAL_CACHE(ctx, cachename) - cache[key] = value - -############################################################# -# set a value in a local cache -# return False if it's already set -def SET_TARGET_TYPE(ctx, target, value): - cache = LOCAL_CACHE(ctx, 'TARGET_TYPE') - if target in cache: - ASSERT(ctx, cache[target] == value, - "Target '%s' re-defined as %s - was %s" % (target, value, cache[target])) - debug("task_gen: Skipping duplicate target %s (curdir=%s)" % (target, ctx.curdir)) - return False - assumed = LOCAL_CACHE(ctx, 'ASSUMED_TARGET') - if target in assumed: - #if assumed[target] != value: - # print "Target '%s' was assumed of type '%s' but is '%s'" % (target, assumed[target], value) - ASSERT(ctx, assumed[target] == value, - "Target '%s' was assumed of type '%s' but is '%s'" % (target, assumed[target], value)) - predeclared = LOCAL_CACHE(ctx, 'PREDECLARED_TARGET') - if target in predeclared: - ASSERT(ctx, predeclared[target] == value, - "Target '%s' was predeclared of type '%s' but is '%s'" % (target, predeclared[target], value)) - LOCAL_CACHE_SET(ctx, 'TARGET_TYPE', target, value) - debug("task_gen: Target '%s' created of type '%s' in %s" % (target, value, ctx.curdir)) - return True - - -############################################################# -# a build assert call -@conf -def ASSERT(ctx, expression, msg): - if not expression: - sys.stderr.write("ERROR: %s\n" % msg) - raise AssertionError -Build.BuildContext.ASSERT = ASSERT - -################################################################ -# create a list of files by pre-pending each with a subdir name -def SUBDIR(bld, subdir, list): - ret = '' - for l in list.split(): - ret = ret + subdir + '/' + l + ' ' - return ret -Build.BuildContext.SUBDIR = SUBDIR - -################################################################# -# create the samba build environment -@conf -def SAMBA_BUILD_ENV(conf): - libpath="%s/%s" % (conf.blddir, LIB_PATH) - conf.env['BUILD_DIRECTORY'] = conf.blddir - if not os.path.exists(libpath): - os.mkdir(libpath) - -############################################## -# remove .. elements from a path list -def NORMPATH(bld, ilist): - return " ".join([os.path.normpath(p) for p in ilist.split(" ")]) -Build.BuildContext.NORMPATH = NORMPATH - -################################################################ -# add an init_function to the list for a subsystem -def ADD_INIT_FUNCTION(bld, subsystem, init_function): - if init_function is None: - return - bld.ASSERT(subsystem is not None, "You must specify a subsystem for init_function '%s'" % init_function) - cache = LOCAL_CACHE(bld, 'INIT_FUNCTIONS') - if not subsystem in cache: - cache[subsystem] = '' - cache[subsystem] += '%s,' % init_function -Build.BuildContext.ADD_INIT_FUNCTION = ADD_INIT_FUNCTION - -####################################################### -# d1 += d2 -def dict_concat(d1, d2): - for t in d2: - if t not in d1: - d1[t] = d2[t] - -################################################################ -# recursively build the dependency list for a target -def FULL_DEPENDENCIES(bld, cache, target, chain, path): - if not target in cache: - return {} - deps = cache[target].copy() - for t in cache[target]: - bld.ASSERT(t not in chain, "Circular dependency for %s: %s->%s" % (t, path, t)); - c2 = chain.copy() - c2[t] = True - dict_concat(deps, FULL_DEPENDENCIES(bld, cache, t, c2, "%s->%s" % (path, t))) - return deps - -############################################################ -# check our build dependencies for circular dependencies -def CHECK_TARGET_DEPENDENCY(bld, target): - cache = LOCAL_CACHE(bld, 'LIB_DEPS') - return FULL_DEPENDENCIES(bld, cache, target, { target:True }, target) - -############################################################ -# check that all dependencies have been declared -def CHECK_DEPENDENCIES(bld): - cache = LOCAL_CACHE(bld, 'LIB_DEPS') - target_cache = LOCAL_CACHE(bld, 'TARGET_TYPE') - debug('deps: Checking dependencies') - for t in cache: - deps = CHECK_TARGET_DEPENDENCY(bld, t) - for d in deps: - #if not d in target_cache: - # print "Dependency '%s' of target '%s' not declared" % (d, t) - ASSERT(bld, d in target_cache, - "Dependency '%s' of target '%s' not declared" % (d, t)) - debug("deps: Dependencies checked for %u targets" % len(target_cache)) -Build.BuildContext.CHECK_DEPENDENCIES = CHECK_DEPENDENCIES - - -############################################################ -# pre-declare a target as being of a particular type -def PREDECLARE(bld, target, type): - cache = LOCAL_CACHE(bld, 'PREDECLARED_TARGET') - target_cache = LOCAL_CACHE(bld, 'TARGET_TYPE') - ASSERT(bld, not target in target_cache, "Target '%s' is already declared" % target) - ASSERT(bld, not target in cache, "Target '%s' already predeclared" % target) - cache[target] = type -Build.BuildContext.PREDECLARE = PREDECLARE - - - -################################################################ -# add to the dependency list. Return a new dependency list with -# any circular dependencies removed -# returns a tuple containing (systemdeps, localdeps, add_objects) -def ADD_DEPENDENCIES(bld, name, deps): - debug('deps: Calculating dependencies for %s' % name) - lib_deps = LOCAL_CACHE(bld, 'LIB_DEPS') - if not name in lib_deps: - lib_deps[name] = {} - list = deps.split() - list2 = [] - for d in list: - lib_deps[name][d] = True; - try: - CHECK_TARGET_DEPENDENCY(bld, name) - list2.append(d) - except AssertionError: - debug("deps: Removing dependency %s from target %s" % (d, name)) - del(lib_deps[name][d]) - - # extract out the system dependencies - sysdeps = [] - localdeps = [] - add_objects = [] - cache = LOCAL_CACHE(bld, 'EMPTY_TARGETS') - target_cache = LOCAL_CACHE(bld, 'TARGET_TYPE') - predeclare = LOCAL_CACHE(bld, 'PREDECLARED_TARGET') - for d in list2: - recurse = False - # strip out any dependencies on empty libraries - if d in cache: - debug("deps: Removing empty dependency '%s' from '%s'" % (d, name)) - continue - type = None - - if d in target_cache: - type = target_cache[d] - elif d in predeclare: - type = predeclare[d] - else: - type = 'SUBSYSTEM' - LOCAL_CACHE_SET(bld, 'ASSUMED_TARGET', d, type) - - if type == 'SYSLIB': - sysdeps.append(d) - elif type == 'LIBRARY': - localdeps.append(d) - elif type == 'SUBSYSTEM': - add_objects.append(d) - recurse = True - elif type == 'MODULE': - add_objects.append(d) - recurse = True - elif type == 'PYTHON': - pass - elif type == 'ASN1': - pass - elif type == 'BINARY': - pass - else: - ASSERT(bld, False, "Unknown target type '%s' for dependency %s" % ( - type, d)) - - # for some types we have to build the list recursively - if recurse and (d in lib_deps): - rec_deps = ' '.join(lib_deps[d].keys()) - (rec_sysdeps, rec_localdeps, rec_add_objects) = ADD_DEPENDENCIES(bld, d, rec_deps) - sysdeps.extend(rec_sysdeps.split()) - localdeps.extend(rec_localdeps.split()) - add_objects.extend(rec_add_objects.split()) - - debug('deps: Dependencies for %s: sysdeps: %u localdeps: %u add_objects=%u' % ( - name, len(sysdeps), len(localdeps), len(add_objects))) - return (' '.join(sysdeps), ' '.join(localdeps), ' '.join(add_objects)) - - -################################################################# -# return a include list for a set of library dependencies -def SAMBA_LIBRARY_INCLUDE_LIST(bld, deps): - ret = bld.curdir + ' ' - cache = LOCAL_CACHE(bld, 'INCLUDE_LIST') - for l in deps.split(): - if l in cache: - ret = ret + cache[l] + ' ' - return ret -Build.BuildContext.SAMBA_LIBRARY_INCLUDE_LIST = SAMBA_LIBRARY_INCLUDE_LIST - -################################################################# -# define a Samba library -def SAMBA_LIBRARY(bld, libname, source_list, - deps='', - public_deps='', - include_list='.', - public_headers=None, - vnum=None, - cflags='', - autoproto=None): - if not SET_TARGET_TYPE(bld, libname, 'LIBRARY'): - return - - # remember empty libraries, so we can strip the dependencies - if (source_list == '') or (source_list == []): - LOCAL_CACHE_SET(bld, 'EMPTY_TARGETS', libname, True) - return - - (sysdeps, localdeps, add_objects) = ADD_DEPENDENCIES(bld, libname, deps) - - ilist = bld.SAMBA_LIBRARY_INCLUDE_LIST(deps) + bld.SUBDIR(bld.curdir, include_list) - ilist = bld.NORMPATH(ilist) - bld.SET_BUILD_GROUP('main') - bld( - features = 'cc cshlib', - source = source_list, - target=libname, - uselib_local = localdeps, - uselib = sysdeps, - add_objects = add_objects, - ccflags = CURRENT_CFLAGS(bld, cflags), - includes='. ' + bld.env['BUILD_DIRECTORY'] + '/default ' + ilist, - vnum=vnum) - - # put a link to the library in bin/shared - soext="" - if vnum is not None: - soext = '.' + vnum.split('.')[0] - bld.SET_BUILD_GROUP('final') - bld( - source = 'lib%s.so' % libname, - rule = 'ln -sf ../${SRC}%s %s/lib%s.so%s' % - (soext, LIB_PATH, libname, soext), - shell = True, - after = 'cc_link', - ) - LOCAL_CACHE_SET(bld, 'INCLUDE_LIST', libname, ilist) - -Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY - - -################################################################# -# define a Samba binary -def SAMBA_BINARY(bld, binname, source_list, - deps='', - include_list='', - public_headers=None, - modules=None, - installdir=None, - ldflags=None, - cflags='', - autoproto=None, - use_hostcc=None, - compiler=None, - group='main', - manpages=None): - ilist = '. ' + bld.env['BUILD_DIRECTORY'] + '/default ' + bld.SAMBA_LIBRARY_INCLUDE_LIST(deps) + ' ' + include_list - ilist = bld.NORMPATH(ilist) - - if not SET_TARGET_TYPE(bld, binname, 'BINARY'): - return - - (sysdeps, localdeps, add_objects) = ADD_DEPENDENCIES(bld, binname, deps) - - cache = LOCAL_CACHE(bld, 'INIT_FUNCTIONS') - if modules is not None: - for m in modules.split(): - bld.ASSERT(m in cache, - "No init_function defined for module '%s' in binary '%s'" % (m, binname)) - cflags += ' -DSTATIC_%s_MODULES="%s"' % (m, cache[m]) - - bld.SET_BUILD_GROUP(group) - bld( - features = 'cc cprogram', - source = source_list, - target = binname, - uselib_local = localdeps, - uselib = sysdeps, - includes = ilist, - ccflags = CURRENT_CFLAGS(bld, cflags), - add_objects = add_objects, - top=True) - # put a link to the binary in bin/ - if not Options.is_install: - bld( - source = binname, - rule = 'rm -f %s && cp ${SRC} .' % (binname), - shell = True, - after = 'cc_link' - ) -Build.BuildContext.SAMBA_BINARY = SAMBA_BINARY - - -################################################################# -# define a Samba python module -def SAMBA_PYTHON(bld, name, source_list, - deps='', - public_deps='', - realname=''): - - if not SET_TARGET_TYPE(bld, name, 'PYTHON'): - return - - (sysdeps, localdeps, add_objects) = ADD_DEPENDENCIES(bld, name, deps) - - return -Build.BuildContext.SAMBA_PYTHON = SAMBA_PYTHON - - -################################################################################ -# a asn1 task which calls out to asn1_compile_wrapper.sh to do the work -Task.simple_task_type('asn1', - ''' -# shell script to convert ASN1 to C. This could be separated out if we want to -set -e -compiler=${TGT[0].compiler} -destdir=${TGT[0].destdir} -wrapper=${TGT[0].asn1wrapper} -srcfile=${SRC[0].abspath(env)} -asn1name=${TGT[0].asn1name} -options="${TGT[0].asn1options}" - -# run the wrapper -$wrapper . $destdir $compiler $srcfile $asn1name ${options} --one-code-file - -# that generated 3 files: -# ${asn1name}.hx -# asn1_${asn1name}.x -# ${asn1name}_files - - -hxfile=$destdir/$asn1name.hx -xfile=$destdir/asn1_$asn1name.x -listfilee=$destdir/"$asn1name"_files - -cfile=${TGT[0].abspath(env)} -hfile=${TGT[1].abspath(env)} - -cp $hxfile $hfile -echo '#include "config.h"' > $cfile -cat $xfile >> $cfile -rm -f $listfile - -''', - color='BLUE', - ext_out='.c', - shell = True) - -@extension('.asn1') -def process_asn1(self, node): - - asn1name = string.replace(node.file(), '.', '_') - c_node = NEW_NODE(node, 'asn1_%s.c' % asn1name) - h_node = NEW_NODE(node, '%s.h' % asn1name) - - c_node.destdir = "default/source4/heimdal/" + self.asn1directory - c_node.asn1options = self.asn1options - c_node.asn1name = asn1name - c_node.asn1wrapper = "../heimdal_build/asn1_compile_wrapper.sh" - c_node.compiler = "default/source4/heimdal_build/asn1_compile" - - self.create_task('asn1', node, [c_node, h_node]) - self.allnodes.append(c_node) - - -################################################################# -# define a Samba ASN1 target -def SAMBA_ASN1(bld, name, source, - options='', - directory=''): - if not SET_TARGET_TYPE(bld, name, 'ASN1'): - return - bld.SET_BUILD_GROUP('build_source') - bld( - features = 'cc', - source = source, - target = name, - asn1options = options, - asn1directory = directory - ) -Build.BuildContext.SAMBA_ASN1 = SAMBA_ASN1 - - - -################################################################################ -# a et task which calls out to compile_et to do the work -Task.simple_task_type('et', - '../heimdal_build/et_compile_wrapper.sh . ${TGT[0].bld_dir(env)} default/source4/heimdal_build/compile_et ${SRC[0].abspath(env)} ${TGT[0].bldpath(env)}', - color='BLUE', ext_out='.c', - shell = False) - -@extension('.et') -def process_et(self, node): - c_node = node.change_ext('.c') - h_node = node.change_ext('.h') - self.create_task('et', node, [c_node, h_node]) - self.allnodes.append(c_node) - - -################################################################# -# define a Samba ET target -def SAMBA_ERRTABLE(bld, name, source, - options='', - directory=''): - if not SET_TARGET_TYPE(bld, name, 'ET'): - return - bld.SET_BUILD_GROUP('build_source') - bld( - features = 'cc', - source = source, - target = name - ) -Build.BuildContext.SAMBA_ERRTABLE = SAMBA_ERRTABLE - -########################################################## -# create a node with a new name, based on an existing node -def NEW_NODE(node, name): - ret = node.parent.find_or_declare([name]) - ASSERT(node, ret is not None, "Unable to find new target with name '%s' from '%s'" % ( - name, node.name)) - return ret - -################################################################################ -# a idl task which calls out to pidl to do the work -Task.simple_task_type('idl', '../../pidl/pidl --header --ndr-parser --client --python --server --outputdir=${TGT[0].outputdir} -- ${SRC}', color='BLUE', ext_out='.c') - -@extension('.idl') -def process_idl(self, node): - bname = node.file_base() - c_node = NEW_NODE(node, 'ndr_%s.c' % bname) - h1_node = NEW_NODE(node, '%s.h' % bname) - h2_node = NEW_NODE(node, 'ndr_%s.h' % bname) - s_node = NEW_NODE(node, 'ndr_%s_s.c' % bname) - cli_node = NEW_NODE(node, 'ndr_%s_c.c' % bname) - cli_h_node = NEW_NODE(node, 'ndr_%s_c.h' % bname) - py_node = NEW_NODE(node, 'py_%s.c' % bname) - - - dname = os.path.dirname(node.bld_dir(self.env)) + "/gen_ndr" - c_node.outputdir = dname - - self.create_task('idl', node, [c_node, h1_node, h2_node, s_node, cli_node, cli_h_node, py_node]) - - # reinject the c node to the list of nodes to process - self.allnodes.append(c_node) - - -################################################################# -# define a PIDL target -def SAMBA_PIDL(bld, directory, source): - name = os.path.basename(string.replace(source, '.idl', '')) - name = "%s/ndr_%s.o" % (directory, name) - - if not SET_TARGET_TYPE(bld, name, 'PIDL'): - return - - bld.SET_BUILD_GROUP('build_source') - bld( - features = 'cc', - source = source, - target = name - ) -Build.BuildContext.SAMBA_PIDL = SAMBA_PIDL - - - -################################################################# -# define a set of Samba PIDL targets -def SAMBA_PIDL_LIST(bld, directory, source_list): - for p in source_list.split(): - bld.SAMBA_PIDL(directory, p) -Build.BuildContext.SAMBA_PIDL_LIST = SAMBA_PIDL_LIST - - -################################################################ -# build a C prototype file automatically -def AUTOPROTO(bld, header, source_list): - if header is not None: - bld.SET_BUILD_GROUP('prototypes') - bld( - source = source_list, - target = header, - rule = '../script/mkproto.pl --srcdir=.. --builddir=. --public=/dev/null --private=${TGT} ${SRC}' - ) -Build.BuildContext.AUTOPROTO = AUTOPROTO - - -################################################################# -# define a Samba module. -def SAMBA_MODULE(bld, modname, source_list, - deps='', - include_list='.', - subsystem=None, - init_function=None, - autoproto=None, - aliases=None, - cflags='', - output_type=None): - - if not SET_TARGET_TYPE(bld, modname, 'MODULE'): - return - - # remember empty modules, so we can strip the dependencies - if (source_list == '') or (source_list == []): - LOCAL_CACHE_SET(bld, 'EMPTY_TARGETS', modname, True) - return - - (sysdeps, localdeps, add_objects) = ADD_DEPENDENCIES(bld, modname, deps) - - ilist = bld.SAMBA_LIBRARY_INCLUDE_LIST(deps) + bld.SUBDIR(bld.curdir, include_list) - ilist = bld.NORMPATH(ilist) - bld.SET_BUILD_GROUP('main') - bld( - features = 'cc', - source = source_list, - target=modname, - ccflags = CURRENT_CFLAGS(bld, cflags), - includes='. ' + bld.env['BUILD_DIRECTORY'] + '/default ' + ilist) -Build.BuildContext.SAMBA_MODULE = SAMBA_MODULE - - -################################################################# -# define a Samba subsystem -def SAMBA_SUBSYSTEM(bld, modname, source_list, - deps='', - public_deps='', - include_list='.', - public_headers=None, - autoproto=None, - cflags='', - group='main', - config_option=None, - init_function_sentinal=None): - - if not SET_TARGET_TYPE(bld, modname, 'SUBSYSTEM'): - return - - # if the caller specifies a config_option, then we create a blank - # subsystem if that configuration option was found at configure time - if (config_option is not None) and bld.CONFIG_SET(config_option): - source_list = '' - - # remember empty subsystems, so we can strip the dependencies - if (source_list == '') or (source_list == []): - LOCAL_CACHE_SET(bld, 'EMPTY_TARGETS', modname, True) - return - - (sysdeps, localdeps, add_objects) = ADD_DEPENDENCIES(bld, modname, deps) - - ilist = bld.SAMBA_LIBRARY_INCLUDE_LIST(deps) + bld.SUBDIR(bld.curdir, include_list) - ilist = bld.NORMPATH(ilist) - bld.SET_BUILD_GROUP(group) - bld( - features = 'cc', - source = source_list, - target=modname, - ccflags = CURRENT_CFLAGS(bld, cflags), - includes='. ' + bld.env['BUILD_DIRECTORY'] + '/default ' + ilist) -Build.BuildContext.SAMBA_SUBSYSTEM = SAMBA_SUBSYSTEM - - -############################################################### -# add a new set of build rules from a subdirectory -# the @runonce decorator ensures we don't end up -# with duplicate rules -def BUILD_SUBDIR(bld, dir): - path = os.path.normpath(bld.curdir + '/' + dir) - cache = LOCAL_CACHE(bld, 'SUBDIR_LIST') - if path in cache: return - cache[path] = True - debug("build: Processing subdirectory %s" % dir) - bld.add_subdirs(dir) - -Build.BuildContext.BUILD_SUBDIR = BUILD_SUBDIR - - -############################################################ -# this overrides the 'waf -v' debug output to be in a nice -# unix like format instead of a python list. -# Thanks to ita on #waf for this -def exec_command(self, cmd, **kw): - import Utils, Logs - _cmd = cmd - if isinstance(cmd, list): - _cmd = ' '.join(cmd) - debug('runner: %s' % _cmd) - if self.log: - self.log.write('%s\n' % cmd) - kw['log'] = self.log - try: - if not kw.get('cwd', None): - kw['cwd'] = self.cwd - except AttributeError: - self.cwd = kw['cwd'] = self.bldnode.abspath() - return Utils.exec_command(cmd, **kw) -Build.BuildContext.exec_command = exec_command - - -########################################################## -# add a new top level command to waf -def ADD_COMMAND(opt, name, function): - Utils.g_module.__dict__[name] = function - opt.name = function -Options.Handler.ADD_COMMAND = ADD_COMMAND - -########################################################### -# setup build groups used to ensure that the different build -# phases happen consecutively -@runonce -def SETUP_BUILD_GROUPS(bld): - bld.env['USING_BUILD_GROUPS'] = True - bld.add_group('setup') - bld.add_group('build_compilers') - bld.add_group('build_source') - bld.add_group('prototypes') - bld.add_group('main') - bld.add_group('final') -Build.BuildContext.SETUP_BUILD_GROUPS = SETUP_BUILD_GROUPS - - -########################################################### -# set the current build group -def SET_BUILD_GROUP(bld, group): - if not 'USING_BUILD_GROUPS' in bld.env: - return - bld.set_group(group) -Build.BuildContext.SET_BUILD_GROUP = SET_BUILD_GROUP - - -#import TaskGen, Task -# -#old_post_run = Task.Task.post_run -#def new_post_run(self): -# self.cached = True -# return old_post_run(self) -# -#for y in ['cc', 'cxx']: -# TaskGen.classes[y].post_run = new_post_run |