ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/group/trunk/OOPSE/ac-tools/aclocal.m4

Comparing trunk/OOPSE/ac-tools/aclocal.m4 (file contents):
Revision 378 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
Revision 747 by gezelter, Fri Sep 5 21:28:52 2003 UTC

#	Line 1 | Line 1
1	<	dnl ACX_SAVE_STATE/ACX_RESTORE_STATE
2	<	dnl Save/restore flags
3	<	dnl
4	<	dnl ACX_SAVE_STATE
5	<	AC_DEFUN(ACX_SAVE_STATE,
6	<	[
7	<	save_CFLAGS=$CFLAGS
8	<	save_CPPFLAGS=$CPPFLAGS
9	<	save_LDFLAGS=$LDFLAGS
10	<	save_LIBS=$LIBS
1	>	dnl
2	>	dnl AC_CHECK_MPI_F90MOD
3	>	dnl
4	>	AC_DEFUN([AC_CHECK_MPI_F90MOD],[
5	>
6	>	AC_ARG_WITH(mpi_f90_mods, [  --with-mpi_f90_mods=<dir>
7	>	Location where MPI f90 modules are installed ],
8	>	mpi_f90_mods="$withval",
9	>	mpi_f90_mods="/usr/local/include/f90choice")
10	>
11	>	AC_MSG_CHECKING(for MPI F90 modules)
12	>	AC_LANG_SAVE()
13	>	AC_LANG([Fortran 90])
14	>	ac_save_F90FLAGS=$F90FLAGS
15	>	AS_IF([test "$mpi_f90_mods"], [F90FLAGS="${F90FLAGS} -I${mpi_f90_mods}"])
16	>	_AC_COMPILE_IFELSE([
17	>	AC_LANG_PROGRAM([
18	>	use mpi
19	>	integer :: ierr
20	>	call MPI_Init(ierr)
21	>	])], [HAVE_MPI_MOD=1], [HAVE_MPI_MOD=0])
22	>
23	>	F90FLAGS=$ac_save_F90FLAGS
24	>	AC_LANG_RESTORE()
25	>
26	>	if test "$HAVE_MPI_MOD" = 1; then
27	>	AC_MSG_RESULT(yes)
28	>	AC_DEFINE(MPI_MOD, 1, [have mpi module])
29	>	MPI_F90_MODS="-I${mpi_f90_mods}"
30	>	AC_SUBST(MPI_F90_MODS)
31	>	else
32	>	AC_MSG_RESULT(no)
33	>	AC_MSG_ERROR([Couldn't locate MPI F90 Modules])
34	>	fi
35	>
36		])
37	<	dnl ACX_RESTORE_STATE
38	<	AC_DEFUN(ACX_RESTORE_STATE,
39	<	[
40	<	CFLAGS=$save_CFLAGS
41	<	CPPFLAGS=$save_CPPFLAGS
42	<	LDFLAGS=$save_LDFLAGS
43	<	LIBS=$save_LIBS
37	>
38	>
39	>	dnl
40	>	dnl AM_PATH_SPRNG
41	>	dnl
42	>	AC_DEFUN([AM_PATH_SPRNG],[
43	>
44	>	AC_ARG_WITH(sprng-prefix, [  --with-sprng-prefix=PREFIX
45	>	Prefix where SPRNG is installed ],
46	>	sprng_prefix="$withval",
47	>	sprng_prefix="/usr/local")
48	>	AC_ARG_WITH(sprng-lib-prefix, [  --with-sprng-lib=PREFIX  SPRNG library directory],
49	>	sprng_lib_prefix="$withval",
50	>	sprng_lib_prefix="/usr/local/lib")
51	>	AC_ARG_WITH(sprng-include-prefix, [  --with-sprng-include=PREFIX
52	>	SPRNG include directory],
53	>	sprng_include_prefix="$withval",
54	>	sprng_include_prefix="/usr/local/include/sprng")
55	>
56	>	if test x$sprng_lib_prefix = x ; then
57	>	sprng_lib_prefix=${sprng_prefix}/lib
58	>	fi
59	>
60	>	if test x$sprng_include_prefix = x ; then
61	>	sprng_include_prefix=${sprng_prefix}/include
62	>	fi
63	>
64	>	AC_MSG_CHECKING(for SPRNG include files in $sprng_include_prefix)
65	>	if test -f ${sprng_include_prefix}/sprng.h; then
66	>	have_sprngincl=yes
67	>	AC_MSG_RESULT(yes)
68	>	else
69	>	have_sprngincl=no
70	>	AC_MSG_RESULT(no)
71	>	AC_MSG_ERROR(Could not locate the SPRNG include files)
72	>	fi
73	>
74	>	AC_MSG_CHECKING(for SPRNG libraries in $sprng_lib_prefix)
75	>	if test -f ${sprng_lib_prefix}/libsprng.a; then
76	>	have_sprnglib=yes
77	>	AC_MSG_RESULT(yes)
78	>	else
79	>	have_sprnglib=no
80	>	AC_MSG_RESULT(no)
81	>	AC_MSG_ERROR(Could not locate the SPRNG libraries)
82	>	fi
83	>
84	>	AC_LANG_SAVE()
85	>	AC_LANG([C])
86	>	ac_save_CPPFLAGS=$CPPFLAGS
87	>	CPPFLAGS="${CPPFLAGS} -I${sprng_include_prefix}"
88	>	ac_save_LDFLAGS=$LDFLAGS
89	>	LDFLAGS="${LDFLAGS} -L${sprng_lib_prefix} -lsprng"
90	>	AC_CHECK_HEADER(sprng.h, [
91	>	AC_CHECK_LIB(sprng,
92	>	init_rng,
93	>	[MKL_LIBDIR="${sprng_lib_prefix}",
94	>	MKL_LIB="-lsprng",
95	>	HAVE_SPRNG="yes"])
96	>	], [MKL_INC="-I${sprng_include_prefix}"])
97	>	CPPFLAGS=$ac_save_CPPFLAGS
98	>	LDFLAGS=$ac_save_LDFLAGS
99	>	AC_LANG_RESTORE()
100	>
101	>	if test x_$HAVE_SPRNG != x_yes; then
102	>	AC_MSG_ERROR(Can't build with SPRNG)
103	>	fi
104	>	AC_SUBST(SPRNG_LIBDIR)
105	>	AC_SUBST(SPRNG_LIB)
106	>	AC_SUBST(SPRNG_INC)
107	>	AC_SUBST(HAVE_SPRNG)
108		])
109
110	+	dnl
111	+	dnl CHECK_MKL
112	+	dnl
113	+	AC_DEFUN([CHECK_MKL],
114	+	[AC_MSG_CHECKING(if MKL is wanted)
115	+	AC_ARG_WITH(mkl,
116	+	[  --with-mkl              Do we want MKL [will check /usr/local/intel/mkl60 /opt/intel/mkl60]],
117	+	[   AC_MSG_RESULT(yes)
118	+	for dir in $withval /usr/local/intel/mkl60 /opt/intel/mkl60; do
119	+	mkldir="$dir"
120	+	if test -f "$dir/include/mkl.h"; then
121	+	found_mkl="yes";
122	+	break;
123	+	fi
124	+	done
125	+	if test x_$found_mkl != x_yes; then
126	+	AC_MSG_ERROR(Cannot find MKL includes)
127	+	else
128	+	printf "MKL includes found in $mkldir/include\n";
129	+	fi
130
131	+	AC_LANG_SAVE()
132	+	AC_LANG([C])
133	+	ac_save_CPPFLAGS=$CPPFLAGS
134	+	CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
135	+	ac_save_LDFLAGS=$LDFLAGS
136	+	LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
137	+	AC_CHECK_HEADER(mkl.h, [
138	+	AC_CHECK_LIB(mkl,
139	+	vslNewStream,
140	+	[MKL_LIBDIR="${mkldir}/lib/32",
141	+	MKL_LIB="-lmkl -lvml -lguide",
142	+	HAVE_MKL="yes"])
143	+	], [MKL_INC="-I${mkldir}/include"])
144	+	CPPFLAGS=$ac_save_CPPFLAGS
145	+	LDFLAGS=$ac_save_LDFLAGS
146	+	AC_LANG_RESTORE()
147	+
148	+	if test x_$HAVE_MKL != x_yes; then
149	+	AC_MSG_ERROR(Can't build with MKL)
150	+	fi
151	+	AC_SUBST(MKL_LIBDIR)
152	+	AC_SUBST(MKL_LIB)
153	+	AC_SUBST(MKL_INC)
154	+	AC_SUBST(HAVE_MKL)
155	+	],
156	+	[
157	+	AC_MSG_RESULT(no)
158	+	])
159	+	])
160	+	dnl
161	+
162		AC_DEFUN(ACX_CHECK_CC_FLAGS,
163		[
164		AC_REQUIRE([AC_PROG_CC])
165		AC_CACHE_CHECK(whether ${CC-cc} accepts $1, ac_$2,
166		[echo 'void f(){}' > conftest.c
167		if test -z "`${CC-cc} $1 -c conftest.c 2>&1`"; then
168	<	ac_$2=yes
168	>	ac_$2=yes
169		else
170	<	ac_$2=no
170	>	ac_$2=no
171		fi
172		rm -f conftest*
173		])
174		if test "$ac_$2" = yes; then
175	<	:
176	<	$3
175	>	:
176	>	$3
177		else
178	<	:
179	<	$4
178	>	:
179	>	$4
180		fi
181		])
182
183	<	dnl **** Check for gcc strength-reduce bug ****
44	<	AC_DEFUN(ACX_GCC_STRENGTH_REDUCE,
183	>	AC_DEFUN(ACX_CHECK_CXX_FLAGS,
184		[
185	<	AC_REQUIRE([AC_PROG_CC])
186	<	AC_CACHE_CHECK([for gcc strength-reduce bug], ac_cv_c_gcc_strength_bug,
187	<	AC_TRY_RUN([
188	<	int main(void) {
189	<	static int Array[[3]];
190	<	unsigned int B = 3;
191	<	int i;
192	<	for(i=0; i<B; i++) Array[[i]] = i - 3;
193	<	exit( Array[[1]] != -2 );
194	<	}
195	<	],
185	>	AC_REQUIRE([AC_PROG_CXX])
186	>	AC_CACHE_CHECK(whether ${CXX-c++} accepts $1, ac_$2,
187	>	[echo 'void f(){}' > conftest.cpp
188	>	if test -z "`${CXX-c++} $1 -c conftest.cpp 2>&1`"; then
189	>	ac_$2=yes
190	>	else
191	>	ac_$2=no
192	>	fi
193	>	rm -f conftest*
194	>	])
195	>	if test "$ac_$2" = yes; then
196	>	:
197	>	$3
198	>	else
199	>	:
200	>	$4
201	>	fi
202	>	])
203
204	<	ac_cv_c_gcc_strength_bug="no",
205	<	ac_cv_c_gcc_strength_bug="yes",
206	<	ac_cv_c_gcc_strength_bug="yes")
207	<	)
208	<
209	<	if test "$ac_cv_c_gcc_strength_bug" = "yes"
210	<	then
211	<	:
212	<	$1
213	<	else
214	<	:
215	<	$2
216	<	fi
204	>	dnl -------------------------------------------------------------------------
205	>	dnl ACX_CHECK_F90_FLAGS()
206	>	dnl
207	>	dnl     Check for optimizer flags the Fortran compiler can use.
208	>	dnl
209	>	AC_DEFUN(ACX_CHECK_F90_FLAGS,
210	>	[
211	>	AC_CACHE_CHECK(whether ${F90-f90} accepts $1, ac_$2,
212	>	[
213	>	AC_LANG_SAVE
214	>	AC_LANG([Fortran 90])
215	>	echo 'program main' > conftest.$ac_ext
216	>	echo 'end program main' >> conftest.$ac_ext
217	>	ac_compile='${F90-f90} -c $1 $F90FLAGS conftest.$ac_ext 1>&AC_FD_CC'
218	>	if AC_TRY_EVAL(ac_compile); then
219	>	ac_$2=yes
220	>	else
221	>	ac_$2=no
222	>	fi
223	>	rm -f conftest*
224	>	AC_LANG_RESTORE()
225		])
226	+	if test "$ac_$2" = yes; then
227	+	:
228	+	$3
229	+	else
230	+	:
231	+	$4
232	+	fi
233	+	])
234	+
235	+	AC_DEFUN(ACX_PROG_GCC_VERSION,
236	+	[
237	+	AC_REQUIRE([AC_PROG_CC])
238	+	AC_CACHE_CHECK(whether we are using gcc $1.$2 or later, ac_cv_prog_gcc_$1_$2,
239	+	[
240	+	dnl The semicolon after "yes" below is to pacify NeXT's syntax-checking cpp.
241	+	cat > conftest.c <<EOF
242	+	#ifdef __GNUC__
243	+	#  if (__GNUC__ > $1) || (__GNUC__ == $1 && __GNUC_MINOR__ >= $2)
244	+	yes;
245	+	#  endif
246	+	#endif
247	+	EOF
248	+	if AC_TRY_COMMAND(${CC-cc} -E conftest.c) | egrep yes >/dev/null 2>&1; then
249	+	ac_cv_prog_gcc_$1_$2=yes
250	+	else
251	+	ac_cv_prog_gcc_$1_$2=no
252	+	fi
253	+	])
254	+	if test "$ac_cv_prog_gcc_$1_$2" = yes; then
255	+	:
256	+	$3
257	+	else
258	+	:
259	+	$4
260	+	fi
261	+	])
262
263	<	dnl **** Checks for FPU arithmetics
264	<	AC_DEFUN(ACX_CHECK_FPU,
263	>
264	>	AC_DEFUN(ACX_PROG_CC_MAXOPT,
265		[
266	<	AC_CACHE_CHECK([for FPU arithmetics type], ac_cv_c_fpu_arithmetics_type,
267	<	AC_TRY_RUN([
78	<	#include <stdio.h>
79	<	#include <string.h>
266	>	AC_REQUIRE([AC_PROG_CC])
267	>	AC_REQUIRE([AC_CANONICAL_HOST])
268
269	<	#define LOG2EA 0.44269504088896340735992
270	<	#define ACCURACY "%1.4f"
269	>	# Try to determine "good" native compiler flags if none specified on command
270	>	# line
271	>	if test "$ac_test_CFLAGS" != "set"; then
272	>	CFLAGS=""
273	>	case "${host_cpu}-${host_os}" in
274
275	<	typedef union {unsigned short s[[4]]; double d;} XTYPE;
275	>	*linux*) if test "$CC" = icc; then
276	>	CFLAGS="-O"
277	>	fi;;
278	>	sparc-solaris2*) if test "$CC" = cc; then
279	>	CFLAGS="-native -fast -xO5 -dalign"
280	>	fi;;
281
282	<	XTYPE X[[]] = {
283	<	{{0,0,0,0}},                          /* Unknown             */
284	<	{{0x3fdc,0x551d,0x94ae,0x0bf8}},      /* Big endian     IEEE */
89	<	{{0x0bf8,0x94ae,0x551d,0x3fdc}},      /* Littile endian IEEE */
90	<	{{0037742,0124354,0122560,0057703}}   /* DEC                 */
91	<	};
92	<
93	<	int main (void)
94	<	{
95	<	int i; char TMPSTR[[1024]]; char LOG2EA_STR[[80]];
96	<	i = 0;
97	<
98	<	sprintf(LOG2EA_STR, ACCURACY, LOG2EA);
99	<
100	<	for (i=3; i >= 0; i--)
101	<	{
102	<	sprintf(TMPSTR, ACCURACY, X[[i]].d);
103	<	if (strcmp(TMPSTR, LOG2EA_STR) == 0) {
104	<	break;
105	<	}
106	<	}
107	<
108	<	exit(i);
109	<	}],
110	<	ac_cv_c_fpu_arithmetics_type="Unknown",
111	<	[case "$?" in
112	<	"1"[)] ac_cv_c_fpu_arithmetics_type="Big endian IEEE" ;;
113	<	"2"[)] ac_cv_c_fpu_arithmetics_type="Little endian IEEE" ;;
114	<	"3"[)] ac_cv_c_fpu_arithmetics_type="DEC" ;;
115	<	esac],
116	<	ac_cv_c_fpu_arithmetics_type="Unknown") )
282	>	alpha*-osf*)  if test "$CC" = cc; then
283	>	CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
284	>	fi;;
285
286	<	case "$ac_cv_c_fpu_arithmetics_type" in
287	<	"DEC")                AC_DEFINE(HAVE_DEC_FPU) ;;
288	<	"Little endian IEEE") AC_DEFINE(HAVE_LIEEE_FPU) ;;
121	<	"Big endian IEEE")    AC_DEFINE(HAVE_BIEEE_FPU) ;;
122	<	esac
286	>	hppa*-hpux*)  if test "$CC" = cc; then
287	>	CFLAGS="-Ae +O3 +Oall"
288	>	fi;;
289
290	<	])
290	>	rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
291	>	CFLAGS="-O3 -qtune=auto -qansialias -w"
292	>	fi;;
293	>	powerpc*-aix*)
294	>	if test "$CC" = cc -o "$CC" = xlc; then
295	>	CFLAGS="-O3 -qtune=auto -qansialias -w"
296	>	echo "*******************************************************"
297	>	echo "*  You have AIX on an unknown powerpc system.  It is  *"
298	>	echo "*  recommended that you use                           *"
299	>	echo "*                                                     *"
300	>	echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
301	>	echo "*                                 ^^^                 *"
302	>	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
303	>	echo "*  PowerPC CPU you have.   For more info, man cc.     *"
304	>	echo "*******************************************************"
305	>	fi;;
306	>	*darwin*)
307	>	if test "$CC" = xlc -o "$CC" = cc; then
308	>	CFLAGS="-O3 -qtune=auto -w"
309	>	echo "*******************************************************"
310	>	echo "*  You have Darwin on an unknown powerpc system.      *"
311	>	echo "*  It is recommended that you use                     *"
312	>	echo "*                                                     *"
313	>	echo "*  CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w    *"
314	>	echo "*                               ^^^                   *"
315	>	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
316	>	echo "*  PowerPC CPU you have.   For more info, man cc.     *"
317	>	echo "*******************************************************"
318	>	fi;;
319	>	esac
320
321	+	# use default flags for gcc on all systems
322	+	if test $ac_cv_prog_gcc = yes; then
323	+	CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
324	+	fi
325
326	<	AC_DEFUN(ACX_ANSI_TYPES,
327	<	[
328	<	dnl **** Check which ANSI integer type is 16 bit
329	<	AC_CACHE_CHECK( "which ANSI integer type is 16 bit", ac_16bit_type,
330	<	AC_TRY_RUN([
331	<	int main(void) {
133	<	if (sizeof(short)==2)
134	<	return(0);
135	<	else if (sizeof(int)==2)
136	<	return(1);
137	<	else
138	<	return(2);
139	<	}], ac_16bit_type="short", ac_16bit_type="int", ac_16bit_type=))
140	<	if test "$ac_16bit_type" = "short"
141	<	then
142	<	T1_AA_TYPE16="short"
143	<	else
144	<	T1_AA_TYPE16="int"
326	>	# test for gcc-specific flags:
327	>	if test $ac_cv_prog_gcc = yes; then
328	>	# -malign-double for x86 systems
329	>	ACX_CHECK_CC_FLAGS(-malign-double,align_double, CFLAGS="$CFLAGS -malign-double")
330	>	# -fstrict-aliasing for gcc-2.95+
331	>	ACX_CHECK_CC_FLAGS(-fstrict-aliasing,fstrict_aliasing, CFLAGS="$CFLAGS -fstrict-aliasing")
332		fi
333
334	<	dnl **** Check which ANSI integer type is 32 bit
335	<	AC_CACHE_CHECK( "which ANSI integer type is 32 bit", ac_32bit_type,
336	<	AC_TRY_RUN([
337	<	int main(void) {
338	<	if (sizeof(int)==4)
339	<	return(0);
340	<	else if (sizeof(long)==4)
341	<	return(1);
342	<	else
343	<	return(2);
344	<	}], ac_32bit_type="int", ac_32bit_type="long", ac_32bit_type=))
345	<	if test "$ac_32bit_type" = "int"
346	<	then
347	<	T1_AA_TYPE32="int"
348	<	else
349	<	T1_AA_TYPE32="long"
334	>	CPU_FLAGS=""
335	>	if test "$GCC" = "yes"; then
336	>	dnl try to guess correct CPU flags, at least for linux
337	>	case "${host_cpu}" in
338	>	i586*)  ACX_CHECK_CC_FLAGS(-mcpu=pentium,cpu_pentium,
339	>	[CPU_FLAGS=-mcpu=pentium],
340	>	[ACX_CHECK_CC_FLAGS(-mpentium,pentium,
341	>	[CPU_FLAGS=-mpentium])])
342	>	;;
343	>	i686*)  ACX_CHECK_CC_FLAGS(-mcpu=pentiumpro,cpu_pentiumpro,
344	>	[CPU_FLAGS=-mcpu=pentiumpro],
345	>	[ACX_CHECK_CC_FLAGS(-mpentiumpro,pentiumpro,
346	>	[CPU_FLAGS=-mpentiumpro])])
347	>	;;
348	>	powerpc*)
349	>	cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
350	>	is60x=`echo $cputype | egrep "^60[0-9]e?$"`
351	>	if test -n "$is60x"; then
352	>	ACX_CHECK_CC_FLAGS(-mcpu=$cputype,m_cpu_60x,
353	>	CPU_FLAGS=-mcpu=$cputype)
354	>	elif test "$cputype" = 750; then
355	>	ACX_PROG_GCC_VERSION(2,95,
356	>	ACX_CHECK_CC_FLAGS(-mcpu=750,m_cpu_750,
357	>	CPU_FLAGS=-mcpu=750))
358	>	fi
359	>	if test -z "$CPU_FLAGS"; then
360	>	ACX_CHECK_CC_FLAGS(-mcpu=powerpc,m_cpu_powerpc,
361	>	CPU_FLAGS=-mcpu=powerpc)
362	>	fi
363	>	if test -z "$CPU_FLAGS"; then
364	>	ACX_CHECK_CC_FLAGS(-mpowerpc,m_powerpc,
365	>	CPU_FLAGS=-mpowerpc)
366	>	fi
367	>	esac
368		fi
369
370	<	dnl **** Check which ANSI integer type is 64 bit
371	<	AC_CACHE_CHECK( "which ANSI integer type is 64 bit", ac_64bit_type,
167	<	AC_TRY_RUN([
168	<	int main(void) {
169	<	if (sizeof(long)==8)
170	<	return(0);
171	<	else
172	<	return(1);
173	<	}], ac_64bit_type="long", ac_64bit_type="<none>", ac_64bit_type=))
174	<	if test "$ac_64bit_type" = "long"
175	<	then
176	<	T1_AA_TYPE64="long"
177	<	else
178	<	T1_AA_TYPE64=
370	>	if test -n "$CPU_FLAGS"; then
371	>	CFLAGS="$CFLAGS $CPU_FLAGS"
372		fi
180	–	])
373
374	<	dnl **** Check for buggy realloc()
375	<	AC_DEFUN(ACX_CHECK_REALLOC,
376	<	[
377	<	AC_CACHE_CHECK([whether realloc is buggy], ac_cv_c_realloc_bug,
378	<	AC_TRY_RUN([
379	<	#include <stdio.h>
380	<	#include <stdlib.h>
381	<	int main(void) {
382	<	void *ptr;
383	<	ptr = NULL;
192	<	ptr = realloc(ptr, 1);
193	<	exit(ptr == NULL);
194	<	}],
195	<	ac_cv_c_realloc_bug="no",
196	<	ac_cv_c_realloc_bug="yes",
197	<	ac_cv_c_realloc_bug="yes") )
198	<	if test "$ac_cv_c_realloc_bug" = "yes"
199	<	then
200	<	:
201	<	$1
202	<	else
203	<	:
204	<	$2
205	<	fi
206	<	])
374	>	if test -z "$CFLAGS"; then
375	>	echo ""
376	>	echo "********************************************************"
377	>	echo "* WARNING: Don't know the best CFLAGS for this system  *"
378	>	echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
379	>	echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
380	>	echo "********************************************************"
381	>	echo ""
382	>	CFLAGS="-O3"
383	>	fi
384
385	+	ACX_CHECK_CC_FLAGS(${CFLAGS}, guessed_cflags, , [
386	+	echo ""
387	+	echo "********************************************************"
388	+	echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
389	+	echo "* your compiler.                                       *"
390	+	echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
391	+	echo "********************************************************"
392	+	echo ""
393	+	CFLAGS=""
394	+	])
395
209	–	dnl ICE_CHECK_DECL (FUNCTION, HEADER-FILE...)
210	–	dnl -----------------------------------------
211	–	dnl
212	–	dnl If FUNCTION is available, define `HAVE_FUNCTION'.  If it is declared
213	–	dnl in one of the headers named in the whitespace-separated list
214	–	dnl HEADER_FILE, define `HAVE_FUNCTION_DECL` (in all capitals).
215	–	dnl
216	–	AC_DEFUN(ICE_CHECK_DECL,
217	–	[
218	–	changequote(,)dnl
219	–	ice_tr=`echo $1 | tr '[a-z]' '[A-Z]'`
220	–	changequote([,])dnl
221	–	ice_have_tr=HAVE_$ice_tr
222	–	ice_have_decl_tr=${ice_have_tr}_DECL
223	–	ice_have_$1=no
224	–	AC_CHECK_FUNCS($1, ice_have_$1=yes)
225	–	if test "${ice_have_$1}" = yes; then
226	–	AC_MSG_CHECKING(for $1 declaration in $2)
227	–	AC_CACHE_VAL(ice_cv_have_$1_decl,
228	–	[
229	–	ice_cv_have_$1_decl=no
230	–	changequote(,)dnl
231	–	ice_re_params='[a-zA-Z_][a-zA-Z0-9_]*'
232	–	ice_re_word='(^|[^a-zA-Z_0-9_])'
233	–	changequote([,])dnl
234	–	for header in $2; do
235	–	# Check for ordinary declaration
236	–	AC_EGREP_HEADER([${ice_re_word}$1 *\(], $header,
237	–	ice_cv_have_$1_decl=yes)
238	–	if test "$ice_cv_have_$1_decl" = yes; then
239	–	break
396		fi
241	–	# Check for "fixed" declaration like "getpid _PARAMS((int))"
242	–	AC_EGREP_HEADER([${ice_re_word}$1 *$ice_re_params\(\(], $header,
243	–	ice_cv_have_$1_decl=yes)
244	–	if test "$ice_cv_have_$1_decl" = yes; then
245	–	break
246	–	fi
247	–	done
397		])
249	–	AC_MSG_RESULT($ice_cv_have_$1_decl)
250	–	if test "$ice_cv_have_$1_decl" = yes; then
251	–	AC_DEFINE_UNQUOTED(${ice_have_decl_tr})
252	–	fi
253	–	fi
254	–	])dnl
398
399	<	dnl --- *@-mdw_CHECK_MANYLIBS-@* ---
257	<	dnl
258	<	dnl Author:     Mark Wooding
259	<	dnl
260	<	dnl Synopsis:   mdw_CHECK_MANYLIBS(FUNC, LIBS, [IF-FOUND], [IF-NOT-FOUND])
261	<	dnl
262	<	dnl Arguments:  FUNC = a function to try to find
263	<	dnl             LIBS = a whitespace-separated list of libraries to search
264	<	dnl             IF-FOUND = what to do when the function is found
265	<	dnl             IF-NOT-FOUND = what to do when the function isn't found
266	<	dnl
267	<	dnl Use:        Searches for a library which defines FUNC.  It first tries
268	<	dnl             without any libraries; then it tries each library specified
269	<	dnl             in LIBS in turn.  If it finds a match, it adds the
270	<	dnl             appropriate library to `LIBS'.
271	<	dnl
272	<	dnl             This is particularly handy under DIREIX: if you link with
273	<	dnl             `-lnsl' then you get non-NIS-aware versions of getpwnam and
274	<	dnl             so on, which is clearly a Bad Thing.
275	<	dnl
276	<	dnl Modified:   by Evgeny Stambulchik to add (found) libraries to `LIBS'
277	<	dnl             *only* if `IF-FOUND' is absent. As well, if no additional
278	<	dnl             library is needed for `FUNC', `mdw_cv_lib_$1' sets to "".
279	<
280	<	AC_DEFUN(mdw_CHECK_MANYLIBS,
281	<	[AC_CACHE_CHECK([for library containing $1], [mdw_cv_lib_$1],
282	<	[mdw_save_LIBS="$LIBS"
283	<	mdw_cv_lib_$1="no"
284	<	AC_TRY_LINK(,[$1()], [mdw_cv_lib_$1="none required"])
285	<	test "$mdw_cv_lib_$1" = "no" && for i in $2; do
286	<	LIBS="-l$i $mdw_save_LIBS"
287	<	AC_TRY_LINK(,[$1()],
288	<	[mdw_cv_lib_$1="-l$i"
289	<	break])
290	<	done
291	<	LIBS="$mdw_save_LIBS"])
292	<	if test "$mdw_cv_lib_$1" != "no"; then
293	<	if test "x$3" != "x"; then
294	<	test "$mdw_cv_lib_$1" = "none required" && mdw_cv_lib_$1=""
295	<	$3
296	<	else
297	<	test "$mdw_cv_lib_$1" = "none required" || LIBS="$mdw_cv_lib_$1 $LIBS"
298	<	fi
299	<	else :
300	<	$4
301	<	fi])
302	<
303	<
304	<	dnl ACX_CHECK_MOTIF
305	<	dnl --------------
306	<	AC_DEFUN(ACX_CHECK_MOTIF,
399	>	AC_DEFUN(ACX_PROG_CXX_MAXOPT,
400		[
401	<	AC_REQUIRE([AC_PATH_XTRA])
402	<	AC_ARG_WITH(motif_library,
310	<	[  --with-motif-library=OBJ     use OBJ as Motif library [-lXm]],
311	<	motif_library="$withval")
312	<	if test "x$motif_library" = "x"
313	<	then
314	<	motif_library=-lXm
315	<	fi
401	>	AC_REQUIRE([AC_PROG_CXX])
402	>	AC_REQUIRE([AC_CANONICAL_HOST])
403
404	<	ACX_SAVE_STATE
405	<
406	<	AC_CACHE_CHECK([for a Motif >= $1 compatible API], acx_cv_motif,
407	<	AC_CACHE_VAL(acx_cv_motif_library, acx_cv_motif_library=$motif_library)
408	<	LIBS="$acx_cv_motif_library $GUI_LIBS"
322	<	CFLAGS="$X_CFLAGS $CFLAGS"
323	<	CPPFLAGS="$X_CFLAGS $CPPFLAGS"
324	<	LDFLAGS="$X_LIBS $LDFLAGS"
325	<	AC_TRY_RUN([
326	<	#include <Xm/XmAll.h>
327	<	int main(void) {
328	<	int vlibn, vincn;
329	<	vincn = XmVersion;
330	<	XmRegisterConverters();
331	<	vlibn = xmUseVersion;
332	<	if (vincn < [$1]) {
333	<	exit(1);
334	<	}
335	<	if (vincn != vlibn) {
336	<	exit(2);
337	<	}
338	<	exit(0);
339	<	}
340	<	],
404	>	# Try to determine "good" native compiler flags if none specified on command
405	>	# line
406	>	if test "$ac_test_CXXFLAGS" != "set"; then
407	>	CXXFLAGS=""
408	>	case "${host_cpu}-${host_os}" in
409
410	<	acx_cv_motif="yes",
411	<	acx_cv_motif="no",
412	<	acx_cv_motif="no"
413	<	)
414	<	)
415	<	if test "$acx_cv_motif" = "yes"
416	<	then
417	<	AC_DEFINE(HAVE_MOTIF)
418	<	MOTIF_LIB="$acx_cv_motif_library"
419	<	$2
420	<	dnl **** Check whether Motif is actually Lesstif
421	<	ICE_CHECK_LESSTIF
422	<	dnl **** Check whether _XmVersionString[] can be referred to
423	<	ACX_CHECK_XMVERSIONSTRING
424	<	else
425	<	MOTIF_LIB=
426	<	$3
427	<	fi
428	<
429	<	ACX_RESTORE_STATE
430	<	])dnl
431	<
432	<
433	<	dnl ICE_CHECK_LESSTIF
434	<	dnl -----------------
435	<	dnl
436	<	dnl Define `HAVE_LESSTIF' if the Motif library is actually a LessTif library
437	<	dnl
438	<	AC_DEFUN(ICE_CHECK_LESSTIF,
439	<	[
440	<	AC_MSG_CHECKING(whether the Motif library is actually a LessTif library)
441	<	AC_CACHE_VAL(ice_cv_have_lesstif,
442	<	AC_EGREP_CPP(yes,
443	<	[#include <Xm/Xm.h>
444	<	#ifdef LesstifVersion
445	<	yes
446	<	#endif
447	<	], ice_cv_have_lesstif=yes, ice_cv_have_lesstif=no))
448	<	AC_MSG_RESULT($ice_cv_have_lesstif)
449	<	if test "$ice_cv_have_lesstif" = yes; then
382	<	AC_DEFINE(HAVE_LESSTIF)
383	<	fi
384	<	])dnl
385	<
386	<
387	<	dnl ACX_CHECK_XMVERSIONSTRING
388	<	dnl --------------
389	<	AC_DEFUN(ACX_CHECK_XMVERSIONSTRING,
390	<	[
391	<	AC_CACHE_CHECK([whether _XmVersionString[] can be referred to],
392	<	acx_cv__xmversionstring,
393	<	AC_TRY_LINK([#include <stdio.h>],
394	<	[extern char _XmVersionString[[]]; printf("%s\n", _XmVersionString);],
395	<	[acx_cv__xmversionstring="yes"],
396	<	[acx_cv__xmversionstring="no"]
397	<	)
398	<	)
399	<	if test "$acx_cv__xmversionstring" = "yes"
400	<	then
401	<	AC_DEFINE(HAVE__XMVERSIONSTRING)
402	<	$1
403	<	else
404	<	:
405	<	$2
406	<	fi
407	<	])dnl
408	<
409	<
410	<	dnl ACX_CHECK_T1LIB
411	<	dnl --------------
412	<	AC_DEFUN(ACX_CHECK_T1LIB,
413	<	[
414	<	AC_CACHE_CHECK([for T1lib >= $1], acx_cv_t1lib,
415	<	ACX_SAVE_STATE
416	<	LIBS="-lt1 -lm $LIBS"
417	<	AC_TRY_RUN([
418	<	#include <string.h>
419	<	#include <t1lib.h>
420	<	int main(void) {
421	<	char *vlib;
422	<	vlib = T1_GetLibIdent();
423	<	if (strcmp(vlib, "[$1]") < 0) {
424	<	exit(1);
425	<	}
426	<	exit(0);
427	<	}
428	<	],
429	<
430	<	acx_cv_t1lib="yes",
431	<	acx_cv_t1lib="no",
432	<	acx_cv_t1lib="no"
433	<	)
434	<	ACX_RESTORE_STATE
435	<	)
436	<	if test "$acx_cv_t1lib" = "yes"
437	<	then
438	<	T1_LIB="-lt1"
439	<	$2
440	<	else
441	<	T1_LIB=
442	<	$3
443	<	fi
444	<	])dnl
445	<
446	<	dnl ACX_CHECK_ZLIB
447	<	dnl --------------
448	<	AC_DEFUN(ACX_CHECK_ZLIB,
449	<	[
450	<	AC_ARG_WITH(zlib_library,
451	<	[  --with-zlib-library=OBJ      use OBJ as ZLIB library [-lz]],
452	<	zlib_library="$withval")
453	<	if test "x$zlib_library" = "x"
454	<	then
455	<	zlib_library=-lz
410	>	*linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
411	>	CXXFLAGS="-O"
412	>	fi;;
413	>	sparc-solaris2*) if test "$CXX" = CC; then
414	>	CXXFLAGS="-native -fast -xO5 -dalign"
415	>	fi;;
416	>	rs6000*-aix*)  if test "$CXX" = xlC; then
417	>	CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
418	>	fi;;
419	>	powerpc*-aix*)
420	>	if test "$CXX" = xlC; then
421	>	CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
422	>	echo "*******************************************************"
423	>	echo "*  You have AIX on an unknown powerpc system.  It is  *"
424	>	echo "*  recommended that you use                           *"
425	>	echo "*                                                     *"
426	>	echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
427	>	echo "*                                 ^^^                 *"
428	>	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
429	>	echo "*  PowerPC CPU you have.   For more info, man cc.     *"
430	>	echo "*******************************************************"
431	>	fi;;
432	>	*darwin*)
433	>	if test "$CXX" = xlC; then
434	>	CXXFLAGS="-O3 -qtune=auto -qansialias -w"
435	>	echo "*******************************************************"
436	>	echo "*  You have AIX on an unknown powerpc system.  It is  *"
437	>	echo "*  recommended that you use                           *"
438	>	echo "*                                                     *"
439	>	echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
440	>	echo "*                                 ^^^                 *"
441	>	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
442	>	echo "*  PowerPC CPU you have.   For more info, man cc.     *"
443	>	echo "*******************************************************"
444	>	fi;;
445	>	esac
446	>
447	>	# use default flags for gcc on all systems
448	>	if test $ac_cv_prog_gcc = yes; then
449	>	CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
450		fi
451
452	<	AC_CACHE_CHECK([for zlib >= $1], acx_cv_zlib,
453	<	AC_CACHE_VAL(acx_cv_zlib_library, acx_cv_zlib_library=$zlib_library)
454	<	ACX_SAVE_STATE
455	<	LIBS="$acx_cv_zlib_library $LIBS"
456	<	AC_TRY_RUN([
457	<	#include <string.h>
458	<	#include <zlib.h>
465	<	int main(void) {
466	<	char *vlib, *vinc;
467	<	vlib = zlibVersion();
468	<	vinc = ZLIB_VERSION;
469	<	if (strcmp(vinc, "[$1]") < 0) {
470	<	exit(1);
471	<	}
472	<	if (strcmp(vinc, vlib) != 0) {
473	<	exit(2);
474	<	}
475	<	exit(0);
476	<	}
477	<	],
452	>	# test for gcc-specific flags:
453	>	if test $ac_cv_prog_gcc = yes; then
454	>	# -malign-double for x86 systems
455	>	ACX_CHECK_CXX_FLAGS(-malign-double,align_double, CXXFLAGS="$CXXFLAGS -malign-double")
456	>	# -fstrict-aliasing for gcc-2.95+
457	>	ACX_CHECK_CXX_FLAGS(-fstrict-aliasing,fstrict_aliasing, CXXFLAGS="$CXXFLAGS -fstrict-aliasing")
458	>	fi
459
460	<	acx_cv_zlib="yes",
461	<	acx_cv_zlib="no",
462	<	acx_cv_zlib="no"
463	<	)
464	<	ACX_RESTORE_STATE
465	<	)
466	<	if test "$acx_cv_zlib" = "yes"
467	<	then
468	<	Z_LIB="$acx_cv_zlib_library"
469	<	$2
470	<	else
471	<	Z_LIB=
472	<	$3
460	>	CPU_FLAGS=""
461	>	if test "$GCC" = "yes"; then
462	>	dnl try to guess correct CPU flags, at least for linux
463	>	case "${host_cpu}" in
464	>	i586*)  ACX_CHECK_CC_FLAGS(-mcpu=pentium,cpu_pentium,
465	>	[CPU_FLAGS=-mcpu=pentium],
466	>	[ACX_CHECK_CXX_FLAGS(-mpentium,pentium,
467	>	[CPU_FLAGS=-mpentium])])
468	>	;;
469	>	i686*)  ACX_CHECK_CXX_FLAGS(-mcpu=pentiumpro,cpu_pentiumpro,
470	>	[CPU_FLAGS=-mcpu=pentiumpro],
471	>	[ACX_CHECK_CXX_FLAGS(-mpentiumpro,pentiumpro,
472	>	[CPU_FLAGS=-mpentiumpro])])
473	>	;;
474	>	powerpc*)
475	>	cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
476	>	is60x=`echo $cputype | egrep "^60[0-9]e?$"`
477	>	if test -n "$is60x"; then
478	>	ACX_CHECK_CXX_FLAGS(-mcpu=$cputype,m_cpu_60x,
479	>	CPU_FLAGS=-mcpu=$cputype)
480	>	elif test "$cputype" = 750; then
481	>	ACX_PROG_GCC_VERSION(2,95,
482	>	ACX_CHECK_CXX_FLAGS(-mcpu=750,m_cpu_750,
483	>	CPU_FLAGS=-mcpu=750))
484	>	fi
485	>	if test -z "$CPU_FLAGS"; then
486	>	ACX_CHECK_CXX_FLAGS(-mcpu=powerpc,m_cpu_powerpc,
487	>	CPU_FLAGS=-mcpu=powerpc)
488	>	fi
489	>	if test -z "$CPU_FLAGS"; then
490	>	ACX_CHECK_CXX_FLAGS(-mpowerpc,m_powerpc,
491	>	CPU_FLAGS=-mpowerpc)
492	>	fi
493	>	esac
494		fi
493	–	])dnl
495
496	<	dnl ACX_CHECK_JPEG
497	<	dnl --------------
497	<	AC_DEFUN(ACX_CHECK_JPEG,
498	<	[
499	<	AC_ARG_WITH(jpeg_library,
500	<	[  --with-jpeg-library=OBJ      use OBJ as JPEG library [-ljpeg]],
501	<	jpeg_library="$withval")
502	<	if test "x$jpeg_library" = "x"
503	<	then
504	<	jpeg_library=-ljpeg
496	>	if test -n "$CPU_FLAGS"; then
497	>	CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
498		fi
506	–
507	–	AC_CACHE_CHECK([for IJG JPEG software >= $1], acx_cv_jpeg,
508	–	AC_CACHE_VAL(acx_cv_jpeg_library, acx_cv_jpeg_library=$jpeg_library)
509	–	ACX_SAVE_STATE
510	–	LIBS="$acx_cv_jpeg_library $LIBS"
511	–	AC_TRY_RUN([
512	–	#include <stdio.h>
513	–	#include <jpeglib.h>
514	–	int main(void) {
515	–	int vinc;
516	–	struct jpeg_compress_struct cinfo;
517	–	jpeg_create_compress(&cinfo);
518	–	vinc = JPEG_LIB_VERSION;
519	–	if (vinc < [$1]) {
520	–	exit(1);
521	–	}
522	–	exit(0);
523	–	}
524	–	],
499
500	<	acx_cv_jpeg="yes",
501	<	acx_cv_jpeg="no",
502	<	acx_cv_jpeg="no"
503	<	)
504	<	ACX_RESTORE_STATE
505	<	)
506	<	if test "$acx_cv_jpeg" = "yes"
507	<	then
508	<	JPEG_LIB=$acx_cv_jpeg_library
535	<	$2
536	<	else
537	<	JPEG_LIB=
538	<	$3
500	>	if test -z "$CXXFLAGS"; then
501	>	echo ""
502	>	echo "**********************************************************"
503	>	echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
504	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
505	>	echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
506	>	echo "**********************************************************"
507	>	echo ""
508	>	CXXFLAGS="-O3"
509		fi
540	–	])dnl
510
511	<	dnl ACX_CHECK_PNG
512	<	dnl --------------
513	<	AC_DEFUN(ACX_CHECK_PNG,
511	>	ACX_CHECK_CXX_FLAGS(${CXXFLAGS}, guessed_cxxflags, , [
512	>	echo ""
513	>	echo "**********************************************************"
514	>	echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
515	>	echo "* your compiler.                                         *"
516	>	echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
517	>	echo "**********************************************************"
518	>	echo ""
519	>	CXXFLAGS=""
520	>	])
521	>
522	>	fi
523	>	])
524	>
525	>	AC_DEFUN(ACX_PROG_F90_MAXOPT,
526		[
527	<	AC_ARG_WITH(png_library,
528	<	[  --with-png-library=OBJ       use OBJ as PNG library [-lpng]],
548	<	png_library="$withval")
549	<	if test "x$png_library" = "x"
550	<	then
551	<	png_library=-lpng
552	<	fi
527	>	AC_REQUIRE([AC_PROG_F90])
528	>	AC_REQUIRE([AC_CANONICAL_HOST])
529
530	<	AC_CACHE_CHECK([for libpng >= $1], acx_cv_png,
531	<	AC_CACHE_VAL(acx_cv_png_library, acx_cv_png_library=$png_library)
532	<	ACX_SAVE_STATE
533	<	LIBS="$acx_cv_png_library $Z_LIB $LIBS"
534	<	AC_TRY_RUN([
559	<	#include <string.h>
560	<	#include <png.h>
561	<	int main(void) {
562	<	char *vlib, *vinc;
563	<	vlib = png_libpng_ver;
564	<	vinc = PNG_LIBPNG_VER_STRING;
565	<	if (strcmp(vinc, "[$1]") < 0) {
566	<	exit(1);
567	<	}
568	<	if (strcmp(vinc, vlib) != 0) {
569	<	exit(2);
570	<	}
571	<	exit(0);
572	<	}
573	<	],
530	>	# Try to determine "good" native compiler flags if none specified on command
531	>	# line
532	>	if test "$ac_test_F90FLAGS" != "set"; then
533	>	F90FLAGS=""
534	>	case "${host_cpu}-${host_os}" in
535
536	<	acx_cv_png="yes",
537	<	acx_cv_png="no",
538	<	acx_cv_png="no"
539	<	)
540	<	ACX_RESTORE_STATE
541	<	)
542	<	if test "$acx_cv_png" = "yes"
543	<	then
544	<	PNG_LIB="$acx_cv_png_library"
545	<	$2
546	<	else
547	<	PNG_LIB=
548	<	$3
536	>	*linux*) if test "$F90" = ifc; then
537	>	F90FLAGS="-O"
538	>	fi;;
539	>	rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
540	>	F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
541	>	fi;;
542	>	powerpc*-aix*)
543	>	if test "$F90" = f90 -o "$F90" = xlf90; then
544	>	F90FLAGS="-O3 -qarch=ppc -qansialias -w"
545	>	echo "*******************************************************"
546	>	echo "*  You have AIX on an unknown powerpc system.  It is  *"
547	>	echo "*  recommended that you use                           *"
548	>	echo "*                                                     *"
549	>	echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
550	>	echo "*                                 ^^^                 *"
551	>	echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
552	>	echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
553	>	echo "*******************************************************"
554	>	fi;;
555	>	*darwin*)
556	>	if test "$F90" = f90 -o "$F90" = xlf90; then
557	>	F90FLAGS="-O3 -qtune=auto -w"
558	>	echo "*********************************************************"
559	>	echo "*  You have Darwin on an unknown powerpc system.  It is *"
560	>	echo "*  recommended that you use                             *"
561	>	echo "*                                                       *"
562	>	echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w    *"
563	>	echo "*                                 ^^^                   *"
564	>	echo "*  where xxx is 601, 603, 604, or whatever kind of      *"
565	>	echo "*  PowerPC CPU you have.   For more info, man xlf.      *"
566	>	echo "*********************************************************"
567	>	fi;;
568	>	esac
569	>
570	>	if test -n "$CPU_FLAGS"; then
571	>	F90FLAGS="$F90FLAGS $CPU_FLAGS"
572		fi
589	–	])dnl
573
574	<	dnl ACX_CHECK_TIFF
575	<	dnl --------------
576	<	AC_DEFUN(ACX_CHECK_TIFF,
577	<	[
578	<	AC_ARG_WITH(tiff_library,
579	<	[  --with-tiff-library=OBJ      use OBJ as TIFF library [-ltiff]],
580	<	tiff_library="$withval")
581	<	if test "x$tiff_library" = "x"
582	<	then
600	<	tiff_library=-ltiff
574	>	if test -z "$F90FLAGS"; then
575	>	echo ""
576	>	echo "**********************************************************"
577	>	echo "* WARNING: Don't know the best F90FLAGS for this system  *"
578	>	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
579	>	echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
580	>	echo "**********************************************************"
581	>	echo ""
582	>	F90FLAGS="-O3"
583		fi
584
585	<	AC_CACHE_CHECK([for libtiff >= $1], acx_cv_tiff,
586	<	AC_CACHE_VAL(acx_cv_tiff_library, acx_cv_tiff_library=$tiff_library)
587	<	ACX_SAVE_STATE
588	<	LIBS="$acx_cv_tiff_library $JPEG_LIB $Z_LIB -lm $LIBS"
589	<	AC_TRY_RUN([
590	<	#include <tiffio.h>
591	<	int main(void) {
592	<	int vinc;
593	<	(void) TIFFGetVersion();
594	<	vinc = TIFFLIB_VERSION;
613	<	if (vinc < [$1]) {
614	<	exit(1);
615	<	}
616	<	exit(0);
617	<	}
618	<	],
585	>	ACX_CHECK_F90_FLAGS(${F90FLAGS}, guessed_f90flags, , [
586	>	echo ""
587	>	echo "**********************************************************"
588	>	echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
589	>	echo "* your compiler.                                         *"
590	>	echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
591	>	echo "**********************************************************"
592	>	echo ""
593	>	F90FLAGS=""
594	>	])
595
596	<	acx_cv_tiff="yes",
597	<	acx_cv_tiff="no",
622	<	acx_cv_tiff="no"
623	<	)
624	<	ACX_RESTORE_STATE
625	<	)
626	<	if test "$acx_cv_tiff" = "yes"
627	<	then
628	<	TIFF_LIB="$acx_cv_tiff_library"
629	<	$2
630	<	else
631	<	TIFF_LIB=
632	<	$3
633	<	fi
634	<	])dnl
596	>	fi
597	>	])
598
599	<	dnl ACX_CHECK_PDFLIB
637	<	dnl --------------
638	<	AC_DEFUN(ACX_CHECK_PDFLIB,
599	>	AC_DEFUN(ACX_PROG_F90_PREPFLAG,
600		[
601	<	AC_ARG_WITH(pdf_library,
602	<	[  --with-pdf-library=OBJ       use OBJ as PDFlib library [-lpdf]],
603	<	pdf_library="$withval")
604	<	if test "x$pdf_library" = "x"
605	<	then
606	<	pdf_library=-lpdf
601	>	AC_REQUIRE([AC_PROG_F90])
602	>	AC_REQUIRE([AC_CANONICAL_HOST])
603	>
604	>	# Try to determine native compiler flags that allow us to use F90 suffix
605	>	# for preprocessed f90 source.
606	>
607	>	if test "$ac_test_PREPFLAG" != "set"; then
608	>	PREPFLAG=""
609	>	case "${host_cpu}-${host_os}" in
610	>
611	>	*linux*) if test "$F90" = ifc; then
612	>	PREPFLAG="-fpp1 "
613	>	fi;;
614	>	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
615	>	PREPFLAG="-qsuffix=cpp=F90 "
616	>	fi;;
617	>	*darwin*)
618	>	if test "$F90" = f90 -o "$F90" = xlf90; then
619	>	PREPFLAG="-qsuffix=cpp=F90 "
620	>	fi;;
621	>	esac
622	>
623	>	if test -z "$PREPFLAG"; then
624	>	echo ""
625	>	echo "**********************************************************"
626	>	echo "* WARNING: Don't know the best PREPFLAG for this system  *"
627	>	echo "* Use  make PREPFLAG=..., or edit the top level Makefile *"
628	>	echo "* (otherwise, an empty PREPFLAG will be used)            *"
629	>	echo "**********************************************************"
630	>	echo ""
631	>	PREPFLAG=""
632		fi
633
634	<	AC_CACHE_CHECK([for PDFlib >= $1], acx_cv_pdflib,
635	<	AC_CACHE_VAL(acx_cv_pdf_library, acx_cv_pdf_library=$pdf_library)
636	<	ACX_SAVE_STATE
637	<	LIBS="$acx_cv_pdf_library $TIFF_LIB $JPEG_LIB $PNG_LIB $Z_LIB $LIBS"
638	<	AC_TRY_RUN([
639	<	#include <pdflib.h>
654	<	int main(void) {
655	<	char *vinc;
656	<	int vlibn, vincn;
657	<	vlibn = 100*PDF_get_majorversion() + PDF_get_minorversion();
658	<	vincn = 100*PDFLIB_MAJORVERSION + PDFLIB_MINORVERSION;
659	<	vinc = PDFLIB_VERSIONSTRING;
660	<	if (strcmp(vinc, "[$1]") < 0) {
661	<	exit(1);
662	<	}
663	<	if (vincn != vlibn) {
664	<	exit(2);
665	<	}
666	<	exit(0);
667	<	}
668	<	],
634	>	AC_MSG_CHECKING(to make sure F90 preprocessor flag works)
635	>	AC_LANG_SAVE()
636	>	AC_LANG([Fortran 90])
637	>	ac_save_ext=$ac_ext
638	>	ac_ext=F90
639	>	ac_save_F90FLAGS=$F90FLAGS
640
641	<	acx_cv_pdflib="yes",
642	<	acx_cv_pdflib="no",
643	<	acx_cv_pdflib="no"
644	<	)
645	<	ACX_RESTORE_STATE
646	<	)
647	<	if test "$acx_cv_pdflib" = "yes"
648	<	then
649	<	PDF_LIB="$acx_cv_pdf_library"
650	<	$2
641	>	AS_IF([test "$PREPFLAG"], [F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"])
642	>	_AC_COMPILE_IFELSE([
643	>	AC_LANG_PROGRAM([
644	>	integer :: i
645	>	i = 1
646	>	])], [prepflagworks=1], [prepflagworks=0])
647	>
648	>	F90FLAGS=$ac_save_F90FLAGS
649	>	ac_ext=$ac_save_ext
650	>	AC_LANG_RESTORE()
651	>
652	>
653	>	if test "$prepflagworks" = 1; then
654	>	AC_MSG_RESULT(yes)
655	>	AC_SUBST(PREPFLAG)
656		else
657	<	PDF_LIB=
658	<	$3
657	>	AC_MSG_RESULT(no)
658	>	AC_MSG_ERROR([Can't figure out working Fortran90 preprocessor flag])
659		fi
660	<	])dnl
660	>	fi
661	>	])
662
663	<	dnl ACX_CHECK_NETCDF
664	<	dnl --------------
688	<	AC_DEFUN(ACX_CHECK_NETCDF,
663	>
664	>	AC_DEFUN(ACX_PROG_F90_PREPDEFFLAG,
665		[
666	<	AC_ARG_WITH(netcdf_libraries,
667	<	[  --with-netcdf-libraries=OBJ  use OBJ as netCDF libraries [-lnetcdf]],
692	<	netcdf_libraries="$withval")
693	<	if test "x$netcdf_libraries" = "x"
694	<	then
695	<	netcdf_libraries=-lnetcdf
696	<	fi
666	>	AC_REQUIRE([AC_PROG_F90])
667	>	AC_REQUIRE([AC_CANONICAL_HOST])
668
669	<	AC_CACHE_CHECK([for netCDF API version >= $1], acx_cv_netcdf,
670	<	AC_CACHE_VAL(acx_cv_netcdf_libraries, acx_cv_netcdf_libraries=$netcdf_libraries)
700	<	ACX_SAVE_STATE
701	<	LIBS="$acx_cv_netcdf_libraries $LIBS"
669	>	# Try to determine native compiler flags that allow us to use F90 suffix
670	>	# for preprocessed f90 source with -D type defines
671
672	+	if test "$ac_test_PREPDEFFLAG" != "set"; then
673	+	PREPDEFFLAG=""
674	+	case "${host_cpu}-${host_os}" in
675
676	<	AC_TRY_RUN([
677	<	#include <stdio.h>
678	<	#include <netcdf.h>
679	<	int main(void) {
680	<	char *vlib;
681	<	vlib = nc_inq_libvers();
682	<	if (strcmp(vlib, "[$1]") < 0) {
683	<	exit(1);
684	<	}
685	<	exit(0);
686	<	}
715	<	],
676	>	*linux*) if test "$F90" = ifc; then
677	>	PREPDEFFLAG=" "
678	>	fi;;
679	>	*aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
680	>	PREPDEFFLAG="-WF,"
681	>	fi;;
682	>	*darwin*)
683	>	if test "$F90" = f90 -o "$F90" = xlf90; then
684	>	PREPDEFFLAG="-WF,"
685	>	fi;;
686	>	esac
687
688	<	acx_cv_netcdf="yes",
689	<	acx_cv_netcdf="no",
690	<	acx_cv_netcdf="no"
691	<	)
692	<	ACX_RESTORE_STATE
693	<	)
694	<	if test "$acx_cv_netcdf" = "yes"
695	<	then
696	<	NETCDF_LIBS="$acx_cv_netcdf_libraries"
726	<	$2
727	<	else
728	<	NETCDF_LIBS=
729	<	$3
688	>	if test -z "$PREPDEFFLAG"; then
689	>	echo ""
690	>	echo "*************************************************************"
691	>	echo "* WARNING: Don't know the best PREPDEFFLAG for this system  *"
692	>	echo "* Use  make PREPDEFFLAG=..., or edit the top level Makefile *"
693	>	echo "* (otherwise, an empty PREPDEFFLAG will be used)            *"
694	>	echo "*************************************************************"
695	>	echo ""
696	>	PREPDEFFLAG=" "
697		fi
731	–	])dnl
698
699	<	dnl ACX_CHECK_FFTW
700	<	dnl --------------
701	<	AC_DEFUN(ACX_CHECK_FFTW,
702	<	[
703	<	AC_ARG_WITH(fftw_library,
704	<	[  --with-fftw-library=OBJ      use OBJ as FFTW library [-lfftw]],
739	<	fftw_library="$withval")
740	<	if test "x$fftw_library" = "x"
741	<	then
742	<	fftw_library=-lfftw
743	<	fi
699	>	AC_MSG_CHECKING(to make sure F90 preprocessor define flag works)
700	>	AC_LANG_SAVE()
701	>	AC_LANG([Fortran 90])
702	>	ac_save_ext=$ac_ext
703	>	ac_ext=F90
704	>	ac_save_F90FLAGS=$F90FLAGS
705
706	<	AC_CACHE_CHECK([for FFTW library >= $1], acx_cv_fftw,
707	<	AC_CACHE_VAL(acx_cv_fftw_library, acx_cv_fftw_library=$fftw_library)
708	<	ACX_SAVE_STATE
709	<	LIBS="$acx_cv_fftw_library $LIBS"
710	<	AC_TRY_RUN([
711	<	#include <fftw.h>
712	<	#include <string.h>
713	<	int main(void) {
714	<	char *vlib = (char *) fftw_version;
715	<	if (strcmp(vlib, "[$1]") < 0) {
755	<	exit(1);
756	<	}
757	<	exit(0);
758	<	}
759	<	],
706	>	AS_IF([test "$PREPDEFFLAG"], [F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"])
707	>	_AC_COMPILE_IFELSE([
708	>	AC_LANG_PROGRAM([
709	>	integer :: i
710	>	#ifdef TEST
711	>	i = 1
712	>	#else
713	>	choke me
714	>	#endif
715	>	])], [prepdefflagworks=1], [prepdefflagworks=0])
716
717	<	acx_cv_fftw="yes",
718	<	acx_cv_fftw="no",
719	<	acx_cv_fftw="no"
764	<	)
717	>	F90FLAGS=$ac_save_F90FLAGS
718	>	ac_ext=$ac_save_ext
719	>	AC_LANG_RESTORE()
720
721	<	ACX_RESTORE_STATE
722	<	)
723	<	if test "$acx_cv_fftw" = "yes"
724	<	then
770	<	FFTW_LIB="$acx_cv_fftw_library"
771	<	$2
721	>
722	>	if test "$prepdefflagworks" = 1; then
723	>	AC_MSG_RESULT(yes)
724	>	AC_SUBST(PREPDEFFLAG)
725		else
726	<	FFTW_LIB=
727	<	$3
726	>	AC_MSG_RESULT(no)
727	>	AC_MSG_ERROR([Can't figure out working Fortran90 preprocessor define flag])
728		fi
729	<	])dnl
729	>	fi
730	>	])
731
732	+	AC_DEFUN([ACX_MPI], [
733	+	AC_PREREQ(2.50) dnl for AC_LANG_CASE
734
735	<	dnl ACX_CHECK_XMHTML
736	<	dnl --------------
737	<	AC_DEFUN(ACX_CHECK_XMHTML,
738	<	[
739	<	AC_ARG_WITH(xmhtml_library,
740	<	[  --with-xmhtml-library=OBJ    use OBJ as XmHTML library [-lXmHTML]],
741	<	xmhtml_library="$withval")
742	<	if test "x$xmhtml_library" = "x"
743	<	then
744	<	xmhtml_library=-lXmHTML
745	<	fi
735	>	AC_LANG_CASE([C], [
736	>	AC_REQUIRE([AC_PROG_CC])
737	>	AC_ARG_VAR(MPICC,[MPI C compiler command])
738	>	AC_CHECK_PROGS(MPICC, mpicc hcc mpcc mpcc_r mpxlc, $CC)
739	>	acx_mpi_save_CC="$CC"
740	>	CC="$MPICC"
741	>	AC_SUBST(MPICC)
742	>	],
743	>	[C++], [
744	>	AC_REQUIRE([AC_PROG_CXX])
745	>	AC_ARG_VAR(MPICXX,[MPI C++ compiler command])
746	>	AC_CHECK_PROGS(MPICXX, mpiCC mpCC, $CXX)
747	>	acx_mpi_save_CXX="$CXX"
748	>	CXX="$MPICXX"
749	>	AC_SUBST(MPICXX)
750	>	],
751	>	[Fortran 90], [
752	>	AC_REQUIRE([AC_PROG_F90])
753	>	AC_ARG_VAR(MPIF77,[MPI Fortran compiler command])
754	>	AC_CHECK_PROGS(MPIF90, mpif90 hf90 mpxlf90 mpf90 mpxlf95 mpxlf_r, $F90)
755	>	acx_mpi_save_F90="$F90"
756	>	F90="$MPIF90"
757	>	AC_SUBST(MPIF90)
758	>	])
759
760	<	AC_CACHE_CHECK([for XmHTML widget >= $1], acx_cv_xmhtml,
761	<	AC_CACHE_VAL(acx_cv_xmhtml_library, acx_cv_xmhtml_library=$xmhtml_library)
762	<	ACX_SAVE_STATE
763	<	LIBS="$acx_cv_xmhtml_library $JPEG_LIB $PNG_LIB $Z_LIB $LIBS"
764	<	AC_TRY_RUN([
765	<	#include <XmHTML/XmHTML.h>
766	<	int main(void) {
767	<	int vlib, vinc;
768	<	vlib = XmHTMLGetVersion();
769	<	vinc = XmHTMLVersion;
770	<	if (vinc < [$1]) {
771	<	exit(1);
772	<	}
804	<	if (vinc != vlib) {
805	<	exit(2);
806	<	}
807	<	exit(0);
808	<	}
809	<	],
760	>	if test x = x"$MPILIBS"; then
761	>	AC_LANG_CASE([C], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
762	>	[C++], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
763	>	[Fortran 90], [AC_MSG_CHECKING([for MPI_Init])
764	>	AC_TRY_LINK([],[      call MPI_Init], [MPILIBS=" "
765	>	AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no)])])
766	>	fi
767	>	if test x = x"$MPILIBS"; then
768	>	AC_CHECK_LIB(mpi, MPI_Init, [MPILIBS="-lmpi"])
769	>	fi
770	>	if test x = x"$MPILIBS"; then
771	>	AC_CHECK_LIB(mpich, MPI_Init, [MPILIBS="-lmpich"])
772	>	fi
773
774	<	acx_cv_xmhtml="yes",
775	<	acx_cv_xmhtml="no",
776	<	acx_cv_xmhtml="no"
777	<	)
778	<	ACX_RESTORE_STATE
779	<	)
780	<	if test "$acx_cv_xmhtml" = "yes"
781	<	then
782	<	XMHTML_LIB="$acx_cv_xmhtml_library"
783	<	$2
784	<	else
785	<	XMHTML_LIB=
823	<	$3
824	<	fi
825	<	])dnl
774	>	dnl We have to use AC_TRY_COMPILE and not AC_CHECK_HEADER because the
775	>	dnl latter uses $CPP, not $CC (which may be mpicc).
776	>	AC_LANG_CASE([C], [if test x != x"$MPILIBS"; then
777	>	AC_MSG_CHECKING([for mpi.h])
778	>	AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
779	>	AC_MSG_RESULT(no)])
780	>	fi],
781	>	[C++], [if test x != x"$MPILIBS"; then
782	>	AC_MSG_CHECKING([for mpi.h])
783	>	AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
784	>	AC_MSG_RESULT(no)])
785	>	fi])
786
787	+	AC_LANG_CASE([C], [CC="$acx_mpi_save_CC"],
788	+	[C++], [CXX="$acx_mpi_save_CXX"],
789	+	[Fortran 90], [F90="$acx_mpi_save_F90"])
790	+
791	+	AC_SUBST(MPILIBS)
792	+
793	+	# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
794	+	if test x = x"$MPILIBS"; then
795	+	$2
796	+	:
797	+	else
798	+	ifelse([$1],,[AC_DEFINE(HAVE_MPI,1,[Define if you have the MPI library.])],[$1])
799	+	:
800	+	fi
801	+	])dnl ACX_MPI
802	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines