# 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, cc, TaskGen
+import Build, os, Options, Task, Utils, cc, TaskGen, fnmatch
from Configure import conf
from Logs import debug
from samba_utils import SUBST_VARS_RECURSIVE
from samba_autoproto import *
from samba_python import *
from samba_deps import *
+import samba_conftests
LIB_PATH="shared"
-
+os.putenv('PYTHONUNBUFFERED', '1')
#################################################################
# create the samba build environment
public_deps='',
includes='',
public_headers=None,
+ header_path=None,
vnum=None,
cflags='',
external_library=False,
group='main',
depends_on='',
local_include=True,
+ vars=None,
install_path=None,
install=True,
enabled=True):
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 not SET_TARGET_TYPE(bld, libname, 'LIBRARY'):
- return
-
- obj_target = libname + '.objlist'
+ 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
public_deps = public_deps,
includes = includes,
public_headers = public_headers,
+ header_path = header_path,
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)
samba_includes = includes,
local_include = local_include,
vnum = vnum,
- install_path = None
+ install_path = None,
+ ldflags = build_rpath(bld)
)
if install_path is None:
install_path = '${LIBDIR}'
install_path = SUBST_VARS_RECURSIVE(install_path, bld.env)
- if install:
+ # 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, libname + '.inst', 'LIBRARY')
+ SET_TARGET_TYPE(bld, install_target, 'LIBRARY')
t = bld(
features = 'cc cshlib',
source = [],
- target = libname + '.inst',
+ target = install_target,
samba_cflags = CURRENT_CFLAGS(bld, libname, cflags),
depends_on = depends_on,
samba_deps = deps,
vnum = vnum,
install_as = libname,
install_path = None,
+ ldflags = install_rpath(bld)
)
- t.env['RPATH'] = install_rpath(bld)
+ if install:
if vnum:
vnum_base = vnum.split('.')[0]
install_name = 'lib%s.so.%s' % (libname, vnum)
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)
+ if public_headers is not None:
+ bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
+
Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY
deps='',
includes='',
public_headers=None,
+ header_path=None,
modules=None,
installdir=None,
ldflags=None,
local_include=True,
subsystem_name=None,
needs_python=False,
+ vars=None,
install=True,
install_path=None):
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
samba_modules = modules,
top = True,
samba_subsystem= subsystem_name,
- install_path = None
+ install_path = None,
+ ldflags = build_rpath(bld)
)
if install_path is None:
install_path = '${BINDIR}'
install_path = SUBST_VARS_RECURSIVE(install_path, bld.env)
- if install:
+ # 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, binname + '.inst', 'BINARY')
+ SET_TARGET_TYPE(bld, install_target, 'BINARY')
t = bld(
features = features,
source = [],
- target = binname + '.inst',
+ target = install_target,
samba_cflags = CURRENT_CFLAGS(bld, binname, cflags),
samba_deps = deps,
samba_includes = includes,
samba_modules = modules,
top = True,
samba_subsystem= subsystem_name,
- install_path = None
+ install_path = None,
+ ldflags = install_rpath(bld)
)
- t.env['RPATH'] = install_rpath(bld)
+ if install:
bld.install_as(os.path.join(install_path, binname),
- binname + '.inst',
+ install_target,
chmod=0755)
# setup the subsystem_name as an alias for the real
if autoproto is not None:
bld.SAMBA_AUTOPROTO(autoproto, source)
+ if public_headers is not None:
+ bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
Build.BuildContext.SAMBA_BINARY = SAMBA_BINARY
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
public_deps='',
includes='',
public_headers=None,
+ header_path=None,
cflags='',
cflags_end=None,
group='main',
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)
bld.HEIMDAL_AUTOPROTO_PRIVATE(heimdal_autoproto_private, source)
if autoproto is not None:
bld.SAMBA_AUTOPROTO(autoproto, source + ' ' + autoproto_extra_source)
+ if public_headers is not None:
+ bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
return t
+
Build.BuildContext.SAMBA_SUBSYSTEM = SAMBA_SUBSYSTEM
def SAMBA_GENERATOR(bld, name, rule, source, target,
- group='build_source', enabled=True):
+ group='build_source', enabled=True,
+ public_headers=None,
+ header_path=None,
+ vars=None):
'''A generic source generator target'''
if not SET_TARGET_TYPE(bld, name, 'GENERATOR'):
return
if not enabled:
- return False
+ 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',
name=name)
+
+ if public_headers is not None:
+ bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
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')
self.name, tsk.env.LINK_SOURCE, tsk.env.LINK_TARGET)
-t = Task.simple_task_type('symlink_bin', 'ln -sf ${SRC} ${BIN_TARGET}',
- color='PINK', ext_in='.bin')
+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('symlink_bin')
-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 ${LINK_TARGET} && ln -s ${SRC[0].abspath(env)} ${LINK_TARGET}',
+ shell=True, color='PINK', ext_in='.bin')
t.quiet = True
@feature('copy_script')
Build.BuildContext.SAMBA_SCRIPT = SAMBA_SCRIPT
+
+def INSTALL_FILES(bld, destdir, files, chmod=0644, flat=False,
+ python_fixup=False, destname=None):
+ '''install a set of files'''
+ destdir = bld.EXPAND_VARIABLES(destdir)
+ if destname:
+ bld.install_as(os.path.join(destdir,destname), files, chmod=chmod)
+ else:
+ bld.install_files(destdir, files, chmod=chmod, relative_trick=not flat)
+Build.BuildContext.INSTALL_FILES = INSTALL_FILES
+
+
+def INSTALL_WILDCARD(bld, destdir, pattern, chmod=0644, flat=False,
+ python_fixup=False, exclude=None):
+ '''install a set of files matching a wildcard pattern'''
+ files=TO_LIST(bld.path.ant_glob(pattern))
+ if exclude:
+ for f in files[:]:
+ if fnmatch.fnmatch(f, exclude):
+ files.remove(f)
+ INSTALL_FILES(bld, destdir, files, chmod=chmod, flat=flat, python_fixup=python_fixup)
+Build.BuildContext.INSTALL_WILDCARD = INSTALL_WILDCARD
+
+
+def PUBLIC_HEADERS(bld, public_headers, header_path=None):
+ '''install some headers
+
+ header_path may either be a string that is added to the INCLUDEDIR,
+ or it can be a dictionary of wildcard patterns which map to destination
+ directories relative to INCLUDEDIR
+ '''
+ dest = '${INCLUDEDIR}'
+ if isinstance(header_path, str):
+ dest += '/' + header_path
+ for h in TO_LIST(public_headers):
+ hdest = dest
+ if isinstance(header_path, list):
+ for (p1, dir) in header_path:
+ found_match=False
+ lst = TO_LIST(p1)
+ for p2 in lst:
+ if fnmatch.fnmatch(h, p2):
+ if dir:
+ hdest = os.path.join(hdest, dir)
+ found_match=True
+ break
+ if found_match: break
+ if h.find(':') != -1:
+ hs=h.split(':')
+ INSTALL_FILES(bld, hdest, hs[0], flat=True, destname=hs[1])
+ else:
+ INSTALL_FILES(bld, hdest, h, flat=True)
+Build.BuildContext.PUBLIC_HEADERS = PUBLIC_HEADERS
+
git.samba.org / nivanova / samba-autobuild / .git / blobdiff