buildtools/wafsamba/samba_autoconf.py

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