from Configure import conf
from Logs import debug
from samba_utils import SUBST_VARS_RECURSIVE
+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 *
from samba_patterns import *
from samba_pidl import *
import irixcc
import generic_cc
import samba_dist
+import samba_wildcard
O644 = 420
abi_file=None,
abi_match=None,
hide_symbols=False,
+ is_bundled=False,
+ manpages=None,
enabled=True):
'''define a Samba library'''
deps = TO_LIST(deps)
deps.append(obj_target)
- if target_type == 'PYTHON' or realname:
- bundled_name = libname
+ if target_type == 'PYTHON' or realname or not is_bundled:
+ # Sanitize the library name
+ bundled_name = libname.lower().replace('_', '-')
+ while bundled_name.startswith("lib"):
+ bundled_name = bundled_name[3:]
else:
bundled_name = BUNDLED_NAME(bld, libname, bundled_extension)
vnum = vnum,
install_path = None,
samba_inst_path = install_path,
- name = libname,
+ name = libname,
samba_realname = realname,
samba_install = install,
abi_file = abi_file,
- abi_match = abi_match
+ abi_match = abi_match,
+ is_bundled = is_bundled
)
if realname and not link_name:
if pc_files is not None:
bld.PKG_CONFIG_FILES(pc_files, vnum=vnum)
+ if manpages is not None and 'XSLTPROC' in bld.env and bld.env['XSLTPROC']:
+ bld.MANPAGES(manpages)
+
+
Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY
needs_python=False,
vars=None,
install=True,
- install_path=None):
+ install_path=None,
+ enabled=True):
'''define a Samba binary'''
+ if not enabled:
+ SET_TARGET_TYPE(bld, binname, 'DISABLED')
+ return
+
if not SET_TARGET_TYPE(bld, binname, 'BINARY'):
return
if subsystem_name is not None:
bld.TARGET_ALIAS(subsystem_name, binname)
+ if manpages is not None and 'XSLTPROC' in bld.env and bld.env['XSLTPROC']:
+ bld.MANPAGES(manpages)
+
Build.BuildContext.SAMBA_BINARY = SAMBA_BINARY
enabled=True):
'''define a Samba 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)
+ source = bld.EXPAND_VARIABLES(source, vars=vars)
+
+ obj_target = modname + '.objlist'
+
+ bld.SAMBA_SUBSYSTEM(obj_target, source,
+ deps=deps,
+ includes=includes,
+ autoproto=autoproto,
+ autoproto_extra_source=autoproto_extra_source,
+ cflags=cflags,
+ local_include=local_include,
+ enabled=enabled)
if internal_module or BUILTIN_LIBRARY(bld, modname):
# treat internal modules as subsystems for now
- SAMBA_SUBSYSTEM(bld, modname, source,
- deps=deps,
- includes=includes,
- autoproto=autoproto,
- autoproto_extra_source=autoproto_extra_source,
- cflags=cflags,
- local_include=local_include,
- enabled=enabled)
+ bld.SAMBA_SUBSYSTEM(modname, deps=obj_target, source=[],
+ enabled=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)
- source = unique_list(TO_LIST(source))
-
- # remember empty modules, so we can strip the dependencies
- if ((source == '') or (source == [])) and deps == '' and public_deps == '':
- SET_TARGET_TYPE(bld, modname, 'EMPTY')
- return
-
if not SET_TARGET_TYPE(bld, modname, 'MODULE'):
return
+ deps = TO_LIST(deps)
+ deps.append(obj_target)
+ realname = modname
if subsystem is not None:
- deps += ' ' + subsystem
+ deps.append(subsystem)
+ while realname.startswith("lib"+subsystem+"_"):
+ realname = realname[len("lib"+subsystem+"_"):]
+ while realname.startswith(subsystem+"_"):
+ realname = realname[len(subsystem+"_"):]
+ while realname.startswith("lib"):
+ realname = realname[len("lib"):]
bld.SET_BUILD_GROUP('main')
- bld(
- features = 'cc',
- source = source,
- target = modname,
+ t = bld(
+ features = 'cc cshlib install_lib',
+ source = [],
+ target = realname,
+ name = modname,
+ link_name = "modules/%s/%s.${SHLIBEXT}" % (subsystem, realname),
samba_cflags = CURRENT_CFLAGS(bld, modname, cflags),
samba_includes = includes,
local_include = local_include,
- samba_deps = TO_LIST(deps)
+ samba_deps = deps,
+ install_path = None,
+ samba_inst_path= "${MODULESDIR}/%s" % subsystem,
+ samba_realname = realname+ ".${SHLIBEXT}",
+ vnum = None,
+ samba_install = True,
+ is_bundled = False,
)
- if autoproto is not None:
- bld.SAMBA_AUTOPROTO(autoproto, source + TO_LIST(autoproto_extra_source))
-
Build.BuildContext.SAMBA_MODULE = SAMBA_MODULE
Build.BuildContext.INSTALL_DIRS = INSTALL_DIRS
+re_header = re.compile('#include[ \t]*"([^"]+)"', re.I | re.M)
+class header_task(Task.Task):
+ """
+ The public headers (the one installed on the system) have both
+ different paths and contents, so the rename is not enough.
+
+ Intermediate .inst.h files are created because path manipulation
+ may be slow. The substitution is thus performed only once.
+ """
+
+ name = 'header'
+ color = 'PINK'
+ vars = ['INCLUDEDIR', 'HEADER_DEPS']
+
+ def run(self):
+ txt = self.inputs[0].read(self.env)
+
+ # hard-coded string, but only present in samba4 (I promise, you won't feel a thing)
+ txt = txt.replace('#if _SAMBA_BUILD_ == 4', '#if 1\n')
+
+ # use a regexp to substitute the #include lines in the files
+ map = self.generator.bld.hnodemap
+ dirnodes = self.generator.bld.hnodedirs
+ def repl(m):
+ if m.group(1):
+ s = m.group(1)
+
+ # pokemon headers: gotta catch'em all!
+ fin = s
+ if s.startswith('bin/default'):
+ node = self.generator.bld.srcnode.find_resource(s.replace('bin/default/', ''))
+ if not node:
+ Logs.warn('could not find the public header for %r' % s)
+ elif node.id in map:
+ fin = map[node.id]
+ else:
+ Logs.warn('could not find the public header replacement for build header %r' % s)
+ else:
+ # this part is more difficult since the path may be relative to anything
+ for dirnode in dirnodes:
+ node = dirnode.find_resource(s)
+ if node:
+ if node.id in map:
+ fin = map[node.id]
+ break
+ else:
+ Logs.warn('could not find the public header replacement for source header %r %r' % (s, node))
+ else:
+ Logs.warn('-> could not find the public header for %r' % s)
+
+ return "#include <%s>" % fin
+ return ''
+
+ txt = re_header.sub(repl, txt)
+
+ # and write the output file
+ f = None
+ try:
+ f = open(self.outputs[0].abspath(self.env), 'w')
+ f.write(txt)
+ finally:
+ if f:
+ f.close()
+
+@TaskGen.feature('pubh')
+def make_public_headers(self):
+ """
+ collect the public headers to process and to install, then
+ create the substitutions (name and contents)
+ """
+
+ if not self.bld.is_install:
+ # install time only (lazy)
+ return
+
+ # keep two variables
+ # hnodedirs: list of folders for searching the headers
+ # hnodemap: node ids and replacement string (node objects are unique)
+ try:
+ self.bld.hnodedirs.append(self.path)
+ except AttributeError:
+ self.bld.hnodemap = {}
+ self.bld.hnodedirs = [self.bld.srcnode, self.path]
+
+ for k in 'source4 source4/include lib/talloc lib/tevent/ source4/lib/ldb/include/'.split():
+ node = self.bld.srcnode.find_dir(k)
+ if node:
+ self.bld.hnodedirs.append(node)
+
+ header_path = getattr(self, 'header_path', None) or ''
+
+ for x in self.to_list(self.headers):
+
+ # too complicated, but what was the original idea?
+ if isinstance(header_path, list):
+ add_dir = ''
+ for (p1, dir) in header_path:
+ lst = self.to_list(p1)
+ for p2 in lst:
+ if fnmatch.fnmatch(x, p2):
+ add_dir = dir
+ break
+ else:
+ continue
+ break
+ inst_path = add_dir
+ else:
+ inst_path = header_path
+
+ dest = ''
+ name = x
+ if x.find(':') != -1:
+ s = x.split(':')
+ name = s[0]
+ dest = s[1]
+
+ inn = self.path.find_resource(name)
+
+ if not inn:
+ raise ValueError("could not find the public header %r in %r" % (name, self.path))
+ out = inn.change_ext('.inst.h')
+ self.create_task('header', inn, out)
+
+ if not dest:
+ dest = inn.name
+
+ if inst_path:
+ inst_path = inst_path + '/'
+ inst_path = inst_path + dest
+
+ self.bld.install_as('${INCLUDEDIR}/%s' % inst_path, out, self.env)
+
+ self.bld.hnodemap[inn.id] = inst_path
+
+ # create a hash (not md5) to make sure the headers are re-created if something changes
+ val = 0
+ lst = list(self.bld.hnodemap.keys())
+ lst.sort()
+ for k in lst:
+ val = hash((val, k, self.bld.hnodemap[k]))
+ self.bld.env.HEADER_DEPS = val
+
def PUBLIC_HEADERS(bld, public_headers, header_path=None):
'''install some headers
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)
+ bld.SET_BUILD_GROUP('final')
+ ret = bld(features=['pubh'], headers=public_headers, header_path=header_path)
+ return ret
Build.BuildContext.PUBLIC_HEADERS = PUBLIC_HEADERS
# split on the vars
a = re.split('(@\w+@)', s)
out = []
+ done_var = {}
back_sub = [ ('PREFIX', '${prefix}'), ('EXEC_PREFIX', '${exec_prefix}')]
for v in a:
if re.match('@\w+@', v):
for (b, m) in back_sub:
s = task.env[b]
if s == v[0:len(s)]:
- v = m + v[len(s):]
+ if not b in done_var:
+ # we don't want to substitute the first usage
+ done_var[b] = True
+ else:
+ v = m + v[len(s):]
+ break
out.append(v)
contents = ''.join(out)
f = open(tgt, 'w')
Build.BuildContext.PKG_CONFIG_FILES = PKG_CONFIG_FILES
+def MANPAGES(bld, manpages):
+ '''build and install manual pages'''
+ bld.env.MAN_XSL = 'http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
+ for m in manpages.split():
+ source = m + '.xml'
+ bld.SAMBA_GENERATOR(m,
+ source=source,
+ target=m,
+ group='final',
+ rule='${XSLTPROC} -o ${TGT} ${MAN_XSL} ${SRC}'
+ )
+ bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m, flat=True)
+Build.BuildContext.MANPAGES = MANPAGES
+
#############################################################
# give a nicer display when building different types of files
git.samba.org / kamenim / samba.git / blobdiff