Context Navigation

source: waflib/Tools/c_config.py @ 733aea2

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+

Last change on this file since 733aea2 was 0fa325b, checked in by Paul Brossier <piem@piem.org>, 11 years ago
waf: unpack
Property mode set to `100755`
File size: 21.6 KB

Line
1	#! /usr/bin/env python
2	# encoding: utf-8
3	# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
4
5	import os,re,shlex,sys
6	from waflib import Build,Utils,Task,Options,Logs,Errors,ConfigSet,Runner
7	from waflib.TaskGen import after_method,feature
8	from waflib.Configure import conf
9	WAF_CONFIG_H='config.h'
10	DEFKEYS='define_key'
11	INCKEYS='include_key'
12	cfg_ver={'atleast-version':'>=','exact-version':'==','max-version':'<=',}
13	SNIP_FUNCTION='''
14	int main(int argc, char **argv) {
15	void *p;
16	(void)argc; (void)argv;
17	p=(void*)(%s);
18	return 0;
19	}
20	'''
21	SNIP_TYPE='''
22	int main(int argc, char **argv) {
23	(void)argc; (void)argv;
24	if ((%(type_name)s *) 0) return 0;
25	if (sizeof (%(type_name)s)) return 0;
26	return 1;
27	}
28	'''
29	SNIP_EMPTY_PROGRAM='''
30	int main(int argc, char **argv) {
31	(void)argc; (void)argv;
32	return 0;
33	}
34	'''
35	SNIP_FIELD='''
36	int main(int argc, char **argv) {
37	char *off;
38	(void)argc; (void)argv;
39	off = (char) &((%(type_name)s)0)->%(field_name)s;
40	return (size_t) off < sizeof(%(type_name)s);
41	}
42	'''
43	MACRO_TO_DESTOS={'__linux__':'linux','__GNU__':'gnu','__FreeBSD__':'freebsd','__NetBSD__':'netbsd','__OpenBSD__':'openbsd','__sun':'sunos','__hpux':'hpux','__sgi':'irix','_AIX':'aix','__CYGWIN__':'cygwin','__MSYS__':'msys','_UWIN':'uwin','_WIN64':'win32','_WIN32':'win32','__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__':'darwin','__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__':'darwin','__QNX__':'qnx','__native_client__':'nacl'}
44	MACRO_TO_DEST_CPU={'__x86_64__':'x86_64','__amd64__':'x86_64','__i386__':'x86','__ia64__':'ia','__mips__':'mips','__sparc__':'sparc','__alpha__':'alpha','__aarch64__':'aarch64','__thumb__':'thumb','__arm__':'arm','__hppa__':'hppa','__powerpc__':'powerpc','__ppc__':'powerpc','__convex__':'convex','__m68k__':'m68k','__s390x__':'s390x','__s390__':'s390','__sh__':'sh',}
45	@conf
46	def parse_flags(self,line,uselib_store,env=None,force_static=False):
47	assert(isinstance(line,str))
48	env=env or self.env
49	app=env.append_value
50	appu=env.append_unique
51	lex=shlex.shlex(line,posix=False)
52	lex.whitespace_split=True
53	lex.commenters=''
54	lst=list(lex)
55	uselib=uselib_store
56	while lst:
57	x=lst.pop(0)
58	st=x[:2]
59	ot=x[2:]
60	if st=='-I'or st=='/I':
61	if not ot:ot=lst.pop(0)
62	appu('INCLUDES_'+uselib,[ot])
63	elif st=='-include':
64	tmp=[x,lst.pop(0)]
65	app('CFLAGS',tmp)
66	app('CXXFLAGS',tmp)
67	elif st=='-D'or(env.CXX_NAME=='msvc'and st=='/D'):
68	if not ot:ot=lst.pop(0)
69	app('DEFINES_'+uselib,[ot])
70	elif st=='-l':
71	if not ot:ot=lst.pop(0)
72	prefix=force_static and'STLIB_'or'LIB_'
73	appu(prefix+uselib,[ot])
74	elif st=='-L':
75	if not ot:ot=lst.pop(0)
76	appu('LIBPATH_'+uselib,[ot])
77	elif x.startswith('/LIBPATH:'):
78	appu('LIBPATH_'+uselib,[x.replace('/LIBPATH:','')])
79	elif x=='-pthread'or x.startswith('+')or x.startswith('-std'):
80	app('CFLAGS_'+uselib,[x])
81	app('CXXFLAGS_'+uselib,[x])
82	app('LINKFLAGS_'+uselib,[x])
83	elif x=='-framework':
84	appu('FRAMEWORK_'+uselib,[lst.pop(0)])
85	elif x.startswith('-F'):
86	appu('FRAMEWORKPATH_'+uselib,[x[2:]])
87	elif x.startswith('-Wl'):
88	app('LINKFLAGS_'+uselib,[x])
89	elif x.startswith('-m')or x.startswith('-f')or x.startswith('-dynamic'):
90	app('CFLAGS_'+uselib,[x])
91	app('CXXFLAGS_'+uselib,[x])
92	elif x.startswith('-bundle'):
93	app('LINKFLAGS_'+uselib,[x])
94	elif x.startswith('-undefined'):
95	arg=lst.pop(0)
96	app('LINKFLAGS_'+uselib,[x,arg])
97	elif x.startswith('-arch')or x.startswith('-isysroot'):
98	tmp=[x,lst.pop(0)]
99	app('CFLAGS_'+uselib,tmp)
100	app('CXXFLAGS_'+uselib,tmp)
101	app('LINKFLAGS_'+uselib,tmp)
102	elif x.endswith('.a')or x.endswith('.so')or x.endswith('.dylib')or x.endswith('.lib'):
103	appu('LINKFLAGS_'+uselib,[x])
104	@conf
105	def ret_msg(self,f,kw):
106	if isinstance(f,str):
107	return f
108	return f(kw)
109	@conf
110	def validate_cfg(self,kw):
111	if not'path'in kw:
112	if not self.env.PKGCONFIG:
113	self.find_program('pkg-config',var='PKGCONFIG')
114	kw['path']=self.env.PKGCONFIG
115	if'atleast_pkgconfig_version'in kw:
116	if not'msg'in kw:
117	kw['msg']='Checking for pkg-config version >= %r'%kw['atleast_pkgconfig_version']
118	return
119	if not'okmsg'in kw:
120	kw['okmsg']='yes'
121	if not'errmsg'in kw:
122	kw['errmsg']='not found'
123	if'modversion'in kw:
124	if not'msg'in kw:
125	kw['msg']='Checking for %r version'%kw['modversion']
126	return
127	for x in cfg_ver.keys():
128	y=x.replace('-','_')
129	if y in kw:
130	if not'package'in kw:
131	raise ValueError('%s requires a package'%x)
132	if not'msg'in kw:
133	kw['msg']='Checking for %r %s %s'%(kw['package'],cfg_ver[x],kw[y])
134	return
135	if not'msg'in kw:
136	kw['msg']='Checking for %r'%(kw['package']or kw['path'])
137	@conf
138	def exec_cfg(self,kw):
139	def define_it():
140	self.define(self.have_define(kw.get('uselib_store',kw['package'])),1,0)
141	if'atleast_pkgconfig_version'in kw:
142	cmd=[kw['path'],'--atleast-pkgconfig-version=%s'%kw['atleast_pkgconfig_version']]
143	self.cmd_and_log(cmd)
144	if not'okmsg'in kw:
145	kw['okmsg']='yes'
146	return
147	for x in cfg_ver:
148	y=x.replace('-','_')
149	if y in kw:
150	self.cmd_and_log([kw['path'],'--%s=%s'%(x,kw[y]),kw['package']])
151	if not'okmsg'in kw:
152	kw['okmsg']='yes'
153	define_it()
154	break
155	if'modversion'in kw:
156	version=self.cmd_and_log([kw['path'],'--modversion',kw['modversion']]).strip()
157	self.define('%s_VERSION'%Utils.quote_define_name(kw.get('uselib_store',kw['modversion'])),version)
158	return version
159	lst=[kw['path']]
160	defi=kw.get('define_variable',None)
161	if not defi:
162	defi=self.env.PKG_CONFIG_DEFINES or{}
163	for key,val in defi.items():
164	lst.append('--define-variable=%s=%s'%(key,val))
165	if'variables'in kw:
166	env=kw.get('env',self.env)
167	uselib=kw.get('uselib_store',kw['package'].upper())
168	vars=Utils.to_list(kw['variables'])
169	for v in vars:
170	val=self.cmd_and_log(lst+['--variable='+v]).strip()
171	var='%s_%s'%(uselib,v)
172	env[var]=val
173	if not'okmsg'in kw:
174	kw['okmsg']='yes'
175	return
176	static=False
177	if'args'in kw:
178	args=Utils.to_list(kw['args'])
179	if'--static'in args or'--static-libs'in args:
180	static=True
181	lst+=args
182	lst.extend(Utils.to_list(kw['package']))
183	ret=self.cmd_and_log(lst)
184	if not'okmsg'in kw:
185	kw['okmsg']='yes'
186	define_it()
187	self.parse_flags(ret,kw.get('uselib_store',kw['package'].upper()),kw.get('env',self.env),force_static=static)
188	return ret
189	@conf
190	def check_cfg(self,k,*kw):
191	if k:
192	lst=k[0].split()
193	kw['package']=lst[0]
194	kw['args']=' '.join(lst[1:])
195	self.validate_cfg(kw)
196	if'msg'in kw:
197	self.start_msg(kw['msg'])
198	ret=None
199	try:
200	ret=self.exec_cfg(kw)
201	except self.errors.WafError:
202	if'errmsg'in kw:
203	self.end_msg(kw['errmsg'],'YELLOW')
204	if Logs.verbose>1:
205	raise
206	else:
207	self.fatal('The configuration failed')
208	else:
209	kw['success']=ret
210	if'okmsg'in kw:
211	self.end_msg(self.ret_msg(kw['okmsg'],kw))
212	return ret
213	@conf
214	def validate_c(self,kw):
215	if not'env'in kw:
216	kw['env']=self.env.derive()
217	env=kw['env']
218	if not'compiler'in kw and not'features'in kw:
219	kw['compiler']='c'
220	if env['CXX_NAME']and Task.classes.get('cxx',None):
221	kw['compiler']='cxx'
222	if not self.env['CXX']:
223	self.fatal('a c++ compiler is required')
224	else:
225	if not self.env['CC']:
226	self.fatal('a c compiler is required')
227	if not'compile_mode'in kw:
228	kw['compile_mode']='c'
229	if'cxx'in Utils.to_list(kw.get('features',[]))or kw.get('compiler','')=='cxx':
230	kw['compile_mode']='cxx'
231	if not'type'in kw:
232	kw['type']='cprogram'
233	if not'features'in kw:
234	kw['features']=[kw['compile_mode'],kw['type']]
235	else:
236	kw['features']=Utils.to_list(kw['features'])
237	if not'compile_filename'in kw:
238	kw['compile_filename']='test.c'+((kw['compile_mode']=='cxx')and'pp'or'')
239	def to_header(dct):
240	if'header_name'in dct:
241	dct=Utils.to_list(dct['header_name'])
242	return''.join(['#include <%s>\n'%x for x in dct])
243	return''
244	if'framework_name'in kw:
245	fwkname=kw['framework_name']
246	if not'uselib_store'in kw:
247	kw['uselib_store']=fwkname.upper()
248	if not kw.get('no_header',False):
249	if not'header_name'in kw:
250	kw['header_name']=[]
251	fwk='%s/%s.h'%(fwkname,fwkname)
252	if kw.get('remove_dot_h',None):
253	fwk=fwk[:-2]
254	kw['header_name']=Utils.to_list(kw['header_name'])+[fwk]
255	kw['msg']='Checking for framework %s'%fwkname
256	kw['framework']=fwkname
257	if'function_name'in kw:
258	fu=kw['function_name']
259	if not'msg'in kw:
260	kw['msg']='Checking for function %s'%fu
261	kw['code']=to_header(kw)+SNIP_FUNCTION%fu
262	if not'uselib_store'in kw:
263	kw['uselib_store']=fu.upper()
264	if not'define_name'in kw:
265	kw['define_name']=self.have_define(fu)
266	elif'type_name'in kw:
267	tu=kw['type_name']
268	if not'header_name'in kw:
269	kw['header_name']='stdint.h'
270	if'field_name'in kw:
271	field=kw['field_name']
272	kw['code']=to_header(kw)+SNIP_FIELD%{'type_name':tu,'field_name':field}
273	if not'msg'in kw:
274	kw['msg']='Checking for field %s in %s'%(field,tu)
275	if not'define_name'in kw:
276	kw['define_name']=self.have_define((tu+'_'+field).upper())
277	else:
278	kw['code']=to_header(kw)+SNIP_TYPE%{'type_name':tu}
279	if not'msg'in kw:
280	kw['msg']='Checking for type %s'%tu
281	if not'define_name'in kw:
282	kw['define_name']=self.have_define(tu.upper())
283	elif'header_name'in kw:
284	if not'msg'in kw:
285	kw['msg']='Checking for header %s'%kw['header_name']
286	l=Utils.to_list(kw['header_name'])
287	assert len(l)>0,'list of headers in header_name is empty'
288	kw['code']=to_header(kw)+SNIP_EMPTY_PROGRAM
289	if not'uselib_store'in kw:
290	kw['uselib_store']=l[0].upper()
291	if not'define_name'in kw:
292	kw['define_name']=self.have_define(l[0])
293	if'lib'in kw:
294	if not'msg'in kw:
295	kw['msg']='Checking for library %s'%kw['lib']
296	if not'uselib_store'in kw:
297	kw['uselib_store']=kw['lib'].upper()
298	if'stlib'in kw:
299	if not'msg'in kw:
300	kw['msg']='Checking for static library %s'%kw['stlib']
301	if not'uselib_store'in kw:
302	kw['uselib_store']=kw['stlib'].upper()
303	if'fragment'in kw:
304	kw['code']=kw['fragment']
305	if not'msg'in kw:
306	kw['msg']='Checking for code snippet'
307	if not'errmsg'in kw:
308	kw['errmsg']='no'
309	for(flagsname,flagstype)in[('cxxflags','compiler'),('cflags','compiler'),('linkflags','linker')]:
310	if flagsname in kw:
311	if not'msg'in kw:
312	kw['msg']='Checking for %s flags %s'%(flagstype,kw[flagsname])
313	if not'errmsg'in kw:
314	kw['errmsg']='no'
315	if not'execute'in kw:
316	kw['execute']=False
317	if kw['execute']:
318	kw['features'].append('test_exec')
319	if not'errmsg'in kw:
320	kw['errmsg']='not found'
321	if not'okmsg'in kw:
322	kw['okmsg']='yes'
323	if not'code'in kw:
324	kw['code']=SNIP_EMPTY_PROGRAM
325	if self.env[INCKEYS]:
326	kw['code']='\n'.join(['#include <%s>'%x for x in self.env[INCKEYS]])+'\n'+kw['code']
327	if not kw.get('success'):kw['success']=None
328	if'define_name'in kw:
329	self.undefine(kw['define_name'])
330	assert'msg'in kw,'invalid parameters, read http://freehackers.org/~tnagy/wafbook/single.html#config_helpers_c'
331	@conf
332	def post_check(self,k,*kw):
333	is_success=0
334	if kw['execute']:
335	if kw['success']is not None:
336	if kw.get('define_ret',False):
337	is_success=kw['success']
338	else:
339	is_success=(kw['success']==0)
340	else:
341	is_success=(kw['success']==0)
342	if'define_name'in kw:
343	if'header_name'in kw or'function_name'in kw or'type_name'in kw or'fragment'in kw:
344	if kw['execute']and kw.get('define_ret',None)and isinstance(is_success,str):
345	self.define(kw['define_name'],is_success,quote=kw.get('quote',1))
346	else:
347	self.define_cond(kw['define_name'],is_success)
348	else:
349	self.define_cond(kw['define_name'],is_success)
350	if'header_name'in kw:
351	if kw.get('auto_add_header_name',False):
352	self.env.append_value(INCKEYS,Utils.to_list(kw['header_name']))
353	if is_success and'uselib_store'in kw:
354	from waflib.Tools import ccroot
355	_vars=set([])
356	for x in kw['features']:
357	if x in ccroot.USELIB_VARS:
358	_vars\|=ccroot.USELIB_VARS[x]
359	for k in _vars:
360	lk=k.lower()
361	if k=='INCLUDES':lk='includes'
362	if k=='DEFINES':lk='defines'
363	if lk in kw:
364	val=kw[lk]
365	if isinstance(val,str):
366	val=val.rstrip(os.path.sep)
367	self.env.append_unique(k+'_'+kw['uselib_store'],val)
368	return is_success
369	@conf
370	def check(self,k,*kw):
371	self.validate_c(kw)
372	self.start_msg(kw['msg'])
373	ret=None
374	try:
375	ret=self.run_c_code(k,*kw)
376	except self.errors.ConfigurationError:
377	self.end_msg(kw['errmsg'],'YELLOW')
378	if Logs.verbose>1:
379	raise
380	else:
381	self.fatal('The configuration failed')
382	else:
383	kw['success']=ret
384	ret=self.post_check(k,*kw)
385	if not ret:
386	self.end_msg(kw['errmsg'],'YELLOW')
387	self.fatal('The configuration failed %r'%ret)
388	else:
389	self.end_msg(self.ret_msg(kw['okmsg'],kw))
390	return ret
391	class test_exec(Task.Task):
392	color='PINK'
393	def run(self):
394	if getattr(self.generator,'rpath',None):
395	if getattr(self.generator,'define_ret',False):
396	self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()])
397	else:
398	self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()])
399	else:
400	env=self.env.env or{}
401	env.update(dict(os.environ))
402	for var in('LD_LIBRARY_PATH','DYLD_LIBRARY_PATH','PATH'):
403	env[var]=self.inputs[0].parent.abspath()+os.path.pathsep+env.get(var,'')
404	if getattr(self.generator,'define_ret',False):
405	self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()],env=env)
406	else:
407	self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()],env=env)
408	@feature('test_exec')
409	@after_method('apply_link')
410	def test_exec_fun(self):
411	self.create_task('test_exec',self.link_task.outputs[0])
412	CACHE_RESULTS=1
413	COMPILE_ERRORS=2
414	@conf
415	def run_c_code(self,k,*kw):
416	lst=[str(v)for(p,v)in kw.items()if p!='env']
417	h=Utils.h_list(lst)
418	dir=self.bldnode.abspath()+os.sep+(not Utils.is_win32 and'.'or'')+'conf_check_'+Utils.to_hex(h)
419	try:
420	os.makedirs(dir)
421	except OSError:
422	pass
423	try:
424	os.stat(dir)
425	except OSError:
426	self.fatal('cannot use the configuration test folder %r'%dir)
427	cachemode=getattr(Options.options,'confcache',None)
428	if cachemode==CACHE_RESULTS:
429	try:
430	proj=ConfigSet.ConfigSet(os.path.join(dir,'cache_run_c_code'))
431	except OSError:
432	pass
433	else:
434	ret=proj['cache_run_c_code']
435	if isinstance(ret,str)and ret.startswith('Test does not build'):
436	self.fatal(ret)
437	return ret
438	bdir=os.path.join(dir,'testbuild')
439	if not os.path.exists(bdir):
440	os.makedirs(bdir)
441	self.test_bld=bld=Build.BuildContext(top_dir=dir,out_dir=bdir)
442	bld.init_dirs()
443	bld.progress_bar=0
444	bld.targets='*'
445	if kw['compile_filename']:
446	node=bld.srcnode.make_node(kw['compile_filename'])
447	node.write(kw['code'])
448	bld.logger=self.logger
449	bld.all_envs.update(self.all_envs)
450	bld.env=kw['env']
451	o=bld(features=kw['features'],source=kw['compile_filename'],target='testprog')
452	for k,v in kw.items():
453	setattr(o,k,v)
454	self.to_log("==>\n%s\n<=="%kw['code'])
455	bld.targets='*'
456	ret=-1
457	try:
458	try:
459	bld.compile()
460	except Errors.WafError:
461	ret='Test does not build: %s'%Utils.ex_stack()
462	self.fatal(ret)
463	else:
464	ret=getattr(bld,'retval',0)
465	finally:
466	proj=ConfigSet.ConfigSet()
467	proj['cache_run_c_code']=ret
468	proj.store(os.path.join(dir,'cache_run_c_code'))
469	return ret
470	@conf
471	def check_cxx(self,k,*kw):
472	kw['compiler']='cxx'
473	return self.check(k,*kw)
474	@conf
475	def check_cc(self,k,*kw):
476	kw['compiler']='c'
477	return self.check(k,*kw)
478	@conf
479	def define(self,key,val,quote=True):
480	assert key and isinstance(key,str)
481	if val is True:
482	val=1
483	elif val in(False,None):
484	val=0
485	if isinstance(val,int)or isinstance(val,float):
486	s='%s=%s'
487	else:
488	s=quote and'%s="%s"'or'%s=%s'
489	app=s%(key,str(val))
490	ban=key+'='
491	lst=self.env['DEFINES']
492	for x in lst:
493	if x.startswith(ban):
494	lst[lst.index(x)]=app
495	break
496	else:
497	self.env.append_value('DEFINES',app)
498	self.env.append_unique(DEFKEYS,key)
499	@conf
500	def undefine(self,key):
501	assert key and isinstance(key,str)
502	ban=key+'='
503	lst=[x for x in self.env['DEFINES']if not x.startswith(ban)]
504	self.env['DEFINES']=lst
505	self.env.append_unique(DEFKEYS,key)
506	@conf
507	def define_cond(self,key,val):
508	assert key and isinstance(key,str)
509	if val:
510	self.define(key,1)
511	else:
512	self.undefine(key)
513	@conf
514	def is_defined(self,key):
515	assert key and isinstance(key,str)
516	ban=key+'='
517	for x in self.env['DEFINES']:
518	if x.startswith(ban):
519	return True
520	return False
521	@conf
522	def get_define(self,key):
523	assert key and isinstance(key,str)
524	ban=key+'='
525	for x in self.env['DEFINES']:
526	if x.startswith(ban):
527	return x[len(ban):]
528	return None
529	@conf
530	def have_define(self,key):
531	return(self.env.HAVE_PAT or'HAVE_%s')%Utils.quote_define_name(key)
532	@conf
533	def write_config_header(self,configfile='',guard='',top=False,env=None,defines=True,headers=False,remove=True,define_prefix=''):
534	if env:
535	Logs.warn('Cannot pass env to write_config_header')
536	if not configfile:configfile=WAF_CONFIG_H
537	waf_guard=guard or'W_%s_WAF'%Utils.quote_define_name(configfile)
538	node=top and self.bldnode or self.path.get_bld()
539	node=node.make_node(configfile)
540	node.parent.mkdir()
541	lst=['/* WARNING! All changes made to this file will be lost! */\n']
542	lst.append('#ifndef %s\n#define %s\n'%(waf_guard,waf_guard))
543	lst.append(self.get_config_header(defines,headers,define_prefix=define_prefix))
544	lst.append('\n#endif /* %s */\n'%waf_guard)
545	node.write('\n'.join(lst))
546	self.env.append_unique(Build.CFG_FILES,[node.abspath()])
547	if remove:
548	for key in self.env[DEFKEYS]:
549	self.undefine(key)
550	self.env[DEFKEYS]=[]
551	@conf
552	def get_config_header(self,defines=True,headers=False,define_prefix=''):
553	lst=[]
554	if headers:
555	for x in self.env[INCKEYS]:
556	lst.append('#include <%s>'%x)
557	if defines:
558	for x in self.env[DEFKEYS]:
559	if self.is_defined(x):
560	val=self.get_define(x)
561	lst.append('#define %s %s'%(define_prefix+x,val))
562	else:
563	lst.append('/* #undef %s */'%(define_prefix+x))
564	return"\n".join(lst)
565	@conf
566	def cc_add_flags(conf):
567	conf.add_os_flags('CPPFLAGS','CFLAGS')
568	conf.add_os_flags('CFLAGS')
569	@conf
570	def cxx_add_flags(conf):
571	conf.add_os_flags('CPPFLAGS','CXXFLAGS')
572	conf.add_os_flags('CXXFLAGS')
573	@conf
574	def link_add_flags(conf):
575	conf.add_os_flags('LINKFLAGS')
576	conf.add_os_flags('LDFLAGS','LINKFLAGS')
577	@conf
578	def cc_load_tools(conf):
579	if not conf.env.DEST_OS:
580	conf.env.DEST_OS=Utils.unversioned_sys_platform()
581	conf.load('c')
582	@conf
583	def cxx_load_tools(conf):
584	if not conf.env.DEST_OS:
585	conf.env.DEST_OS=Utils.unversioned_sys_platform()
586	conf.load('cxx')
587	@conf
588	def get_cc_version(conf,cc,gcc=False,icc=False):
589	cmd=cc+['-dM','-E','-']
590	env=conf.env.env or None
591	try:
592	p=Utils.subprocess.Popen(cmd,stdin=Utils.subprocess.PIPE,stdout=Utils.subprocess.PIPE,stderr=Utils.subprocess.PIPE,env=env)
593	p.stdin.write('\n')
594	out=p.communicate()[0]
595	except Exception:
596	conf.fatal('Could not determine the compiler version %r'%cmd)
597	if not isinstance(out,str):
598	out=out.decode(sys.stdout.encoding or'iso8859-1')
599	if gcc:
600	if out.find('__INTEL_COMPILER')>=0:
601	conf.fatal('The intel compiler pretends to be gcc')
602	if out.find('__GNUC__')<0:
603	conf.fatal('Could not determine the compiler type')
604	if icc and out.find('__INTEL_COMPILER')<0:
605	conf.fatal('Not icc/icpc')
606	k={}
607	if icc or gcc:
608	out=out.splitlines()
609	for line in out:
610	lst=shlex.split(line)
611	if len(lst)>2:
612	key=lst[1]
613	val=lst[2]
614	k[key]=val
615	def isD(var):
616	return var in k
617	def isT(var):
618	return var in k and k[var]!='0'
619	if not conf.env.DEST_OS:
620	conf.env.DEST_OS=''
621	for i in MACRO_TO_DESTOS:
622	if isD(i):
623	conf.env.DEST_OS=MACRO_TO_DESTOS[i]
624	break
625	else:
626	if isD('__APPLE__')and isD('__MACH__'):
627	conf.env.DEST_OS='darwin'
628	elif isD('__unix__'):
629	conf.env.DEST_OS='generic'
630	if isD('__ELF__'):
631	conf.env.DEST_BINFMT='elf'
632	elif isD('__WINNT__')or isD('__CYGWIN__'):
633	conf.env.DEST_BINFMT='pe'
634	conf.env.LIBDIR=conf.env['PREFIX']+'/bin'
635	elif isD('__APPLE__'):
636	conf.env.DEST_BINFMT='mac-o'
637	if not conf.env.DEST_BINFMT:
638	conf.env.DEST_BINFMT=Utils.destos_to_binfmt(conf.env.DEST_OS)
639	for i in MACRO_TO_DEST_CPU:
640	if isD(i):
641	conf.env.DEST_CPU=MACRO_TO_DEST_CPU[i]
642	break
643	Logs.debug('ccroot: dest platform: '+' '.join([conf.env[x]or'?'for x in('DEST_OS','DEST_BINFMT','DEST_CPU')]))
644	if icc:
645	ver=k['__INTEL_COMPILER']
646	conf.env['CC_VERSION']=(ver[:-2],ver[-2],ver[-1])
647	else:
648	if isD('__clang__'):
649	conf.env['CC_VERSION']=(k['__clang_major__'],k['__clang_minor__'],k['__clang_patchlevel__'])
650	else:
651	conf.env['CC_VERSION']=(k['__GNUC__'],k['__GNUC_MINOR__'],k['__GNUC_PATCHLEVEL__'])
652	return k
653	@conf
654	def get_xlc_version(conf,cc):
655	cmd=cc+['-qversion']
656	try:
657	out,err=conf.cmd_and_log(cmd,output=0)
658	except Errors.WafError:
659	conf.fatal('Could not find xlc %r'%cmd)
660	for v in(r"IBM XL C/C\+\+.* V(?P<major>\d)\.(?P<minor>\d)",):
661	version_re=re.compile(v,re.I).search
662	match=version_re(out or err)
663	if match:
664	k=match.groupdict()
665	conf.env['CC_VERSION']=(k['major'],k['minor'])
666	break
667	else:
668	conf.fatal('Could not determine the XLC version.')
669	@conf
670	def add_as_needed(self):
671	if self.env.DEST_BINFMT=='elf'and'gcc'in(self.env.CXX_NAME,self.env.CC_NAME):
672	self.env.append_unique('LINKFLAGS','--as-needed')
673	class cfgtask(Task.TaskBase):
674	def display(self):
675	return''
676	def runnable_status(self):
677	return Task.RUN_ME
678	def uid(self):
679	return Utils.SIG_NIL
680	def run(self):
681	conf=self.conf
682	bld=Build.BuildContext(top_dir=conf.srcnode.abspath(),out_dir=conf.bldnode.abspath())
683	bld.env=conf.env
684	bld.init_dirs()
685	bld.in_msg=1
686	bld.logger=self.logger
687	try:
688	bld.check(**self.args)
689	except Exception:
690	return 1
691	@conf
692	def multicheck(self,k,*kw):
693	self.start_msg(kw.get('msg','Executing %d configuration tests'%len(k)))
694	class par(object):
695	def __init__(self):
696	self.keep=False
697	self.cache_global=Options.cache_global
698	self.nocache=Options.options.nocache
699	self.returned_tasks=[]
700	self.task_sigs={}
701	def total(self):
702	return len(tasks)
703	def to_log(self,k,*kw):
704	return
705	bld=par()
706	tasks=[]
707	for dct in k:
708	x=cfgtask(bld=bld)
709	tasks.append(x)
710	x.args=dct
711	x.bld=bld
712	x.conf=self
713	x.args=dct
714	x.logger=Logs.make_mem_logger(str(id(x)),self.logger)
715	def it():
716	yield tasks
717	while 1:
718	yield[]
719	p=Runner.Parallel(bld,Options.options.jobs)
720	p.biter=it()
721	p.start()
722	for x in tasks:
723	x.logger.memhandler.flush()
724	for x in tasks:
725	if x.hasrun!=Task.SUCCESS:
726	self.end_msg(kw.get('errmsg','no'),color='YELLOW')
727	self.fatal(kw.get('fatalmsg',None)or'One of the tests has failed, see the config.log for more information')
728	self.end_msg('ok')

Note: See TracBrowser for help on using the repository browser.

Download in other formats: