source: vendor/current/buildtools/wafsamba/wafsamba.py

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 34.8 KB
Line 
1# a waf tool to add autoconf-like macros to the configure section
2# and for SAMBA_ macros for building libraries, binaries etc
3
4import Build, os, sys, Options, Task, Utils, cc, TaskGen, fnmatch, re, shutil, Logs, Constants
5from Configure import conf
6from Logs import debug
7from samba_utils import SUBST_VARS_RECURSIVE
8TaskGen.task_gen.apply_verif = Utils.nada
9
10# bring in the other samba modules
11from samba_optimisation import *
12from samba_utils import *
13from samba_version import *
14from samba_autoconf import *
15from samba_patterns import *
16from samba_pidl import *
17from samba_autoproto import *
18from samba_python import *
19from samba_perl import *
20from samba_deps import *
21from samba_bundled import *
22from samba_third_party import *
23import samba_cross
24import samba_install
25import samba_conftests
26import samba_abi
27import samba_headers
28import tru64cc
29import irixcc
30import hpuxcc
31import generic_cc
32import samba_dist
33import samba_wildcard
34import stale_files
35import symbols
36import pkgconfig
37import configure_file
38
39# some systems have broken threading in python
40if os.environ.get('WAF_NOTHREADS') == '1':
41 import nothreads
42
43LIB_PATH="shared"
44
45os.environ['PYTHONUNBUFFERED'] = '1'
46
47
48if Constants.HEXVERSION < 0x105019:
49 Logs.error('''
50Please use the version of waf that comes with Samba, not
51a system installed version. See http://wiki.samba.org/index.php/Waf
52for details.
53
54Alternatively, please run ./configure and make as usual. That will
55call the right version of waf.''')
56 sys.exit(1)
57
58
59@conf
60def SAMBA_BUILD_ENV(conf):
61 '''create the samba build environment'''
62 conf.env.BUILD_DIRECTORY = conf.blddir
63 mkdir_p(os.path.join(conf.blddir, LIB_PATH))
64 mkdir_p(os.path.join(conf.blddir, LIB_PATH, "private"))
65 mkdir_p(os.path.join(conf.blddir, "modules"))
66 mkdir_p(os.path.join(conf.blddir, 'python/samba/dcerpc'))
67 # this allows all of the bin/shared and bin/python targets
68 # to be expressed in terms of build directory paths
69 mkdir_p(os.path.join(conf.blddir, 'default'))
70 for (source, target) in [('shared', 'shared'), ('modules', 'modules'), ('python', 'python_modules')]:
71 link_target = os.path.join(conf.blddir, 'default/' + target)
72 if not os.path.lexists(link_target):
73 os.symlink('../' + source, link_target)
74
75 # get perl to put the blib files in the build directory
76 blib_bld = os.path.join(conf.blddir, 'default/pidl/blib')
77 blib_src = os.path.join(conf.srcdir, 'pidl/blib')
78 mkdir_p(blib_bld + '/man1')
79 mkdir_p(blib_bld + '/man3')
80 if os.path.islink(blib_src):
81 os.unlink(blib_src)
82 elif os.path.exists(blib_src):
83 shutil.rmtree(blib_src)
84
85
86def ADD_INIT_FUNCTION(bld, subsystem, target, init_function):
87 '''add an init_function to the list for a subsystem'''
88 if init_function is None:
89 return
90 bld.ASSERT(subsystem is not None, "You must specify a subsystem for init_function '%s'" % init_function)
91 cache = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
92 if not subsystem in cache:
93 cache[subsystem] = []
94 cache[subsystem].append( { 'TARGET':target, 'INIT_FUNCTION':init_function } )
95Build.BuildContext.ADD_INIT_FUNCTION = ADD_INIT_FUNCTION
96
97
98def generate_empty_file(task):
99 task.outputs[0].write('')
100 return 0
101
102#################################################################
103def SAMBA_LIBRARY(bld, libname, source,
104 deps='',
105 public_deps='',
106 includes='',
107 public_headers=None,
108 public_headers_install=True,
109 private_headers=None,
110 header_path=None,
111 pc_files=None,
112 vnum=None,
113 soname=None,
114 cflags='',
115 ldflags='',
116 external_library=False,
117 realname=None,
118 keep_underscore=False,
119 autoproto=None,
120 autoproto_extra_source='',
121 group='main',
122 depends_on='',
123 local_include=True,
124 global_include=True,
125 vars=None,
126 subdir=None,
127 install_path=None,
128 install=True,
129 pyembed=False,
130 pyext=False,
131 target_type='LIBRARY',
132 bundled_extension=False,
133 bundled_name=None,
134 link_name=None,
135 abi_directory=None,
136 abi_match=None,
137 hide_symbols=False,
138 manpages=None,
139 private_library=False,
140 grouping_library=False,
141 allow_undefined_symbols=False,
142 allow_warnings=False,
143 enabled=True):
144 '''define a Samba library'''
145
146 if pyembed and bld.env['IS_EXTRA_PYTHON']:
147 public_headers = pc_files = None
148
149 if private_library and public_headers:
150 raise Utils.WafError("private library '%s' must not have public header files" %
151 libname)
152
153 if LIB_MUST_BE_PRIVATE(bld, libname):
154 private_library = True
155
156 if not enabled:
157 SET_TARGET_TYPE(bld, libname, 'DISABLED')
158 return
159
160 source = bld.EXPAND_VARIABLES(source, vars=vars)
161 if subdir:
162 source = bld.SUBDIR(subdir, source)
163
164 # remember empty libraries, so we can strip the dependencies
165 if ((source == '') or (source == [])):
166 if deps == '' and public_deps == '':
167 SET_TARGET_TYPE(bld, libname, 'EMPTY')
168 return
169 empty_c = libname + '.empty.c'
170 bld.SAMBA_GENERATOR('%s_empty_c' % libname,
171 rule=generate_empty_file,
172 target=empty_c)
173 source=empty_c
174
175 if BUILTIN_LIBRARY(bld, libname):
176 obj_target = libname
177 else:
178 obj_target = libname + '.objlist'
179
180 if group == 'libraries':
181 subsystem_group = 'main'
182 else:
183 subsystem_group = group
184
185 # first create a target for building the object files for this library
186 # by separating in this way, we avoid recompiling the C files
187 # separately for the install library and the build library
188 bld.SAMBA_SUBSYSTEM(obj_target,
189 source = source,
190 deps = deps,
191 public_deps = public_deps,
192 includes = includes,
193 public_headers = public_headers,
194 public_headers_install = public_headers_install,
195 private_headers= private_headers,
196 header_path = header_path,
197 cflags = cflags,
198 group = subsystem_group,
199 autoproto = autoproto,
200 autoproto_extra_source=autoproto_extra_source,
201 depends_on = depends_on,
202 hide_symbols = hide_symbols,
203 allow_warnings = allow_warnings,
204 pyembed = pyembed,
205 pyext = pyext,
206 local_include = local_include,
207 global_include = global_include)
208
209 if BUILTIN_LIBRARY(bld, libname):
210 return
211
212 if not SET_TARGET_TYPE(bld, libname, target_type):
213 return
214
215 # the library itself will depend on that object target
216 deps += ' ' + public_deps
217 deps = TO_LIST(deps)
218 deps.append(obj_target)
219
220 realname = bld.map_shlib_extension(realname, python=(target_type=='PYTHON'))
221 link_name = bld.map_shlib_extension(link_name, python=(target_type=='PYTHON'))
222
223 # we don't want any public libraries without version numbers
224 if (not private_library and target_type != 'PYTHON' and not realname):
225 if vnum is None and soname is None:
226 raise Utils.WafError("public library '%s' must have a vnum" %
227 libname)
228 if pc_files is None and not bld.env['IS_EXTRA_PYTHON']:
229 raise Utils.WafError("public library '%s' must have pkg-config file" %
230 libname)
231 if public_headers is None and not bld.env['IS_EXTRA_PYTHON']:
232 raise Utils.WafError("public library '%s' must have header files" %
233 libname)
234
235 if bundled_name is not None:
236 pass
237 elif target_type == 'PYTHON' or realname or not private_library:
238 if keep_underscore:
239 bundled_name = libname
240 else:
241 bundled_name = libname.replace('_', '-')
242 else:
243 assert (private_library == True and realname is None)
244 if abi_directory or vnum or soname:
245 bundled_extension=True
246 bundled_name = PRIVATE_NAME(bld, libname.replace('_', '-'),
247 bundled_extension, private_library)
248
249 ldflags = TO_LIST(ldflags)
250 if bld.env['ENABLE_RELRO'] is True:
251 ldflags.extend(TO_LIST('-Wl,-z,relro,-z,now'))
252
253 features = 'c cshlib symlink_lib install_lib'
254 if pyext:
255 features += ' pyext'
256 if pyembed:
257 features += ' pyembed'
258
259 if abi_directory:
260 features += ' abi_check'
261
262 if pyembed and bld.env['PYTHON_SO_ABI_FLAG']:
263 # For ABI checking, we don't care about the exact Python version.
264 # Replace the Python ABI tag (e.g. ".cpython-35m") by a generic ".py3"
265 abi_flag = bld.env['PYTHON_SO_ABI_FLAG']
266 replacement = '.py%s' % bld.env['PYTHON_VERSION'].split('.')[0]
267 version_libname = libname.replace(abi_flag, replacement)
268 else:
269 version_libname = libname
270
271 vscript = None
272 if bld.env.HAVE_LD_VERSION_SCRIPT:
273 if private_library:
274 version = "%s_%s" % (Utils.g_module.APPNAME, Utils.g_module.VERSION)
275 elif vnum:
276 version = "%s_%s" % (libname, vnum)
277 else:
278 version = None
279 if version:
280 vscript = "%s.vscript" % libname
281 bld.ABI_VSCRIPT(version_libname, abi_directory, version, vscript,
282 abi_match)
283 fullname = apply_pattern(bundled_name, bld.env.shlib_PATTERN)
284 fullpath = bld.path.find_or_declare(fullname)
285 vscriptpath = bld.path.find_or_declare(vscript)
286 if not fullpath:
287 raise Utils.WafError("unable to find fullpath for %s" % fullname)
288 if not vscriptpath:
289 raise Utils.WafError("unable to find vscript path for %s" % vscript)
290 bld.add_manual_dependency(fullpath, vscriptpath)
291 if bld.is_install:
292 # also make the .inst file depend on the vscript
293 instname = apply_pattern(bundled_name + '.inst', bld.env.shlib_PATTERN)
294 bld.add_manual_dependency(bld.path.find_or_declare(instname), bld.path.find_or_declare(vscript))
295 vscript = os.path.join(bld.path.abspath(bld.env), vscript)
296
297 bld.SET_BUILD_GROUP(group)
298 t = bld(
299 features = features,
300 source = [],
301 target = bundled_name,
302 depends_on = depends_on,
303 samba_ldflags = ldflags,
304 samba_deps = deps,
305 samba_includes = includes,
306 version_script = vscript,
307 version_libname = version_libname,
308 local_include = local_include,
309 global_include = global_include,
310 vnum = vnum,
311 soname = soname,
312 install_path = None,
313 samba_inst_path = install_path,
314 name = libname,
315 samba_realname = realname,
316 samba_install = install,
317 abi_directory = "%s/%s" % (bld.path.abspath(), abi_directory),
318 abi_match = abi_match,
319 private_library = private_library,
320 grouping_library=grouping_library,
321 allow_undefined_symbols=allow_undefined_symbols
322 )
323
324 if realname and not link_name:
325 link_name = 'shared/%s' % realname
326
327 if link_name:
328 t.link_name = link_name
329
330 if pc_files is not None and not private_library:
331 bld.PKG_CONFIG_FILES(pc_files, vnum=vnum)
332
333 if (manpages is not None and 'XSLTPROC_MANPAGES' in bld.env and
334 bld.env['XSLTPROC_MANPAGES']):
335 bld.MANPAGES(manpages, install)
336
337
338Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY
339
340
341#################################################################
342def SAMBA_BINARY(bld, binname, source,
343 deps='',
344 includes='',
345 public_headers=None,
346 private_headers=None,
347 header_path=None,
348 modules=None,
349 ldflags=None,
350 cflags='',
351 autoproto=None,
352 use_hostcc=False,
353 use_global_deps=True,
354 compiler=None,
355 group='main',
356 manpages=None,
357 local_include=True,
358 global_include=True,
359 subsystem_name=None,
360 pyembed=False,
361 vars=None,
362 subdir=None,
363 install=True,
364 install_path=None,
365 enabled=True):
366 '''define a Samba binary'''
367
368 if not enabled:
369 SET_TARGET_TYPE(bld, binname, 'DISABLED')
370 return
371
372 if not SET_TARGET_TYPE(bld, binname, 'BINARY'):
373 return
374
375 features = 'c cprogram symlink_bin install_bin'
376 if pyembed:
377 features += ' pyembed'
378
379 obj_target = binname + '.objlist'
380
381 source = bld.EXPAND_VARIABLES(source, vars=vars)
382 if subdir:
383 source = bld.SUBDIR(subdir, source)
384 source = unique_list(TO_LIST(source))
385
386 if group == 'binaries':
387 subsystem_group = 'main'
388 else:
389 subsystem_group = group
390
391 # only specify PIE flags for binaries
392 pie_cflags = cflags
393 pie_ldflags = TO_LIST(ldflags)
394 if bld.env['ENABLE_PIE'] is True:
395 pie_cflags += ' -fPIE'
396 pie_ldflags.extend(TO_LIST('-pie'))
397 if bld.env['ENABLE_RELRO'] is True:
398 pie_ldflags.extend(TO_LIST('-Wl,-z,relro,-z,now'))
399
400 # first create a target for building the object files for this binary
401 # by separating in this way, we avoid recompiling the C files
402 # separately for the install binary and the build binary
403 bld.SAMBA_SUBSYSTEM(obj_target,
404 source = source,
405 deps = deps,
406 includes = includes,
407 cflags = pie_cflags,
408 group = subsystem_group,
409 autoproto = autoproto,
410 subsystem_name = subsystem_name,
411 local_include = local_include,
412 global_include = global_include,
413 use_hostcc = use_hostcc,
414 pyext = pyembed,
415 use_global_deps= use_global_deps)
416
417 bld.SET_BUILD_GROUP(group)
418
419 # the binary itself will depend on that object target
420 deps = TO_LIST(deps)
421 deps.append(obj_target)
422
423 t = bld(
424 features = features,
425 source = [],
426 target = binname,
427 samba_deps = deps,
428 samba_includes = includes,
429 local_include = local_include,
430 global_include = global_include,
431 samba_modules = modules,
432 top = True,
433 samba_subsystem= subsystem_name,
434 install_path = None,
435 samba_inst_path= install_path,
436 samba_install = install,
437 samba_ldflags = pie_ldflags
438 )
439
440 if manpages is not None and 'XSLTPROC_MANPAGES' in bld.env and bld.env['XSLTPROC_MANPAGES']:
441 bld.MANPAGES(manpages, install)
442
443Build.BuildContext.SAMBA_BINARY = SAMBA_BINARY
444
445
446#################################################################
447def SAMBA_MODULE(bld, modname, source,
448 deps='',
449 includes='',
450 subsystem=None,
451 init_function=None,
452 module_init_name='samba_init_module',
453 autoproto=None,
454 autoproto_extra_source='',
455 cflags='',
456 internal_module=True,
457 local_include=True,
458 global_include=True,
459 vars=None,
460 subdir=None,
461 enabled=True,
462 pyembed=False,
463 manpages=None,
464 allow_undefined_symbols=False,
465 allow_warnings=False
466 ):
467 '''define a Samba module.'''
468
469 bld.ASSERT(subsystem, "You must specify a subsystem for SAMBA_MODULE(%s)" % modname)
470
471 source = bld.EXPAND_VARIABLES(source, vars=vars)
472 if subdir:
473 source = bld.SUBDIR(subdir, source)
474
475 if internal_module or BUILTIN_LIBRARY(bld, modname):
476 # Do not create modules for disabled subsystems
477 if GET_TARGET_TYPE(bld, subsystem) == 'DISABLED':
478 return
479 bld.SAMBA_SUBSYSTEM(modname, source,
480 deps=deps,
481 includes=includes,
482 autoproto=autoproto,
483 autoproto_extra_source=autoproto_extra_source,
484 cflags=cflags,
485 local_include=local_include,
486 global_include=global_include,
487 allow_warnings=allow_warnings,
488 enabled=enabled)
489
490 bld.ADD_INIT_FUNCTION(subsystem, modname, init_function)
491 return
492
493 if not enabled:
494 SET_TARGET_TYPE(bld, modname, 'DISABLED')
495 return
496
497 # Do not create modules for disabled subsystems
498 if GET_TARGET_TYPE(bld, subsystem) == 'DISABLED':
499 return
500
501 realname = modname
502 deps += ' ' + subsystem
503 while realname.startswith("lib"+subsystem+"_"):
504 realname = realname[len("lib"+subsystem+"_"):]
505 while realname.startswith(subsystem+"_"):
506 realname = realname[len(subsystem+"_"):]
507
508 build_name = "%s_module_%s" % (subsystem, realname)
509
510 realname = bld.make_libname(realname)
511 while realname.startswith("lib"):
512 realname = realname[len("lib"):]
513
514 build_link_name = "modules/%s/%s" % (subsystem, realname)
515
516 if init_function:
517 cflags += " -D%s=%s" % (init_function, module_init_name)
518
519 bld.SAMBA_LIBRARY(modname,
520 source,
521 deps=deps,
522 includes=includes,
523 cflags=cflags,
524 realname = realname,
525 autoproto = autoproto,
526 local_include=local_include,
527 global_include=global_include,
528 vars=vars,
529 bundled_name=build_name,
530 link_name=build_link_name,
531 install_path="${MODULESDIR}/%s" % subsystem,
532 pyembed=pyembed,
533 manpages=manpages,
534 allow_undefined_symbols=allow_undefined_symbols,
535 allow_warnings=allow_warnings
536 )
537
538
539Build.BuildContext.SAMBA_MODULE = SAMBA_MODULE
540
541
542#################################################################
543def SAMBA_SUBSYSTEM(bld, modname, source,
544 deps='',
545 public_deps='',
546 includes='',
547 public_headers=None,
548 public_headers_install=True,
549 private_headers=None,
550 header_path=None,
551 cflags='',
552 cflags_end=None,
553 group='main',
554 init_function_sentinel=None,
555 autoproto=None,
556 autoproto_extra_source='',
557 depends_on='',
558 local_include=True,
559 local_include_first=True,
560 global_include=True,
561 subsystem_name=None,
562 enabled=True,
563 use_hostcc=False,
564 use_global_deps=True,
565 vars=None,
566 subdir=None,
567 hide_symbols=False,
568 allow_warnings=False,
569 pyext=False,
570 pyembed=False):
571 '''define a Samba subsystem'''
572
573 if not enabled:
574 SET_TARGET_TYPE(bld, modname, 'DISABLED')
575 return
576
577 # remember empty subsystems, so we can strip the dependencies
578 if ((source == '') or (source == [])):
579 if deps == '' and public_deps == '':
580 SET_TARGET_TYPE(bld, modname, 'EMPTY')
581 return
582 empty_c = modname + '.empty.c'
583 bld.SAMBA_GENERATOR('%s_empty_c' % modname,
584 rule=generate_empty_file,
585 target=empty_c)
586 source=empty_c
587
588 if not SET_TARGET_TYPE(bld, modname, 'SUBSYSTEM'):
589 return
590
591 source = bld.EXPAND_VARIABLES(source, vars=vars)
592 if subdir:
593 source = bld.SUBDIR(subdir, source)
594 source = unique_list(TO_LIST(source))
595
596 deps += ' ' + public_deps
597
598 bld.SET_BUILD_GROUP(group)
599
600 features = 'c'
601 if pyext:
602 features += ' pyext'
603 if pyembed:
604 features += ' pyembed'
605
606 t = bld(
607 features = features,
608 source = source,
609 target = modname,
610 samba_cflags = CURRENT_CFLAGS(bld, modname, cflags,
611 allow_warnings=allow_warnings,
612 hide_symbols=hide_symbols),
613 depends_on = depends_on,
614 samba_deps = TO_LIST(deps),
615 samba_includes = includes,
616 local_include = local_include,
617 local_include_first = local_include_first,
618 global_include = global_include,
619 samba_subsystem= subsystem_name,
620 samba_use_hostcc = use_hostcc,
621 samba_use_global_deps = use_global_deps,
622 )
623
624 if cflags_end is not None:
625 t.samba_cflags.extend(TO_LIST(cflags_end))
626
627 if autoproto is not None:
628 bld.SAMBA_AUTOPROTO(autoproto, source + TO_LIST(autoproto_extra_source))
629 if public_headers is not None:
630 bld.PUBLIC_HEADERS(public_headers, header_path=header_path,
631 public_headers_install=public_headers_install)
632 return t
633
634
635Build.BuildContext.SAMBA_SUBSYSTEM = SAMBA_SUBSYSTEM
636
637
638def SAMBA_GENERATOR(bld, name, rule, source='', target='',
639 group='generators', enabled=True,
640 public_headers=None,
641 public_headers_install=True,
642 private_headers=None,
643 header_path=None,
644 vars=None,
645 dep_vars=[],
646 always=False):
647 '''A generic source generator target'''
648
649 if not SET_TARGET_TYPE(bld, name, 'GENERATOR'):
650 return
651
652 if not enabled:
653 return
654
655 dep_vars.append('ruledeps')
656 dep_vars.append('SAMBA_GENERATOR_VARS')
657
658 bld.SET_BUILD_GROUP(group)
659 t = bld(
660 rule=rule,
661 source=bld.EXPAND_VARIABLES(source, vars=vars),
662 target=target,
663 shell=isinstance(rule, str),
664 update_outputs=True,
665 before='cc',
666 ext_out='.c',
667 samba_type='GENERATOR',
668 dep_vars = dep_vars,
669 name=name)
670
671 if vars is None:
672 vars = {}
673 t.env.SAMBA_GENERATOR_VARS = vars
674
675 if always:
676 t.always = True
677
678 if public_headers is not None:
679 bld.PUBLIC_HEADERS(public_headers, header_path=header_path,
680 public_headers_install=public_headers_install)
681 return t
682Build.BuildContext.SAMBA_GENERATOR = SAMBA_GENERATOR
683
684
685
686@Utils.run_once
687def SETUP_BUILD_GROUPS(bld):
688 '''setup build groups used to ensure that the different build
689 phases happen consecutively'''
690 bld.p_ln = bld.srcnode # we do want to see all targets!
691 bld.env['USING_BUILD_GROUPS'] = True
692 bld.add_group('setup')
693 bld.add_group('build_compiler_source')
694 bld.add_group('vscripts')
695 bld.add_group('base_libraries')
696 bld.add_group('generators')
697 bld.add_group('compiler_prototypes')
698 bld.add_group('compiler_libraries')
699 bld.add_group('build_compilers')
700 bld.add_group('build_source')
701 bld.add_group('prototypes')
702 bld.add_group('headers')
703 bld.add_group('main')
704 bld.add_group('symbolcheck')
705 bld.add_group('syslibcheck')
706 bld.add_group('final')
707Build.BuildContext.SETUP_BUILD_GROUPS = SETUP_BUILD_GROUPS
708
709
710def SET_BUILD_GROUP(bld, group):
711 '''set the current build group'''
712 if not 'USING_BUILD_GROUPS' in bld.env:
713 return
714 bld.set_group(group)
715Build.BuildContext.SET_BUILD_GROUP = SET_BUILD_GROUP
716
717
718
719@conf
720def ENABLE_TIMESTAMP_DEPENDENCIES(conf):
721 """use timestamps instead of file contents for deps
722 this currently doesn't work"""
723 def h_file(filename):
724 import stat
725 st = os.stat(filename)
726 if stat.S_ISDIR(st[stat.ST_MODE]): raise IOError('not a file')
727 m = Utils.md5()
728 m.update(str(st.st_mtime))
729 m.update(str(st.st_size))
730 m.update(filename)
731 return m.digest()
732 Utils.h_file = h_file
733
734
735def SAMBA_SCRIPT(bld, name, pattern, installdir, installname=None):
736 '''used to copy scripts from the source tree into the build directory
737 for use by selftest'''
738
739 source = bld.path.ant_glob(pattern, flat=True)
740
741 bld.SET_BUILD_GROUP('build_source')
742 for s in TO_LIST(source):
743 iname = s
744 if installname is not None:
745 iname = installname
746 target = os.path.join(installdir, iname)
747 tgtdir = os.path.dirname(os.path.join(bld.srcnode.abspath(bld.env), '..', target))
748 mkdir_p(tgtdir)
749 link_src = os.path.normpath(os.path.join(bld.curdir, s))
750 link_dst = os.path.join(tgtdir, os.path.basename(iname))
751 if os.path.islink(link_dst) and os.readlink(link_dst) == link_src:
752 continue
753 if os.path.exists(link_dst):
754 os.unlink(link_dst)
755 Logs.info("symlink: %s -> %s/%s" % (s, installdir, iname))
756 os.symlink(link_src, link_dst)
757Build.BuildContext.SAMBA_SCRIPT = SAMBA_SCRIPT
758
759
760def copy_and_fix_python_path(task):
761 pattern='sys.path.insert(0, "bin/python")'
762 if task.env["PYTHONARCHDIR"] in sys.path and task.env["PYTHONDIR"] in sys.path:
763 replacement = ""
764 elif task.env["PYTHONARCHDIR"] == task.env["PYTHONDIR"]:
765 replacement="""sys.path.insert(0, "%s")""" % task.env["PYTHONDIR"]
766 else:
767 replacement="""sys.path.insert(0, "%s")
768sys.path.insert(1, "%s")""" % (task.env["PYTHONARCHDIR"], task.env["PYTHONDIR"])
769
770 if task.env["PYTHON"][0] == "/":
771 replacement_shebang = "#!%s\n" % task.env["PYTHON"]
772 else:
773 replacement_shebang = "#!/usr/bin/env %s\n" % task.env["PYTHON"]
774
775 installed_location=task.outputs[0].bldpath(task.env)
776 source_file = open(task.inputs[0].srcpath(task.env))
777 installed_file = open(installed_location, 'w')
778 lineno = 0
779 for line in source_file:
780 newline = line
781 if (lineno == 0 and task.env["PYTHON_SPECIFIED"] is True and
782 line[:2] == "#!"):
783 newline = replacement_shebang
784 elif pattern in line:
785 newline = line.replace(pattern, replacement)
786 installed_file.write(newline)
787 lineno = lineno + 1
788 installed_file.close()
789 os.chmod(installed_location, 0755)
790 return 0
791
792def copy_and_fix_perl_path(task):
793 pattern='use lib "$RealBin/lib";'
794
795 replacement = ""
796 if not task.env["PERL_LIB_INSTALL_DIR"] in task.env["PERL_INC"]:
797 replacement = 'use lib "%s";' % task.env["PERL_LIB_INSTALL_DIR"]
798
799 if task.env["PERL"][0] == "/":
800 replacement_shebang = "#!%s\n" % task.env["PERL"]
801 else:
802 replacement_shebang = "#!/usr/bin/env %s\n" % task.env["PERL"]
803
804 installed_location=task.outputs[0].bldpath(task.env)
805 source_file = open(task.inputs[0].srcpath(task.env))
806 installed_file = open(installed_location, 'w')
807 lineno = 0
808 for line in source_file:
809 newline = line
810 if lineno == 0 and task.env["PERL_SPECIFIED"] == True and line[:2] == "#!":
811 newline = replacement_shebang
812 elif pattern in line:
813 newline = line.replace(pattern, replacement)
814 installed_file.write(newline)
815 lineno = lineno + 1
816 installed_file.close()
817 os.chmod(installed_location, 0755)
818 return 0
819
820
821def install_file(bld, destdir, file, chmod=MODE_644, flat=False,
822 python_fixup=False, perl_fixup=False,
823 destname=None, base_name=None):
824 '''install a file'''
825 destdir = bld.EXPAND_VARIABLES(destdir)
826 if not destname:
827 destname = file
828 if flat:
829 destname = os.path.basename(destname)
830 dest = os.path.join(destdir, destname)
831 if python_fixup:
832 # fix the path python will use to find Samba modules
833 inst_file = file + '.inst'
834 bld.SAMBA_GENERATOR('python_%s' % destname,
835 rule=copy_and_fix_python_path,
836 dep_vars=["PYTHON","PYTHON_SPECIFIED","PYTHONDIR","PYTHONARCHDIR"],
837 source=file,
838 target=inst_file)
839 file = inst_file
840 if perl_fixup:
841 # fix the path perl will use to find Samba modules
842 inst_file = file + '.inst'
843 bld.SAMBA_GENERATOR('perl_%s' % destname,
844 rule=copy_and_fix_perl_path,
845 dep_vars=["PERL","PERL_SPECIFIED","PERL_LIB_INSTALL_DIR"],
846 source=file,
847 target=inst_file)
848 file = inst_file
849 if base_name:
850 file = os.path.join(base_name, file)
851 bld.install_as(dest, file, chmod=chmod)
852
853
854def INSTALL_FILES(bld, destdir, files, chmod=MODE_644, flat=False,
855 python_fixup=False, perl_fixup=False,
856 destname=None, base_name=None):
857 '''install a set of files'''
858 for f in TO_LIST(files):
859 install_file(bld, destdir, f, chmod=chmod, flat=flat,
860 python_fixup=python_fixup, perl_fixup=perl_fixup,
861 destname=destname, base_name=base_name)
862Build.BuildContext.INSTALL_FILES = INSTALL_FILES
863
864
865def INSTALL_WILDCARD(bld, destdir, pattern, chmod=MODE_644, flat=False,
866 python_fixup=False, exclude=None, trim_path=None):
867 '''install a set of files matching a wildcard pattern'''
868 files=TO_LIST(bld.path.ant_glob(pattern, flat=True))
869 if trim_path:
870 files2 = []
871 for f in files:
872 files2.append(os_path_relpath(f, trim_path))
873 files = files2
874
875 if exclude:
876 for f in files[:]:
877 if fnmatch.fnmatch(f, exclude):
878 files.remove(f)
879 INSTALL_FILES(bld, destdir, files, chmod=chmod, flat=flat,
880 python_fixup=python_fixup, base_name=trim_path)
881Build.BuildContext.INSTALL_WILDCARD = INSTALL_WILDCARD
882
883
884def INSTALL_DIRS(bld, destdir, dirs):
885 '''install a set of directories'''
886 destdir = bld.EXPAND_VARIABLES(destdir)
887 dirs = bld.EXPAND_VARIABLES(dirs)
888 for d in TO_LIST(dirs):
889 bld.install_dir(os.path.join(destdir, d))
890Build.BuildContext.INSTALL_DIRS = INSTALL_DIRS
891
892
893def MANPAGES(bld, manpages, install):
894 '''build and install manual pages'''
895 bld.env.MAN_XSL = 'http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
896 for m in manpages.split():
897 source = m + '.xml'
898 bld.SAMBA_GENERATOR(m,
899 source=source,
900 target=m,
901 group='final',
902 rule='${XSLTPROC} --xinclude -o ${TGT} --nonet ${MAN_XSL} ${SRC}'
903 )
904 if install:
905 bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m, flat=True)
906Build.BuildContext.MANPAGES = MANPAGES
907
908def SAMBAMANPAGES(bld, manpages, extra_source=None):
909 '''build and install manual pages'''
910 bld.env.SAMBA_EXPAND_XSL = bld.srcnode.abspath() + '/docs-xml/xslt/expand-sambadoc.xsl'
911 bld.env.SAMBA_MAN_XSL = bld.srcnode.abspath() + '/docs-xml/xslt/man.xsl'
912 bld.env.SAMBA_CATALOG = bld.srcnode.abspath() + '/bin/default/docs-xml/build/catalog.xml'
913 bld.env.SAMBA_CATALOGS = 'file:///etc/xml/catalog file:///usr/local/share/xml/catalog file://' + bld.env.SAMBA_CATALOG
914
915 for m in manpages.split():
916 source = m + '.xml'
917 if extra_source is not None:
918 source = [source, extra_source]
919 bld.SAMBA_GENERATOR(m,
920 source=source,
921 target=m,
922 group='final',
923 dep_vars=['SAMBA_MAN_XSL', 'SAMBA_EXPAND_XSL', 'SAMBA_CATALOG'],
924 rule='''XML_CATALOG_FILES="${SAMBA_CATALOGS}"
925 export XML_CATALOG_FILES
926 ${XSLTPROC} --xinclude --stringparam noreference 0 -o ${TGT}.xml --nonet ${SAMBA_EXPAND_XSL} ${SRC[0].abspath(env)}
927 ${XSLTPROC} --nonet -o ${TGT} ${SAMBA_MAN_XSL} ${TGT}.xml'''
928 )
929 bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m, flat=True)
930Build.BuildContext.SAMBAMANPAGES = SAMBAMANPAGES
931
932#############################################################
933# give a nicer display when building different types of files
934def progress_display(self, msg, fname):
935 col1 = Logs.colors(self.color)
936 col2 = Logs.colors.NORMAL
937 total = self.position[1]
938 n = len(str(total))
939 fs = '[%%%dd/%%%dd] %s %%s%%s%%s\n' % (n, n, msg)
940 return fs % (self.position[0], self.position[1], col1, fname, col2)
941
942def link_display(self):
943 if Options.options.progress_bar != 0:
944 return Task.Task.old_display(self)
945 fname = self.outputs[0].bldpath(self.env)
946 return progress_display(self, 'Linking', fname)
947Task.TaskBase.classes['cc_link'].display = link_display
948
949def samba_display(self):
950 if Options.options.progress_bar != 0:
951 return Task.Task.old_display(self)
952
953 targets = LOCAL_CACHE(self, 'TARGET_TYPE')
954 if self.name in targets:
955 target_type = targets[self.name]
956 type_map = { 'GENERATOR' : 'Generating',
957 'PROTOTYPE' : 'Generating'
958 }
959 if target_type in type_map:
960 return progress_display(self, type_map[target_type], self.name)
961
962 if len(self.inputs) == 0:
963 return Task.Task.old_display(self)
964
965 fname = self.inputs[0].bldpath(self.env)
966 if fname[0:3] == '../':
967 fname = fname[3:]
968 ext_loc = fname.rfind('.')
969 if ext_loc == -1:
970 return Task.Task.old_display(self)
971 ext = fname[ext_loc:]
972
973 ext_map = { '.idl' : 'Compiling IDL',
974 '.et' : 'Compiling ERRTABLE',
975 '.asn1': 'Compiling ASN1',
976 '.c' : 'Compiling' }
977 if ext in ext_map:
978 return progress_display(self, ext_map[ext], fname)
979 return Task.Task.old_display(self)
980
981Task.TaskBase.classes['Task'].old_display = Task.TaskBase.classes['Task'].display
982Task.TaskBase.classes['Task'].display = samba_display
983
984
985@after('apply_link')
986@feature('cshlib')
987def apply_bundle_remove_dynamiclib_patch(self):
988 if self.env['MACBUNDLE'] or getattr(self,'mac_bundle',False):
989 if not getattr(self,'vnum',None):
990 try:
991 self.env['LINKFLAGS'].remove('-dynamiclib')
992 self.env['LINKFLAGS'].remove('-single_module')
993 except ValueError:
994 pass
Note: See TracBrowser for help on using the repository browser.