Context Navigation

aclocal_cc.m4 @ 4876

Revision 4876, 74.7 KB (checked in by buntinas, 5 months ago)
tweaked warning options some more

Line
1	dnl
2	dnl This is a replacement for AC_PROG_CC that does not prefer gcc and
3	dnl that does not mess with CFLAGS. See acspecific.m4 for the original defn.
4	dnl
5	dnl/D*
6	dnl PAC_PROG_CC - Find a working C compiler
7	dnl
8	dnl Synopsis:
9	dnl PAC_PROG_CC
10	dnl
11	dnl Output Effect:
12	dnl Sets the variable CC if it is not already set
13	dnl
14	dnl Notes:
15	dnl Unlike AC_PROG_CC, this does not prefer gcc and does not set CFLAGS.
16	dnl It does check that the compiler can compile a simple C program.
17	dnl It also sets the variable GCC to yes if the compiler is gcc. It does
18	dnl not yet check for some special options needed in particular for
19	dnl parallel computers, such as -Tcray-t3e, or special options to get
20	dnl full ANSI/ISO C, such as -Aa for HP.
21	dnl
22	dnl D/*
23	dnl 2.52 doesn't have AC_PROG_CC_GNU
24	ifdef([AC_PROG_CC_GNU],,[AC_DEFUN([AC_PROG_CC_GNU],)])
25	AC_DEFUN([PAC_PROG_CC],[
26	AC_PROVIDE([AC_PROG_CC])
27	AC_CHECK_PROGS(CC, cc xlC xlc pgcc icc pathcc gcc )
28	test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
29	PAC_PROG_CC_WORKS
30	AC_PROG_CC_GNU
31	if test "$ac_cv_prog_gcc" = yes; then
32	GCC=yes
33	else
34	GCC=
35	fi
36	])
37	dnl
38	dnl/D*
39	dnl PAC_C_CHECK_COMPILER_OPTION - Check that a compiler option is accepted
40	dnl without warning messages
41	dnl
42	dnl Synopsis:
43	dnl PAC_C_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
44	dnl
45	dnl Output Effects:
46	dnl
47	dnl If no actions are specified, a working value is added to 'COPTIONS'
48	dnl
49	dnl Notes:
50	dnl This is now careful to check that the output is different, since
51	dnl some compilers are noisy.
52	dnl
53	dnl We are extra careful to prototype the functions in case compiler options
54	dnl that complain about poor code are in effect.
55	dnl
56	dnl Because this is a long script, we have ensured that you can pass a
57	dnl variable containing the option name as the first argument.
58	dnl D/*
59	AC_DEFUN([PAC_C_CHECK_COMPILER_OPTION],[
60	AC_MSG_CHECKING([whether C compiler accepts option $1])
61	save_CFLAGS="$CFLAGS"
62	CFLAGS="$1 $CFLAGS"
63	rm -f conftest.out
64	echo 'int foo(void);int foo(void){return 0;}' > conftest2.c
65	echo 'int main(void);int main(void){return 0;}' > conftest.c
66	if ${CC-cc} $save_CFLAGS $CPPFLAGS -o conftest conftest.c $LDFLAGS >conftest.bas 2>&1 ; then
67	if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest.c $LDFLAGS >conftest.out 2>&1 ; then
68	if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
69	AC_MSG_RESULT(yes)
70	AC_MSG_CHECKING([whether routines compiled with $1 can be linked with ones compiled without $1])
71	rm -f conftest.out
72	rm -f conftest.bas
73	if ${CC-cc} -c $save_CFLAGS $CPPFLAGS conftest2.c >conftest2.out 2>&1 ; then
74	if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest2.o conftest.c $LDFLAGS >conftest.bas 2>&1 ; then
75	if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest2.o conftest.c $LDFLAGS >conftest.out 2>&1 ; then
76	if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
77	AC_MSG_RESULT(yes)
78	CFLAGS="$save_CFLAGS"
79	ifelse($2,,COPTIONS="$COPTIONS $1",$2)
80	elif test -s conftest.out ; then
81	cat conftest.out >&AC_FD_CC
82	AC_MSG_RESULT(no)
83	CFLAGS="$save_CFLAGS"
84	$3
85	else
86	AC_MSG_RESULT(no)
87	CFLAGS="$save_CFLAGS"
88	$3
89	fi
90	else
91	if test -s conftest.out ; then
92	cat conftest.out >&AC_FD_CC
93	fi
94	AC_MSG_RESULT(no)
95	CFLAGS="$save_CFLAGS"
96	$3
97	fi
98	else
99	# Could not link with the option!
100	AC_MSG_RESULT(no)
101	fi
102	else
103	if test -s conftest2.out ; then
104	cat conftest2.out >&AC_FD_CC
105	fi
106	AC_MSG_RESULT(no)
107	CFLAGS="$save_CFLAGS"
108	$3
109	fi
110	else
111	cat conftest.out >&AC_FD_CC
112	AC_MSG_RESULT(no)
113	$3
114	CFLAGS="$save_CFLAGS"
115	fi
116	else
117	AC_MSG_RESULT(no)
118	$3
119	if test -s conftest.out ; then cat conftest.out >&AC_FD_CC ; fi
120	CFLAGS="$save_CFLAGS"
121	fi
122	else
123	# Could not compile without the option!
124	AC_MSG_RESULT(no)
125	fi
126	# This is needed for Mac OSX 10.5
127	rm -rf conftest.dSYM
128	rm -f conftest*
129	])
130	dnl
131	dnl/D*
132	dnl PAC_C_OPTIMIZATION - Determine C options for producing optimized code
133	dnl
134	dnl Synopsis
135	dnl PAC_C_OPTIMIZATION([action if found])
136	dnl
137	dnl Output Effect:
138	dnl Adds options to 'COPTIONS' if no other action is specified
139	dnl
140	dnl Notes:
141	dnl This is a temporary standin for compiler optimization.
142	dnl It should try to match known systems to known compilers (checking, of
143	dnl course), and then falling back to some common defaults.
144	dnl Note that many compilers will complain about -g and aggressive
145	dnl optimization.
146	dnl D/*
147	AC_DEFUN([PAC_C_OPTIMIZATION],[
148	for copt in "-O4 -Ofast" "-Ofast" "-fast" "-O3" "-xO3" "-O" ; do
149	PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
150	if test "$found_opt" = "yes" ; then
151	ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
152	break
153	fi
154	done
155	if test "$ac_cv_prog_gcc" = "yes" ; then
156	for copt in "-fomit-frame-pointer" "-finline-functions" \
157	"-funroll-loops" ; do
158	PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
159	if test $found_opt = "yes" ; then
160	ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
161	# no break because we're trying to add them all
162	fi
163	done
164	# We could also look for architecture-specific gcc options
165	fi
166
167	])
168	dnl
169	dnl/D*
170	dnl PAC_C_DEPENDS - Determine how to use the C compiler to generate
171	dnl dependency information
172	dnl
173	dnl Synopsis:
174	dnl PAC_C_DEPENDS
175	dnl
176	dnl Output Effects:
177	dnl Sets the following shell variables and call AC_SUBST for them:
178	dnl+ C_DEPEND_OPT - Compiler options needed to create dependencies
179	dnl. C_DEPEND_OUT - Shell redirection for dependency file (may be empty)
180	dnl. C_DEPEND_PREFIX - Empty (null) or true; this is used to handle
181	dnl systems that do not provide dependency information
182	dnl- C_DEPEND_MV - Command to move created dependency file
183	dnl Also creates a Depends file in the top directory (!).
184	dnl
185	dnl In addition, the variable 'C_DEPEND_DIR' must be set to indicate the
186	dnl directory in which the dependency files should live.
187	dnl
188	dnl Notes:
189	dnl A typical Make rule that exploits this macro is
190	dnl.vb
191	dnl #
192	dnl # Dependency processing
193	dnl .SUFFIXES: .dep
194	dnl DEP_SOURCES = ${SOURCES:%.c=.dep/%.dep}
195	dnl C_DEPEND_DIR = .dep
196	dnl Depends: ${DEP_SOURCES}
197	dnl @-rm -f Depends
198	dnl cat .dep/.dep >Depends*
199	dnl .dep/%.dep:%.c
200	dnl @if [ ! -d .dep ] ; then mkdir .dep ; fi
201	dnl @@C_DEPEND_PREFIX@ ${C_COMPILE} @C_DEPEND_OPT@ $< @C_DEPEND_OUT@
202	dnl @@C_DEPEND_MV@
203	dnl
204	dnl depends-clean:
205	dnl @-rm -f .dep ${srcdir}/.dep Depends ${srcdir}/Depends
206	dnl @-touch Depends
207	dnl.ve
208	dnl
209	dnl For each file 'foo.c', this creates a file 'foo.dep' and creates a file
210	dnl 'Depends' that contains all of the '.dep' files.*
211	dnl
212	dnl For your convenience, the autoconf variable 'C_DO_DEPENDS' names a file
213	dnl that may contain this code (you must have `dependsrule` or
214	dnl `dependsrule.in` in the same directory as the other auxillery configure
215	dnl scripts (set with dnl 'AC_CONFIG_AUX_DIR'). If you use `dependsrule.in`,
216	dnl you must have `dependsrule` in 'AC_OUTPUT' before this `Makefile`.
217	dnl
218	dnl D/*
219	dnl
220	dnl Eventually, we can add an option to the C_DEPEND_MV to strip system
221	dnl includes, such as /usr/xxxx and /opt/xxxx
222	dnl
223	AC_DEFUN([PAC_C_DEPENDS],[
224	AC_SUBST(C_DEPEND_OPT)AM_IGNORE(C_DEPEND_OPT)
225	AC_SUBST(C_DEPEND_OUT)AM_IGNORE(C_DEPEND_OUT)
226	AC_SUBST(C_DEPEND_MV)AM_IGNORE(C_DEPEND_MV)
227	AC_SUBST(C_DEPEND_PREFIX)AM_IGNORE(C_DEPEND_PREFIX)
228	AC_SUBST_FILE(C_DO_DEPENDS)
229	dnl set the value of the variable to a
230	dnl file that contains the dependency code, such as
231	dnl ${top_srcdir}/maint/dependrule
232	if test -n "$ac_cv_c_depend_opt" ; then
233	AC_MSG_RESULT([Option $ac_cv_c_depend_opt creates dependencies (cached)])
234	C_DEPEND_OUT="$ac_cv_c_depend_out"
235	C_DEPEND_MV="$ac_cv_c_depend_mv"
236	C_DEPEND_OPT="$ac_cv_c_depend_opt"
237	C_DEPEND_PREFIX="$ac_cv_c_depend_prefix"
238	C_DO_DEPENDS="$ac_cv_c_do_depends"
239	else
240	# Determine the values
241	# This is needed for Mac OSX 10.5
242	rm -rf conftest.dSYM
243	rm -f conftest*
244	dnl
245	dnl Some systems (/usr/ucb/cc on Solaris) do not generate a dependency for
246	dnl an include that doesn't begin in column 1
247	dnl
248	cat >conftest.c <<EOF
249	#include "confdefs.h"
250	int f(void) { return 0; }
251	EOF
252	dnl -xM1 is Solaris C compiler (no /usr/include files)
253	dnl -MM is gcc (no /usr/include files)
254	dnl -MMD is gcc to .d
255	dnl .u is xlC (AIX) output
256	for copt in "-xM1" "-c -xM1" "-xM" "-c -xM" "-MM" "-M" "-c -M"; do
257	AC_MSG_CHECKING([whether $copt option generates dependencies])
258	rm -f conftest.o conftest.u conftest.d conftest.err conftest.out
259	dnl also need to check that error output is empty
260	if $CC $CFLAGS $copt conftest.c >conftest.out 2>conftest.err && \
261	test ! -s conftest.err ; then
262	dnl Check for dependency info in conftest.out
263	if test -s conftest.u ; then
264	C_DEPEND_OUT=""
265	C_DEPEND_MV='mv $[].u ${C_DEPEND_DIR}/$[].dep'
266	pac_dep_file=conftest.u
267	elif test -s conftest.d ; then
268	C_DEPEND_OUT=""
269	C_DEPEND_MV='mv $[].d ${C_DEPEND_DIR}/$[].dep'
270	pac_dep_file=conftest.d
271	else
272	dnl C_DEPEND_OUT='>${C_DEPEND_DIR}/$[].dep'*
273	dnl This for is needed for VPATH. Perhaps the others should match.
274	C_DEPEND_OUT='>$@'
275	C_DEPEND_MV=:
276	pac_dep_file=conftest.out
277	fi
278	if grep 'confdefs.h' $pac_dep_file >/dev/null 2>&1 ; then
279	AC_MSG_RESULT(yes)
280	C_DEPEND_OPT="$copt"
281	AC_MSG_CHECKING([whether .o file created with dependency file])
282	if test -s conftest.o ; then
283	AC_MSG_RESULT(yes)
284	else
285	AC_MSG_RESULT(no)
286	echo "Output of $copt option was" >&AC_FD_CC
287	cat $pac_dep_file >&AC_FD_CC
288	fi
289	break
290	else
291	AC_MSG_RESULT(no)
292	fi
293	else
294	echo "Error in compiling program with flags $copt" >&AC_FD_CC
295	cat conftest.out >&AC_FD_CC
296	if test -s conftest.err ; then cat conftest.err >&AC_FD_CC ; fi
297	AC_MSG_RESULT(no)
298	fi
299	copt=""
300	done
301	if test -f $CONFIG_AUX_DIR/dependsrule -o \
302	-f $CONFIG_AUX_DIR/dependsrule.in; then
303	C_DO_DEPENDS="$CONFIG_AUX_DIR/dependsrule"
304	else
305	C_DO_DEPENDS="/dev/null"
306	fi
307	if test "X$copt" = "X" ; then
308	C_DEPEND_PREFIX="true"
309	else
310	C_DEPEND_PREFIX=""
311	fi
312	ac_cv_c_depend_out="$C_DEPEND_OUT"
313	ac_cv_c_depend_mv="$C_DEPEND_MV"
314	ac_cv_c_depend_opt="$C_DEPEND_OPT"
315	ac_cv_c_depend_prefix="$C_DEPEND_PREFIX"
316	ac_cv_c_do_depends="$C_DO_DEPENDS"
317	fi
318	])
319	dnl
320	dnl/D*
321	dnl PAC_C_PROTOTYPES - Check that the compiler accepts ANSI prototypes.
322	dnl
323	dnl Synopsis:
324	dnl PAC_C_PROTOTYPES([action if true],[action if false])
325	dnl
326	dnl D/*
327	AC_DEFUN([PAC_C_PROTOTYPES],[
328	AC_CACHE_CHECK([whether $CC supports function prototypes],
329	pac_cv_c_prototypes,[
330	AC_TRY_COMPILE([int f(double a){return 0;}],[return 0];,
331	pac_cv_c_prototypes="yes",pac_cv_c_prototypes="no")])
332	if test "$pac_cv_c_prototypes" = "yes" ; then
333	ifelse([$1],,:,[$1])
334	else
335	ifelse([$2],,:,[$2])
336	fi
337	])dnl
338	dnl
339	dnl/D*
340	dnl PAC_FUNC_SEMCTL - Check for semctl and its argument types
341	dnl
342	dnl Synopsis:
343	dnl PAC_FUNC_SEMCTL
344	dnl
345	dnl Output Effects:
346	dnl Sets 'HAVE_SEMCTL' if semctl is available.
347	dnl Sets 'HAVE_UNION_SEMUN' if 'union semun' is available.
348	dnl Sets 'SEMCTL_NEEDS_SEMUN' if a 'union semun' type must be passed as the
349	dnl fourth argument to 'semctl'.
350	dnl D/*
351	dnl Check for semctl and arguments
352	AC_DEFUN([PAC_FUNC_SEMCTL],[
353	AC_CHECK_FUNC(semctl)
354	if test "$ac_cv_func_semctl" = "yes" ; then
355	AC_CACHE_CHECK([for union semun],
356	pac_cv_type_union_semun,[
357	AC_TRY_COMPILE([#include <sys/types.h>
358	#include <sys/ipc.h>
359	#include <sys/sem.h>],[union semun arg;arg.val=0;],
360	pac_cv_type_union_semun="yes",pac_cv_type_union_semun="no")])
361	if test "$pac_cv_type_union_semun" = "yes" ; then
362	AC_DEFINE(HAVE_UNION_SEMUN,1,[Has union semun])
363	#
364	# See if we can use an int in semctl or if we need the union
365	AC_CACHE_CHECK([whether semctl needs union semun],
366	pac_cv_func_semctl_needs_semun,[
367	AC_TRY_COMPILE([#include <sys/types.h>
368	#include <sys/ipc.h>
369	#include <sys/sem.h>],[
370	int arg = 0; semctl( 1, 1, SETVAL, arg );],
371	pac_cv_func_semctl_needs_semun="yes",
372	pac_cv_func_semctl_needs_semun="no")
373	])
374	if test "$pac_cv_func_semctl_needs_semun" = "yes" ; then
375	AC_DEFINE(SEMCTL_NEEDS_SEMUN,1,[Needs an explicit definition of semun])
376	fi
377	fi
378	fi
379	])
380	dnl
381	dnl/D*
382	dnl PAC_C_VOLATILE - Check if C supports volatile
383	dnl
384	dnl Synopsis:
385	dnl PAC_C_VOLATILE
386	dnl
387	dnl Output Effect:
388	dnl Defines 'volatile' as empty if volatile is not available.
389	dnl
390	dnl D/*
391	AC_DEFUN([PAC_C_VOLATILE],[
392	AC_CACHE_CHECK([for volatile],
393	pac_cv_c_volatile,[
394	AC_TRY_COMPILE(,[volatile int a;],pac_cv_c_volatile="yes",
395	pac_cv_c_volatile="no")])
396	if test "$pac_cv_c_volatile" = "no" ; then
397	AC_DEFINE(volatile,,[if C does not support volatile])
398	fi
399	])dnl
400	dnl
401	dnl/D*
402	dnl PAC_C_INLINE - Check if C supports inline
403	dnl
404	dnl Synopsis:
405	dnl PAC_C_INLINE
406	dnl
407	dnl Output Effect:
408	dnl Defines 'inline' as empty if inline is not available.
409	dnl
410	dnl D/*
411	AC_DEFUN([PAC_C_INLINE],[
412	AC_CACHE_CHECK([for inline],
413	pac_cv_c_inline,[
414	AC_TRY_COMPILE([inline int a( int b ){return b+1;}],[int a;],
415	pac_cv_c_inline="yes",pac_cv_c_inline="no")])
416	if test "$pac_cv_c_inline" = "no" ; then
417	AC_DEFINE(inline,,[if C does not support inline])
418	fi
419	])dnl
420	dnl
421	dnl/D*
422	dnl PAC_C_CONST - Check if C supports const
423	dnl
424	dnl Synopsis:
425	dnl PAC_C_CONST
426	dnl
427	dnl Output Effect:
428	dnl AC_MSG_ERROR if const is not supported.
429	dnl
430	dnl D/*
431	dnl AC_DEFUN(PAC_C_CONST,[
432	dnl AC_CACHE_CHECK([for support of const in C],
433	dnl pac_cv_c_const,[
434	dnl AC_LANG_PUSH(C)
435	dnl AC_TRY_COMPILE(,[const int a = 1; int b; b = a;],
436	dnl pac_cv_c_const="yes", pac_cv_c_const="no")])
437	dnl if test "$pac_cv_c_const" = "no" ; then
438	dnl AC_MSG_ERROR([C does not support const! Abort...])
439	dnl fi
440	dnl AC_LANG_POP(C)
441	dnl ])dnl
442	AC_DEFUN([PAC_C_CONST],
443	[AC_CACHE_CHECK([for an ANSI C-conforming const], pac_cv_c_const,
444	[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
445	[[/* FIXME: Include the comments suggested by Paul. */
446	#ifndef __cplusplus
447	/* Ultrix mips cc rejects this. */
448	typedef int charset[2];
449	const charset cs = {0,0};
450	/* SunOS 4.1.1 cc rejects this. */
451	char const const pcpcc;
452	char **ppc;
453	/* NEC SVR4.0.2 mips cc rejects this. */
454	struct point {int x, y;};
455	static struct point const zero = {0,0};
456	/* AIX XL C 1.02.0.0 rejects this.
457	It does not let you subtract one const X* pointer from another in
458	an arm of an if-expression whose if-part is not a constant
459	expression */
460	const char *g = "string";
461	pcpcc = &g + (g ? g-g : 0);
462	/* HPUX 7.0 cc rejects these. */
463	++pcpcc;
464	ppc = (char**) pcpcc;
465	pcpcc = (char const const ) ppc;
466	{ /* SCO 3.2v4 cc rejects this. */
467	char const s = 0 ? (char ) 0 : (char const *) 0;
468	if (s) return 0;
469	}
470	{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
471	int x[] = {25, 17};
472	const int *foo = &x[0];
473	++foo;
474	}
475	{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
476	typedef const int *iptr;
477	iptr p = 0;
478	++p;
479	}
480	{ /* AIX XL C 1.02.0.0 rejects this saying
481	"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
482	struct s { int j; const int *ap[3]; };
483	struct s a;
484	struct s *b = &a;
485	b->j = 5;
486	}
487	{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
488	const int foo = 10;
489	if (!foo) return 0;
490	}
491	return !cs[0] && !zero.x;
492	#endif
493	]])],
494	[pac_cv_c_const=yes],
495	[pac_cv_c_const=no])])
496	if test $pac_cv_c_const = no; then
497	AC_DEFINE(const,,
498	[Define to empty if `const' does not conform to ANSI C.])
499	fi
500	])dnl
501	dnl
502	dnl/D*
503	dnl PAC_C_CPP_CONCAT - Check whether the C compiler accepts ISO CPP string
504	dnl concatenation
505	dnl
506	dnl Synopsis:
507	dnl PAC_C_CPP_CONCAT([true-action],[false-action])
508	dnl
509	dnl Output Effects:
510	dnl Invokes the true or false action
511	dnl
512	dnl D/*
513	AC_DEFUN([PAC_C_CPP_CONCAT],[
514	pac_pound="#"
515	AC_CACHE_CHECK([whether the compiler $CC accepts $ac_pound$ac_pound for concatenation in cpp],
516	pac_cv_c_cpp_concat,[
517	AC_TRY_COMPILE([
518	#define concat(a,b) a##b],[int concat(a,b);return ab;],
519	pac_cv_cpp_concat="yes",pac_cv_cpp_concat="no")])
520	if test $pac_cv_c_cpp_concat = "yes" ; then
521	ifelse([$1],,:,[$1])
522	else
523	ifelse([$2],,:,[$2])
524	fi
525	])dnl
526	dnl
527	dnl/D*
528	dnl PAC_FUNC_GETTIMEOFDAY - Check whether gettimeofday takes 1 or 2 arguments
529	dnl
530	dnl Synopsis
531	dnl PAC_IS_GETTIMEOFDAY_OK(ok_action,failure_action)
532	dnl
533	dnl Notes:
534	dnl One version of Solaris accepted only one argument.
535	dnl
536	dnl D/*
537	AC_DEFUN([PAC_FUNC_GETTIMEOFDAY],[
538	AC_CACHE_CHECK([whether gettimeofday takes 2 arguments],
539	pac_cv_func_gettimeofday,[
540	AC_TRY_COMPILE([#include <sys/time.h>],[struct timeval tp;
541	gettimeofday(&tp,(void*)0);return 0;],pac_cv_func_gettimeofday="yes",
542	pac_cv_func_gettimeofday="no")
543	])
544	if test "$pac_cv_func_gettimeofday" = "yes" ; then
545	ifelse($1,,:,$1)
546	else
547	ifelse($2,,:,$2)
548	fi
549	])
550	dnl
551	dnl/D*
552	dnl PAC_C_RESTRICT - Check if C supports restrict
553	dnl
554	dnl Synopsis:
555	dnl PAC_C_RESTRICT
556	dnl
557	dnl Output Effect:
558	dnl Defines 'restrict' if some version of restrict is supported; otherwise
559	dnl defines 'restrict' as empty. This allows you to include 'restrict' in
560	dnl declarations in the same way that 'AC_C_CONST' allows you to use 'const'
561	dnl in declarations even when the C compiler does not support 'const'
562	dnl
563	dnl Note that some compilers accept restrict only with additional options.
564	dnl DEC/Compaq/HP Alpha Unix (Tru64 etc.) -accept restrict_keyword
565	dnl
566	dnl D/*
567	AC_DEFUN([PAC_C_RESTRICT],[
568	AC_CACHE_CHECK([for restrict],
569	pac_cv_c_restrict,[
570	AC_TRY_COMPILE(,[int * restrict a;],pac_cv_c_restrict="restrict",
571	pac_cv_c_restrict="no")
572	if test "$pac_cv_c_restrict" = "no" ; then
573	AC_TRY_COMPILE(,[int * _Restrict a;],pac_cv_c_restrict="_Restrict",
574	pac_cv_c_restrict="no")
575	fi
576	if test "$pac_cv_c_restrict" = "no" ; then
577	AC_TRY_COMPILE(,[int * __restrict a;],pac_cv_c_restrict="__restrict",
578	pac_cv_c_restrict="no")
579	fi
580	])
581	if test "$pac_cv_c_restrict" = "no" ; then
582	restrict_val=""
583	elif test "$pac_cv_c_restrict" != "restrict" ; then
584	restrict_val=$pac_cv_c_restrict
585	fi
586	if test "$restrict_val" != "restrict" ; then
587	AC_DEFINE_UNQUOTED(restrict,$restrict_val,[if C does not support restrict])
588	fi
589	])dnl
590	dnl
591	dnl/D*
592	dnl PAC_HEADER_STDARG - Check whether standard args are defined and whether
593	dnl they are old style or new style
594	dnl
595	dnl Synopsis:
596	dnl PAC_HEADER_STDARG(action if works, action if oldstyle, action if fails)
597	dnl
598	dnl Output Effects:
599	dnl Defines HAVE_STDARG_H if the header exists.
600	dnl defines
601	dnl
602	dnl Notes:
603	dnl It isn't enough to check for stdarg. Even gcc doesn't get it right;
604	dnl on some systems, the gcc version of stdio.h loads stdarg.h `with the wrong
605	dnl options` (causing it to choose the `old style` 'va_start' etc).
606	dnl
607	dnl The original test tried the two-arg version first; the old-style
608	dnl va_start took only a single arg.
609	dnl This turns out to be VERY tricky, because some compilers (e.g., Solaris)
610	dnl are quite happy to accept the wrong* number of arguments to a macro!*
611	dnl Instead, we try to find a clean compile version, using our special
612	dnl PAC_C_TRY_COMPILE_CLEAN command.
613	dnl
614	dnl D/*
615	AC_DEFUN([PAC_HEADER_STDARG],[
616	AC_CHECK_HEADER(stdarg.h)
617	dnl Sets ac_cv_header_stdarg_h
618	if test "$ac_cv_header_stdarg_h" = "yes" ; then
619	dnl results are yes,oldstyle,no.
620	AC_CACHE_CHECK([whether stdarg is oldstyle],
621	pac_cv_header_stdarg_oldstyle,[
622	PAC_C_TRY_COMPILE_CLEAN([#include <stdio.h>
623	#include <stdarg.h>],
624	[int func( int a, ... ){
625	int b;
626	va_list ap;
627	va_start( ap );
628	b = va_arg(ap, int);
629	printf( "%d-%d\n", a, b );
630	va_end(ap);
631	fflush(stdout);
632	return 0;
633	}
634	int main() { func( 1, 2 ); return 0;}],pac_check_compile)
635	case "$pac_check_compile" in
636	0) pac_cv_header_stdarg_oldstyle="yes"
637	;;
638	1) pac_cv_header_stdarg_oldstyle="may be newstyle"
639	;;
640	2) pac_cv_header_stdarg_oldstyle="no" # compile failed
641	;;
642	esac
643	])
644	if test "$pac_cv_header_stdarg_oldstyle" = "yes" ; then
645	ifelse($2,,:,[$2])
646	else
647	AC_CACHE_CHECK([whether stdarg works],
648	pac_cv_header_stdarg_works,[
649	PAC_C_TRY_COMPILE_CLEAN([
650	#include <stdio.h>
651	#include <stdarg.h>],[
652	int func( int a, ... ){
653	int b;
654	va_list ap;
655	va_start( ap, a );
656	b = va_arg(ap, int);
657	printf( "%d-%d\n", a, b );
658	va_end(ap);
659	fflush(stdout);
660	return 0;
661	}
662	int main() { func( 1, 2 ); return 0;}],pac_check_compile)
663	case "$pac_check_compile" in
664	0) pac_cv_header_stdarg_works="yes"
665	;;
666	1) pac_cv_header_stdarg_works="yes with warnings"
667	;;
668	2) pac_cv_header_stdarg_works="no"
669	;;
670	esac
671	])
672	fi # test on oldstyle
673	if test "$pac_cv_header_stdarg_works" = "no" ; then
674	ifelse($3,,:,[$3])
675	else
676	ifelse($1,,:,[$1])
677	fi
678	else
679	ifelse($3,,:,[$3])
680	fi # test on header
681	])
682	*dnl/D**
683	dnl PAC_C_TRY_COMPILE_CLEAN - Try to compile a program, separating success
684	dnl with no warnings from success with warnings.
685	dnl
686	dnl Synopsis:
687	dnl PAC_C_TRY_COMPILE_CLEAN(header,program,flagvar)
688	dnl
689	dnl Output Effect:
690	dnl The 'flagvar' is set to 0 (clean), 1 (dirty but success ok), or 2
691	dnl (failed).
692	dnl
693	dnl D/*
694	AC_DEFUN([PAC_C_TRY_COMPILE_CLEAN],[
695	$3=2
696	dnl Get the compiler output to test against
697	if test -z "$pac_TRY_COMPLILE_CLEAN" ; then
698	# This is needed for Mac OSX 10.5
699	rm -rf conftest.dSYM
700	rm -f conftest*
701	echo 'int try(void);int try(void){return 0;}' > conftest.c
702	if ${CC-cc} $CFLAGS -c conftest.c >conftest.bas 2>&1 ; then
703	if test -s conftest.bas ; then
704	pac_TRY_COMPILE_CLEAN_OUT=`cat conftest.bas`
705	fi
706	pac_TRY_COMPILE_CLEAN=1
707	else
708	AC_MSG_WARN([Could not compile simple test program!])
709	if test -s conftest.bas ; then cat conftest.bas >> config.log ; fi
710	fi
711	fi
712	dnl
713	dnl Create the program that we need to test with
714	# This is needed for Mac OSX 10.5
715	rm -rf conftest.dSYM
716	rm -f conftest*
717	cat >conftest.c <<EOF
718	#include "confdefs.h"
719	[$1]
720	[$2]
721	EOF
722	dnl
723	dnl Compile it and test
724	if ${CC-cc} $CFLAGS -c conftest.c >conftest.bas 2>&1 ; then
725	dnl Success. Is the output the same?
726	if test "$pac_TRY_COMPILE_CLEAN_OUT" = "`cat conftest.bas`" ; then
727	$3=0
728	else
729	cat conftest.c >>config.log
730	if test -s conftest.bas ; then cat conftest.bas >> config.log ; fi
731	$3=1
732	fi
733	else
734	dnl Failure. Set flag to 2
735	cat conftest.c >>config.log
736	if test -s conftest.bas ; then cat conftest.bas >> config.log ; fi
737	$3=2
738	fi
739	# This is needed for Mac OSX 10.5
740	rm -rf conftest.dSYM
741	rm -f conftest*
742	])
743	dnl
744	dnl/D*
745	dnl PAC_PROG_C_UNALIGNED_DOUBLES - Check that the C compiler allows unaligned
746	dnl doubles
747	dnl
748	dnl Synopsis:
749	dnl PAC_PROG_C_UNALIGNED_DOUBLES(action-if-true,action-if-false,
750	dnl action-if-unknown)
751	dnl
752	dnl Notes:
753	dnl 'action-if-unknown' is used in the case of cross-compilation.
754	dnl D/*
755	AC_DEFUN([PAC_PROG_C_UNALIGNED_DOUBLES],[
756	AC_CACHE_CHECK([whether C compiler allows unaligned doubles],
757	pac_cv_prog_c_unaligned_doubles,[
758	AC_TRY_RUN([
759	void fetch_double( v )
760	double *v;
761	{
762	*v = 1.0;
763	}
764	int main( argc, argv )
765	int argc;
766	char **argv;
767	{
768	int p[4];
769	double *p_val;
770	fetch_double( (double *)&(p[0]) );
771	p_val = (double *)&(p[0]);
772	if (*p_val != 1.0) return 1;
773	fetch_double( (double *)&(p[1]) );
774	p_val = (double *)&(p[1]);
775	if (*p_val != 1.0) return 1;
776	return 0;
777	}
778	],pac_cv_prog_c_unaligned_doubles="yes",pac_cv_prog_c_unaligned_doubles="no",
779	pac_cv_prog_c_unaligned_doubles="unknown")])
780	ifelse($1,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "yes" ; then
781	$1
782	fi)
783	ifelse($2,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "no" ; then
784	$2
785	fi)
786	ifelse($3,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "unknown" ; then
787	$3
788	fi)
789	])
790	dnl
791	dnl/D*
792	dnl PAC_PROG_C_WEAK_SYMBOLS - Test whether C supports weak alias symbols.
793	dnl
794	dnl Synopsis
795	dnl PAC_PROG_C_WEAK_SYMBOLS(action-if-true,action-if-false)
796	dnl
797	dnl Output Effect:
798	dnl Defines one of the following if a weak symbol pragma is found:
799	dnl.vb
800	dnl HAVE_PRAGMA_WEAK - #pragma weak
801	dnl HAVE_PRAGMA_HP_SEC_DEF - #pragma _HP_SECONDARY_DEF
802	dnl HAVE_PRAGMA_CRI_DUP - #pragma _CRI duplicate x as y
803	dnl.ve
804	dnl May also define
805	dnl.vb
806	dnl HAVE_WEAK_ATTRIBUTE
807	dnl.ve
808	dnl if functions can be declared as 'int foo(...) __attribute__ ((weak));'
809	dnl sets the shell variable pac_cv_attr_weak to yes.
810	dnl Also checks for __attribute__((weak_import)) which is supported by
811	dnl Apple in Mac OSX (at least in Darwin). Note that this provides only
812	dnl weak symbols, not weak aliases
813	dnl
814	dnl D/*
815	AC_DEFUN([PAC_PROG_C_WEAK_SYMBOLS],[
816	pragma_extra_message=""
817	AC_CACHE_CHECK([for type of weak symbol alias support],
818	pac_cv_prog_c_weak_symbols,[
819	# Test for weak symbol support...
820	# We can't put # in the message because it causes autoconf to generate
821	# incorrect code
822	AC_TRY_LINK([
823	extern int PFoo(int);
824	#pragma weak PFoo = Foo
825	int Foo(int a) { return a; }
826	],[return PFoo(1);],has_pragma_weak=yes)
827	#
828	# Some systems (Linux ia64 and ecc, for example), support weak symbols
829	# only within a single object file! This tests that case.
830	# Note that there is an extern int PFoo declaration before the
831	# pragma. Some compilers require this in order to make the weak symbol
832	# extenally visible.
833	if test "$has_pragma_weak" = yes ; then
834	# This is needed for Mac OSX 10.5
835	rm -rf conftest.dSYM
836	rm -f conftest*
837	cat >>conftest1.c <<EOF
838	extern int PFoo(int);
839	#pragma weak PFoo = Foo
840	int Foo(int);
841	int Foo(int a) { return a; }
842	EOF
843	cat >>conftest2.c <<EOF
844	extern int PFoo(int);
845	int main(int argc, char **argv) {
846	return PFoo(0);}
847	EOF
848	ac_link2='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest1.c conftest2.c $LIBS >conftest.out 2>&1'
849	if eval $ac_link2 ; then
850	# The gcc 3.4.x compiler accepts the pragma weak, but does not
851	# correctly implement it on systems where the loader doesn't
852	# support weak symbols (e.g., cygwin). This is a bug in gcc, but it
853	# it is one that we* have to detect.*
854	# This is needed for Mac OSX 10.5
855	rm -rf conftest.dSYM
856	rm -f conftest*
857	cat >>conftest1.c <<EOF
858	extern int PFoo(int);
859	#pragma weak PFoo = Foo
860	int Foo(int);
861	int Foo(int a) { return a; }
862	EOF
863	cat >>conftest2.c <<EOF
864	extern int Foo(int);
865	int PFoo(int a) { return a+1;}
866	int main(int argc, char **argv) {
867	return Foo(0);}
868	EOF
869	if eval $ac_link2 ; then
870	pac_cv_prog_c_weak_symbols="pragma weak"
871	else
872	echo "$ac_link2" >> config.log
873	echo "Failed program was" >> config.log
874	cat conftest1.c >>config.log
875	cat conftest2.c >>config.log
876	if test -s conftest.out ; then cat conftest.out >> config.log ; fi
877	has_pragma_weak=0
878	pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
879	fi
880	else
881	echo "$ac_link2" >>config.log
882	echo "Failed program was" >>config.log
883	cat conftest1.c >>config.log
884	cat conftest2.c >>config.log
885	if test -s conftest.out ; then cat conftest.out >> config.log ; fi
886	has_pragma_weak=0
887	pragma_extra_message="pragma weak does not work outside of a file"
888	fi
889	# This is needed for Mac OSX 10.5
890	rm -rf conftest.dSYM
891	rm -f conftest*
892	fi
893	dnl
894	if test -z "$pac_cv_prog_c_weak_symbols" ; then
895	AC_TRY_LINK([
896	extern int PFoo(int);
897	#pragma _HP_SECONDARY_DEF Foo PFoo
898	int Foo(int a) { return a; }
899	],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _HP_SECONDARY_DEF")
900	fi
901	dnl
902	if test -z "$pac_cv_prog_c_weak_symbols" ; then
903	AC_TRY_LINK([
904	extern int PFoo(int);
905	#pragma _CRI duplicate PFoo as Foo
906	int Foo(int a) { return a; }
907	],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _CRI duplicate x as y")
908	fi
909	dnl
910	if test -z "$pac_cv_prog_c_weak_symbols" ; then
911	pac_cv_prog_c_weak_symbols="no"
912	fi
913	dnl
914	dnl If there is an extra explanatory message, echo it now so that it
915	dnl doesn't interfere with the cache result value
916	if test -n "$pragma_extra_message" ; then
917	echo $pragma_extra_message
918	fi
919	dnl
920	])
921	if test "$pac_cv_prog_c_weak_symbols" = "no" ; then
922	ifelse([$2],,:,[$2])
923	else
924	case "$pac_cv_prog_c_weak_symbols" in
925	"pragma weak") AC_DEFINE(HAVE_PRAGMA_WEAK,1,[Supports weak pragma])
926	;;
927	"pragma _HP") AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,1,[HP style weak pragma])
928	;;
929	"pragma _CRI") AC_DEFINE(HAVE_PRAGMA_CRI_DUP,1,[Cray style weak pragma])
930	;;
931	esac
932	ifelse([$1],,:,[$1])
933	fi
934	AC_CACHE_CHECK([whether __attribute__ ((weak)) allowed],
935	pac_cv_attr_weak,[
936	AC_TRY_COMPILE([int foo(int) __attribute__ ((weak));],[int a;],
937	pac_cv_attr_weak=yes,pac_cv_attr_weak=no)])
938	# Note that being able to compile with weak_import doesn't mean that
939	# it works.
940	AC_CACHE_CHECK([whether __attribute ((weak_import)) allowed],
941	pac_cv_attr_weak_import,[
942	AC_TRY_COMPILE([int foo(int) __attribute__ ((weak_import));],[int a;],
943	pac_cv_attr_weak_import=yes,pac_cv_attr_weak_import=no)])
944	])
945
946	#
947	# This is a replacement that checks that FAILURES are signaled as well
948	# (later configure macros look for the .o file, not just success from the
949	# compiler, but they should not HAVE to
950	#
951	dnl --- insert 2.52 compatibility here ---
952	dnl 2.52 does not have AC_PROG_CC_WORKS
953	ifdef([AC_PROG_CC_WORKS],,[AC_DEFUN([AC_PROG_CC_WORKS],)])
954	dnl
955	AC_DEFUN([PAC_PROG_CC_WORKS],
956	[AC_PROG_CC_WORKS
957	AC_MSG_CHECKING([whether the C compiler sets its return status correctly])
958	AC_LANG_SAVE
959	AC_LANG_C
960	AC_TRY_COMPILE(,[int a = bzzzt;],notbroken=no,notbroken=yes)
961	AC_MSG_RESULT($notbroken)
962	if test "$notbroken" = "no" ; then
963	AC_MSG_ERROR([installation or configuration problem: C compiler does not
964	correctly set error code when a fatal error occurs])
965	fi
966	])
967	dnl
968	dnl/D*
969	dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS - Test whether C and the
970	dnl linker allow multiple weak symbols.
971	dnl
972	dnl Synopsis
973	dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(action-if-true,action-if-false)
974	dnl
975	dnl
976	dnl D/*
977	AC_DEFUN([PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS],[
978	AC_CACHE_CHECK([for multiple weak symbol support],
979	pac_cv_prog_c_multiple_weak_symbols,[
980	# Test for multiple weak symbol support...
981	#
982	# This is needed for Mac OSX 10.5
983	rm -rf conftest.dSYM
984	rm -f conftest*
985	cat >>conftest1.c <<EOF
986	extern int PFoo(int);
987	extern int PFoo_(int);
988	extern int pfoo_(int);
989	#pragma weak PFoo = Foo
990	#pragma weak PFoo_ = Foo
991	#pragma weak pfoo_ = Foo
992	int Foo(int);
993	int Foo(a) { return a; }
994	EOF
995	cat >>conftest2.c <<EOF
996	extern int PFoo(int), PFoo_(int), pfoo_(int);
997	int main() {
998	return PFoo(0) + PFoo_(1) + pfoo_(2);}
999	EOF
1000	ac_link2='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest1.c conftest2.c $LIBS >conftest.out 2>&1'
1001	if eval $ac_link2 ; then
1002	pac_cv_prog_c_multiple_weak_symbols="yes"
1003	else
1004	echo "$ac_link2" >>config.log
1005	echo "Failed program was" >>config.log
1006	cat conftest1.c >>config.log
1007	cat conftest2.c >>config.log
1008	if test -s conftest.out ; then cat conftest.out >> config.log ; fi
1009	fi
1010	# This is needed for Mac OSX 10.5
1011	rm -rf conftest.dSYM
1012	rm -f conftest*
1013	dnl
1014	])
1015	if test "$pac_cv_prog_c_multiple_weak_symbols" = "yes" ; then
1016	ifelse([$1],,:,[$1])
1017	else
1018	ifelse([$2],,:,[$2])
1019	fi
1020	])
1021	dnl
1022	dnl/D*
1023	dnl PAC_FUNC_CRYPT - Check that the function crypt is defined
1024	dnl
1025	dnl Synopsis:
1026	dnl PAC_FUNC_CRYPT
1027	dnl
1028	dnl Output Effects:
1029	dnl
1030	dnl In Solaris, the crypt function is not defined in unistd unless
1031	dnl _XOPEN_SOURCE is defines and _XOPEN_VERSION is 4 or greater.
1032	dnl We test by looking for a missing crypt by defining our own
1033	dnl incompatible one and trying to compile it.
1034	dnl Defines NEED_CRYPT_PROTOTYPE if no prototype is found.
1035	dnl D/*
1036	AC_DEFUN([PAC_FUNC_CRYPT],[
1037	AC_CACHE_CHECK([whether crypt defined in unistd.h],
1038	pac_cv_func_crypt_defined,[
1039	AC_TRY_COMPILE([
1040	#include <unistd.h>
1041	double crypt(double a){return a;}],[return 0];,
1042	pac_cv_func_crypt_defined="no",pac_cv_func_crypt_defined="yes")])
1043	if test "$pac_cv_func_crypt_defined" = "no" ; then
1044	# check to see if defining _XOPEN_SOURCE helps
1045	AC_CACHE_CHECK([whether crypt defined in unistd with _XOPEN_SOURCE],
1046	pac_cv_func_crypt_xopen,[
1047	AC_TRY_COMPILE([
1048	#define _XOPEN_SOURCE
1049	#include <unistd.h>
1050	double crypt(double a){return a;}],[return 0];,
1051	pac_cv_func_crypt_xopen="no",pac_cv_func_crypt_xopen="yes")])
1052	fi
1053	if test "$pac_cv_func_crypt_xopen" = "yes" ; then
1054	AC_DEFINE(_XOPEN_SOURCE,1,[if xopen needed for crypt])
1055	elif test "$pac_cv_func_crypt_defined" = "no" ; then
1056	AC_DEFINE(NEED_CRYPT_PROTOTYPE,1,[if a prototype for crypt is needed])
1057	fi
1058	])dnl
1059
1060	dnl Use the value of enable-strict to update CFLAGS
1061	dnl pac_cc_strict_flags contains the strict flags.
1062	dnl
1063	dnl -std=c89 is used to select the C89 version of the ANSI/ISO C standard.
1064	dnl As of this writing, many C compilers still accepted only this version,
1065	dnl not the later C99 version. When all compilers accept C99, this
1066	dnl should be changed to the appropriate standard level. Note that we've
1067	dnl had trouble with gcc 2.95.3 accepting -std=c89 but then trying to
1068	dnl compile program with a invalid set of options
1069	dnl (-D __STRICT_ANSI__-trigraphs)
1070	AC_DEFUN([PAC_CC_STRICT],[
1071	export enable_strict_done
1072	if test "$enable_strict_done" != "yes" ; then
1073
1074	# Some comments on strict warning options.
1075	# These were added to reduce warnings:
1076	# -Wno-missing-field-initializers -- We want to allow a struct to be
1077	# initialized to zero using "struct x y = {0};" and not require
1078	# each field to be initialized individually.
1079	# -Wno-type-limits -- There are places where we compare an unsigned to
1080	# a constant that happens to be zero e.g., if x is unsigned and
1081	# MIN_VAL is zero, we'd like to do "MPIU_Assert(x >= MIN_VAL);".
1082	# Note this option is not supported by gcc 4.2.
1083	# -Wno-unused-parameter -- For portability, some parameters go unused
1084	# when we have different implementations of functions for
1085	# different platforms
1086	# -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions,
1087	# but fn_fail may not be used if the function doesn't return an
1088	# error.
1089	# -Wno-sign-compare -- read() and write() return bytes read/written
1090	# as a signed value, but we often compare this to size_t (or
1091	# msg_sz_t) variables.
1092	# These were removed to reduce warnings:
1093	# -Wcast-qual -- Sometimes we need to cast "volatile char" to*
1094	# "char", e.g., for memcpy.*
1095	# -Wpadded -- We catch struct padding with asserts when we need to
1096	# -Wredundant-decls -- Having redundant declarations is benign and the
1097	# code already has some.
1098
1099	pac_common_strict_flags="-O2 -Wall -Wextra -Wno-missing-field-initializers -Wno-type-limits -Wstrict-prototypes -Wmissing-prototypes -DGCC_WALL -Wno-unused-parameter -Wno-unused-label -Wshadow -Wmissing-declarations -Wno-long-long -Wfloat-equal -Wdeclaration-after-statement -Wundef -Wno-endif-labels -Wpointer-arith -Wbad-function-cast -Wcast-align -Wwrite-strings -Wno-sign-compare -Waggregate-return -Wold-style-definition -Wmissing-noreturn -Wno-multichar -Wno-deprecated-declarations -Wpacked -Wnested-externs -Winvalid-pch -Wno-pointer-sign -Wvariadic-macros -std=c89"
1100	pac_cc_strict_flags=""
1101	case "$1" in
1102	yes\|all\|posix)
1103	enable_strict_done="yes"
1104	pac_cc_strict_flags="$pac_common_strict_flags -D_POSIX_C_SOURCE=199506L"
1105	;;
1106
1107	noposix)
1108	enable_strict_done="yes"
1109	pac_cc_strict_flags="$pac_common_strict_flags"
1110	;;
1111
1112	no)
1113	# Accept and ignore this value
1114	:
1115	;;
1116
1117	*)
1118	if test -n "$1" ; then
1119	AC_MSG_WARN([Unrecognized value for enable-strict:$1])
1120	fi
1121	;;
1122
1123	esac
1124
1125	# See if the above options work with the compiler
1126	accepted_flags=""
1127	for flag in $pac_cc_strict_flags ; do
1128	old_CFLAGS=$CFLAGS
1129	CFLAGS="$CFLAGS $accepted_flags $flag"
1130	AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[int a;])],accepted_flags="$accepted_flags $flag",)
1131	CFLAGS="$old_CFLAGS"
1132	done
1133	pac_cc_strict_flags=$accepted_flags
1134	fi
1135	])
1136
1137	dnl/D*
1138	dnl PAC_ARG_STRICT - Add --enable-strict to configure.
1139	dnl
1140	dnl Synopsis:
1141	dnl PAC_ARG_STRICT
1142	dnl
1143	dnl Output effects:
1144	dnl Adds '--enable-strict' to the command line.
1145	dnl
1146	dnl D/*
1147	AC_DEFUN([PAC_ARG_STRICT],[
1148	AC_ARG_ENABLE(strict,
1149	[--enable-strict - Turn on strict compilation testing when using gcc])
1150	PAC_CC_STRICT($enable_strict)
1151	CFLAGS="$CFLAGS $pac_cc_strict_flags"
1152	export CFLAGS
1153	])
1154
1155	dnl/D*
1156	dnl PAC_ARG_CC_G - Add debugging flags for the C compiler
1157	dnl
1158	dnl Synopsis:
1159	dnl PAC_ARG_CC_G
1160	dnl
1161	dnl Output Effect:
1162	dnl Adds '-g' to 'COPTIONS' and exports 'COPTIONS'. Sets and exports the
1163	dnl variable 'enable_g_simple' so that subsidiary 'configure's will not
1164	dnl add another '-g'.
1165	dnl
1166	dnl Notes:
1167	dnl '--enable-g' should be used for all internal debugging modes if possible.
1168	dnl Use the 'enable_val' that 'enable_g' is set to to pass particular values,
1169	dnl and ignore any values that are not recognized (some other 'configure'
1170	dnl may have used them. Of course, if you need extra values, you must
1171	dnl add code to extract values from 'enable_g'.
1172	dnl
1173	dnl For example, to look for a particular keyword, you could use
1174	dnl.vb
1175	dnl SaveIFS="$IFS"
1176	dnl IFS=","
1177	dnl for key in $enable_g ; do
1178	dnl case $key in
1179	dnl mem) # add code for memory debugging
1180	dnl ;;
1181	dnl ) # ignore all other values*
1182	dnl ;;
1183	dnl esac
1184	dnl done
1185	dnl IFS="$SaveIFS"
1186	dnl.ve
1187	dnl
1188	dnl D/*
1189	AC_DEFUN([PAC_ARG_CC_G],[
1190	AC_ARG_ENABLE(g,
1191	[--enable-g - Turn on debugging of the package (typically adds -g to COPTIONS)])
1192	export COPTIONS
1193	export enable_g_simple
1194	if test -n "$enable_g" -a "$enable_g" != "no" -a \
1195	"$enable_g_simple" != "done" ; then
1196	enable_g_simple="done"
1197	if test "$enable_g" = "g" -o "$enable_g" = "yes" ; then
1198	COPTIONS="$COPTIONS -g"
1199	fi
1200	fi
1201	])
1202	dnl
1203	dnl Simple version for both options
1204	dnl
1205	AC_DEFUN([PAC_ARG_CC_COMMON],[
1206	PAC_ARG_CC_G
1207	PAC_ARG_STRICT
1208	])
1209	dnl
1210	dnl Eventually, this can be used instead of the funky Fortran stuff to
1211	dnl access the command line from a C routine.
1212	dnl #
1213	dnl # Under IRIX (some version) __Argc and __Argv gave the argc,argv values
1214	dnl #Under linux, __libc_argv and __libc_argc
1215	dnl AC_MSG_CHECKING([for alternative argc,argv names])
1216	dnl AC_TRY_LINK([
1217	dnl extern int __Argc; extern char __Argv;],[return __Argc;],
1218	dnl alt_argv="__Argv")
1219	dnl if test -z "$alt_argv" ; then
1220	dnl AC_TRY_LINK([
1221	dnl extern int __libc_argc; extern char __libc_argv;],[return __lib_argc;],
1222	dnl alt_argv="__lib_argv")
1223	dnl fi
1224	dnl if test -z "$alt_argv" ; then
1225	dnl AC_MSG_RESULT(none found))
1226	dnl else
1227	dnl AC_MSG_RESULT($alt_argv)
1228	dnl fi
1229	dnl
1230	dnl
1231	dnl Check whether we need -fno-common to correctly compile the source code.
1232	dnl This is necessary if global variables are defined without values in
1233	dnl gcc. Here is the test
1234	dnl conftest1.c:
1235	dnl extern int a; int a;
1236	dnl conftest2.c:
1237	dnl extern int a; int main(int argc; char argv[] ){ return a; }*
1238	dnl Make a library out of conftest1.c and try to link with it.
1239	dnl If that fails, recompile it with -fno-common and see if that works.
1240	dnl If so, add -fno-common to CFLAGS
1241	dnl An alternative is to use, on some systems, ranlib -c to force
1242	dnl the system to find common symbols.
1243	dnl
1244	AC_DEFUN([PAC_PROG_C_BROKEN_COMMON],[
1245	AC_CACHE_CHECK([whether global variables handled properly],
1246	ac_cv_prog_cc_globals_work,[
1247	AC_REQUIRE([AC_PROG_RANLIB])
1248	ac_cv_prog_cc_globals_work=no
1249	rm -f libconftest.a
1250	echo 'extern int a; int a;' > conftest1.c
1251	echo 'extern int a; int main( ){ return a; }' > conftest2.c
1252	if ${CC-cc} $CFLAGS -c conftest1.c >conftest.out 2>&1 ; then
1253	if ${AR-ar} cr libconftest.a conftest1.o >/dev/null 2>&1 ; then
1254	if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1255	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >>conftest.out 2>&1 ; then
1256	# Success! C works
1257	ac_cv_prog_cc_globals_work=yes
1258	else
1259	echo "Error linking program with uninitialized global" >&AC_FD_CC
1260	echo "Programs were:" >&AC_FD_CC
1261	echo "conftest1.c:" >&AC_FD_CC
1262	cat conftest1.c >&AC_FD_CC
1263	echo "conftest2.c:" >&AC_FD_CC
1264	cat conftest2.c >&AC_FD_CC
1265	echo "and link line was:" >&AC_FD_CC
1266	echo "${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a" >&AC_FD_CC
1267	echo "with output:" >&AC_FD_CC
1268	cat conftest.out >&AC_FD_CC
1269
1270	# Failure! Do we need -fno-common?
1271	${CC-cc} $CFLAGS -fno-common -c conftest1.c >> conftest.out 2>&1
1272	rm -f libconftest.a
1273	${AR-ar} cr libconftest.a conftest1.o
1274	${RANLIB-:} libconftest.a
1275	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >> conftest.out 2>&1 ; then
1276	ac_cv_prog_cc_globals_work="needs -fno-common"
1277	CFLAGS="$CFLAGS -fno-common"
1278	elif test -n "$RANLIB" ; then
1279	# Try again, with ranlib changed to ranlib -c
1280	# (send output to /dev/null incase this ranlib
1281	# doesn't know -c)
1282	${RANLIB} -c libconftest.a >/dev/null 2>&1
1283	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >> conftest.out 2>&1 ; then
1284	RANLIB="$RANLIB -c"
1285	#else
1286	# # That didn't work
1287	# :
1288	fi
1289	#else
1290	# :
1291	fi
1292	fi
1293	fi
1294	fi
1295	fi
1296	# This is needed for Mac OSX 10.5
1297	rm -rf conftest.dSYM
1298	rm -f conftest* libconftest*])
1299	if test "$ac_cv_prog_cc_globals_work" = no ; then
1300	AC_MSG_WARN([Common symbols not supported on this system!])
1301	fi
1302	])
1303	dnl
1304	dnl
1305	dnl Return the structure alignment in pac_cv_c_struct_align
1306	dnl Possible values include
1307	dnl packed - no padding or alignment, any item may begin on any byte
1308	dnl largest - extent of a structure is a multiple of the largest item;
1309	dnl items are aligned with their size
1310	dnl four - structs padded to a multiple of four
1311	dnl two - like four, but to a multiple of two
1312	dnl eight - If objects containing 8-byte items are padded to a multiple
1313	dnl of eight
1314	dnl largestor4 - like largest, except that for items of size > 4, align
1315	dnl on 4-byte boundaries. E.g., align on the
1316	dnl min(4,max(size of items)).
1317	dnl largestorword - (should be named largestorqword, with qword meaning
1318	dnl quad-word): Like largestor4, but with a special case
1319	dnl for 16-byte items (this is the 16-byte aligned
1320	dnl quad-word-load special case).
1321	dnl
1322	dnl In addition, a "Could not determine alignment" and a
1323	dnl "Multiple cases:" return is possible.
1324	dnl
1325	AC_DEFUN([PAC_C_STRUCT_ALIGNMENT],[
1326	AC_CACHE_CHECK([for C struct alignment],pac_cv_c_struct_align,[
1327	AC_TRY_RUN([
1328	#include <stdio.h>
1329	#ifdef DEBUG_STRUCT_ALIGNMENT
1330	#define DBG(a,b,c) printf( "type %s, size = %d, extent = %d\n", a, b, c )
1331	#define CHECK(cond,flag) if (cond) { flag = 0; \
1332	printf( "Setting %s to false because of %s\n", #flag, #cond ); }
1333	#else
1334	#define DBG(a,b,c)
1335	#define CHECK(cond,flag) if (cond) { flag = 0; }
1336	#endif
1337
1338	int main( int argc, char *argv[] )
1339	{
1340	FILE *cf;
1341	int is_packed = 1;
1342	int is_two = 1;
1343	int is_four = 1;
1344	int is_eight = 1;
1345	int is_largest = 1;
1346	int is_largestorword = 1;
1347	int is_largestor4 = 1;
1348	int numCases;
1349
1350	/* We've seen PowerPC systems where the alignment may
1351	be largest for some items but not for double + int */
1352	struct { char a; int b; } char_int;
1353	struct { short a; int b; } short_int;
1354	struct { char a; short b; } char_short;
1355	struct { char a; long b; } char_long;
1356	struct { char a; float b; } char_float;
1357	struct { char a; double b; } char_double;
1358	struct { char a; int b; char c; } char_int_char;
1359	struct { char a; short b; char c; } char_short_char;
1360	#ifdef HAVE_LONG_DOUBLE
1361	struct { char a; long double b; } char_long_double;
1362	#endif
1363	int size, extent;
1364
1365	size = sizeof(char) + sizeof(int);
1366	extent = sizeof(char_int);
1367	if (size != extent) is_packed = 0;
1368	CHECK((extent % sizeof(int)) != 0, is_largest);
1369	CHECK((extent % sizeof(int)) != 0, is_largestor4);
1370	CHECK((extent % sizeof(int)) != 0, is_largestorword);
1371	if ( (extent % 2) != 0) is_two = 0;
1372	if ( (extent % 4) != 0) is_four = 0;
1373	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1374	DBG("char_int",size,extent);
1375
1376	size = sizeof(short) + sizeof(int);
1377	extent = sizeof(short_int);
1378	if (size != extent) is_packed = 0;
1379	CHECK((extent % sizeof(int)) != 0, is_largest);
1380	CHECK((extent % sizeof(int)) != 0, is_largestor4);
1381	CHECK((extent % sizeof(int)) != 0, is_largestorword);
1382	if ( (extent % 2) != 0) is_two = 0;
1383	if ( (size == 6) && (extent == 8) ) is_two = 0;
1384	if ( (extent % 4) != 0) is_four = 0;
1385	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1386	DBG("short_int",size,extent);
1387
1388	size = sizeof(char) + sizeof(short);
1389	extent = sizeof(char_short);
1390	if (size != extent) is_packed = 0;
1391	CHECK((extent % sizeof(short)) != 0,is_largest);
1392	CHECK((extent % sizeof(short)) != 0,is_largestor4);
1393	CHECK((extent % sizeof(short)) != 0,is_largestorword);
1394	if ( (extent % 2) != 0) is_two = 0;
1395	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1396	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1397	DBG("char_short",size,extent);
1398
1399	size = sizeof(char) + sizeof(long);
1400	extent = sizeof(char_long);
1401	if (size != extent) is_packed = 0;
1402	CHECK((extent % sizeof(long)) != 0,is_largest);
1403	CHECK((extent % 4) != 0,is_largestor4);
1404	CHECK((extent % sizeof(long)) != 0,is_largestorword);
1405	if ( (extent % 2) != 0) is_two = 0;
1406	if ( (extent % 4) != 0) is_four = 0;
1407	if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
1408	DBG("char_long",size,extent);
1409
1410	size = sizeof(char) + sizeof(float);
1411	extent = sizeof(char_float);
1412	if (size != extent) is_packed = 0;
1413	CHECK((extent % sizeof(float)) != 0,is_largest);
1414	CHECK((extent % sizeof(float)) != 0,is_largestor4);
1415	CHECK((extent % sizeof(float)) != 0,is_largestorword);
1416	if ( (extent % 2) != 0) is_two = 0;
1417	if ( (extent % 4) != 0) is_four = 0;
1418	if (sizeof(float) == 8 && (extent % 8) != 0) is_eight = 0;
1419	DBG("char_float",size,extent);
1420
1421	size = sizeof(char) + sizeof(double);
1422	extent = sizeof(char_double);
1423	if (size != extent) is_packed = 0;
1424	CHECK((extent % sizeof(double)) != 0,is_largest);
1425	CHECK((extent % 4) != 0,is_largestor4);
1426	CHECK((extent % sizeof(int)) != 0,is_largestorword);
1427	if ( (extent % 2) != 0) is_two = 0;
1428	if ( (extent % 4) != 0) is_four = 0;
1429	if (sizeof(double) == 8 && (extent % 8) != 0) is_eight = 0;
1430	DBG("char_double",size,extent);
1431
1432	#ifdef HAVE_LONG_DOUBLE
1433	size = sizeof(char) + sizeof(long double);
1434	extent = sizeof(char_long_double);
1435	if (size != extent) is_packed = 0;
1436	CHECK((extent % sizeof(long double)) != 0,is_largest);
1437	CHECK((extent % 4) != 0,is_largestor4);
1438	CHECK((extent % 16) == 0,is_largestor4);
1439	CHECK((extent % sizeof(long double)) != 0,is_largestorword);
1440	/* This case only applies to largestorword if long doubles are 16 bytes */
1441	if (sizeof(long double) != 16) is_largestorword = 0;
1442	if ( (extent % 2) != 0) is_two = 0;
1443	if ( (extent % 4) != 0) is_four = 0;
1444	if (sizeof(long double) >= 8 && (extent % 8) != 0) is_eight = 0;
1445	DBG("char_long-double",size,extent);
1446	#else
1447	/* The special case of largestorword only applies if long double
1448	available */
1449	is_largestorword=0;
1450	#endif
1451
1452	/* char int char helps separate largest from 4/8 aligned */
1453	size = sizeof(char) + sizeof(int) + sizeof(char);
1454	extent = sizeof(char_int_char);
1455	if (size != extent) is_packed = 0;
1456	CHECK((extent % sizeof(int)) != 0,is_largest);
1457	CHECK((extent % sizeof(int)) != 0,is_largestor4);
1458	CHECK((extent % sizeof(int)) != 0,is_largestorword);
1459	if ( (extent % 2) != 0) is_two = 0;
1460	if ( (extent % 4) != 0) is_four = 0;
1461	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1462	DBG("char_int_char",size,extent);
1463
1464	/* char short char helps separate largest from 4/8 aligned */
1465	size = sizeof(char) + sizeof(short) + sizeof(char);
1466	extent = sizeof(char_short_char);
1467	if (size != extent) is_packed = 0;
1468	CHECK((extent % sizeof(short)) != 0,is_largest);
1469	CHECK((extent % sizeof(short)) != 0,is_largestor4);
1470	CHECK((extent % sizeof(short)) != 0,is_largestorword);
1471	if ( (extent % 2) != 0) is_two = 0;
1472	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1473	CHECK((extent == 6) && (size == 4),is_four);
1474	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1475	DBG("char_short_char",size,extent);
1476
1477	/* If aligned mod 8, it will be aligned mod 4 */
1478	if (is_eight) { is_four = 0; is_two = 0; }
1479
1480	if (is_four) is_two = 0;
1481
1482	/* largest superceeds eight */
1483	if (is_largest) is_eight = 0;
1484
1485	/* Tabulate the results */
1486	cf = fopen( "ctest.out", "w" );
1487	numCases = is_packed + is_largest + is_largestorword + is_largestor4 +
1488	is_two + is_four + is_eight;
1489	if (numCases == 0) {
1490	fprintf( cf, "Could not determine alignment\n" );
1491	}
1492	else {
1493	if (numCases != 1) {
1494	fprintf( cf, "Multiple cases:\n" );
1495	}
1496	if (is_packed) fprintf( cf, "packed\n" );
1497	if (is_largest) fprintf( cf, "largest\n" );
1498	if (is_largestorword) fprintf( cf, "largestorword\n" );
1499	if (is_largestor4) fprintf( cf, "largestor4\n" );
1500	if (is_two) fprintf( cf, "two\n" );
1501	if (is_four) fprintf( cf, "four\n" );
1502	if (is_eight) fprintf( cf, "eight\n" );
1503	}
1504	fclose( cf );
1505	return 0;
1506	}],
1507	pac_cv_c_struct_align=`cat ctest.out`
1508	,pac_cv_c_struct_align="unknown",pac_cv_c_struct_align="$CROSS_ALIGN_STRUCT")
1509	rm -f ctest.out
1510	])
1511	if test -z "$pac_cv_c_struct_align" ; then
1512	pac_cv_c_struct_align="unknown"
1513	fi
1514	])
1515	dnl
1516	dnl
1517	dnl Return the integer structure alignment in pac_cv_c_max_integer_align
1518	dnl Possible values include
1519	dnl packed
1520	dnl two
1521	dnl four
1522	dnl eight
1523	dnl
1524	dnl In addition, a "Could not determine alignment" and a "error!"
1525	dnl return is possible.
1526	AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
1527	AC_CACHE_CHECK([for max C struct integer alignment],
1528	pac_cv_c_max_integer_align,[
1529	AC_TRY_RUN([
1530	#include <stdio.h>
1531	#define DBG(a,b,c)
1532	int main( int argc, char *argv[] )
1533	{
1534	FILE *cf;
1535	int is_packed = 1;
1536	int is_two = 1;
1537	int is_four = 1;
1538	int is_eight = 1;
1539	struct { char a; int b; } char_int;
1540	struct { char a; short b; } char_short;
1541	struct { char a; long b; } char_long;
1542	struct { char a; int b; char c; } char_int_char;
1543	struct { char a; short b; char c; } char_short_char;
1544	#ifdef HAVE_LONG_LONG_INT
1545	struct { long long int a; char b; } lli_c;
1546	struct { char a; long long int b; } c_lli;
1547	#endif
1548	int size, extent, extent2;
1549
1550	/* assume max integer alignment isn't 8 if we don't have
1551	* an eight-byte value :)
1552	*/
1553	#ifdef HAVE_LONG_LONG_INT
1554	if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
1555	is_eight = 0;
1556	#else
1557	if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
1558	#endif
1559
1560	size = sizeof(char) + sizeof(int);
1561	extent = sizeof(char_int);
1562	if (size != extent) is_packed = 0;
1563	if ( (extent % 2) != 0) is_two = 0;
1564	if ( (extent % 4) != 0) is_four = 0;
1565	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1566	DBG("char_int",size,extent);
1567
1568	size = sizeof(char) + sizeof(short);
1569	extent = sizeof(char_short);
1570	if (size != extent) is_packed = 0;
1571	if ( (extent % 2) != 0) is_two = 0;
1572	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1573	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1574	DBG("char_short",size,extent);
1575
1576	size = sizeof(char) + sizeof(long);
1577	extent = sizeof(char_long);
1578	if (size != extent) is_packed = 0;
1579	if ( (extent % 2) != 0) is_two = 0;
1580	if ( (extent % 4) != 0) is_four = 0;
1581	if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
1582	DBG("char_long",size,extent);
1583
1584	#ifdef HAVE_LONG_LONG_INT
1585	size = sizeof(char) + sizeof(long long int);
1586	extent = sizeof(lli_c);
1587	extent2 = sizeof(c_lli);
1588	if (size != extent) is_packed = 0;
1589	if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1590	if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1591	if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
1592	is_eight = 0;
1593	#endif
1594
1595	size = sizeof(char) + sizeof(int) + sizeof(char);
1596	extent = sizeof(char_int_char);
1597	if (size != extent) is_packed = 0;
1598	if ( (extent % 2) != 0) is_two = 0;
1599	if ( (extent % 4) != 0) is_four = 0;
1600	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1601	DBG("char_int_char",size,extent);
1602
1603	size = sizeof(char) + sizeof(short) + sizeof(char);
1604	extent = sizeof(char_short_char);
1605	if (size != extent) is_packed = 0;
1606	if ( (extent % 2) != 0) is_two = 0;
1607	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1608	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1609	DBG("char_short_char",size,extent);
1610
1611	/* If aligned mod 8, it will be aligned mod 4 */
1612	if (is_eight) { is_four = 0; is_two = 0; }
1613
1614	if (is_four) is_two = 0;
1615
1616	/* Tabulate the results */
1617	cf = fopen( "ctest.out", "w" );
1618	if (is_packed + is_two + is_four + is_eight == 0) {
1619	fprintf( cf, "Could not determine alignment\n" );
1620	}
1621	else {
1622	if (is_packed + is_two + is_four + is_eight != 1) {
1623	fprintf( cf, "error!\n" );
1624	}
1625	else {
1626	if (is_packed) fprintf( cf, "packed\n" );
1627	if (is_two) fprintf( cf, "two\n" );
1628	if (is_four) fprintf( cf, "four\n" );
1629	if (is_eight) fprintf( cf, "eight\n" );
1630	}
1631	}
1632	fclose( cf );
1633	return 0;
1634	}],
1635	pac_cv_c_max_integer_align=`cat ctest.out`,
1636	pac_cv_c_max_integer_align="unknown",
1637	pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
1638	rm -f ctest.out
1639	])
1640	if test -z "$pac_cv_c_max_integer_align" ; then
1641	pac_cv_c_max_integer_align="unknown"
1642	fi
1643	])
1644	dnl
1645	dnl
1646	dnl Return the floating point structure alignment in
1647	dnl pac_cv_c_max_fp_align.
1648	dnl
1649	dnl Possible values include:
1650	dnl packed
1651	dnl two
1652	dnl four
1653	dnl eight
1654	dnl sixteen
1655	dnl
1656	dnl In addition, a "Could not determine alignment" and a "error!"
1657	dnl return is possible.
1658	AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
1659	AC_CACHE_CHECK([for max C struct floating point alignment],
1660	pac_cv_c_max_fp_align,[
1661	AC_TRY_RUN([
1662	#include <stdio.h>
1663	#define DBG(a,b,c)
1664	int main( int argc, char *argv[] )
1665	{
1666	FILE *cf;
1667	int is_packed = 1;
1668	int is_two = 1;
1669	int is_four = 1;
1670	int is_eight = 1;
1671	int is_sixteen = 1;
1672	struct { char a; float b; } char_float;
1673	struct { float b; char a; } float_char;
1674	struct { char a; double b; } char_double;
1675	struct { double b; char a; } double_char;
1676	#ifdef HAVE_LONG_DOUBLE
1677	struct { char a; long double b; } char_long_double;
1678	struct { long double b; char a; } long_double_char;
1679	struct { long double a; int b; char c; } long_double_int_char;
1680	#endif
1681	int size, extent1, extent2;
1682
1683	size = sizeof(char) + sizeof(float);
1684	extent1 = sizeof(char_float);
1685	extent2 = sizeof(float_char);
1686	if (size != extent1) is_packed = 0;
1687	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1688	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1689	if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1690	is_eight = 0;
1691	DBG("char_float",size,extent1);
1692
1693	size = sizeof(char) + sizeof(double);
1694	extent1 = sizeof(char_double);
1695	extent2 = sizeof(double_char);
1696	if (size != extent1) is_packed = 0;
1697	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1698	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1699	if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1700	is_eight = 0;
1701	DBG("char_double",size,extent1);
1702
1703	#ifdef HAVE_LONG_DOUBLE
1704	size = sizeof(char) + sizeof(long double);
1705	extent1 = sizeof(char_long_double);
1706	extent2 = sizeof(long_double_char);
1707	if (size != extent1) is_packed = 0;
1708	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1709	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1710	if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1711	is_eight = 0;
1712	if (sizeof(long double) > 8 && (extent1 % 16) != 0
1713	&& (extent2 % 16) != 0) is_sixteen = 0;
1714	DBG("char_long-double",size,extent1);
1715
1716	extent1 = sizeof(long_double_int_char);
1717	if ( (extent1 % 2) != 0) is_two = 0;
1718	if ( (extent1 % 4) != 0) is_four = 0;
1719	if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1720	if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1721	#else
1722	is_sixteen = 0;
1723	#endif
1724
1725	if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1726
1727	if (is_eight) { is_four = 0; is_two = 0; }
1728
1729	if (is_four) is_two = 0;
1730
1731	/* Tabulate the results */
1732	cf = fopen( "ctest.out", "w" );
1733	if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1734	fprintf( cf, "Could not determine alignment\n" );
1735	}
1736	else {
1737	if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1738	fprintf( cf, "error!\n" );
1739	}
1740	else {
1741	if (is_packed) fprintf( cf, "packed\n" );
1742	if (is_two) fprintf( cf, "two\n" );
1743	if (is_four) fprintf( cf, "four\n" );
1744	if (is_eight) fprintf( cf, "eight\n" );
1745	if (is_sixteen) fprintf( cf, "sixteen\n" );
1746	}
1747	}
1748	fclose( cf );
1749	return 0;
1750	}],
1751	pac_cv_c_max_fp_align=`cat ctest.out`,
1752	pac_cv_c_max_fp_align="unknown",
1753	pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
1754	rm -f ctest.out
1755	])
1756	if test -z "$pac_cv_c_max_fp_align" ; then
1757	pac_cv_c_max_fp_align="unknown"
1758	fi
1759	])
1760	dnl
1761	dnl
1762	dnl Return the floating point structure alignment in
1763	dnl pac_cv_c_max_double_fp_align.
1764	dnl
1765	dnl Possible values include:
1766	dnl packed
1767	dnl two
1768	dnl four
1769	dnl eight
1770	dnl
1771	dnl In addition, a "Could not determine alignment" and a "error!"
1772	dnl return is possible.
1773	AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
1774	AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
1775	pac_cv_c_max_double_fp_align,[
1776	AC_TRY_RUN([
1777	#include <stdio.h>
1778	#define DBG(a,b,c)
1779	int main( int argc, char *argv[] )
1780	{
1781	FILE *cf;
1782	int is_packed = 1;
1783	int is_two = 1;
1784	int is_four = 1;
1785	int is_eight = 1;
1786	struct { char a; float b; } char_float;
1787	struct { float b; char a; } float_char;
1788	struct { char a; double b; } char_double;
1789	struct { double b; char a; } double_char;
1790	int size, extent1, extent2;
1791
1792	size = sizeof(char) + sizeof(float);
1793	extent1 = sizeof(char_float);
1794	extent2 = sizeof(float_char);
1795	if (size != extent1) is_packed = 0;
1796	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1797	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1798	if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1799	is_eight = 0;
1800	DBG("char_float",size,extent1);
1801
1802	size = sizeof(char) + sizeof(double);
1803	extent1 = sizeof(char_double);
1804	extent2 = sizeof(double_char);
1805	if (size != extent1) is_packed = 0;
1806	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1807	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1808	if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1809	is_eight = 0;
1810	DBG("char_double",size,extent1);
1811
1812	if (is_eight) { is_four = 0; is_two = 0; }
1813
1814	if (is_four) is_two = 0;
1815
1816	/* Tabulate the results */
1817	cf = fopen( "ctest.out", "w" );
1818	if (is_packed + is_two + is_four + is_eight == 0) {
1819	fprintf( cf, "Could not determine alignment\n" );
1820	}
1821	else {
1822	if (is_packed + is_two + is_four + is_eight != 1) {
1823	fprintf( cf, "error!\n" );
1824	}
1825	else {
1826	if (is_packed) fprintf( cf, "packed\n" );
1827	if (is_two) fprintf( cf, "two\n" );
1828	if (is_four) fprintf( cf, "four\n" );
1829	if (is_eight) fprintf( cf, "eight\n" );
1830	}
1831	}
1832	fclose( cf );
1833	return 0;
1834	}],
1835	pac_cv_c_max_double_fp_align=`cat ctest.out`,
1836	pac_cv_c_max_double_fp_align="unknown",
1837	pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
1838	rm -f ctest.out
1839	])
1840	if test -z "$pac_cv_c_max_double_fp_align" ; then
1841	pac_cv_c_max_double_fp_align="unknown"
1842	fi
1843	])
1844	AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
1845	AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
1846	pac_cv_c_max_longdouble_fp_align,[
1847	AC_TRY_RUN([
1848	#include <stdio.h>
1849	#define DBG(a,b,c)
1850	*int main( int argc, char argv[] )**
1851	{
1852	*FILE cf;**
1853	int is_packed = 1;
1854	int is_two = 1;
1855	int is_four = 1;
1856	int is_eight = 1;
1857	int is_sixteen = 1;
1858	struct { char a; long double b; } char_long_double;
1859	struct { long double b; char a; } long_double_char;
1860	struct { long double a; int b; char c; } long_double_int_char;
1861	int size, extent1, extent2;
1862
1863	size = sizeof(char) + sizeof(long double);
1864	extent1 = sizeof(char_long_double);
1865	extent2 = sizeof(long_double_char);
1866	if (size != extent1) is_packed = 0;
1867	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1868	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1869	if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1870	is_eight = 0;
1871	if (sizeof(long double) > 8 && (extent1 % 16) != 0
1872	&& (extent2 % 16) != 0) is_sixteen = 0;
1873	DBG("char_long-double",size,extent1);
1874
1875	extent1 = sizeof(long_double_int_char);
1876	if ( (extent1 % 2) != 0) is_two = 0;
1877	if ( (extent1 % 4) != 0) is_four = 0;
1878	if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1879	if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1880
1881	if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1882
1883	if (is_eight) { is_four = 0; is_two = 0; }
1884
1885	if (is_four) is_two = 0;
1886
1887	*/ Tabulate the results /*
1888	cf = fopen( "ctest.out", "w" );
1889	if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1890	fprintf( cf, "Could not determine alignment\n" );
1891	}
1892	else {
1893	if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1894	fprintf( cf, "error!\n" );
1895	}
1896	else {
1897	if (is_packed) fprintf( cf, "packed\n" );
1898	if (is_two) fprintf( cf, "two\n" );
1899	if (is_four) fprintf( cf, "four\n" );
1900	if (is_eight) fprintf( cf, "eight\n" );
1901	if (is_sixteen) fprintf( cf, "sixteen\n" );
1902	}
1903	}
1904	fclose( cf );
1905	return 0;
1906	}],
1907	pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1908	pac_cv_c_max_longdouble_fp_align="unknown",
1909	pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1910	rm -f ctest.out
1911	])
1912	if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1913	pac_cv_c_max_longdouble_fp_align="unknown"
1914	fi
1915	])
1916	dnl
1917	dnl Other tests assume that there is potentially a maximum alignment
1918	dnl and that if there is no maximum alignment, or a type is smaller than
1919	dnl that value, then we align on the size of the value, with the exception
1920	dnl of the "position-based alignment" rules we test for separately.
1921	dnl
1922	dnl It turns out that these assumptions have fallen short in at least one
1923	dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1924	dnl even when long doubles are aligned on 16-byte boundaries. So this test
1925	dnl is here specifically to handle this case.
1926	dnl
1927	dnl Puts result in pac_cv_c_double_alignment_exception.
1928	dnl
1929	dnl Possible values currently include no and four.
1930	dnl
1931	AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1932	AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1933	pac_cv_c_double_alignment_exception,[
1934	AC_TRY_RUN([
1935	#include <stdio.h>
1936	#define DBG(a,b,c)
1937	*int main( int argc, char argv[] )**
1938	{
1939	*FILE cf;**
1940	struct { char a; double b; } char_double;
1941	struct { double b; char a; } double_char;
1942	int extent1, extent2, align_4 = 0;
1943
1944	extent1 = sizeof(char_double);
1945	extent2 = sizeof(double_char);
1946
1947	*/ we'**re interested in the largest value, will let separate test
1948	* deal with position-based issues.
1949	*/
1950	if (extent1 < extent2) extent1 = extent2;
1951	if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1952	if (extent1 % 4 == 0) {
1953	#ifdef HAVE_MAX_FP_ALIGNMENT
1954	if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1955	#else
1956	align_4 = 1;
1957	#endif
1958	}
1959	}
1960
1961	cf = fopen( "ctest.out", "w" );
1962
1963	if (align_4) fprintf( cf, "four\n" );
1964	else fprintf( cf, "no\n" );
1965
1966	fclose( cf );
1967	return 0;
1968	}],
1969	pac_cv_c_double_alignment_exception=`cat ctest.out`,
1970	pac_cv_c_double_alignment_exception="unknown",
1971	pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1972	rm -f ctest.out
1973	])
1974	if test -z "$pac_cv_c_double_alignment_exception" ; then
1975	pac_cv_c_double_alignment_exception="unknown"
1976	fi
1977	])
1978	dnl
1979	dnl
1980	dnl Test for odd struct alignment rule that only applies max.
1981	dnl padding when double value is at front of type.
1982	dnl Puts result in pac_cv_c_double_pos_align.
1983	dnl
1984	dnl Search for "Power alignment mode" for more details.
1985	dnl
1986	dnl Possible values include yes, no, and unknown.
1987	dnl
1988	AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1989	AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1990	pac_cv_c_double_pos_align,[
1991	AC_TRY_RUN([
1992	#include <stdio.h>
1993	#define DBG(a,b,c)
1994	int main( int argc, char *argv[] )
1995	{
1996	FILE *cf;
1997	int padding_varies_by_pos = 0;
1998	struct { char a; double b; } char_double;
1999	struct { double b; char a; } double_char;
2000	int extent1, extent2;
2001
2002	extent1 = sizeof(char_double);
2003	extent2 = sizeof(double_char);
2004	if (extent1 != extent2) padding_varies_by_pos = 1;
2005
2006	cf = fopen( "ctest.out", "w" );
2007	if (padding_varies_by_pos) fprintf( cf, "yes\n" );
2008	else fprintf( cf, "no\n" );
2009
2010	fclose( cf );
2011	return 0;
2012	}],
2013	pac_cv_c_double_pos_align=`cat ctest.out`,
2014	pac_cv_c_double_pos_align="unknown",
2015	pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
2016	rm -f ctest.out
2017	])
2018	if test -z "$pac_cv_c_double_pos_align" ; then
2019	pac_cv_c_double_pos_align="unknown"
2020	fi
2021	])
2022	dnl
2023	dnl
2024	dnl Test for odd struct alignment rule that only applies max.
2025	dnl padding when long long int value is at front of type.
2026	dnl Puts result in pac_cv_c_llint_pos_align.
2027	dnl
2028	dnl Search for "Power alignment mode" for more details.
2029	dnl
2030	dnl Possible values include yes, no, and unknown.
2031	dnl
2032	AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
2033	AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
2034	pac_cv_c_llint_pos_align,[
2035	AC_TRY_RUN([
2036	#include <stdio.h>
2037	#define DBG(a,b,c)
2038	int main( int argc, char *argv[] )
2039	{
2040	FILE *cf;
2041	int padding_varies_by_pos = 0;
2042	#ifdef HAVE_LONG_LONG_INT
2043	struct { char a; long long int b; } char_llint;
2044	struct { long long int b; char a; } llint_char;
2045	int extent1, extent2;
2046
2047	extent1 = sizeof(char_llint);
2048	extent2 = sizeof(llint_char);
2049	if (extent1 != extent2) padding_varies_by_pos = 1;
2050	#endif
2051
2052	cf = fopen( "ctest.out", "w" );
2053	if (padding_varies_by_pos) fprintf( cf, "yes\n" );
2054	else fprintf( cf, "no\n" );
2055
2056	fclose( cf );
2057	return 0;
2058	}],
2059	pac_cv_c_llint_pos_align=`cat ctest.out`,
2060	pac_cv_c_llint_pos_align="unknown",
2061	pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
2062	rm -f ctest.out
2063	])
2064	if test -z "$pac_cv_c_llint_pos_align" ; then
2065	pac_cv_c_llint_pos_align="unknown"
2066	fi
2067	])
2068
2069	dnl
2070	dnl
2071	dnl/D*
2072	dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
2073	dnl
2074	dnl Synopsis:
2075	dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
2076	dnl
2077	dnl Output Effect:
2078	dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the
2079	dnl headerfiles.
2080	dnl
2081	dnl Approach:
2082	dnl Try to compile a program with the function, but passed with an incorrect
2083	dnl calling sequence. If the compilation fails, then the declaration
2084	dnl is provided within the header files. If the compilation succeeds,
2085	dnl the declaration is required.
2086	dnl
2087	dnl We use a 'double' as the first argument to try and catch varargs
2088	dnl routines that may use an int or pointer as the first argument.
2089	dnl
2090	dnl There is one difficulty - if the compiler has been instructed to
2091	dnl fail on implicitly defined functions, then this test will always
2092	dnl fail.
2093	dnl
2094	dnl D/*
2095	AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
2096	AC_CACHE_CHECK([whether $2 needs a declaration],
2097	pac_cv_func_decl_$2,[
2098	AC_TRY_COMPILE([$1
2099	int $2(double, int, double, const char *);],[int a=$2(1.0,27,1.0,"foo");],
2100	pac_cv_func_decl_$2=yes,pac_cv_func_decl_$2=no)])
2101	if test "$pac_cv_func_decl_$2" = "yes" ; then
2102	changequote(<<,>>)dnl
2103	define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z ], [A-Z__]))dnl*
2104	changequote([, ])dnl
2105	AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
2106	undefine([PAC_FUNC_NAME])
2107	fi
2108	])dnl
2109	dnl
2110	dnl /D*
2111	dnl PAC_CHECK_SIZEOF_DERIVED - Get the size of a user-defined type,
2112	dnl such as a struct
2113	dnl
2114	dnl PAC_CHECK_SIZEOF_DERIVED(shortname,definition,defaultsize)
2115	dnl Like AC_CHECK_SIZEOF, but handles arbitrary types.
2116	dnl Unlike AC_CHECK_SIZEOF, does not define SIZEOF_xxx (because
2117	dnl autoheader can''t handle this case)
2118	dnl D/*
2119	AC_DEFUN([PAC_CHECK_SIZEOF_DERIVED],[
2120	changequote(<<,>>)dnl
2121	define(<<AC_TYPE_NAME>>,translit(sizeof_$1,[a-z ], [A-Z_P]))dnl*
2122	define(<<AC_CV_NAME>>,translit(pac_cv_sizeof_$1,[ ], [_p]))dnl*
2123	changequote([,])dnl
2124	rm -f conftestval
2125	AC_MSG_CHECKING([for size of $1])
2126	AC_CACHE_VAL(AC_CV_NAME,
2127	[AC_TRY_RUN([#include <stdio.h>
2128	main()
2129	{
2130	$2 a;
2131	FILE *f=fopen("conftestval", "w");
2132	if (!f) exit(1);
2133	fprintf(f, "%d\n", sizeof(a));
2134	exit(0);
2135	}],AC_CV_NAME=`cat conftestval`,AC_CV_NAME=0,ifelse([$3],,,AC_CV_NAME=$3))])
2136	AC_MSG_RESULT($AC_CV_NAME)
2137	dnl AC_DEFINE_UNQUOTED(AC_TYPE_NAME,$AC_CV_NAME)
2138	undefine([AC_TYPE_NAME])undefine([AC_CV_NAME])
2139	])
2140	dnl
2141	dnl /D*
2142	dnl PAC_CHECK_SIZEOF_2TYPES - Get the size of a pair of types
2143	dnl
2144	dnl PAC_CHECK_SIZEOF_2TYPES(shortname,type1,type2,defaultsize)
2145	dnl Like AC_CHECK_SIZEOF, but handles pairs of types.
2146	dnl Unlike AC_CHECK_SIZEOF, does not define SIZEOF_xxx (because
2147	dnl autoheader can''t handle this case)
2148	dnl D/*
2149	AC_DEFUN([PAC_CHECK_SIZEOF_2TYPES],[
2150	changequote(<<,>>)dnl
2151	define(<<AC_TYPE_NAME>>,translit(sizeof_$1,[a-z ], [A-Z_P]))dnl*
2152	define(<<AC_CV_NAME>>,translit(pac_cv_sizeof_$1,[ ], [_p]))dnl*
2153	changequote([,])dnl
2154	rm -f conftestval
2155	AC_MSG_CHECKING([for size of $1])
2156	AC_CACHE_VAL(AC_CV_NAME,
2157	[AC_TRY_RUN([#include <stdio.h>
2158	main()
2159	{
2160	$2 a;
2161	$3 b;
2162	FILE *f=fopen("conftestval", "w");
2163	if (!f) return 1; /* avoid exit */
2164	fprintf(f, "%d\n", (int)(sizeof(a) + sizeof(b)));
2165	return 0;
2166	}],AC_CV_NAME=`cat conftestval`,AC_CV_NAME=0,ifelse([$4],,,AC_CV_NAME=$4))])
2167	if test "X$AC_CV_NAME" = "X" ; then
2168	# We have a problem. The test returned a zero status, but no output,
2169	# or we're cross-compiling (or think we are) and have no value for
2170	# this object
2171	:
2172	fi
2173	rm -f conftestval
2174	AC_MSG_RESULT($AC_CV_NAME)
2175	dnl AC_DEFINE_UNQUOTED(AC_TYPE_NAME,$AC_CV_NAME)
2176	undefine([AC_TYPE_NAME])undefine([AC_CV_NAME])
2177	])
2178
2179	dnl
2180	dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
2181	dnl Use the following
2182	dnl #ifndef HAVE_GCC_ATTRIBUTE
2183	dnl #define __attribute__(a)
2184	dnl #endif
2185	dnl If not, define __attribute__(a) as null
2186	dnl
2187	dnl We start by requiring Gcc. Some other compilers accept __attribute__
2188	dnl but generate warning messages, or have different interpretations
2189	dnl (which seems to make __attribute__ just as bad as #pragma)
2190	dnl For example, the Intel icc compiler accepts __attribute__ and
2191	dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
2192	dnl
2193	AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
2194	AC_REQUIRE([AC_PROG_CC_GNU])
2195	if test "$ac_cv_prog_gcc" = "yes" ; then
2196	AC_CACHE_CHECK([whether __attribute__ allowed],
2197	pac_cv_gnu_attr_pure,[
2198	AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
2199	pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
2200	AC_CACHE_CHECK([whether __attribute__((format)) allowed],
2201	pac_cv_gnu_attr_format,[
2202	AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
2203	pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
2204	if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
2205	AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
2206	fi
2207	fi
2208	])
2209	dnl
2210	dnl Check for a broken install (fails to preserve file modification times,
2211	dnl thus breaking libraries.
2212	dnl
2213	dnl Create a library, install it, and then try to link against it.
2214	AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
2215	AC_CACHE_CHECK([whether install breaks libraries],
2216	ac_cv_prog_install_breaks_libs,[
2217	AC_REQUIRE([AC_PROG_RANLIB])
2218	AC_REQUIRE([AC_PROG_INSTALL])
2219	AC_REQUIRE([AC_PROG_CC])
2220	ac_cv_prog_install_breaks_libs=yes
2221	# This is needed for Mac OSX 10.5
2222	rm -rf conftest.dSYM
2223	rm -f libconftest* conftest*
2224	echo 'int foo(int);int foo(int a){return a;}' > conftest1.c
2225	echo 'extern int foo(int); int main( int argc, char **argv){ return foo(0); }' > conftest2.c
2226	if ${CC-cc} $CFLAGS -c conftest1.c >conftest.out 2>&1 ; then
2227	if ${AR-ar} cr libconftest.a conftest1.o >/dev/null 2>&1 ; then
2228	if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
2229	# Anything less than sleep 10, and Mac OS/X (Darwin)
2230	# will claim that install works because ranlib won't complain
2231	sleep 10
2232	libinstall="$INSTALL_DATA"
2233	eval "libinstall=\"$libinstall\""
2234	if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
2235	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
2236	# Success! Install works
2237	ac_cv_prog_install_breaks_libs=no
2238	else
2239	# Failure! Does install -p work?
2240	rm -f libconftest1.a
2241	if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
2242	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
2243	# Success! Install works
2244	ac_cv_prog_install_breaks_libs="no, with -p"
2245	fi
2246	fi
2247	fi
2248	fi
2249	fi
2250	fi
2251	fi
2252	# This is needed for Mac OSX 10.5
2253	rm -rf conftest.dSYM
2254	rm -f conftest* libconftest*])
2255
2256	if test -z "$RANLIB_AFTER_INSTALL" ; then
2257	RANLIB_AFTER_INSTALL=no
2258	fi
2259	case "$ac_cv_prog_install_breaks_libs" in
2260	yes)
2261	RANLIB_AFTER_INSTALL=yes
2262	;;
2263	"no, with -p")
2264	INSTALL_DATA="$INSTALL_DATA -p"
2265	;;
2266	*)
2267	# Do nothing
2268	:
2269	;;
2270	esac
2271	AC_SUBST(RANLIB_AFTER_INSTALL)
2272	])
2273
2274	#
2275	# determine if the compiler defines a symbol containing the function name
2276	# Inspired by checks within the src/mpid/globus/configure.in file in MPICH2
2277	#
2278	# These tests check not only that the compiler defines some symbol, such
2279	# as __FUNCTION__, but that the symbol correctly names the function.
2280	#
2281	# Defines
2282	# HAVE__FUNC__ (if __func__ defined)
2283	# HAVE_CAP__FUNC__ (if __FUNC__ defined)
2284	# HAVE__FUNCTION__ (if __FUNCTION__ defined)
2285	#
2286	AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
2287	AC_CACHE_CHECK([whether the compiler defines __func__],
2288	pac_cv_have__func__,[
2289	tmp_am_cross=no
2290	AC_RUN_IFELSE([
2291	#include <string.h>
2292	int foo(void);
2293	int foo(void)
2294	{
2295	return (strcmp(__func__, "foo") == 0);
2296	}
2297	int main(int argc, char ** argv)
2298	{
2299	return (foo() ? 0 : 1);
2300	}
2301	], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
2302	if test "$tmp_am_cross" = yes ; then
2303	AC_LINK_IFELSE([
2304	#include <string.h>
2305	int foo(void);
2306	int foo(void)
2307	{
2308	return (strcmp(__func__, "foo") == 0);
2309	}
2310	int main(int argc, char ** argv)
2311	{
2312	return (foo() ? 0 : 1);
2313	}
2314	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2315	fi
2316	])
2317
2318	if test "$pac_cv_have__func__" = "yes" ; then
2319	AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
2320	fi
2321
2322	AC_CACHE_CHECK([whether the compiler defines __FUNC__],
2323	pac_cv_have_cap__func__,[
2324	tmp_am_cross=no
2325	AC_RUN_IFELSE([
2326	#include <string.h>
2327	int foo(void);
2328	int foo(void)
2329	{
2330	return (strcmp(__FUNC__, "foo") == 0);
2331	}
2332	int main(int argc, char ** argv)
2333	{
2334	return (foo() ? 0 : 1);
2335	}
2336	], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
2337	if test "$tmp_am_cross" = yes ; then
2338	AC_LINK_IFELSE([
2339	#include <string.h>
2340	int foo(void);
2341	int foo(void)
2342	{
2343	return (strcmp(__FUNC__, "foo") == 0);
2344	}
2345	int main(int argc, char ** argv)
2346	{
2347	return (foo() ? 0 : 1);
2348	}
2349	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2350	fi
2351	])
2352
2353	if test "$pac_cv_have_cap__func__" = "yes" ; then
2354	AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
2355	fi
2356
2357	AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
2358	pac_cv_have__function__,[
2359	tmp_am_cross=no
2360	AC_RUN_IFELSE([
2361	#include <string.h>
2362	int foo(void);
2363	int foo(void)
2364	{
2365	return (strcmp(__FUNCTION__, "foo") == 0);
2366	}
2367	int main(int argc, char ** argv)
2368	{
2369	return (foo() ? 0 : 1);
2370	}
2371	], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
2372	if test "$tmp_am_cross" = yes ; then
2373	AC_LINK_IFELSE([
2374	#include <string.h>
2375	int foo(void);
2376	int foo(void)
2377	{
2378	return (strcmp(__FUNCTION__, "foo") == 0);
2379	}
2380	int main(int argc, char ** argv)
2381	{
2382	return (foo() ? 0 : 1);
2383	}
2384	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2385	fi
2386	])
2387
2388	if test "$pac_cv_have__function__" = "yes" ; then
2389	AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
2390	fi
2391
2392	])

Note: See TracBrowser for help on using the browser.

Context Navigation

root/mpich2/trunk/confdb/aclocal_cc.m4 @ 4876

Download in other formats: