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 @conf
 327 def CHECK_VALUEOF(conf, v, headers=None, define=None):
 328     '''check the value of a variable/define'''
 329     ret = True
 330     v_define = define
 331     if v_define is None:
 332         v_define = 'VALUEOF_%s' % v.upper().replace(' ', '_')
 333     if CHECK_CODE(conf,
 334                   'printf("%%u", (unsigned)(%s))' % v,
 335                   define=v_define,
 336                   execute=True,
 337                   define_ret=True,
 338                   quote=False,
 339                   headers=headers,
 340                   local_include=False,
 341                   msg="Checking value of %s" % v):
 342         return int(conf.env[v_define])
 343
 344     return None
 345
 346 @conf
 347 def CHECK_CODE(conf, code, define,
 348                always=False, execute=False, addmain=True,
 349                add_headers=True, mandatory=False,
 350                headers=None, msg=None, cflags='', includes='# .',
 351                local_include=True, lib=None, link=True,
 352                define_ret=False, quote=False,
 353                on_target=True):
 354     '''check if some code compiles and/or runs'''
 355
 356     if CONFIG_SET(conf, define):
 357         return True
 358
 359     if headers is not None:
 360         CHECK_HEADERS(conf, headers=headers, lib=lib)
 361
 362     if add_headers:
 363         hdrs = header_list(conf, headers=headers, lib=lib)
 364     else:
 365         hdrs = ''
 366     if execute:
 367         execute = 1
 368     else:
 369         execute = 0
 370
 371     defs = conf.get_config_header()
 372
 373     if addmain:
 374         fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
 375     else:
 376         fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
 377
 378     if msg is None:
 379         msg="Checking for %s" % define
 380
 381     cflags = TO_LIST(cflags)
 382
 383     if local_include:
 384         cflags.append('-I%s' % conf.curdir)
 385
 386     if not link:
 387         type='nolink'
 388     else:
 389         type='cprogram'
 390
 391     uselib = TO_LIST(lib)
 392
 393     (ccflags, ldflags, cpppath) = library_flags(conf, uselib)
 394
 395     includes = TO_LIST(includes)
 396     includes.extend(cpppath)
 397
 398     uselib = [l.upper() for l in uselib]
 399
 400     cflags.extend(ccflags)
 401
 402     if on_target:
 403         exec_args = conf.SAMBA_CROSS_ARGS(msg=msg)
 404     else:
 405         exec_args = []
 406
 407     conf.COMPOUND_START(msg)
 408
 409     ret = conf.check(fragment=fragment,
 410                      execute=execute,
 411                      define_name = define,
 412                      mandatory = mandatory,
 413                      ccflags=cflags,
 414                      ldflags=ldflags,
 415                      includes=includes,
 416                      uselib=uselib,
 417                      type=type,
 418                      msg=msg,
 419                      quote=quote,
 420                      exec_args=exec_args,
 421                      define_ret=define_ret)
 422     if not ret and CONFIG_SET(conf, define):
 423         # sometimes conf.check() returns false, but it
 424         # sets the define. Maybe a waf bug?
 425         ret = True
 426     if ret:
 427         if not define_ret:
 428             conf.DEFINE(define, 1)
 429             conf.COMPOUND_END(True)
 430         else:
 431             conf.COMPOUND_END(conf.env[define])
 432         return True
 433     if always:
 434         conf.DEFINE(define, 0)
 435     conf.COMPOUND_END(False)
 436     return False
 437
 438
 439
 440 @conf
 441 def CHECK_STRUCTURE_MEMBER(conf, structname, member,
 442                            always=False, define=None, headers=None):
 443     '''check for a structure member'''
 444     if define is None:
 445         define = 'HAVE_%s' % member.upper()
 446     return CHECK_CODE(conf,
 447                       '%s s; void *_x; _x=(void *)&s.%s' % (structname, member),
 448                       define,
 449                       execute=False,
 450                       link=False,
 451                       always=always,
 452                       headers=headers,
 453                       local_include=False,
 454                       msg="Checking for member %s in %s" % (member, structname))
 455
 456
 457 @conf
 458 def CHECK_CFLAGS(conf, cflags, fragment='int main(void) { return 0; }\n'):
 459     '''check if the given cflags are accepted by the compiler
 460     '''
 461     return conf.check(fragment=fragment,
 462                       execute=0,
 463                       type='nolink',
 464                       ccflags=cflags,
 465                       msg="Checking compiler accepts %s" % cflags)
 466
 467 @conf
 468 def CHECK_LDFLAGS(conf, ldflags):
 469     '''check if the given ldflags are accepted by the linker
 470     '''
 471     return conf.check(fragment='int main(void) { return 0; }\n',
 472                       execute=0,
 473                       ldflags=ldflags,
 474                       msg="Checking linker accepts %s" % ldflags)
 475
 476
 477 @conf
 478 def CONFIG_GET(conf, option):
 479     '''return True if a configuration option was found'''
 480     if (option in conf.env):
 481         return conf.env[option]
 482     else:
 483         return None
 484
 485 @conf
 486 def CONFIG_SET(conf, option):
 487     '''return True if a configuration option was found'''
 488     if option not in conf.env:
 489         return False
 490     v = conf.env[option]
 491     if v is None:
 492         return False
 493     if v == []:
 494         return False
 495     if v == ():
 496         return False
 497     return True
 498
 499 @conf
 500 def CONFIG_RESET(conf, option):
 501     if option not in conf.env:
 502         return
 503     del conf.env[option]
 504
 505 Build.BuildContext.CONFIG_RESET = CONFIG_RESET
 506 Build.BuildContext.CONFIG_SET = CONFIG_SET
 507 Build.BuildContext.CONFIG_GET = CONFIG_GET
 508
 509
 510 def library_flags(self, libs):
 511     '''work out flags from pkg_config'''
 512     ccflags = []
 513     ldflags = []
 514     cpppath = []
 515     for lib in TO_LIST(libs):
 516         # note that we do not add the -I and -L in here, as that is added by the waf
 517         # core. Adding it here would just change the order that it is put on the link line
 518         # which can cause system paths to be added before internal libraries
 519         extra_ccflags = TO_LIST(getattr(self.env, 'CCFLAGS_%s' % lib.upper(), []))
 520         extra_ldflags = TO_LIST(getattr(self.env, 'LDFLAGS_%s' % lib.upper(), []))
 521         extra_cpppath = TO_LIST(getattr(self.env, 'CPPPATH_%s' % lib.upper(), []))
 522         ccflags.extend(extra_ccflags)
 523         ldflags.extend(extra_ldflags)
 524         cpppath.extend(extra_cpppath)
 525     if 'EXTRA_LDFLAGS' in self.env:
 526         ldflags.extend(self.env['EXTRA_LDFLAGS'])
 527
 528     ccflags = unique_list(ccflags)
 529     ldflags = unique_list(ldflags)
 530     cpppath = unique_list(cpppath)
 531     return (ccflags, ldflags, cpppath)
 532
 533
 534 @conf
 535 def CHECK_LIB(conf, libs, mandatory=False, empty_decl=True, set_target=True, shlib=False):
 536     '''check if a set of libraries exist as system libraries
 537
 538     returns the sublist of libs that do exist as a syslib or []
 539     '''
 540
 541     fragment= '''
 542 int foo()
 543 {
 544     int v = 2;
 545     return v*2;
 546 }
 547 '''
 548     ret = []
 549     liblist  = TO_LIST(libs)
 550     for lib in liblist[:]:
 551         if GET_TARGET_TYPE(conf, lib) == 'SYSLIB':
 552             ret.append(lib)
 553             continue
 554
 555         (ccflags, ldflags, cpppath) = library_flags(conf, lib)
 556         if shlib:
 557             res = conf.check(features='cc cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 558         else:
 559             res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 560
 561         if not res:
 562             if mandatory:
 563                 Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 564                 sys.exit(1)
 565             if empty_decl:
 566                 # if it isn't a mandatory library, then remove it from dependency lists
 567                 if set_target:
 568                     SET_TARGET_TYPE(conf, lib, 'EMPTY')
 569         else:
 570             conf.define('HAVE_LIB%s' % lib.upper().replace('-','_').replace('.','_'), 1)
 571             conf.env['LIB_' + lib.upper()] = lib
 572             if set_target:
 573                 conf.SET_TARGET_TYPE(lib, 'SYSLIB')
 574             ret.append(lib)
 575
 576     return ret
 577
 578
 579
 580 @conf
 581 def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False,
 582                    headers=None, link=True, empty_decl=True, set_target=True):
 583     """
 584     check that the functions in 'list' are available in 'library'
 585     if they are, then make that library available as a dependency
 586
 587     if the library is not available and mandatory==True, then
 588     raise an error.
 589
 590     If the library is not available and mandatory==False, then
 591     add the library to the list of dependencies to remove from
 592     build rules
 593
 594     optionally check for the functions first in libc
 595     """
 596     remaining = TO_LIST(list)
 597     liblist   = TO_LIST(library)
 598
 599     # check if some already found
 600     for f in remaining[:]:
 601         if CONFIG_SET(conf, 'HAVE_%s' % f.upper()):
 602             remaining.remove(f)
 603
 604     # see if the functions are in libc
 605     if checklibc:
 606         for f in remaining[:]:
 607             if CHECK_FUNC(conf, f, link=True, headers=headers):
 608                 remaining.remove(f)
 609
 610     if remaining == []:
 611         for lib in liblist:
 612             if GET_TARGET_TYPE(conf, lib) != 'SYSLIB' and empty_decl:
 613                 SET_TARGET_TYPE(conf, lib, 'EMPTY')
 614         return True
 615
 616     checklist = conf.CHECK_LIB(liblist, empty_decl=empty_decl, set_target=set_target)
 617     for lib in liblist[:]:
 618         if not lib in checklist and mandatory:
 619             Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 620             sys.exit(1)
 621
 622     ret = True
 623     for f in remaining:
 624         if not CHECK_FUNC(conf, f, lib=' '.join(checklist), headers=headers, link=link):
 625             ret = False
 626
 627     return ret
 628
 629
 630 @conf
 631 def IN_LAUNCH_DIR(conf):
 632     '''return True if this rule is being run from the launch directory'''
 633     return os.path.realpath(conf.curdir) == os.path.realpath(Options.launch_dir)
 634 Options.Handler.IN_LAUNCH_DIR = IN_LAUNCH_DIR
 635
 636
 637 @conf
 638 def SAMBA_CONFIG_H(conf, path=None):
 639     '''write out config.h in the right directory'''
 640     # we don't want to produce a config.h in places like lib/replace
 641     # when we are building projects that depend on lib/replace
 642     if not IN_LAUNCH_DIR(conf):
 643         return
 644
 645     if Options.options.debug:
 646         conf.ADD_CFLAGS('-g', testflags=True)
 647
 648     if Options.options.developer:
 649         conf.env.DEVELOPER_MODE = True
 650
 651         conf.ADD_CFLAGS('-g', testflags=True)
 652         conf.ADD_CFLAGS('-Wall', testflags=True)
 653         conf.ADD_CFLAGS('-Wshadow', testflags=True)
 654         conf.ADD_CFLAGS('-Wmissing-prototypes', testflags=True)
 655         conf.ADD_CFLAGS('-Wcast-align -Wcast-qual', testflags=True)
 656         conf.ADD_CFLAGS('-fno-common', testflags=True)
 657
 658         conf.ADD_CFLAGS('-Werror=address', testflags=True)
 659         # we add these here to ensure that -Wstrict-prototypes is not set during configure
 660         conf.ADD_CFLAGS('-Werror=strict-prototypes -Wstrict-prototypes',
 661                         testflags=True)
 662         conf.ADD_CFLAGS('-Werror=write-strings -Wwrite-strings',
 663                         testflags=True)
 664         conf.ADD_CFLAGS('-Werror-implicit-function-declaration',
 665                         testflags=True)
 666         conf.ADD_CFLAGS('-Werror=pointer-arith -Wpointer-arith',
 667                         testflags=True)
 668         conf.ADD_CFLAGS('-Werror=declaration-after-statement -Wdeclaration-after-statement',
 669                         testflags=True)
 670
 671         conf.ADD_CFLAGS('-Wformat=2 -Wno-format-y2k', testflags=True)
 672         # This check is because for ldb_search(), a NULL format string
 673         # is not an error, but some compilers complain about that.
 674         if CHECK_CFLAGS(conf, ["-Werror=format", "-Wformat=2"], '''
 675 int testformat(char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
 676
 677 int main(void) {
 678         testformat(0);
 679         return 0;
 680 }
 681
 682 '''):
 683             if not 'EXTRA_CFLAGS' in conf.env:
 684                 conf.env['EXTRA_CFLAGS'] = []
 685             conf.env['EXTRA_CFLAGS'].extend(TO_LIST("-Werror=format"))
 686
 687     if Options.options.picky_developer:
 688         conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS', '-Werror', testflags=True)
 689
 690     if Options.options.fatal_errors:
 691         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 692
 693     if Options.options.pedantic:
 694         conf.ADD_CFLAGS('-W', testflags=True)
 695
 696     if path is None:
 697         conf.write_config_header('config.h', top=True)
 698     else:
 699         conf.write_config_header(path)
 700     conf.SAMBA_CROSS_CHECK_COMPLETE()
 701
 702
 703 @conf
 704 def CONFIG_PATH(conf, name, default):
 705     '''setup a configurable path'''
 706     if not name in conf.env:
 707         if default[0] == '/':
 708             conf.env[name] = default
 709         else:
 710             conf.env[name] = conf.env['PREFIX'] + default
 711
 712 @conf
 713 def ADD_NAMED_CFLAGS(conf, name, flags, testflags=False):
 714     '''add some CFLAGS to the command line
 715        optionally set testflags to ensure all the flags work
 716     '''
 717     if testflags:
 718         ok_flags=[]
 719         for f in flags.split():
 720             if CHECK_CFLAGS(conf, f):
 721                 ok_flags.append(f)
 722         flags = ok_flags
 723     if not name in conf.env:
 724         conf.env[name] = []
 725     conf.env[name].extend(TO_LIST(flags))
 726
 727 @conf
 728 def ADD_CFLAGS(conf, flags, testflags=False):
 729     '''add some CFLAGS to the command line
 730        optionally set testflags to ensure all the flags work
 731     '''
 732     ADD_NAMED_CFLAGS(conf, 'EXTRA_CFLAGS', flags, testflags=testflags)
 733
 734 @conf
 735 def ADD_LDFLAGS(conf, flags, testflags=False):
 736     '''add some LDFLAGS to the command line
 737        optionally set testflags to ensure all the flags work
 738
 739        this will return the flags that are added, if any
 740     '''
 741     if testflags:
 742         ok_flags=[]
 743         for f in flags.split():
 744             if CHECK_LDFLAGS(conf, f):
 745                 ok_flags.append(f)
 746         flags = ok_flags
 747     if not 'EXTRA_LDFLAGS' in conf.env:
 748         conf.env['EXTRA_LDFLAGS'] = []
 749     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 750     return flags
 751
 752
 753 @conf
 754 def ADD_EXTRA_INCLUDES(conf, includes):
 755     '''add some extra include directories to all builds'''
 756     if not 'EXTRA_INCLUDES' in conf.env:
 757         conf.env['EXTRA_INCLUDES'] = []
 758     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 759
 760
 761
 762 def CURRENT_CFLAGS(bld, target, cflags, allow_warnings=True, hide_symbols=False):
 763     '''work out the current flags. local flags are added first'''
 764     ret = TO_LIST(cflags)
 765     if not 'EXTRA_CFLAGS' in bld.env:
 766         list = []
 767     else:
 768         list = bld.env['EXTRA_CFLAGS'];
 769     ret.extend(list)
 770     if not allow_warnings and 'PICKY_CFLAGS' in bld.env:
 771         list = bld.env['PICKY_CFLAGS'];
 772         ret.extend(list)
 773     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 774         ret.append('-fvisibility=hidden')
 775     return ret
 776
 777
 778 @conf
 779 def CHECK_CC_ENV(conf):
 780     """trim whitespaces from 'CC'.
 781     The build farm sometimes puts a space at the start"""
 782     if os.environ.get('CC'):
 783         conf.env.CC = TO_LIST(os.environ.get('CC'))
 784         if len(conf.env.CC) == 1:
 785             # make for nicer logs if just a single command
 786             conf.env.CC = conf.env.CC[0]
 787
 788
 789 @conf
 790 def SETUP_CONFIGURE_CACHE(conf, enable):
 791     '''enable/disable cache of configure results'''
 792     if enable:
 793         # when -C is chosen, we will use a private cache and will
 794         # not look into system includes. This roughtly matches what
 795         # autoconf does with -C
 796         cache_path = os.path.join(conf.blddir, '.confcache')
 797         mkdir_p(cache_path)
 798         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 799     else:
 800         # when -C is not chosen we will not cache configure checks
 801         # We set the recursion limit low to prevent waf from spending
 802         # a lot of time on the signatures of the files.
 803         Options.cache_global = os.environ['WAFCACHE'] = ''
 804         preproc.recursion_limit = 1
 805     # in either case we don't need to scan system includes
 806     preproc.go_absolute = False
 807
 808
 809 @conf
 810 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
 811     # we don't want any libraries or modules to rely on runtime
 812     # resolution of symbols
 813     if not sys.platform.startswith("openbsd"):
 814         conf.env.undefined_ldflags = conf.ADD_LDFLAGS('-Wl,-no-undefined', testflags=True)
 815
 816     if not sys.platform.startswith("openbsd") and conf.env.undefined_ignore_ldflags == []:
 817         if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
 818             conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']