# a waf tool to add autoconf-like macros to the configure section
# and for SAMBA_ macros for building libraries, binaries etc
-import Build, os, Options, Task, Utils
+import Build, os, Options, Task, Utils, cc, TaskGen
from Configure import conf
from Logs import debug
+from samba_utils import SUBST_VARS_RECURSIVE
# bring in the other samba modules
+from samba_optimisation import *
from samba_utils import *
from samba_autoconf import *
from samba_patterns import *
LIB_PATH="shared"
-
+os.putenv('PYTHONUNBUFFERED', '1')
#################################################################
# create the samba build environment
autoproto=None,
group='main',
depends_on='',
- local_include=True):
+ local_include=True,
+ vars=None,
+ install_path=None,
+ install=True,
+ enabled=True):
+
+ if not enabled:
+ SET_TARGET_TYPE(bld, libname, 'DISABLED')
+ return
+
+ source = bld.EXPAND_VARIABLES(source, vars=vars)
# remember empty libraries, so we can strip the dependencies
if (source == '') or (source == []):
SET_TARGET_TYPE(bld, libname, 'EMPTY')
return
+ if bld.env.DISABLE_SHARED:
+ obj_target = libname
+ else:
+ obj_target = libname + '.objlist'
+
+ # first create a target for building the object files for this library
+ # by separating in this way, we avoid recompiling the C files
+ # separately for the install library and the build library
+ bld.SAMBA_SUBSYSTEM(obj_target,
+ source = source,
+ deps = deps,
+ public_deps = public_deps,
+ includes = includes,
+ public_headers = public_headers,
+ cflags = cflags,
+ group = group,
+ autoproto = autoproto,
+ depends_on = depends_on,
+ local_include = local_include)
+
+ if bld.env.DISABLE_SHARED:
+ return
+
if not SET_TARGET_TYPE(bld, libname, 'LIBRARY'):
return
+ # the library itself will depend on that object target
deps += ' ' + public_deps
+ deps = TO_LIST(deps)
+ deps.append(obj_target)
- # this print below should show that we're runnig this code
bld.SET_BUILD_GROUP(group)
t = bld(
features = 'cc cshlib symlink_lib',
- source = source,
+ source = [],
target = libname,
samba_cflags = CURRENT_CFLAGS(bld, libname, cflags),
depends_on = depends_on,
- samba_deps = TO_LIST(deps),
+ samba_deps = deps,
samba_includes = includes,
local_include = local_include,
- vnum = vnum
+ vnum = vnum,
+ install_path = None,
+ ldflags = build_rpath(bld)
)
+
+ if install_path is None:
+ install_path = '${LIBDIR}'
+ install_path = SUBST_VARS_RECURSIVE(install_path, bld.env)
+
+ # we don't need the double libraries if rpath is off
+ if (bld.env.RPATH_ON_INSTALL == False and
+ bld.env.RPATH_ON_BUILD == False):
+ install_target = libname
+ else:
+ install_target = libname + '.inst'
+
+ if install and install_target != libname:
+ # create a separate install library, which may have
+ # different rpath settings
+ SET_TARGET_TYPE(bld, install_target, 'LIBRARY')
+ t = bld(
+ features = 'cc cshlib',
+ source = [],
+ target = install_target,
+ samba_cflags = CURRENT_CFLAGS(bld, libname, cflags),
+ depends_on = depends_on,
+ samba_deps = deps,
+ samba_includes = includes,
+ local_include = local_include,
+ vnum = vnum,
+ install_as = libname,
+ install_path = None,
+ ldflags = install_rpath(bld)
+ )
+
+ if install:
+ if vnum:
+ vnum_base = vnum.split('.')[0]
+ install_name = 'lib%s.so.%s' % (libname, vnum)
+ install_link = 'lib%s.so.%s' % (libname, vnum_base)
+ else:
+ install_name = 'lib%s.so' % libname
+ install_link = None
+
+ bld.install_as(os.path.join(install_path, install_name),
+ 'lib%s.inst.so' % libname)
+ if install_link:
+ bld.symlink_as(os.path.join(install_path, install_link), install_name)
+
if autoproto is not None:
bld.SAMBA_AUTOPROTO(autoproto, source)
Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY
+
#################################################################
# define a Samba binary
def SAMBA_BINARY(bld, binname, source,
manpages=None,
local_include=True,
subsystem_name=None,
- needs_python=False):
+ needs_python=False,
+ vars=None,
+ install=True,
+ install_path=None):
if not SET_TARGET_TYPE(bld, binname, 'BINARY'):
return
- features = 'cc cprogram copy_bin'
+ features = 'cc cprogram'
if needs_python:
features += ' pyembed'
bld.SET_BUILD_GROUP(group)
+
+ obj_target = binname + '.objlist'
+
+ source = bld.EXPAND_VARIABLES(source, vars=vars)
+
+ # first create a target for building the object files for this binary
+ # by separating in this way, we avoid recompiling the C files
+ # separately for the install binary and the build binary
+ bld.SAMBA_SUBSYSTEM(obj_target,
+ source = source,
+ deps = deps,
+ includes = includes,
+ cflags = cflags,
+ group = group,
+ autoproto = autoproto,
+ subsystem_name = subsystem_name,
+ needs_python = needs_python,
+ local_include = local_include)
+
+ # the library itself will depend on that object target
+ deps = TO_LIST(deps)
+ deps.append(obj_target)
+
bld(
- features = features,
- source = source,
+ features = features + ' symlink_bin',
+ source = [],
target = binname,
samba_cflags = CURRENT_CFLAGS(bld, binname, cflags),
- samba_deps = TO_LIST(deps),
+ samba_deps = deps,
samba_includes = includes,
local_include = local_include,
samba_modules = modules,
top = True,
- samba_subsystem= subsystem_name
+ samba_subsystem= subsystem_name,
+ install_path = None,
+ ldflags = build_rpath(bld)
)
+ if install_path is None:
+ install_path = '${BINDIR}'
+ install_path = SUBST_VARS_RECURSIVE(install_path, bld.env)
+
+ # we don't need the double binaries if rpath is off
+ if (bld.env.RPATH_ON_INSTALL == False and
+ bld.env.RPATH_ON_BUILD == False):
+ install_target = binname
+ else:
+ install_target = binname + '.inst'
+
+ if install and install_target != binname:
+ # we create a separate 'install' binary, which
+ # will have different rpath settings
+ SET_TARGET_TYPE(bld, install_target, 'BINARY')
+ t = bld(
+ features = features,
+ source = [],
+ target = install_target,
+ samba_cflags = CURRENT_CFLAGS(bld, binname, cflags),
+ samba_deps = deps,
+ samba_includes = includes,
+ local_include = local_include,
+ samba_modules = modules,
+ top = True,
+ samba_subsystem= subsystem_name,
+ install_path = None,
+ ldflags = install_rpath(bld)
+ )
+
+ if install:
+ bld.install_as(os.path.join(install_path, binname),
+ install_target,
+ chmod=0755)
+
# setup the subsystem_name as an alias for the real
# binary name, so it can be found when expanding
# subsystem dependencies
cflags='',
internal_module=True,
local_include=True,
+ vars=None,
enabled=True):
- if internal_module:
+ # we add the init function regardless of whether the module
+ # is enabled or not, as we need to generate a null list if
+ # all disabled
+ bld.ADD_INIT_FUNCTION(subsystem, modname, init_function)
+
+ if internal_module or bld.env.DISABLE_SHARED:
# treat internal modules as subsystems for now
SAMBA_SUBSYSTEM(bld, modname, source,
deps=deps,
cflags=cflags,
local_include=local_include,
enabled=enabled)
- # even though we're treating it as a subsystem, we need to
- # add it to the init_function list
- # TODO: we should also create an implicit dependency
- # between the subsystem target and this target
- if enabled:
- bld.ADD_INIT_FUNCTION(subsystem, modname, init_function)
return
if not enabled:
SET_TARGET_TYPE(bld, modname, 'DISABLED')
return
+ source = bld.EXPAND_VARIABLES(source, vars=vars)
+
# remember empty modules, so we can strip the dependencies
if (source == '') or (source == []):
SET_TARGET_TYPE(bld, modname, 'EMPTY')
if not SET_TARGET_TYPE(bld, modname, 'MODULE'):
return
-
- bld.ADD_INIT_FUNCTION(subsystem, modname, init_function)
-
if subsystem is not None:
deps += ' ' + subsystem
includes='',
public_headers=None,
cflags='',
+ cflags_end=None,
group='main',
- config_option=None,
init_function_sentinal=None,
heimdal_autoproto=None,
heimdal_autoproto_options=None,
local_include_first=True,
subsystem_name=None,
enabled=True,
+ vars=None,
needs_python=False):
if not enabled:
if not SET_TARGET_TYPE(bld, modname, 'SUBSYSTEM'):
return
+ source = bld.EXPAND_VARIABLES(source, vars=vars)
+
deps += ' ' + public_deps
bld.SET_BUILD_GROUP(group)
samba_subsystem= subsystem_name
)
+ if cflags_end is not None:
+ t.samba_cflags.extend(TO_LIST(cflags_end))
+
if heimdal_autoproto is not None:
bld.HEIMDAL_AUTOPROTO(heimdal_autoproto, source, options=heimdal_autoproto_options)
if heimdal_autoproto_private is not None:
def SAMBA_GENERATOR(bld, name, rule, source, target,
- group='build_source'):
+ group='build_source', enabled=True,
+ vars=None):
'''A generic source generator target'''
if not SET_TARGET_TYPE(bld, name, 'GENERATOR'):
return
+ if not enabled:
+ return
+
bld.SET_BUILD_GROUP(group)
bld(
rule=rule,
- source=source,
+ source=bld.EXPAND_VARIABLES(source, vars=vars),
target=target,
+ shell=True,
+ on_results=True,
before='cc',
- ext_out='.c')
+ ext_out='.c',
+ name=name)
Build.BuildContext.SAMBA_GENERATOR = SAMBA_GENERATOR
bld.p_ln = bld.srcnode # we do want to see all targets!
bld.env['USING_BUILD_GROUPS'] = True
bld.add_group('setup')
+ bld.add_group('build_compiler_source')
bld.add_group('base_libraries')
bld.add_group('build_compilers')
bld.add_group('build_source')
# handle the creation of links for libraries and binaries
# note that we use a relative symlink path to allow the whole tree
# to me moved/copied elsewhere without breaking the links
-t = Task.simple_task_type('symlink_lib', 'ln -sf ${LINK_SOURCE} ${LINK_TARGET}',
- color='PINK', ext_in='.bin')
+t = Task.simple_task_type('symlink_lib', 'rm -f ${LINK_TARGET} && ln -s ${LINK_SOURCE} ${LINK_TARGET}',
+ shell=True, color='PINK', ext_in='.bin')
t.quiet = True
@feature('symlink_lib')
debug('task_gen: LINK for %s is %s -> %s',
self.name, tsk.env.LINK_SOURCE, tsk.env.LINK_TARGET)
-# for binaries we need to copy the executable to avoid the rpath changing
-# in the local bin/ directory on install
-t = Task.simple_task_type('copy_bin', 'rm -f ${BIN_TARGET} && cp ${SRC} ${BIN_TARGET}', color='PINK',
- ext_in='.bin', shell=True)
+
+t = Task.simple_task_type('symlink_bin', 'rm -f ${BIN_TARGET} && ln -s ${SRC} ${BIN_TARGET}',
+ shell=True, color='PINK', ext_in='.bin')
t.quiet = True
-@feature('copy_bin')
+@feature('symlink_bin')
@after('apply_link')
-def copy_bin(self):
+def symlink_bin(self):
if Options.is_install:
# we don't want to copy the install binary, as
# that has the install rpath, not the build rpath
# The rpath of the binaries in bin/default/foo/blah is different
# during the install phase, as distros insist on not using rpath in installed binaries
return
- tsk = self.create_task('copy_bin', self.link_task.outputs[0])
+ tsk = self.create_task('symlink_bin', self.link_task.outputs[0])
tsk.env.BIN_TARGET = self.target
debug('task_gen: BIN_TARGET for %s is %s', self.name, tsk.env.BIN_TARGET)
-t = Task.simple_task_type('copy_script', 'ln -sf ${SRC[0].abspath(env)} ${LINK_TARGET}',
- color='PINK', ext_in='.bin', shell=True)
+t = Task.simple_task_type('copy_script', 'rm -f && ln -s ${SRC[0].abspath(env)} ${LINK_TARGET}',
+ shell=True, color='PINK', ext_in='.bin')
t.quiet = True
@feature('copy_script')
tgtdir = os.path.dirname(os.path.join(bld.srcnode.abspath(bld.env), '..', target))
mkdir_p(tgtdir)
t = bld(features='copy_script',
- source=s,
- target = target,
- always=True)
+ source = s,
+ target = target,
+ always = True,
+ install_path = None)
t.env.LINK_TARGET = target
Build.BuildContext.SAMBA_SCRIPT = SAMBA_SCRIPT
+
git.samba.org / nivanova / samba-autobuild / .git / blobdiff