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 is True:
  66         p('ok')
  67     elif not result:
  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:
 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 not link):
 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, fragment='int main(void) { return 0; }\n'):
 441     '''check if the given cflags are accepted by the compiler
 442     '''
 443     return conf.check(fragment=fragment,
 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 is 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 -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         # This check is because for ldb_search(), a NULL format string
 631         # is not an error, but some compilers complain about that.
 632         if CHECK_CFLAGS(conf, ["-Werror=format", "-Wformat=2"], '''
 633 int testformat(char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
 634
 635 int main(void) {
 636         testformat(0);
 637         return 0;
 638 }
 639
 640 '''):
 641             if not 'EXTRA_CFLAGS' in conf.env:
 642                 conf.env['EXTRA_CFLAGS'] = []
 643             conf.env['EXTRA_CFLAGS'].extend(TO_LIST("-Werror=format"))
 644
 645     if Options.options.picky_developer:
 646         conf.ADD_CFLAGS('-Werror', testflags=True)
 647
 648     if Options.options.fatal_errors:
 649         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 650
 651     if Options.options.pedantic:
 652         conf.ADD_CFLAGS('-W', testflags=True)
 653
 654     if path is None:
 655         conf.write_config_header('config.h', top=True)
 656     else:
 657         conf.write_config_header(path)
 658     conf.SAMBA_CROSS_CHECK_COMPLETE()
 659
 660
 661 @conf
 662 def CONFIG_PATH(conf, name, default):
 663     '''setup a configurable path'''
 664     if not name in conf.env:
 665         if default[0] == '/':
 666             conf.env[name] = default
 667         else:
 668             conf.env[name] = conf.env['PREFIX'] + default
 669
 670 @conf
 671 def ADD_CFLAGS(conf, flags, testflags=False):
 672     '''add some CFLAGS to the command line
 673        optionally set testflags to ensure all the flags work
 674     '''
 675     if testflags:
 676         ok_flags=[]
 677         for f in flags.split():
 678             if CHECK_CFLAGS(conf, f):
 679                 ok_flags.append(f)
 680         flags = ok_flags
 681     if not 'EXTRA_CFLAGS' in conf.env:
 682         conf.env['EXTRA_CFLAGS'] = []
 683     conf.env['EXTRA_CFLAGS'].extend(TO_LIST(flags))
 684
 685 @conf
 686 def ADD_LDFLAGS(conf, flags, testflags=False):
 687     '''add some LDFLAGS to the command line
 688        optionally set testflags to ensure all the flags work
 689
 690        this will return the flags that are added, if any
 691     '''
 692     if testflags:
 693         ok_flags=[]
 694         for f in flags.split():
 695             if CHECK_LDFLAGS(conf, f):
 696                 ok_flags.append(f)
 697         flags = ok_flags
 698     if not 'EXTRA_LDFLAGS' in conf.env:
 699         conf.env['EXTRA_LDFLAGS'] = []
 700     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 701     return flags
 702
 703
 704 @conf
 705 def ADD_EXTRA_INCLUDES(conf, includes):
 706     '''add some extra include directories to all builds'''
 707     if not 'EXTRA_INCLUDES' in conf.env:
 708         conf.env['EXTRA_INCLUDES'] = []
 709     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 710
 711
 712
 713 def CURRENT_CFLAGS(bld, target, cflags, hide_symbols=False):
 714     '''work out the current flags. local flags are added first'''
 715     if not 'EXTRA_CFLAGS' in bld.env:
 716         list = []
 717     else:
 718         list = bld.env['EXTRA_CFLAGS'];
 719     ret = TO_LIST(cflags)
 720     ret.extend(list)
 721     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 722         ret.append('-fvisibility=hidden')
 723     return ret
 724
 725
 726 @conf
 727 def CHECK_CC_ENV(conf):
 728     """trim whitespaces from 'CC'.
 729     The build farm sometimes puts a space at the start"""
 730     if os.environ.get('CC'):
 731         conf.env.CC = TO_LIST(os.environ.get('CC'))
 732         if len(conf.env.CC) == 1:
 733             # make for nicer logs if just a single command
 734             conf.env.CC = conf.env.CC[0]
 735
 736
 737 @conf
 738 def SETUP_CONFIGURE_CACHE(conf, enable):
 739     '''enable/disable cache of configure results'''
 740     if enable:
 741         # when -C is chosen, we will use a private cache and will
 742         # not look into system includes. This roughtly matches what
 743         # autoconf does with -C
 744         cache_path = os.path.join(conf.blddir, '.confcache')
 745         mkdir_p(cache_path)
 746         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 747     else:
 748         # when -C is not chosen we will not cache configure checks
 749         # We set the recursion limit low to prevent waf from spending
 750         # a lot of time on the signatures of the files.
 751         Options.cache_global = os.environ['WAFCACHE'] = ''
 752         preproc.recursion_limit = 1
 753     # in either case we don't need to scan system includes
 754     preproc.go_absolute = False
 755
 756
 757 @conf
 758 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
 759     # we don't want any libraries or modules to rely on runtime
 760     # resolution of symbols
 761     if sys.platform != "openbsd4" and sys.platform != "openbsd5":
 762         conf.env.undefined_ldflags = conf.ADD_LDFLAGS('-Wl,-no-undefined', testflags=True)
 763
 764     if sys.platform != "openbsd4" and sys.platform != "openbsd5" and conf.env.undefined_ignore_ldflags == []:
 765         if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
 766             conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']