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