| 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 == True:
|
|---|
| 66 | p('ok ')
|
|---|
| 67 | elif result == False:
|
|---|
| 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) = library_flags(conf, lib)
|
|---|
| 96 |
|
|---|
| 97 | hdrs = hlist_to_string(conf, headers=h)
|
|---|
| 98 | ret = conf.check(fragment='%s\nint main(void) { return 0; }' % hdrs,
|
|---|
| 99 | type='nolink',
|
|---|
| 100 | execute=0,
|
|---|
| 101 | ccflags=ccflags,
|
|---|
| 102 | msg="Checking for header %s" % h)
|
|---|
| 103 | if not ret:
|
|---|
| 104 | missing_headers.add(h)
|
|---|
| 105 | return False
|
|---|
| 106 |
|
|---|
| 107 | conf.DEFINE(d, 1)
|
|---|
| 108 | if add_headers and not h in conf.env.hlist:
|
|---|
| 109 | conf.env.hlist.append(h)
|
|---|
| 110 | return ret
|
|---|
| 111 |
|
|---|
| 112 |
|
|---|
| 113 | @conf
|
|---|
| 114 | def CHECK_HEADERS(conf, headers, add_headers=False, together=False, lib=None):
|
|---|
| 115 | '''check for a list of headers
|
|---|
| 116 |
|
|---|
| 117 | when together==True, then the headers accumulate within this test.
|
|---|
| 118 | This is useful for interdependent headers
|
|---|
| 119 | '''
|
|---|
| 120 | ret = True
|
|---|
| 121 | if not add_headers and together:
|
|---|
| 122 | saved_hlist = conf.env.hlist[:]
|
|---|
| 123 | set_add_headers = True
|
|---|
| 124 | else:
|
|---|
| 125 | set_add_headers = add_headers
|
|---|
| 126 | for hdr in TO_LIST(headers):
|
|---|
| 127 | if not CHECK_HEADER(conf, hdr, set_add_headers, lib=lib):
|
|---|
| 128 | ret = False
|
|---|
| 129 | if not add_headers and together:
|
|---|
| 130 | conf.env.hlist = saved_hlist
|
|---|
| 131 | return ret
|
|---|
| 132 |
|
|---|
| 133 |
|
|---|
| 134 | def header_list(conf, headers=None, lib=None):
|
|---|
| 135 | '''form a list of headers which exist, as a string'''
|
|---|
| 136 | hlist=[]
|
|---|
| 137 | if headers is not None:
|
|---|
| 138 | for h in TO_LIST(headers):
|
|---|
| 139 | if CHECK_HEADER(conf, h, add_headers=False, lib=lib):
|
|---|
| 140 | hlist.append(h)
|
|---|
| 141 | return hlist_to_string(conf, headers=hlist)
|
|---|
| 142 |
|
|---|
| 143 |
|
|---|
| 144 | @conf
|
|---|
| 145 | def CHECK_TYPE(conf, t, alternate=None, headers=None, define=None, lib=None, msg=None):
|
|---|
| 146 | '''check for a single type'''
|
|---|
| 147 | if define is None:
|
|---|
| 148 | define = 'HAVE_' + t.upper().replace(' ', '_')
|
|---|
| 149 | if msg is None:
|
|---|
| 150 | msg='Checking for %s' % t
|
|---|
| 151 | ret = CHECK_CODE(conf, '%s _x' % t,
|
|---|
| 152 | define,
|
|---|
| 153 | execute=False,
|
|---|
| 154 | headers=headers,
|
|---|
| 155 | local_include=False,
|
|---|
| 156 | msg=msg,
|
|---|
| 157 | lib=lib,
|
|---|
| 158 | link=False)
|
|---|
| 159 | if not ret and alternate:
|
|---|
| 160 | conf.DEFINE(t, alternate)
|
|---|
| 161 | return ret
|
|---|
| 162 |
|
|---|
| 163 |
|
|---|
| 164 | @conf
|
|---|
| 165 | def CHECK_TYPES(conf, list, headers=None, define=None, alternate=None, lib=None):
|
|---|
| 166 | '''check for a list of types'''
|
|---|
| 167 | ret = True
|
|---|
| 168 | for t in TO_LIST(list):
|
|---|
| 169 | if not CHECK_TYPE(conf, t, headers=headers,
|
|---|
| 170 | define=define, alternate=alternate, lib=lib):
|
|---|
| 171 | ret = False
|
|---|
| 172 | return ret
|
|---|
| 173 |
|
|---|
| 174 |
|
|---|
| 175 | @conf
|
|---|
| 176 | def CHECK_TYPE_IN(conf, t, headers=None, alternate=None, define=None):
|
|---|
| 177 | '''check for a single type with a header'''
|
|---|
| 178 | return CHECK_TYPE(conf, t, headers=headers, alternate=alternate, define=define)
|
|---|
| 179 |
|
|---|
| 180 |
|
|---|
| 181 | @conf
|
|---|
| 182 | def CHECK_VARIABLE(conf, v, define=None, always=False,
|
|---|
| 183 | headers=None, msg=None, lib=None):
|
|---|
| 184 | '''check for a variable declaration (or define)'''
|
|---|
| 185 | if define is None:
|
|---|
| 186 | define = 'HAVE_%s' % v.upper()
|
|---|
| 187 |
|
|---|
| 188 | if msg is None:
|
|---|
| 189 | msg="Checking for variable %s" % v
|
|---|
| 190 |
|
|---|
| 191 | return CHECK_CODE(conf,
|
|---|
| 192 | # we need to make sure the compiler doesn't
|
|---|
| 193 | # optimize it out...
|
|---|
| 194 | '''
|
|---|
| 195 | #ifndef %s
|
|---|
| 196 | void *_x; _x=(void *)&%s; return (int)_x;
|
|---|
| 197 | #endif
|
|---|
| 198 | return 0
|
|---|
| 199 | ''' % (v, v),
|
|---|
| 200 | execute=False,
|
|---|
| 201 | link=False,
|
|---|
| 202 | msg=msg,
|
|---|
| 203 | local_include=False,
|
|---|
| 204 | lib=lib,
|
|---|
| 205 | headers=headers,
|
|---|
| 206 | define=define,
|
|---|
| 207 | always=always)
|
|---|
| 208 |
|
|---|
| 209 |
|
|---|
| 210 | @conf
|
|---|
| 211 | def CHECK_DECLS(conf, vars, reverse=False, headers=None, always=False):
|
|---|
| 212 | '''check a list of variable declarations, using the HAVE_DECL_xxx form
|
|---|
| 213 | of define
|
|---|
| 214 |
|
|---|
| 215 | When reverse==True then use HAVE_xxx_DECL instead of HAVE_DECL_xxx
|
|---|
| 216 | '''
|
|---|
| 217 | ret = True
|
|---|
| 218 | for v in TO_LIST(vars):
|
|---|
| 219 | if not reverse:
|
|---|
| 220 | define='HAVE_DECL_%s' % v.upper()
|
|---|
| 221 | else:
|
|---|
| 222 | define='HAVE_%s_DECL' % v.upper()
|
|---|
| 223 | if not CHECK_VARIABLE(conf, v,
|
|---|
| 224 | define=define,
|
|---|
| 225 | headers=headers,
|
|---|
| 226 | msg='Checking for declaration of %s' % v,
|
|---|
| 227 | always=always):
|
|---|
| 228 | ret = False
|
|---|
| 229 | return ret
|
|---|
| 230 |
|
|---|
| 231 |
|
|---|
| 232 | def CHECK_FUNC(conf, f, link=True, lib=None, headers=None):
|
|---|
| 233 | '''check for a function'''
|
|---|
| 234 | define='HAVE_%s' % f.upper()
|
|---|
| 235 |
|
|---|
| 236 | ret = False
|
|---|
| 237 |
|
|---|
| 238 | conf.COMPOUND_START('Checking for %s' % f)
|
|---|
| 239 |
|
|---|
| 240 | if link is None or link == True:
|
|---|
| 241 | ret = CHECK_CODE(conf,
|
|---|
| 242 | # this is based on the autoconf strategy
|
|---|
| 243 | '''
|
|---|
| 244 | #define %s __fake__%s
|
|---|
| 245 | #ifdef HAVE_LIMITS_H
|
|---|
| 246 | # include <limits.h>
|
|---|
| 247 | #else
|
|---|
| 248 | # include <assert.h>
|
|---|
| 249 | #endif
|
|---|
| 250 | #undef %s
|
|---|
| 251 | #if defined __stub_%s || defined __stub___%s
|
|---|
| 252 | #error "bad glibc stub"
|
|---|
| 253 | #endif
|
|---|
| 254 | extern char %s();
|
|---|
| 255 | int main() { return %s(); }
|
|---|
| 256 | ''' % (f, f, f, f, f, f, f),
|
|---|
| 257 | execute=False,
|
|---|
| 258 | link=True,
|
|---|
| 259 | addmain=False,
|
|---|
| 260 | add_headers=False,
|
|---|
| 261 | define=define,
|
|---|
| 262 | local_include=False,
|
|---|
| 263 | lib=lib,
|
|---|
| 264 | headers=headers,
|
|---|
| 265 | msg='Checking for %s' % f)
|
|---|
| 266 |
|
|---|
| 267 | if not ret:
|
|---|
| 268 | ret = CHECK_CODE(conf,
|
|---|
| 269 | # it might be a macro
|
|---|
| 270 | # we need to make sure the compiler doesn't
|
|---|
| 271 | # optimize it out...
|
|---|
| 272 | 'void *__x = (void *)%s; return (int)__x' % f,
|
|---|
| 273 | execute=False,
|
|---|
| 274 | link=True,
|
|---|
| 275 | addmain=True,
|
|---|
| 276 | add_headers=True,
|
|---|
| 277 | define=define,
|
|---|
| 278 | local_include=False,
|
|---|
| 279 | lib=lib,
|
|---|
| 280 | headers=headers,
|
|---|
| 281 | msg='Checking for macro %s' % f)
|
|---|
| 282 |
|
|---|
| 283 | if not ret and (link is None or link == False):
|
|---|
| 284 | ret = CHECK_VARIABLE(conf, f,
|
|---|
| 285 | define=define,
|
|---|
| 286 | headers=headers,
|
|---|
| 287 | msg='Checking for declaration of %s' % f)
|
|---|
| 288 | conf.COMPOUND_END(ret)
|
|---|
| 289 | return ret
|
|---|
| 290 |
|
|---|
| 291 |
|
|---|
| 292 | @conf
|
|---|
| 293 | def CHECK_FUNCS(conf, list, link=True, lib=None, headers=None):
|
|---|
| 294 | '''check for a list of functions'''
|
|---|
| 295 | ret = True
|
|---|
| 296 | for f in TO_LIST(list):
|
|---|
| 297 | if not CHECK_FUNC(conf, f, link=link, lib=lib, headers=headers):
|
|---|
| 298 | ret = False
|
|---|
| 299 | return ret
|
|---|
| 300 |
|
|---|
| 301 |
|
|---|
| 302 | @conf
|
|---|
| 303 | def CHECK_SIZEOF(conf, vars, headers=None, define=None):
|
|---|
| 304 | '''check the size of a type'''
|
|---|
| 305 | ret = True
|
|---|
| 306 | for v in TO_LIST(vars):
|
|---|
| 307 | v_define = define
|
|---|
| 308 | if v_define is None:
|
|---|
| 309 | v_define = 'SIZEOF_%s' % v.upper().replace(' ', '_')
|
|---|
| 310 | if not CHECK_CODE(conf,
|
|---|
| 311 | 'printf("%%u", (unsigned)sizeof(%s))' % v,
|
|---|
| 312 | define=v_define,
|
|---|
| 313 | execute=True,
|
|---|
| 314 | define_ret=True,
|
|---|
| 315 | quote=False,
|
|---|
| 316 | headers=headers,
|
|---|
| 317 | local_include=False,
|
|---|
| 318 | msg="Checking size of %s" % v):
|
|---|
| 319 | ret = False
|
|---|
| 320 | return ret
|
|---|
| 321 |
|
|---|
| 322 |
|
|---|
| 323 |
|
|---|
| 324 | @conf
|
|---|
| 325 | def CHECK_CODE(conf, code, define,
|
|---|
| 326 | always=False, execute=False, addmain=True,
|
|---|
| 327 | add_headers=True, mandatory=False,
|
|---|
| 328 | headers=None, msg=None, cflags='', includes='# .',
|
|---|
| 329 | local_include=True, lib=None, link=True,
|
|---|
| 330 | define_ret=False, quote=False,
|
|---|
| 331 | on_target=True):
|
|---|
| 332 | '''check if some code compiles and/or runs'''
|
|---|
| 333 |
|
|---|
| 334 | if CONFIG_SET(conf, define):
|
|---|
| 335 | return True
|
|---|
| 336 |
|
|---|
| 337 | if headers is not None:
|
|---|
| 338 | CHECK_HEADERS(conf, headers=headers, lib=lib)
|
|---|
| 339 |
|
|---|
| 340 | if add_headers:
|
|---|
| 341 | hdrs = header_list(conf, headers=headers, lib=lib)
|
|---|
| 342 | else:
|
|---|
| 343 | hdrs = ''
|
|---|
| 344 | if execute:
|
|---|
| 345 | execute = 1
|
|---|
| 346 | else:
|
|---|
| 347 | execute = 0
|
|---|
| 348 |
|
|---|
| 349 | defs = conf.get_config_header()
|
|---|
| 350 |
|
|---|
| 351 | if addmain:
|
|---|
| 352 | fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
|
|---|
| 353 | else:
|
|---|
| 354 | fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
|
|---|
| 355 |
|
|---|
| 356 | if msg is None:
|
|---|
| 357 | msg="Checking for %s" % define
|
|---|
| 358 |
|
|---|
| 359 | cflags = TO_LIST(cflags)
|
|---|
| 360 |
|
|---|
| 361 | if local_include:
|
|---|
| 362 | cflags.append('-I%s' % conf.curdir)
|
|---|
| 363 |
|
|---|
| 364 | if not link:
|
|---|
| 365 | type='nolink'
|
|---|
| 366 | else:
|
|---|
| 367 | type='cprogram'
|
|---|
| 368 |
|
|---|
| 369 | uselib = TO_LIST(lib)
|
|---|
| 370 |
|
|---|
| 371 | (ccflags, ldflags) = library_flags(conf, uselib)
|
|---|
| 372 |
|
|---|
| 373 | cflags.extend(ccflags)
|
|---|
| 374 |
|
|---|
| 375 | if on_target:
|
|---|
| 376 | exec_args = conf.SAMBA_CROSS_ARGS(msg=msg)
|
|---|
| 377 | else:
|
|---|
| 378 | exec_args = []
|
|---|
| 379 |
|
|---|
| 380 | conf.COMPOUND_START(msg)
|
|---|
| 381 |
|
|---|
| 382 | ret = conf.check(fragment=fragment,
|
|---|
| 383 | execute=execute,
|
|---|
| 384 | define_name = define,
|
|---|
| 385 | mandatory = mandatory,
|
|---|
| 386 | ccflags=cflags,
|
|---|
| 387 | ldflags=ldflags,
|
|---|
| 388 | includes=includes,
|
|---|
| 389 | uselib=uselib,
|
|---|
| 390 | type=type,
|
|---|
| 391 | msg=msg,
|
|---|
| 392 | quote=quote,
|
|---|
| 393 | exec_args=exec_args,
|
|---|
| 394 | define_ret=define_ret)
|
|---|
| 395 | if not ret and CONFIG_SET(conf, define):
|
|---|
| 396 | # sometimes conf.check() returns false, but it
|
|---|
| 397 | # sets the define. Maybe a waf bug?
|
|---|
| 398 | ret = True
|
|---|
| 399 | if ret:
|
|---|
| 400 | if not define_ret:
|
|---|
| 401 | conf.DEFINE(define, 1)
|
|---|
| 402 | conf.COMPOUND_END(True)
|
|---|
| 403 | else:
|
|---|
| 404 | conf.COMPOUND_END(conf.env[define])
|
|---|
| 405 | return True
|
|---|
| 406 | if always:
|
|---|
| 407 | conf.DEFINE(define, 0)
|
|---|
| 408 | conf.COMPOUND_END(False)
|
|---|
| 409 | return False
|
|---|
| 410 |
|
|---|
| 411 |
|
|---|
| 412 |
|
|---|
| 413 | @conf
|
|---|
| 414 | def CHECK_STRUCTURE_MEMBER(conf, structname, member,
|
|---|
| 415 | always=False, define=None, headers=None):
|
|---|
| 416 | '''check for a structure member'''
|
|---|
| 417 | if define is None:
|
|---|
| 418 | define = 'HAVE_%s' % member.upper()
|
|---|
| 419 | return CHECK_CODE(conf,
|
|---|
| 420 | '%s s; void *_x; _x=(void *)&s.%s' % (structname, member),
|
|---|
| 421 | define,
|
|---|
| 422 | execute=False,
|
|---|
| 423 | link=False,
|
|---|
| 424 | always=always,
|
|---|
| 425 | headers=headers,
|
|---|
| 426 | local_include=False,
|
|---|
| 427 | msg="Checking for member %s in %s" % (member, structname))
|
|---|
| 428 |
|
|---|
| 429 |
|
|---|
| 430 | @conf
|
|---|
| 431 | def CHECK_CFLAGS(conf, cflags):
|
|---|
| 432 | '''check if the given cflags are accepted by the compiler
|
|---|
| 433 | '''
|
|---|
| 434 | return conf.check(fragment='int main(void) { return 0; }\n',
|
|---|
| 435 | execute=0,
|
|---|
| 436 | type='nolink',
|
|---|
| 437 | ccflags=cflags,
|
|---|
| 438 | msg="Checking compiler accepts %s" % cflags)
|
|---|
| 439 |
|
|---|
| 440 | @conf
|
|---|
| 441 | def CHECK_LDFLAGS(conf, ldflags):
|
|---|
| 442 | '''check if the given ldflags are accepted by the linker
|
|---|
| 443 | '''
|
|---|
| 444 | return conf.check(fragment='int main(void) { return 0; }\n',
|
|---|
| 445 | execute=0,
|
|---|
| 446 | ldflags=ldflags,
|
|---|
| 447 | msg="Checking linker accepts %s" % ldflags)
|
|---|
| 448 |
|
|---|
| 449 |
|
|---|
| 450 | @conf
|
|---|
| 451 | def CONFIG_GET(conf, option):
|
|---|
| 452 | '''return True if a configuration option was found'''
|
|---|
| 453 | if (option in conf.env):
|
|---|
| 454 | return conf.env[option]
|
|---|
| 455 | else:
|
|---|
| 456 | return None
|
|---|
| 457 |
|
|---|
| 458 | @conf
|
|---|
| 459 | def CONFIG_SET(conf, option):
|
|---|
| 460 | '''return True if a configuration option was found'''
|
|---|
| 461 | return (option in conf.env) and (conf.env[option] != ())
|
|---|
| 462 | Build.BuildContext.CONFIG_SET = CONFIG_SET
|
|---|
| 463 | Build.BuildContext.CONFIG_GET = CONFIG_GET
|
|---|
| 464 |
|
|---|
| 465 |
|
|---|
| 466 | def library_flags(self, libs):
|
|---|
| 467 | '''work out flags from pkg_config'''
|
|---|
| 468 | ccflags = []
|
|---|
| 469 | ldflags = []
|
|---|
| 470 | for lib in TO_LIST(libs):
|
|---|
| 471 | inc_path = getattr(self.env, 'CPPPATH_%s' % lib.upper(), [])
|
|---|
| 472 | lib_path = getattr(self.env, 'LIBPATH_%s' % lib.upper(), [])
|
|---|
| 473 | ccflags.extend(['-I%s' % i for i in inc_path])
|
|---|
| 474 | ldflags.extend(['-L%s' % l for l in lib_path])
|
|---|
| 475 | extra_ccflags = TO_LIST(getattr(self.env, 'CCFLAGS_%s' % lib.upper(), []))
|
|---|
| 476 | extra_ldflags = TO_LIST(getattr(self.env, 'LDFLAGS_%s' % lib.upper(), []))
|
|---|
| 477 | ccflags.extend(extra_ccflags)
|
|---|
| 478 | ldflags.extend(extra_ldflags)
|
|---|
| 479 | if 'EXTRA_LDFLAGS' in self.env:
|
|---|
| 480 | ldflags.extend(self.env['EXTRA_LDFLAGS'])
|
|---|
| 481 |
|
|---|
| 482 | ccflags = unique_list(ccflags)
|
|---|
| 483 | ldflags = unique_list(ldflags)
|
|---|
| 484 | return (ccflags, ldflags)
|
|---|
| 485 |
|
|---|
| 486 |
|
|---|
| 487 | @conf
|
|---|
| 488 | def CHECK_LIB(conf, libs, mandatory=False, empty_decl=True, set_target=True, shlib=False):
|
|---|
| 489 | '''check if a set of libraries exist as system libraries
|
|---|
| 490 |
|
|---|
| 491 | returns the sublist of libs that do exist as a syslib or []
|
|---|
| 492 | '''
|
|---|
| 493 |
|
|---|
| 494 | fragment= '''
|
|---|
| 495 | int foo()
|
|---|
| 496 | {
|
|---|
| 497 | int v = 2;
|
|---|
| 498 | return v*2;
|
|---|
| 499 | }
|
|---|
| 500 | '''
|
|---|
| 501 | ret = []
|
|---|
| 502 | liblist = TO_LIST(libs)
|
|---|
| 503 | for lib in liblist[:]:
|
|---|
| 504 | if GET_TARGET_TYPE(conf, lib) == 'SYSLIB':
|
|---|
| 505 | ret.append(lib)
|
|---|
| 506 | continue
|
|---|
| 507 |
|
|---|
| 508 | (ccflags, ldflags) = library_flags(conf, lib)
|
|---|
| 509 | if shlib:
|
|---|
| 510 | res = conf.check(features='cc cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags)
|
|---|
| 511 | else:
|
|---|
| 512 | res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags)
|
|---|
| 513 |
|
|---|
| 514 | if not res:
|
|---|
| 515 | if mandatory:
|
|---|
| 516 | Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
|
|---|
| 517 | sys.exit(1)
|
|---|
| 518 | if empty_decl:
|
|---|
| 519 | # if it isn't a mandatory library, then remove it from dependency lists
|
|---|
| 520 | if set_target:
|
|---|
| 521 | SET_TARGET_TYPE(conf, lib, 'EMPTY')
|
|---|
| 522 | else:
|
|---|
| 523 | conf.define('HAVE_LIB%s' % lib.upper().replace('-','_'), 1)
|
|---|
| 524 | conf.env['LIB_' + lib.upper()] = lib
|
|---|
| 525 | if set_target:
|
|---|
| 526 | conf.SET_TARGET_TYPE(lib, 'SYSLIB')
|
|---|
| 527 | ret.append(lib)
|
|---|
| 528 |
|
|---|
| 529 | return ret
|
|---|
| 530 |
|
|---|
| 531 |
|
|---|
| 532 |
|
|---|
| 533 | @conf
|
|---|
| 534 | def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False,
|
|---|
| 535 | headers=None, link=True, empty_decl=True, set_target=True):
|
|---|
| 536 | """
|
|---|
| 537 | check that the functions in 'list' are available in 'library'
|
|---|
| 538 | if they are, then make that library available as a dependency
|
|---|
| 539 |
|
|---|
| 540 | if the library is not available and mandatory==True, then
|
|---|
| 541 | raise an error.
|
|---|
| 542 |
|
|---|
| 543 | If the library is not available and mandatory==False, then
|
|---|
| 544 | add the library to the list of dependencies to remove from
|
|---|
| 545 | build rules
|
|---|
| 546 |
|
|---|
| 547 | optionally check for the functions first in libc
|
|---|
| 548 | """
|
|---|
| 549 | remaining = TO_LIST(list)
|
|---|
| 550 | liblist = TO_LIST(library)
|
|---|
| 551 |
|
|---|
| 552 | # check if some already found
|
|---|
| 553 | for f in remaining[:]:
|
|---|
| 554 | if CONFIG_SET(conf, 'HAVE_%s' % f.upper()):
|
|---|
| 555 | remaining.remove(f)
|
|---|
| 556 |
|
|---|
| 557 | # see if the functions are in libc
|
|---|
| 558 | if checklibc:
|
|---|
| 559 | for f in remaining[:]:
|
|---|
| 560 | if CHECK_FUNC(conf, f, link=True, headers=headers):
|
|---|
| 561 | remaining.remove(f)
|
|---|
| 562 |
|
|---|
| 563 | if remaining == []:
|
|---|
| 564 | for lib in liblist:
|
|---|
| 565 | if GET_TARGET_TYPE(conf, lib) != 'SYSLIB' and empty_decl:
|
|---|
| 566 | SET_TARGET_TYPE(conf, lib, 'EMPTY')
|
|---|
| 567 | return True
|
|---|
| 568 |
|
|---|
| 569 | checklist = conf.CHECK_LIB(liblist, empty_decl=empty_decl, set_target=set_target)
|
|---|
| 570 | for lib in liblist[:]:
|
|---|
| 571 | if not lib in checklist and mandatory:
|
|---|
| 572 | Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
|
|---|
| 573 | sys.exit(1)
|
|---|
| 574 |
|
|---|
| 575 | ret = True
|
|---|
| 576 | for f in remaining:
|
|---|
| 577 | if not CHECK_FUNC(conf, f, lib=' '.join(checklist), headers=headers, link=link):
|
|---|
| 578 | ret = False
|
|---|
| 579 |
|
|---|
| 580 | return ret
|
|---|
| 581 |
|
|---|
| 582 |
|
|---|
| 583 | @conf
|
|---|
| 584 | def IN_LAUNCH_DIR(conf):
|
|---|
| 585 | '''return True if this rule is being run from the launch directory'''
|
|---|
| 586 | return os.path.realpath(conf.curdir) == os.path.realpath(Options.launch_dir)
|
|---|
| 587 | Options.Handler.IN_LAUNCH_DIR = IN_LAUNCH_DIR
|
|---|
| 588 |
|
|---|
| 589 |
|
|---|
| 590 | @conf
|
|---|
| 591 | def SAMBA_CONFIG_H(conf, path=None):
|
|---|
| 592 | '''write out config.h in the right directory'''
|
|---|
| 593 | # we don't want to produce a config.h in places like lib/replace
|
|---|
| 594 | # when we are building projects that depend on lib/replace
|
|---|
| 595 | if not IN_LAUNCH_DIR(conf):
|
|---|
| 596 | return
|
|---|
| 597 |
|
|---|
| 598 | if Options.options.developer:
|
|---|
| 599 | # we add these here to ensure that -Wstrict-prototypes is not set during configure
|
|---|
| 600 | conf.ADD_CFLAGS('-Wall -g -Wshadow -Wstrict-prototypes -Wpointer-arith -Wcast-align -Wwrite-strings -Werror-implicit-function-declaration -Wformat=2 -Wno-format-y2k -Wmissing-prototypes',
|
|---|
| 601 | testflags=True)
|
|---|
| 602 | if os.getenv('TOPLEVEL_BUILD'):
|
|---|
| 603 | conf.ADD_CFLAGS('-Wcast-qual', testflags=True)
|
|---|
| 604 | conf.env.DEVELOPER_MODE = True
|
|---|
| 605 |
|
|---|
| 606 | if Options.options.picky_developer:
|
|---|
| 607 | conf.ADD_CFLAGS('-Werror', testflags=True)
|
|---|
| 608 |
|
|---|
| 609 | if Options.options.fatal_errors:
|
|---|
| 610 | conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
|
|---|
| 611 |
|
|---|
| 612 | if Options.options.pedantic:
|
|---|
| 613 | conf.ADD_CFLAGS('-W', testflags=True)
|
|---|
| 614 |
|
|---|
| 615 | if path is None:
|
|---|
| 616 | conf.write_config_header('config.h', top=True)
|
|---|
| 617 | else:
|
|---|
| 618 | conf.write_config_header(path)
|
|---|
| 619 | conf.SAMBA_CROSS_CHECK_COMPLETE()
|
|---|
| 620 |
|
|---|
| 621 |
|
|---|
| 622 | @conf
|
|---|
| 623 | def CONFIG_PATH(conf, name, default):
|
|---|
| 624 | '''setup a configurable path'''
|
|---|
| 625 | if not name in conf.env:
|
|---|
| 626 | if default[0] == '/':
|
|---|
| 627 | conf.env[name] = default
|
|---|
| 628 | else:
|
|---|
| 629 | conf.env[name] = conf.env['PREFIX'] + default
|
|---|
| 630 |
|
|---|
| 631 | @conf
|
|---|
| 632 | def ADD_CFLAGS(conf, flags, testflags=False):
|
|---|
| 633 | '''add some CFLAGS to the command line
|
|---|
| 634 | optionally set testflags to ensure all the flags work
|
|---|
| 635 | '''
|
|---|
| 636 | if testflags:
|
|---|
| 637 | ok_flags=[]
|
|---|
| 638 | for f in flags.split():
|
|---|
| 639 | if CHECK_CFLAGS(conf, f):
|
|---|
| 640 | ok_flags.append(f)
|
|---|
| 641 | flags = ok_flags
|
|---|
| 642 | if not 'EXTRA_CFLAGS' in conf.env:
|
|---|
| 643 | conf.env['EXTRA_CFLAGS'] = []
|
|---|
| 644 | conf.env['EXTRA_CFLAGS'].extend(TO_LIST(flags))
|
|---|
| 645 |
|
|---|
| 646 | @conf
|
|---|
| 647 | def ADD_LDFLAGS(conf, flags, testflags=False):
|
|---|
| 648 | '''add some LDFLAGS to the command line
|
|---|
| 649 | optionally set testflags to ensure all the flags work
|
|---|
| 650 |
|
|---|
| 651 | this will return the flags that are added, if any
|
|---|
| 652 | '''
|
|---|
| 653 | if testflags:
|
|---|
| 654 | ok_flags=[]
|
|---|
| 655 | for f in flags.split():
|
|---|
| 656 | if CHECK_LDFLAGS(conf, f):
|
|---|
| 657 | ok_flags.append(f)
|
|---|
| 658 | flags = ok_flags
|
|---|
| 659 | if not 'EXTRA_LDFLAGS' in conf.env:
|
|---|
| 660 | conf.env['EXTRA_LDFLAGS'] = []
|
|---|
| 661 | conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
|
|---|
| 662 | return flags
|
|---|
| 663 |
|
|---|
| 664 |
|
|---|
| 665 | @conf
|
|---|
| 666 | def ADD_EXTRA_INCLUDES(conf, includes):
|
|---|
| 667 | '''add some extra include directories to all builds'''
|
|---|
| 668 | if not 'EXTRA_INCLUDES' in conf.env:
|
|---|
| 669 | conf.env['EXTRA_INCLUDES'] = []
|
|---|
| 670 | conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
|
|---|
| 671 |
|
|---|
| 672 |
|
|---|
| 673 |
|
|---|
| 674 | def CURRENT_CFLAGS(bld, target, cflags, hide_symbols=False):
|
|---|
| 675 | '''work out the current flags. local flags are added first'''
|
|---|
| 676 | if not 'EXTRA_CFLAGS' in bld.env:
|
|---|
| 677 | list = []
|
|---|
| 678 | else:
|
|---|
| 679 | list = bld.env['EXTRA_CFLAGS'];
|
|---|
| 680 | ret = TO_LIST(cflags)
|
|---|
| 681 | ret.extend(list)
|
|---|
| 682 | if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
|
|---|
| 683 | ret.append('-fvisibility=hidden')
|
|---|
| 684 | return ret
|
|---|
| 685 |
|
|---|
| 686 |
|
|---|
| 687 | @conf
|
|---|
| 688 | def CHECK_CC_ENV(conf):
|
|---|
| 689 | """trim whitespaces from 'CC'.
|
|---|
| 690 | The build farm sometimes puts a space at the start"""
|
|---|
| 691 | if os.environ.get('CC'):
|
|---|
| 692 | conf.env.CC = TO_LIST(os.environ.get('CC'))
|
|---|
| 693 | if len(conf.env.CC) == 1:
|
|---|
| 694 | # make for nicer logs if just a single command
|
|---|
| 695 | conf.env.CC = conf.env.CC[0]
|
|---|
| 696 |
|
|---|
| 697 |
|
|---|
| 698 | @conf
|
|---|
| 699 | def SETUP_CONFIGURE_CACHE(conf, enable):
|
|---|
| 700 | '''enable/disable cache of configure results'''
|
|---|
| 701 | if enable:
|
|---|
| 702 | # when -C is chosen, we will use a private cache and will
|
|---|
| 703 | # not look into system includes. This roughtly matches what
|
|---|
| 704 | # autoconf does with -C
|
|---|
| 705 | cache_path = os.path.join(conf.blddir, '.confcache')
|
|---|
| 706 | mkdir_p(cache_path)
|
|---|
| 707 | Options.cache_global = os.environ['WAFCACHE'] = cache_path
|
|---|
| 708 | else:
|
|---|
| 709 | # when -C is not chosen we will not cache configure checks
|
|---|
| 710 | # We set the recursion limit low to prevent waf from spending
|
|---|
| 711 | # a lot of time on the signatures of the files.
|
|---|
| 712 | Options.cache_global = os.environ['WAFCACHE'] = ''
|
|---|
| 713 | preproc.recursion_limit = 1
|
|---|
| 714 | # in either case we don't need to scan system includes
|
|---|
| 715 | preproc.go_absolute = False
|
|---|
