buildtools/wafsamba/samba_autoconf.py

   1 # a waf tool to add autoconf-like macros to the configure section
   2
   3 import os, sys
   4 import Build, Options, preproc, Logs
   5 from Configure import conf
   6 from TaskGen import feature
   7 from samba_utils import TO_LIST, GET_TARGET_TYPE, SET_TARGET_TYPE, runonce, unique_list, mkdir_p
   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             if not CHECK_CODE(conf,
 233                       '''
 234                       return (int)%s;
 235                       ''' % (v),
 236                       execute=False,
 237                       link=False,
 238                       msg='Checking for declaration of %s (as enum)' % v,
 239                       local_include=False,
 240                       headers=headers,
 241                       define=define,
 242                       always=always):
 243                 ret = False
 244     return ret
 245
 246
 247 def CHECK_FUNC(conf, f, link=True, lib=None, headers=None):
 248     '''check for a function'''
 249     define='HAVE_%s' % f.upper()
 250
 251     ret = False
 252
 253     conf.COMPOUND_START('Checking for %s' % f)
 254
 255     if link is None or link:
 256         ret = CHECK_CODE(conf,
 257                          # this is based on the autoconf strategy
 258                          '''
 259                          #define %s __fake__%s
 260                          #ifdef HAVE_LIMITS_H
 261                          # include <limits.h>
 262                          #else
 263                          # include <assert.h>
 264                          #endif
 265                          #undef %s
 266                          #if defined __stub_%s || defined __stub___%s
 267                          #error "bad glibc stub"
 268                          #endif
 269                          extern char %s();
 270                          int main() { return %s(); }
 271                          ''' % (f, f, f, f, f, f, f),
 272                          execute=False,
 273                          link=True,
 274                          addmain=False,
 275                          add_headers=False,
 276                          define=define,
 277                          local_include=False,
 278                          lib=lib,
 279                          headers=headers,
 280                          msg='Checking for %s' % f)
 281
 282         if not ret:
 283             ret = CHECK_CODE(conf,
 284                              # it might be a macro
 285                              # we need to make sure the compiler doesn't
 286                              # optimize it out...
 287                              'void *__x = (void *)%s; return (int)__x' % f,
 288                              execute=False,
 289                              link=True,
 290                              addmain=True,
 291                              add_headers=True,
 292                              define=define,
 293                              local_include=False,
 294                              lib=lib,
 295                              headers=headers,
 296                              msg='Checking for macro %s' % f)
 297
 298     if not ret and (link is None or not link):
 299         ret = CHECK_VARIABLE(conf, f,
 300                              define=define,
 301                              headers=headers,
 302                              msg='Checking for declaration of %s' % f)
 303     conf.COMPOUND_END(ret)
 304     return ret
 305
 306
 307 @conf
 308 def CHECK_FUNCS(conf, list, link=True, lib=None, headers=None):
 309     '''check for a list of functions'''
 310     ret = True
 311     for f in TO_LIST(list):
 312         if not CHECK_FUNC(conf, f, link=link, lib=lib, headers=headers):
 313             ret = False
 314     return ret
 315
 316
 317 @conf
 318 def CHECK_SIZEOF(conf, vars, headers=None, define=None, critical=True):
 319     '''check the size of a type'''
 320     for v in TO_LIST(vars):
 321         v_define = define
 322         ret = False
 323         if v_define is None:
 324             v_define = 'SIZEOF_%s' % v.upper().replace(' ', '_')
 325         for size in list((1, 2, 4, 8, 16, 32)):
 326             if CHECK_CODE(conf,
 327                       'static int test_array[1 - 2 * !(((long int)(sizeof(%s))) <= %d)];' % (v, size),
 328                       define=v_define,
 329                       quote=False,
 330                       headers=headers,
 331                       local_include=False,
 332                       msg="Checking if size of %s == %d" % (v, size)):
 333                 conf.DEFINE(v_define, size)
 334                 ret = True
 335                 break
 336         if not ret and critical:
 337             Logs.error("Couldn't determine size of '%s'" % v)
 338             sys.exit(1)
 339     return ret
 340
 341 @conf
 342 def CHECK_VALUEOF(conf, v, headers=None, define=None):
 343     '''check the value of a variable/define'''
 344     ret = True
 345     v_define = define
 346     if v_define is None:
 347         v_define = 'VALUEOF_%s' % v.upper().replace(' ', '_')
 348     if CHECK_CODE(conf,
 349                   'printf("%%u", (unsigned)(%s))' % v,
 350                   define=v_define,
 351                   execute=True,
 352                   define_ret=True,
 353                   quote=False,
 354                   headers=headers,
 355                   local_include=False,
 356                   msg="Checking value of %s" % v):
 357         return int(conf.env[v_define])
 358
 359     return None
 360
 361 @conf
 362 def CHECK_CODE(conf, code, define,
 363                always=False, execute=False, addmain=True,
 364                add_headers=True, mandatory=False,
 365                headers=None, msg=None, cflags='', includes='# .',
 366                local_include=True, lib=None, link=True,
 367                define_ret=False, quote=False,
 368                on_target=True):
 369     '''check if some code compiles and/or runs'''
 370
 371     if CONFIG_SET(conf, define):
 372         return True
 373
 374     if headers is not None:
 375         CHECK_HEADERS(conf, headers=headers, lib=lib)
 376
 377     if add_headers:
 378         hdrs = header_list(conf, headers=headers, lib=lib)
 379     else:
 380         hdrs = ''
 381     if execute:
 382         execute = 1
 383     else:
 384         execute = 0
 385
 386     defs = conf.get_config_header()
 387
 388     if addmain:
 389         fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
 390     else:
 391         fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
 392
 393     if msg is None:
 394         msg="Checking for %s" % define
 395
 396     cflags = TO_LIST(cflags)
 397
 398     if local_include:
 399         cflags.append('-I%s' % conf.curdir)
 400
 401     if not link:
 402         type='nolink'
 403     else:
 404         type='cprogram'
 405
 406     uselib = TO_LIST(lib)
 407
 408     (ccflags, ldflags, cpppath) = library_flags(conf, uselib)
 409
 410     includes = TO_LIST(includes)
 411     includes.extend(cpppath)
 412
 413     uselib = [l.upper() for l in uselib]
 414
 415     cflags.extend(ccflags)
 416
 417     if on_target:
 418         exec_args = conf.SAMBA_CROSS_ARGS(msg=msg)
 419     else:
 420         exec_args = []
 421
 422     conf.COMPOUND_START(msg)
 423
 424     ret = conf.check(fragment=fragment,
 425                      execute=execute,
 426                      define_name = define,
 427                      mandatory = mandatory,
 428                      ccflags=cflags,
 429                      ldflags=ldflags,
 430                      includes=includes,
 431                      uselib=uselib,
 432                      type=type,
 433                      msg=msg,
 434                      quote=quote,
 435                      exec_args=exec_args,
 436                      define_ret=define_ret)
 437     if not ret and CONFIG_SET(conf, define):
 438         # sometimes conf.check() returns false, but it
 439         # sets the define. Maybe a waf bug?
 440         ret = True
 441     if ret:
 442         if not define_ret:
 443             conf.DEFINE(define, 1)
 444             conf.COMPOUND_END(True)
 445         else:
 446             conf.COMPOUND_END(conf.env[define])
 447         return True
 448     if always:
 449         conf.DEFINE(define, 0)
 450     conf.COMPOUND_END(False)
 451     return False
 452
 453
 454
 455 @conf
 456 def CHECK_STRUCTURE_MEMBER(conf, structname, member,
 457                            always=False, define=None, headers=None):
 458     '''check for a structure member'''
 459     if define is None:
 460         define = 'HAVE_%s' % member.upper()
 461     return CHECK_CODE(conf,
 462                       '%s s; void *_x; _x=(void *)&s.%s' % (structname, member),
 463                       define,
 464                       execute=False,
 465                       link=False,
 466                       always=always,
 467                       headers=headers,
 468                       local_include=False,
 469                       msg="Checking for member %s in %s" % (member, structname))
 470
 471
 472 @conf
 473 def CHECK_CFLAGS(conf, cflags, fragment='int main(void) { return 0; }\n'):
 474     '''check if the given cflags are accepted by the compiler
 475     '''
 476     return conf.check(fragment=fragment,
 477                       execute=0,
 478                       type='nolink',
 479                       ccflags=cflags,
 480                       msg="Checking compiler accepts %s" % cflags)
 481
 482 @conf
 483 def CHECK_LDFLAGS(conf, ldflags):
 484     '''check if the given ldflags are accepted by the linker
 485     '''
 486     return conf.check(fragment='int main(void) { return 0; }\n',
 487                       execute=0,
 488                       ldflags=ldflags,
 489                       msg="Checking linker accepts %s" % ldflags)
 490
 491
 492 @conf
 493 def CONFIG_GET(conf, option):
 494     '''return True if a configuration option was found'''
 495     if (option in conf.env):
 496         return conf.env[option]
 497     else:
 498         return None
 499
 500 @conf
 501 def CONFIG_SET(conf, option):
 502     '''return True if a configuration option was found'''
 503     if option not in conf.env:
 504         return False
 505     v = conf.env[option]
 506     if v is None:
 507         return False
 508     if v == []:
 509         return False
 510     if v == ():
 511         return False
 512     return True
 513
 514 @conf
 515 def CONFIG_RESET(conf, option):
 516     if option not in conf.env:
 517         return
 518     del conf.env[option]
 519
 520 Build.BuildContext.CONFIG_RESET = CONFIG_RESET
 521 Build.BuildContext.CONFIG_SET = CONFIG_SET
 522 Build.BuildContext.CONFIG_GET = CONFIG_GET
 523
 524
 525 def library_flags(self, libs):
 526     '''work out flags from pkg_config'''
 527     ccflags = []
 528     ldflags = []
 529     cpppath = []
 530     for lib in TO_LIST(libs):
 531         # note that we do not add the -I and -L in here, as that is added by the waf
 532         # core. Adding it here would just change the order that it is put on the link line
 533         # which can cause system paths to be added before internal libraries
 534         extra_ccflags = TO_LIST(getattr(self.env, 'CCFLAGS_%s' % lib.upper(), []))
 535         extra_ldflags = TO_LIST(getattr(self.env, 'LDFLAGS_%s' % lib.upper(), []))
 536         extra_cpppath = TO_LIST(getattr(self.env, 'CPPPATH_%s' % lib.upper(), []))
 537         ccflags.extend(extra_ccflags)
 538         ldflags.extend(extra_ldflags)
 539         cpppath.extend(extra_cpppath)
 540     if 'EXTRA_LDFLAGS' in self.env:
 541         ldflags.extend(self.env['EXTRA_LDFLAGS'])
 542
 543     ccflags = unique_list(ccflags)
 544     ldflags = unique_list(ldflags)
 545     cpppath = unique_list(cpppath)
 546     return (ccflags, ldflags, cpppath)
 547
 548
 549 @conf
 550 def CHECK_LIB(conf, libs, mandatory=False, empty_decl=True, set_target=True, shlib=False):
 551     '''check if a set of libraries exist as system libraries
 552
 553     returns the sublist of libs that do exist as a syslib or []
 554     '''
 555
 556     fragment= '''
 557 int foo()
 558 {
 559     int v = 2;
 560     return v*2;
 561 }
 562 '''
 563     ret = []
 564     liblist  = TO_LIST(libs)
 565     for lib in liblist[:]:
 566         if GET_TARGET_TYPE(conf, lib) == 'SYSLIB':
 567             ret.append(lib)
 568             continue
 569
 570         (ccflags, ldflags, cpppath) = library_flags(conf, lib)
 571         if shlib:
 572             res = conf.check(features='c cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 573         else:
 574             res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags, uselib=lib.upper())
 575
 576         if not res:
 577             if mandatory:
 578                 Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 579                 sys.exit(1)
 580             if empty_decl:
 581                 # if it isn't a mandatory library, then remove it from dependency lists
 582                 if set_target:
 583                     SET_TARGET_TYPE(conf, lib, 'EMPTY')
 584         else:
 585             conf.define('HAVE_LIB%s' % lib.upper().replace('-','_').replace('.','_'), 1)
 586             conf.env['LIB_' + lib.upper()] = lib
 587             if set_target:
 588                 conf.SET_TARGET_TYPE(lib, 'SYSLIB')
 589             ret.append(lib)
 590
 591     return ret
 592
 593
 594
 595 @conf
 596 def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False,
 597                    headers=None, link=True, empty_decl=True, set_target=True):
 598     """
 599     check that the functions in 'list' are available in 'library'
 600     if they are, then make that library available as a dependency
 601
 602     if the library is not available and mandatory==True, then
 603     raise an error.
 604
 605     If the library is not available and mandatory==False, then
 606     add the library to the list of dependencies to remove from
 607     build rules
 608
 609     optionally check for the functions first in libc
 610     """
 611     remaining = TO_LIST(list)
 612     liblist   = TO_LIST(library)
 613
 614     # check if some already found
 615     for f in remaining[:]:
 616         if CONFIG_SET(conf, 'HAVE_%s' % f.upper()):
 617             remaining.remove(f)
 618
 619     # see if the functions are in libc
 620     if checklibc:
 621         for f in remaining[:]:
 622             if CHECK_FUNC(conf, f, link=True, headers=headers):
 623                 remaining.remove(f)
 624
 625     if remaining == []:
 626         for lib in liblist:
 627             if GET_TARGET_TYPE(conf, lib) != 'SYSLIB' and empty_decl:
 628                 SET_TARGET_TYPE(conf, lib, 'EMPTY')
 629         return True
 630
 631     checklist = conf.CHECK_LIB(liblist, empty_decl=empty_decl, set_target=set_target)
 632     for lib in liblist[:]:
 633         if not lib in checklist and mandatory:
 634             Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 635             sys.exit(1)
 636
 637     ret = True
 638     for f in remaining:
 639         if not CHECK_FUNC(conf, f, lib=' '.join(checklist), headers=headers, link=link):
 640             ret = False
 641
 642     return ret
 643
 644
 645 @conf
 646 def IN_LAUNCH_DIR(conf):
 647     '''return True if this rule is being run from the launch directory'''
 648     return os.path.realpath(conf.curdir) == os.path.realpath(Options.launch_dir)
 649 Options.Handler.IN_LAUNCH_DIR = IN_LAUNCH_DIR
 650
 651
 652 @conf
 653 def SAMBA_CONFIG_H(conf, path=None):
 654     '''write out config.h in the right directory'''
 655     # we don't want to produce a config.h in places like lib/replace
 656     # when we are building projects that depend on lib/replace
 657     if not IN_LAUNCH_DIR(conf):
 658         return
 659
 660     # we need to build real code that can't be optimized away to test
 661     if conf.check(fragment='''
 662         #include <stdio.h>
 663
 664         int main(void)
 665         {
 666             char t[100000];
 667             while (fgets(t, sizeof(t), stdin));
 668             return 0;
 669         }
 670         ''',
 671         execute=0,
 672         ccflags='-fstack-protector',
 673         ldflags='-fstack-protector',
 674         msg='Checking if toolchain accepts -fstack-protector'):
 675             conf.ADD_CFLAGS('-fstack-protector')
 676             conf.ADD_LDFLAGS('-fstack-protector')
 677
 678     if Options.options.debug:
 679         conf.ADD_CFLAGS('-g', testflags=True)
 680
 681     if Options.options.developer:
 682         conf.env.DEVELOPER_MODE = True
 683
 684         conf.ADD_CFLAGS('-g', testflags=True)
 685         conf.ADD_CFLAGS('-Wall', testflags=True)
 686         conf.ADD_CFLAGS('-Wshadow', testflags=True)
 687         conf.ADD_CFLAGS('-Wmissing-prototypes', testflags=True)
 688         conf.ADD_CFLAGS('-Wcast-align -Wcast-qual', testflags=True)
 689         conf.ADD_CFLAGS('-fno-common', testflags=True)
 690
 691         conf.ADD_CFLAGS('-Werror=address', testflags=True)
 692         # we add these here to ensure that -Wstrict-prototypes is not set during configure
 693         conf.ADD_CFLAGS('-Werror=strict-prototypes -Wstrict-prototypes',
 694                         testflags=True)
 695         conf.ADD_CFLAGS('-Werror=write-strings -Wwrite-strings',
 696                         testflags=True)
 697         conf.ADD_CFLAGS('-Werror-implicit-function-declaration',
 698                         testflags=True)
 699         conf.ADD_CFLAGS('-Werror=pointer-arith -Wpointer-arith',
 700                         testflags=True)
 701         conf.ADD_CFLAGS('-Werror=declaration-after-statement -Wdeclaration-after-statement',
 702                         testflags=True)
 703         conf.ADD_CFLAGS('-Werror=return-type -Wreturn-type',
 704                         testflags=True)
 705         conf.ADD_CFLAGS('-Werror=uninitialized -Wuninitialized',
 706                         testflags=True)
 707
 708         conf.ADD_CFLAGS('-Wformat=2 -Wno-format-y2k', testflags=True)
 709         # This check is because for ldb_search(), a NULL format string
 710         # is not an error, but some compilers complain about that.
 711         if CHECK_CFLAGS(conf, ["-Werror=format", "-Wformat=2"], '''
 712 int testformat(char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
 713
 714 int main(void) {
 715         testformat(0);
 716         return 0;
 717 }
 718
 719 '''):
 720             if not 'EXTRA_CFLAGS' in conf.env:
 721                 conf.env['EXTRA_CFLAGS'] = []
 722             conf.env['EXTRA_CFLAGS'].extend(TO_LIST("-Werror=format"))
 723
 724     if Options.options.picky_developer:
 725         conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS', '-Werror -Wno-error=deprecated-declarations', testflags=True)
 726
 727     if Options.options.fatal_errors:
 728         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 729
 730     if Options.options.pedantic:
 731         conf.ADD_CFLAGS('-W', testflags=True)
 732
 733     if Options.options.address_sanitizer:
 734         conf.ADD_CFLAGS('-fno-omit-frame-pointer -O1 -fsanitize=address', testflags=True)
 735         conf.ADD_LDFLAGS('-fsanitize=address', testflags=True)
 736         conf.env['ADDRESS_SANITIZER'] = True
 737
 738
 739     # Let people pass an additional ADDITIONAL_{CFLAGS,LDFLAGS}
 740     # environment variables which are only used the for final build.
 741     #
 742     # The CFLAGS and LDFLAGS environment variables are also
 743     # used for the configure checks which might impact their results.
 744     conf.add_os_flags('ADDITIONAL_CFLAGS')
 745     if conf.env.ADDITIONAL_CFLAGS and conf.CHECK_CFLAGS(conf.env['ADDITIONAL_CFLAGS']):
 746         conf.env['EXTRA_CFLAGS'].extend(conf.env['ADDITIONAL_CFLAGS'])
 747     conf.add_os_flags('ADDITIONAL_LDFLAGS')
 748     if conf.env.ADDITIONAL_LDFLAGS and conf.CHECK_LDFLAGS(conf.env['ADDITIONAL_LDFLAGS']):
 749         conf.env['EXTRA_LDFLAGS'].extend(conf.env['ADDITIONAL_LDFLAGS'])
 750
 751     if path is None:
 752         conf.write_config_header('config.h', top=True)
 753     else:
 754         conf.write_config_header(path)
 755     conf.SAMBA_CROSS_CHECK_COMPLETE()
 756
 757
 758 @conf
 759 def CONFIG_PATH(conf, name, default):
 760     '''setup a configurable path'''
 761     if not name in conf.env:
 762         if default[0] == '/':
 763             conf.env[name] = default
 764         else:
 765             conf.env[name] = conf.env['PREFIX'] + default
 766
 767 @conf
 768 def ADD_NAMED_CFLAGS(conf, name, flags, testflags=False):
 769     '''add some CFLAGS to the command line
 770        optionally set testflags to ensure all the flags work
 771     '''
 772     if testflags:
 773         ok_flags=[]
 774         for f in flags.split():
 775             if CHECK_CFLAGS(conf, f):
 776                 ok_flags.append(f)
 777         flags = ok_flags
 778     if not name in conf.env:
 779         conf.env[name] = []
 780     conf.env[name].extend(TO_LIST(flags))
 781
 782 @conf
 783 def ADD_CFLAGS(conf, flags, testflags=False):
 784     '''add some CFLAGS to the command line
 785        optionally set testflags to ensure all the flags work
 786     '''
 787     ADD_NAMED_CFLAGS(conf, 'EXTRA_CFLAGS', flags, testflags=testflags)
 788
 789 @conf
 790 def ADD_LDFLAGS(conf, flags, testflags=False):
 791     '''add some LDFLAGS to the command line
 792        optionally set testflags to ensure all the flags work
 793
 794        this will return the flags that are added, if any
 795     '''
 796     if testflags:
 797         ok_flags=[]
 798         for f in flags.split():
 799             if CHECK_LDFLAGS(conf, f):
 800                 ok_flags.append(f)
 801         flags = ok_flags
 802     if not 'EXTRA_LDFLAGS' in conf.env:
 803         conf.env['EXTRA_LDFLAGS'] = []
 804     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 805     return flags
 806
 807
 808 @conf
 809 def ADD_EXTRA_INCLUDES(conf, includes):
 810     '''add some extra include directories to all builds'''
 811     if not 'EXTRA_INCLUDES' in conf.env:
 812         conf.env['EXTRA_INCLUDES'] = []
 813     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 814
 815
 816
 817 def CURRENT_CFLAGS(bld, target, cflags, allow_warnings=False, hide_symbols=False):
 818     '''work out the current flags. local flags are added first'''
 819     ret = TO_LIST(cflags)
 820     if not 'EXTRA_CFLAGS' in bld.env:
 821         list = []
 822     else:
 823         list = bld.env['EXTRA_CFLAGS'];
 824     ret.extend(list)
 825     if not allow_warnings and 'PICKY_CFLAGS' in bld.env:
 826         list = bld.env['PICKY_CFLAGS'];
 827         ret.extend(list)
 828     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 829         ret.append(bld.env.VISIBILITY_CFLAGS)
 830     return ret
 831
 832
 833 @conf
 834 def CHECK_CC_ENV(conf):
 835     """trim whitespaces from 'CC'.
 836     The build farm sometimes puts a space at the start"""
 837     if os.environ.get('CC'):
 838         conf.env.CC = TO_LIST(os.environ.get('CC'))
 839         if len(conf.env.CC) == 1:
 840             # make for nicer logs if just a single command
 841             conf.env.CC = conf.env.CC[0]
 842
 843
 844 @conf
 845 def SETUP_CONFIGURE_CACHE(conf, enable):
 846     '''enable/disable cache of configure results'''
 847     if enable:
 848         # when -C is chosen, we will use a private cache and will
 849         # not look into system includes. This roughtly matches what
 850         # autoconf does with -C
 851         cache_path = os.path.join(conf.blddir, '.confcache')
 852         mkdir_p(cache_path)
 853         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 854     else:
 855         # when -C is not chosen we will not cache configure checks
 856         # We set the recursion limit low to prevent waf from spending
 857         # a lot of time on the signatures of the files.
 858         Options.cache_global = os.environ['WAFCACHE'] = ''
 859         preproc.recursion_limit = 1
 860     # in either case we don't need to scan system includes
 861     preproc.go_absolute = False
 862
 863
 864 @conf
 865 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
 866     # we don't want any libraries or modules to rely on runtime
 867     # resolution of symbols
 868     if not sys.platform.startswith("openbsd"):
 869         conf.env.undefined_ldflags = conf.ADD_LDFLAGS('-Wl,-no-undefined', testflags=True)
 870
 871     if not sys.platform.startswith("openbsd") and conf.env.undefined_ignore_ldflags == []:
 872         if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
 873             conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']
 874
 875 @conf
 876 def CHECK_CFG(self, *k, **kw):
 877     return self.check_cfg(*k, **kw)