buildtools/wafsamba/wafsamba.py

   1 # a waf tool to add autoconf-like macros to the configure section
   2 # and for SAMBA_ macros for building libraries, binaries etc
   3
   4 import Build, os, Options, Task, Utils, cc, TaskGen, fnmatch, re, shutil, Logs, Constants
   5 from Configure import conf
   6 from Logs import debug
   7 from samba_utils import SUBST_VARS_RECURSIVE
   8 TaskGen.task_gen.apply_verif = Utils.nada
   9
  10 # bring in the other samba modules
  11 from samba_optimisation import *
  12 from samba_utils import *
  13 from samba_version import *
  14 from samba_autoconf import *
  15 from samba_patterns import *
  16 from samba_pidl import *
  17 from samba_autoproto import *
  18 from samba_python import *
  19 from samba_deps import *
  20 from samba_bundled import *
  21 import samba_install
  22 import samba_conftests
  23 import samba_abi
  24 import tru64cc
  25 import irixcc
  26 import generic_cc
  27 import samba_dist
  28 import samba_wildcard
  29 import stale_files
  30
  31 # some systems have broken threading in python
  32 if os.environ.get('WAF_NOTHREADS') == '1':
  33     import nothreads
  34
  35 LIB_PATH="shared"
  36
  37 os.putenv('PYTHONUNBUFFERED', '1')
  38
  39
  40 if Constants.HEXVERSION < 0x105019:
  41     Logs.error('''
  42 Please use the version of waf that comes with Samba, not
  43 a system installed version. See http://wiki.samba.org/index.php/Waf
  44 for details.
  45
  46 Alternatively, please use ./autogen-waf.sh, and then
  47 run ./configure and make as usual. That will call the right version of waf.
  48 ''')
  49     sys.exit(1)
  50
  51
  52 @conf
  53 def SAMBA_BUILD_ENV(conf):
  54     '''create the samba build environment'''
  55     conf.env.BUILD_DIRECTORY = conf.blddir
  56     mkdir_p(os.path.join(conf.blddir, LIB_PATH))
  57     mkdir_p(os.path.join(conf.blddir, "modules"))
  58     mkdir_p(os.path.join(conf.blddir, 'python/samba/dcerpc'))
  59     # this allows all of the bin/shared and bin/python targets
  60     # to be expressed in terms of build directory paths
  61     mkdir_p(os.path.join(conf.blddir, 'default'))
  62     for p in ['python','shared', 'modules']:
  63         link_target = os.path.join(conf.blddir, 'default/' + p)
  64         if not os.path.lexists(link_target):
  65             os.symlink('../' + p, link_target)
  66
  67     # get perl to put the blib files in the build directory
  68     blib_bld = os.path.join(conf.blddir, 'default/pidl/blib')
  69     blib_src = os.path.join(conf.srcdir, 'pidl/blib')
  70     mkdir_p(blib_bld + '/man1')
  71     mkdir_p(blib_bld + '/man3')
  72     if os.path.islink(blib_src):
  73         os.unlink(blib_src)
  74     elif os.path.exists(blib_src):
  75         shutil.rmtree(blib_src)
  76
  77
  78 def ADD_INIT_FUNCTION(bld, subsystem, target, init_function):
  79     '''add an init_function to the list for a subsystem'''
  80     if init_function is None:
  81         return
  82     bld.ASSERT(subsystem is not None, "You must specify a subsystem for init_function '%s'" % init_function)
  83     cache = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
  84     if not subsystem in cache:
  85         cache[subsystem] = []
  86     cache[subsystem].append( { 'TARGET':target, 'INIT_FUNCTION':init_function } )
  87 Build.BuildContext.ADD_INIT_FUNCTION = ADD_INIT_FUNCTION
  88
  89
  90
  91 #################################################################
  92 def SAMBA_LIBRARY(bld, libname, source,
  93                   deps='',
  94                   public_deps='',
  95                   includes='',
  96                   public_headers=None,
  97                   header_path=None,
  98                   pc_files=None,
  99                   vnum=None,
 100                   cflags='',
 101                   external_library=False,
 102                   realname=None,
 103                   autoproto=None,
 104                   group='main',
 105                   depends_on='',
 106                   local_include=True,
 107                   vars=None,
 108                   install_path=None,
 109                   install=True,
 110                   pyembed=False,
 111                   pyext=False,
 112                   target_type='LIBRARY',
 113                   bundled_extension=True,
 114                   link_name=None,
 115                   abi_file=None,
 116                   abi_match=None,
 117                   hide_symbols=False,
 118                   manpages=None,
 119                   private_library=False,
 120                   grouping_library=False,
 121                   enabled=True):
 122     '''define a Samba library'''
 123
 124     if not enabled:
 125         SET_TARGET_TYPE(bld, libname, 'DISABLED')
 126         return
 127
 128     source = bld.EXPAND_VARIABLES(source, vars=vars)
 129
 130     # remember empty libraries, so we can strip the dependencies
 131     if ((source == '') or (source == [])) and deps == '' and public_deps == '':
 132         SET_TARGET_TYPE(bld, libname, 'EMPTY')
 133         return
 134
 135     if BUILTIN_LIBRARY(bld, libname):
 136         obj_target = libname
 137     else:
 138         obj_target = libname + '.objlist'
 139
 140     # first create a target for building the object files for this library
 141     # by separating in this way, we avoid recompiling the C files
 142     # separately for the install library and the build library
 143     bld.SAMBA_SUBSYSTEM(obj_target,
 144                         source         = source,
 145                         deps           = deps,
 146                         public_deps    = public_deps,
 147                         includes       = includes,
 148                         public_headers = public_headers,
 149                         header_path    = header_path,
 150                         cflags         = cflags,
 151                         group          = group,
 152                         autoproto      = autoproto,
 153                         depends_on     = depends_on,
 154                         hide_symbols   = hide_symbols,
 155                         pyext          = pyext or (target_type == "PYTHON"),
 156                         local_include  = local_include)
 157
 158     if BUILTIN_LIBRARY(bld, libname):
 159         return
 160
 161     if not SET_TARGET_TYPE(bld, libname, target_type):
 162         return
 163
 164     # the library itself will depend on that object target
 165     deps += ' ' + public_deps
 166     deps = TO_LIST(deps)
 167     deps.append(obj_target)
 168
 169     realname = bld.map_shlib_extension(realname, python=(target_type=='PYTHON'))
 170     link_name = bld.map_shlib_extension(link_name, python=(target_type=='PYTHON'))
 171
 172     # we don't want any public libraries without version numbers
 173     if not private_library and vnum is None and target_type != 'PYTHON' and not realname:
 174         raise Utils.WafError("public library '%s' must have a vnum" % libname)
 175
 176     if target_type == 'PYTHON' or realname or not private_library:
 177         bundled_name = libname.replace('_', '-')
 178     else:
 179         bundled_name = PRIVATE_NAME(bld, libname, bundled_extension, private_library)
 180
 181     if private_library:
 182         if vnum:
 183             Logs.error("vnum is invalid for private libraries")
 184             sys.exit(1)
 185         vnum = bld.env.PACKAGE_VERSION
 186
 187     features = 'cc cshlib symlink_lib install_lib'
 188     if target_type == 'PYTHON':
 189         features += ' pyext'
 190     if pyext or pyembed:
 191         # this is quite strange. we should add pyext feature for pyext
 192         # but that breaks the build. This may be a bug in the waf python tool
 193         features += ' pyembed'
 194     if abi_file:
 195         features += ' abi_check'
 196
 197     if abi_file:
 198         abi_file = os.path.join(bld.curdir, abi_file)
 199
 200     bld.SET_BUILD_GROUP(group)
 201     t = bld(
 202         features        = features,
 203         source          = [],
 204         target          = bundled_name,
 205         depends_on      = depends_on,
 206         samba_deps      = deps,
 207         samba_includes  = includes,
 208         local_include   = local_include,
 209         vnum            = vnum,
 210         install_path    = None,
 211         samba_inst_path = install_path,
 212         name            = libname,
 213         samba_realname  = realname,
 214         samba_install   = install,
 215         abi_file        = abi_file,
 216         abi_match       = abi_match,
 217         private_library = private_library,
 218         grouping_library=grouping_library
 219         )
 220
 221     if realname and not link_name:
 222         link_name = 'shared/%s' % realname
 223
 224     if link_name:
 225         t.link_name = link_name
 226
 227     if pc_files is not None:
 228         bld.PKG_CONFIG_FILES(pc_files, vnum=vnum)
 229
 230     if manpages is not None and 'XSLTPROC_MANPAGES' in bld.env and bld.env['XSLTPROC_MANPAGES']:
 231         bld.MANPAGES(manpages)
 232
 233
 234 Build.BuildContext.SAMBA_LIBRARY = SAMBA_LIBRARY
 235
 236
 237 #################################################################
 238 def SAMBA_BINARY(bld, binname, source,
 239                  deps='',
 240                  includes='',
 241                  public_headers=None,
 242                  header_path=None,
 243                  modules=None,
 244                  ldflags=None,
 245                  cflags='',
 246                  autoproto=None,
 247                  use_hostcc=False,
 248                  use_global_deps=True,
 249                  compiler=None,
 250                  group='binaries',
 251                  manpages=None,
 252                  local_include=True,
 253                  subsystem_name=None,
 254                  pyembed=False,
 255                  vars=None,
 256                  install=True,
 257                  install_path=None,
 258                  enabled=True):
 259     '''define a Samba binary'''
 260
 261     if not enabled:
 262         SET_TARGET_TYPE(bld, binname, 'DISABLED')
 263         return
 264
 265     if not SET_TARGET_TYPE(bld, binname, 'BINARY'):
 266         return
 267
 268     features = 'cc cprogram symlink_bin install_bin'
 269     if pyembed:
 270         features += ' pyembed'
 271
 272     obj_target = binname + '.objlist'
 273
 274     source = bld.EXPAND_VARIABLES(source, vars=vars)
 275     source = unique_list(TO_LIST(source))
 276
 277     # first create a target for building the object files for this binary
 278     # by separating in this way, we avoid recompiling the C files
 279     # separately for the install binary and the build binary
 280     bld.SAMBA_SUBSYSTEM(obj_target,
 281                         source         = source,
 282                         deps           = deps,
 283                         includes       = includes,
 284                         cflags         = cflags,
 285                         group          = group,
 286                         autoproto      = autoproto,
 287                         subsystem_name = subsystem_name,
 288                         local_include  = local_include,
 289                         use_hostcc     = use_hostcc,
 290                         pyext          = pyembed,
 291                         use_global_deps= use_global_deps)
 292
 293     bld.SET_BUILD_GROUP(group)
 294
 295     # the binary itself will depend on that object target
 296     deps = TO_LIST(deps)
 297     deps.append(obj_target)
 298
 299     t = bld(
 300         features       = features,
 301         source         = [],
 302         target         = binname,
 303         samba_deps     = deps,
 304         samba_includes = includes,
 305         local_include  = local_include,
 306         samba_modules  = modules,
 307         top            = True,
 308         samba_subsystem= subsystem_name,
 309         install_path   = None,
 310         samba_inst_path= install_path,
 311         samba_install  = install
 312         )
 313
 314     # setup the subsystem_name as an alias for the real
 315     # binary name, so it can be found when expanding
 316     # subsystem dependencies
 317     if subsystem_name is not None:
 318         bld.TARGET_ALIAS(subsystem_name, binname)
 319
 320     if manpages is not None and 'XSLTPROC_MANPAGES' in bld.env and bld.env['XSLTPROC_MANPAGES']:
 321         bld.MANPAGES(manpages)
 322
 323 Build.BuildContext.SAMBA_BINARY = SAMBA_BINARY
 324
 325
 326 #################################################################
 327 def SAMBA_MODULE(bld, modname, source,
 328                  deps='',
 329                  includes='',
 330                  subsystem=None,
 331                  init_function=None,
 332                  autoproto=None,
 333                  autoproto_extra_source='',
 334                  aliases=None,
 335                  cflags='',
 336                  internal_module=True,
 337                  local_include=True,
 338                  vars=None,
 339                  enabled=True,
 340                  pyembed=True,
 341                  ):
 342     '''define a Samba module.'''
 343
 344     source = bld.EXPAND_VARIABLES(source, vars=vars)
 345
 346     if internal_module or BUILTIN_LIBRARY(bld, modname):
 347         # treat internal modules as subsystems for now
 348         if subsystem is not None:
 349             deps += ' ' + subsystem
 350
 351         bld.SAMBA_SUBSYSTEM(modname, source,
 352                     deps=deps,
 353                     includes=includes,
 354                     autoproto=autoproto,
 355                     autoproto_extra_source=autoproto_extra_source,
 356                     cflags=cflags,
 357                     local_include=local_include,
 358                     enabled=enabled)
 359
 360         bld.ADD_INIT_FUNCTION(subsystem, modname, init_function)
 361         return
 362
 363     if not enabled:
 364         SET_TARGET_TYPE(bld, modname, 'DISABLED')
 365         return
 366
 367     if aliases is not None:
 368         # if we have aliases, then create a private base library, and a set
 369         # of modules on top of that library
 370         if init_function:
 371             cflags += " -D%s=samba_init_module" % init_function
 372
 373         basename = modname + '-base'
 374         bld.SAMBA_LIBRARY(basename,
 375                           source,
 376                           deps=deps,
 377                           cflags=cflags,
 378                           autoproto = autoproto,
 379                           local_include=local_include,
 380                           vars=vars,
 381                           pyembed=pyembed,
 382                           private_library=True
 383                           )
 384
 385         aliases = TO_LIST(aliases)
 386         aliases.append(modname)
 387
 388         for alias in aliases:
 389             bld.SAMBA_MODULE(alias,
 390                              source=[],
 391                              internal_module=False,
 392                              subsystem=subsystem,
 393                              init_function=init_function,
 394                              deps=basename)
 395         return
 396
 397
 398     obj_target = modname + '.objlist'
 399
 400     realname = modname
 401     if subsystem is not None:
 402         deps += ' ' + subsystem
 403         while realname.startswith("lib"+subsystem+"_"):
 404             realname = realname[len("lib"+subsystem+"_"):]
 405         while realname.startswith(subsystem+"_"):
 406             realname = realname[len(subsystem+"_"):]
 407
 408     realname = bld.make_libname(realname)
 409     while realname.startswith("lib"):
 410         realname = realname[len("lib"):]
 411
 412     build_link_name = "modules/%s/%s" % (subsystem, realname)
 413
 414     if init_function:
 415         cflags += " -D%s=samba_init_module" % init_function
 416
 417     bld.SAMBA_LIBRARY(modname,
 418                       source,
 419                       deps=deps,
 420                       cflags=cflags,
 421                       realname = realname,
 422                       autoproto = autoproto,
 423                       local_include=local_include,
 424                       vars=vars,
 425                       link_name=build_link_name,
 426                       install_path="${MODULESDIR}/%s" % subsystem,
 427                       pyembed=pyembed,
 428                       )
 429
 430
 431 Build.BuildContext.SAMBA_MODULE = SAMBA_MODULE
 432
 433
 434 #################################################################
 435 def SAMBA_SUBSYSTEM(bld, modname, source,
 436                     deps='',
 437                     public_deps='',
 438                     includes='',
 439                     public_headers=None,
 440                     header_path=None,
 441                     cflags='',
 442                     cflags_end=None,
 443                     group='main',
 444                     init_function_sentinal=None,
 445                     autoproto=None,
 446                     autoproto_extra_source='',
 447                     depends_on='',
 448                     local_include=True,
 449                     local_include_first=True,
 450                     subsystem_name=None,
 451                     enabled=True,
 452                     use_hostcc=False,
 453                     use_global_deps=True,
 454                     vars=None,
 455                     hide_symbols=False,
 456                     pyext=False):
 457     '''define a Samba subsystem'''
 458
 459     if not enabled:
 460         SET_TARGET_TYPE(bld, modname, 'DISABLED')
 461         return
 462
 463     # remember empty subsystems, so we can strip the dependencies
 464     if ((source == '') or (source == [])) and deps == '' and public_deps == '':
 465         SET_TARGET_TYPE(bld, modname, 'EMPTY')
 466         return
 467
 468     if not SET_TARGET_TYPE(bld, modname, 'SUBSYSTEM'):
 469         return
 470
 471     source = bld.EXPAND_VARIABLES(source, vars=vars)
 472     source = unique_list(TO_LIST(source))
 473
 474     deps += ' ' + public_deps
 475
 476     bld.SET_BUILD_GROUP(group)
 477
 478     features = 'cc'
 479     if pyext:
 480         features += ' pyext'
 481
 482     t = bld(
 483         features       = features,
 484         source         = source,
 485         target         = modname,
 486         samba_cflags   = CURRENT_CFLAGS(bld, modname, cflags, hide_symbols=hide_symbols),
 487         depends_on     = depends_on,
 488         samba_deps     = TO_LIST(deps),
 489         samba_includes = includes,
 490         local_include  = local_include,
 491         local_include_first  = local_include_first,
 492         samba_subsystem= subsystem_name,
 493         samba_use_hostcc = use_hostcc,
 494         samba_use_global_deps = use_global_deps
 495         )
 496
 497     if cflags_end is not None:
 498         t.samba_cflags.extend(TO_LIST(cflags_end))
 499
 500     if autoproto is not None:
 501         bld.SAMBA_AUTOPROTO(autoproto, source + TO_LIST(autoproto_extra_source))
 502     if public_headers is not None:
 503         bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
 504     return t
 505
 506
 507 Build.BuildContext.SAMBA_SUBSYSTEM = SAMBA_SUBSYSTEM
 508
 509
 510 def SAMBA_GENERATOR(bld, name, rule, source='', target='',
 511                     group='generators', enabled=True,
 512                     public_headers=None,
 513                     header_path=None,
 514                     vars=None,
 515                     always=False):
 516     '''A generic source generator target'''
 517
 518     if not SET_TARGET_TYPE(bld, name, 'GENERATOR'):
 519         return
 520
 521     if not enabled:
 522         return
 523
 524     bld.SET_BUILD_GROUP(group)
 525     t = bld(
 526         rule=rule,
 527         source=bld.EXPAND_VARIABLES(source, vars=vars),
 528         target=target,
 529         shell=isinstance(rule, str),
 530         on_results=True,
 531         before='cc',
 532         ext_out='.c',
 533         name=name)
 534
 535     if always:
 536         t.always = True
 537
 538     if public_headers is not None:
 539         bld.PUBLIC_HEADERS(public_headers, header_path=header_path)
 540     return t
 541 Build.BuildContext.SAMBA_GENERATOR = SAMBA_GENERATOR
 542
 543
 544
 545 @runonce
 546 def SETUP_BUILD_GROUPS(bld):
 547     '''setup build groups used to ensure that the different build
 548     phases happen consecutively'''
 549     bld.p_ln = bld.srcnode # we do want to see all targets!
 550     bld.env['USING_BUILD_GROUPS'] = True
 551     bld.add_group('setup')
 552     bld.add_group('build_compiler_source')
 553     bld.add_group('base_libraries')
 554     bld.add_group('generators')
 555     bld.add_group('compiler_prototypes')
 556     bld.add_group('compiler_libraries')
 557     bld.add_group('build_compilers')
 558     bld.add_group('build_source')
 559     bld.add_group('prototypes')
 560     bld.add_group('main')
 561     bld.add_group('binaries')
 562     bld.add_group('final')
 563 Build.BuildContext.SETUP_BUILD_GROUPS = SETUP_BUILD_GROUPS
 564
 565
 566 def SET_BUILD_GROUP(bld, group):
 567     '''set the current build group'''
 568     if not 'USING_BUILD_GROUPS' in bld.env:
 569         return
 570     bld.set_group(group)
 571 Build.BuildContext.SET_BUILD_GROUP = SET_BUILD_GROUP
 572
 573
 574
 575 @conf
 576 def ENABLE_TIMESTAMP_DEPENDENCIES(conf):
 577     """use timestamps instead of file contents for deps
 578     this currently doesn't work"""
 579     def h_file(filename):
 580         import stat
 581         st = os.stat(filename)
 582         if stat.S_ISDIR(st[stat.ST_MODE]): raise IOError('not a file')
 583         m = Utils.md5()
 584         m.update(str(st.st_mtime))
 585         m.update(str(st.st_size))
 586         m.update(filename)
 587         return m.digest()
 588     Utils.h_file = h_file
 589
 590
 591
 592 t = Task.simple_task_type('copy_script', 'rm -f ${LINK_TARGET} && ln -s ${SRC[0].abspath(env)} ${LINK_TARGET}',
 593                           shell=True, color='PINK', ext_in='.bin')
 594 t.quiet = True
 595
 596 @feature('copy_script')
 597 @before('apply_link')
 598 def copy_script(self):
 599     tsk = self.create_task('copy_script', self.allnodes[0])
 600     tsk.env.TARGET = self.target
 601
 602 def SAMBA_SCRIPT(bld, name, pattern, installdir, installname=None):
 603     '''used to copy scripts from the source tree into the build directory
 604        for use by selftest'''
 605
 606     source = bld.path.ant_glob(pattern)
 607
 608     bld.SET_BUILD_GROUP('build_source')
 609     for s in TO_LIST(source):
 610         iname = s
 611         if installname != None:
 612             iname = installname
 613         target = os.path.join(installdir, iname)
 614         tgtdir = os.path.dirname(os.path.join(bld.srcnode.abspath(bld.env), '..', target))
 615         mkdir_p(tgtdir)
 616         t = bld(features='copy_script',
 617                 source       = s,
 618                 target       = target,
 619                 always       = True,
 620                 install_path = None)
 621         t.env.LINK_TARGET = target
 622
 623 Build.BuildContext.SAMBA_SCRIPT = SAMBA_SCRIPT
 624
 625
 626 def install_file(bld, destdir, file, chmod=MODE_644, flat=False,
 627                  python_fixup=False, destname=None, base_name=None):
 628     '''install a file'''
 629     destdir = bld.EXPAND_VARIABLES(destdir)
 630     if not destname:
 631         destname = file
 632         if flat:
 633             destname = os.path.basename(destname)
 634     dest = os.path.join(destdir, destname)
 635     if python_fixup:
 636         # fixup the python path it will use to find Samba modules
 637         inst_file = file + '.inst'
 638         if bld.env["PYTHONDIR"] not in sys.path:
 639             regex = "s|\(sys.path.insert.*\)bin/python\(.*\)$|\\1${PYTHONDIR}\\2|g"
 640         else:
 641             # Eliminate updating sys.path if the target python dir is already
 642             # in python path.
 643             regex = "s|sys.path.insert.*bin/python.*$||g"
 644         bld.SAMBA_GENERATOR('python_%s' % destname,
 645                             rule="sed '%s' < ${SRC} > ${TGT}" % regex,
 646                             source=file,
 647                             target=inst_file)
 648         file = inst_file
 649     if base_name:
 650         file = os.path.join(base_name, file)
 651     bld.install_as(dest, file, chmod=chmod)
 652
 653
 654 def INSTALL_FILES(bld, destdir, files, chmod=MODE_644, flat=False,
 655                   python_fixup=False, destname=None, base_name=None):
 656     '''install a set of files'''
 657     for f in TO_LIST(files):
 658         install_file(bld, destdir, f, chmod=chmod, flat=flat,
 659                      python_fixup=python_fixup, destname=destname,
 660                      base_name=base_name)
 661 Build.BuildContext.INSTALL_FILES = INSTALL_FILES
 662
 663
 664 def INSTALL_WILDCARD(bld, destdir, pattern, chmod=MODE_644, flat=False,
 665                      python_fixup=False, exclude=None, trim_path=None):
 666     '''install a set of files matching a wildcard pattern'''
 667     files=TO_LIST(bld.path.ant_glob(pattern))
 668     if trim_path:
 669         files2 = []
 670         for f in files:
 671             files2.append(os_path_relpath(f, trim_path))
 672         files = files2
 673
 674     if exclude:
 675         for f in files[:]:
 676             if fnmatch.fnmatch(f, exclude):
 677                 files.remove(f)
 678     INSTALL_FILES(bld, destdir, files, chmod=chmod, flat=flat,
 679                   python_fixup=python_fixup, base_name=trim_path)
 680 Build.BuildContext.INSTALL_WILDCARD = INSTALL_WILDCARD
 681
 682
 683 def INSTALL_DIRS(bld, destdir, dirs):
 684     '''install a set of directories'''
 685     destdir = bld.EXPAND_VARIABLES(destdir)
 686     dirs = bld.EXPAND_VARIABLES(dirs)
 687     for d in TO_LIST(dirs):
 688         bld.install_dir(os.path.join(destdir, d))
 689 Build.BuildContext.INSTALL_DIRS = INSTALL_DIRS
 690
 691
 692 re_header = re.compile('#include[ \t]*"([^"]+)"', re.I | re.M)
 693 class header_task(Task.Task):
 694     """
 695     The public headers (the one installed on the system) have both
 696     different paths and contents, so the rename is not enough.
 697
 698     Intermediate .inst.h files are created because path manipulation
 699     may be slow. The substitution is thus performed only once.
 700     """
 701
 702     name = 'header'
 703     color = 'PINK'
 704     vars = ['INCLUDEDIR', 'HEADER_DEPS']
 705
 706     def run(self):
 707         txt = self.inputs[0].read(self.env)
 708
 709         # hard-coded string, but only present in samba4 (I promise, you won't feel a thing)
 710         txt = txt.replace('#if _SAMBA_BUILD_ == 4', '#if 1\n')
 711
 712         # use a regexp to substitute the #include lines in the files
 713         map = self.generator.bld.hnodemap
 714         dirnodes = self.generator.bld.hnodedirs
 715         def repl(m):
 716             if m.group(1):
 717                 s = m.group(1)
 718
 719                 # pokemon headers: gotta catch'em all!
 720                 fin = s
 721                 if s.startswith('bin/default'):
 722                     node = self.generator.bld.srcnode.find_resource(s.replace('bin/default/', ''))
 723                     if not node:
 724                         Logs.warn('could not find the public header for %r' % s)
 725                     elif node.id in map:
 726                         fin = map[node.id]
 727                     else:
 728                         Logs.warn('could not find the public header replacement for build header %r' % s)
 729                 else:
 730                     # this part is more difficult since the path may be relative to anything
 731                     for dirnode in dirnodes:
 732                         node = dirnode.find_resource(s)
 733                         if node:
 734                              if node.id in map:
 735                                  fin = map[node.id]
 736                                  break
 737                              else:
 738                                  Logs.warn('could not find the public header replacement for source header %r %r' % (s, node))
 739                     else:
 740                         Logs.warn('-> could not find the public header for %r' % s)
 741
 742                 return "#include <%s>" % fin
 743             return ''
 744
 745         txt = re_header.sub(repl, txt)
 746
 747         # and write the output file
 748         f = None
 749         try:
 750             f = open(self.outputs[0].abspath(self.env), 'w')
 751             f.write(txt)
 752         finally:
 753             if f:
 754                 f.close()
 755
 756 @TaskGen.feature('pubh')
 757 def make_public_headers(self):
 758     """
 759     collect the public headers to process and to install, then
 760     create the substitutions (name and contents)
 761     """
 762
 763     if not self.bld.is_install:
 764         # install time only (lazy)
 765         return
 766
 767     # keep two variables
 768     #    hnodedirs: list of folders for searching the headers
 769     #    hnodemap: node ids and replacement string (node objects are unique)
 770     try:
 771         self.bld.hnodedirs.append(self.path)
 772     except AttributeError:
 773         self.bld.hnodemap = {}
 774         self.bld.hnodedirs = [self.bld.srcnode, self.path]
 775
 776         for k in 'source4 source4/include lib/talloc lib/tevent/ source4/lib/ldb/include/'.split():
 777             node = self.bld.srcnode.find_dir(k)
 778             if node:
 779                 self.bld.hnodedirs.append(node)
 780
 781     header_path = getattr(self, 'header_path', None) or ''
 782
 783     for x in self.to_list(self.headers):
 784
 785         # too complicated, but what was the original idea?
 786         if isinstance(header_path, list):
 787             add_dir = ''
 788             for (p1, dir) in header_path:
 789                 lst = self.to_list(p1)
 790                 for p2 in lst:
 791                     if fnmatch.fnmatch(x, p2):
 792                         add_dir = dir
 793                         break
 794                 else:
 795                     continue
 796                 break
 797             inst_path = add_dir
 798         else:
 799             inst_path = header_path
 800
 801         dest = ''
 802         name = x
 803         if x.find(':') != -1:
 804             s = x.split(':')
 805             name = s[0]
 806             dest = s[1]
 807
 808         inn = self.path.find_resource(name)
 809
 810         if not inn:
 811             raise ValueError("could not find the public header %r in %r" % (name, self.path))
 812         out = inn.change_ext('.inst.h')
 813         self.create_task('header', inn, out)
 814
 815         if not dest:
 816             dest = inn.name
 817
 818         if inst_path:
 819             inst_path = inst_path + '/'
 820         inst_path = inst_path + dest
 821
 822         self.bld.install_as('${INCLUDEDIR}/%s' % inst_path, out, self.env)
 823
 824         self.bld.hnodemap[inn.id] = inst_path
 825
 826     # create a hash (not md5) to make sure the headers are re-created if something changes
 827     val = 0
 828     lst = list(self.bld.hnodemap.keys())
 829     lst.sort()
 830     for k in lst:
 831         val = hash((val, k, self.bld.hnodemap[k]))
 832     self.bld.env.HEADER_DEPS = val
 833
 834 def PUBLIC_HEADERS(bld, public_headers, header_path=None):
 835     '''install some headers
 836
 837     header_path may either be a string that is added to the INCLUDEDIR,
 838     or it can be a dictionary of wildcard patterns which map to destination
 839     directories relative to INCLUDEDIR
 840     '''
 841     bld.SET_BUILD_GROUP('final')
 842     ret = bld(features=['pubh'], headers=public_headers, header_path=header_path)
 843     return ret
 844 Build.BuildContext.PUBLIC_HEADERS = PUBLIC_HEADERS
 845
 846
 847 def subst_at_vars(task):
 848     '''substiture @VAR@ style variables in a file'''
 849     src = task.inputs[0].srcpath(task.env)
 850     tgt = task.outputs[0].bldpath(task.env)
 851
 852     f = open(src, 'r')
 853     s = f.read()
 854     f.close()
 855     # split on the vars
 856     a = re.split('(@\w+@)', s)
 857     out = []
 858     done_var = {}
 859     back_sub = [ ('PREFIX', '${prefix}'), ('EXEC_PREFIX', '${exec_prefix}')]
 860     for v in a:
 861         if re.match('@\w+@', v):
 862             vname = v[1:-1]
 863             if not vname in task.env and vname.upper() in task.env:
 864                 vname = vname.upper()
 865             if not vname in task.env:
 866                 Logs.error("Unknown substitution %s in %s" % (v, task.name))
 867                 sys.exit(1)
 868             v = SUBST_VARS_RECURSIVE(task.env[vname], task.env)
 869             # now we back substitute the allowed pc vars
 870             for (b, m) in back_sub:
 871                 s = task.env[b]
 872                 if s == v[0:len(s)]:
 873                     if not b in done_var:
 874                         # we don't want to substitute the first usage
 875                         done_var[b] = True
 876                     else:
 877                         v = m + v[len(s):]
 878                     break
 879         out.append(v)
 880     contents = ''.join(out)
 881     f = open(tgt, 'w')
 882     s = f.write(contents)
 883     f.close()
 884     return 0
 885
 886
 887 def PKG_CONFIG_FILES(bld, pc_files, vnum=None):
 888     '''install some pkg_config pc files'''
 889     dest = '${PKGCONFIGDIR}'
 890     dest = bld.EXPAND_VARIABLES(dest)
 891     for f in TO_LIST(pc_files):
 892         base=os.path.basename(f)
 893         t = bld.SAMBA_GENERATOR('PKGCONFIG_%s' % base,
 894                                 rule=subst_at_vars,
 895                                 source=f+'.in',
 896                                 target=f)
 897         if vnum:
 898             t.env.PACKAGE_VERSION = vnum
 899         INSTALL_FILES(bld, dest, f, flat=True, destname=base)
 900 Build.BuildContext.PKG_CONFIG_FILES = PKG_CONFIG_FILES
 901
 902
 903 def MANPAGES(bld, manpages):
 904     '''build and install manual pages'''
 905     bld.env.MAN_XSL = 'http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
 906     for m in manpages.split():
 907         source = m + '.xml'
 908         bld.SAMBA_GENERATOR(m,
 909                             source=source,
 910                             target=m,
 911                             group='final',
 912                             rule='${XSLTPROC} -o ${TGT} --nonet ${MAN_XSL} ${SRC}'
 913                             )
 914         bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m, flat=True)
 915 Build.BuildContext.MANPAGES = MANPAGES
 916
 917
 918 #############################################################
 919 # give a nicer display when building different types of files
 920 def progress_display(self, msg, fname):
 921     col1 = Logs.colors(self.color)
 922     col2 = Logs.colors.NORMAL
 923     total = self.position[1]
 924     n = len(str(total))
 925     fs = '[%%%dd/%%%dd] %s %%s%%s%%s\n' % (n, n, msg)
 926     return fs % (self.position[0], self.position[1], col1, fname, col2)
 927
 928 def link_display(self):
 929     if Options.options.progress_bar != 0:
 930         return Task.Task.old_display(self)
 931     fname = self.outputs[0].bldpath(self.env)
 932     return progress_display(self, 'Linking', fname)
 933 Task.TaskBase.classes['cc_link'].display = link_display
 934
 935 def samba_display(self):
 936     if Options.options.progress_bar != 0:
 937         return Task.Task.old_display(self)
 938
 939     targets    = LOCAL_CACHE(self, 'TARGET_TYPE')
 940     if self.name in targets:
 941         target_type = targets[self.name]
 942         type_map = { 'GENERATOR' : 'Generating',
 943                      'PROTOTYPE' : 'Generating'
 944                      }
 945         if target_type in type_map:
 946             return progress_display(self, type_map[target_type], self.name)
 947
 948     fname = self.inputs[0].bldpath(self.env)
 949     if fname[0:3] == '../':
 950         fname = fname[3:]
 951     ext_loc = fname.rfind('.')
 952     if ext_loc == -1:
 953         return Task.Task.old_display(self)
 954     ext = fname[ext_loc:]
 955
 956     ext_map = { '.idl' : 'Compiling IDL',
 957                 '.et'  : 'Compiling ERRTABLE',
 958                 '.asn1': 'Compiling ASN1',
 959                 '.c'   : 'Compiling' }
 960     if ext in ext_map:
 961         return progress_display(self, ext_map[ext], fname)
 962     return Task.Task.old_display(self)
 963
 964 Task.TaskBase.classes['Task'].old_display = Task.TaskBase.classes['Task'].display
 965 Task.TaskBase.classes['Task'].display = samba_display