build: lib needs to take a list when more than 1
[nivanova/samba-autobuild/.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
4 import string
5 from Configure import conf
6 from samba_utils import *
7
8 ####################################################
9 # some autoconf like helpers, to make the transition
10 # to waf a bit easier for those used to autoconf
11 # m4 files
12
13 @runonce
14 @conf
15 def DEFINE(conf, d, v, add_to_cflags=False):
16     '''define a config option'''
17     conf.define(d, v, quote=False)
18     if add_to_cflags:
19         conf.env.append_value('CCDEFINES', d + '=' + str(v))
20
21 @runonce
22 def CHECK_HEADER(conf, h, add_headers=True):
23     '''check for a header'''
24     if conf.check(header_name=h) and add_headers:
25         conf.env.hlist.append(h)
26         return True
27     return False
28
29
30 @conf
31 def CHECK_HEADERS(conf, list, add_headers=True):
32     '''check for a list of headers'''
33     ret = True
34     for hdr in TO_LIST(list):
35         if not CHECK_HEADER(conf, hdr, add_headers):
36             ret = False
37     return ret
38
39
40 @conf
41 def CHECK_TYPES(conf, list):
42     '''check for a list of types'''
43     ret = True
44     lst = TO_LIST(list)
45     for t in TO_LIST(list):
46         if not conf.check(type_name=t, header_name=conf.env.hlist):
47             ret = False
48     return ret
49
50
51 @conf
52 def CHECK_TYPE_IN(conf, t, hdr, define=None):
53     '''check for a type in a specific header'''
54     if conf.check(header_name=hdr):
55         if define is None:
56             ret = conf.check(type_name=t, header_name=hdr)
57         else:
58             ret = conf.check(type_name=t, header_name=hdr, define_name=define)
59         return ret
60     return False
61
62
63 @conf
64 def CHECK_TYPE(conf, t, alternate=None, headers=None, define=None):
65     '''check for a type with an alternate'''
66     if headers is None:
67         headers = conf.env.hlist
68     if define is not None:
69         ret = conf.check(type_name=t, header_name=headers, define_name=define)
70     else:
71         ret = conf.check(type_name=t, header_name=headers)
72     if not ret and alternate is not None:
73         conf.DEFINE(t, alternate)
74     return ret
75
76
77 @conf
78 def CHECK_VARIABLE(conf, v, define=None, always=False, headers=None):
79     '''check for a variable declaration (or define)'''
80     hdrs=''
81     if headers is not None:
82         hlist = TO_LIST(headers)
83     else:
84         hlist = conf.env.hlist
85     for h in hlist:
86         hdrs += '#include <%s>\n' % h
87     if define is None:
88         define = 'HAVE_%s' % v.upper()
89     if conf.check(fragment=
90                   '''
91                   %s
92                   int main(void) {
93                     #ifndef %s
94                     void *_x; _x=(void *)&%s;
95                     #endif
96                     return 0;
97                   }
98                   ''' % (hdrs, v, v),
99                   execute=0,
100                   msg="Checking for variable %s" % v):
101         conf.DEFINE(define, 1)
102         return True
103     elif always:
104         conf.DEFINE(define, 0)
105         return False
106
107 @conf
108 def CHECK_DECLS(conf, vars, reverse=False, headers=None):
109     '''check a list of variable declarations, using the HAVE_DECL_xxx form
110        of define
111
112        When reverse==True then use HAVE_xxx_DECL instead of HAVE_DECL_xxx
113        '''
114     ret = True
115     for v in TO_LIST(vars):
116         if not reverse:
117             define='HAVE_DECL_%s' % v.upper()
118         else:
119             define='HAVE_%s_DECL' % v.upper()
120         if not CHECK_VARIABLE(conf, v, define=define, headers=headers):
121             ret = False
122     return ret
123
124
125 @runonce
126 def CHECK_FUNC(conf, f, checklink=False):
127     '''check for a function'''
128     if checklink:
129         return CHECK_CODE(conf, '%s()' % f, execute=False, define='HAVE_%s' % f.upper())
130     return conf.check(function_name=f, header_name=conf.env.hlist)
131
132
133 @conf
134 def CHECK_FUNCS(conf, list, checklink=False):
135     '''check for a list of functions'''
136     ret = True
137     for f in TO_LIST(list):
138         if not CHECK_FUNC(conf, f, checklink):
139             ret = False
140     return ret
141
142
143 @conf
144 def CHECK_SIZEOF(conf, vars, headers=None, define=None):
145     '''check the size of a type'''
146     hdrs=''
147     if headers is not None:
148         hlist = TO_LIST(headers)
149     else:
150         hlist = conf.env.hlist
151     for h in hlist:
152         hdrs += '#include <%s>\n' % h
153     for v in TO_LIST(vars):
154         if define is None:
155             define_name = 'SIZEOF_%s' % string.replace(v.upper(), ' ', '_')
156         else:
157             define_name = define
158         conf.check(fragment=
159                    '''
160                   %s
161                   int main(void) {
162                     printf("%%u\\n", (unsigned)sizeof(%s));
163                     return 0;
164                   }
165                   ''' % (hdrs, v),
166                    execute=1,
167                    define_ret=True,
168                    define_name=define_name,
169                    quote=False,
170                    msg="Checking size of %s" % v)
171
172
173 @conf
174 def CHECK_CODE(conf, code, define,
175                always=False, execute=False, addmain=True, mandatory=False,
176                headers=None, msg=None, cflags='', includes='# .',
177                local_include=True):
178     '''check if some code compiles and/or runs'''
179     hdrs=''
180     if headers is not None:
181         hlist = TO_LIST(headers)
182     else:
183         hlist = conf.env.hlist
184     for h in hlist:
185         hdrs += '#include <%s>\n' % h
186
187     if execute:
188         execute = 1
189     else:
190         execute = 0
191
192     if addmain:
193         fragment='#include "__confdefs.h"\n%s\n int main(void) { %s; return 0; }' % (hdrs, code)
194     else:
195         fragment='#include "__confdefs.h"\n%s\n%s' % (hdrs, code)
196
197     conf.write_config_header('__confdefs.h', top=True)
198
199     if msg is None:
200         msg="Checking for %s" % define
201
202     # include the directory containing __confdefs.h
203     cflags += ' -I../../default'
204
205     if local_include:
206         cflags += ' -I%s' % conf.curdir
207
208     if conf.check(fragment=fragment,
209                   execute=execute,
210                   define_name = define,
211                   mandatory = mandatory,
212                   ccflags=TO_LIST(cflags),
213                   includes=includes,
214                   msg=msg):
215         conf.DEFINE(define, 1)
216         return True
217     if always:
218         conf.DEFINE(define, 0)
219     return False
220
221
222
223 @conf
224 def CHECK_STRUCTURE_MEMBER(conf, structname, member,
225                            always=False, define=None, headers=None):
226     '''check for a structure member'''
227     hdrs=''
228     if headers is not None:
229         hlist = TO_LIST(headers)
230     else:
231         hlist = conf.env.hlist
232     for h in hlist:
233         hdrs += '#include <%s>\n' % h
234     if define is None:
235         define = 'HAVE_%s' % member.upper()
236     if conf.check(fragment=
237                   '''
238                   %s
239                   int main(void) {
240                     %s s;
241                     void *_x; _x=(void *)&s.%s;
242                     return 0;
243                   }
244                   ''' % (hdrs, structname, member),
245                   execute=0,
246                   msg="Checking for member %s in %s" % (member, structname)):
247         conf.DEFINE(define, 1)
248         return True
249     elif always:
250         conf.DEFINE(define, 0)
251         return False
252
253
254 @conf
255 def CHECK_CFLAGS(conf, cflags, variable):
256     '''check if the given cflags are accepted by the compiler'''
257     if conf.check(fragment='int main(void) { return 0; }',
258                   execute=0,
259                   ccflags=cflags,
260                   msg="Checking compiler accepts %s" % cflags):
261         conf.env[variable] = cflags
262         return True
263     return False
264
265
266 #################################################
267 # return True if a configuration option was found
268 @conf
269 def CONFIG_SET(conf, option):
270     return (option in conf.env) and (conf.env[option] != ())
271 Build.BuildContext.CONFIG_SET = CONFIG_SET
272
273
274 ###########################################################
275 # check that the functions in 'list' are available in 'library'
276 # if they are, then make that library available as a dependency
277 #
278 # if the library is not available and mandatory==True, then
279 # raise an error.
280 #
281 # If the library is not available and mandatory==False, then
282 # add the library to the list of dependencies to remove from
283 # build rules
284 #
285 # optionally check for the functions first in libc
286 @conf
287 def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False):
288     # first see if the functions are in libc
289     if checklibc:
290         remaining = []
291         for f in TO_LIST(list):
292             if not CHECK_FUNC(conf, f):
293                 remaining.append(f)
294     else:
295         remaining = TO_LIST(list)
296
297     if remaining == []:
298         for lib in TO_LIST(library):
299             if GET_TARGET_TYPE(conf, lib) != 'SYSLIB':
300                 SET_TARGET_TYPE(conf, lib, 'EMPTY')
301         return True
302
303     ret = True
304     for lib in TO_LIST(library):
305         if not conf.check(lib=lib, uselib_store=lib):
306             conf.ASSERT(not mandatory,
307                         "Mandatory library '%s' not found for functions '%s'" % (library, list))
308             # if it isn't a mandatory library, then remove it from dependency lists
309             SET_TARGET_TYPE(conf, library, 'EMPTY')
310             ret = False
311         else:
312             conf.define('HAVE_LIB%s' % string.replace(lib.upper(),'-','_'), 1)
313             conf.env['LIB_' + lib.upper()] = lib
314             LOCAL_CACHE_SET(conf, 'TARGET_TYPE', lib, 'SYSLIB')
315
316     if not ret:
317         return ret
318
319     ret = True
320     for f in remaining:
321         if not conf.check(function_name=f, lib=TO_LIST(library), header_name=conf.env.hlist):
322             ret = False
323     return ret
324
325
326 #################################################
327 # write out config.h in the right directory
328 @conf
329 def SAMBA_CONFIG_H(conf, path=None):
330     # we don't want to produce a config.h in places like lib/replace
331     # when we are building projects that depend on lib/replace
332     if os.path.realpath(conf.curdir) != os.path.realpath(Options.launch_dir):
333         return
334     if path is None:
335         conf.write_config_header('config.h', top=True)
336     else:
337         conf.write_config_header(path)
338
339
340 ##############################################################
341 # setup a configurable path
342 @conf
343 def CONFIG_PATH(conf, name, default):
344     if not name in conf.env:
345         if default[0] == '/':
346             conf.env[name] = default
347         else:
348             conf.env[name] = conf.env['PREFIX'] + default
349     conf.define(name, conf.env[name], quote=True)
350
351 ##############################################################
352 # add some CFLAGS to the command line
353 @conf
354 def ADD_CFLAGS(conf, flags):
355     if not 'EXTRA_CFLAGS' in conf.env:
356         conf.env['EXTRA_CFLAGS'] = []
357     conf.env['EXTRA_CFLAGS'].extend(TO_LIST(flags))
358
359 ##############################################################
360 # add some extra include directories to all builds
361 @conf
362 def ADD_EXTRA_INCLUDES(conf, includes):
363     if not 'EXTRA_INCLUDES' in conf.env:
364         conf.env['EXTRA_INCLUDES'] = []
365     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
366
367
368 ##############################################################
369 # work out the current flags. local flags are added first
370 def CURRENT_CFLAGS(bld, target, cflags):
371     if not 'EXTRA_CFLAGS' in bld.env:
372         list = []
373     else:
374         list = bld.env['EXTRA_CFLAGS'];
375     ret = TO_LIST(cflags)
376     ret.extend(list)
377     return ret