buildtools/wafsamba/samba_autoconf.py

   1 # a waf tool to add autoconf-like macros to the configure section
   2
   3 import Build, os, sys, Options, preproc, Logs
   4 import string
   5 from Configure import conf
   6 from samba_utils import *
   7 import samba_cross
   8
   9 missing_headers = set()
  10
  11 ####################################################
  12 # some autoconf like helpers, to make the transition
  13 # to waf a bit easier for those used to autoconf
  14 # m4 files
  15
  16 @runonce
  17 @conf
  18 def DEFINE(conf, d, v, add_to_cflags=False, quote=False):
  19     '''define a config option'''
  20     conf.define(d, v, quote=quote)
  21     if add_to_cflags:
  22         conf.env.append_value('CCDEFINES', d + '=' + str(v))
  23
  24 def hlist_to_string(conf, headers=None):
  25     '''convert a headers list to a set of #include lines'''
  26     hdrs=''
  27     hlist = conf.env.hlist
  28     if headers:
  29         hlist = hlist[:]
  30         hlist.extend(TO_LIST(headers))
  31     for h in hlist:
  32         hdrs += '#include <%s>\n' % h
  33     return hdrs
  34
  35
  36 @conf
  37 def COMPOUND_START(conf, msg):
  38     '''start a compound test'''
  39     def null_check_message_1(self,*k,**kw):
  40         return
  41     def null_check_message_2(self,*k,**kw):
  42         return
  43
  44     v = getattr(conf.env, 'in_compound', [])
  45     if v != [] and v != 0:
  46         conf.env.in_compound = v + 1
  47         return
  48     conf.check_message_1(msg)
  49     conf.saved_check_message_1 = conf.check_message_1
  50     conf.check_message_1 = null_check_message_1
  51     conf.saved_check_message_2 = conf.check_message_2
  52     conf.check_message_2 = null_check_message_2
  53     conf.env.in_compound = 1
  54
  55
  56 @conf
  57 def COMPOUND_END(conf, result):
  58     '''start a compound test'''
  59     conf.env.in_compound -= 1
  60     if conf.env.in_compound != 0:
  61         return
  62     conf.check_message_1 = conf.saved_check_message_1
  63     conf.check_message_2 = conf.saved_check_message_2
  64     p = conf.check_message_2
  65     if result == True:
  66         p('ok ')
  67     elif result == False:
  68         p('not found', 'YELLOW')
  69     else:
  70         p(result)
  71
  72
  73 @feature('nolink')
  74 def nolink(self):
  75     '''using the nolink type in conf.check() allows us to avoid
  76        the link stage of a test, thus speeding it up for tests
  77        that where linking is not needed'''
  78     pass
  79
  80
  81 def CHECK_HEADER(conf, h, add_headers=False, lib=None):
  82     '''check for a header'''
  83     if h in missing_headers and lib is None:
  84         return False
  85     d = h.upper().replace('/', '_')
  86     d = d.replace('.', '_')
  87     d = d.replace('-', '_')
  88     d = 'HAVE_%s' % d
  89     if CONFIG_SET(conf, d):
  90         if add_headers:
  91             if not h in conf.env.hlist:
  92                 conf.env.hlist.append(h)
  93         return True
  94
  95     (ccflags, ldflags, cpppath) = library_flags(conf, lib)
  96
  97     hdrs = hlist_to_string(conf, headers=h)
  98     if lib is None:
  99         lib = ""
 100     ret = conf.check(fragment='%s\nint main(void) { return 0; }' % hdrs,
 101                      type='nolink',
 102                      execute=0,
 103                      ccflags=ccflags,
 104                      includes=cpppath,
 105                      uselib=lib.upper(),
 106                      msg="Checking for header %s" % h)
 107     if not ret:
 108         missing_headers.add(h)
 109         return False
 110
 111     conf.DEFINE(d, 1)
 112     if add_headers and not h in conf.env.hlist:
 113         conf.env.hlist.append(h)
 114     return ret
 115
 116
 117 @conf
 118 def CHECK_HEADERS(conf, headers, add_headers=False, together=False, lib=None):
 119     '''check for a list of headers
 120
 121     when together==True, then the headers accumulate within this test.
 122     This is useful for interdependent headers
 123     '''
 124     ret = True
 125     if not add_headers and together:
 126         saved_hlist = conf.env.hlist[:]
 127         set_add_headers = True
 128     else:
 129         set_add_headers = add_headers
 130     for hdr in TO_LIST(headers):
 131         if not CHECK_HEADER(conf, hdr, set_add_headers, lib=lib):
 132             ret = False
 133     if not add_headers and together:
 134         conf.env.hlist = saved_hlist
 135     return ret
 136
 137
 138 def header_list(conf, headers=None, lib=None):
 139     '''form a list of headers which exist, as a string'''
 140     hlist=[]
 141     if headers is not None:
 142         for h in TO_LIST(headers):
 143             if CHECK_HEADER(conf, h, add_headers=False, lib=lib):
 144                 hlist.append(h)
 145     return hlist_to_string(conf, headers=hlist)
 146
 147
 148 @conf
 149 def CHECK_TYPE(conf, t, alternate=None, headers=None, define=None, lib=None, msg=None):
 150     '''check for a single type'''
 151     if define is None:
 152         define = 'HAVE_' + t.upper().replace(' ', '_')
 153     if msg is None:
 154         msg='Checking for %s' % t
 155     ret = CHECK_CODE(conf, '%s _x' % t,
 156                      define,
 157                      execute=False,
 158                      headers=headers,
 159                      local_include=False,
 160                      msg=msg,
 161                      lib=lib,
 162                      link=False)
 163     if not ret and alternate:
 164         conf.DEFINE(t, alternate)
 165     return ret
 166
 167
 168 @conf
 169 def CHECK_TYPES(conf, list, headers=None, define=None, alternate=None, lib=None):
 170     '''check for a list of types'''
 171     ret = True
 172     for t in TO_LIST(list):
 173         if not CHECK_TYPE(conf, t, headers=headers,
 174                           define=define, alternate=alternate, lib=lib):
 175             ret = False
 176     return ret
 177
 178
 179 @conf
 180 def CHECK_TYPE_IN(conf, t, headers=None, alternate=None, define=None):
 181     '''check for a single type with a header'''
 182     return CHECK_TYPE(conf, t, headers=headers, alternate=alternate, define=define)
 183
 184
 185 @conf
 186 def CHECK_VARIABLE(conf, v, define=None, always=False,
 187                    headers=None, msg=None, lib=None):
 188     '''check for a variable declaration (or define)'''
 189     if define is None:
 190         define = 'HAVE_%s' % v.upper()
 191
 192     if msg is None:
 193         msg="Checking for variable %s" % v
 194
 195     return CHECK_CODE(conf,
 196                       # we need to make sure the compiler doesn't
 197                       # optimize it out...
 198                       '''
 199                       #ifndef %s
 200                       void *_x; _x=(void *)&%s; return (int)_x;
 201                       #endif
 202                       return 0
 203                       ''' % (v, v),
 204                       execute=False,
 205                       link=False,
 206                       msg=msg,
 207                       local_include=False,
 208                       lib=lib,
 209                       headers=headers,
 210                       define=define,
 211                       always=always)
 212
 213
 214 @conf
 215 def CHECK_DECLS(conf, vars, reverse=False, headers=None, always=False):
 216     '''check a list of variable declarations, using the HAVE_DECL_xxx form
 217        of define
 218
 219        When reverse==True then use HAVE_xxx_DECL instead of HAVE_DECL_xxx
 220        '''
 221     ret = True
 222     for v in TO_LIST(vars):
 223         if not reverse:
 224             define='HAVE_DECL_%s' % v.upper()
 225         else:
 226             define='HAVE_%s_DECL' % v.upper()
 227         if not CHECK_VARIABLE(conf, v,
 228                               define=define,
 229                               headers=headers,
 230                               msg='Checking for declaration of %s' % v,
 231                               always=always):
 232             ret = False
 233     return ret
 234
 235
 236 def CHECK_FUNC(conf, f, link=True, lib=None, headers=None):
 237     '''check for a function'''
 238     define='HAVE_%s' % f.upper()
 239
 240     ret = False
 241
 242     conf.COMPOUND_START('Checking for %s' % f)
 243
 244     if link is None or link == True:
 245         ret = CHECK_CODE(conf,
 246                          # this is based on the autoconf strategy
 247                          '''
 248                          #define %s __fake__%s
 249                          #ifdef HAVE_LIMITS_H
 250                          # include <limits.h>
 251                          #else
 252                          # include <assert.h>
 253                          #endif
 254                          #undef %s
 255                          #if defined __stub_%s || defined __stub___%s
 256                          #error "bad glibc stub"
 257                          #endif
 258                          extern char %s();
 259                          int main() { return %s(); }
 260                          ''' % (f, f, f, f, f, f, f),
 261                          execute=False,
 262                          link=True,
 263                          addmain=False,
 264                          add_headers=False,
 265                          define=define,
 266                          local_include=False,
 267                          lib=lib,
 268                          headers=headers,
 269                          msg='Checking for %s' % f)
 270
 271         if not ret:
 272             ret = CHECK_CODE(conf,
 273                              # it might be a macro
 274                              # we need to make sure the compiler doesn't
 275                              # optimize it out...
 276                              'void *__x = (void *)%s; return (int)__x' % f,
 277                              execute=False,
 278                              link=True,
 279                              addmain=True,
 280                              add_headers=True,
 281                              define=define,
 282                              local_include=False,
 283                              lib=lib,
 284                              headers=headers,
 285                              msg='Checking for macro %s' % f)
 286
 287     if not ret and (link is None or link == False):
 288         ret = CHECK_VARIABLE(conf, f,
 289                              define=define,
 290                              headers=headers,
 291                              msg='Checking for declaration of %s' % f)
 292     conf.COMPOUND_END(ret)
 293     return ret
 294
 295
 296 @conf
 297 def CHECK_FUNCS(conf, list, link=True, lib=None, headers=None):
 298     '''check for a list of functions'''
 299     ret = True
 300     for f in TO_LIST(list):
 301         if not CHECK_FUNC(conf, f, link=link, lib=lib, headers=headers):
 302             ret = False
 303     return ret
 304
 305
 306 @conf
 307 def CHECK_SIZEOF(conf, vars, headers=None, define=None):
 308     '''check the size of a type'''
 309     ret = True
 310     for v in TO_LIST(vars):
 311         v_define = define
 312         if v_define is None:
 313             v_define = 'SIZEOF_%s' % v.upper().replace(' ', '_')
 314         if not CHECK_CODE(conf,
 315                           'printf("%%u", (unsigned)sizeof(%s))' % v,
 316                           define=v_define,
 317                           execute=True,
 318                           define_ret=True,
 319                           quote=False,
 320                           headers=headers,
 321                           local_include=False,
 322                           msg="Checking size of %s" % v):
 323             ret = False
 324     return ret
 325
 326
 327
 328 @conf
 329 def CHECK_CODE(conf, code, define,
 330                always=False, execute=False, addmain=True,
 331                add_headers=True, mandatory=False,
 332                headers=None, msg=None, cflags='', includes='# .',
 333                local_include=True, lib=None, link=True,
 334                define_ret=False, quote=False,
 335                on_target=True):
 336     '''check if some code compiles and/or runs'''
 337
 338     if CONFIG_SET(conf, define):
 339         return True
 340
 341     if headers is not None:
 342         CHECK_HEADERS(conf, headers=headers, lib=lib)
 343
 344     if add_headers:
 345         hdrs = header_list(conf, headers=headers, lib=lib)
 346     else:
 347         hdrs = ''
 348     if execute:
 349         execute = 1
 350     else:
 351         execute = 0
 352
 353     defs = conf.get_config_header()
 354
 355     if addmain:
 356         fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
 357     else:
 358         fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
 359
 360     if msg is None:
 361         msg="Checking for %s" % define
 362
 363     cflags = TO_LIST(cflags)
 364
 365     if local_include:
 366         cflags.append('-I%s' % conf.curdir)
 367
 368     if not link:
 369         type='nolink'
 370     else:
 371         type='cprogram'
 372
 373     uselib = TO_LIST(lib)
 374
 375     (ccflags, ldflags, cpppath) = library_flags(conf, uselib)
 376
 377     includes = TO_LIST(includes)
 378     includes.extend(cpppath)
 379
 380     uselib = [l.upper() for l in uselib]
 381
 382     cflags.extend(ccflags)
 383
 384     if on_target:
 385         exec_args = conf.SAMBA_CROSS_ARGS(msg=msg)
 386     else:
 387         exec_args = []
 388
 389     conf.COMPOUND_START(msg)
 390
 391     ret = conf.check(fragment=fragment,
 392                      execute=execute,
 393                      define_name = define,
 394                      mandatory = mandatory,
 395                      ccflags=cflags,
 396                      ldflags=ldflags,
 397                      includes=includes,
 398                      uselib=uselib,
 399                      type=type,
 400                      msg=msg,
 401                      quote=quote,
 402                      exec_args=exec_args,
 403                      define_ret=define_ret)
 404     if not ret and CONFIG_SET(conf, define):
 405         # sometimes conf.check() returns false, but it
 406         # sets the define. Maybe a waf bug?
 407         ret = True
 408     if ret:
 409         if not define_ret:
 410             conf.DEFINE(define, 1)
 411             conf.COMPOUND_END(True)
 412         else:
 413             conf.COMPOUND_END(conf.env[define])
 414         return True
 415     if always:
 416         conf.DEFINE(define, 0)
 417     conf.COMPOUND_END(False)
 418     return False
 419
 420
 421
 422 @conf
 423 def CHECK_STRUCTURE_MEMBER(conf, structname, member,
 424                            always=False, define=None, headers=None):
 425     '''check for a structure member'''
 426     if define is None:
 427         define = 'HAVE_%s' % member.upper()
 428     return CHECK_CODE(conf,
 429                       '%s s; void *_x; _x=(void *)&s.%s' % (structname, member),
 430                       define,
 431                       execute=False,
 432                       link=False,
 433                       always=always,
 434                       headers=headers,
 435                       local_include=False,
 436                       msg="Checking for member %s in %s" % (member, structname))
 437
 438
 439 @conf
 440 def CHECK_CFLAGS(conf, cflags):
 441     '''check if the given cflags are accepted by the compiler
 442     '''
 443     return conf.check(fragment='int main(void) { return 0; }\n',
 444                       execute=0,
 445                       type='nolink',
 446                       ccflags=cflags,
 447                       msg="Checking compiler accepts %s" % cflags)
 448
 449 @conf
 450 def CHECK_LDFLAGS(conf, ldflags):
 451     '''check if the given ldflags are accepted by the linker
 452     '''
 453     return conf.check(fragment='int main(void) { return 0; }\n',
 454                       execute=0,
 455                       ldflags=ldflags,
 456                       msg="Checking linker accepts %s" % ldflags)
 457
 458
 459 @conf
 460 def CONFIG_GET(conf, option):
 461     '''return True if a configuration option was found'''
 462     if (option in conf.env):
 463         return conf.env[option]
 464     else:
 465         return None
 466
 467 @conf
 468 def CONFIG_SET(conf, option):
 469     '''return True if a configuration option was found'''
 470     if option not in conf.env:
 471         return False
 472     v = conf.env[option]
 473     if v == None:
 474         return False
 475     if v == []:
 476         return False
 477     if v == ():
 478         return False
 479     return True
 480 Build.BuildContext.CONFIG_SET = CONFIG_SET
 481 Build.BuildContext.CONFIG_GET = CONFIG_GET
 482
 483
 484 def library_flags(self, libs):
 485     '''work out flags from pkg_config'''
 486     ccflags = []
 487     ldflags = []
 488     cpppath = []
 489     for lib in TO_LIST(libs):
 490         # note that we do not add the -I and -L in here, as that is added by the waf
 491         # core. Adding it here would just change the order that it is put on the link line
 492         # which can cause system paths to be added before internal libraries
 493         extra_ccflags = TO_LIST(getattr(self.env, 'CCFLAGS_%s' % lib.upper(), []))
 494         extra_ldflags = TO_LIST(getattr(self.env, 'LDFLAGS_%s' % lib.upper(), []))
 495         extra_cpppath = TO_LIST(getattr(self.env, 'CPPPATH_%s' % lib.upper(), []))
 496         ccflags.extend(extra_ccflags)
 497         ldflags.extend(extra_ldflags)
 498         cpppath.extend(extra_cpppath)
 499     if 'EXTRA_LDFLAGS' in self.env:
 500         ldflags.extend(self.env['EXTRA_LDFLAGS'])
 501
 502     ccflags = unique_list(ccflags)
 503     ldflags = unique_list(ldflags)
 504     cpppath = unique_list(cpppath)
 505     return (ccflags, ldflags, cpppath)
 506
 507
 508 @conf
 509 def CHECK_LIB(conf, libs, mandatory=False, empty_decl=True, set_target=True, shlib=False):
 510     '''check if a set of libraries exist as system libraries
 511
 512     returns the sublist of libs that do exist as a syslib or []
 513     '''
 514
 515     fragment= '''
 516 int foo()
 517 {
 518     int v = 2;
 519     return v*2;
 520 }
 521 '''
 522     ret = []
 523     liblist  = TO_LIST(libs)
 524     for lib in liblist[:]:
 525         if GET_TARGET_TYPE(conf, lib) == 'SYSLIB':
 526             ret.append(lib)
 527             continue
 528
 529         (ccflags, ldflags, cpppath) = library_flags(conf, lib)
 530         if shlib:
 531             res = conf.check(features='cc cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 532         else:
 533             res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 534
 535         if not res:
 536             if mandatory:
 537                 Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 538                 sys.exit(1)
 539             if empty_decl:
 540                 # if it isn't a mandatory library, then remove it from dependency lists
 541                 if set_target:
 542                     SET_TARGET_TYPE(conf, lib, 'EMPTY')
 543         else:
 544             conf.define('HAVE_LIB%s' % lib.upper().replace('-','_'), 1)
 545             conf.env['LIB_' + lib.upper()] = lib
 546             if set_target:
 547                 conf.SET_TARGET_TYPE(lib, 'SYSLIB')
 548             ret.append(lib)
 549
 550     return ret
 551
 552
 553
 554 @conf
 555 def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False,
 556                    headers=None, link=True, empty_decl=True, set_target=True):
 557     """
 558     check that the functions in 'list' are available in 'library'
 559     if they are, then make that library available as a dependency
 560
 561     if the library is not available and mandatory==True, then
 562     raise an error.
 563
 564     If the library is not available and mandatory==False, then
 565     add the library to the list of dependencies to remove from
 566     build rules
 567
 568     optionally check for the functions first in libc
 569     """
 570     remaining = TO_LIST(list)
 571     liblist   = TO_LIST(library)
 572
 573     # check if some already found
 574     for f in remaining[:]:
 575         if CONFIG_SET(conf, 'HAVE_%s' % f.upper()):
 576             remaining.remove(f)
 577
 578     # see if the functions are in libc
 579     if checklibc:
 580         for f in remaining[:]:
 581             if CHECK_FUNC(conf, f, link=True, headers=headers):
 582                 remaining.remove(f)
 583
 584     if remaining == []:
 585         for lib in liblist:
 586             if GET_TARGET_TYPE(conf, lib) != 'SYSLIB' and empty_decl:
 587                 SET_TARGET_TYPE(conf, lib, 'EMPTY')
 588         return True
 589
 590     checklist = conf.CHECK_LIB(liblist, empty_decl=empty_decl, set_target=set_target)
 591     for lib in liblist[:]:
 592         if not lib in checklist and mandatory:
 593             Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 594             sys.exit(1)
 595
 596     ret = True
 597     for f in remaining:
 598         if not CHECK_FUNC(conf, f, lib=' '.join(checklist), headers=headers, link=link):
 599             ret = False
 600
 601     return ret
 602
 603
 604 @conf
 605 def IN_LAUNCH_DIR(conf):
 606     '''return True if this rule is being run from the launch directory'''
 607     return os.path.realpath(conf.curdir) == os.path.realpath(Options.launch_dir)
 608 Options.Handler.IN_LAUNCH_DIR = IN_LAUNCH_DIR
 609
 610
 611 @conf
 612 def SAMBA_CONFIG_H(conf, path=None):
 613     '''write out config.h in the right directory'''
 614     # we don't want to produce a config.h in places like lib/replace
 615     # when we are building projects that depend on lib/replace
 616     if not IN_LAUNCH_DIR(conf):
 617         return
 618
 619     if Options.options.debug:
 620         conf.ADD_CFLAGS('-g',
 621                         testflags=True)
 622
 623     if Options.options.developer:
 624         # we add these here to ensure that -Wstrict-prototypes is not set during configure
 625         conf.ADD_CFLAGS('-Wall -g -Wshadow -Werror=strict-prototypes -Wstrict-prototypes -Werror=pointer-arith -Wpointer-arith -Wcast-align -Werror=write-strings -Wwrite-strings -Werror-implicit-function-declaration -Werror=format -Wformat=2 -Wno-format-y2k -Wmissing-prototypes -fno-common -Werror=address',
 626                         testflags=True)
 627         conf.ADD_CFLAGS('-Wcast-qual', testflags=True)
 628         conf.env.DEVELOPER_MODE = True
 629
 630     if Options.options.picky_developer:
 631         conf.ADD_CFLAGS('-Werror', testflags=True)
 632
 633     if Options.options.fatal_errors:
 634         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 635
 636     if Options.options.pedantic:
 637         conf.ADD_CFLAGS('-W', testflags=True)
 638
 639     if path is None:
 640         conf.write_config_header('config.h', top=True)
 641     else:
 642         conf.write_config_header(path)
 643     conf.SAMBA_CROSS_CHECK_COMPLETE()
 644
 645
 646 @conf
 647 def CONFIG_PATH(conf, name, default):
 648     '''setup a configurable path'''
 649     if not name in conf.env:
 650         if default[0] == '/':
 651             conf.env[name] = default
 652         else:
 653             conf.env[name] = conf.env['PREFIX'] + default
 654
 655 @conf
 656 def ADD_CFLAGS(conf, flags, testflags=False):
 657     '''add some CFLAGS to the command line
 658        optionally set testflags to ensure all the flags work
 659     '''
 660     if testflags:
 661         ok_flags=[]
 662         for f in flags.split():
 663             if CHECK_CFLAGS(conf, f):
 664                 ok_flags.append(f)
 665         flags = ok_flags
 666     if not 'EXTRA_CFLAGS' in conf.env:
 667         conf.env['EXTRA_CFLAGS'] = []
 668     conf.env['EXTRA_CFLAGS'].extend(TO_LIST(flags))
 669
 670 @conf
 671 def ADD_LDFLAGS(conf, flags, testflags=False):
 672     '''add some LDFLAGS to the command line
 673        optionally set testflags to ensure all the flags work
 674
 675        this will return the flags that are added, if any
 676     '''
 677     if testflags:
 678         ok_flags=[]
 679         for f in flags.split():
 680             if CHECK_LDFLAGS(conf, f):
 681                 ok_flags.append(f)
 682         flags = ok_flags
 683     if not 'EXTRA_LDFLAGS' in conf.env:
 684         conf.env['EXTRA_LDFLAGS'] = []
 685     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 686     return flags
 687
 688
 689 @conf
 690 def ADD_EXTRA_INCLUDES(conf, includes):
 691     '''add some extra include directories to all builds'''
 692     if not 'EXTRA_INCLUDES' in conf.env:
 693         conf.env['EXTRA_INCLUDES'] = []
 694     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 695
 696
 697
 698 def CURRENT_CFLAGS(bld, target, cflags, hide_symbols=False):
 699     '''work out the current flags. local flags are added first'''
 700     if not 'EXTRA_CFLAGS' in bld.env:
 701         list = []
 702     else:
 703         list = bld.env['EXTRA_CFLAGS'];
 704     ret = TO_LIST(cflags)
 705     ret.extend(list)
 706     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 707         ret.append('-fvisibility=hidden')
 708     return ret
 709
 710
 711 @conf
 712 def CHECK_CC_ENV(conf):
 713     """trim whitespaces from 'CC'.
 714     The build farm sometimes puts a space at the start"""
 715     if os.environ.get('CC'):
 716         conf.env.CC = TO_LIST(os.environ.get('CC'))
 717         if len(conf.env.CC) == 1:
 718             # make for nicer logs if just a single command
 719             conf.env.CC = conf.env.CC[0]
 720
 721
 722 @conf
 723 def SETUP_CONFIGURE_CACHE(conf, enable):
 724     '''enable/disable cache of configure results'''
 725     if enable:
 726         # when -C is chosen, we will use a private cache and will
 727         # not look into system includes. This roughtly matches what
 728         # autoconf does with -C
 729         cache_path = os.path.join(conf.blddir, '.confcache')
 730         mkdir_p(cache_path)
 731         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 732     else:
 733         # when -C is not chosen we will not cache configure checks
 734         # We set the recursion limit low to prevent waf from spending
 735         # a lot of time on the signatures of the files.
 736         Options.cache_global = os.environ['WAFCACHE'] = ''
 737         preproc.recursion_limit = 1
 738     # in either case we don't need to scan system includes
 739     preproc.go_absolute = False
 740
 741
 742 @conf
 743 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
 744     # we don't want any libraries or modules to rely on runtime
 745     # resolution of symbols
 746     if sys.platform != "openbsd4" and sys.platform != "openbsd5":
 747         conf.env.undefined_ldflags = conf.ADD_LDFLAGS('-Wl,-no-undefined', testflags=True)
 748
 749     if sys.platform != "openbsd4" and sys.platform != "openbsd5" and conf.env.undefined_ignore_ldflags == []:
 750         if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
 751             conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']