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             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='cc 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     if conf.CHECK_CFLAGS(['-fstack-protector']) and conf.CHECK_LDFLAGS(['-fstack-protector']):
 661         conf.ADD_CFLAGS('-fstack-protector')
 662         conf.ADD_LDFLAGS('-fstack-protector')
 663
 664     if Options.options.debug:
 665         conf.ADD_CFLAGS('-g', testflags=True)
 666
 667     if Options.options.developer:
 668         conf.env.DEVELOPER_MODE = True
 669
 670         conf.ADD_CFLAGS('-g', testflags=True)
 671         conf.ADD_CFLAGS('-Wall', testflags=True)
 672         conf.ADD_CFLAGS('-Wshadow', testflags=True)
 673         conf.ADD_CFLAGS('-Wmissing-prototypes', testflags=True)
 674         conf.ADD_CFLAGS('-Wcast-align -Wcast-qual', testflags=True)
 675         conf.ADD_CFLAGS('-fno-common', testflags=True)
 676
 677         conf.ADD_CFLAGS('-Werror=address', testflags=True)
 678         # we add these here to ensure that -Wstrict-prototypes is not set during configure
 679         conf.ADD_CFLAGS('-Werror=strict-prototypes -Wstrict-prototypes',
 680                         testflags=True)
 681         conf.ADD_CFLAGS('-Werror=write-strings -Wwrite-strings',
 682                         testflags=True)
 683         conf.ADD_CFLAGS('-Werror-implicit-function-declaration',
 684                         testflags=True)
 685         conf.ADD_CFLAGS('-Werror=pointer-arith -Wpointer-arith',
 686                         testflags=True)
 687         conf.ADD_CFLAGS('-Werror=declaration-after-statement -Wdeclaration-after-statement',
 688                         testflags=True)
 689         conf.ADD_CFLAGS('-Werror=return-type -Wreturn-type',
 690                         testflags=True)
 691         conf.ADD_CFLAGS('-Werror=uninitialized -Wuninitialized',
 692                         testflags=True)
 693
 694         conf.ADD_CFLAGS('-Wformat=2 -Wno-format-y2k', testflags=True)
 695         # This check is because for ldb_search(), a NULL format string
 696         # is not an error, but some compilers complain about that.
 697         if CHECK_CFLAGS(conf, ["-Werror=format", "-Wformat=2"], '''
 698 int testformat(char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
 699
 700 int main(void) {
 701         testformat(0);
 702         return 0;
 703 }
 704
 705 '''):
 706             if not 'EXTRA_CFLAGS' in conf.env:
 707                 conf.env['EXTRA_CFLAGS'] = []
 708             conf.env['EXTRA_CFLAGS'].extend(TO_LIST("-Werror=format"))
 709
 710     if Options.options.picky_developer:
 711         conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS', '-Werror -Wno-error=deprecated-declarations', testflags=True)
 712
 713     if Options.options.fatal_errors:
 714         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 715
 716     if Options.options.pedantic:
 717         conf.ADD_CFLAGS('-W', testflags=True)
 718
 719     if Options.options.address_sanitizer:
 720         conf.ADD_CFLAGS('-fno-omit-frame-pointer -O1 -fsanitize=address', testflags=True)
 721         conf.ADD_LDFLAGS('-fsanitize=address', testflags=True)
 722         conf.env['ADDRESS_SANITIZER'] = True
 723
 724
 725     # Let people pass an additional ADDITIONAL_{CFLAGS,LDFLAGS}
 726     # environment variables which are only used the for final build.
 727     #
 728     # The CFLAGS and LDFLAGS environment variables are also
 729     # used for the configure checks which might impact their results.
 730     conf.add_os_flags('ADDITIONAL_CFLAGS')
 731     if conf.env.ADDITIONAL_CFLAGS and conf.CHECK_CFLAGS(conf.env['ADDITIONAL_CFLAGS']):
 732         conf.env['EXTRA_CFLAGS'].extend(conf.env['ADDITIONAL_CFLAGS'])
 733     conf.add_os_flags('ADDITIONAL_LDFLAGS')
 734     if conf.env.ADDITIONAL_LDFLAGS and conf.CHECK_LDFLAGS(conf.env['ADDITIONAL_LDFLAGS']):
 735         conf.env['EXTRA_LDFLAGS'].extend(conf.env['ADDITIONAL_LDFLAGS'])
 736
 737     if path is None:
 738         conf.write_config_header('config.h', top=True)
 739     else:
 740         conf.write_config_header(path)
 741     conf.SAMBA_CROSS_CHECK_COMPLETE()
 742
 743
 744 @conf
 745 def CONFIG_PATH(conf, name, default):
 746     '''setup a configurable path'''
 747     if not name in conf.env:
 748         if default[0] == '/':
 749             conf.env[name] = default
 750         else:
 751             conf.env[name] = conf.env['PREFIX'] + default
 752
 753 @conf
 754 def ADD_NAMED_CFLAGS(conf, name, flags, testflags=False):
 755     '''add some CFLAGS to the command line
 756        optionally set testflags to ensure all the flags work
 757     '''
 758     if testflags:
 759         ok_flags=[]
 760         for f in flags.split():
 761             if CHECK_CFLAGS(conf, f):
 762                 ok_flags.append(f)
 763         flags = ok_flags
 764     if not name in conf.env:
 765         conf.env[name] = []
 766     conf.env[name].extend(TO_LIST(flags))
 767
 768 @conf
 769 def ADD_CFLAGS(conf, flags, testflags=False):
 770     '''add some CFLAGS to the command line
 771        optionally set testflags to ensure all the flags work
 772     '''
 773     ADD_NAMED_CFLAGS(conf, 'EXTRA_CFLAGS', flags, testflags=testflags)
 774
 775 @conf
 776 def ADD_LDFLAGS(conf, flags, testflags=False):
 777     '''add some LDFLAGS to the command line
 778        optionally set testflags to ensure all the flags work
 779
 780        this will return the flags that are added, if any
 781     '''
 782     if testflags:
 783         ok_flags=[]
 784         for f in flags.split():
 785             if CHECK_LDFLAGS(conf, f):
 786                 ok_flags.append(f)
 787         flags = ok_flags
 788     if not 'EXTRA_LDFLAGS' in conf.env:
 789         conf.env['EXTRA_LDFLAGS'] = []
 790     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 791     return flags
 792
 793
 794 @conf
 795 def ADD_EXTRA_INCLUDES(conf, includes):
 796     '''add some extra include directories to all builds'''
 797     if not 'EXTRA_INCLUDES' in conf.env:
 798         conf.env['EXTRA_INCLUDES'] = []
 799     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 800
 801
 802
 803 def CURRENT_CFLAGS(bld, target, cflags, allow_warnings=False, hide_symbols=False):
 804     '''work out the current flags. local flags are added first'''
 805     ret = TO_LIST(cflags)
 806     if not 'EXTRA_CFLAGS' in bld.env:
 807         list = []
 808     else:
 809         list = bld.env['EXTRA_CFLAGS'];
 810     ret.extend(list)
 811     if not allow_warnings and 'PICKY_CFLAGS' in bld.env:
 812         list = bld.env['PICKY_CFLAGS'];
 813         ret.extend(list)
 814     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 815         ret.append(bld.env.VISIBILITY_CFLAGS)
 816     return ret
 817
 818
 819 @conf
 820 def CHECK_CC_ENV(conf):
 821     """trim whitespaces from 'CC'.
 822     The build farm sometimes puts a space at the start"""
 823     if os.environ.get('CC'):
 824         conf.env.CC = TO_LIST(os.environ.get('CC'))
 825         if len(conf.env.CC) == 1:
 826             # make for nicer logs if just a single command
 827             conf.env.CC = conf.env.CC[0]
 828
 829
 830 @conf
 831 def SETUP_CONFIGURE_CACHE(conf, enable):
 832     '''enable/disable cache of configure results'''
 833     if enable:
 834         # when -C is chosen, we will use a private cache and will
 835         # not look into system includes. This roughtly matches what
 836         # autoconf does with -C
 837         cache_path = os.path.join(conf.blddir, '.confcache')
 838         mkdir_p(cache_path)
 839         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 840     else:
 841         # when -C is not chosen we will not cache configure checks
 842         # We set the recursion limit low to prevent waf from spending
 843         # a lot of time on the signatures of the files.
 844         Options.cache_global = os.environ['WAFCACHE'] = ''
 845         preproc.recursion_limit = 1
 846     # in either case we don't need to scan system includes
 847     preproc.go_absolute = False
 848
 849
 850 @conf
 851 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
 852     # we don't want any libraries or modules to rely on runtime
 853     # resolution of symbols
 854     if not sys.platform.startswith("openbsd"):
 855         conf.env.undefined_ldflags = conf.ADD_LDFLAGS('-Wl,-no-undefined', testflags=True)
 856
 857     if not sys.platform.startswith("openbsd") and conf.env.undefined_ignore_ldflags == []:
 858         if conf.CHECK_LDFLAGS(['-undefined', 'dynamic_lookup']):
 859             conf.env.undefined_ignore_ldflags = ['-undefined', 'dynamic_lookup']
 860
 861 @conf
 862 def CHECK_CFG(self, *k, **kw):
 863     return self.check_cfg(*k, **kw)