Context Navigation

aclocal_cc.m4 @ 4854

Revision 4854, 73.6 KB (checked in by buntinas, 5 months ago)
removed error on implicit declaration warning option which broke PAC_FUNC_NEEDS_DECL

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	pac_cc_strict_flags=""
1074	pac_common_strict_flags="-O2 -Wall -Wextra -Wstrict-prototypes -Wmissing-prototypes -DGCC_WALL -Wunused -Wshadow -Wmissing-declarations -Wno-long-long -Wunused-value -Wno-unused-parameter -Wfloat-equal -Wdeclaration-after-statement -Wundef -Wno-endif-labels -Wpointer-arith -Wbad-function-cast -Wcast-qual -Wcast-align -Wwrite-strings -Wsign-compare -Waggregate-return -Wold-style-definition -Wmissing-field-initializers -Wmissing-noreturn -Wmissing-format-attribute -Wno-multichar -Wno-deprecated-declarations -Wpacked -Wnested-externs -Winline -Winvalid-pch -Wno-pointer-sign -Wvariadic-macros -std=c89"
1075	case "$1" in
1076	yes\|all)
1077	enable_strict_done="yes"
1078	pac_cc_strict_flags="$pac_common_strict_flags"
1079	;;
1080
1081	posix)
1082	# fsync is a part of POSIX only in the real-time
1083	# extensions, apparently, so code that used include
1084	# <unistd.h> and POSIX and expects fsync to be defined
1085	# is in trouble. Because of that we're not including
1086	# the -W option to error if a function is not
1087	# prototyped.
1088	enable_strict_done="yes"
1089	pac_cc_strict_flags="$pac_common_strict_flags -D_POSIX_C_SOURCE=199506L"
1090	;;
1091
1092	no)
1093	# Accept and ignore this value
1094	:
1095	;;
1096
1097	*)
1098	if test -n "$1" ; then
1099	AC_MSG_WARN([Unrecognized value for enable-strict:$1])
1100	fi
1101	;;
1102
1103	esac
1104
1105	# See if the above options work with the compiler
1106	accepted_flags=""
1107	for flag in $pac_cc_strict_flags ; do
1108	old_CFLAGS=$CFLAGS
1109	CFLAGS="$CFLAGS $accepted_flags $flag"
1110	AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[int a;])],accepted_flags="$accepted_flags $flag",)
1111	CFLAGS="$old_CFLAGS"
1112	done
1113	pac_cc_strict_flags=$accepted_flags
1114	fi
1115	])
1116
1117	dnl/D*
1118	dnl PAC_ARG_STRICT - Add --enable-strict to configure.
1119	dnl
1120	dnl Synopsis:
1121	dnl PAC_ARG_STRICT
1122	dnl
1123	dnl Output effects:
1124	dnl Adds '--enable-strict' to the command line.
1125	dnl
1126	dnl D/*
1127	AC_DEFUN([PAC_ARG_STRICT],[
1128	AC_ARG_ENABLE(strict,
1129	[--enable-strict - Turn on strict compilation testing when using gcc])
1130	PAC_CC_STRICT($enable_strict)
1131	CFLAGS="$CFLAGS $pac_cc_strict_flags"
1132	export CFLAGS
1133	])
1134
1135	dnl/D*
1136	dnl PAC_ARG_CC_G - Add debugging flags for the C compiler
1137	dnl
1138	dnl Synopsis:
1139	dnl PAC_ARG_CC_G
1140	dnl
1141	dnl Output Effect:
1142	dnl Adds '-g' to 'COPTIONS' and exports 'COPTIONS'. Sets and exports the
1143	dnl variable 'enable_g_simple' so that subsidiary 'configure's will not
1144	dnl add another '-g'.
1145	dnl
1146	dnl Notes:
1147	dnl '--enable-g' should be used for all internal debugging modes if possible.
1148	dnl Use the 'enable_val' that 'enable_g' is set to to pass particular values,
1149	dnl and ignore any values that are not recognized (some other 'configure'
1150	dnl may have used them. Of course, if you need extra values, you must
1151	dnl add code to extract values from 'enable_g'.
1152	dnl
1153	dnl For example, to look for a particular keyword, you could use
1154	dnl.vb
1155	dnl SaveIFS="$IFS"
1156	dnl IFS=","
1157	dnl for key in $enable_g ; do
1158	dnl case $key in
1159	dnl mem) # add code for memory debugging
1160	dnl ;;
1161	dnl ) # ignore all other values*
1162	dnl ;;
1163	dnl esac
1164	dnl done
1165	dnl IFS="$SaveIFS"
1166	dnl.ve
1167	dnl
1168	dnl D/*
1169	AC_DEFUN([PAC_ARG_CC_G],[
1170	AC_ARG_ENABLE(g,
1171	[--enable-g - Turn on debugging of the package (typically adds -g to COPTIONS)])
1172	export COPTIONS
1173	export enable_g_simple
1174	if test -n "$enable_g" -a "$enable_g" != "no" -a \
1175	"$enable_g_simple" != "done" ; then
1176	enable_g_simple="done"
1177	if test "$enable_g" = "g" -o "$enable_g" = "yes" ; then
1178	COPTIONS="$COPTIONS -g"
1179	fi
1180	fi
1181	])
1182	dnl
1183	dnl Simple version for both options
1184	dnl
1185	AC_DEFUN([PAC_ARG_CC_COMMON],[
1186	PAC_ARG_CC_G
1187	PAC_ARG_STRICT
1188	])
1189	dnl
1190	dnl Eventually, this can be used instead of the funky Fortran stuff to
1191	dnl access the command line from a C routine.
1192	dnl #
1193	dnl # Under IRIX (some version) __Argc and __Argv gave the argc,argv values
1194	dnl #Under linux, __libc_argv and __libc_argc
1195	dnl AC_MSG_CHECKING([for alternative argc,argv names])
1196	dnl AC_TRY_LINK([
1197	dnl extern int __Argc; extern char __Argv;],[return __Argc;],
1198	dnl alt_argv="__Argv")
1199	dnl if test -z "$alt_argv" ; then
1200	dnl AC_TRY_LINK([
1201	dnl extern int __libc_argc; extern char __libc_argv;],[return __lib_argc;],
1202	dnl alt_argv="__lib_argv")
1203	dnl fi
1204	dnl if test -z "$alt_argv" ; then
1205	dnl AC_MSG_RESULT(none found))
1206	dnl else
1207	dnl AC_MSG_RESULT($alt_argv)
1208	dnl fi
1209	dnl
1210	dnl
1211	dnl Check whether we need -fno-common to correctly compile the source code.
1212	dnl This is necessary if global variables are defined without values in
1213	dnl gcc. Here is the test
1214	dnl conftest1.c:
1215	dnl extern int a; int a;
1216	dnl conftest2.c:
1217	dnl extern int a; int main(int argc; char argv[] ){ return a; }*
1218	dnl Make a library out of conftest1.c and try to link with it.
1219	dnl If that fails, recompile it with -fno-common and see if that works.
1220	dnl If so, add -fno-common to CFLAGS
1221	dnl An alternative is to use, on some systems, ranlib -c to force
1222	dnl the system to find common symbols.
1223	dnl
1224	AC_DEFUN([PAC_PROG_C_BROKEN_COMMON],[
1225	AC_CACHE_CHECK([whether global variables handled properly],
1226	ac_cv_prog_cc_globals_work,[
1227	AC_REQUIRE([AC_PROG_RANLIB])
1228	ac_cv_prog_cc_globals_work=no
1229	rm -f libconftest.a
1230	echo 'extern int a; int a;' > conftest1.c
1231	echo 'extern int a; int main( ){ return a; }' > conftest2.c
1232	if ${CC-cc} $CFLAGS -c conftest1.c >conftest.out 2>&1 ; then
1233	if ${AR-ar} cr libconftest.a conftest1.o >/dev/null 2>&1 ; then
1234	if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1235	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >>conftest.out 2>&1 ; then
1236	# Success! C works
1237	ac_cv_prog_cc_globals_work=yes
1238	else
1239	echo "Error linking program with uninitialized global" >&AC_FD_CC
1240	echo "Programs were:" >&AC_FD_CC
1241	echo "conftest1.c:" >&AC_FD_CC
1242	cat conftest1.c >&AC_FD_CC
1243	echo "conftest2.c:" >&AC_FD_CC
1244	cat conftest2.c >&AC_FD_CC
1245	echo "and link line was:" >&AC_FD_CC
1246	echo "${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a" >&AC_FD_CC
1247	echo "with output:" >&AC_FD_CC
1248	cat conftest.out >&AC_FD_CC
1249
1250	# Failure! Do we need -fno-common?
1251	${CC-cc} $CFLAGS -fno-common -c conftest1.c >> conftest.out 2>&1
1252	rm -f libconftest.a
1253	${AR-ar} cr libconftest.a conftest1.o
1254	${RANLIB-:} libconftest.a
1255	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >> conftest.out 2>&1 ; then
1256	ac_cv_prog_cc_globals_work="needs -fno-common"
1257	CFLAGS="$CFLAGS -fno-common"
1258	elif test -n "$RANLIB" ; then
1259	# Try again, with ranlib changed to ranlib -c
1260	# (send output to /dev/null incase this ranlib
1261	# doesn't know -c)
1262	${RANLIB} -c libconftest.a >/dev/null 2>&1
1263	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest.a >> conftest.out 2>&1 ; then
1264	RANLIB="$RANLIB -c"
1265	#else
1266	# # That didn't work
1267	# :
1268	fi
1269	#else
1270	# :
1271	fi
1272	fi
1273	fi
1274	fi
1275	fi
1276	# This is needed for Mac OSX 10.5
1277	rm -rf conftest.dSYM
1278	rm -f conftest* libconftest*])
1279	if test "$ac_cv_prog_cc_globals_work" = no ; then
1280	AC_MSG_WARN([Common symbols not supported on this system!])
1281	fi
1282	])
1283	dnl
1284	dnl
1285	dnl Return the structure alignment in pac_cv_c_struct_align
1286	dnl Possible values include
1287	dnl packed - no padding or alignment, any item may begin on any byte
1288	dnl largest - extent of a structure is a multiple of the largest item;
1289	dnl items are aligned with their size
1290	dnl four - structs padded to a multiple of four
1291	dnl two - like four, but to a multiple of two
1292	dnl eight - If objects containing 8-byte items are padded to a multiple
1293	dnl of eight
1294	dnl largestor4 - like largest, except that for items of size > 4, align
1295	dnl on 4-byte boundaries. E.g., align on the
1296	dnl min(4,max(size of items)).
1297	dnl largestorword - (should be named largestorqword, with qword meaning
1298	dnl quad-word): Like largestor4, but with a special case
1299	dnl for 16-byte items (this is the 16-byte aligned
1300	dnl quad-word-load special case).
1301	dnl
1302	dnl In addition, a "Could not determine alignment" and a
1303	dnl "Multiple cases:" return is possible.
1304	dnl
1305	AC_DEFUN([PAC_C_STRUCT_ALIGNMENT],[
1306	AC_CACHE_CHECK([for C struct alignment],pac_cv_c_struct_align,[
1307	AC_TRY_RUN([
1308	#include <stdio.h>
1309	#ifdef DEBUG_STRUCT_ALIGNMENT
1310	#define DBG(a,b,c) printf( "type %s, size = %d, extent = %d\n", a, b, c )
1311	#define CHECK(cond,flag) if (cond) { flag = 0; \
1312	printf( "Setting %s to false because of %s\n", #flag, #cond ); }
1313	#else
1314	#define DBG(a,b,c)
1315	#define CHECK(cond,flag) if (cond) { flag = 0; }
1316	#endif
1317
1318	int main( int argc, char *argv[] )
1319	{
1320	FILE *cf;
1321	int is_packed = 1;
1322	int is_two = 1;
1323	int is_four = 1;
1324	int is_eight = 1;
1325	int is_largest = 1;
1326	int is_largestorword = 1;
1327	int is_largestor4 = 1;
1328	int numCases;
1329
1330	/* We've seen PowerPC systems where the alignment may
1331	be largest for some items but not for double + int */
1332	struct { char a; int b; } char_int;
1333	struct { short a; int b; } short_int;
1334	struct { char a; short b; } char_short;
1335	struct { char a; long b; } char_long;
1336	struct { char a; float b; } char_float;
1337	struct { char a; double b; } char_double;
1338	struct { char a; int b; char c; } char_int_char;
1339	struct { char a; short b; char c; } char_short_char;
1340	#ifdef HAVE_LONG_DOUBLE
1341	struct { char a; long double b; } char_long_double;
1342	#endif
1343	int size, extent;
1344
1345	size = sizeof(char) + sizeof(int);
1346	extent = sizeof(char_int);
1347	if (size != extent) is_packed = 0;
1348	CHECK((extent % sizeof(int)) != 0, is_largest);
1349	CHECK((extent % sizeof(int)) != 0, is_largestor4);
1350	CHECK((extent % sizeof(int)) != 0, is_largestorword);
1351	if ( (extent % 2) != 0) is_two = 0;
1352	if ( (extent % 4) != 0) is_four = 0;
1353	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1354	DBG("char_int",size,extent);
1355
1356	size = sizeof(short) + sizeof(int);
1357	extent = sizeof(short_int);
1358	if (size != extent) is_packed = 0;
1359	CHECK((extent % sizeof(int)) != 0, is_largest);
1360	CHECK((extent % sizeof(int)) != 0, is_largestor4);
1361	CHECK((extent % sizeof(int)) != 0, is_largestorword);
1362	if ( (extent % 2) != 0) is_two = 0;
1363	if ( (size == 6) && (extent == 8) ) is_two = 0;
1364	if ( (extent % 4) != 0) is_four = 0;
1365	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1366	DBG("short_int",size,extent);
1367
1368	size = sizeof(char) + sizeof(short);
1369	extent = sizeof(char_short);
1370	if (size != extent) is_packed = 0;
1371	CHECK((extent % sizeof(short)) != 0,is_largest);
1372	CHECK((extent % sizeof(short)) != 0,is_largestor4);
1373	CHECK((extent % sizeof(short)) != 0,is_largestorword);
1374	if ( (extent % 2) != 0) is_two = 0;
1375	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1376	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1377	DBG("char_short",size,extent);
1378
1379	size = sizeof(char) + sizeof(long);
1380	extent = sizeof(char_long);
1381	if (size != extent) is_packed = 0;
1382	CHECK((extent % sizeof(long)) != 0,is_largest);
1383	CHECK((extent % 4) != 0,is_largestor4);
1384	CHECK((extent % sizeof(long)) != 0,is_largestorword);
1385	if ( (extent % 2) != 0) is_two = 0;
1386	if ( (extent % 4) != 0) is_four = 0;
1387	if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
1388	DBG("char_long",size,extent);
1389
1390	size = sizeof(char) + sizeof(float);
1391	extent = sizeof(char_float);
1392	if (size != extent) is_packed = 0;
1393	CHECK((extent % sizeof(float)) != 0,is_largest);
1394	CHECK((extent % sizeof(float)) != 0,is_largestor4);
1395	CHECK((extent % sizeof(float)) != 0,is_largestorword);
1396	if ( (extent % 2) != 0) is_two = 0;
1397	if ( (extent % 4) != 0) is_four = 0;
1398	if (sizeof(float) == 8 && (extent % 8) != 0) is_eight = 0;
1399	DBG("char_float",size,extent);
1400
1401	size = sizeof(char) + sizeof(double);
1402	extent = sizeof(char_double);
1403	if (size != extent) is_packed = 0;
1404	CHECK((extent % sizeof(double)) != 0,is_largest);
1405	CHECK((extent % 4) != 0,is_largestor4);
1406	CHECK((extent % sizeof(int)) != 0,is_largestorword);
1407	if ( (extent % 2) != 0) is_two = 0;
1408	if ( (extent % 4) != 0) is_four = 0;
1409	if (sizeof(double) == 8 && (extent % 8) != 0) is_eight = 0;
1410	DBG("char_double",size,extent);
1411
1412	#ifdef HAVE_LONG_DOUBLE
1413	size = sizeof(char) + sizeof(long double);
1414	extent = sizeof(char_long_double);
1415	if (size != extent) is_packed = 0;
1416	CHECK((extent % sizeof(long double)) != 0,is_largest);
1417	CHECK((extent % 4) != 0,is_largestor4);
1418	CHECK((extent % 16) == 0,is_largestor4);
1419	CHECK((extent % sizeof(long double)) != 0,is_largestorword);
1420	/* This case only applies to largestorword if long doubles are 16 bytes */
1421	if (sizeof(long double) != 16) is_largestorword = 0;
1422	if ( (extent % 2) != 0) is_two = 0;
1423	if ( (extent % 4) != 0) is_four = 0;
1424	if (sizeof(long double) >= 8 && (extent % 8) != 0) is_eight = 0;
1425	DBG("char_long-double",size,extent);
1426	#else
1427	/* The special case of largestorword only applies if long double
1428	available */
1429	is_largestorword=0;
1430	#endif
1431
1432	/* char int char helps separate largest from 4/8 aligned */
1433	size = sizeof(char) + sizeof(int) + sizeof(char);
1434	extent = sizeof(char_int_char);
1435	if (size != extent) is_packed = 0;
1436	CHECK((extent % sizeof(int)) != 0,is_largest);
1437	CHECK((extent % sizeof(int)) != 0,is_largestor4);
1438	CHECK((extent % sizeof(int)) != 0,is_largestorword);
1439	if ( (extent % 2) != 0) is_two = 0;
1440	if ( (extent % 4) != 0) is_four = 0;
1441	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1442	DBG("char_int_char",size,extent);
1443
1444	/* char short char helps separate largest from 4/8 aligned */
1445	size = sizeof(char) + sizeof(short) + sizeof(char);
1446	extent = sizeof(char_short_char);
1447	if (size != extent) is_packed = 0;
1448	CHECK((extent % sizeof(short)) != 0,is_largest);
1449	CHECK((extent % sizeof(short)) != 0,is_largestor4);
1450	CHECK((extent % sizeof(short)) != 0,is_largestorword);
1451	if ( (extent % 2) != 0) is_two = 0;
1452	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1453	CHECK((extent == 6) && (size == 4),is_four);
1454	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1455	DBG("char_short_char",size,extent);
1456
1457	/* If aligned mod 8, it will be aligned mod 4 */
1458	if (is_eight) { is_four = 0; is_two = 0; }
1459
1460	if (is_four) is_two = 0;
1461
1462	/* largest superceeds eight */
1463	if (is_largest) is_eight = 0;
1464
1465	/* Tabulate the results */
1466	cf = fopen( "ctest.out", "w" );
1467	numCases = is_packed + is_largest + is_largestorword + is_largestor4 +
1468	is_two + is_four + is_eight;
1469	if (numCases == 0) {
1470	fprintf( cf, "Could not determine alignment\n" );
1471	}
1472	else {
1473	if (numCases != 1) {
1474	fprintf( cf, "Multiple cases:\n" );
1475	}
1476	if (is_packed) fprintf( cf, "packed\n" );
1477	if (is_largest) fprintf( cf, "largest\n" );
1478	if (is_largestorword) fprintf( cf, "largestorword\n" );
1479	if (is_largestor4) fprintf( cf, "largestor4\n" );
1480	if (is_two) fprintf( cf, "two\n" );
1481	if (is_four) fprintf( cf, "four\n" );
1482	if (is_eight) fprintf( cf, "eight\n" );
1483	}
1484	fclose( cf );
1485	return 0;
1486	}],
1487	pac_cv_c_struct_align=`cat ctest.out`
1488	,pac_cv_c_struct_align="unknown",pac_cv_c_struct_align="$CROSS_ALIGN_STRUCT")
1489	rm -f ctest.out
1490	])
1491	if test -z "$pac_cv_c_struct_align" ; then
1492	pac_cv_c_struct_align="unknown"
1493	fi
1494	])
1495	dnl
1496	dnl
1497	dnl Return the integer structure alignment in pac_cv_c_max_integer_align
1498	dnl Possible values include
1499	dnl packed
1500	dnl two
1501	dnl four
1502	dnl eight
1503	dnl
1504	dnl In addition, a "Could not determine alignment" and a "error!"
1505	dnl return is possible.
1506	AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
1507	AC_CACHE_CHECK([for max C struct integer alignment],
1508	pac_cv_c_max_integer_align,[
1509	AC_TRY_RUN([
1510	#include <stdio.h>
1511	#define DBG(a,b,c)
1512	int main( int argc, char *argv[] )
1513	{
1514	FILE *cf;
1515	int is_packed = 1;
1516	int is_two = 1;
1517	int is_four = 1;
1518	int is_eight = 1;
1519	struct { char a; int b; } char_int;
1520	struct { char a; short b; } char_short;
1521	struct { char a; long b; } char_long;
1522	struct { char a; int b; char c; } char_int_char;
1523	struct { char a; short b; char c; } char_short_char;
1524	#ifdef HAVE_LONG_LONG_INT
1525	struct { long long int a; char b; } lli_c;
1526	struct { char a; long long int b; } c_lli;
1527	#endif
1528	int size, extent, extent2;
1529
1530	/* assume max integer alignment isn't 8 if we don't have
1531	* an eight-byte value :)
1532	*/
1533	#ifdef HAVE_LONG_LONG_INT
1534	if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
1535	is_eight = 0;
1536	#else
1537	if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
1538	#endif
1539
1540	size = sizeof(char) + sizeof(int);
1541	extent = sizeof(char_int);
1542	if (size != extent) is_packed = 0;
1543	if ( (extent % 2) != 0) is_two = 0;
1544	if ( (extent % 4) != 0) is_four = 0;
1545	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1546	DBG("char_int",size,extent);
1547
1548	size = sizeof(char) + sizeof(short);
1549	extent = sizeof(char_short);
1550	if (size != extent) is_packed = 0;
1551	if ( (extent % 2) != 0) is_two = 0;
1552	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1553	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1554	DBG("char_short",size,extent);
1555
1556	size = sizeof(char) + sizeof(long);
1557	extent = sizeof(char_long);
1558	if (size != extent) is_packed = 0;
1559	if ( (extent % 2) != 0) is_two = 0;
1560	if ( (extent % 4) != 0) is_four = 0;
1561	if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
1562	DBG("char_long",size,extent);
1563
1564	#ifdef HAVE_LONG_LONG_INT
1565	size = sizeof(char) + sizeof(long long int);
1566	extent = sizeof(lli_c);
1567	extent2 = sizeof(c_lli);
1568	if (size != extent) is_packed = 0;
1569	if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1570	if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1571	if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
1572	is_eight = 0;
1573	#endif
1574
1575	size = sizeof(char) + sizeof(int) + sizeof(char);
1576	extent = sizeof(char_int_char);
1577	if (size != extent) is_packed = 0;
1578	if ( (extent % 2) != 0) is_two = 0;
1579	if ( (extent % 4) != 0) is_four = 0;
1580	if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
1581	DBG("char_int_char",size,extent);
1582
1583	size = sizeof(char) + sizeof(short) + sizeof(char);
1584	extent = sizeof(char_short_char);
1585	if (size != extent) is_packed = 0;
1586	if ( (extent % 2) != 0) is_two = 0;
1587	if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
1588	if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
1589	DBG("char_short_char",size,extent);
1590
1591	/* If aligned mod 8, it will be aligned mod 4 */
1592	if (is_eight) { is_four = 0; is_two = 0; }
1593
1594	if (is_four) is_two = 0;
1595
1596	/* Tabulate the results */
1597	cf = fopen( "ctest.out", "w" );
1598	if (is_packed + is_two + is_four + is_eight == 0) {
1599	fprintf( cf, "Could not determine alignment\n" );
1600	}
1601	else {
1602	if (is_packed + is_two + is_four + is_eight != 1) {
1603	fprintf( cf, "error!\n" );
1604	}
1605	else {
1606	if (is_packed) fprintf( cf, "packed\n" );
1607	if (is_two) fprintf( cf, "two\n" );
1608	if (is_four) fprintf( cf, "four\n" );
1609	if (is_eight) fprintf( cf, "eight\n" );
1610	}
1611	}
1612	fclose( cf );
1613	return 0;
1614	}],
1615	pac_cv_c_max_integer_align=`cat ctest.out`,
1616	pac_cv_c_max_integer_align="unknown",
1617	pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
1618	rm -f ctest.out
1619	])
1620	if test -z "$pac_cv_c_max_integer_align" ; then
1621	pac_cv_c_max_integer_align="unknown"
1622	fi
1623	])
1624	dnl
1625	dnl
1626	dnl Return the floating point structure alignment in
1627	dnl pac_cv_c_max_fp_align.
1628	dnl
1629	dnl Possible values include:
1630	dnl packed
1631	dnl two
1632	dnl four
1633	dnl eight
1634	dnl sixteen
1635	dnl
1636	dnl In addition, a "Could not determine alignment" and a "error!"
1637	dnl return is possible.
1638	AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
1639	AC_CACHE_CHECK([for max C struct floating point alignment],
1640	pac_cv_c_max_fp_align,[
1641	AC_TRY_RUN([
1642	#include <stdio.h>
1643	#define DBG(a,b,c)
1644	int main( int argc, char *argv[] )
1645	{
1646	FILE *cf;
1647	int is_packed = 1;
1648	int is_two = 1;
1649	int is_four = 1;
1650	int is_eight = 1;
1651	int is_sixteen = 1;
1652	struct { char a; float b; } char_float;
1653	struct { float b; char a; } float_char;
1654	struct { char a; double b; } char_double;
1655	struct { double b; char a; } double_char;
1656	#ifdef HAVE_LONG_DOUBLE
1657	struct { char a; long double b; } char_long_double;
1658	struct { long double b; char a; } long_double_char;
1659	struct { long double a; int b; char c; } long_double_int_char;
1660	#endif
1661	int size, extent1, extent2;
1662
1663	size = sizeof(char) + sizeof(float);
1664	extent1 = sizeof(char_float);
1665	extent2 = sizeof(float_char);
1666	if (size != extent1) is_packed = 0;
1667	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1668	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1669	if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1670	is_eight = 0;
1671	DBG("char_float",size,extent1);
1672
1673	size = sizeof(char) + sizeof(double);
1674	extent1 = sizeof(char_double);
1675	extent2 = sizeof(double_char);
1676	if (size != extent1) is_packed = 0;
1677	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1678	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1679	if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1680	is_eight = 0;
1681	DBG("char_double",size,extent1);
1682
1683	#ifdef HAVE_LONG_DOUBLE
1684	size = sizeof(char) + sizeof(long double);
1685	extent1 = sizeof(char_long_double);
1686	extent2 = sizeof(long_double_char);
1687	if (size != extent1) is_packed = 0;
1688	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1689	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1690	if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1691	is_eight = 0;
1692	if (sizeof(long double) > 8 && (extent1 % 16) != 0
1693	&& (extent2 % 16) != 0) is_sixteen = 0;
1694	DBG("char_long-double",size,extent1);
1695
1696	extent1 = sizeof(long_double_int_char);
1697	if ( (extent1 % 2) != 0) is_two = 0;
1698	if ( (extent1 % 4) != 0) is_four = 0;
1699	if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1700	if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1701	#else
1702	is_sixteen = 0;
1703	#endif
1704
1705	if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1706
1707	if (is_eight) { is_four = 0; is_two = 0; }
1708
1709	if (is_four) is_two = 0;
1710
1711	/* Tabulate the results */
1712	cf = fopen( "ctest.out", "w" );
1713	if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1714	fprintf( cf, "Could not determine alignment\n" );
1715	}
1716	else {
1717	if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1718	fprintf( cf, "error!\n" );
1719	}
1720	else {
1721	if (is_packed) fprintf( cf, "packed\n" );
1722	if (is_two) fprintf( cf, "two\n" );
1723	if (is_four) fprintf( cf, "four\n" );
1724	if (is_eight) fprintf( cf, "eight\n" );
1725	if (is_sixteen) fprintf( cf, "sixteen\n" );
1726	}
1727	}
1728	fclose( cf );
1729	return 0;
1730	}],
1731	pac_cv_c_max_fp_align=`cat ctest.out`,
1732	pac_cv_c_max_fp_align="unknown",
1733	pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
1734	rm -f ctest.out
1735	])
1736	if test -z "$pac_cv_c_max_fp_align" ; then
1737	pac_cv_c_max_fp_align="unknown"
1738	fi
1739	])
1740	dnl
1741	dnl
1742	dnl Return the floating point structure alignment in
1743	dnl pac_cv_c_max_double_fp_align.
1744	dnl
1745	dnl Possible values include:
1746	dnl packed
1747	dnl two
1748	dnl four
1749	dnl eight
1750	dnl
1751	dnl In addition, a "Could not determine alignment" and a "error!"
1752	dnl return is possible.
1753	AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
1754	AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
1755	pac_cv_c_max_double_fp_align,[
1756	AC_TRY_RUN([
1757	#include <stdio.h>
1758	#define DBG(a,b,c)
1759	int main( int argc, char *argv[] )
1760	{
1761	FILE *cf;
1762	int is_packed = 1;
1763	int is_two = 1;
1764	int is_four = 1;
1765	int is_eight = 1;
1766	struct { char a; float b; } char_float;
1767	struct { float b; char a; } float_char;
1768	struct { char a; double b; } char_double;
1769	struct { double b; char a; } double_char;
1770	int size, extent1, extent2;
1771
1772	size = sizeof(char) + sizeof(float);
1773	extent1 = sizeof(char_float);
1774	extent2 = sizeof(float_char);
1775	if (size != extent1) is_packed = 0;
1776	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1777	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1778	if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1779	is_eight = 0;
1780	DBG("char_float",size,extent1);
1781
1782	size = sizeof(char) + sizeof(double);
1783	extent1 = sizeof(char_double);
1784	extent2 = sizeof(double_char);
1785	if (size != extent1) is_packed = 0;
1786	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1787	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1788	if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1789	is_eight = 0;
1790	DBG("char_double",size,extent1);
1791
1792	if (is_eight) { is_four = 0; is_two = 0; }
1793
1794	if (is_four) is_two = 0;
1795
1796	/* Tabulate the results */
1797	cf = fopen( "ctest.out", "w" );
1798	if (is_packed + is_two + is_four + is_eight == 0) {
1799	fprintf( cf, "Could not determine alignment\n" );
1800	}
1801	else {
1802	if (is_packed + is_two + is_four + is_eight != 1) {
1803	fprintf( cf, "error!\n" );
1804	}
1805	else {
1806	if (is_packed) fprintf( cf, "packed\n" );
1807	if (is_two) fprintf( cf, "two\n" );
1808	if (is_four) fprintf( cf, "four\n" );
1809	if (is_eight) fprintf( cf, "eight\n" );
1810	}
1811	}
1812	fclose( cf );
1813	return 0;
1814	}],
1815	pac_cv_c_max_double_fp_align=`cat ctest.out`,
1816	pac_cv_c_max_double_fp_align="unknown",
1817	pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
1818	rm -f ctest.out
1819	])
1820	if test -z "$pac_cv_c_max_double_fp_align" ; then
1821	pac_cv_c_max_double_fp_align="unknown"
1822	fi
1823	])
1824	AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
1825	AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
1826	pac_cv_c_max_longdouble_fp_align,[
1827	AC_TRY_RUN([
1828	#include <stdio.h>
1829	#define DBG(a,b,c)
1830	int main( int argc, char *argv[] )
1831	{
1832	FILE *cf;
1833	int is_packed = 1;
1834	int is_two = 1;
1835	int is_four = 1;
1836	int is_eight = 1;
1837	int is_sixteen = 1;
1838	struct { char a; long double b; } char_long_double;
1839	struct { long double b; char a; } long_double_char;
1840	struct { long double a; int b; char c; } long_double_int_char;
1841	int size, extent1, extent2;
1842
1843	size = sizeof(char) + sizeof(long double);
1844	extent1 = sizeof(char_long_double);
1845	extent2 = sizeof(long_double_char);
1846	if (size != extent1) is_packed = 0;
1847	if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1848	if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1849	if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1850	is_eight = 0;
1851	if (sizeof(long double) > 8 && (extent1 % 16) != 0
1852	&& (extent2 % 16) != 0) is_sixteen = 0;
1853	DBG("char_long-double",size,extent1);
1854
1855	extent1 = sizeof(long_double_int_char);
1856	if ( (extent1 % 2) != 0) is_two = 0;
1857	if ( (extent1 % 4) != 0) is_four = 0;
1858	if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1859	if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1860
1861	if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1862
1863	if (is_eight) { is_four = 0; is_two = 0; }
1864
1865	if (is_four) is_two = 0;
1866
1867	*/ Tabulate the results /*
1868	cf = fopen( "ctest.out", "w" );
1869	if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1870	fprintf( cf, "Could not determine alignment\n" );
1871	}
1872	else {
1873	if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1874	fprintf( cf, "error!\n" );
1875	}
1876	else {
1877	if (is_packed) fprintf( cf, "packed\n" );
1878	if (is_two) fprintf( cf, "two\n" );
1879	if (is_four) fprintf( cf, "four\n" );
1880	if (is_eight) fprintf( cf, "eight\n" );
1881	if (is_sixteen) fprintf( cf, "sixteen\n" );
1882	}
1883	}
1884	fclose( cf );
1885	return 0;
1886	}],
1887	pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1888	pac_cv_c_max_longdouble_fp_align="unknown",
1889	pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1890	rm -f ctest.out
1891	])
1892	if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1893	pac_cv_c_max_longdouble_fp_align="unknown"
1894	fi
1895	])
1896	dnl
1897	dnl Other tests assume that there is potentially a maximum alignment
1898	dnl and that if there is no maximum alignment, or a type is smaller than
1899	dnl that value, then we align on the size of the value, with the exception
1900	dnl of the "position-based alignment" rules we test for separately.
1901	dnl
1902	dnl It turns out that these assumptions have fallen short in at least one
1903	dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1904	dnl even when long doubles are aligned on 16-byte boundaries. So this test
1905	dnl is here specifically to handle this case.
1906	dnl
1907	dnl Puts result in pac_cv_c_double_alignment_exception.
1908	dnl
1909	dnl Possible values currently include no and four.
1910	dnl
1911	AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1912	AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1913	pac_cv_c_double_alignment_exception,[
1914	AC_TRY_RUN([
1915	#include <stdio.h>
1916	#define DBG(a,b,c)
1917	*int main( int argc, char argv[] )**
1918	{
1919	*FILE cf;**
1920	struct { char a; double b; } char_double;
1921	struct { double b; char a; } double_char;
1922	int extent1, extent2, align_4 = 0;
1923
1924	extent1 = sizeof(char_double);
1925	extent2 = sizeof(double_char);
1926
1927	*/ we'**re interested in the largest value, will let separate test
1928	* deal with position-based issues.
1929	*/
1930	if (extent1 < extent2) extent1 = extent2;
1931	if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1932	if (extent1 % 4 == 0) {
1933	#ifdef HAVE_MAX_FP_ALIGNMENT
1934	if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1935	#else
1936	align_4 = 1;
1937	#endif
1938	}
1939	}
1940
1941	cf = fopen( "ctest.out", "w" );
1942
1943	if (align_4) fprintf( cf, "four\n" );
1944	else fprintf( cf, "no\n" );
1945
1946	fclose( cf );
1947	return 0;
1948	}],
1949	pac_cv_c_double_alignment_exception=`cat ctest.out`,
1950	pac_cv_c_double_alignment_exception="unknown",
1951	pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1952	rm -f ctest.out
1953	])
1954	if test -z "$pac_cv_c_double_alignment_exception" ; then
1955	pac_cv_c_double_alignment_exception="unknown"
1956	fi
1957	])
1958	dnl
1959	dnl
1960	dnl Test for odd struct alignment rule that only applies max.
1961	dnl padding when double value is at front of type.
1962	dnl Puts result in pac_cv_c_double_pos_align.
1963	dnl
1964	dnl Search for "Power alignment mode" for more details.
1965	dnl
1966	dnl Possible values include yes, no, and unknown.
1967	dnl
1968	AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1969	AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1970	pac_cv_c_double_pos_align,[
1971	AC_TRY_RUN([
1972	#include <stdio.h>
1973	#define DBG(a,b,c)
1974	int main( int argc, char *argv[] )
1975	{
1976	FILE *cf;
1977	int padding_varies_by_pos = 0;
1978	struct { char a; double b; } char_double;
1979	struct { double b; char a; } double_char;
1980	int extent1, extent2;
1981
1982	extent1 = sizeof(char_double);
1983	extent2 = sizeof(double_char);
1984	if (extent1 != extent2) padding_varies_by_pos = 1;
1985
1986	cf = fopen( "ctest.out", "w" );
1987	if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1988	else fprintf( cf, "no\n" );
1989
1990	fclose( cf );
1991	return 0;
1992	}],
1993	pac_cv_c_double_pos_align=`cat ctest.out`,
1994	pac_cv_c_double_pos_align="unknown",
1995	pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
1996	rm -f ctest.out
1997	])
1998	if test -z "$pac_cv_c_double_pos_align" ; then
1999	pac_cv_c_double_pos_align="unknown"
2000	fi
2001	])
2002	dnl
2003	dnl
2004	dnl Test for odd struct alignment rule that only applies max.
2005	dnl padding when long long int value is at front of type.
2006	dnl Puts result in pac_cv_c_llint_pos_align.
2007	dnl
2008	dnl Search for "Power alignment mode" for more details.
2009	dnl
2010	dnl Possible values include yes, no, and unknown.
2011	dnl
2012	AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
2013	AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
2014	pac_cv_c_llint_pos_align,[
2015	AC_TRY_RUN([
2016	#include <stdio.h>
2017	#define DBG(a,b,c)
2018	int main( int argc, char *argv[] )
2019	{
2020	FILE *cf;
2021	int padding_varies_by_pos = 0;
2022	#ifdef HAVE_LONG_LONG_INT
2023	struct { char a; long long int b; } char_llint;
2024	struct { long long int b; char a; } llint_char;
2025	int extent1, extent2;
2026
2027	extent1 = sizeof(char_llint);
2028	extent2 = sizeof(llint_char);
2029	if (extent1 != extent2) padding_varies_by_pos = 1;
2030	#endif
2031
2032	cf = fopen( "ctest.out", "w" );
2033	if (padding_varies_by_pos) fprintf( cf, "yes\n" );
2034	else fprintf( cf, "no\n" );
2035
2036	fclose( cf );
2037	return 0;
2038	}],
2039	pac_cv_c_llint_pos_align=`cat ctest.out`,
2040	pac_cv_c_llint_pos_align="unknown",
2041	pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
2042	rm -f ctest.out
2043	])
2044	if test -z "$pac_cv_c_llint_pos_align" ; then
2045	pac_cv_c_llint_pos_align="unknown"
2046	fi
2047	])
2048
2049	dnl
2050	dnl
2051	dnl/D*
2052	dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
2053	dnl
2054	dnl Synopsis:
2055	dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
2056	dnl
2057	dnl Output Effect:
2058	dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the
2059	dnl headerfiles.
2060	dnl
2061	dnl Approach:
2062	dnl Try to compile a program with the function, but passed with an incorrect
2063	dnl calling sequence. If the compilation fails, then the declaration
2064	dnl is provided within the header files. If the compilation succeeds,
2065	dnl the declaration is required.
2066	dnl
2067	dnl We use a 'double' as the first argument to try and catch varargs
2068	dnl routines that may use an int or pointer as the first argument.
2069	dnl
2070	dnl There is one difficulty - if the compiler has been instructed to
2071	dnl fail on implicitly defined functions, then this test will always
2072	dnl fail.
2073	dnl
2074	dnl D/*
2075	AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
2076	AC_CACHE_CHECK([whether $2 needs a declaration],
2077	pac_cv_func_decl_$2,[
2078	AC_TRY_COMPILE([$1
2079	int $2(double, int, double, const char *);],[int a=$2(1.0,27,1.0,"foo");],
2080	pac_cv_func_decl_$2=yes,pac_cv_func_decl_$2=no)])
2081	if test "$pac_cv_func_decl_$2" = "yes" ; then
2082	changequote(<<,>>)dnl
2083	define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z ], [A-Z__]))dnl*
2084	changequote([, ])dnl
2085	AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
2086	undefine([PAC_FUNC_NAME])
2087	fi
2088	])dnl
2089	dnl
2090	dnl /D*
2091	dnl PAC_CHECK_SIZEOF_DERIVED - Get the size of a user-defined type,
2092	dnl such as a struct
2093	dnl
2094	dnl PAC_CHECK_SIZEOF_DERIVED(shortname,definition,defaultsize)
2095	dnl Like AC_CHECK_SIZEOF, but handles arbitrary types.
2096	dnl Unlike AC_CHECK_SIZEOF, does not define SIZEOF_xxx (because
2097	dnl autoheader can''t handle this case)
2098	dnl D/*
2099	AC_DEFUN([PAC_CHECK_SIZEOF_DERIVED],[
2100	changequote(<<,>>)dnl
2101	define(<<AC_TYPE_NAME>>,translit(sizeof_$1,[a-z ], [A-Z_P]))dnl*
2102	define(<<AC_CV_NAME>>,translit(pac_cv_sizeof_$1,[ ], [_p]))dnl*
2103	changequote([,])dnl
2104	rm -f conftestval
2105	AC_MSG_CHECKING([for size of $1])
2106	AC_CACHE_VAL(AC_CV_NAME,
2107	[AC_TRY_RUN([#include <stdio.h>
2108	main()
2109	{
2110	$2 a;
2111	FILE *f=fopen("conftestval", "w");
2112	if (!f) exit(1);
2113	fprintf(f, "%d\n", sizeof(a));
2114	exit(0);
2115	}],AC_CV_NAME=`cat conftestval`,AC_CV_NAME=0,ifelse([$3],,,AC_CV_NAME=$3))])
2116	AC_MSG_RESULT($AC_CV_NAME)
2117	dnl AC_DEFINE_UNQUOTED(AC_TYPE_NAME,$AC_CV_NAME)
2118	undefine([AC_TYPE_NAME])undefine([AC_CV_NAME])
2119	])
2120	dnl
2121	dnl /D*
2122	dnl PAC_CHECK_SIZEOF_2TYPES - Get the size of a pair of types
2123	dnl
2124	dnl PAC_CHECK_SIZEOF_2TYPES(shortname,type1,type2,defaultsize)
2125	dnl Like AC_CHECK_SIZEOF, but handles pairs of types.
2126	dnl Unlike AC_CHECK_SIZEOF, does not define SIZEOF_xxx (because
2127	dnl autoheader can''t handle this case)
2128	dnl D/*
2129	AC_DEFUN([PAC_CHECK_SIZEOF_2TYPES],[
2130	changequote(<<,>>)dnl
2131	define(<<AC_TYPE_NAME>>,translit(sizeof_$1,[a-z ], [A-Z_P]))dnl*
2132	define(<<AC_CV_NAME>>,translit(pac_cv_sizeof_$1,[ ], [_p]))dnl*
2133	changequote([,])dnl
2134	rm -f conftestval
2135	AC_MSG_CHECKING([for size of $1])
2136	AC_CACHE_VAL(AC_CV_NAME,
2137	[AC_TRY_RUN([#include <stdio.h>
2138	main()
2139	{
2140	$2 a;
2141	$3 b;
2142	FILE *f=fopen("conftestval", "w");
2143	if (!f) return 1; /* avoid exit */
2144	fprintf(f, "%d\n", (int)(sizeof(a) + sizeof(b)));
2145	return 0;
2146	}],AC_CV_NAME=`cat conftestval`,AC_CV_NAME=0,ifelse([$4],,,AC_CV_NAME=$4))])
2147	if test "X$AC_CV_NAME" = "X" ; then
2148	# We have a problem. The test returned a zero status, but no output,
2149	# or we're cross-compiling (or think we are) and have no value for
2150	# this object
2151	:
2152	fi
2153	rm -f conftestval
2154	AC_MSG_RESULT($AC_CV_NAME)
2155	dnl AC_DEFINE_UNQUOTED(AC_TYPE_NAME,$AC_CV_NAME)
2156	undefine([AC_TYPE_NAME])undefine([AC_CV_NAME])
2157	])
2158
2159	dnl
2160	dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
2161	dnl Use the following
2162	dnl #ifndef HAVE_GCC_ATTRIBUTE
2163	dnl #define __attribute__(a)
2164	dnl #endif
2165	dnl If not, define __attribute__(a) as null
2166	dnl
2167	dnl We start by requiring Gcc. Some other compilers accept __attribute__
2168	dnl but generate warning messages, or have different interpretations
2169	dnl (which seems to make __attribute__ just as bad as #pragma)
2170	dnl For example, the Intel icc compiler accepts __attribute__ and
2171	dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
2172	dnl
2173	AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
2174	AC_REQUIRE([AC_PROG_CC_GNU])
2175	if test "$ac_cv_prog_gcc" = "yes" ; then
2176	AC_CACHE_CHECK([whether __attribute__ allowed],
2177	pac_cv_gnu_attr_pure,[
2178	AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
2179	pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
2180	AC_CACHE_CHECK([whether __attribute__((format)) allowed],
2181	pac_cv_gnu_attr_format,[
2182	AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
2183	pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
2184	if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
2185	AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
2186	fi
2187	fi
2188	])
2189	dnl
2190	dnl Check for a broken install (fails to preserve file modification times,
2191	dnl thus breaking libraries.
2192	dnl
2193	dnl Create a library, install it, and then try to link against it.
2194	AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
2195	AC_CACHE_CHECK([whether install breaks libraries],
2196	ac_cv_prog_install_breaks_libs,[
2197	AC_REQUIRE([AC_PROG_RANLIB])
2198	AC_REQUIRE([AC_PROG_INSTALL])
2199	AC_REQUIRE([AC_PROG_CC])
2200	ac_cv_prog_install_breaks_libs=yes
2201	# This is needed for Mac OSX 10.5
2202	rm -rf conftest.dSYM
2203	rm -f libconftest* conftest*
2204	echo 'int foo(int);int foo(int a){return a;}' > conftest1.c
2205	echo 'extern int foo(int); int main( int argc, char **argv){ return foo(0); }' > conftest2.c
2206	if ${CC-cc} $CFLAGS -c conftest1.c >conftest.out 2>&1 ; then
2207	if ${AR-ar} cr libconftest.a conftest1.o >/dev/null 2>&1 ; then
2208	if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
2209	# Anything less than sleep 10, and Mac OS/X (Darwin)
2210	# will claim that install works because ranlib won't complain
2211	sleep 10
2212	libinstall="$INSTALL_DATA"
2213	eval "libinstall=\"$libinstall\""
2214	if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
2215	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
2216	# Success! Install works
2217	ac_cv_prog_install_breaks_libs=no
2218	else
2219	# Failure! Does install -p work?
2220	rm -f libconftest1.a
2221	if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
2222	if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
2223	# Success! Install works
2224	ac_cv_prog_install_breaks_libs="no, with -p"
2225	fi
2226	fi
2227	fi
2228	fi
2229	fi
2230	fi
2231	fi
2232	# This is needed for Mac OSX 10.5
2233	rm -rf conftest.dSYM
2234	rm -f conftest* libconftest*])
2235
2236	if test -z "$RANLIB_AFTER_INSTALL" ; then
2237	RANLIB_AFTER_INSTALL=no
2238	fi
2239	case "$ac_cv_prog_install_breaks_libs" in
2240	yes)
2241	RANLIB_AFTER_INSTALL=yes
2242	;;
2243	"no, with -p")
2244	INSTALL_DATA="$INSTALL_DATA -p"
2245	;;
2246	*)
2247	# Do nothing
2248	:
2249	;;
2250	esac
2251	AC_SUBST(RANLIB_AFTER_INSTALL)
2252	])
2253
2254	#
2255	# determine if the compiler defines a symbol containing the function name
2256	# Inspired by checks within the src/mpid/globus/configure.in file in MPICH2
2257	#
2258	# These tests check not only that the compiler defines some symbol, such
2259	# as __FUNCTION__, but that the symbol correctly names the function.
2260	#
2261	# Defines
2262	# HAVE__FUNC__ (if __func__ defined)
2263	# HAVE_CAP__FUNC__ (if __FUNC__ defined)
2264	# HAVE__FUNCTION__ (if __FUNCTION__ defined)
2265	#
2266	AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
2267	AC_CACHE_CHECK([whether the compiler defines __func__],
2268	pac_cv_have__func__,[
2269	tmp_am_cross=no
2270	AC_RUN_IFELSE([
2271	#include <string.h>
2272	int foo(void);
2273	int foo(void)
2274	{
2275	return (strcmp(__func__, "foo") == 0);
2276	}
2277	int main(int argc, char ** argv)
2278	{
2279	return (foo() ? 0 : 1);
2280	}
2281	], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
2282	if test "$tmp_am_cross" = yes ; then
2283	AC_LINK_IFELSE([
2284	#include <string.h>
2285	int foo(void);
2286	int foo(void)
2287	{
2288	return (strcmp(__func__, "foo") == 0);
2289	}
2290	int main(int argc, char ** argv)
2291	{
2292	return (foo() ? 0 : 1);
2293	}
2294	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2295	fi
2296	])
2297
2298	if test "$pac_cv_have__func__" = "yes" ; then
2299	AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
2300	fi
2301
2302	AC_CACHE_CHECK([whether the compiler defines __FUNC__],
2303	pac_cv_have_cap__func__,[
2304	tmp_am_cross=no
2305	AC_RUN_IFELSE([
2306	#include <string.h>
2307	int foo(void);
2308	int foo(void)
2309	{
2310	return (strcmp(__FUNC__, "foo") == 0);
2311	}
2312	int main(int argc, char ** argv)
2313	{
2314	return (foo() ? 0 : 1);
2315	}
2316	], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
2317	if test "$tmp_am_cross" = yes ; then
2318	AC_LINK_IFELSE([
2319	#include <string.h>
2320	int foo(void);
2321	int foo(void)
2322	{
2323	return (strcmp(__FUNC__, "foo") == 0);
2324	}
2325	int main(int argc, char ** argv)
2326	{
2327	return (foo() ? 0 : 1);
2328	}
2329	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2330	fi
2331	])
2332
2333	if test "$pac_cv_have_cap__func__" = "yes" ; then
2334	AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
2335	fi
2336
2337	AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
2338	pac_cv_have__function__,[
2339	tmp_am_cross=no
2340	AC_RUN_IFELSE([
2341	#include <string.h>
2342	int foo(void);
2343	int foo(void)
2344	{
2345	return (strcmp(__FUNCTION__, "foo") == 0);
2346	}
2347	int main(int argc, char ** argv)
2348	{
2349	return (foo() ? 0 : 1);
2350	}
2351	], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
2352	if test "$tmp_am_cross" = yes ; then
2353	AC_LINK_IFELSE([
2354	#include <string.h>
2355	int foo(void);
2356	int foo(void)
2357	{
2358	return (strcmp(__FUNCTION__, "foo") == 0);
2359	}
2360	int main(int argc, char ** argv)
2361	{
2362	return (foo() ? 0 : 1);
2363	}
2364	], pac_cv_have__func__=yes, pac_cv_have__func__=no)
2365	fi
2366	])
2367
2368	if test "$pac_cv_have__function__" = "yes" ; then
2369	AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
2370	fi
2371
2372	])

Note: See TracBrowser for help on using the browser.

Context Navigation

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

Download in other formats: