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